elanous 0.2.36 → 0.2.38

package/src/domains/surface-events.ts

@@ -172,10 +172,58 @@ export function recordInboundTurn(
   finally { if (ownDb) db.close(); }
 }
 
+/** 발화 «원천» — 사람이 말한 것과 시험 fixture·외부 CLI agent 가 던진 것을 계측상 구분한다.
+ *  ⛔ 원천 표기가 없는 0건을 «사람 표본 0» 으로 오인하면 안 되고, 반대로 시험 fixture 가
+ *  사람과 같은 서피스(cli·telegram)에 기록됐다는 이유로 사람 표본으로 세어도 안 된다. */
+export type SurfaceUtteranceOrigin = 'human' | 'test-fixture' | 'external-cli-agent' | 'elanous-self' | 'unknown';
+
+const TEST_FIXTURE_ORIGIN = /^(?:test-fixture|test_fixture|fixture|test|test-runner|bun-test)$/i;
+const HUMAN_ORIGIN = /^(?:human|user|tui|pwa|telegram|discord|cli)$/i;
+const EXTERNAL_CLI_AGENT_ORIGIN = /^(?:claude-code|codex|gemini|agent|external|external-cli-agent|external:[\w-]+|ext:[\w-]+)$/i;
+const HUMAN_PROSE_SURFACE = /^(?:cli|tui|pwa|telegram|discord|ipad|watch)$/i;
+
+function refsOf(raw: string | null): Record<string, unknown> {
+  if (!raw) return {};
+  try {
+    const value: unknown = JSON.parse(raw);
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {};
+  } catch { return {}; }
+}
+
+/** 원천 분류기 — provenance(recordInboundTurn opts.origin → refs.origin/tags.origin:<origin>)
+ *  표기를 먼저 읽고, 표기가 없을 때만 서피스로 추정한다. 시험 fixture 는 서피스 추정 «전에» 가른다. */
+export function classifySurfaceUtteranceOrigin(
+  row: Pick<SurfaceEventRow, 'direction' | 'surface' | 'kind' | 'refs' | 'tags'>,
+): SurfaceUtteranceOrigin {
+  if (row.direction !== 'inbound') return 'unknown';
+  const refs = refsOf(row.refs);
+  const explicit = typeof refs.origin === 'string' ? refs.origin : undefined;
+  const utteranceOrigin = typeof refs.utteranceOrigin === 'string' ? refs.utteranceOrigin : undefined;
+  const fixtureTagged = (row.tags ?? '').split(/\s+/).filter(Boolean)
+    .some((tag) => TEST_FIXTURE_ORIGIN.test(tag.split(':').pop() ?? ''));
+  if ((utteranceOrigin && TEST_FIXTURE_ORIGIN.test(utteranceOrigin)) || (explicit && TEST_FIXTURE_ORIGIN.test(explicit)) || fixtureTagged) {
+    return 'test-fixture';
+  }
+  if (utteranceOrigin === 'human') return 'human';
+  if (utteranceOrigin === 'agent') return 'external-cli-agent';
+  if (explicit) {
+    if (HUMAN_ORIGIN.test(explicit)) return 'human';
+    if (EXTERNAL_CLI_AGENT_ORIGIN.test(explicit)) return 'external-cli-agent';
+  }
+  // recordInboundTurn marks its recorder as elanous-self; on chat Q&A the speaker is the human.
+  if (row.kind === 'qna' && /^(?:telegram|discord)$/i.test(row.surface)) return 'human';
+  if (explicit === 'elanous-self') return 'elanous-self';
+  if (/^ext:/i.test(row.surface)) return 'external-cli-agent';
+  if (HUMAN_PROSE_SURFACE.test(row.surface)) return 'human';
+  return 'unknown';
+}
+
 export interface SurfaceUtteranceQuery {
   from: string;
   to: string;
   surface?: string;
+  /** 원천 필터(선택) — 미지정이면 종전과 같이 창 안의 모든 발화를 읽는다(보존 계약). */
+  origin?: SurfaceUtteranceOrigin | readonly SurfaceUtteranceOrigin[];
 }
 
 /** Read every event in a half-open UTC interval without touching recall state. */
