elanous 0.2.38 → 0.2.41

package/src/self-implement/orchestrator.ts

@@ -107,8 +107,9 @@ import { GoalRunStore, insertGoalRunRecord, type GoalPriorRuns } from './goal-ru
 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 { 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 { emitSessionEvent, type SessionEventInput } from '../context-bus/session-events.js';
 import { decideLineageSupersede, lineageSupersedeCloseComment, type LineageSupersedeOpenDraft } from './lineage-supersede.js';
@@ -136,7 +137,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';
@@ -226,7 +227,7 @@ 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, requiredEvidenceFromGoal, createRequiredEvidenceBudget, coverRequiredEvidence, settleUncoveredEvidence, formatUncoveredEvidenceFeedback, type OffDiffEvidenceParse } from './off-diff-evidence.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 { 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';
@@ -321,7 +322,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';
@@ -1061,6 +1069,8 @@ 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. */
@@ -1083,7 +1093,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 }
   >;
@@ -2180,6 +2190,8 @@ export function appendGoalExecutionRecord(goalFile: string, record: GoalExecutio
 }
 
 export interface SelfImplementOptions {
+  /** Parent managed-task cancellation, linked to the active implementation child. */
+  signal?: AbortSignal;
   /** ⭐ 걸음을 «호출부»로 흘리는 이음매 — 노드에 들어갈 때마다 한 번.
    *  🩸 2026-09-08: 이 콜백은 «내부에» 있었고 ***호출부가 0*** 이라 걸음이 런 밖으로 안 나갔다.
    *    ⇒ 런 슈퍼바이저는 「시도의 요약 판정」만 보고 「어떻게 걸었나」를 «못 봤다».
@@ -3012,8 +3024,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 {
@@ -3022,7 +3034,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) {
@@ -3566,15 +3580,22 @@ async function autohealRecordedStop(stopEntry: RunLedgerEntry, s: SelfImplementS
   try {
     const record = readRunStopRecord(stopEntry);
     if (!record) return;
+    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 */ }
     if (result.action === 'needs-owner') {
       try {
         const stopKey = JSON.stringify([stopEntry.timestamp, record.site ?? '', record.class, record.cause, record.evidenceRef]);
@@ -3592,6 +3613,40 @@ 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,
+    mergeReason: result.mergeReason,
+    abandonedClassification: result.abandonedClassification?.classification,
+    providerErrorCategory: result.providerErrors?.category,
+    supervisorVerdict: result.supervisorVerdict,
+  });
+  let stopEntry: RunLedgerEntry | undefined;
+  try {
+    stopEntry = recordRunStop({
+      runId,
+      ...(goalId ? { goalId } : {}),
+      shardIdentity,
+      site: mergeHeld ? 'merge-hold' : `terminal-${result.stage}`,
+      class: stopClass,
+      cause: mergeHeld ? `merge held: ${result.mergeReason}` : result.detail ?? `terminal failure: ${result.stage}`,
+      evidenceRef: result.prUrl ?? `run-ledger:${runId}:${result.stage}`,
+      nextMove: `Existing heal ladder: ${stopClass}; failure disposition remains until its prescribed action resolves`,
+    }, 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);
@@ -3759,17 +3814,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;
@@ -3806,18 +3864,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 로 죽었는데 부모가 남긴 것은
@@ -4106,6 +4189,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,
@@ -4285,6 +4369,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,
@@ -4305,6 +4394,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) {
@@ -4316,20 +4406,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
@@ -4418,6 +4512,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) {
@@ -4427,6 +4522,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
@@ -4487,9 +4583,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
@@ -4950,6 +5049,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'] },
@@ -4986,13 +5117,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,
@@ -5003,7 +5135,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.
@@ -5044,9 +5192,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;
@@ -5054,6 +5209,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 } : {}),
@@ -5078,13 +5236,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;
@@ -5101,6 +5261,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);
   // ⛔ 선택을 «전부» 싣는다 — 얹힌 것만 실으면 「왜 안 얹혔나」를 사후에 못 묻는다.
