elanous 0.2.25 → 0.2.28

package/src/harness/harness-cli-command.ts

@@ -25,6 +25,8 @@ import { classifyPodExitStop, recordRunStop, runStopRecorded, RUN_STOP_EVENT } f
 import { ensureOpenRouterChildModelLive, resolveChildLlmEffort, resolveImplementationChildModel } from '../self-dev/dev-cli.js';
 import { resolveHarnessTarget } from '../self-implement/harness-target-options.js';
 import { buildRunProgressRows, isPartialRunningRuns, queryRunningRuns, renderRunProgressTable } from '../self-implement/running-runs.js';
+import { launchBindingRunIds, readLaunchBinding } from './launch-registry.js';
+import { psProcessStartMs } from './harness-stop.js';
 import { DevPipelineError } from '../self-dev/dev-pipeline.js';
 import { collectDraftMetrics, collectOverlapMetrics, DRAFT_SWEEP_CONCURRENCY, mapBounded, resolveDraftSweepCloseCap, runDraftSweep, sweepFailureReason, type DraftSweepAdapters, type DraftSweepResult, type OverlapMetricAdapters, type SweepDraft, type SweepMergedPr, type SweepReviewGate } from '../self-dev/draft-sweep.js';
 import { readAskPreflightRowsSince, readSalvagedRowsSince } from '../self-dev/ask-launch-io.js';
@@ -303,6 +305,7 @@ function registerHarnessAskSayOptions(command: Command): Command {
     .addOption(new Option('--pod-memory <tier>', 'pod: 메모리 등급 — lite(2Gi · 문서·조사·네트워크 스킬 골 · OOM 이면 high 로 한 번 재시도) | standard(16Gi) | high(32Gi) · 없으면 골 문면 `Pod 메모리: <등급>` 한 줄 · 그것도 없으면 골이 apps/pwa/ 를 담을 때 high').choices(['lite', 'standard', 'high']))
     .option('--after <goal-or-pr>', 'pod: 선행 — 이 골 ID(16자) 또는 PR(#N) 이 병합될 때까지 Pod 발사가 큐에서 이유와 함께 기다린다(병합 없이 닫히면 blocked) · 골 문면 `선행: #N` 한 줄과 같다 · 대상 파일만 겹치면 선행이 아니다(경고만)')
     .option('--source <spec>', 'pod: 원천 — commit:<40자 sha> | pr:<정수> | worktree:<경로> | files:<경로>[,<경로>…] · `--substrate pod` 와 함께')
+    .option('--repair-commit-only <expected-head>', 'pod: 기존 PR head에서 수리한 커밋을 bundle로 반환(PR 생성 없음)')
     .option('--bench <id[:sha]>', '벤치 팔 — base 를 bench/<id>/base 로 고정(없으면 sha·생략 시 origin/main 으로 만든다 · 있으면 sha 일치 확인 · 불일치 거부) · 팔 가지 bench/<id>/<arm> · PR 라벨 elanous:bench · PR 직전 main 동기화 생략 · 원장 elanous bench ls <id>');
 }
 
@@ -395,7 +398,7 @@ function assertHarnessChildLlmModel(opts: HarnessAskSayChildLlmOptions): void {
 }
 
 /** Shared post-parse gate: validate child model before any ask/say early return (including `--dry-run`). */
