Function main

src/adapters/scripts/evolver-session-end.js:219–319

()

}

function main() {
  let inputData = '';
  let handled = false;
  let watchdog = null;
  const finish = (payload) => {
    if (handled) return;
    handled = true;
    if (watchdog) clearTimeout(watchdog);
    process.stdout.write(JSON.stringify(payload || {}));
    process.exit(0);
  };
  process.stdin.setEncoding('utf8');
  process.stdin.on('data', chunk => { inputData += chunk; });
  process.stdin.on('end', () => {
    if (handled) return;
    // recordToHub is async (uses the shared Hub fetch transport); wrap the rest of the
    // handler in an immediately-invoked async function so we can await it
    // while still honouring the watchdog timeout and the `handled` guard.
    (async () => {
      try {
        const diffInfo = getGitDiffStats();

        if (!diffInfo.hasChanges) {
          // No git diff means no signal source — session-end derives the
          // outcome (status/score/signals/summary) entirely from the diff, so
          // there is nothing meaningful to record. This is expected in a
          // non-git workspace or a repo with no changes this session. Rather
          // than fabricate an empty outcome (which would pollute the memory
          // graph), record nothing — but leave a log breadcrumb so the user
          // can tell "evolver ran but had nothing to record" apart from
          // "evolver never fired".
          const reason = diffInfo.isRepo
            ? 'no changes detected this session'
            : 'not a git workspace';
          appendEvolutionLog(`[Evolution] Session end: nothing recorded (${reason}).`);
          finish({});
          return;
        }

        const signals = detectSignals(diffInfo.diffSnippet);
        if (signals.length === 0) signals.push('stable_success_plateau');

        const hasErrors = signals.includes('log_error') || signals.includes('test_failure');
        const status = hasErrors ? 'failed' : 'success';
        const score = hasErrors ? 0.3 : 0.8;

        const outcome = {
          geneId: 'ad_hoc',
          signals,
          status,
          score,
          summary: `Session end: ${diffInfo.summary}. Signals: [${signals.join(', ')}]`,
        };

        const evolverRoot = findEvolverRoot();
        const graphPath = findMemoryGraph(evolverRoot);

        // Local first: recordToHub is async with an 8s socket timeout, but