@@ -183,9 +231,40 @@ export function querySurfaceUtterances(db: Database, opts: SurfaceUtteranceQuery
   const where = ["julianday(e.ts) >= julianday(?)", "julianday(e.ts) < julianday(?)", "e.direction = 'inbound'", "e.kind IN ('utterance', 'qna')"];
   const params: string[] = [opts.from, opts.to];
   if (opts.surface) { where.push('e.surface = ?'); params.push(opts.surface); }
-  return db.prepare(
+  const rows = db.prepare(
     `SELECT e.* FROM events e WHERE ${where.join(' AND ')} ORDER BY julianday(e.ts) ASC, e.id ASC`,
   ).all(...params) as SurfaceEventRow[];
+  if (opts.origin === undefined) return rows;
+  const wanted = new Set<SurfaceUtteranceOrigin>(typeof opts.origin === 'string' ? [opts.origin] : opts.origin);
+  return rows.filter((row) => wanted.has(classifySurfaceUtteranceOrigin(row)));
+}
+
+/** 원천별 발화 수 — «사람 원천 0» 을 사람 표본으로 읽지 않게 하는 계측 입구(read-only·recall 무접촉). */
+export interface SurfaceUtteranceOriginCounts {
+  human: number;
+  testFixture: number;
+  externalCliAgent: number;
+  elanousSelf: number;
+  unknown: number;
+  total: number;
+}
+
+export function countSurfaceUtterancesByOrigin(
+  db: Database,
+  opts: Omit<SurfaceUtteranceQuery, 'origin'>,
+): SurfaceUtteranceOriginCounts {
+  const counts: SurfaceUtteranceOriginCounts = { human: 0, testFixture: 0, externalCliAgent: 0, elanousSelf: 0, unknown: 0, total: 0 };
+  for (const row of querySurfaceUtterances(db, opts)) {
+    counts.total += 1;
+    switch (classifySurfaceUtteranceOrigin(row)) {
+      case 'human': counts.human += 1; break;
+      case 'test-fixture': counts.testFixture += 1; break;
+      case 'external-cli-agent': counts.externalCliAgent += 1; break;
+      case 'elanous-self': counts.elanousSelf += 1; break;
+      default: counts.unknown += 1;
+    }
+  }
+  return counts;
 }
 
 export interface QueryEventsOpts {

package/src/exec-requests/planner.ts

@@ -10,6 +10,41 @@ import { debug } from '../debug/log.js';
 import { peerEditRunGate } from '../nexus/api/graph-peer-edit.js';
 import { OUTPUT_KINDS, pickDefaultOutput, type OutputKind } from './default-outputs.js';
 
+/**
+ * 코드포인트 순서 비교 — `localeCompare` 는 «실행 로케일의 ICU 콜레이션» 을 쓰므로 같은 문자열 쌍의 대소가
+ * 플랫폼/로케일마다 뒤집힌다(실측: '🎉party' vs '2026-10-23', 'alpha' vs 'Zebra' 는 콜레이션과 코드포인트가 반대).
+ * 순서가 실행 환경에 따라 달라지면 «가장 새 것» 선택이 재현 불가능해진다 — 그래서 코드포인트로 고정한다.
+ */
+export function compareCodePoints(a: string, b: string): number {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+/** 숫자 구간의 선행 0 을 지운다(01 == 1). */
+const stripLeadingZeros = (digits: string): string => digits.replace(/^0+(?=\d)/, '');
+
+/**
+ * 버전 문자열 비교 — 숫자 구간만 «수치» 로, 나머지는 «코드포인트» 로 비교한다.
+ * `localeCompare(..., { numeric: true })` 의 수치 규칙은 그대로 두고 콜레이션 의존만 걷어낸 등가물이다.
+ */
+export function compareVersionish(a: string, b: string): number {
+  const chunks = (value: string): string[] => value.match(/\d+|\D+/g) ?? [];
+  const left = chunks(a);
+  const right = chunks(b);
+  for (let index = 0; index < Math.min(left.length, right.length); index += 1) {
+    const [x, y] = [left[index]!, right[index]!];
+    if (/^\d/.test(x) && /^\d/.test(y)) {
+      const [dx, dy] = [stripLeadingZeros(x), stripLeadingZeros(y)];
+      if (dx.length !== dy.length) return dx.length < dy.length ? -1 : 1;
+      const digits = compareCodePoints(dx, dy);
+      if (digits !== 0) return digits;
+      continue;
+    }
+    const text = compareCodePoints(x, y);
+    if (text !== 0) return text;
+  }
+  return left.length === right.length ? 0 : left.length < right.length ? -1 : 1;
+}
+
 export interface InstalledGraph {
   id: string;
   title: string;
@@ -43,7 +78,7 @@ export function installedPluginGraphs(pluginsRoot = join(elanousStateRoot(), 'pl
   };
   for (const market of dirs(pluginsRoot)) {
     for (const name of dirs(join(pluginsRoot, market))) {
-      const versions = dirs(join(pluginsRoot, market, name)).sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
+      const versions = dirs(join(pluginsRoot, market, name)).sort((a, b) => compareVersionish(b, a));
       const version = versions[0];
       if (!version) continue;
       const root = join(pluginsRoot, market, name, version);
@@ -146,7 +181,7 @@ export function latestFieldFolder(configRoot = getElanousConfigDir()): string |
         const photos = readdirSync(path, { withFileTypes: true }).filter(file => file.isFile() && /\.(?:png|jpe?g|webp|heic)$/i.test(file.name));
         for (const photo of photos) {
           const time = statSync(join(path, photo.name)).mtimeMs;
-          if (!latest || time > latest.time || (time === latest.time && path.localeCompare(latest.path) > 0)) latest = { path, time };
+          if (!latest || time > latest.time || (time === latest.time && compareCodePoints(path, latest.path) > 0)) latest = { path, time };
         }
       } catch { /* Unreadable event does not supply photos. */ }
     }

package/src/execution-loop/launch-gate.ts

@@ -88,8 +88,6 @@ export function activeRunsForGoal(goalId: string, deps: ActiveRunsForGoalDeps =
   }
 }
 
-const LAUNCH_BUDGET_PROVIDER: Readonly<Record<string, string>> = { 'codex-rotate': CODEX_PROVIDER, grok: GROK_PROVIDER };
-
 /**
  * L6 발사 관문의 예산 입력 보정 — 발사 우주의 config 에 체인이 없으면(작업 트리 = 시험 우주) 막지 않고
  * 코드 기본 체인으로 판단한다. `--child-llm-provider` 를 명시했으면 그것이 체인이다(예산 판정 밖 provider 는 통과).
@@ -98,6 +96,9 @@ export function harnessLaunchBudgetDecision(
   inputs: BudgetInputs,
   opts: { readonly childLlmProvider?: string; readonly childLlmModel?: string } = {},
 ): { readonly decision: BudgetDecision; readonly warning?: string; readonly unmeasuredProvider?: string } {
+  // Resolve imported provider constants only when the launch gate is called.
+  // This module participates in the CLI/tool catalog import cycle.
+  const launchBudgetProvider: Readonly<Record<string, string>> = { 'codex-rotate': CODEX_PROVIDER, grok: GROK_PROVIDER };
   const explicit = opts.childLlmProvider?.trim();
   const judged = (selected: BudgetInputs) => {
     const { decision, unmeasuredProvider } = decideLaunchBudget(selected);
@@ -114,7 +115,7 @@ export function harnessLaunchBudgetDecision(
     return judged({ ...inputs, preference: { ...inputs.preference, chain } });
   }
   if (inputs.preference.chain.length > 0) return judged(inputs);
-  const chain = DEFAULT_FALLBACK_CHAIN.map((step) => ({ provider: LAUNCH_BUDGET_PROVIDER[step] ?? step }));
+  const chain = DEFAULT_FALLBACK_CHAIN.map((step) => ({ provider: launchBudgetProvider[step] ?? step }));
   const result = judged({ ...inputs, preference: { ...inputs.preference, chain } });
   return {
     ...result,

package/src/git-fs/cli-stderr.ts

@@ -0,0 +1,45 @@
+import { debug } from '../debug/log.js';
+
+export type CliStderrRecord = {
+  readonly source: 'git' | 'gh';
+  readonly exitCode: number;
+  readonly raw: Buffer;
+};
+
+export type CliStderrSink = (record: CliStderrRecord) => void;
+
+let activeSink: CliStderrSink | null = null;
+
+export function hasCliStderrSink(): boolean {
+  return activeSink !== null;
+}
+
+/** Install a surface-specific sink; without one, CLI stderr keeps its process contract. */
+export function setCliStderrSink(sink: CliStderrSink | null): () => void {
+  const previous = activeSink;
+  activeSink = sink;
+  return () => {
+    if (activeSink === sink) activeSink = previous;
+  };
+}
+
+/** Preserve raw bytes for the caller and keep ordinary CLI invocations on process.stderr. */
+export function writeCliStderr(record: CliStderrRecord): void {
+  const sink = activeSink;
+  if (!sink) {
+    process.stderr.write(record.raw);
+    return;
+  }
+  // A failed screen redraw must not fall through to the physical TTY and overwrite its prompt.
+  try { sink(record); } catch (error) {
+    // Keep the prompt isolated, but leave a forensic breadcrumb for a failed presentation path.
+    try {
+      debug.log('tui.cli-stderr', 'sink-failed', {
+        source: record.source,
+        exitCode: record.exitCode,
+        byteLength: record.raw.length,
+        errorName: error instanceof Error ? error.name : typeof error,
+      });
+    } catch { /* never fall through to the physical TTY */ }
+  }
+}

package/src/git-fs/gh-cli.ts

@@ -1,5 +1,6 @@
 import { spawn, spawnSync } from 'node:child_process';
 import { debug } from '../debug/log.js';
+import { writeCliStderr } from './cli-stderr.js';
 
 const LF = 0x0a;
 const MAX_GH_RETRY_ATTEMPTS = 3;
@@ -195,14 +196,16 @@ export function runGhCli(args: string[]): void {
   const auxiliaryFailure = exitCode === 0 ? undefined : auxiliaryFailureSignature(stderr);
 
   if (stdout.length) process.stdout.write(stdout);
-  if (stderr.length) process.stderr.write(stderr);
+  const stderrChunks: Buffer[] = [];
+  if (stderr.length) stderrChunks.push(stderr);
   // ⛔⭐⭐⭐⭐⭐ **상태 줄은 `stderr` 로** — `git-cli.ts` 의 같은 주석이 canonical.
   //   `--json` 산출 뒤에 비-JSON 한 줄이 붙으면 ***모든 JSON 소비자가 죽는다***(`jq: parse error` 실측).
   //   stdout 은 ***원 바이트 그대로만*** 나간다.
   const endsWithoutLf = (buffer: Buffer): boolean => buffer.length > 0 && buffer[buffer.length - 1] !== LF;
-  if (endsWithoutLf(stderr)) process.stderr.write('\n');
+  if (endsWithoutLf(stderr)) stderrChunks.push(Buffer.from('\n'));
 
-  process.stderr.write(`${statusLine(label, result, auxiliaryFailure)}\n`);
+  stderrChunks.push(Buffer.from(`${statusLine(label, result, auxiliaryFailure)}\n`));
+  writeCliStderr({ source: 'gh', exitCode, raw: Buffer.concat(stderrChunks) });
   process.exitCode = exitCode;
   if (auxiliaryFailure) {
     debug.log('gh.cli', 'partial-outcome', {

package/src/git-fs/git-cli.ts

@@ -2,6 +2,7 @@ import { spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { debug } from '../debug/log.js';
+import { hasCliStderrSink, writeCliStderr } from './cli-stderr.js';
 import { runGitWithRetry, type GitRunner } from './retry.js';
 
 const LF = 0x0a;
@@ -134,7 +135,11 @@ export function runGitCli(args: string[]): void {
   // ⛔ 실행 «전» 스냅샷 — 이 명령이 마커를 남길 수 있는 종류일 때만 잰다(무관한 명령엔 비용 0).
   const probesForRun = SUBCOMMAND_PROBES[subcommand];
   const probesBefore = probesForRun ? probeSnapshot(args, probesForRun, process.env) : undefined;
-  if (HELP_ARGUMENTS.has(args[0] ?? '')) process.stderr.write(HELP_GUIDANCE);
+  const stderrChunks: Buffer[] = [];
+  if (HELP_ARGUMENTS.has(args[0] ?? '')) {
+    if (hasCliStderrSink()) stderrChunks.push(Buffer.from(HELP_GUIDANCE));
+    else process.stderr.write(HELP_GUIDANCE);
+  }
   let attempts = 0;
   let rawStdout: Buffer = Buffer.alloc(0);
   let rawStderr: Buffer = Buffer.alloc(0);
@@ -154,7 +159,7 @@ export function runGitCli(args: string[]): void {
   const result = runGitWithRetry(args, runner);
 
   if (rawStdout.length) process.stdout.write(rawStdout);
-  if (rawStderr.length) process.stderr.write(rawStderr);
+  if (rawStderr.length) stderrChunks.push(rawStderr);
 
   // ⛔⭐⭐⭐⭐⭐ **상태 줄은 `stderr` 로 나간다** — 2026-08-09 정정(라이브에서 «둘이» 밟았다).
   //   초판은 stdout 에 썼다. 그러면 ***산출을 값으로 쓰는 모든 소비자가 깨진다***:
@@ -166,7 +171,7 @@ export function runGitCli(args: string[]): void {
   //     `git`·`gh` 자신의 오류도 똑같이 사라지므로 일관된다.
   //   ⇒ 📌 stdout 은 이제 ***원 바이트 그대로만*** 나간다(separator 도 안 붙인다).
   const endsWithoutLf = (buf: Buffer): boolean => buf.length > 0 && buf[buf.length - 1] !== LF;
-  if (endsWithoutLf(rawStderr)) process.stderr.write('\n');
+  if (endsWithoutLf(rawStderr)) stderrChunks.push(Buffer.from('\n'));
 
   const exitCode = result.status ?? 1;
   const leftKind = exitCode !== 0 && probesForRun
@@ -176,11 +181,12 @@ export function runGitCli(args: string[]): void {
   const leftReason = leftKind
     ? `${leftKind}-${hasUnmergedPaths(args, process.env) ? 'conflict' : 'in-progress'}`
     : undefined;
-  process.stderr.write(
+  stderrChunks.push(Buffer.from(
     `[git] ${subcommand} ${exitCode === 0 ? 'ok' : 'FAILED'} rc=${exitCode}`
     + (leftReason ? ` worktree-changed=yes reason=${leftReason}` : '')
     + '\n',
-  );
+  ));
+  writeCliStderr({ source: 'git', exitCode, raw: Buffer.concat(stderrChunks) });
   process.exitCode = exitCode;
   debug.log('git.cli', 'completed', {
     subcommand,

package/src/git-fs/watcher.ts

@@ -1,6 +1,6 @@
 // ── git-fs watcher ──
 //
-// fs.watchFile() on the small set of files whose change indicates
+// fs.watchFile() polls the small set of entries whose replacement indicates
 // the branch or the current commit moved:
 //
 //   <gitDir>/HEAD                    branch switch / detach
@@ -15,7 +15,7 @@
 // watching the whole working tree. The dirty probe is throttled
 // separately.
 
-import { watch, type FSWatcher } from 'node:fs';
+import { unwatchFile, watchFile, type Stats } from 'node:fs';
 import { join } from 'node:path';
 import type { GitHeadInfo } from './types.js';
 import type { LocatedGit } from './locate.js';
@@ -24,9 +24,9 @@ type Listener = () => void;
 
 export class GitFileWatcher {
   private readonly listeners = new Set<Listener>();
-  private headWatcher: FSWatcher | null = null;
-  private refWatcher: FSWatcher | null = null;
-  private packedRefsWatcher: FSWatcher | null = null;
+  private headWatcher: { stop: () => void } | null = null;
+  private refWatcher: { stop: () => void } | null = null;
+  private packedRefsWatcher: { stop: () => void } | null = null;
   private currentBranch: string | null = null;
   private disposed = false;
 
@@ -54,7 +54,7 @@ export class GitFileWatcher {
     const next = head?.branch ?? null;
     if (next === this.currentBranch) return;
     this.currentBranch = next;
-    if (this.refWatcher) { this.refWatcher.close(); this.refWatcher = null; }
+    if (this.refWatcher) { this.refWatcher.stop(); this.refWatcher = null; }
     this.installRefWatcher();
   }
 
@@ -62,9 +62,9 @@ export class GitFileWatcher {
     if (this.disposed) return;
     this.disposed = true;
     this.listeners.clear();
-    if (this.headWatcher) { try { this.headWatcher.close(); } catch {} }
-    if (this.refWatcher) { try { this.refWatcher.close(); } catch {} }
-    if (this.packedRefsWatcher) { try { this.packedRefsWatcher.close(); } catch {} }
+    if (this.headWatcher) { try { this.headWatcher.stop(); } catch {} }
+    if (this.refWatcher) { try { this.refWatcher.stop(); } catch {} }
+    if (this.packedRefsWatcher) { try { this.packedRefsWatcher.stop(); } catch {} }
     this.headWatcher = null;
     this.refWatcher = null;
     this.packedRefsWatcher = null;
@@ -77,10 +77,22 @@ export class GitFileWatcher {
     }
   }
 
+  private watchPath(path: string): { stop: () => void } {
+    const onChange = (current: Stats, previous: Stats) => {
+      if (current.mtimeMs !== previous.mtimeMs || current.ino !== previous.ino || current.size !== previous.size) {
+        this.fire();
+      }
+    };
+    watchFile(path, { interval: 250, persistent: false }, onChange);
+    return { stop: () => unwatchFile(path, onChange) };
+  }
+
   private installHeadWatcher(): void {
-    const path = join(this.located.gitDir, 'HEAD');
     try {
-      this.headWatcher = watch(path, { persistent: false }, () => this.fire());
+      // Git replaces HEAD atomically via HEAD.lock + rename. fs.watch can stay
+      // attached to the old inode or miss the event on loaded hosts; stat
+      // polling follows the path and observes the replacement.
+      this.headWatcher = this.watchPath(join(this.located.gitDir, 'HEAD'));
     } catch {
       // HEAD may not exist during `git init` transient state; swallow.
     }
@@ -89,19 +101,12 @@ export class GitFileWatcher {
   private installRefWatcher(): void {
     if (!this.currentBranch) return;
     const path = join(this.located.commonGitDir, 'refs', 'heads', ...this.currentBranch.split('/'));
-    try {
-      this.refWatcher = watch(path, { persistent: false }, () => this.fire());
-    } catch {
-      // Loose ref may be packed — rely on packed-refs watcher.
-    }
+    // Loose refs are atomically replaced on commit. Polling the path survives
+    // replacement and also detects a ref that is created after subscription.
+    this.refWatcher = this.watchPath(path);
   }
 
   private installPackedRefsWatcher(): void {
-    const path = join(this.located.commonGitDir, 'packed-refs');
-    try {
-      this.packedRefsWatcher = watch(path, { persistent: false }, () => this.fire());
-    } catch {
-      // No packed-refs yet — not an error.
-    }
+    this.packedRefsWatcher = this.watchPath(join(this.located.commonGitDir, 'packed-refs'));
   }
 }

package/src/git-fs/worktree.ts

@@ -61,13 +61,18 @@ function worktreeAddTimeoutForTrackedFileCount(trackedFileCount: number | null):
   return { ms: Math.min(WORKTREE_ADD_TIMEOUT_MAX_MS, Math.max(WORKTREE_ADD_TIMEOUT_MS, scaledMs)), trackedFileCount, source: 'tracked-files' };
 }
 
+export function worktreeAddTimeoutSec(seconds: number | undefined): number | undefined {
+  return typeof seconds === 'number' && Number.isSafeInteger(seconds) && seconds > 0 && seconds <= 2_147_483
+    ? seconds : undefined;
+}
+
 export function worktreeAddTimeoutForRepo(
   repoRoot: string,
   countTrackedFilesForRepo: (repoRoot: string, ref?: string) => number | null = countTrackedFiles,
   trackedFileRef?: string,
 ): WorktreeAddTimeout {
-  const seconds = getUserConfig().harness?.worktreeAddTimeoutSec;
-  if (typeof seconds === 'number' && Number.isSafeInteger(seconds) && seconds > 0 && seconds <= 2_147_483) {
+  const seconds = worktreeAddTimeoutSec(getUserConfig().harness?.worktreeAddTimeoutSec);
+  if (seconds !== undefined) {
     return { ms: seconds * 1000, trackedFileCount: null, source: 'config' };
   }
   return worktreeAddTimeoutForTrackedFileCount(countTrackedFilesForRepo(repoRoot, trackedFileRef));
@@ -347,7 +352,18 @@ function bakedDependenciesMatch(repoTree: string, bakedTree: string): boolean {
   } catch { return false; }
 }
 
-function prepareWorktreeDependencies(repoRoot: string, worktreePath: string, opts: CreateWorktreeOpts, deps: WorktreeAddDeps): void {
+/** Pod source may omit node_modules while the image carries matching baked dependencies. */
+export function worktreeDependenciesAvailable(repoRoot: string, fallbackRoot = GATE_DEPS_DIR): boolean {
+  for (const tree of GATE_DEPS_TREES) {
+    const repoTree = join(repoRoot, tree);
+    if (!existsSync(join(repoTree, 'package.json')) || !existsSync(join(repoTree, 'bun.lock'))) continue;
+    if (existsSync(join(repoTree, 'node_modules'))) continue;
+    if (!bakedDependenciesMatch(repoTree, join(fallbackRoot, tree))) return false;
+  }
+  return true;
+}
+
+export function prepareWorktreeDependencies(repoRoot: string, worktreePath: string, opts: Pick<CreateWorktreeOpts, 'dependencyFallbackRoot' | 'dependencyInstallTimeoutMs'>, deps: WorktreeAddDeps): void {
   const fallbackRoot = opts.dependencyFallbackRoot?.trim() || GATE_DEPS_DIR;
   const timeoutMs = opts.dependencyInstallTimeoutMs ?? WORKTREE_DEPENDENCY_INSTALL_TIMEOUT_MS;
   if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0) throw new Error('dependencyInstallTimeoutMs must be a positive integer');

package/src/graph-runner/graph-cli.ts

@@ -28,6 +28,28 @@ function findGraphFile(graphId: string): string | undefined {
 
 export function registerGraphCommands(program: Command, runsDeps: { root?: string; processStartMs?: (pid: number) => number | null } = {}): void {
   const graph = program.command('graph').description('Run a declared command graph or inspect its latest run');
+  graph.command('adapt-report')
+    .description('Measure recorded graph path diversity, unit calls, adaptations and landings for one goal')
+    .requiredOption('--goal <id>', 'Goal ID to measure')
+    .option('--json', 'Print measurement as JSON')
+    .action(async (opts: { goal: string; json?: boolean }) => {
+      try {
+        const { queryGraphAdaptReport } = await import('../self-implement/run-ledger.js');
+        const report = queryGraphAdaptReport(opts.goal);
+        if (opts.json) await writeStdoutJson(JSON.stringify(report) + '\n');
+        else if (report.runCount === 0) console.log(`graph adapt-report: ${opts.goal} · 표본 0 · 제외 ${report.excludedCount} ${JSON.stringify(report.exclusionReasons)}`);
+        else {
+          const landing = (group: typeof report.adapted) => group.denominator
+            ? `${group.landed}/${group.denominator} (${(group.rate! * 100).toFixed(1)}%)` : '표본 0';
+          console.log(`graph adapt-report: ${opts.goal} · 경로 ${report.uniquePathSignatures} · 유닛 호출 ${report.unitCallCount} · 적응 ${report.adaptationCount}`);
+          console.log(`적응 착지율 ${landing(report.adapted)} · 비적응 착지율 ${landing(report.nonAdapted)}`);
+          console.log(`제외 ${report.excludedCount} ${JSON.stringify(report.exclusionReasons)}`);
+        }
+      } catch (error) {
+        console.error(`graph adapt-report: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+      }
+    });
   graph.command('wizard-run <request>')
     .description('Run one request through the smart wizard graph and stop at its approval gate')
     .option('--json', 'Print run identity and transitions as JSON')
@@ -405,12 +427,14 @@ export function registerGraphCommands(program: Command, runsDeps: { root?: strin
         const state = matches[0]!;
         const detail = { ...row(state), nodes: state.nodes.map((node) => {
           const summary = lastJsonObject(node.output)?.summary;
-          return { nodeId: node.nodeId, ok: node.ok, summary: typeof summary === 'string' ? summary.slice(0, 300) : null };
+          return { nodeId: node.nodeId, ok: node.ok, exit: node.exit,
+            ...(node.reason === undefined ? {} : { reason: node.reason }),
+            summary: typeof summary === 'string' ? summary.slice(0, 300) : null };
         }), pending: state.pending ?? null, resume: state.resume ?? null };
         if (opts.json) await writeStdoutJson(JSON.stringify(detail) + '\n');
         else {
           console.log(`${detail.runId} · ${detail.graphId} · ${detail.status} · alive=${detail.alive}`);
-          for (const node of detail.nodes) console.log(`  ${node.nodeId} · ok=${node.ok} · ${node.summary ?? '-'}`);
+          for (const node of detail.nodes) console.log(`  ${node.nodeId} · ok=${node.ok} · exit=${node.exit ?? '-'} · ${node.reason ?? node.summary ?? '-'}`);
           console.log(`pending: ${JSON.stringify(detail.pending)}`);
           console.log(`resume: ${JSON.stringify(detail.resume)}`);
         }

package/src/graph-runner/graph-grow.ts

@@ -3,13 +3,10 @@ import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { createGraphVariant } from '../self-implement/graph-variant.js';
 import type { GraphEdgeSpec, GraphNodeSpec, GraphTemplateSpec } from '../self-implement/graph-yaml.js';
+import type { ResearchEdgeDecisionRegistry, ResearchEdgeProposal, ResolvedResearchEdgeDecision } from '../research/edge-decision.js';
 import { createLLMGrowthProposer } from './graph-grow-llm.js';
 
-export interface GrowthProposal {
-  node: GraphNodeSpec;
-  returnTo?: string;
-  reason: string;
-}
+export type GrowthProposal = ResearchEdgeProposal;
 
 export type GrowthProposer = (input: { graph: GraphTemplateSpec; nodeId: string; outcome: string; runId: string; output?: unknown }) => GrowthProposal | undefined | Promise<GrowthProposal | undefined>;
 export type GrowthRecipeEffect = 'read-only' | 'external-effect' | 'unknown';
@@ -68,10 +65,41 @@ export function growthDecision(input: Parameters<GrowthProposer>[0], proposal: G
 
 export async function proposeGrowth(input: Parameters<GrowthProposer>[0],
   proposer: GrowthProposer = createLLMGrowthProposer(), classifyRecipe?: (node: GraphNodeSpec) => GrowthRecipeEffect | GrowthRecipeClassification,
-  decisionDeps: GrowthDecisionDeps = {}): Promise<{ ok: true; graph: GraphTemplateSpec; growth: GraphGrowth } | { ok: false; reason: string; park?: boolean; growth?: GraphGrowth; decisionId?: string; decisionRef?: string; command?: GrowthCommand; approval?: string }> {
+  decisionDeps: GrowthDecisionDeps = {}, edgeDecisionRegistry?: ResearchEdgeDecisionRegistry): Promise<
+    | { ok: true; graph: GraphTemplateSpec; growth: GraphGrowth; edgeDecision?: ResolvedResearchEdgeDecision }
+    | { ok: false; reason: string; park?: boolean; growth?: GraphGrowth; decisionId?: string; decisionRef?: string; command?: GrowthCommand; approval?: string; edgeDecision?: ResolvedResearchEdgeDecision }
+  > {
   let proposal: GrowthProposal | undefined;
-  try { proposal = await proposer(input); }
-  catch (error) { return { ok: false, reason: `proposer failed: ${String(error)}` }; }
+  const value = input.output;
+  const assessment = value !== null && typeof value === 'object' && !Array.isArray(value)
+    && Array.isArray((value as Record<string, unknown>).gaps)
+    && Array.isArray((value as Record<string, unknown>).contradictions)
+    && Array.isArray((value as Record<string, unknown>).verdicts)
+    ? { gaps: (value as Record<string, unknown>).gaps as unknown[],
+      contradictions: (value as Record<string, unknown>).contradictions as unknown[],
+      verdicts: (value as Record<string, unknown>).verdicts as unknown[] }
+    : undefined;
+  let edgeDecision: ResolvedResearchEdgeDecision | undefined;
+  if (assessment) {
+    const [{ createResearchEdgeDecisionRegistry }, { debug }] = await Promise.all([
+      import('../research/edge-decision.js'), import('../debug/log.js'),
+    ]);
+    edgeDecision = await (edgeDecisionRegistry ?? createResearchEdgeDecisionRegistry()).decide(assessment);
+    try {
+      debug.log('research.edge', 'decision', {
+        provider: edgeDecision.provider,
+        decision: edgeDecision.action,
+        reason: edgeDecision.reason,
+      });
+    } catch { /* observation must not change graph growth */ }
+    if (edgeDecision.action !== 'add') {
+      return { ok: false, reason: `edge decision ${edgeDecision.action}: ${edgeDecision.reason}`, edgeDecision };
+    }
+    proposal = edgeDecision.proposal;
+  } else {
+    try { proposal = await proposer(input); }
+    catch (error) { return { ok: false, reason: `proposer failed: ${String(error)}` }; }
+  }
   if (!proposal) return { ok: false, reason: 'no proposal' };
   if (!proposal.node || typeof proposal.reason !== 'string' || !proposal.reason.trim()) return { ok: false, reason: 'proposal requires a node and reason' };
   let result: ReturnType<typeof createGraphVariant>;
@@ -99,5 +127,5 @@ export async function proposeGrowth(input: Parameters<GrowthProposer>[0],
         growth: proposalGrowth(input, proposal) };
     }
   }
-  return { ok: true, graph: result.template, growth: proposalGrowth(input, proposal) };
+  return { ok: true, graph: result.template, growth: proposalGrowth(input, proposal), ...(edgeDecision ? { edgeDecision } : {}) };
 }

package/src/graph-runner/graph-run-api.ts

@@ -117,7 +117,7 @@ export function runnableIssues(doc: Record<string, unknown>, allowedRecipes: Rea
   return issues;
 }
 
-export interface GraphRunNodeView { nodeId: string; ok: boolean; executed: boolean; startedAt?: string; endedAt?: string; error?: string }
+export interface GraphRunNodeView { nodeId: string; ok: boolean; exit: number | null; executed: boolean; startedAt?: string; endedAt?: string; error?: string; reason?: string }
 export interface GraphRunView {
   graphId: string; runId: string; status: GraphRunState['status'] | 'starting';
   startedAt?: string; finishedAt?: string; path: string[];
@@ -130,9 +130,10 @@ export function graphRunView(state: GraphRunState): GraphRunView {
     ...(state.startedAt ? { startedAt: state.startedAt } : {}), ...(state.finishedAt ? { finishedAt: state.finishedAt } : {}),
     path: state.path,
     nodes: state.nodes.map((node) => ({
-      nodeId: node.nodeId, ok: node.ok, executed: node.executed,
+      nodeId: node.nodeId, ok: node.ok, exit: node.exit, executed: node.executed,
       ...(node.startedAt ? { startedAt: node.startedAt } : {}), ...(node.endedAt ? { endedAt: node.endedAt } : {}),
       ...(node.error ? { error: node.error.slice(0, 300) } : {}),
+      ...(node.reason === undefined ? {} : { reason: node.reason }),
     })),
     ...(state.currentNode ? { currentNode: state.currentNode } : {}),
   };