elanous 0.2.41 → 0.2.43

package/src/self-implement/orchestrator.ts

@@ -106,11 +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, classifyTerminalHarnessFailure, forgetRunStop, isRunStopClass, readRunStopRecord, recordRunStop, runStopRecorded } from './run-stop.js';
+import { appendRunLedgerEntries, appendRunLedgerEntry, loadRunLedger, parseRunShardIdentity, pathSignatureOf, queryRunChain, runLedgerDir, type RunChainShardSibling, type RunLedgerBatchWriter, 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 } from './doctor-visit.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';
@@ -227,7 +228,8 @@ import { formatGateFailedId, type PremiseReviewCard, type PremiseReviewInput } f
 import { runWorkflowToCompletion } from '../workflow-runtime/executor.js';
 import { mapReworkVerdict, supervisionObservationFields } from './supervision-vocabulary.js';
 import { resolveRunOutcome } from './run-outcome.js';
-import { authorLimitationCountFromGoal, authoredSignalExecution, harvestEvidenceLines, harvestedEvidenceObservation, MAX_HARVESTED_EVIDENCE_CHARS, parseOffDiffEvidence, judgeTddEvidence, requiredEvidenceFromGoal, createRequiredEvidenceBudget, coverRequiredEvidence, settleUncoveredEvidence, formatUncoveredEvidenceFeedback, type OffDiffEvidenceParse } from './off-diff-evidence.js';
+import { authorLimitationCountFromGoal, authoredSignalExecution, harvestEvidenceLines, harvestedEvidenceObservation, MAX_HARVESTED_EVIDENCE_CHARS, parseOffDiffEvidence, judgeTddEvidence, receiveObservedTddRed, receiveObservedTddGreen, runTddBaseHeadTest, requiredEvidenceFromGoal, createRequiredEvidenceBudget, coverRequiredEvidence, settleUncoveredEvidence, formatUncoveredEvidenceFeedback, type OffDiffEvidenceParse } from './off-diff-evidence.js';
+import type { TddRecordTag } from './tdd-evidence-tags.js';
 import { resolveEvidenceHeadCommit } from './evidence-command-budget.js';
 import { pressDecisionSignals, type DecisionSignalPressResult } from './decision-signal-press.js';
 import { inspectDecisionObservations, inspectDecisionSignalKinds, inspectDecisionSignalObservations } from '../../scripts/ask-marker-check.js';
@@ -319,6 +321,7 @@ import { createArtifactStore } from '../artifact/index.js';
 import { mapStageToRunStatus, type SelfImplementStage } from './run-status-mapping.js';
 import type { LifecycleScreenComparison } from './lifecycle-screen-scoreboard.js';
 import { buildRuntimeOverlayState } from './graph-overlay-condition.js';