-type HarnessSubstrateOpts = { substrate?: 'local' | 'pod'; podPool?: string; podMemory?: 'lite' | 'standard' | 'high'; after?: string; autoMerge?: boolean; base?: string; json?: boolean; target?: string; source?: string; seat?: QueueSeat };
+type HarnessSubstrateOpts = { substrate?: 'local' | 'pod'; podPool?: string; podMemory?: 'lite' | 'standard' | 'high'; after?: string; autoMerge?: boolean; base?: string; json?: boolean; target?: string; source?: string; repairCommitOnly?: string; seat?: QueueSeat };
 function resolveLaunchSubstrate(opts: HarnessSubstrateOpts): ResolvedHarnessSubstrate {
   const resolved = resolveHarnessSubstrate({ flag: opts, config: getUserConfig(), env: process.env });
   debug.log('harness.substrate', 'resolved', resolved);
@@ -691,7 +694,7 @@ async function onPod(opts: unknown, entrance: 'cli-harness-ask' | 'cli-harness-s
   const status = await dispatchHarnessOnPod({ entrance, input, podPool: pool, ...(authorOnPod && entrance === 'cli-harness-say' ? { authorOnPod: true } : {}),
     ...(child.childLlmProvider?.trim() ? { childLlmProvider: child.childLlmProvider.trim() } : {}),
     ...(child.childLlmModel?.trim() ? { childLlmModel: child.childLlmModel.trim() } : {}),
-    ...(child.childLlmEffort?.trim() ? { childLlmEffort: child.childLlmEffort.trim() } : {}), ...(authorOnPod && podAuthorGrade ? { authorGrade: podAuthorGrade.grade, authorGradeSource: podAuthorGrade.source } : {}), ...(dispatchRecorded ? { dispatchRecorded: true } : {}), ...(o.podMemory ? { podMemory: o.podMemory } : {}), ...((opts as HarnessAskSayChildLlmOptions).goalType ? { goalType: (opts as HarnessAskSayChildLlmOptions).goalType } : {}), ...(o.after ? { after: o.after } : {}), ...(o.autoMerge === false ? { autoMerge: false } : {}), ...(o.base ? { base: o.base } : {}), ...(o.json ? { json: true } : {}), ...(o.source ? { source: o.source } : {}), ...(o.seat ? { seat: o.seat } : {}) },
+    ...(child.childLlmEffort?.trim() ? { childLlmEffort: child.childLlmEffort.trim() } : {}), ...(authorOnPod && podAuthorGrade ? { authorGrade: podAuthorGrade.grade, authorGradeSource: podAuthorGrade.source } : {}), ...(dispatchRecorded ? { dispatchRecorded: true } : {}), ...(o.podMemory ? { podMemory: o.podMemory } : {}), ...((opts as HarnessAskSayChildLlmOptions).goalType ? { goalType: (opts as HarnessAskSayChildLlmOptions).goalType } : {}), ...(o.after ? { after: o.after } : {}), ...(o.autoMerge === false ? { autoMerge: false } : {}), ...(o.base ? { base: o.base } : {}), ...(o.json ? { json: true } : {}), ...(o.source ? { source: o.source } : {}), ...(o.repairCommitOnly ? { repairCommitOnly: o.repairCommitOnly } : {}), ...(o.seat ? { seat: o.seat } : {}) },
     { onOutput: (text) => {
       runId ??= harnessPodRunId(output + text);
       output = (output + text).slice(-16_000);
@@ -892,6 +895,8 @@ async function dispatchHarnessAskSay(
     if (isHarnessDryRun(opts)) {
       resolveLaunchSubstrate(opts);
       printHarnessLaunchDryRun(dryRunPreview);
+      const repair = opts as HarnessSubstrateOpts;
+      if (repair.repairCommitOnly) console.log(`[dry-run] repair forwarding: --pod-source ${repair.source} --repair-commit-only ${repair.repairCommitOnly} --no-auto-merge`);
       return;
     }
     ensureJourneyKey();
@@ -937,7 +942,7 @@ async function dispatchHarnessAskSay(
         ['--goal-type', opts.goalType], ...(dryRunPreview.entrance === 'cli-harness-say' ? [['--author-grade', opts.authorGradeSource === 'flag' ? opts.authorGrade : undefined] as [string, string | undefined]] : []), ['--child-llm-provider', opts.childLlmProvider],
         ['--child-llm-model', opts.childLlmModel], ['--child-llm-effort', opts.childLlmEffort],
         ['--pod-pool', (opts as HarnessSubstrateOpts).podPool], ['--pod-memory', (opts as HarnessSubstrateOpts).podMemory],
-        ['--after', (opts as HarnessSubstrateOpts).after], ['--source', (opts as HarnessSubstrateOpts).source],
+        ['--after', (opts as HarnessSubstrateOpts).after], ['--source', (opts as HarnessSubstrateOpts).source], ['--repair-commit-only', (opts as HarnessSubstrateOpts).repairCommitOnly],
       ];
       for (const [flag, value] of values) if (value !== undefined) flags.push(flag, value);
       if ((opts as HarnessSubstrateOpts).source !== undefined && resolved.substrate !== 'pod') {
@@ -1011,8 +1016,9 @@ async function dispatchHarnessAskSay(
       const previous = process.env.ELANOUS_HARNESS_SEAT;
       if (stampedSeat) process.env.ELANOUS_HARNESS_SEAT = stampedSeat;
       else delete process.env.ELANOUS_HARNESS_SEAT;
-      // 배치 노드 — 실행 칸(local | pod)이 그 출구 라벨이고, YAML 의 decompose 간선(on: substrate)이 그 값으로 갈린다.
-      passJourneyNode('dispatch', { ...journey, outcome: resolved.substrate });
+      // The source label selects the declared author or same-PR rework edge; substrate remains data for decompose.
+      passJourneyNode('dispatch', { ...journey, outcome: (stampedOpts as HarnessSubstrateOpts).repairCommitOnly ? 'pr-source' : 'fresh',
+        data: { substrate: resolved.substrate } });
       const benchRow = bench ? recordBenchLaunch(bench, stampedOpts, resolved.substrate, dryRunPreview.entrance, benchDeps) : undefined;
       try { await dispatch(resolved, stampedOpts); }
       finally {
@@ -2391,6 +2397,7 @@ const defaultDraftSweepStopRun: DraftSweepStopRun = async (runId) => {
 export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: DraftSweepGitExecute = runGitCommand, cwd = process.cwd(),
   executeAsync: (args: string[]) => Promise<string> = execute === executeGh ? executeGhAsync : async (args) => execute(args),
   stopRun: DraftSweepStopRun = defaultDraftSweepStopRun): GithubDraftSweepAdapters {
+  const ensuredSweepLabels = new Set<string>();
   const inventory = async (repository: string, state: 'open' | 'closed'): Promise<GithubPull[]> => {
     // ⛔ A large repository has tens of thousands of closed PRs (2026-09-28: 21k → «exceeded pagination limit», no sweep at all).
     //    Merged twins only matter after the oldest open draft was opened, so the closed listing stops at that time.
@@ -2642,11 +2649,19 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
         .map((line) => line.slice('branch refs/heads/'.length).trim()));
     },
     setLabels: async (repository, number, change) => {
+      if (change.add.startsWith('elanous:swept:')) {
+        const key = `${repository}:${change.add}`;
+        if (!ensuredSweepLabels.has(key)) {
+          execute(['label', 'create', change.add, '--repo', repository, '--color', '6A737D',
+            '--description', 'Draft sweep close reason; reopen this PR to restore it', '--force']);
+          ensuredSweepLabels.add(key);
+        }
+      }
       execute(['pr', 'edit', String(number), '--repo', repository, '--add-label', change.add,
         ...change.remove.flatMap((name) => ['--remove-label', name])]);
     },
-    closeDraft: async (repository, number, comment) => {
-      execute(['pr', 'close', String(number), '--repo', repository, '--comment', comment]);
+    closeDraft: async (repository, number) => {
+      execute(['pr', 'close', String(number), '--repo', repository]);
     },
     getClaimOwner: async (repository, number) => claimCommentOwner(repository, number, execute),
     getActiveClaimOwner: async (repository, number) => activeClaimOwnerFromBodies(await claimCommentsFor(repository, number)),
@@ -3137,7 +3152,13 @@ export interface HarnessCliCommandDeps {
   mission?: HarnessMissionHandler;
   missionLoop?: HarnessMissionLoopHandler;
   /** `harness progress` 가 도는 런 관측을 읽는 자리(시험 주입). 기본은 queryRunningRuns. */
-  progress?: { query?: typeof queryRunningRuns; nowMs?: () => number };
+  progress?: {
+    query?: typeof queryRunningRuns;
+    nowMs?: () => number;
+    bindingRunIds?: typeof launchBindingRunIds;
+    readBinding?: typeof readLaunchBinding;
+    processStartMs?: typeof psProcessStartMs;
+  };
 }
 
 export function installHarnessCliCommand(program: Command, deps: HarnessCliCommandDeps): Command {
@@ -3198,8 +3219,33 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
     });
   harnessCmd.command('progress').description('도는 골마다 진도를 한 표로 읽는다 — 단계 · 진입 시각 · 마지막 진전 · pty (읽기 전용)')
     .option('--json', '같은 행 배열을 JSON 으로 출력')
-    .action((opts: { json?: boolean }) => {
+    .option('--pid <number>', '기록된 로컬 PID 에 연결된 런 한 건만 조회')
+    .action((opts: { json?: boolean; pid?: string }) => {
       try {
+        if (opts.pid !== undefined) {
+          const pid = Number(opts.pid);
+          if (!Number.isSafeInteger(pid) || pid <= 1) {
+            console.error('❌ --pid 는 2 이상의 정수여야 합니다');
+            process.exitCode = 2;
+            return;
+          }
+          const bindings = (deps.progress?.bindingRunIds ?? launchBindingRunIds)()
+            .map((runId) => ({ runId, binding: (deps.progress?.readBinding ?? readLaunchBinding)(runId) }))
+            .filter(({ binding }) => binding?.pid === pid);
+          const binding = bindings.length === 1 && !bindings[0]!.binding?.podName ? bindings[0] : undefined;
+          const startedAt = binding ? (deps.progress?.processStartMs ?? psProcessStartMs)(pid) : null;
+          // ps lstart has second precision. A wider stop-oriented tolerance would attribute a reused PID to this run.
+          const observed = binding && startedAt !== null
+            && startedAt === Math.floor(binding.binding!.startedAt / 1_000) * 1_000;
+          const result = observed
+            ? (deps.progress?.query ?? queryRunningRuns)({ runIds: [binding.runId], caller: 'harness.progress.pid' })
+            : null;
+          const row = result ? buildRunProgressRows(result, (deps.progress?.nowMs ?? Date.now)())
+            .find((item) => item.runId === binding!.runId && item.status !== 'ended-unclosed' && item.status !== 'unknown') : undefined;
+          if (opts.json) console.log(JSON.stringify({ pid, observation: row ? 'observed' : 'unobserved', runId: row?.runId ?? null, progress: row ?? null }));
+          else console.log(row ? `pid ${pid} · ${renderRunProgressTable({ ...result!, entries: result!.entries.filter((item) => item.runId === row.runId) }, (deps.progress?.nowMs ?? Date.now)()).split('\n').slice(1).join('\n')}` : `pid ${pid} · 미관측`);
+          return;
+        }
         const result = (deps.progress?.query ?? queryRunningRuns)({ caller: 'harness.progress' });
         const nowMs = (deps.progress?.nowMs ?? Date.now)();
         if (opts.json) {
@@ -3300,6 +3346,11 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
   if (ask) {
     registerHarnessAskSayOptions(harnessCmd.command('ask <goal-path>').description('골 문서 경로를 받아 구동한다'))
       .action(async (goalPath: string, opts: HarnessAskSayChildLlmOptions & HarnessDryRunOpts) => {
+        if ((opts as HarnessSubstrateOpts).repairCommitOnly !== undefined) {
+          console.error('--repair-commit-only is supported only by harness say');
+          process.exitCode = 2;
+          return;
+        }
         await dispatchHarnessAskSay(
           opts,
           {
@@ -3328,6 +3379,13 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
     registerHarnessAskSayOptions(harnessCmd.command('say <sentence...>').description('문장을 받아 구동한다'))
       .addOption(new Option('--author-grade <grade>', 'say 저작 등급 (full|lite)').choices(['full', 'lite']))
       .action(async (sentence: string[], opts: HarnessAskSayChildLlmOptions & HarnessDryRunOpts) => {
+        const repair = opts as HarnessSubstrateOpts;
+        if (repair.repairCommitOnly !== undefined && (repair.substrate !== 'pod' || !/^pr:[1-9]\d*$/.test(repair.source ?? '')
+          || !/^[0-9a-f]{40}$/.test(repair.repairCommitOnly) || repair.autoMerge !== false || repair.target !== undefined)) {
+          console.error('--repair-commit-only requires --substrate pod --source pr:N --no-auto-merge and a 40-hex expected head');
+          process.exitCode = 2;
+          return;
+        }
         const grade = resolveGoalAuthorGrade(opts.authorGrade, getUserConfig().harness?.authorGrade);
         const podSource = process.env.ELANOUS_POD_AUTHOR_ON_POD === '1' && process.env.ELANOUS_POD_AUTHOR_GRADE === grade.grade
           ? process.env.ELANOUS_POD_AUTHOR_GRADE_SOURCE : undefined;
@@ -3348,7 +3406,7 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
               return Promise.resolve();
             }
             return resolved.substrate === 'pod'
-              ? onPod(stampedOpts, 'cli-harness-say', sentence.join(' '), resolved.pool!, deps.podDispatchTask, harnessAuthorOnPod())
+              ? onPod(stampedOpts, 'cli-harness-say', sentence.join(' '), resolved.pool!, deps.podDispatchTask, !(opts as HarnessSubstrateOpts).repairCommitOnly && harnessAuthorOnPod())
               : (announceLocalChildProvider(stampedOpts), say(sentence, normalizeHarnessAskSayOptions(stampedOpts)));
           },
           deps.launchGate, queueDeps, immediateLaunch, queueDeps.launch ? undefined : immediateExit, deps.bench,

package/src/harness/harness-pod-dispatch.ts

@@ -43,6 +43,8 @@ export interface HarnessPodDispatchInput {
   readonly json?: boolean;
   /** 사람이 고른 원천 spec — `commit:` · `pr:` · `worktree:` · `files:`. 검증은 발사 전. */
   readonly source?: string;
+  /** Existing PR head for a commit-only repair. Requires source pr:N. */
+  readonly repairCommitOnly?: string;
   /** `--child-llm-provider/--child-llm-model/--child-llm-effort` — carried to `self orchestrate` so the Pod child uses them (10-05 PODPROVIDER). */
   readonly childLlmProvider?: string;
   readonly childLlmModel?: string;
@@ -59,10 +61,11 @@ export function podOrchestrateArgs(input: HarnessPodDispatchInput, goalFile: str
     '--substrate', 'pod',
     ...(input.podPool ? ['--pod-pool', input.podPool] : []),
     // 하니스 기본(자동 병합)을 따른다 · 끄면 PR 까지 — 어느 쪽이든 Pod 가 사라져도 결과가 남는다.
-    ...(input.autoMerge === false ? ['--open-pr'] : ['--auto-merge']),
-    ...(input.base ? ['--base', input.base] : []),
+    ...(input.repairCommitOnly ? [] : input.autoMerge === false ? ['--open-pr'] : ['--auto-merge']),
+    ...(input.repairCommitOnly && input.source ? ['--base', `pr-${input.source.slice(3)}`] : input.base ? ['--base', input.base] : []),
     ...(input.json ? ['--json'] : []),
     ...(input.source ? ['--pod-source', input.source] : []),
+    ...(input.repairCommitOnly ? ['--repair-commit-only', input.repairCommitOnly] : []),
     ...(input.childLlmProvider?.trim() ? ['--child-llm-provider', input.childLlmProvider.trim()] : []),
     ...(input.childLlmModel?.trim() ? ['--child-llm-model', input.childLlmModel.trim()] : []),
     ...(input.childLlmEffort?.trim() ? ['--child-llm-effort', input.childLlmEffort.trim()] : []),
@@ -85,6 +88,10 @@ export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDi
       return 2;
     }
   }
+  if (input.repairCommitOnly && (!/^pr:[1-9]\d*$/.test(input.source ?? '') || !/^[0-9a-f]{40}$/.test(input.repairCommitOnly) || input.autoMerge === true)) {
+    debug.log('harness.substrate', 'repair-refused', { entrance: input.entrance, reason: 'requires pr source, 40-hex head, and no auto-merge' });
+    return 2;
+  }
   const env = { ...process.env, ...oldDoorInternalEnv('self-orchestrate') };
   // POD-OBS(10-06): 자식 orchestrate 는 트리 파생 우주에서 돈다 — Pod 원장 재방출을 «발사한 집»의 logs.db 에도 남기게 경로를 넘긴다.
   env[POD_REEMIT_LOGS_DB_ENV] = logsDbPath();
@@ -146,7 +153,7 @@ export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDi
     memoryLimit: podMemoryLimitFor(goalText, env).limit });
   delete env.ELANOUS_POD_AFTER;
   if (input.after) env.ELANOUS_POD_AFTER = input.after;
-  if (input.authorOnPod) env.ELANOUS_POD_AUTHOR_ON_POD = '1';
+  if (input.authorOnPod && !input.repairCommitOnly) env.ELANOUS_POD_AUTHOR_ON_POD = '1';
   else delete env.ELANOUS_POD_AUTHOR_ON_POD;
   if (input.authorOnPod && input.authorGrade) {
     env.ELANOUS_POD_AUTHOR_GRADE = input.authorGrade;
@@ -157,7 +164,7 @@ export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDi
     delete env.ELANOUS_POD_AUTHOR_GRADE;
     delete env.ELANOUS_POD_AUTHOR_GRADE_SOURCE;
   }
-  if (input.entrance === 'cli-harness-ask') {
+  if (input.entrance === 'cli-harness-ask' && !input.repairCommitOnly) {
     const root = findGitDir(cwd)?.root;
     const path = resolve(cwd, input.input);
     const relativePath = root ? relative(realpathSync(root), realpathSync(path)) : '';

package/src/harness/harness-stop.ts

@@ -81,7 +81,7 @@ export function discoverStopProcesses(runId: string, goalPath: string | null, ta
     const match = /^\s*(\d+)\s+((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s+\w+\s+\d+\s+\d\d:\d\d:\d\d\s+\d{4})\s+(.+)$/.exec(line);
     if (!match) return { status: 'failed', reason: 'unparseable process table row' };
     const pid = Number(match[1]);
-    const startedAt = Date.parse(match[2]!);
+    const startedAt = Date.parse(`${match[2]!} GMT`);
     if (!Number.isSafeInteger(pid) || !Number.isFinite(startedAt)) return { status: 'failed', reason: 'invalid process table row' };
     if (pid <= 1) continue;
     const args = match[3]!.match(/"[^"]*"|'[^']*'|\S+/g)?.map((part) => part.replace(/^(['"])(.*)\1$/, '$2')) ?? [];
@@ -132,7 +132,9 @@ function stopProcessCwd(pid: number): string | null {
 
 function scanStopProcessTable(runId: string, goalPath: string | null): StopProcessScan {
   let r: ReturnType<typeof spawnSync>;
-  try { r = spawnSync('ps', ['-eo', 'pid=,lstart=,args='], { encoding: 'utf8', timeout: 5_000, maxBuffer: 16 * 1024 * 1024 }); }
+  try { r = spawnSync('ps', ['-eo', 'pid=,lstart=,args='], {
+    encoding: 'utf8', timeout: 5_000, maxBuffer: 16 * 1024 * 1024, env: { ...process.env, TZ: 'UTC' },
+  }); }
   catch (error) { return { status: 'failed', reason: String(error) }; }
   if (r.error || r.status !== 0 || typeof r.stdout !== 'string') return { status: 'failed', reason: String(r.error ?? r.stderr ?? `ps status ${r.status}`) };
   return discoverStopProcesses(runId, goalPath, r.stdout, stopProcessCwd);
@@ -201,13 +203,15 @@ export function pidRecordFromLaunchBinding(runId: string, registryDir = launchRe
   return { pid: binding.pid, startedAt: binding.startedAt, ...(binding.argv0 ? { argv0: binding.argv0 } : {}) };
 }
 
-/** macOS·Linux 공통 — `ps -o lstart=` 는 로컬 시각 문자열(초 단위)이다. */
+/** macOS·Linux 공통 — UTC 시작 시각과 상태를 같은 ps 관측에서 읽는다. */
 export function psProcessStartMs(pid: number): number | null {
-  const r = spawnSync('ps', ['-o', 'lstart=', '-p', String(pid)], { encoding: 'utf8', timeout: 5_000 });
+  const r = spawnSync('ps', ['-o', 'lstart=,stat=', '-p', String(pid)], {
+    encoding: 'utf8', timeout: 5_000, env: { ...process.env, TZ: 'UTC' },
+  });
   if (r.status !== 0) return null;
-  const text = r.stdout.trim();
-  if (!text) return null;
-  const ms = Date.parse(text);
+  const match = /^\s*((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s+\w+\s+\d+\s+\d\d:\d\d:\d\d\s+\d{4})\s+(\S+)\s*$/.exec(r.stdout);
+  if (!match || match[2]!.startsWith('Z')) return null;
+  const ms = Date.parse(`${match[1]!} GMT`);
   return Number.isFinite(ms) ? ms : null;
 }
 

package/src/hq/seats.ts

@@ -278,6 +278,18 @@ export function hqInit(options: { root?: string; home?: string } = {}): { root:
   return { root, created, cron };
 }
 
+// A skipped refresh leaves the seat looking idle to every other surface: one observation line carries the
+// reason and how far the kept HEAD trails the fetched origin/main. Observation never changes the verdict
+// (same rule as judgeLandedTip).
+function observeRefreshSkipped(path: string, role: HqSeatRole, reason: 'dirty' | 'unlanded-head', head?: string): void {
+  try {
+    const tip = head ?? git(path, 'rev-parse', 'HEAD');
+    const behind = runGitCommand(path, ['rev-list', '--count', 'HEAD..refs/remotes/origin/main'], { encoding: 'utf8' });
+    const count = behind.status === 0 && /^\d+$/.test(behind.stdout.trim()) ? Number(behind.stdout.trim()) : null;
+    debug.log('hq.seat', 'refresh-skipped', { role, path, reason, head: tip, behind: count });
+  } catch { /* observation must not change the verdict */ }
+}
+
 export function hqSeat(value: string, options: { root?: string; refresh?: boolean } = {}): { path: string; outcome: 'created' | 'unchanged' | 'refreshed' | 'dirty' } {
   const role = roleOf(value);
   const root = resolve(options.root ?? hqRoot());
@@ -301,16 +313,18 @@ export function hqSeat(value: string, options: { root?: string; refresh?: boolea
   const onBranch = runGitCommand(path, ['symbolic-ref', '--quiet', '--short', 'HEAD'], { encoding: 'utf8' });
   if (onBranch.status === 0) throw new Error(`not a seat: ${path} is on branch ${onBranch.stdout.trim()}; refusing to touch it`);
   // A dirty seat must be byte-for-byte untouched, including its detached HEAD.
-  if (options.refresh && !clean(path)) return { path, outcome: 'dirty' };
+  // The cron line fetches the mirror before refreshing, so `behind` counts against the fetched origin/main.
+  if (options.refresh && !clean(path)) { observeRefreshSkipped(path, role, 'dirty'); return { path, outcome: 'dirty' }; }
   if (!options.refresh) return { path, outcome: 'unchanged' };
   git(repo, 'fetch', 'origin');
   // Concurrent refreshes of one seat (cron and a person) serialize on the house lock; each re-checks first.
   return withLedgerLock(root, () => {
     assertRegisteredWorktree(repo, path);
     if (runGitCommand(path, ['symbolic-ref', '--quiet', 'HEAD'], { encoding: 'utf8' }).status === 0) throw new Error(`not a seat: ${path} is on a branch; refusing to touch it`);
-    if (!clean(path)) return { path, outcome: 'dirty' as const };
+    if (!clean(path)) { observeRefreshSkipped(path, role, 'dirty'); return { path, outcome: 'dirty' as const }; }
     // Commits made on the detached seat are not on origin/main; moving HEAD would orphan them. Treat as dirty.
-    if (!mergedIntoMain(repo, git(path, 'rev-parse', 'HEAD'))) return { path, outcome: 'dirty' as const };
+    const head = git(path, 'rev-parse', 'HEAD');
+    if (!mergedIntoMain(repo, head)) { observeRefreshSkipped(path, role, 'unlanded-head', head); return { path, outcome: 'dirty' as const }; }
     git(path, 'checkout', '--detach', 'refs/remotes/origin/main');
     return { path, outcome: 'refreshed' as const };
   });

package/src/index.ts

@@ -38,6 +38,7 @@ import { DEV_PIPELINE_SINK_SURFACE } from './self-implement/self-cli-sink-surfac
 import { registerPrivateLedgerCommands } from './cli/private-ledger-commands.js';
 import { registerKnowCommand } from './cli/know-cli.js';
 import { registerSeatRequestsCommands } from './cli/seat-requests-cli.js';
+import { registerSeatBootCommands } from './cli/seat-cli.js';
 import { applyTestStateDirFlagFromArgv } from './cli/test-state-dir-flag.js';
 import { applyTestFlagFromArgv, observeTestFlagOwnership, uncoveredTestFlagPaths, staleTestFlagPaths } from './cli/test-flag.js';
 import { registerPtyTakeoverCommands } from './cli/pty-takeover-cli.js';
@@ -1118,6 +1119,7 @@ hqCmd.command('fence').description('이 호스트가 임대를 쥐었을 때만
     process.exitCode = hqFenceRun(opts.role as 'cron', command);
   });
 const seatCmd = program.command('seat').description('분배된 자리의 하루 루프와 보고');
+registerSeatBootCommands(seatCmd);
 registerSeatRequestsCommands(seatCmd);
 seatCmd.command('asks').description('최근 CTO 되묻기 왕복과 10분 판정')
   .option('--since <duration>', '조회 창 (예: 24h)', '24h')
@@ -2394,18 +2396,20 @@ harnessCmd
   .description('하니스 disposable worktree + 브랜치 정리(기본 접두는 만드는 쪽 상수에서 온다). ⚠️ 열린 PR 은 항상 보존. 기본 dry-run(계획만·--yes 로 실제 제거).')
   .option('--abandoned', 'PR 이력 없는 것(escalated/방치) 제거 [기본]')
   .option('--merged', 'PR 머지된 것 제거')
+  .option('--include-unowned-merged-clean', '미소유 merged-clean worktree 회수 허용(merged 모드 전용)')
   .option('--all', '열린 PR 외 전부 제거')
   .option('--force', '열린 PR 브랜치도 제거(위험)')
   .option('--yes', '실제 제거(생략 시 dry-run)')
   .option('--prefix <p>', `브랜치 prefix(기본 ${WORKTREE_BRANCH_PREFIX_HELP})`)
   .option('--repo <repo>', 'gh repo(기본 origin 추론)')
   .option('--json', '구조화 출력')
-  .action(async (opts: { abandoned?: boolean; merged?: boolean; all?: boolean; force?: boolean; yes?: boolean; prefix?: string; repo?: string; json?: boolean }) => {
+  .action(async (opts: { abandoned?: boolean; merged?: boolean; all?: boolean; force?: boolean; includeUnownedMergedClean?: boolean; yes?: boolean; prefix?: string; repo?: string; json?: boolean }) => {
     const { execHarnessClean } = await import('./harness/harness-clean.js');
     const mode = opts.all ? 'all' : opts.merged ? 'merged' : 'abandoned';
     const res = execHarnessClean({
       mode, dryRun: !opts.yes,
       ...(opts.force ? { force: true } : {}),
+      ...(opts.includeUnownedMergedClean ? { includeUnownedMergedClean: true } : {}),
       ...(opts.prefix ? { branchPrefix: opts.prefix } : {}),
       ...(opts.repo ? { repo: opts.repo } : {}),
     });
@@ -3352,6 +3356,20 @@ coordCmd.command('events')
   });
 
 const selfCmd = program.command('self').description('Self-awareness memory — 외부 도구(Claude Code/Codex)가 구현/변경 이력을 elanous 기억에 주입·회상');
+selfCmd.command('repair-commit-export <pr> <base-head> <child-output> <repo> <outbox>')
+  .description('Pod commit-only repair artifact exporter (installed CLI)')
+  .action(async (pr: string, baseHead: string, outputPath: string, repo: string, outbox: string) => {
+    const { readFileSync } = await import('node:fs');
+    const { writePodRepairCommit } = await import('./task-orchestrator/surfaces/pod-repair-commit.js');
+    try {
+      const result = writePodRepairCommit({ pr: Number(pr), baseHead, runId: process.env.ELANOUS_PARENT_RUN_ID ?? '', output: readFileSync(outputPath, 'utf8'), repo, outbox });
+      console.log(`ELANOUS_POD_REPAIR_COMMIT ${result.pr} ${result.baseHead} ${result.commit}`);
+    } catch (error) {
+      console.error(`ELANOUS_POD_REPAIR_FAILED ${error instanceof Error ? error.message : String(error)}`);
+      process.exitCode = 1;
+    }
+  });
+{ const { registerSelfUtterancesCommand } = await import('./cli/self-utterances-cli.js'); registerSelfUtterancesCommand(selfCmd); }
 
 // M12 Claude Code 의존도 계기판 — `elanous self dependence [--since] [--until] [--json]`(읽기만).
 { const { registerDependenceCommand } = await import('./cli/dependence-gauge.js'); registerDependenceCommand(selfCmd); }
@@ -4377,6 +4395,7 @@ selfCmd
   .option('--base <branch>', 'PR base 브랜치(생략 시 provider 기본)')
   .option('--no-draft', 'non-draft PR (기본 draft)')
   .option('--open-pr', 'gate 통과 후 push + draft PR open (기본: PR 안 열고 worktree 보존·fail-closed). 이 플래그가 HITL 명시 승인.')
+  .addOption(new Option('--no-open-pr', '수리 실행: PR 개설 없이 worktree-only로 종료').default(undefined))
   .option('--auto-merge', '★ 내부 리뷰가 clean(실제 리뷰 완료·verdict≠fail)이면 자동 병합(squash). must-fix 있으면 무시(hold·rework). outward-facing(main 병합)이라 명시 opt-in. 미지정=리뷰 후 HITL/draft.')
   .option('--merge-by-host', 'Pod 자식: 병합 직전 merge-ready 로 끝내 호스트가 재게이트한 뒤 병합')
   .option('--child-llm-provider <id>', '구현 자식 LLM provider(--child-llm-model 과 함께 · Pod 의 grok 폴백이 쓴다)')
@@ -4562,6 +4581,13 @@ const selfOrchestrateCmd = selfCmd
       ui.error(refused.message);
       process.exit(refused.exitCode);
     }
+    const repairRequested = (opts as { repairCommitOnly?: string }).repairCommitOnly;
+    if (repairRequested !== undefined && ((opts as { substrate?: string }).substrate !== 'pod'
+      || !/^pr:[1-9]\d*$/.test((opts as { podSource?: string }).podSource ?? '')
+      || !/^[0-9a-f]{40}$/.test(repairRequested) || opts.openPr || opts.autoMerge)) {
+      ui.error('--repair-commit-only: --substrate pod, --pod-source pr:N, 40-hex expected head, PR/자동 병합 없음이 필요합니다');
+      process.exit(2);
+    }
     // 위치 인자는 종전처럼 분리하고 파일 입력은 파일당 한 골이다.
     let inputGoals: ReturnType<typeof readSelfOrchestrateGoals>;
     try { inputGoals = readSelfOrchestrateGoals(parts, opts.goalFile); }
@@ -5011,6 +5037,10 @@ const selfOrchestrateCmd = selfCmd
         }
         const passEnv = podProvider === 'grok' ? requestedPassEnv.filter((key) => !grokKeyNames.includes(key)) : podProvider === 'openrouter' ? [...new Set([...requestedPassEnv, 'OPENROUTER_API_KEY'])] : podProvider === 'anthropic' ? [...new Set([...requestedPassEnv, 'ANTHROPIC_API_KEY'])] : requestedPassEnv;
         const podSourceSpec = (opts as { podSource?: string }).podSource;
+        const repairBaseHead = (opts as { repairCommitOnly?: string }).repairCommitOnly;
+        if (repairBaseHead && (!/^pr:[1-9]\d*$/.test(podSourceSpec ?? '') || !/^[0-9a-f]{40}$/.test(repairBaseHead) || opts.autoMerge || opts.openPr || goalTexts.length !== 1)) {
+          ui.error('--repair-commit-only: --pod-source pr:N, 40-hex expected head, 골 1개, PR/자동 병합 없음이 필요합니다'); process.exit(2);
+        }
         let podSource: import('./task-orchestrator/surfaces/pod-source-receive.js').PodSource | undefined;
         if (podSourceSpec) {
           const { parsePodSourceSpec, resolvePodSource } = await import('./task-orchestrator/surfaces/pod-source-spec.js');
@@ -5033,7 +5063,7 @@ const selfOrchestrateCmd = selfCmd
         if (childFlags.childLlmProvider?.trim()) debug.log('self-implement.pod', 'child-provider-named', { provider: childFlags.childLlmProvider.trim(), model: childFlags.childLlmModel ?? null, podProvider });
         // BEDROCK-POD-PROVIDER-DROP — provider·account 는 한 곳(podLaunchProviderOptions)에서 — 손 나열이 bedrock 을 떨궈 codex(team)로 돌았다(10-11).
         const podProviderOptions = (await import('./task-orchestrator/surfaces/pod-child-providers.js')).podLaunchProviderOptions(podProvider, { explicitPodAccount, grokApiKeyOptIn });
-        const podBase = { hostSupervised: opts.supervise === true, ...podChildLlm, ...(remoteOnlyPool ? { imageCommit: image.imageCommit } : {}), ...podProviderOptions, ...(accountBroker ? { accountBroker, rotationAccounts } : {}), passEnv, ...(pool ? { pool } : {}), ...((opts as { podSkillEnv?: boolean }).podSkillEnv ? { skillEnv: true } : {}), ...(podSource ? { source: podSource } : {}) };
+        const podBase = { hostSupervised: opts.supervise === true, ...podChildLlm, ...(remoteOnlyPool ? { imageCommit: image.imageCommit } : {}), ...podProviderOptions, ...(accountBroker ? { accountBroker, rotationAccounts } : {}), passEnv, ...(pool ? { pool } : {}), ...((opts as { podSkillEnv?: boolean }).podSkillEnv ? { skillEnv: true } : {}), ...(podSource ? { source: podSource } : {}), ...(repairBaseHead && podSource?.kind === 'pr' ? { repairCommitOnly: { pr: podSource.number, baseHead: repairBaseHead } } : {}) };
         if (benchArms) {
           const { benchPodSpawn } = await import('./task-orchestrator/surfaces/self-implement-pod.js');
           podSpawn = benchPodSpawn(benchArms, podBase);
@@ -5143,7 +5173,8 @@ selfOrchestrateCmd
   .addOption(new Option('--no-supervise', '⛔ 런 슈퍼바이저를 «끈다»(대표 2026-08-22 ***기본 ON***) — 켜져 있으면 런이 끝나면 실패를 «트리아지»해서 다시 걸 것이 있으면 «스스로» 재개한다(골루프처럼 끝까지). 정지 사유는 converged|needs-human|max-rounds|no-progress 로 각각 «다른 값»으로 말한다. 관측=elanous logs --category self-dev.supervisor').hideHelp())
   .addOption(new Option('--supervise-rounds <n>', '슈퍼바이저 재개 라운드 상한 (기본 3 · 끄려면 --no-supervise)').hideHelp())
   .addOption(new Option('--json', '구조화 출력 [{taskId, feature, status, stage?, prUrl?, merged?, error?}]').hideHelp())
-  .addOption(new Option('--pod-source <spec>', 'pod: 원천 — commit:<40자 sha> | pr:<정수> | worktree:<경로> | files:<경로>[,<경로>…] · 없으면 기본 clone').hideHelp());
+  .addOption(new Option('--pod-source <spec>', 'pod: 원천 — commit:<40자 sha> | pr:<정수> | worktree:<경로> | files:<경로>[,<경로>…] · 없으면 기본 clone').hideHelp())
+  .addOption(new Option('--repair-commit-only <expected-head>', 'pod: 기존 PR head에서 재작업하고 PR 생성 없이 커밋 bundle을 돌려준다').hideHelp());
 
 function formatRelativeAge(updatedAt: number, now = Date.now()): string {
   const seconds = Math.floor(Math.max(0, now - updatedAt) / 1000);
@@ -5646,7 +5677,8 @@ selfCmd
   .option('--context <path>', '리뷰어가 함께 판단할 레포 상대 파일 경로(반복 가능)', (value: string, previous: string[] = []) => [...previous, value])
   .option('--context-text <text>', '리뷰어가 함께 판단할 텍스트(반복 가능)', (value: string, previous: string[] = []) => [...previous, value])
   .option('--json', '구조화 출력 {pr, verdict, mustFix, shouldFix, reviewed}')
-  .action(async (prParts: string[], opts: { intent?: string; model?: string; acp?: boolean; acpModel?: string; acpBackend?: string; acpTimeout?: string; context?: string[]; contextText?: string[]; json?: boolean }) => {
+  .option('--save <name>', '리뷰 결과를 상태 디렉터리의 review-results/<name>-<PR>-<head12>.json에 저장')
+  .action(async (prParts: string[], opts: { intent?: string; model?: string; acp?: boolean; acpModel?: string; acpBackend?: string; acpTimeout?: string; context?: string[]; contextText?: string[]; json?: boolean; save?: string }) => {
     const prArgs = prParts.flatMap((p) => String(p).split(/[,\s]+/).filter(Boolean)); // 번호/#번호/URL·콤마목록.
     if (!prArgs.length) { ui.error('PR 필요: elanous self review <번호|URL> [..]'); process.exit(2); }
     // ⭐ 본문은 seam(`runSelfReviewCliCommand`)에 있다 — 이 액션은 **의존 배선만** 한다.
@@ -5744,6 +5776,19 @@ selfCmd
       envModel: () => process.env.ELANOUS_PR_REVIEW_MODEL,
     });
     if (opts.json) await writeStdoutJson(selfReviewJsonLine(results));
+    // Detached TA review: stdout is now complete in its result file. Resume only the bound card.
+    try {
+      const { rejudgeCompletedTaskReview, TA_REVIEW_COMPLETION_CARD_ENV, TA_REVIEW_COMPLETION_STATE_ENV, TA_REVIEW_COMPLETION_RESULT_ENV } = await import('./task-agent/review-result-capture.js');
+      const completionEnv: Record<string, string | undefined> = {};
+      for (const key of [TA_REVIEW_COMPLETION_CARD_ENV, TA_REVIEW_COMPLETION_STATE_ENV, TA_REVIEW_COMPLETION_RESULT_ENV]) {
+        const value = process.env[key];
+        if (value) completionEnv[key] = value;
+        delete process.env[key];
+      }
+      await rejudgeCompletedTaskReview(completionEnv);
+    } catch (error) {
+      try { debug.log('task-agent', 'review-completion-rejudge-failed', { reason: String(error).slice(-300) }, { level: 'warn' }); } catch { /* fail-soft */ }
+    }
     if (failed >= 1) process.exitCode = 1;
   });
 
@@ -5822,22 +5867,25 @@ selfCmd
   .description('외부 도구 발화를 elanous 기억에 주입 — origin/git/branch/cwd/시간 태그(회상이 "누가 언제 어디서" 구분). text=--text 또는 stdin')
   .option('-s, --text <text>', '발화 원문(생략 시 stdin)')
   .option('--source <origin>', 'claude-code|codex|gemini|…', 'claude-code')
+  .option('--origin <origin>', '발화 주체: human|agent (기본 agent)')
   .option('--session <id>', '세션 id')
   .option('--git-hash <hash>', '발화 시점 git HEAD(short)')
   .option('--branch <name>', 'git 브랜치')
   .option('--cwd <dir>', '작업 디렉토리')
   .option('--ts <iso>', 'ISO 시간(기본 now)')
   .option('-i, --importance <n>', '0-10 현저성', '5')
-  .action(async (opts: { text?: string; source: string; session?: string; gitHash?: string; branch?: string; cwd?: string; ts?: string; importance: string }) => {
+  .action(async (opts: { text?: string; source: string; origin?: string; session?: string; gitHash?: string; branch?: string; cwd?: string; ts?: string; importance: string }) => {
+    if (opts.origin !== undefined && opts.origin !== 'human' && opts.origin !== 'agent') { ui.error('utterance: --origin must be human or agent'); process.exitCode = 1; return; }
     let text = opts.text;
     if (!text) text = await readPipedStdin();   // ★ OBS-T3
     if (!text || !text.trim()) { ui.error('utterance: --text 또는 stdin 필요'); process.exit(1); }
     // 독립 CLI 프로세스 — 데몬 StoreSink 를 상속 안 하므로 logs.db 싱크를 붙여야
     // injectUtterance 의 `debug.log('memory.utterance','ingress')` 가 logs.db 에 닿음(제1원칙 관측).
-    const { injectUtterance } = await import('./domains/self-awareness.js');
-    const r = injectUtterance({
+    const { recordSelfUtterance } = await import('./cli/self-utterances-cli.js');
+    const r = recordSelfUtterance({
       text: text.trim(),
       origin: opts.source,
+      utteranceOrigin: opts.origin === 'human' ? 'human' : 'agent',
       ...(opts.session ? { sessionId: opts.session } : {}),
       ...(opts.gitHash ? { gitHash: opts.gitHash } : {}),
       ...(opts.branch ? { branch: opts.branch } : {}),
@@ -7704,7 +7752,7 @@ configCmd
   .action(async (path: string | undefined, opts: { reveal?: boolean }) => {
     const { resolveCurrentInstance } = await import('./instance/current.js');
     const instance = resolveCurrentInstance();
-    if (instance.kind === 'test' && instance.layer === 'tree-derived') {
+    if (instance.kind === 'test' && String(instance.layer) === 'tree-derived') {
       console.error('⚠️ test 우주의 config를 읽습니다 — 운영 값은 --config-dir ~/.elanous');
     }
     const cfg = getUserConfig() as unknown as Record<string, unknown>;
@@ -11722,7 +11770,10 @@ async function main(): Promise<void> {
   // 한다. 인터랙티브 TUI 는 데몬 sink 를 상속 안 하므로 안 붙이면 debug.log 가 no-op
   // (제1원칙 관측 갭 · tui-sim 드라이브에서 agent.source 0건으로 실측 2026-07-19).
   // PR#4622(self utterance CLI)·session-cli 미러. fail-open·비블로킹.
+  const bootTimer = (await import('./dashboard/boot-timing.js')).createBootTimer();
+  bootTimer.begin();
   try { await (await import('./domains/standalone-log-sink.js')).registerStandaloneLogSink('tui'); } catch { /* fail-open */ }
+  bootTimer.phase('log-sink');
   // P3(대표 2026-07-26) — footgun 관측을 logs.db 에 도달시킨다. 초반(arg 파싱 前) warnProdSpawnFootgun 은
   //   StoreSink 등록 前이라 debug.log 가 logs.db 미도달이었다(순서 갭). sink 등록 직후 관측만 재발행(stderr 중복 X).
   try { (await import('./instance-root-coherence.js')).warnProdSpawnFootgun({ emit: 'log' }); } catch { /* fail-open */ }
@@ -11732,7 +11783,9 @@ async function main(): Promise<void> {
   // so `elanous self screen` / `/v1/terminals` / (P2) PWA can see the
   // dashboard the user is actually looking at. Off unless this boots
   // (no producer in headless/daemon paths). fail-soft·비블로킹.
+  bootTimer.begin();
   try { (await import('./capture/tui-self-report.js')).startTuiSelfReport(); } catch { /* fail-soft */ }
+  bootTimer.phase('self-report');
 
   // Dashboard handles sync inline — only returns on quit
   // ⛔ stdin 이 TTY 가 아니면 «뜨지 않는다» — 뜨면 readKey 가 엔터를 지어내 초당 수백 프레임을
@@ -11745,7 +11798,14 @@ async function main(): Promise<void> {
       return;
     }
   }
-  await showDashboard(dashboardOpts);
+  bootTimer.begin();
+  await showDashboard({
+    ...dashboardOpts,
+    onFirstFrameRendered: () => {
+      bootTimer.phase('show-dashboard');
+      bootTimer.done();
+    },
+  });
   closeTui();
   // Force exit: the dashboard starts background timers (clipboard
   // poller, shimmer/blink animations) that keep the Bun event loop

package/src/instance/current.ts

@@ -1,9 +1,8 @@
-import { join } from 'node:path';
 import { debug } from '../debug/log.js';
 import { getElanousConfigDirOverride } from '../elanous-config-dir.js';
 import { getTestStateRoot } from '../nexus/paths.js';
-import { findTreeRoot, getAppliedGlobalTestRoot } from '../cli/test-flag.js';
-import { isInstalledCopyScript, treeFromScriptPath } from './leader.js';
+import { getAppliedGlobalTestRoot } from '../cli/test-flag.js';
+import { isInstalledCopyScript } from './leader.js';
 import { prodInstanceRoot, resolveInstance, type InstanceResolution } from './resolve.js';
 
 interface ResolveCurrentInstanceDeps {
@@ -16,15 +15,12 @@ interface ResolveCurrentInstanceDeps {
 
 /** 현재 프로세스의 4층 판정 입력을 모아 순수 리졸버에 전달한다. */
 export function resolveCurrentInstance(deps: ResolveCurrentInstanceDeps = {}): InstanceResolution {
-  const cwd = (deps.cwd ?? (() => process.cwd()))();
   const explicitFlagRoot = (deps.explicitFlagRoot ?? (() =>
     getAppliedGlobalTestRoot() ?? getTestStateRoot() ?? getElanousConfigDirOverride()))();
-  const treeRoot = (process.argv[1] ? treeFromScriptPath(process.argv[1]) : null) ?? findTreeRoot(cwd);
   const resolution = resolveInstance({
     explicitFlagRoot,
     stampedStateDir: (deps.stampedStateDir ?? (() => process.env.ELANOUS_STATE_DIR))(),
     installedCopy: isInstalledCopyScript(),
-    treeTestRoot: treeRoot ? join(treeRoot, '.elanous-test') : null,
     prodRoot: prodInstanceRoot(),
   });
   debug.log('instance.current', 'resolved', { layer: resolution.layer, kind: resolution.kind });

package/src/instance/resolve.ts

@@ -1,9 +1,9 @@
-// 인스턴스 우주: 명시 루트 → 부모 스탬프 → 설치본 → 소스 트리 격리.
+// 인스턴스 우주: 명시 루트 → 부모 스탬프 → 운영 집. 트리 위치는 우주를 고르지 않는다.
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 
 export type InstanceKind = 'prod' | 'test';
-export type ResolutionLayer = 'explicit-flag' | 'parent-stamp' | 'installed' | 'tree-derived' | 'default';
+export type ResolutionLayer = 'explicit-flag' | 'parent-stamp' | 'installed' | 'default';
 
 export interface InstanceResolution {
   kind: InstanceKind;
@@ -50,10 +50,9 @@ export function resolveInstance(deps: ResolveDeps = {}): InstanceResolution {
   }
   const installed = deps.installedCopy ?? isInstalledExecution();
   if (installed) return { kind: 'prod', root: prodRoot, layer: 'installed', why: '설치본으로 실행' };
-  const treeTestRoot = deps.treeTestRoot === undefined ? treeDerivedRootFor(process.cwd()) : deps.treeTestRoot;
-  if (treeTestRoot) return { kind: 'test', root: normRoot(treeTestRoot), layer: 'tree-derived', why: '소스 트리(격리)' };
-  // 레포 밖의 비설치 실행은 운영 권위를 얻지 않는다. 격리 루트를 cwd 에 둔다.
-  return { kind: 'test', root: normRoot(join(process.cwd(), '.elanous-test')), layer: 'default', why: '소스 트리 밖 실행(격리)' };
+  // Explicit --test selects a test root before this resolver runs. A checkout,
+  // worktree, or arbitrary cwd alone never changes the operating house.
+  return { kind: 'prod', root: prodRoot, layer: 'default', why: '명시 시험 우주가 없는 운영 집' };
 }
 
 /** 부모가 도장으로 물려준 우주와 자식이 실제로 쓰는 우주가 다른가. 비어 있는 쪽은 비교하지 않는다. */