@@ -5114,7 +5296,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;
@@ -5134,6 +5316,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` 가 그 둘을 가른다: 배선이 돌면 이 줄이 있고, 그 수가 «본 오버레이 수»다.
@@ -5172,7 +5364,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', {
@@ -5465,13 +5657,20 @@ async function runSelfImplementInner(
   }
 
   // The repository copy travels with both local and Pod worktrees. Operational HQ ledgers are never read here.
-  const knowhow = selectKnowhowPack(wt.path, opts.feature);
-  if (knowhow.text) round0Feature = `${knowhow.text}\n\n${round0Feature}`;
+  const knowhow = selectKnowhowPack(
+    wt.path,
+    opts.feature,
+    undefined,
+    { goalFile: opts.goalFile ?? null },
+  );
+  // Keep the original ask first: the child preflight and PR title read its first line.
+  const injectKnowhow = getUserConfig().harness?.knowhowChildInjection === true;
+  if (injectKnowhow && knowhow.text) round0Feature = `${round0Feature}\n\n${knowhow.text}`;
   const knowhowRevisionRead = runGitCommand(wt.path, ['rev-parse', '--verify', 'HEAD'], { encoding: 'utf8', timeout: 10_000 });
   const knowhowRevision = knowhowRevisionRead.status === 0 && /^[0-9a-f]{40,64}$/i.test(knowhowRevisionRead.stdout.trim())
     ? knowhowRevisionRead.stdout.trim() : null;
-  observe('knowhow-pack', { ids: knowhow.ids, bytes: knowhow.bytes, injected: knowhow.bytes > 0,
-    reason: knowhow.reason, repoPath: wt.path, repoRevision: knowhowRevision });
+  observe('knowhow-pack', { goal: opts.feature.slice(0, 4096), ids: knowhow.ids, bytes: knowhow.bytes, sources: knowhow.sources ?? [], injected: injectKnowhow && knowhow.bytes > 0,
+    reason: knowhow.reason, knowhowReason: knowhow.knowhowReason ?? knowhow.reason, repoPath: wt.path, repoRevision: knowhowRevision });
 
   // E1 착수 구체화(RFC-progressive-goal-elaboration §2 E1 · §7 간선 ①) — 고정 층(KPI·판정 신호)은 그대로, 카드만 덧붙인다.
   const elaboration = await (await import('./goal-elaborate.js')).runArrivalElaboration({ goal: opts.feature, prompt: round0Feature, cwd: wt.path, callLLM: s.elaborateCallLLM, observe });
@@ -7269,7 +7468,34 @@ 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();
+    else opts.signal?.addEventListener('abort', abortImplementation, { once: true });
     let implementPromise: ReturnType<SelfImplementSeams['implement']>;
     // Rework needs landed sibling PRs only after the initial round; shard eligibility avoids an expensive impossible lookup.
     const landedSiblings = round > 0
@@ -7292,7 +7518,7 @@ async function runSelfImplementInner(
       ...(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) {
@@ -7336,7 +7562,10 @@ async function runSelfImplementInner(
       }
       finalizeSupervisorDeliveries(error instanceof StepTimeoutError ? 'next-round-implement-timeout' : 'next-round-implement-rejected');
       throw error;
+    } finally {
+      opts.signal?.removeEventListener('abort', abortImplementation);
     }
+    if (opts.signal?.aborted) throw opts.signal.reason ?? new Error('SelfImplement aborted');
     // ⭐ 성공 경로에서도 닫는다 — 이 호출은 끝났고, 이후 자식이 늦게 보내는 입력은
     //   「이 라운드의 재투입」이 아니다(다음 라운드는 자기 콜백을 새로 만든다).
     closeSupervisorInput();
@@ -7452,6 +7681,69 @@ async function runSelfImplementInner(
         impl = { ...impl, ok: true, completionDisposition: undefined };
       }
     }
+    // ⭐ TDD 를 로직으로(S4) — 문면(device-first 조각 계획)이 아니라 실행 판정으로 끼운다.
+    //   ① 자식의 [tdd-red]/[tdd-green] 기록을 태그·같은 명령·결과로 판정한다.
+    //   ② 첫 조각 커밋의 피처 시험·구현 전 실행 RED 기록과 구현 뒤 같은 명령 GREEN 기록이
+    //     없으면 수리 라운드 1회(완료 경계·기존 동작은 보존), 그래도 없으면 fail-closed.
+    //   ③ 관측 원장에 tdd-red/tdd-green 이벤트를 남긴다.
+    let tddJudgment = judgeTddEvidence(roundGoal, parseOffDiffEvidence(impl.evidenceTranscript?.trim() || impl.summary));
+    if (tddJudgment.needsRepair && impl.ok && round < effectiveMax && opts.goalFile
+      && !hasCurrentProviderError() && !hasCurrentCredentialFailure()) {
+      let goalDocument: string | undefined;
+      try { goalDocument = readFileSync(opts.goalFile, 'utf8'); } catch { goalDocument = undefined; }
+      if (goalDocument !== undefined) {
+        const tddRetryNote = [
+          '[구현 재작업 · tdd-evidence-missing]',
+          `대상 경로: ${declaredPathsFromGoalDocumentText(goalDocument).paths.join(' · ') || '골 문서에 선언된 대상 경로 없음'}`,
+          '첫 조각 커밋에 피처 시험을 먼저 쓰고 구현 전 실행 RED 기록을 남기고, 구현 뒤 같은 명령의 GREEN 기록을 남겨라.',
+          "기록 양식(두 줄씩): 'EVIDENCE: [tdd-red] <무엇을 확인했나> || <증거 명령>' 다음 줄 'RESULT: <실패 요약 한 줄>' ·",
+          "'EVIDENCE: [tdd-green] <무엇을 확인했나> || <같은 증거 명령>' 다음 줄 'RESULT: <통과 요약 한 줄>'.",
+          `지금 잡힌 결손: ${tddJudgment.missing.join(' · ')}`,
+          '원래 골 문서(완료 경계 포함):',
+          goalDocument,
+        ].join('\n');
+        const tddRetryRound = round + 1;
+        observe('implementation-tdd-rework', { status: 'started', round: tddRetryRound, missing: [...tddJudgment.missing] }, { level: 'warn' });
+        progress('implementing', `[구현 재작업 · tdd-evidence-missing] 수리 라운드 ${tddRetryRound} 시작 — RED/GREEN 기록 결손`);
+        onNodeEntry(node('rework'), tddRetryRound);
+        onNodeEntry(node('implement'), tddRetryRound);
+        const tddRetryAbort = new AbortController();
+        const beforeTddRetry = impl;
+        let tddRetryImpl = impl;
+        try {
+          tddRetryImpl = await stepTimeout(s.implement({
+            sessionId, cwd: wt.path, feature: `${feature}\n\n${tddRetryNote}`, runId, shardIdentity, signal: tddRetryAbort.signal,
+            ...(harnessSeededPaths.length ? { harnessSeededPaths } : {}),
+            onSurfaceProgress: (line) => progress('implementing', line.trimEnd()),
+            roundContext: { round: tddRetryRound, effectiveMax, previousRoundFailure: tddRetryNote },
+            ...(opts.childLlm ? { childLlm: opts.childLlm } : {}),
+            ...(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));
+        if (tddRetryImpl.ok && !tddRetryJudgment.needsRepair) {
+          observe('implementation-tdd-rework', { status: 'succeeded', round: tddRetryRound, missing: [] });
+          tddJudgment = tddRetryJudgment;
+          impl = tddRetryImpl;
+          round = tddRetryRound;
+        } else {
+          observe('implementation-tdd-rework', { status: 'exhausted', round: tddRetryRound, missing: [...tddRetryJudgment.missing] }, { level: 'warn' });
+          impl = { ...beforeTddRetry, ok: false, summary: `[구현 재작업 · tdd-evidence-missing] RED/GREEN 기록 결손 — ${beforeTddRetry.summary}` };
+        }
+      }
+    }
+    observe('tdd-red', {
+      round, planned: tddJudgment.planned, observed: tddJudgment.red.observed, missing: tddJudgment.red.observed ? [] : ['tdd-red'],
+      verify: tddJudgment.red.verify ?? null, result: tddJudgment.red.result ?? null,
+    }, tddJudgment.planned && !tddJudgment.red.observed ? { level: 'warn' } : {});
+    observe('tdd-green', {
+      round, planned: tddJudgment.planned, observed: tddJudgment.green.observed, sameCommand: tddJudgment.sameCommand,
+      missing: tddJudgment.green.observed && tddJudgment.sameCommand ? [] : ['tdd-green'],
+      verify: tddJudgment.green.verify ?? null, result: tddJudgment.green.result ?? null,
+    }, tddJudgment.planned && !(tddJudgment.green.observed && tddJudgment.sameCommand) ? { level: 'warn' } : {});
     // A finished child can leave edits without a commit. Measure them before any
     // diff/no-changes classification, and commit only paths declared in the goal.
     finishedChildCommitMissing = false;
@@ -9046,9 +9338,9 @@ async function runSelfImplementInner(
       const mergedBase = m.baseRefName?.trim() || observedPrBase;
       if (mergedBase && displayBranchName(mergedBase) === 'main') {
         try {
-          const { syncMergedPrChecklist } = await import('../release-loop/merged-pr-checklist.js');
+          const { syncMergedPrChecklistWithFeedback } = await import('../release-loop/merged-pr-checklist.js');
           const goalFile = opts.goalFile ?? (opts.goalId ? s.goalDocumentPathByGoalId?.(opts.goalId) : undefined);
-          syncMergedPrChecklist(pr.number, wt.path, goalFile);
+          await syncMergedPrChecklistWithFeedback(pr.number, wt.path, goalFile);
         } catch (error) {
           observe('merged-pr-checklist-sync-failed', { number: pr.number, error: safeErrorDescription(error) }, { level: 'warn' });
         }