+import { runtimeOverlayRunSteps } from './runtime-overlay-run-steps.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';
@@ -356,6 +359,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';
@@ -1064,6 +1070,8 @@ export type ImplementTerminalStatus = {
 export interface SelfImplementSeams {
   /** Run-observer ledger sink. Tests inject an in-memory sink to avoid touching user state. */
   writeRunLedger?: RunLedgerWriter;
+  /** Atomic sink for one accepted runtime graph overlay's structural event batch. */
+  writeRunLedgerBatch?: RunLedgerBatchWriter;
   checkUnwiredExports?: typeof findUnwiredExports;
   /** STOP-AUTOHEAL — heal action seams (live mode only runs actions given here; missing = needs-owner). */
   stopAutohealActions?: AutohealActions;
@@ -1077,6 +1085,8 @@ export interface SelfImplementSeams {
   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. */
@@ -1222,6 +1232,8 @@ export interface SelfImplementSeams {
   headCommit?: (cwd: string) => string | undefined;
   /** Test seam for required evidence command execution; production uses its bounded shell runner. */
   evidenceCommandRunner?: (command: string, cwd: string) => Pick<ReturnType<typeof spawnSync>, 'status' | 'stdout' | 'stderr' | 'error'>;
+  /** Replays the goal's changed Bun test on base and head when child RED output is absent. */
+  runTddBaseHeadTest?: typeof runTddBaseHeadTest;
   /** `commit` pins the pushed state; without it the worktree HEAD is pushed. */
   preserveBlockedBranch?: (ctx: { cwd: string; branch: string; title: string; commit?: string }) => boolean | Promise<boolean>;
   /** DRAFT-NOT-ARCHIVE — `tools.selfImplement.draftOnStop` 읽기 seam. 생략하면 user-config(실패·부재 = 'always' · 종전). */
@@ -2208,6 +2220,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. */
@@ -2398,7 +2412,9 @@ export interface SelfImplementResult {
   /** Additive hard-cap disposition; outcome remains the stable public terminal contract. */
   salvage?: 'launched' | 'parked';
   /** Rework stopped on exclusively baseline/flaky/precondition failures; do not retry this goal against the same base. */
-  terminationReason?: 'blocked-by-baseline' | 'goal-only-rework-exhausted';
+  terminationReason?: 'blocked-by-baseline' | 'goal-only-rework-exhausted' | 'tdd-evidence-missing';
+  /** Structured TDD failure survives child JSON/result truncation and parent-ledger mapping. */
+  tddEvidenceFailure?: { reason: 'tdd-evidence-missing'; round: number; missing: readonly TddRecordTag[] };
   sessionId?: string;
   worktreePath?: string;
   branch?: string;
@@ -2887,6 +2903,8 @@ type BlockedDraftPrState = {
   childSummaryArtifact?: ChildSummaryArtifactRef;
   terminalStatus?: ImplementTerminalStatus;
   planRevision?: ReworkPlanRevision;
+  stopStage?: string;
+  stopClass?: ReturnType<typeof classifyTerminalHarnessFailure>;
   /** Classifier output for this unfinished run. Omitted means the cause was not classified. */
   abandonedClassification?: AbandonedClassificationResult;
 };
@@ -2901,29 +2919,39 @@ export type BlockedDraftClassificationRecord = {
   readonly classification: string;
   readonly classificationBasis: string;
   readonly worktreeClean: boolean | null;
+  readonly stop: { readonly class: ReturnType<typeof classifyTerminalHarnessFailure>; readonly stage: string };
 };
 
 export function blockedDraftClassificationRecord(
   classification: AbandonedClassificationResult | undefined,
+  stop: { readonly stage?: string; readonly class?: ReturnType<typeof classifyTerminalHarnessFailure> } = {},
 ): BlockedDraftClassificationRecord {
+  const stage = typeof stop.stage === 'string' && stop.stage.trim() ? stop.stage : 'unknown';
+  const stopClass = stop.class ?? classifyTerminalHarnessFailure({
+    stage,
+    ...(classification ? { abandonedClassification: classification.classification } : {}),
+  });
   if (!classification) {
     return {
       classification: BLOCKED_DRAFT_UNCLASSIFIED_CLASSIFICATION,
       classificationBasis: BLOCKED_DRAFT_UNCLASSIFIED_CLASSIFICATION,
       worktreeClean: null,
+      stop: { class: stopClass, stage },
     };
   }
   return {
     classification: classification.classification,
     classificationBasis: classification.classificationBasis,
     worktreeClean: classification.worktreeClean ?? null,
+    stop: { class: stopClass, stage },
   };
 }
 
 export function formatBlockedDraftClassificationSection(
   classification: AbandonedClassificationResult | undefined,
+  stop: { readonly stage?: string; readonly class?: ReturnType<typeof classifyTerminalHarnessFailure> } = {},
 ): string[] {
-  const record = blockedDraftClassificationRecord(classification);
+  const record = blockedDraftClassificationRecord(classification, stop);
   const human = record.classification === BLOCKED_DRAFT_UNCLASSIFIED_CLASSIFICATION
     ? `${record.classification} (분류를 못 함)`
     : record.classification;
@@ -2934,6 +2962,8 @@ export function formatBlockedDraftClassificationSection(
     `- classification: ${record.classification}`,
     `- classificationBasis: ${record.classificationBasis}`,
     `- worktreeClean: ${worktreeCleanText}`,
+    `- stop.class: ${record.stop.class}`,
+    `- stop.stage: ${record.stop.stage}`,
     '',
     '```json',
     JSON.stringify(record),
@@ -2959,7 +2989,7 @@ function blockedDraftPrBody(feature: string, implSummary: string, state: Blocked
     ...(state.childSummaryArtifact ? [`- child summary artifact: ${state.childSummaryArtifact.path}`] : []),
     ...(state.terminalStatus ? [`- child terminal status: reached=${state.terminalStatus.reached}; changed=${state.terminalStatus.changed}; toolCalls=${state.terminalStatus.toolCalls}; timedOut=${state.terminalStatus.timedOut}`] : []),
     '',
-    ...formatBlockedDraftClassificationSection(state.abandonedClassification),
+    ...formatBlockedDraftClassificationSection(state.abandonedClassification, { stage: state.stopStage, class: state.stopClass }),
     '',
     '## 미배달 감독 수리 지시',
     ...(state.undeliveredSupervisorInputs.length
@@ -3095,10 +3125,12 @@ export function assembleBlockedDraftPrBody(
   persist?: SelfImplementSeams['persistPrBodyArtifact'],
 ): { body: string; truncated: boolean; originalChars: number } {
   const raw = blockedDraftPrBody(feature, implSummary, state, goalFile);
-  const classificationRecord = blockedDraftClassificationRecord(state.abandonedClassification);
+  const classificationRecord = blockedDraftClassificationRecord(state.abandonedClassification, { stage: state.stopStage, class: state.stopClass });
   const essentialSuffix = [
     `- reason: ${state.reason}`,
     `- classification: ${classificationRecord.classification}`,
+    `- stop.class: ${classificationRecord.stop.class}`,
+    `- stop.stage: ${classificationRecord.stop.stage}`,
     JSON.stringify(classificationRecord),
     ...(state.reasonTruncated ? ['- reason truncated: true'] : []),
     ...(state.terminalStatus ? [`- child terminal status: reached=${state.terminalStatus.reached}; changed=${state.terminalStatus.changed}; toolCalls=${state.terminalStatus.toolCalls}; timedOut=${state.terminalStatus.timedOut}`] : []),
@@ -3580,6 +3612,9 @@ 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 */ }
@@ -3596,10 +3631,13 @@ async function autohealRecordedStop(stopEntry: RunLedgerEntry, s: SelfImplementS
       ...(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' });
         }
@@ -3626,11 +3664,23 @@ async function dispatchTerminalHarnessHeal(input: {
   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({
@@ -3639,9 +3689,11 @@ async function dispatchTerminalHarnessHeal(input: {
       shardIdentity,
       site: mergeHeld ? 'merge-hold' : `terminal-${result.stage}`,
       class: stopClass,
-      cause: mergeHeld ? `merge held: ${result.mergeReason}` : result.detail ?? `terminal failure: ${result.stage}`,
+      // 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);
@@ -4175,6 +4227,49 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
         unjoinedNodes: unjoined,
       }, { category: 'graph.path' });
     }
+    if (runGraphTemplate?.graphId === 'self-implement') {
+      const profileIds = new Set<string>();
+      let journeyEvidenceStatus: 'read' | 'missing' | 'read-error' = 'missing';
+      let journeyEvidenceError: string | undefined;
+      const journeySteps: Array<{ from: string; to: string; skipped?: string[] }> = [];
+      try {
+        // `recordJourneyEdge` appends graph.path synchronously to the canonical run ledger.
+        // Reading that same append boundary avoids a potentially lagging debug LogStore mirror.
+        const entries = loadRunLedger(runId, runLedgerDir());
+        if (entries !== null) {
+          journeyEvidenceStatus = 'read';
+          for (const entry of entries) {
+            if (entry.event !== 'graph.path') continue;
+            const data = entry.data;
+            if (Array.isArray(data.profileIds)) for (const id of data.profileIds) if (typeof id === 'string') profileIds.add(id);
+            if (data.event !== 'edge-taken' || typeof data.from !== 'string' || typeof data.taken !== 'string') continue;
+            const skipped = Array.isArray(data.skippedNodes)
+              ? data.skippedNodes.flatMap((item) => item && typeof item === 'object'
+                && typeof (item as { node?: unknown }).node === 'string' ? [(item as { node: string }).node] : [])
+              : [];
+            journeySteps.push({ from: data.from, to: data.taken, ...(skipped.length > 0 ? { skipped } : {}) });
+          }
+        }
+      } catch (error) {
+        journeyEvidenceStatus = 'read-error';
+        journeyEvidenceError = error instanceof Error ? error.message : String(error);
+      }
+      const pathBasis = 'self-implement-pipeline-and-journey-v1';
+      const pipelineNodes = traversedNodes.map(String);
+      const pipelineSteps = pipelineNodes.slice(1).map((to, index) => ({ from: pipelineNodes[index]!, to }));
+      const pathSteps = [...pipelineSteps, ...journeySteps];
+      const visitedNodes = [
+        ...pipelineNodes,
+        ...journeySteps.flatMap((step) => [step.from, ...(step.skipped ?? []), step.to]),
+      ];
+      const pathSignature = pathSignatureOf(pathSteps);
+      observeOuter('path-signature', {
+        ...graphIdentityOf(runGraphTemplate), ...journeyJoinFields(), pathBasis,
+        profileIds: [...profileIds].sort(), pathSignature, pathSteps, visitedNodes,
+        journeyEdgeCount: journeySteps.length,
+        journeyEvidenceStatus, ...(journeyEvidenceError ? { journeyEvidenceError } : {}),
+      }, { category: 'graph.path' });
+    }
     try {
       const checked = terminalNode
         ? (opts.seams.checkPipelineTraversal ?? checkPipelineTraversal)(traversedNodes, terminalNode)
@@ -4661,6 +4756,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(),
         });
       }
@@ -4865,6 +4964,7 @@ export function attachAbandonedClassification(
       ...(credentialFailure ? { credentialFailure: true } : {}),
       ...(providerError ? { providerError: true } : {}),
       ...(providerError && result.providerErrors?.category ? { providerErrorCategory: result.providerErrors.category } : {}),
+      ...(result.terminationReason === 'tdd-evidence-missing' ? { terminationReason: result.terminationReason } : {}),
       worktreePorcelain: worktree.worktreePorcelain,
       ...(worktree.gitResidue ? { gitResidue: worktree.gitResidue } : {}),
       ...(result.completionDisposition ? { completionDisposition: result.completionDisposition } : {}),
@@ -4899,6 +4999,7 @@ export function observeRunOutcome(
     worktreePath: SelfImplementResult['worktreePath'] | undefined;
     review: SelfImplementResult['review'] | undefined;
     completionDisposition: SelfImplementResult['completionDisposition'] | undefined;
+    terminationReason?: SelfImplementResult['terminationReason'];
     supervisorVerdict: SelfImplementResult['supervisorVerdict'] | undefined;
     goalCauseObserved?: SelfImplementResult['goalCauseObserved'];
     mergeApprovalReceived: SelfImplementResult['mergeApprovalReceived'] | undefined;
@@ -4940,6 +5041,7 @@ export function observeRunOutcome(
       ...(result.quotaExhaustionAssessment?.exhausted ? { quotaExhausted: true } : {}),
       ...(result.quotaExhaustionAssessment?.accountAvailability ? { quotaAccountAvailability: result.quotaExhaustionAssessment.accountAvailability } : {}),
       ...(result.providerErrors?.category ? { providerError: true, providerErrorCategory: result.providerErrors.category } : {}),
+      ...(result.terminationReason === 'tdd-evidence-missing' ? { terminationReason: result.terminationReason } : {}),
       stage: result.stage,
       reviewResultObserved: result.review !== undefined,
       mustFixReported: (result.review?.mustFix.length ?? 0) > 0,
@@ -5287,6 +5389,7 @@ async function runSelfImplementInner(
   if (graphAuthority.enabled) onGraphTemplateResolved(graphTemplate);
   // ⛔ 선택을 «전부» 싣는다 — 얹힌 것만 실으면 「왜 안 얹혔나」를 사후에 못 묻는다.
   let reviewRepeat: number | undefined;
+  const recordedRuntimeStructuralSteps = new Set<string>();
   /** ⭐ ③ «다이나믹» — 라운드마다 runtime 오버레이를 다시 고른다.
    *  ⛔ **매번 «기준 선언»에서 다시 얹는다** — 이전 라운드 결과 위에 겹쳐 얹으면
    *    「이 걸음을 무엇이 만들었나」가 «누적»이 되어 사후에 못 푼다.
@@ -5307,6 +5410,7 @@ async function runSelfImplementInner(
       ...(stopClass === undefined ? {} : { stopClass }),
       ...(reviewRepeat === undefined ? {} : { reviewRepeat }),
     });
+    const beforeRuntimeGraph = graphTemplate;
     const decision = decideTemplate({
       goalType: graphGoalType,
       authority: graphAuthority,
@@ -5315,7 +5419,41 @@ async function runSelfImplementInner(
       stage: 'runtime',
       ...(variantSpec ? { specs: { [variantSpec.graphId]: variantSpec } } : {}),
     });
-    if (decision.appliedIds.length > 0) graphTemplate = decision.template;
+    if (decision.appliedIds.length > 0) {
+      graphTemplate = decision.template;
+      const structuralEvents = runtimeOverlayRunSteps({
+        runId: runIdentity.runId,
+        timestamp: new Date().toISOString(),
+        before: beforeRuntimeGraph,
+        after: graphTemplate,
+        overlayIds: decision.appliedIds,
+        round,
+      });
+      const pendingStructuralEvents = structuralEvents.map((entry) => ({
+        entry,
+        key: entry.event === 'node-added'
+          ? `${entry.event}:${entry.data.node}`
+          : `${entry.event}:${entry.data.from}:${entry.data.outcome}:${entry.data.was}:${entry.data.to}`,
+      })).filter(({ key }) => !recordedRuntimeStructuralSteps.has(key));
+      if (pendingStructuralEvents.length > 0) {
+        try {
+          const batch = pendingStructuralEvents.map(({ entry }) => entry);
+          if (opts.seams.writeRunLedgerBatch) opts.seams.writeRunLedgerBatch(batch);
+          else if (opts.seams.writeRunLedger) for (const entry of batch) opts.seams.writeRunLedger(entry);
+          else appendRunLedgerEntries(batch);
+          for (const { key } of pendingStructuralEvents) recordedRuntimeStructuralSteps.add(key);
+        } catch (error) {
+          const first = pendingStructuralEvents[0]!.entry;
+          observe('graph-overlay-step-write-failed', {
+            runId: runIdentity.runId,
+            round,
+            event: first.event,
+            events: pendingStructuralEvents.map(({ entry }) => entry.event),
+            error: error instanceof Error ? error.message : String(error),
+          });
+        }
+      }
+    }
     // ⭐ SELFIMPL-NODE-SEAMS-BACK — 같은 NodeContext 가 라운드로 이어진다: 체크포인트를 옮기고,
     //   부품이 도는 중에 다른 판으로 바뀌었으면 그 사실을 값으로 낸다(걸음과 신원이 갈리는 것을 막는다).
     if (nodeContext !== undefined) {
@@ -5690,8 +5828,8 @@ async function runSelfImplementInner(
   //   거짓 표시한다 · 리뷰 4R). 수확본이 비면 **요약에서 수확**한다 — 요약 원문을 통째로 싣지 않는다.
   const harvestedForPr = (): string | undefined => {
     if (!impl) return undefined;
-    const fromChild = impl.evidenceTranscript?.trim() ? impl.evidenceTranscript : undefined;
-    const picked = fromChild ?? harvestEvidenceLines(impl.summary);
+    const fromChild = impl.evidenceTranscript?.trim() ? harvestEvidenceLines(impl.evidenceTranscript) : undefined;
+    const picked = fromChild?.trim() ? fromChild : harvestEvidenceLines(impl.summary);
     return picked.trim() ? picked : undefined;
   };
   let offDiffEvidence: OffDiffEvidenceParse = { items: [], discardedMissingVerify: 0, discardedEmptyClaim: 0, missingResult: 0, orphanResult: 0, truncatedResult: 0, anchoredEvidence: 0 };
@@ -6112,6 +6250,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);
@@ -6161,6 +6300,7 @@ async function runSelfImplementInner(
   };
   let blockedDraftNoChanges = false;
   let blockedDraftPrFailure: string | undefined;
+  let blockedDraftPrFailureKind: 'blocked-draft-pr-guard' | undefined;
   let repairLink: { originalPr: number; salvageRef: string } | undefined;
   const reviewBlockedResult = (pr: { url: string; number: number } | undefined) => ({
     stage: blockedDraftNoChanges && podReviewBlockedDraft ? 'no-changes' as const : podReviewBlockedDraft && !pr ? 'aborted' as const : 'review-blocked' as const,
@@ -6231,14 +6371,26 @@ async function runSelfImplementInner(
       observe('blocked-draft-decision-signal-failed', { stage, error: decisionSignalObservation.error }, { level: 'warn' });
     }
     const abandonedClassification = classifyUnfinishedRun(stage, verdict, decomposition);
-    const classificationRecord = blockedDraftClassificationRecord(abandonedClassification);
+    const stopClass = classifyTerminalHarnessFailure({
+      stage,
+      abandonedClassification: abandonedClassification.classification,
+      ...(verdict ? { supervisorVerdict: verdict } : {}),
+    });
+    const classificationRecord = blockedDraftClassificationRecord(abandonedClassification, { stage, class: stopClass });
     observe('blocked-draft-classification', {
       stage,
       ...classificationRecord,
     }, { level: 'warn' });
+    observe('draft-stop-classified', {
+      stage,
+      stop: classificationRecord.stop,
+      classification: classificationRecord.classification,
+      classificationBasis: classificationRecord.classificationBasis,
+    }, { level: 'warn' });
     const observation = {
       branch: wt.branch,
       stage,
+      stopClass: classificationRecord.stop.class,
       verdict: verdict ?? null,
       reason: reason.slice(0, 240),
       rounds: round,
@@ -6281,6 +6433,8 @@ async function runSelfImplementInner(
         reason,
         rounds: round,
         undeliveredSupervisorInputs: undeliveredSupervisorInputSnapshot(),
+        stopStage: stage,
+        stopClass,
         abandonedClassification,
         ...(decomposition ? { decomposition } : {}),
         ...(harvestedForPr() ? { evidence: harvestedForPr() as string } : {}),
@@ -6552,6 +6706,9 @@ async function runSelfImplementInner(
         ...(artifactPath ? { prBodyArtifactPath: artifactPath } : {}),
         ...(artifactError ? { prBodyArtifactError: artifactError } : {}),
       }, { level: 'warn' });
+      blockedDraftPrFailureKind = /self-implement PR guard 실패/.test(prError) && /(?:same-cell|goal-only)/.test(prError)
+        ? 'blocked-draft-pr-guard' : undefined;
+      blockedDraftPrFailure = `draft PR 생성 실패: ${prError}`;
       // STOP-RECORD: a failed blocked-draft PR open (e.g. same-branch rerun with a PR already open) left no stop reason.
       let draftStopEntry: RunLedgerEntry | undefined;
       try {
@@ -7240,7 +7397,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) {
@@ -7513,6 +7701,29 @@ 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 } : {}),
@@ -7525,6 +7736,31 @@ async function runSelfImplementInner(
           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');
@@ -7540,7 +7776,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) {
@@ -7615,7 +7851,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) {
@@ -7686,7 +7922,61 @@ async function runSelfImplementInner(
     //   ② 첫 조각 커밋의 피처 시험·구현 전 실행 RED 기록과 구현 뒤 같은 명령 GREEN 기록이
     //     없으면 수리 라운드 1회(완료 경계·기존 동작은 보존), 그래도 없으면 fail-closed.
     //   ③ 관측 원장에 tdd-red/tdd-green 이벤트를 남긴다.
-    let tddJudgment = judgeTddEvidence(roundGoal, parseOffDiffEvidence(impl.evidenceTranscript?.trim() || impl.summary));
+    let tddTranscript = [impl.evidenceTranscript, impl.summary].filter((part): part is string => Boolean(part?.trim())).join('\n');
+    let tddJudgment = judgeTddEvidence(roundGoal, parseOffDiffEvidence(tddTranscript));
+    const runHarnessBaseTddWhenRedMissing = (input: {
+      readonly round: number;
+      readonly goal: string;
+      readonly transcript: string;
+      readonly judgment: ReturnType<typeof judgeTddEvidence>;
+      readonly implementation: typeof impl;
+    }): { readonly transcript: string; readonly judgment: ReturnType<typeof judgeTddEvidence> } => {
+      if (!input.judgment.planned || input.judgment.red.observed || !input.implementation.ok
+        || input.implementation.terminalStatus?.reached !== true) {
+        return { transcript: input.transcript, judgment: input.judgment };
+      }
+      if (!wt.resolvedBase) {
+        observe('tdd-base-test', { round: input.round, status: 'unmeasured', reason: 'base-commit-unavailable' }, { level: 'warn' });
+        return { transcript: input.transcript, judgment: input.judgment };
+      }
+      const result = (s.runTddBaseHeadTest ?? runTddBaseHeadTest)({ cwd: wt.path, baseSha: wt.resolvedBase, goal: input.goal });
+      observe('tdd-base-test', {
+        round: input.round, status: result.accepted ? 'red-green' : 'unmeasured', reason: result.reason,
+        baseSha: wt.resolvedBase, command: result.command, baseResult: result.baseResult ?? null, headResult: result.headResult ?? null,
+      }, result.accepted ? {} : { level: 'warn' });
+      if (!result.accepted || !result.transcript) return { transcript: input.transcript, judgment: input.judgment };
+      const transcript = `${result.transcript}\n${input.transcript}`;
+      return { transcript, judgment: judgeTddEvidence(input.goal, parseOffDiffEvidence(transcript)) };
+    };
+    const baseTdd = runHarnessBaseTddWhenRedMissing({ round, goal: roundGoal, transcript: tddTranscript, judgment: tddJudgment, implementation: impl });
+    tddTranscript = baseTdd.transcript;
+    tddJudgment = baseTdd.judgment;
+    const receivedTddRed = receiveObservedTddRed({
+      goal: roundGoal, judgment: tddJudgment, transcript: tddTranscript,
+      resultParsed: impl.ok && impl.terminalStatus?.reached === true,
+    });
+    debug.log('self-implement.tdd-evidence', 'red-receive', {
+      round, source: 'child-tool-output', accepted: receivedTddRed.accepted, reason: receivedTddRed.reason,
+      observedTestCommand: receivedTddRed.command ?? null, observedTestResult: receivedTddRed.result ?? null,
+    });
+    if (receivedTddRed.accepted) {
+      tddTranscript = receivedTddRed.transcript;
+      tddJudgment = judgeTddEvidence(roundGoal, parseOffDiffEvidence(tddTranscript));
+    }
+    const receivedTddGreen = receiveObservedTddGreen({
+      goal: roundGoal, judgment: tddJudgment, transcript: tddTranscript,
+      resultParsed: impl.ok && impl.terminalStatus?.reached === true,
+    });
+    debug.log('self-implement.tdd-evidence', 'green-receive', {
+      round, source: 'child-tool-output', accepted: receivedTddGreen.accepted, reason: receivedTddGreen.reason,
+      taggedGreenPresent: tddJudgment.green.observed, observedTestCommand: receivedTddGreen.command ?? null,
+      observedTestResult: receivedTddGreen.result ?? null,
+    });
+    if (receivedTddGreen.accepted) {
+      tddTranscript = receivedTddGreen.transcript;
+      tddJudgment = judgeTddEvidence(roundGoal, parseOffDiffEvidence(tddTranscript));
+    }
+    let tddEvidenceFailure: SelfImplementResult['tddEvidenceFailure'];
     if (tddJudgment.needsRepair && impl.ok && round < effectiveMax && opts.goalFile
       && !hasCurrentProviderError() && !hasCurrentCredentialFailure()) {
       let goalDocument: string | undefined;
@@ -7716,21 +8006,62 @@ 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) {
           tddRetryAbort.abort();
           tddRetryImpl = { ...beforeTddRetry, ok: false, summary: `[구현 재작업 · tdd-evidence-missing] 수리 라운드 실패 — ${safeErrorDescription(error)}` };
         }
-        const tddRetryJudgment = judgeTddEvidence(roundGoal, parseOffDiffEvidence(tddRetryImpl.evidenceTranscript?.trim() || tddRetryImpl.summary));
+        let tddRetryTranscript = [tddRetryImpl.evidenceTranscript, tddRetryImpl.summary]
+          .filter((part): part is string => Boolean(part?.trim())).join('\n');
+        let tddRetryJudgment = judgeTddEvidence(roundGoal, parseOffDiffEvidence(tddRetryTranscript));
+        const retryBaseTdd = runHarnessBaseTddWhenRedMissing({
+          round: tddRetryRound, goal: roundGoal, transcript: tddRetryTranscript, judgment: tddRetryJudgment, implementation: tddRetryImpl,
+        });
+        tddRetryTranscript = retryBaseTdd.transcript;
+        tddRetryJudgment = retryBaseTdd.judgment;
+        const retryTddRed = receiveObservedTddRed({
+          goal: roundGoal, judgment: tddRetryJudgment, transcript: tddRetryTranscript,
+          resultParsed: tddRetryImpl.ok && tddRetryImpl.terminalStatus?.reached === true,
+        });
+        debug.log('self-implement.tdd-evidence', 'red-receive', {
+          round: tddRetryRound, source: 'child-tool-output', accepted: retryTddRed.accepted, reason: retryTddRed.reason,
+          observedTestCommand: retryTddRed.command ?? null, observedTestResult: retryTddRed.result ?? null,
+        });
+        if (retryTddRed.accepted) {
+          tddRetryTranscript = retryTddRed.transcript;
+          tddRetryJudgment = judgeTddEvidence(roundGoal, parseOffDiffEvidence(tddRetryTranscript));
+        }
+        const retryTddGreen = receiveObservedTddGreen({
+          goal: roundGoal, judgment: tddRetryJudgment, transcript: tddRetryTranscript,
+          resultParsed: tddRetryImpl.ok && tddRetryImpl.terminalStatus?.reached === true,
+        });
+        debug.log('self-implement.tdd-evidence', 'green-receive', {
+          round: tddRetryRound, source: 'child-tool-output', accepted: retryTddGreen.accepted, reason: retryTddGreen.reason,
+          taggedGreenPresent: tddRetryJudgment.green.observed, observedTestCommand: retryTddGreen.command ?? null,
+          observedTestResult: retryTddGreen.result ?? null,
+        });
+        if (retryTddGreen.accepted) {
+          tddRetryTranscript = retryTddGreen.transcript;
+          tddRetryJudgment = judgeTddEvidence(roundGoal, parseOffDiffEvidence(tddRetryTranscript));
+        }
         if (tddRetryImpl.ok && !tddRetryJudgment.needsRepair) {
-          observe('implementation-tdd-rework', { status: 'succeeded', round: tddRetryRound, missing: [] });
+          observe('implementation-tdd-rework', { status: 'succeeded', round: tddRetryRound, missing: [...tddRetryJudgment.missing] });
           tddJudgment = tddRetryJudgment;
           impl = tddRetryImpl;
           round = tddRetryRound;
         } else {
           observe('implementation-tdd-rework', { status: 'exhausted', round: tddRetryRound, missing: [...tddRetryJudgment.missing] }, { level: 'warn' });
+          // Only an initially successful implementation can enter this one retry. Goal-only exhaustion
+          // has impl.ok=false before this point, so these two terminal reason codes cannot compete.
+          if (tddRetryJudgment.missing.length > 0) {
+            tddEvidenceFailure = {
+              reason: 'tdd-evidence-missing',
+              round: tddRetryRound,
+              missing: [...tddRetryJudgment.missing],
+            };
+          }
           impl = { ...beforeTddRetry, ok: false, summary: `[구현 재작업 · tdd-evidence-missing] RED/GREEN 기록 결손 — ${beforeTddRetry.summary}` };
         }
       }
@@ -7821,7 +8152,7 @@ async function runSelfImplementInner(
     //   창 밖으로 밀려 파서에 도달조차 못 하던 자리다. 미주입 seam 은 종전대로 요약에서 판다(무회귀).
     // ⛔ `??` 가 아니라 **빈 문자열도 폴백**이다 — 수확본이 비면 *"수확했다"* 가 아니라 *"없다"* 이고,
     //    `??` 로 두면 관측이 `harvested` 라 **거짓을 말한다**(리뷰 3R).
-    const harvested = impl.evidenceTranscript?.trim() ? impl.evidenceTranscript : undefined;
+    const harvested = impl.evidenceTranscript?.trim() ? harvestEvidenceLines(impl.evidenceTranscript) : undefined;
     const childEvidenceSource = harvested ?? impl.summary;
     let diffEvidence = '';
     let roundObservationMeasurementBasis: ObservationMeasurementBasis | undefined;
@@ -7911,8 +8242,13 @@ 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 보존)');
+    // TDD exhaustion marks impl failed above; this return precedes finished-child commit and gate handling,
+    // so those success-only terminal paths cannot swallow the structured report-deficit facts.
     if (!impl.ok) {
       finalizeSupervisorDeliveries('next-round-implement-not-ok');
       const abort = buildImplementAbortRecord(impl.summary, impl.terminalStatus);
@@ -7936,7 +8272,11 @@ async function runSelfImplementInner(
         salvageStatusExpected: false,
         ...(abort.terminalStatus ? { terminalStatus: abort.terminalStatus } : {}),
       });
-      return { ok: false, stage: 'aborted', node: 'implement', ...resolveRunOutcome({ termination: 'abandoned' }), ...(goalOnlyReworkExhausted ? { terminationReason: 'goal-only-rework-exhausted' as const } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, quotaExhaustionAssessment: quotaExhaustionAssessmentForRun(), ...(impl.completionDisposition ? { completionDisposition: impl.completionDisposition } : {}), ...(pr ? { prUrl: pr.url, prNumber: pr.number } : {}), detail: impl.summary };
+      return { ok: false, stage: 'aborted', node: 'implement', ...resolveRunOutcome({ termination: 'abandoned' }),
+        ...(tddEvidenceFailure ? { terminationReason: tddEvidenceFailure.reason, tddEvidenceFailure }
+          : goalOnlyReworkExhausted ? { terminationReason: 'goal-only-rework-exhausted' as const } : {}),
+        sessionId, worktreePath: wt.path, branch: wt.branch, quotaExhaustionAssessment: quotaExhaustionAssessmentForRun(), ...(impl.completionDisposition ? { completionDisposition: impl.completionDisposition } : {}), ...(pr ? { prUrl: pr.url, prNumber: pr.number } : {}), detail: blockedDraftPrFailure ?? impl.summary,
+        ...(blockedDraftPrFailureKind ? { detailKind: blockedDraftPrFailureKind } : {}) };
     }
 
     if (finishedChildCommitMissing) {