elanous 0.2.40 → 0.2.42

package/src/self-implement/orchestrator.ts

@@ -106,10 +106,12 @@ export function formatAutoMergeSuccessMessage(input: {
 import { GoalRunStore, insertGoalRunRecord, type GoalPriorRuns } from './goal-run-store.js';
 import { writeGoalRunRecordFragment } from './goal-execution-records.js';
 import { getUserConfig } from '../user-config.js';
-import { appendRunLedgerEntry, loadRunLedger, parseRunShardIdentity, queryRunChain, type RunChainShardSibling, type RunLedgerEntry, type RunLedgerWriter, type RunOriginData, type RunShardIdentity } from './run-ledger.js';
-import { classifyMergeHoldStop, forgetRunStop, isRunStopClass, readRunStopRecord, recordRunStop, runStopRecorded } from './run-stop.js';
-import { autohealFromStop, parseAutohealMode, type AutohealActions, type AutohealResult } from './stop-autoheal.js';
-import { recordParentNeedsOwnerVisit } from './doctor-visit.js';
+import { appendRunLedgerEntry, loadRunLedger, parseRunShardIdentity, queryRunChain, runLedgerDir, type RunChainShardSibling, type RunLedgerEntry, type RunLedgerWriter, type RunOriginData, type RunShardIdentity } from './run-ledger.js';
+import { buildRunStopTerminalEvidence, classifyMergeHoldStop, classifyTerminalHarnessFailure, forgetRunStop, isRunStopClass, readRunStopRecord, recordRunStop, runStopRecorded } from './run-stop.js';
+import { autohealFromStop, parseAutohealMode, pickAutohealAction, type AutohealActions, type AutohealResult } from './stop-autoheal.js';
+import { operationalAutohealActions } from './stop-autoheal-operational.js';
+import { recordParentNeedsOwnerVisit, runDoctorHandoff } from './doctor-visit.js';
+import { readRunChart, recordRunChartDecision, RUN_DOCTOR_HANDOFF_INPUT_PREFIX } from './run-chart.js';
 import { emitSessionEvent, type SessionEventInput } from '../context-bus/session-events.js';
 import { decideLineageSupersede, lineageSupersedeCloseComment, type LineageSupersedeOpenDraft } from './lineage-supersede.js';
 import { basename, isAbsolute, join, relative, resolve, sep } from 'node:path';
@@ -136,7 +138,7 @@ import { boundaryGlobs, boundaryViolations } from './goal-boundary.js';
 import { askAtExecution, type ExecutionClarificationResult } from './execution-clarification.js';
 import { decideScopeExpansion, renderScopeExpansionSection, SCOPE_EXPANSION_CAP, type ScopeExpansion, type ScopeStopReason } from './scope-adjacency.js';
 import { targetScopedGoalText } from './goal-text-path-scope.js';
-import { selectKnowhowPack } from './knowhow-pack.js';
+import { selectKnowhowPack, selectHealKnowhowPack } from './knowhow-pack.js';
 import { declaredNewFilePaths } from './goal-new-paths.js';
 import { dropStaleReverts, type RevertGuardResult } from './revert-guard.js';
 import type { SelfDevGoalType } from '../self-dev/orchestrate.js';
@@ -321,7 +323,14 @@ import { buildRuntimeOverlayState } from './graph-overlay-condition.js';
 import { activeTemplate, decideTemplate, graphAuthorityFields, nodeNameForStage, overlayDecisionObservation, resolveGraphAuthorityForUserConfig, routeGate, visitBudgetOf } from './graph-authority.js';
 import type { GraphTemplate } from './graph-templates.js';
 import { defaultOverlaysDir, loadGraphOverlays, type GraphOverlaySpec } from './graph-overlay-yaml.js';
-import { graphIdentityOf, measureL0Coverage, pipelineNodeEntryPayload } from './graph-templates.js';
+import { defaultGraphsDir, graphIdentityOf, measureL0Coverage, pipelineNodeEntryPayload } from './graph-templates.js';
+import {
+  buildStageNodeContext,
+  resolveGraphStageUnits,
+  stageNodeContextObservation,
+  stageUnitDrift,
+  type StageNodeContext,
+} from './graph-stage-units.js';
 import { AMBIGUOUS_STAGES, checkPipelineTraversal, nodesForStage, pipelineGraphIdentity, TERMINAL_STAGES_BY_NODE, type PipelineNodeId, type PipelineTraversalCheck } from './pipeline-shape.js';
 import { appendGateWorktreeFreshnessEvidence, gateEvidenceNote } from '../harness/review-adapter.js';
 import { diffHeaderPaths } from '../agent-substrate/self-review-cli.js';
@@ -348,6 +357,9 @@ import {
 } from '../ask-user-question/tool.js';
 import { acquireClarificationResolverLease, decideClarificationResolverInstall } from './clarification-resolver-lease.js';
 import { inspectCodexRotation } from '../oauth/codex-account-store.js';
+import { resolveGrokCredential } from '../grok/credential.js';
+import { resolveChildLlmPreference } from './child-llm-preference.js';
+import { reselectChildForRework } from './rework-child-provider.js';
 import { resolveDefaultProvider } from '../llm.js';
 import { createWidgetAskUserResolver } from '../expression/widget/adapters/ask-user-resolver.js';
 import { createNodeReadlineHost } from '../expression/widget/readline-host.js';
@@ -1061,12 +1073,16 @@ export interface SelfImplementSeams {
   stopAutohealActions?: AutohealActions;
   /** STOP-AUTOHEAL — one-attempt guard reader. Default: real run ledger, or none when `writeRunLedger` is injected. */
   stopAutohealLoadLedger?: (runId: string) => readonly RunLedgerEntry[] | null;
+  /** Supervisor heal delivery history reader; defaults to the run ledger unless a test injects a writer. */
+  healPackLoadLedger?: (runId: string) => readonly RunLedgerEntry[] | null;
   /** STOP-AUTOHEAL — observes each dispatcher result (tests). */
   onStopAutoheal?: (result: AutohealResult) => void;
   /** Optional context-journal sink for isolated runs. */
   emitContextEvent?: (input: SessionEventInput) => void;
   /** Registers this run as an ephemeral loop-agent asset; failures are observed but never affect execution. */
   registerLoopAgent?: (input: LoopAgentInput) => void;
+  /** Executes a persisted run-doctor supervisor handoff; injectable to verify the parent delivery route. */
+  runDoctorHandoff?: typeof runDoctorHandoff;
   /** Wraps implementation and gate promises with their effective wall-clock timeout; tests observe the actual stage budgets. */
   withStepTimeout?: <T>(promise: Promise<T>, ms: number, step: keyof StepTimeouts) => Promise<T>;
   /** Samples the one-minute machine load at the end of a gate observation. */
@@ -1083,7 +1099,7 @@ export interface SelfImplementSeams {
    * store, the orchestrator must not claim the child had zero provider failures.
    */
   queryChildProviderErrors?: (input: { runId: string; sinceMs: number; untilMs: number }) => Promise<
-    | { status: 'found'; providerErrorCount: number; credentialFailureCount: number; lastProviderError?: { provider?: string; message?: string }; lastCredentialFailure?: { provider?: string; message?: string } }
+    | { status: 'found'; providerErrorCount: number; credentialFailureCount: number; lastProviderError?: { provider?: string; model?: string; message?: string; observedAt?: string }; lastCredentialFailure?: { provider?: string; model?: string; message?: string; observedAt?: string } }
     | { status: 'none' }
     | { status: 'unavailable'; reason?: string }
   >;
@@ -2198,6 +2214,8 @@ export interface SelfImplementOptions {
   runId?: string;
   /** Authored goal document's stable identity, carried into self-implement observations when present. */
   goalId?: string;
+  /** Stable heal-cell identity propagated across supervisor reauthor retries. */
+  healCellKey?: string;
   /** Optional opaque ID for joining this request with correlated execution records. */
   correlationId?: string;
   /** Optional opaque ID for the parent correlation in a nested request. */
@@ -3014,8 +3032,8 @@ export function queryStructuredChildProviderErrors(
     });
     if (rows.length === 0) return { status: 'none' };
     let credentialFailureCount = 0;
-    let lastProviderError: { provider?: string; message?: string } | undefined;
-    let lastCredentialFailure: { provider?: string; message?: string } | undefined;
+    let lastProviderError: { provider?: string; model?: string; message?: string; observedAt?: string } | undefined;
+    let lastCredentialFailure: { provider?: string; model?: string; message?: string; observedAt?: string } | undefined;
     for (const row of rows) {
       let data: Record<string, unknown> | undefined;
       try {
@@ -3024,7 +3042,9 @@ export function queryStructuredChildProviderErrors(
       } catch { /* malformed payload is still a structured router-error record */ }
       const detail = {
         ...(typeof data?.provider === 'string' ? { provider: data.provider } : {}),
+        ...(typeof data?.model === 'string' ? { model: data.model } : {}),
         ...(typeof data?.message === 'string' ? { message: data.message } : {}),
+        ...(typeof row.ts === 'string' ? { observedAt: row.ts } : {}),
       };
       lastProviderError = detail;
       if (data?.authRejected === true) {
@@ -3568,19 +3588,32 @@ async function autohealRecordedStop(stopEntry: RunLedgerEntry, s: SelfImplementS
   try {
     const record = readRunStopRecord(stopEntry);
     if (!record) return;
+    const chartDir = runLedgerDir();
+    const chartBefore = readRunChart(stopEntry.runId, 'macrophage', chartDir);
+    const chartStopKey = JSON.stringify([stopEntry.timestamp, record.site ?? '', record.class, record.cause, record.evidenceRef]);
+    try { debug.log('harness.heal', 'symptom', { runId: stopEntry.runId, class: record.class, cause: record.cause, evidenceRef: record.evidenceRef }); } catch { /* observation is fail-soft */ }
+    const pick = pickAutohealAction(record.class);
+    try { debug.log('harness.heal', 'prescription', { runId: stopEntry.runId, class: record.class, action: pick.action, source: pick.source, ...(pick.overlayId ? { overlayId: pick.overlayId } : {}) }); } catch { /* observation is fail-soft */ }
     const mode = parseAutohealMode((await import('../user-config.js')).getUserConfig().tools.selfImplement.autoheal?.mode);
     const loadLedger = s?.stopAutohealLoadLedger ?? (s?.writeRunLedger ? () => null : undefined);
+    // A test ledger must never trigger a production host gate. Explicit seams override operational hands.
+    const actions = s?.writeRunLedger ? s.stopAutohealActions
+      : { ...operationalAutohealActions({ repoRoot: process.cwd() }), ...s?.stopAutohealActions };
     const result = await autohealFromStop({ runId: stopEntry.runId, ...(stopEntry.goalId ? { goalId: stopEntry.goalId } : {}), record }, {
       mode,
       knowhowCandidateDir: join(effectiveInstanceRoot(), 'self-implement', 'knowhow-candidates'),
-      ...(s?.stopAutohealActions ? { actions: s.stopAutohealActions } : {}),
+      ...(actions ? { actions } : {}),
       ...(loadLedger ? { loadLedger } : {}),
       ...(s?.writeRunLedger ? { writeLedger: s.writeRunLedger } : {}),
     });
+    try { debug.log('harness.heal', 'outcome', { runId: stopEntry.runId, class: result.class, action: result.action, mode: result.mode, outcome: result.outcome, ...(result.reason ? { reason: result.reason } : {}), ...(result.detail ? { detail: result.detail } : {}) }); } catch { /* observation is fail-soft */ }
+    recordRunChartDecision({ runId: stopEntry.runId, device: 'macrophage', stopKey: chartStopKey,
+      observed: `${record.class}: ${record.cause}`, verdict: result.action, action: result.outcome,
+      handoff: result.action === 'needs-owner' ? 'outer-supervisor' : null,
+      why: result.reason ?? result.detail ?? record.cause, readStopKeys: chartBefore.map((cell) => cell.stopKey), dir: chartDir });
     if (result.action === 'needs-owner') {
       try {
-        const stopKey = JSON.stringify([stopEntry.timestamp, record.site ?? '', record.class, record.cause, record.evidenceRef]);
-        const visit = recordParentNeedsOwnerVisit({ runId: stopEntry.runId, stopKey, evidence: result.reason ?? record.cause });
+        const visit = recordParentNeedsOwnerVisit({ runId: stopEntry.runId, stopKey: chartStopKey, evidence: result.reason ?? record.cause });
         if (visit.status === 'missing-ledger') {
           debug.log('run-doctor', 'visit-failed', { runId: stopEntry.runId, from: 'parent', symptom: 'needs-owner', error: 'run-ledger-missing' });
         }
@@ -3594,6 +3627,54 @@ async function autohealRecordedStop(stopEntry: RunLedgerEntry, s: SelfImplementS
   }
 }
 
+async function dispatchTerminalHarnessHeal(input: {
+  result: SelfImplementResult;
+  runId: string;
+  goalId?: string;
+  shardIdentity: RunShardIdentity;
+  seams: SelfImplementSeams;
+}): Promise<void> {
+  const { result, runId, goalId, shardIdentity, seams } = input;
+  const mergeHeld = Boolean(result.mergeReason && result.mergeReason !== 'auto');
+  if (result.outcome !== 'abandoned' && result.outcome !== 'budget-exhausted' && result.stage !== 'timed-out' && !mergeHeld) return;
+  if (runStopRecorded(runId)) return;
+  const stopClass = mergeHeld ? classifyMergeHoldStop(result.mergeReason) : classifyTerminalHarnessFailure({
+    stage: result.stage,
+    cause: result.detail,
+    mergeReason: result.mergeReason,
+    abandonedClassification: result.abandonedClassification?.classification,
+    providerErrorCategory: result.providerErrors?.category,
+    supervisorVerdict: result.supervisorVerdict,
+  });
+  let priorLedger: RunLedgerEntry[] = [];
+  try { priorLedger = loadRunLedger(runId) ?? []; } catch { /* terminal observation must not change the run result */ }
+  const terminalEvidence = buildRunStopTerminalEvidence({
+    stage: result.stage,
+    node: result.node,
+    outcome: result.outcome,
+    detail: result.detail,
+    terminationReason: result.terminationReason,
+    providerErrorCategory: result.providerErrors?.category,
+    entries: priorLedger,
+  });
+  let stopEntry: RunLedgerEntry | undefined;
+  try {
+    stopEntry = recordRunStop({
+      runId,
+      ...(goalId ? { goalId } : {}),
+      shardIdentity,
+      site: mergeHeld ? 'merge-hold' : `terminal-${result.stage}`,
+      class: stopClass,
+      // Never copy free-form provider/child text into the durable stop summary.
+      cause: mergeHeld ? `merge held: ${result.mergeReason}` : `terminal failure: ${result.stage}; ${terminalEvidence.reasonCode}`,
+      evidenceRef: result.prUrl ?? `run-ledger:${runId}:${result.stage}`,
+      nextMove: `Existing heal ladder: ${stopClass}; failure disposition remains until its prescribed action resolves`,
+      terminalEvidence,
+    }, seams.writeRunLedger ?? appendRunLedgerEntry);
+  } catch { /* stop observation cannot change the run outcome */ }
+  if (stopEntry) await autohealRecordedStop(stopEntry, seams);
+}
+
 export function measureReviewRework(counts: readonly number[], findings: readonly (readonly RecurrenceFinding[])[]): ReviewRework {
   const deltas = counts.slice(1).map((count, index) => Math.sign(count - counts[index]!));
   const directions = deltas.filter((delta) => delta !== 0);
@@ -3761,17 +3842,20 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
   let lastCredentialFailureSeq = 0;
   let lastFailedGateSeq = 0;
   let lastMustFixReviewSeq = 0;
+  let providerErrorAtLastGate: string | undefined;
   const recordFailureVerdict = async (kind: 'gate' | 'review'): Promise<void> => {
     // Capture child errors at the verdict boundary, not when terminal reporting eventually reads them.
     await mergeChildProviderErrors();
+    providerErrorAtLastGate = lastProviderErrorSeq > Math.max(lastFailedGateSeq, lastMustFixReviewSeq)
+      ? lastProviderError?.message : undefined;
     if (kind === 'gate') lastFailedGateSeq = ++failureSequence;
     else lastMustFixReviewSeq = ++failureSequence;
   };
   const latestVerdictSeq = (): number => Math.max(lastFailedGateSeq, lastMustFixReviewSeq);
   const hasCurrentProviderError = (): boolean => providerErrorCount > 0 && lastProviderErrorSeq > latestVerdictSeq();
   const hasCurrentCredentialFailure = (): boolean => credentialFailureCount > 0 && lastCredentialFailureSeq > latestVerdictSeq();
-  let lastProviderError: { provider?: string; message?: string } | undefined;
-  let lastCredentialFailure: { provider?: string; message?: string } | undefined;
+  let lastProviderError: { provider?: string; model?: string; message?: string; observedAt?: string } | undefined;
+  let lastCredentialFailure: { provider?: string; model?: string; message?: string; observedAt?: string } | undefined;
   let childProviderErrorQueryStatus: 'found' | 'none' | 'unavailable' | 'not-configured' = 'not-configured';
   let queriedProviderErrorCount = 0;
   let queriedCredentialFailureCount = 0;
@@ -3808,18 +3892,43 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
       childProviderErrorQueryStatus = 'unavailable';
     }
   };
+  const observeFailureClassificationInputs = (result: SelfImplementResult): void => {
+    if (!isAbandonedClassificationOutcome(result.outcome)) return;
+    observeOuter('failure-classification-inputs', {
+      stage: result.stage,
+      node: result.node,
+      outcome: result.outcome,
+      classification: result.abandonedClassification?.classification ?? null,
+      classificationBasis: result.abandonedClassification?.classificationBasis ?? null,
+      childProviderErrorQueryStatus,
+      providerErrorCount,
+      credentialFailureCount,
+      queriedProviderErrorCount,
+      queriedCredentialFailureCount,
+      lastProviderError: lastProviderError ? { provider: lastProviderError.provider ?? null, model: lastProviderError.model ?? null, observedAt: lastProviderError.observedAt ?? null } : null,
+      lastCredentialFailure: lastCredentialFailure ? { provider: lastCredentialFailure.provider ?? null, model: lastCredentialFailure.model ?? null, observedAt: lastCredentialFailure.observedAt ?? null } : null,
+      lastProviderErrorSeq,
+      lastCredentialFailureSeq,
+      lastFailedGateSeq,
+      lastMustFixReviewSeq,
+      currentProviderError: hasCurrentProviderError(),
+      currentCredentialFailure: hasCurrentCredentialFailure(),
+    });
+  };
   const unregisterProviderErrorSink = debug.registerSink({
     name: `self-implement-provider-error-${runId}`,
     emit(record) {
       if (record.category !== 'llm.router.error') return;
       const data = record.data;
       if (!data || typeof data !== 'object') return;
-      const { provider, message } = data as Record<string, unknown>;
+      const { provider, model, message } = data as Record<string, unknown>;
       providerErrorCount++;
       lastProviderErrorSeq = ++failureSequence;
       lastProviderError = {
         ...(typeof provider === 'string' ? { provider } : {}),
+        ...(typeof model === 'string' ? { model } : {}),
         ...(typeof message === 'string' ? { message } : {}),
+        ...(typeof record.ts === 'string' ? { observedAt: record.ts } : {}),
       };
       // ⛔⭐⭐⭐ 자격 거부는 「프로바이더 오류」의 부분집합이지만 ***사람이 할 다음 행동이 다르다***
       //   (2026-08-14 실측 · `[T]` 83차): grok 자식 «둘»이 401 로 죽었는데 부모가 남긴 것은
@@ -4108,6 +4217,7 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
     }
   };
   let terminalResult: SelfImplementResult | undefined;
+  let uncaughtTerminalStop: SelfImplementResult | undefined;
   let reviewReflectRejectedCount: number | undefined;
   const attachReviewReflectionOutcome = <T extends Omit<SelfImplementResult, 'runId'>>(result: T): T & Pick<SelfImplementResult, 'completionStatus' | 'reviewReflectRejectedCount'> => ({
     ...result,
@@ -4287,6 +4397,11 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
       (sessionId) => { terminalSessionId = sessionId; },
       (contract) => { runContract = contract; },
       recordFailureVerdict,
+      () => {
+        const error = providerErrorAtLastGate;
+        providerErrorAtLastGate = undefined;
+        return error;
+      },
       () => providerErrorCount > 0,
       () => credentialFailureCount > 0,
       hasCurrentProviderError,
@@ -4307,6 +4422,7 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
       opts.seams.inspectCodexRotation,
       runProviderName,
     );
+    observeFailureClassificationInputs(addressedResult);
     if (isAbandonedClassificationOutcome(addressedResult.outcome)) logQuotaProvider(addressedResult.quotaExhaustionAssessment);
     observeOuter('child-provider-error-query', { status: childProviderErrorQueryStatus });
     if (lastProviderError) {
@@ -4318,20 +4434,24 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
     }
     terminalResult = withEvidenceCoverage(withMeasuredRework(addressedResult));
     // runSelfImplement is the terminal caller: retain every existing PR/ledger/log observation and append one stop fact.
-    if ((addressedResult.stage === 'aborted' || (addressedResult.mergeReason && addressedResult.mergeReason !== 'auto')) && !runStopRecorded(runId)) {
+    const envDeficitStop = addressedResult.stage === 'gate-failed' && addressedResult.harvestable === true
+      && addressedResult.detail?.includes(GATE_ENV_DEFICIT_HARVESTABLE_MARK) === true;
+    if ((addressedResult.stage === 'aborted' || envDeficitStop || (addressedResult.mergeReason && addressedResult.mergeReason !== 'auto')) && !runStopRecorded(runId)) {
       const reason = addressedResult.mergeReason;
       const aborted = addressedResult.stage === 'aborted';
       let stopEntry: RunLedgerEntry | undefined;
       try {
         stopEntry = recordRunStop({ runId, ...(opts.goalId ? { goalId: opts.goalId } : {}), shardIdentity,
-          site: aborted ? 'implement-aborted' : 'merge-hold',
-          class: aborted ? 'unclassified' : classifyMergeHoldStop(reason), cause: aborted ? 'implement aborted' : `merge held: ${reason}`,
+          site: envDeficitStop ? 'gate-env-deficit' : aborted ? 'implement-aborted' : 'merge-hold',
+          class: envDeficitStop ? 'env-unrelated' : aborted ? 'unclassified' : classifyMergeHoldStop(reason),
+          cause: envDeficitStop ? addressedResult.detail ?? 'gate environment deficit' : aborted ? 'implement aborted' : `merge held: ${reason}`,
           evidenceRef: addressedResult.prUrl ?? `run-ledger:${runId}:${aborted ? 'implemented' : 'merge-decision'}`,
-          nextMove: aborted ? 'Inspect preserved worktree and child summary' : 'Review merge decision and PR before landing',
+          nextMove: envDeficitStop ? 'Measure the preserved PR head in a clean checkout' : aborted ? 'Inspect preserved worktree and child summary' : 'Review merge decision and PR before landing',
         }, opts.seams.writeRunLedger ?? appendRunLedgerEntry);
       } catch { /* stop observation cannot change the run outcome */ }
       if (stopEntry) await autohealRecordedStop(stopEntry, opts.seams);
     }
+    await dispatchTerminalHarnessHeal({ result: addressedResult, runId, ...(opts.goalId ? { goalId: opts.goalId } : {}), shardIdentity, seams: opts.seams });
     observeDeclaredScopeDiff(observeOuter, {
       goalFile: opts.goalFile,
       changedFiles: opts.goalFile && addressedResult.worktreePath
@@ -4420,6 +4540,7 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
       terminalNode = result.node;
       await mergeChildProviderErrors();
       const addressedResult = attachAbandonedClassification(attachReviewReflectionOutcome({ ...result, ...providerErrorsForResult() }), opts.goalFile, hasCurrentProviderError(), hasCurrentCredentialFailure(), opts.seams.inspectCodexRotation, runProviderName);
+      observeFailureClassificationInputs(addressedResult);
       logQuotaProvider(addressedResult.quotaExhaustionAssessment);
       observeOuter('child-provider-error-query', { status: childProviderErrorQueryStatus });
       if (lastProviderError) {
@@ -4429,6 +4550,7 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
         observeOuter('credential-failure-observed', { count: credentialFailureCount, ...lastCredentialFailure });
       }
       terminalResult = withMeasuredRework(addressedResult);   // ⛔ 이 분기(StepTimeoutError)는 스코프가 달라 달성 근사값은 «없다»(0 으로 채우지 않는다)
+      await dispatchTerminalHarnessHeal({ result: addressedResult, runId, ...(opts.goalId ? { goalId: opts.goalId } : {}), shardIdentity, seams: opts.seams });
       observeDeclaredScopeDiff(observeOuter, {
         goalFile: opts.goalFile,
         changedFiles: opts.goalFile && addressedResult.worktreePath
@@ -4489,9 +4611,12 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
         ...terminalDetail(terminalSessionId),
       },
     });
+    uncaughtTerminalStop = { runId, ok: false, stage: 'aborted', node: terminalNode ?? 'implement', outcome: 'abandoned', detail: safeErrorDescription(e) };
     throw e;
   } finally {
     if (loopRegistered) registerRunLoop('ended');
+    // Persist the outer-exception stop and its prescription before the crashed run-status below.
+    if (uncaughtTerminalStop) await dispatchTerminalHarnessHeal({ result: uncaughtTerminalStop, runId, ...(opts.goalId ? { goalId: opts.goalId } : {}), shardIdentity, seams: opts.seams });
     const terminalStage = terminalResult?.stage ?? 'crashed';
     // A blocked draft may be opened on the first failed attempt, before the
     // normal outcome observer has written its terminal status. Persist the
@@ -4564,6 +4689,10 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
           summary: reworkCap
             ? reworkCapFailureSummary(opts.feature, reworkCap)
             : opts.feature.split(/\r?\n/, 1)[0]?.trim() || `Harness run ${runId} failed`,
+          goalText: opts.feature,
+          ...(opts.goalId ? { goalId: opts.goalId } : {}),
+          ...(opts.goalFile ? { goalFile: opts.goalFile } : {}),
+          ...(opts.healCellKey ? { cellKey: opts.healCellKey } : {}),
           at: new Date().toISOString(),
         });
       }
@@ -4952,6 +5081,38 @@ function reworkCapFailureSummary(feature: string, decision: ReworkCapHealDecisio
   return `${title} [${decision.defectClass} → ${decision.nextAction}] ${evidence}`;
 }
 
+/** ⭐ SELFIMPL-NODE-SEAMS-BACK — 등록 부품(구현·gate·리뷰·git·착지)을 graphs/units 에서 해석하고
+ *  합성 선언을 평탄화해 «하나의 NodeContext» 로 묶는다. ⛔ 실패는 값(reason)으로 낸다 — 실행을 막지 않는다. */
+export function resolveRunStageNodeContext(input: {
+  readonly graphId: string;
+  readonly graphVersion: string;
+  readonly graphsDir: string;
+  readonly runId: string;
+  readonly attempts?: number;
+  readonly round?: number;
+  readonly goalId?: string;
+  readonly goalType?: string;
+}): { readonly nodeContext?: StageNodeContext; readonly reason?: string } {
+  const resolution = resolveGraphStageUnits(input.graphId, input.graphsDir);
+  if (resolution.units.length === 0) {
+    return { reason: resolution.reason ?? 'no-unit-resolved' };
+  }
+  return {
+    nodeContext: buildStageNodeContext({
+      resolution,
+      graphId: input.graphId,
+      graphVersion: input.graphVersion,
+      runId: input.runId,
+      ...(input.attempts === undefined ? {} : { attempts: input.attempts }),
+      ...(input.round === undefined ? {} : { round: input.round }),
+      ...(input.goalId === undefined ? {} : { goalId: input.goalId }),
+      ...(input.goalType === undefined ? {} : { goalType: input.goalType }),
+    }),
+    ...(resolution.reason === undefined ? {} : { reason: resolution.reason }),
+  };
+}
+
+/** 라운드마다 같은 부품이 «그 파일·그 판»인지 — 도는 중에 바뀌면 걸음과 신원이 갈린다. */
 async function runSelfImplementInner(
   opts: SelfImplementOptions,
   identity?: { runId: string; source: ReturnType<typeof resolveRunIdentity>['source'] },
@@ -4988,13 +5149,14 @@ async function runSelfImplementInner(
   hasCredentialFailure: () => boolean = () => false,
   providerErrorCategory: () => NonNullable<SelfImplementResult['providerErrors']>['category'] | undefined = () => undefined,
   onReviewReflectRejected: (rejectedCount: number) => void = () => {},
-  observe: ReturnType<typeof makeRunObserver> = makeRunObserver(identity?.runId ?? resolveRunIdentity({ explicit: opts.runId }).runId, opts.goalId, debug.log.bind(debug), opts.seams.writeRunLedger, shardIdentity),
+  observe?: ReturnType<typeof makeRunObserver>,
   /** ⭐ 「이 런이 «실제로» 어느 두뇌로 돌았나」를 원장까지 나른다 — ⛔ 기록 «시점»에 다시 읽지 않는다
    *  (그러면 「런이 끝날 무렵의 provider」가 되어 `F45` 를 그대로 밟는다). 시작 시점 값을 넘긴다. */
   onActiveProvider: (active: { provider?: string; model?: string; auth?: string }) => void = () => {},
   onSessionCreated: (sessionId: string) => void = () => {},
   onRunContractResolved: (contract: RunContract) => void = () => {},
   onFailureVerdict: (kind: 'gate' | 'review') => Promise<void> = async () => {},
+  providerErrorAtLastGate: () => string | undefined = () => undefined,
   hasObservedProviderError: () => boolean = hasProviderError,
   hasObservedCredentialFailure: () => boolean = hasCredentialFailure,
   hasCurrentProviderError: () => boolean = hasProviderError,
@@ -5005,7 +5167,23 @@ async function runSelfImplementInner(
   onPrAttributed: (number: number) => void = () => {},
   onPrAttributionMismatch: () => void = () => {},
 ): Promise<Omit<SelfImplementResult, 'runId'>> {
+  const runIdentity = identity ?? resolveRunIdentity({ explicit: opts.runId });
+  observe ??= makeRunObserver(runIdentity.runId, opts.goalId, debug.log.bind(debug), opts.seams.writeRunLedger, shardIdentity);
   const s = opts.seams;
+  const deliveredHealPacks = new Set<string>();
+  const healRunId = identity?.runId ?? resolveRunIdentity({ explicit: opts.runId }).runId;
+  try {
+    const entries = (s.healPackLoadLedger ?? (s.writeRunLedger ? () => null : loadRunLedger))(healRunId);
+    for (const entry of entries ?? []) {
+      if (entry.runId !== healRunId || entry.event !== 'supervisor-heal-pack'
+        || !['matched', 'already-delivered'].includes(String(entry.data?.decision))) continue;
+      const { signature, packIds } = entry.data;
+      if (typeof signature !== 'string' || !Array.isArray(packIds)) continue;
+      for (const id of packIds) {
+        if (typeof id === 'string') deliveredHealPacks.add(`${healRunId}:${signature}:${id}`);
+      }
+    }
+  } catch { /* An unavailable history contributes no invented deliveries. */ }
   const pipelineStartedAtMs = Date.now();
   // Graph authority is always ON; retain the resolved event with default provenance.
   // For research documents, its declared docs-only routing intentionally skips the gate.
@@ -5046,9 +5224,16 @@ async function runSelfImplementInner(
       : undefined;
     if (launch && !launch.ok) throw new Error(`graph variant rejected: ${JSON.stringify(launch.rejections)}`);
     const sourceSpec = launch?.ok ? launch.template : baseSpec;
+    // ⭐ unit 선언 근거 — 이 런이 읽은 «대상 경로»(단위 선언) 원문의 내용 해시만 남긴다.
+    //   ⛔ 본문은 로그에도 원장에도 복제하지 않는다(goalContentHash 와 같은 해시-only 예비).
+    //   ⛔ 읽지 못한 경로(신설 파일 등)는 해시를 지어내지 않고 근거에서 뺀다.
+    const unitDeclarations = declaredPremiseScopePaths(opts.feature).flatMap(path => {
+      try { return [{ path, content: readFileSync(resolve(process.cwd(), path), 'utf8') }]; } catch { return []; }
+    });
     // ⭐ 최초 변형 선택 — 골 종류(graphGoalType)·대상 경로 수(declaredPremiseScopePaths) 두 입력만으로
     //   결정론적으로 id·선택 이유를 유도해 검증 결과에 싣는다(종류를 못 읽었으면 지어내지 않는다).
     const variant = createGraphVariant({ template: sourceSpec, goal: `g_${variantRunId.replace(/[^a-z0-9_-]/gi, '_')}`, plan: opts.graphVariantPlan,
+      ...(unitDeclarations.length === 0 ? {} : { unitDeclarations }),
       ...(graphGoalType === undefined ? {} : { goalAnalysis: { goalType: graphGoalType, targetPathCount: declaredPremiseScopePaths(opts.feature).length } }) });
     if (!variant.ok) throw new Error(`graph variant rejected: ${JSON.stringify(variant.rejections)}`);
     variantSpec = variant.template;
@@ -5056,6 +5241,9 @@ async function runSelfImplementInner(
     const graphFile = saveRunGraphVariant(variantRunId, stringify({
       graph_id: variantSpec.graphId, version: variantSpec.version,
       ...(variant.selection === undefined ? {} : { variant_id: variant.selection.variantId, reason: variant.selection.reason }),
+      // 추가 키 — 한 런이 어느 unit 선언 «버전»을 읽었는지. 경로·내용 해시뿐이고 본문은 없다.
+      ...(variant.selection?.unitDeclarations === undefined ? {}
+        : { unit_declarations: variant.selection.unitDeclarations.map(entry => ({ path: entry.path, content_hash: entry.contentHash })) }),
       entry_node: variantSpec.entryNode, terminal_nodes: variantSpec.terminalNodes,
       ...(variantSpec.journeyStages ? { journey_stages: variantSpec.journeyStages } : {}),
       ...(variantSpec.runContract ? { run_contract: variantSpec.runContract } : {}),
@@ -5080,13 +5268,15 @@ async function runSelfImplementInner(
     // ⭐ 저장·diff — 방금 원장 옆에 쓴 선택(id·이유)을 다시 읽어 «같은지» 확인한다(다르면 이 런의 그래프 신원이 거짓).
     if (variant.selection !== undefined) {
       const persisted = loadRunGraphVariant(variantRunId);
-      if (persisted === null || persisted.variantId !== variant.selection.variantId || persisted.reason !== variant.selection.reason) {
+      if (persisted === null || persisted.variantId !== variant.selection.variantId || persisted.reason !== variant.selection.reason
+        || JSON.stringify(persisted.unitDeclarations ?? null) !== JSON.stringify(variant.selection.unitDeclarations ?? null)) {
         throw new Error(`graph variant rejected: persisted selection mismatch: ${JSON.stringify(persisted)}`);
       }
     }
     observe('graph-variant-applied', { graphId: variant.template.graphId, overlayId: variant.overlay.overlayId,
       graphFile, patches: variant.patches,
-      ...(variant.selection === undefined ? {} : { variantId: variant.selection.variantId, variantReason: variant.selection.reason }) });
+      ...(variant.selection === undefined ? {} : { variantId: variant.selection.variantId, variantReason: variant.selection.reason }),
+      ...(variant.selection?.unitDeclarations === undefined ? {} : { unitDeclarations: variant.selection.unitDeclarations }) });
   }
   /** 단계 이름 → 그 템플릿의 노드 이름. */
   const node = (stage: PipelineNodeId): PipelineNodeId => nodeNameForStage(stage, graphTemplate) as PipelineNodeId;
@@ -5103,6 +5293,28 @@ async function runSelfImplementInner(
     onRunContractResolved(runContract);
     observe('graph-run-contract-resolved', { ...graphIdentityOf(graphTemplate), ...runContract, ...runContractAtNode(runContract) });
   }
+  // ⭐ SELFIMPL-NODE-SEAMS-BACK — 등록 부품을 «생산 진입점»에서 해석·평탄화해 하나의 NodeContext 로 만든다.
+  //   ⛔ 이 줄이 없으면 부품은 선언만 있고 걸음에서 안 불린다. 실패는 값으로 남기고 실행은 안 막는다.
+  let nodeContext: StageNodeContext | undefined;
+  {
+    const unitResolution = resolveRunStageNodeContext({
+      graphId: graphTemplate.graphId,
+      graphVersion: graphTemplate.version,
+      graphsDir: defaultGraphsDir(),
+      runId: runIdentity.runId,
+      ...(typeof attemptOrdinal === 'number' ? { attempts: attemptOrdinal } : {}),
+      ...(opts.goalId === undefined ? {} : { goalId: opts.goalId }),
+      ...(graphGoalType === undefined ? {} : { goalType: graphGoalType }),
+    });
+    nodeContext = unitResolution.nodeContext;
+    if (nodeContext === undefined) {
+      if (graphTemplate.graphId === 'self-implement') {
+        observe('graph-stage-units-unresolved', { ...graphIdentityOf(graphTemplate), reason: unitResolution.reason ?? 'no-unit-resolved' });
+      }
+    } else {
+      observe('graph-stage-units-resolved', stageNodeContextObservation(nodeContext));
+    }
+  }
   // ⛔ 승격이 꺼져 있으면 «심지 않는다» — 그러면 예산 관측도 안 난다(운영 원장이 오늘과 같다).
   if (graphAuthority.enabled) onGraphTemplateResolved(graphTemplate);
   // ⛔ 선택을 «전부» 싣는다 — 얹힌 것만 실으면 「왜 안 얹혔나」를 사후에 못 묻는다.
@@ -5116,7 +5328,7 @@ async function runSelfImplementInner(
     // ⛔ 「지금 아는 것」만 준다 — 없는 값을 0 으로 지어내지 않는다(key-absent 가 그것을 말한다).
     let stopClass: import('./run-stop.js').RunStopClass | undefined;
     try {
-      const { runId } = identity ?? resolveRunIdentity({ explicit: opts.runId });
+      const { runId } = runIdentity;
       const entries = loadRunLedger(runId);
       const lastStop = entries?.slice().reverse().find((entry) => entry.event === 'stop');
       if (lastStop && isRunStopClass(lastStop.data.class)) stopClass = readRunStopRecord(lastStop)?.class;
@@ -5136,6 +5348,16 @@ async function runSelfImplementInner(
       ...(variantSpec ? { specs: { [variantSpec.graphId]: variantSpec } } : {}),
     });
     if (decision.appliedIds.length > 0) graphTemplate = decision.template;
+    // ⭐ SELFIMPL-NODE-SEAMS-BACK — 같은 NodeContext 가 라운드로 이어진다: 체크포인트를 옮기고,
+    //   부품이 도는 중에 다른 판으로 바뀌었으면 그 사실을 값으로 낸다(걸음과 신원이 갈리는 것을 막는다).
+    if (nodeContext !== undefined) {
+      nodeContext = { ...nodeContext, checkpoint: { ...nodeContext.checkpoint, round } };
+      const drift = stageUnitDrift(nodeContext.grounding.units, defaultGraphsDir());
+      observe('graph-stage-units-drift', {
+        graphId: nodeContext.goal.graphId, graphVersion: nodeContext.goal.graphVersion,
+        round, missing: drift.missing, changed: drift.changed,
+      });
+    }
     // ⛔⭐ 승격이 켜져 있으면 «언제나» 낸다 — 후보가 0이어도 낸다.
     //   🩸 안 내면 「얹을 게 없었다」와 「이 배선이 «안 돌았다»」가 원장에서 «같은 값»(0건)이 된다.
     //   ⇒ `considered` 가 그 둘을 가른다: 배선이 돌면 이 줄이 있고, 그 수가 «본 오버레이 수»다.
@@ -5174,7 +5396,7 @@ async function runSelfImplementInner(
     roundClassifications.push(classification);
     onRoundClassification(classification);
   };
-  const { runId, source: runIdSource } = identity ?? resolveRunIdentity({ explicit: opts.runId });
+  const { runId, source: runIdSource } = runIdentity;
   const branch = opts.branchName ?? plannedSelfImplBranch(opts.feature, opts.goalId, runId);
   try {
     debug.log('run-identity', 'own', {
@@ -5922,6 +6144,7 @@ async function runSelfImplementInner(
   };
   let preservationBase = wt.resolvedBase;
   const runProviderName = opts.childLlm?.provider ?? (s.currentProviderName?.() ?? currentProviderName());
+  let activeChildLlm = opts.childLlm;
   let cachedQuotaExhaustionAssessment: QuotaExhaustionAssessment | undefined;
   const quotaExhaustionAssessmentForRun = (): QuotaExhaustionAssessment => {
     cachedQuotaExhaustionAssessment ??= readQuotaExhausted(s.inspectCodexRotation, runProviderName);
@@ -7050,7 +7273,38 @@ async function runSelfImplementInner(
           if (fabricObservation) observe('rework-budget-fabric-shadow', fabricObservation);
         }
       } catch (error) {
-        if (judgmentStarted) throw error;
+        if (judgmentStarted) {
+          const failureKind = classifyReviewProviderFailure(safeErrorDescription(error));
+          if (failureKind === 'credentials-unavailable') {
+            const blockedStage = isReviewRework(reworkKind) ? 'review-blocked' : 'gate-failed';
+            const reason = 'rework skipped: provider credentials unavailable';
+            observe('rework-skipped-provider-unavailable', { round, kind: reworkKind, reason: failureKind }, { level: 'warn' });
+            finalizeSupervisorDeliveries('rework-provider-credentials-unavailable');
+            if (blockedStage === 'review-blocked') recordPendingReviewTriage('follow-up', 'review-blocked', effectiveMax);
+            const pr = await preserveBlockedArtifacts({
+              stage: blockedStage,
+              reason,
+              gate,
+              failureKind,
+              salvageStatusExpected: false,
+            });
+            const common = {
+              ok: false as const,
+              node: 'rework' as const,
+              ...resolveRunOutcome({ termination: 'abandoned' }),
+              sessionId,
+              worktreePath: wt.path,
+              branch: wt.branch,
+              gate,
+              ...(review ? { review } : {}),
+              quotaExhaustionAssessment: quotaExhaustionAssessmentForRun(),
+            };
+            return blockedStage === 'review-blocked'
+              ? { ...common, ...reviewBlockedResult(pr), detail: reason }
+              : { ...common, stage: 'gate-failed' as const, ...(pr ? { prUrl: pr.url, prNumber: pr.number } : {}), detail: reason };
+          }
+          throw error;
+        }
         consecutiveUnresolvedBudget = 0;
       }
     } else if (round > 0) {
@@ -7278,6 +7532,30 @@ async function runSelfImplementInner(
       }
       throw error;
     }
+    // Only the preceding round's observed error or gate evidence can authorize a remedy.
+    let healInput = '';
+    if (round > 0) {
+      const failure = reworkKind === 'gate' && gate?.passed === false ? gate : undefined;
+      const failures = failure?.baselineFailures;
+      const facts = failure?.reflectGateFacts;
+      const providerMessage = providerErrorAtLastGate();
+      const signature = providerMessage && /\b1310\b.*\blimit\b|\blimit\b.*\b1310\b/i.test(providerMessage) ? 'provider-1310'
+        : failure && facts?.introduced === 0 && facts.preexisting !== undefined && facts.preexisting > 0
+          && facts.unknown === 0 && failures?.length && failures.every(item => item.attribution === 'preexisting')
+          ? 'preexisting'
+          : failure && failures?.some(item => item.timeoutVariability === 'may-vary'
+            && /\b(?:order|time)[ -]dependent\b/i.test(`${item.name} ${item.diagnostic ?? ''}`))
+            ? 'order-time-dependent' : 'unknown';
+      const pack = signature === 'unknown' ? { text: '', ids: [], bytes: 0 } : selectHealKnowhowPack(wt.path, signature);
+      const freshIds = pack.ids.filter(id => !deliveredHealPacks.has(`${healRunId}:${signature}:${id}`));
+      const decision = !pack.ids.length ? 'unknown' : freshIds.length ? 'matched' : 'already-delivered';
+      if (decision === 'matched') {
+        for (const id of freshIds) deliveredHealPacks.add(`${healRunId}:${signature}:${id}`);
+        healInput = `[SUPERVISOR-HEAL-PACK signature=${signature} ids=${freshIds.join(',')}]\n${pack.text.split('\n').slice(1).filter(line => freshIds.some(id => line.startsWith(`${id}:`))).join('\n')}`;
+      }
+      observe('supervisor-heal-pack', { runId: healRunId, round, signature, packIds: decision === 'matched' ? freshIds : decision === 'already-delivered' ? pack.ids : [], decision,
+        ...(decision === 'unknown' ? { missingEvidence: signature === 'unknown' ? 'observed-signature-unavailable' : 'matching-active-pack-unavailable' } : {}) });
+    }
     const implementAbortController = new AbortController();
     const abortImplementation = (): void => implementAbortController.abort(opts.signal?.reason);
     if (opts.signal?.aborted) abortImplementation();
@@ -7299,18 +7577,66 @@ async function runSelfImplementInner(
     let supervisorInputClosed = false;
     const closeSupervisorInput = (): void => { supervisorInputClosed = true; };
     try {
+      if (round > 0 && activeChildLlm?.provider === 'grok') {
+        const { readGrokQuotaForLaunch, defaultChildLlmModel } = await import('../self-dev/dev-cli.js');
+        const grokQuota = readGrokQuotaForLaunch();
+        const grokCredential = resolveGrokCredential() ? 'available' as const : 'unavailable' as const;
+        let codexRotation: ReturnType<typeof inspectCodexRotation> | undefined;
+        try { codexRotation = (s.inspectCodexRotation ?? inspectCodexRotation)(); } catch { codexRotation = undefined; }
+        const preference = resolveChildLlmPreference(getUserConfig());
+        const alternateSlot = preference.chain.find((slot) => slot.provider === 'openai-codex' && slot.provider !== activeChildLlm!.provider);
+        const hasCodexCredential = (codexRotation?.knownAccountCount ?? 0) > 0;
+        const codexQuota = readQuotaExhausted(s.inspectCodexRotation, 'openai-codex');
+        const alternate = hasCodexCredential ? {
+          provider: 'openai-codex', model: alternateSlot?.model ?? defaultChildLlmModel('openai-codex'), source: 'config' as const,
+        } : undefined;
+        const decision = reselectChildForRework({ current: activeChildLlm, grokQuota, grokCredential,
+          ...(alternate ? { alternate } : {}), alternateCredential: hasCodexCredential ? 'available' : 'unavailable',
+          alternateQuotaExhausted: codexQuota.exhausted });
+        if (decision.action === 'reselect') {
+          activeChildLlm = decision.selection;
+          observe('rework-child-model-reselected', { round, previousProvider: decision.previous.provider, previousModel: decision.previous.model,
+            provider: activeChildLlm.provider, model: activeChildLlm.model, reason: decision.reason, quota: grokQuota,
+            grokCredential, alternateQuotaExhausted: codexQuota.exhausted ?? null });
+        }
+      }
       implementPromise = s.implement({
       sessionId, cwd: wt.path, feature, runId, shardIdentity, signal: implementAbortController.signal,
       ...(harnessSeededPaths.length ? { harnessSeededPaths } : {}),
       onSurfaceProgress: (line) => progress('implementing', line.trimEnd()),
       onLifecycleScreenClassification: recordRoundClassification,
-      ...(round > 0 ? { roundContext: { round, effectiveMax, previousRoundFailure: reworkPromptNote, ...(landedSiblings ? { landedSiblings } : {}) } } : {}),
+      ...(round > 0 ? { roundContext: { round, effectiveMax, previousRoundFailure: healInput ? `${reworkPromptNote}\n\n${healInput}` : reworkPromptNote, ...(landedSiblings ? { landedSiblings } : {}) } } : {}),
       onSupervisorInput: (text, updateDelivery) => {
         const normalized = text.trim();
         if (!normalized) {
           updateDelivery?.('not-delivered', 'empty-supervisor-input');
           return;
         }
+        if (normalized.startsWith(RUN_DOCTOR_HANDOFF_INPUT_PREFIX)) {
+          const runIdMatch = /(?:^|\s)runId=([^\s]+)/u.exec(normalized);
+          const stopKeyMatch = /(?:^|\s)stopKey=([^\s]+)/u.exec(normalized);
+          if (!runIdMatch?.[1] || runIdMatch[1] !== runId || !stopKeyMatch?.[1]) {
+            updateDelivery?.('not-delivered', 'invalid-run-doctor-handoff');
+            return;
+          }
+          void (s.runDoctorHandoff ?? runDoctorHandoff)({ runId, stopKey: stopKeyMatch[1], dir: runLedgerDir(elanousStateRoot() || undefined),
+            dispatch: (action, handoff) => {
+              if (action !== 'reauthor-from-materialized') return { outcome: 'needs-human', detail: `prescription executor not wired: ${action}` };
+              const accepted = recordFailureEvent({ source: 'harness-run', kind: 'run-supervisor-wait-streak', ref: runId,
+                summary: `[implement aborted] run-supervisor wait streak ${String(handoff.waitCount ?? 'unknown')} · doctor reauthor handoff`,
+                goalText: feature, ...(opts.goalId ? { goalId: opts.goalId } : {}), ...(opts.goalFile ? { goalFile: opts.goalFile } : {}),
+                ...(opts.healCellKey ? { cellKey: opts.healCellKey } : {}), at: new Date().toISOString() });
+              return { outcome: accepted.folded ? 'heal-event-already-present' : 'heal-graph-requested',
+                detail: accepted.folded ? 'same-run heal event already recorded' : 'PR1 heal intake accepted the materialized reauthor action' };
+            },
+          }).then((result) => {
+            updateDelivery?.(result.status === 'acted' || result.status === 'already-acted' ? 'delivered' : 'not-delivered',
+              result.status === 'needs-human' ? result.outcome : result.status === 'missing-handoff' ? 'run-chart-handoff-missing' : undefined);
+          }).catch((error: unknown) => {
+            updateDelivery?.('not-delivered', error instanceof Error ? error.message.slice(0, 120) : String(error).slice(0, 120));
+          });
+          return;
+        }
         if (supervisorInputClosed) {
           recordUndeliveredSupervisorInput(normalized, 'late-supervisor-input');
           updateDelivery?.('not-delivered', 'late-supervisor-input');
@@ -7326,7 +7652,7 @@ async function runSelfImplementInner(
         supervisorDeliveryUpdates.push({ text: normalized, update: updateDelivery });
       },
       ...(escalateTier !== 'none' ? { escalateTier } : {}),
-      ...(opts.childLlm ? { childLlm: opts.childLlm } : {}),
+      ...(activeChildLlm ? { childLlm: activeChildLlm } : {}),
       ...(opts.documentReferences ? { documentReferences: opts.documentReferences } : {}),
     });
     } catch (error) {
@@ -7401,7 +7727,7 @@ async function runSelfImplementInner(
               ...(harnessSeededPaths.length ? { harnessSeededPaths } : {}),
               onSurfaceProgress: line => progress('implementing', line.trimEnd()),
               roundContext: { round: retryRound, effectiveMax, previousRoundFailure: retryNote },
-              ...(opts.childLlm ? { childLlm: opts.childLlm } : {}),
+              ...(activeChildLlm ? { childLlm: activeChildLlm } : {}),
               ...(opts.documentReferences ? { documentReferences: opts.documentReferences } : {}),
             }), T.implement, 'implement');
           } catch (error) {
@@ -7502,7 +7828,7 @@ async function runSelfImplementInner(
             ...(harnessSeededPaths.length ? { harnessSeededPaths } : {}),
             onSurfaceProgress: (line) => progress('implementing', line.trimEnd()),
             roundContext: { round: tddRetryRound, effectiveMax, previousRoundFailure: tddRetryNote },
-            ...(opts.childLlm ? { childLlm: opts.childLlm } : {}),
+            ...(activeChildLlm ? { childLlm: activeChildLlm } : {}),
             ...(opts.documentReferences ? { documentReferences: opts.documentReferences } : {}),
           }), T.implement, 'implement');
         } catch (error) {
@@ -7697,7 +8023,10 @@ async function runSelfImplementInner(
     }, { compact: { stringMax: Math.max(MAX_HARVESTED_EVIDENCE_CHARS, harvestObs.harvestedEvidence?.length ?? 0) } });
     if (impl.ok) completionDisposition = finishedChildCommitMissing || finishedChildCommitted ? undefined : impl.completionDisposition;
     const effectiveDisposition = impl.ok ? completionDisposition : impl.completionDisposition;
-    observe('implemented', { ok: impl.ok, round, ...(effectiveDisposition ? { completionDisposition: effectiveDisposition } : {}) });
+    let materializedPaths: readonly string[] | undefined;
+    try { materializedPaths = (s.changedFilesForGateRoute ?? changedFiles)(wt.path); } catch { /* unknown diff is not path evidence */ }
+    observe('implemented', { ok: impl.ok, round, ...(materializedPaths ? { materializedPaths: [...materializedPaths] } : {}),
+      ...(effectiveDisposition ? { completionDisposition: effectiveDisposition } : {}) });
     progress('implemented', impl.ok ? (round === 0 ? '구현 완료' : `rework ${round} 완료`) : impl.completionDisposition ? '변경 없이 완료 검증' : '구현 실패(worktree 보존)');
     if (!impl.ok) {
       finalizeSupervisorDeliveries('next-round-implement-not-ok');