elanous 0.2.20 → 0.2.21

package/src/self-dev/launch-preflight.ts

@@ -538,6 +538,9 @@ export interface LaunchPreflightInput {
   readonly askTargetPaths?: readonly string[];
   /** 대상 경로 라벨이 «있는데» 거부된 조각. 0건 막음 문면이 그 이유를 말하게 한다(판정은 안 바꾼다). */
   readonly askTargetPathRejections?: readonly AskTargetPathHintRejection[];
+  /** AUTO-TARGET: machine-suggested target paths dropped because the goal is NOT-GROUNDED (no persistent evidence).
+   *  Non-empty = the goal is a scope card and must not launch an implementation. */
+  readonly notGroundedDroppedTargetPaths?: readonly string[];
   /** ask 원문 경로. 있으면 ask-outside-path 경고만 이 목록과 최종 대상을 비교한다. */
   readonly askOutsidePathHints?: readonly string[];
   /** 이번에 쏠 골의 브랜치 이름. 없으면 형제 PR 축의 경고를 내지 않는다. */
@@ -559,19 +562,31 @@ function emitAskMarkerObservation(result: LaunchPreflightResult): void {
   emittedAskMarkerObservations.add(result);
 }
 
+/** AUTO-TARGET: blocker name for a NOT-GROUNDED goal whose only target paths were machine-suggested (a scope card). */
+export const NOT_GROUNDED_SCOPE_CARD_BLOCKER = '(NOT-GROUNDED 범위 카드)';
+
 export function evaluateLaunchPreflight(input: LaunchPreflightInput): LaunchPreflightResult {
   const paths = [...new Set(input.paths.filter((path) => path.trim().length > 0))];
   const blockers: LaunchPreflightBlocker[] = [];
   const warnings: LaunchPreflightBlocker[] = [];
 
+  // AUTO-TARGET (10-08 canary · TSC-HEAP): a NOT-GROUNDED goal whose only target paths came from the
+  //   harness candidate search is a scope card — refuse it with that reason, not the generic «no label» text.
+  const notGroundedDropped = input.notGroundedDroppedTargetPaths ?? [];
+  const notGroundedDetail = notGroundedDropped.length > 0
+    ? `골이 NOT-GROUNDED(영속 근거 0)라 하니스 후보 검색이 넣은 대상 경로 ${notGroundedDropped.length}개(${notGroundedDropped.slice(0, 3).join(' · ')}${notGroundedDropped.length > 3 ? ' …' : ''})를 대상으로 쓰지 않는다 — 범위 카드: 구현 발사 대상이 아니다 · ask 첫 줄에 사람이 「대상 경로: <파일>」을 적거나 접지 근거를 복구한 뒤 다시 저작`
+    : undefined;
+  if (notGroundedDetail !== undefined && paths.length > 0) {
+    blockers.push({ kind: 'no-target-paths', name: NOT_GROUNDED_SCOPE_CARD_BLOCKER, detail: notGroundedDetail });
+  }
   // ① 모집단이 0이면 «통과»가 아니라 «막는 사유»다(METHOD v32 를 이 코드에도 적용).
   if (paths.length === 0) {
     blockers.push({
       kind: 'no-target-paths',
-      name: '(대상 경로 0)',
+      name: notGroundedDetail !== undefined ? NOT_GROUNDED_SCOPE_CARD_BLOCKER : '(대상 경로 0)',
       // ⛔ 2026-09-23 — 라벨이 «있는데» 조각이 거부된 경우를 「라벨을 넣어라」로 뭉개면 「거부됐다」를 「없다」로 읽게 된다
       //   (실측: `대상 경로: README.md — 설명…` 한 줄 → has-whitespace 로 통째 거부 · 문면은 「넣어라」뿐이었다).
-      detail: (input.askTargetPathRejections?.length
+      detail: notGroundedDetail !== undefined ? notGroundedDetail : (input.askTargetPathRejections?.length
         ? `대상 경로 라벨은 있는데 조각 ${input.askTargetPathRejections.length}개가 거부됐다: ${input.askTargetPathRejections.slice(0, 3).map((r) => `「${r.fragment.length > 40 ? `${r.fragment.slice(0, 40)}…` : r.fragment}」(${r.reason})`).join(' · ')} — 그 줄에는 «경로만» 둔다(설명은 다음 줄)`
         : '골에서 대상 경로를 하나도 못 뽑았다 — ask 첫 줄에 「대상 경로: <파일> · <파일>」을 넣어라')
         + ' — 이 상태의 「위반 0」은 「검사했다」가 아니다 — elanous self author --inspect-target-paths "<문면>"',
@@ -1192,6 +1207,9 @@ export interface AskPreflightDeps {
   readonly askTargetPaths?: (document: string) => readonly string[];
   /** 대상 경로 라벨 «안»에서 거부된 조각(이유 포함). 0건 막음 문면이 「라벨이 없다」와 「있는데 거부됐다」를 가르게 한다. */
   readonly askTargetPathRejections?: (document: string) => readonly AskTargetPathHintRejection[];
+  /** AUTO-TARGET: true when the authored goal is NOT-GROUNDED with no persistent evidence (a scope card).
+   *  Omitted = this distinction is not made (existing behavior). Production wires `isNotGroundedWithoutPersistentEvidence`. */
+  readonly notGroundedWithoutPersistentEvidence?: (document: string) => boolean;
 }
 
 export interface AskPreflightOptions {
@@ -1212,6 +1230,10 @@ export interface AskPreflightOptions {
   readonly plannedBranch?: string;
   /** 저작 전 ask 원문. 주면 기존 ask-marker-check로 형식을 관측하되 발사를 막지 않는다. */
   readonly askText?: string;
+  /** AUTO-TARGET: target paths the harness put into the ask (candidate search), not the human.
+   *  If the authored goal is NOT-GROUNDED without persistent evidence, these paths are dropped and the
+   *  goal stops before launch (`no-target-paths` blocker naming the reason). */
+  readonly machineSuggestedTargetPaths?: readonly string[];
 }
 
 export type PlannedBranchResolution =
@@ -1539,7 +1561,24 @@ export function decideAskPreflight(
     }
   }
   // ⛔ 저작 전에는 pathsOverride 자체가 ask 대상 힌트다. 저작 뒤에는 골에서 뽑은 대상만 역할로 쓴다.
-  const askTargetPaths = opts.pathsOverride ?? (goalDocument && deps.askTargetPaths ? deps.askTargetPaths(goalDocument) : []);
+  const declaredAskTargetPaths = opts.pathsOverride ?? (goalDocument && deps.askTargetPaths ? deps.askTargetPaths(goalDocument) : []);
+  // AUTO-TARGET: a NOT-GROUNDED goal (no persistent evidence) carries no machine-suggested target path.
+  const machineSuggested = new Set((opts.machineSuggestedTargetPaths ?? []).map((path) => path.trim()).filter(Boolean));
+  let notGroundedGoal = false;
+  if (!opts.pathsOverride && goalDocument !== null && machineSuggested.size > 0 && deps.notGroundedWithoutPersistentEvidence) {
+    try { notGroundedGoal = deps.notGroundedWithoutPersistentEvidence(goalDocument); } catch { notGroundedGoal = false; }
+  }
+  const notGroundedDroppedTargetPaths = notGroundedGoal ? declaredAskTargetPaths.filter((path) => machineSuggested.has(path)) : [];
+  const askTargetPaths = notGroundedDroppedTargetPaths.length > 0
+    ? declaredAskTargetPaths.filter((path) => !machineSuggested.has(path))
+    : declaredAskTargetPaths;
+  if (notGroundedDroppedTargetPaths.length > 0) {
+    try {
+      debug.log('harness.preflight', 'not-grounded-target-paths-dropped', { goalFile: opts.goalFile, dropped: notGroundedDroppedTargetPaths });
+    } catch {
+      // Observation never changes the launch decision.
+    }
+  }
   // 저작 뒤에는 접지가 읽은 경로와 선언 대상 경로를 함께 검사한다. 저작 전 pathsOverride는 그대로 쓴다.
   const paths = opts.pathsOverride ?? [...new Set([...tracedPaths, ...askTargetPaths])];
   const askMarkerInspection = opts.askText === undefined
@@ -1677,6 +1716,7 @@ export function decideAskPreflight(
     ...(goalRulersUnknownReason ? { goalRulersUnknownReason } : {}),
     preexistingFailures,
     ...(askTargetPaths.length > 0 ? { askTargetPaths } : {}),
+    ...(notGroundedDroppedTargetPaths.length > 0 ? { notGroundedDroppedTargetPaths } : {}),
     ...(askTargetPaths.length === 0 && goalDocument && deps.askTargetPathRejections
       ? { askTargetPathRejections: deps.askTargetPathRejections(goalDocument) }
       : {}),

package/src/self-dev/release-path-guard.ts

@@ -1,6 +1,9 @@
-// Release path = what publishing reads directly: the release scripts and graph, plus the manifest, release notes and cut schedule
-// in `src/release-loop/`. The checklist store (`checklist.ts`, `feature-store.ts`) is shared ops ledger code — the gate catches its regressions (OP 10-03).
-export const RELEASE_PATH_PREFIXES = ['scripts/release-loop/', 'graphs/release/', 'src/release-loop/manifest', 'src/release-loop/release-note', 'src/release-loop/release-schedule'] as const;
+// Release path = release scripts and graph, manifest, notes and cut schedule, plus gate execution modules
+// imported by scripts/release-loop/gate-node.ts (pod-command-job → pod-pool → pod-lease; pod-bun-cache; pod-install-slots; gate-shards).
+// The checklist store (`checklist.ts`, `feature-store.ts`) remains shared ops ledger code (OP 10-03).
+export const RELEASE_PATH_PREFIXES = ['scripts/release-loop/', 'graphs/release/', 'src/release-loop/manifest', 'src/release-loop/release-note', 'src/release-loop/release-schedule',
+  'src/task-orchestrator/surfaces/pod-command-job.ts', 'src/task-orchestrator/surfaces/pod-pool.ts', 'src/task-orchestrator/surfaces/pod-lease.ts',
+  'src/task-orchestrator/surfaces/pod-bun-cache.ts', 'src/task-orchestrator/surfaces/pod-install-slots.ts', 'src/release-loop/gate-shards.ts'] as const;
 export const RELEASE_PATH_LABEL = 'elanous:release-path';
 
 /** Flatten every GitHub PR file page, including the source of a rename. */
@@ -35,7 +38,7 @@ export function releaseGitDiffPaths(output: string): string[] {
 
 /** Evaluate the paths from the opened PR, not the requested goal or local working tree. */
 export function releasePathHold(paths: readonly string[]): string | undefined {
-  return paths.find((path) => RELEASE_PATH_PREFIXES.some((prefix) => path.startsWith(prefix)));
+  return paths.find((path) => RELEASE_PATH_PREFIXES.some((prefix) => prefix.endsWith('.ts') ? path === prefix : path.startsWith(prefix)));
 }
 
 /** Fixed opening of the hold comment — also how a PR held by several merge surfaces (or polls) is recognised, so it is posted once. */

package/src/self-implement/frozen-merges.ts

@@ -4,6 +4,8 @@ import { createHash } from 'node:crypto';
 import { dirname, join, resolve } from 'node:path';
 import { effectiveInstanceRoot, prodInstanceRoot } from '../instance/resolve.js';
 import { debug } from '../debug/log.js';
+import { enterJourneyNode, exitJourneyNode, passJourneyNode, withJourneyNodeSync } from '../self-dev/graph-journey-nodes.js';
+import { routeJourneyEdge } from '../self-dev/graph-journey-route.js';
 import { beginLandingMerge, type LandingFreeze } from '../release-loop/landing-freeze.js';
 
 /** `manual`: the owning repository could not be determined — a sweep never resumes it; a person does. */
@@ -183,6 +185,26 @@ export function admitLandingMerge(
   hooks: { afterQueue?: () => void } = {},
   claimKey?: { prNumber: number; repoRoot: string; headCommit?: string },
   opts: { prodFreezeRoot?: string; forceReason?: string } = {},
+): LandingAdmission {
+  // HARNESS-FULL-GRAPH — 병합 직전 한 곳의 동결 검사가 그래프 노드 freeze-check(출구: open | frozen | taken)이고,
+  // 동결이면 보류 대기열이 노드 hold 다. 판정은 바꾸지 않는다 — 관측만.
+  const pr = claimKey?.prNumber;
+  enterJourneyNode('freeze-check', { provenance: 'admit-landing-merge', ...(pr === undefined ? {} : { data: { pr } }) });
+  const admission = withJourneyNodeSync('freeze-check', { provenance: 'admit-landing-merge', ...(pr === undefined ? {} : { data: { pr } }) },
+    () => admitLandingMergeUnobserved(heldEntry, root, hooks, claimKey, opts));
+  const freezeLabel = admission.kind === 'merge' ? 'open' : admission.kind === 'held' ? 'frozen' : 'taken';
+  exitJourneyNode('freeze-check', { provenance: 'admit-landing-merge', outcome: freezeLabel, ...(pr === undefined ? {} : { data: { pr } }) });
+  // 2판: 간선 판독을 남긴다(관측). 승인 요구(open→hold) 강제는 0.2.22 — 보류 사유 값이 먼저다(RFC §3).
+  routeJourneyEdge('freeze-check', freezeLabel, { freeze: freezeLabel });
+  return admission;
+}
+
+function admitLandingMergeUnobserved(
+  heldEntry: FrozenMerge | null | (() => FrozenMerge | null),
+  root: string,
+  hooks: { afterQueue?: () => void },
+  claimKey: { prNumber: number; repoRoot: string; headCommit?: string } | undefined,
+  opts: { prodFreezeRoot?: string; forceReason?: string },
 ): LandingAdmission {
   let entry: FrozenMerge | null | undefined;
   const prodFreezeRoot = opts.prodFreezeRoot ?? prodInstanceRoot();
@@ -223,6 +245,7 @@ export function admitLandingMerge(
     if (entry === undefined) entry = typeof heldEntry === 'function' ? heldEntry() : heldEntry; // only built when frozen
     if (!entry) return { kind: 'held', freeze: landing.frozen };
     queueFrozenMerge(entry, root);
+    passJourneyNode('hold', { provenance: 'admit-landing-merge', outcome: 'queued', data: { pr: entry.prNumber } });
     hooks.afterQueue?.();
     const afterQueue = beginLandingMerge(root, new Date(), prodFreezeRoot, opts.forceReason);
     if (afterQueue.frozen) return { kind: 'held', freeze: afterQueue.frozen };

package/src/self-implement/goal-author.ts

@@ -1363,6 +1363,20 @@ export function tracedPathReferences(document: string): TracedPathReference[] {
   return references;
 }
 
+/**
+ * AUTO-TARGET (10-08 canary · TSC-HEAP run-446cdc71): an authored goal whose `## PROBLEM` Situation line says
+ * NOT-GROUNDED has no persistent (Read-verified) evidence — `scqaNarrative` writes NOT-GROUNDED exactly when that
+ * channel is empty, and `## TRACED PATHS` then carries no path. Such a goal is a scope card, not an implementation
+ * goal: any target path it carries was not verified by grounding. Callers that know a path was machine-suggested
+ * (not written by the human) must not launch on it. Lite goals have no Situation line and return false.
+ */
+export function isNotGroundedWithoutPersistentEvidence(document: string): boolean {
+  const problem = markdownSection(document, 'PROBLEM');
+  if (problem === null) return false;
+  const situation = problem.split(/\r?\n/).find((line) => line.startsWith('Situation: '));
+  return situation !== undefined && situation.startsWith('Situation: NOT-GROUNDED') && tracedPathReferences(document).length === 0;
+}
+
 /** Inspect supplied goal text and branch name, optionally validating traced paths through an injected reader. */
 /**
  * Lint findings plus the number of inline invariant markers recognized for judgment candidates.

package/src/self-implement/heal-intake.ts

@@ -3,6 +3,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmdir
 import { dirname, join } from 'node:path';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { debug } from '../debug/log.js';
+import { passJourneyNode } from '../self-dev/graph-journey-nodes.js';
 import { getUserConfig } from '../user-config.js';
 import { psProcessStartMs, START_TOLERANCE_MS } from '../harness/harness-stop.js';
 
@@ -184,6 +185,8 @@ export function recordFailureEvent(event: FailureEvent, root = effectiveInstance
     return false;
   });
   debug.log('heal.intake', 'recorded', { source: event.source, kind: event.kind, ref: event.ref, folded });
+  // HARNESS-FULL-GRAPH — 하니스 런 실패 사건의 접수가 그래프 노드 heal 이다(출구: started | folded).
+  if (event.source === 'harness-run') passJourneyNode('heal', { provenance: 'heal-intake', outcome: folded ? 'folded' : 'started', data: { kind: event.kind, ref: event.ref } });
   if (!folded) {
     const runId = healRunId(event);
     void Promise.resolve().then(() => startLoop(HEAL_GRAPH, { runId, input: { failureEvent: event }, deps: { root } }))

package/src/self-implement/orchestrator.ts

@@ -72,6 +72,7 @@ import { basename, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { homedir } from 'node:os';
 import { enqueueControlMemo, readSoftStopRequestStatus, type SoftStopRequestRead } from '../harness/control-inbox.js';
 import { debug } from '../debug/log.js';
+import { enterJourneyNode, exitJourneyNode, journeyJoinFields, withJourneyNode } from '../self-dev/graph-journey-nodes.js';
 import { classifyGateEnvDeficit, DEFAULT_GATE_ENV_RETRY, GATE_ENV_DEFICIT_HARVESTABLE_MARK, type GateEnvDeficitKind } from './gate-env-retry.js';
 import { recordFailureEvent } from './heal-intake.js';
 import { classifyReworkCapExhaustion, type ReworkCapHealDecision } from './heal-triage.js';
@@ -975,6 +976,8 @@ export interface SelfImplementSeams {
   readSoftStopRequestStatus?: (spaceId: string) => SoftStopRequestRead;
   /** Parent harness space whose durable stop marker is read. Tests inject this; production uses `getHarnessSpace()`. */
   parentSoftStopSpaceId?: string;
+  /** Real, created worktree's soft-stop target; observation only, never guesses a space. */
+  onSoftStopSpaceReady?: (spaceId: string) => void;
   /** disposable worktree 생성 → 경로·브랜치 ⊕ **어디서 갈랐나**(관측용).
    *  ⚠️ 관측 3필드는 **선택**이다 — 시임은 주입점이고, 테스트 더블에게 git SHA 를 지어내라고
    *  요구하면 계약이 아니라 부담이 된다. 실 시임(`defaultSeams`)은 항상 채운다.
@@ -3805,6 +3808,8 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
     const attemptOrdinal = readRunAttemptOrdinal(runId);
     const identified = {
       ...graphIdentity,
+      // HARNESS-FULL-GRAPH — 앞단 여정 걸음(runId 없음)과 이 런의 걸음을 잇는 조인 키.
+      ...journeyJoinFields(),
       ...data,
       attemptOrdinal,
     };
@@ -5019,6 +5024,9 @@ async function runSelfImplementInner(
   //   그래서 getHarnessSpace() 만 보면 운영에서 늘 undefined 이고 정지 확인이 «한 번도» 안 돈다(#20040 착지 직후 실측).
   //   `self send <space> --stop` 이 겨냥하는 것은 자식의 공간 = 워크트리 이름이다(아래 activeChildInboxId 와 같은 식 · dev-cli.ts recordRestart 폴백과 같다).
   const parentSoftStopSpaceId = s.parentSoftStopSpaceId || getHarnessSpace()?.id || normalizeSpaceId(basename(wt.path)) || undefined;
+  if (parentSoftStopSpaceId) {
+    try { s.onSoftStopSpaceReady?.(parentSoftStopSpaceId); } catch { /* UI registration must not break execution */ }
+  }
   const readParentSoftStop = s.readSoftStopRequestStatus ?? readSoftStopRequestStatus;
   const honorParentSoftStop = (
     beforeNode: 'gate' | 'review' | 'rework' | 'open-pr',
@@ -8088,7 +8096,14 @@ async function runSelfImplementInner(
       }
       const defaultBranch = resolveDefaultBranchTarget(s.defaultBranchRef ?? defaultBranchRef, wt.path).target ?? undefined;
       progress('merged', formatAutoMergeSuccessMessage({ prNumber: pr.number, mergedBase, defaultBranch }));
-      await runPostMergeCleanup(s.postMergeCleanup, wt.path, wt.branch, opts.goalFile, mergedBase && defaultBranch && displayBranchName(mergedBase) === displayBranchName(defaultBranch) ? defaultBranch : undefined, observe);
+      // HARNESS-FULL-GRAPH — 회수도 그래프 노드(cleanup)다. 결과 = completed | preserved | failed.
+      let cleanupOutcome = 'completed';
+      enterJourneyNode('cleanup', { provenance: 'post-merge', runId });
+      await withJourneyNode('cleanup', { provenance: 'post-merge', runId }, () => runPostMergeCleanup(s.postMergeCleanup, wt.path, wt.branch, opts.goalFile, mergedBase && defaultBranch && displayBranchName(mergedBase) === displayBranchName(defaultBranch) ? defaultBranch : undefined, (event, data) => {
+        if (event.startsWith('post-merge-cleanup-')) cleanupOutcome = event.slice('post-merge-cleanup-'.length);
+        observe(event, data);
+      }));
+      exitJourneyNode('cleanup', { provenance: 'post-merge', runId, outcome: cleanupOutcome });
       const mergedLedger = (() => {
         try { return loadRunLedger(runId); } catch { return null; }
       })();

package/src/self-implement/seams.ts

@@ -972,6 +972,8 @@ export interface DefaultSeamsOptions {
   signal?: AbortSignal;
   /** Parent-surface progress receiver supplied by the dev pipeline. */
   onProgress?: SelfImplementSeams['onProgress'];
+  /** Relay the actual worktree soft-stop target to the invoking surface. */
+  onSoftStopSpaceReady?: SelfImplementSeams['onSoftStopSpaceReady'];
   /** ⑤ HITL — PR 승인 게이트. ★fail-closed: 생략 시 PR 안 열림(자동 승인 없음). 실전 필수. */
   approvePr?: SelfImplementSeams['approvePr'];
   /** gate 스텝(기본 ['test']). */
@@ -1394,6 +1396,7 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
   };
   return {
     ...(o.onProgress ? { onProgress: o.onProgress } : {}),
+    ...(o.onSoftStopSpaceReady ? { onSoftStopSpaceReady: o.onSoftStopSpaceReady } : {}),
     ...(escalateGoalClarifications ? { escalateGoalClarifications } : {}),
     queryChildProviderErrors,
     persistPrBodyArtifact: (input) => createArtifactStore().put('block', input.body, {

package/src/self-implement/self-implement-runtime.ts

@@ -55,6 +55,13 @@ interface SelfImplementRuntimeDeps {
 }
 let runtimeDeps: SelfImplementRuntimeDeps = {};
 
+// TUI-only observer. The tool call id is furnished by the actual dispatcher;
+// other surfaces and calls without an id cannot register a stop target.
+let softStopSpaceObserver: ((toolCallId: string, spaceId: string) => void) | null = null;
+export function setSelfImplementSoftStopSpaceObserver(observer: typeof softStopSpaceObserver): void {
+  softStopSpaceObserver = observer;
+}
+
 /** 자식 헤드리스 elanous 의 config/state 격리 + 구현 대기 상한을 주입. */
 export function setSelfImplementRuntimeDeps(d: SelfImplementRuntimeDeps | null): void {
   runtimeDeps = d ?? {};
@@ -711,6 +718,11 @@ export const selfImplementRuntime: ToolRuntime<SelfImplementRuntimeRequest, Self
       ...(runtimeDeps.implementMaxWaitSec ? { implementMaxWaitSec: runtimeDeps.implementMaxWaitSec } : {}),
       ...(approvePr ? { approvePr } : {}),
       onProgress: resolveHarnessProgressSink(ctx),
+      ...(ctx.surface === 'tui' && ctx.toolCallId && softStopSpaceObserver ? {
+        onSoftStopSpaceReady: (spaceId: string) => {
+          try { softStopSpaceObserver?.(ctx.toolCallId!, spaceId); } catch { /* UI observer cannot break harness */ }
+        },
+      } : {}),
     });
 
     const runnableDocumentReferences = documentReferences.filter(({ result }) => result.kind !== 'outside-repository');

package/src/session-runtime/index.ts

@@ -162,6 +162,8 @@ export interface SessionPostureSnapshot {
 
 export interface SessionRuntimeDispatchDeps {
   signal?: AbortSignal;
+  /** Current LLM tool call, for correlating a foreground harness stop target with the TUI call. */
+  toolCallId?: string;
   userText?: string;
   modelFamily?: ModelFamily;
   /** Parent Agent capability context for an inline runtime fallback. */
@@ -183,7 +185,7 @@ export interface SessionRuntimeDispatchDeps {
   // scheduler-retirement R1 의 LLM tool unwire 후 모두 no-op stub 였고
   // 본 PR 에서 정식 폐기.
   getToolRuntime(name: string): ToolRuntime<Record<string, unknown>, ToolRunResult> | undefined;
-  dispatchToolRuntime(name: string, args: Record<string, unknown>): Promise<unknown>;
+  dispatchToolRuntime(name: string, args: Record<string, unknown>, toolCallId?: string): Promise<unknown>;
   dispatchPluginTool(name: string, args: Record<string, unknown>): Promise<
     { ok: true; result: unknown } | { ok: false; error: string }
   >;
@@ -2166,7 +2168,7 @@ export async function dispatchSessionRuntimeTool(
   //    registered runtimes) and drops `pathPolicy` on the floor.
   const nativeRuntime = nativeRule?.preferRuntime ? deps.getToolRuntime(name) : undefined;
   if (nativeRuntime) {
-    const result = await deps.dispatchToolRuntime(name, normalizedArgs);
+    const result = await deps.dispatchToolRuntime(name, normalizedArgs, deps.toolCallId);
     rememberCandidateListingResult(name, normalizedArgs, result, scopedAnalysis, deps.searchPlannerState);
     return result;
   }
@@ -2201,7 +2203,7 @@ export async function dispatchSessionRuntimeTool(
   if (rt) {
     const isPtyTool = name.startsWith('PtyShell') || name.startsWith('pty_shell');
     if (!isPtyTool || deps.ptyDashboardOn) {
-      const result = await deps.dispatchToolRuntime(name, normalizedArgs);
+      const result = await deps.dispatchToolRuntime(name, normalizedArgs, deps.toolCallId);
       rememberCandidateListingResult(name, normalizedArgs, result, scopedAnalysis, deps.searchPlannerState);
       return result;
     }

package/src/shell-env-bootstrap.ts

@@ -55,6 +55,11 @@ import { basename } from 'node:path';
 import { debug } from './debug/log.js';
 
 const TIMEOUT_MS = 3000;
+// An interactive shell (`-i`) ignores SIGTERM, so the default timeout signal never ends it: the
+// capture then blocks until the rc files finish. 10-08 TUI-BOOT-60: a stale pyenv rehash lock made
+// every `zsh -l -i` wait 60 s, and the «3 s» capture held the TUI boot for ~65 s. SIGKILL makes the
+// timeout real.
+const TIMEOUT_SIGNAL = 'SIGKILL' as const;
 const POSIX_SHELLS = new Set(['zsh', 'bash', 'fish', 'sh', 'dash', 'ksh']);
 
 let cached: Record<string, string> | null = null;
@@ -126,6 +131,7 @@ export function runPrintenvCapture(): Record<string, string> | null {
       env: seedEnv,
       encoding: 'utf8',
       timeout: TIMEOUT_MS,
+      killSignal: TIMEOUT_SIGNAL,
       stdio: ['ignore', 'pipe', 'pipe'],
       // Don't inherit our stdio — rc files that run `clear` or issue
       // OSC sequences would corrupt our TUI output otherwise.
@@ -133,6 +139,8 @@ export function runPrintenvCapture(): Record<string, string> | null {
   } catch {
     return null;
   }
+  // ETIMEDOUT with status 0 = the shell outlived the timeout; never trust a late capture.
+  if (res.error) return null;
   if (res.status !== 0 && res.status !== null) return null;
   if (res.signal) return null;
   return acceptCapture(typeof res.stdout === 'string' ? res.stdout : '');
@@ -149,10 +157,16 @@ export async function warmCapturedEnv(spawn: typeof Bun.spawn = Bun.spawn): Prom
   const start = Date.now();
   try {
     const proc = spawn([seed.shell, '-l', '-i', '-c', 'printenv'], { env: seed.seedEnv as Record<string, string>, stdin: 'ignore', stdout: 'pipe', stderr: 'ignore' });
-    const timer = setTimeout(() => proc.kill(), TIMEOUT_MS);
-    const [out, code] = await Promise.all([new Response(proc.stdout as ReadableStream).text(), proc.exited]);
+    // A grandchild (e.g. a pyenv rehash) can keep the stdout pipe open after the shell is killed,
+    // so the timeout settles the race itself instead of waiting for EOF.
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const timedOut = new Promise<null>((resolve) => {
+      timer = setTimeout(() => { proc.kill(TIMEOUT_SIGNAL); resolve(null); }, TIMEOUT_MS);
+    });
+    const finished = Promise.all([new Response(proc.stdout as ReadableStream).text(), proc.exited]);
+    const result = await Promise.race([finished, timedOut]);
     clearTimeout(timer);
-    const parsed = code === 0 ? acceptCapture(out) : null;
+    const parsed = result && result[1] === 0 ? acceptCapture(result[0]) : null;
     if (captured) return cached !== null; // a synchronous capture won the race
     if (!parsed) return false;
     cached = parsed;

package/src/task-agent/card-evidence.ts

@@ -139,6 +139,12 @@ async function defaultLoadLedger(): Promise<(runId: string) => RunLedgerEntry[]
   // 연합 목록을 못 읽으면 이 우주만 읽되, 여기서 못 찾으면 «없음»이 아니라 실패로 올린다(card-bind-failed).
   let federationFailure: unknown;
   try { dirs = [...new Set([...dirs, ...resolveFederatedRunLedgerDirectories({})])]; } catch (error) { federationFailure = new Error(`federated run-ledger lookup failed: ${error instanceof Error ? error.message : String(error)}`); }
+  // HARNESS-PARENT-ON-MSB1: 원격 부모 런의 원장 거울(`tasks show` 가 ssh 로 당긴다) — 이 우주 ⊕ 연합 «뒤»에만 붙는다.
+  try {
+    const { remoteLedgerMirrorDirs } = await import('./parent-host.js');
+    const { prodInstanceRoot } = await import('../instance/resolve.js');
+    dirs = [...new Set([...dirs, ...remoteLedgerMirrorDirs(prodInstanceRoot())])];
+  } catch { /* 거울이 없으면 종전 그대로 */ }
   return ledgerLoader(dirs, (runId, dir) => loadRunLedger(runId, dir), federationFailure);
 }