elanous 0.2.22 → 0.2.24

package/src/self-implement/orchestrator.ts

@@ -31,7 +31,8 @@ export {
   type PrEvidenceInput,
 } from './pr-evidence-artifact.js';
 import { judgePredictionAccuracy } from './judge-prediction-accuracy.js';
-import { measureReviewFindingRecurrence, type ReviewFindingRecurrence } from './review-finding-recurrence.js';
+import { classifyPodReviewBudgetResidue, measureReviewFindingRecurrence, type ReviewFindingRecurrence, type RecurrenceFinding } from './review-finding-recurrence.js';
+import type { ReviewRework } from '../self-dev/run-types.js';
 import { createHash } from 'node:crypto';
 import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import { writeGoalDocumentAtomic } from './goal-document-write.js';
@@ -64,7 +65,7 @@ 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, readRunStopRecord, recordRunStop, runStopRecorded } from './run-stop.js';
+import { classifyMergeHoldStop, forgetRunStop, isRunStopClass, readRunStopRecord, recordRunStop, runStopRecorded } from './run-stop.js';
 import { autohealFromStop, parseAutohealMode, type AutohealActions, type AutohealResult } from './stop-autoheal.js';
 import { emitSessionEvent, type SessionEventInput } from '../context-bus/session-events.js';
 import { decideLineageSupersede, lineageSupersedeCloseComment, type LineageSupersedeOpenDraft } from './lineage-supersede.js';
@@ -80,7 +81,7 @@ import { releasePathHold, releasePathHoldComment, RELEASE_PATH_LABEL } from '../
 import { emitDecision } from '../live/detail-switch.js';
 import { reworkDecision } from './decision-events.js';
 import type { LogSink } from '../mss/logging/sink.js';
-import type { LogQuery, LogStoreRow } from '../mss/logging/log-store.js';
+import { LogStore, logsDbPath, type LogQuery, type LogStoreRow } from '../mss/logging/log-store.js';
 import { refreshCodexQuotaSignals } from '../budget/codex-quota-refresh.js';
 import { inspectActiveProvider, type ActiveProviderInfo } from '../provider-summary.js';
 import { recordHitlEvent } from '../self-dev/hitl-log.js';
@@ -108,7 +109,7 @@ import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { addNextMdReleaseNote, harnessReleaseNote, parseReleaseNoteSection, releaseNotesDir, renderReleaseNoteSection, writeReleaseNote, type ReleaseNoteFragment, type ReleaseNoteSection } from '../release-loop/release-note.js';
 import { landingFreezeMessage } from '../release-loop/landing-freeze.js';
 import { admitLandingMerge, owningRepoRoot } from './frozen-merges.js';
-import { recordFollowUpOnMerge, type FollowUpMergeInput, type FollowUpSeams } from './follow-up-goals.js';
+import { recordFollowUpOnBlocked, recordFollowUpOnMerge, type FollowUpBlockedInput, type FollowUpMergeInput, type FollowUpSeams } from './follow-up-goals.js';
 
 /** Merge result and exit stay untouched: a draft failure is one debug line. */
 async function draftFollowUpAfterMerge(input: FollowUpMergeInput, followUp: FollowUpSeams | undefined): Promise<void> {
@@ -128,10 +129,30 @@ async function draftFollowUpAfterMerge(input: FollowUpMergeInput, followUp: Foll
     debug.log('self-implement.follow-up', 'draft-failed', { prNumber: input.prNumber, error: error instanceof Error ? error.message : String(error) });
   }
 }
+
+async function draftFollowUpAfterBlocked(input: FollowUpBlockedInput, followUp: FollowUpSeams | undefined): Promise<void> {
+  try {
+    await recordFollowUpOnBlocked(input, {
+      ...(followUp ? {
+        ...(followUp.mode ? { mode: followUp.mode } : {}),
+        ...(followUp.readDrafts ? { readDrafts: followUp.readDrafts } : {}),
+        ...(followUp.appendDraft ? { appendDraft: followUp.appendDraft } : {}),
+        ...(followUp.enqueue ? { enqueue: followUp.enqueue } : {}),
+        ...(followUp.cellOwner ? { cellOwner: followUp.cellOwner } : {}),
+        ...(followUp.stateRoot ? { stateRoot: followUp.stateRoot } : {}),
+      } : {}),
+      log: (category, event, data) => { debug.log(category, event, data); },
+    });
+  } catch (error) {
+    debug.log('self-implement.follow-up', 'draft-failed', { ending: 'blocked', runId: input.runId, prNumber: input.prNumber ?? 0, stage: input.stage, error: error instanceof Error ? error.message : String(error) });
+  }
+}
 import { plannedSelfImplBranch } from '../harness/worktree-branch-prefix.js';
 export { slugifyFeature } from '../harness/worktree-branch-prefix.js';
 import { AUTO_REVIEW_LABEL, resolveAutoReviewLabels } from './context-capsule.js';
 import { GOAL_TYPES, extractVerbatimOriginalAsk, leadingGoalMetadata, parseAskFile, parseGoalType, type GoalType } from './goal-author.js';
+import { renderRoundSummaryCard, type RoundSummaryEntry } from './round-summary-card.js';
+import { computeFlexSignals } from './flex-signals.js';
 import { resolveAdaptiveMaxReworkDecision, resolveEscalateTier, resolveEscalateTarget, buildReworkFeature, failIndicator, isRepeatedUnverifiedOnlyGateFailure, unverifiedRepeatKey, appendReworkHistory, truncateReworkHistoryByItem, applyReworkBudgetDecision, parseContractConflictRelaxation, parseReworkBudgetDecision, resolveReworkBudgetCarry, stripReworkBudgetHeaders, countConsecutiveMustFixIds, mergeReworkNotes, resolveReworkKind, type ReworkPlanRevision, type ReworkNotePart } from './rework-policy.js';
 import type { SupervisionReworkSource } from './supervision-vocabulary.js';
 import { classifyReworkBudgetShadow } from './classify-shadow.js';
@@ -139,7 +160,7 @@ import { createReworkBudgetJudgment, REWORK_BUDGET_JUDGMENT, reworkBudgetEvidenc
 import { runWorkflowToCompletion } from '../workflow-runtime/executor.js';
 import { mapReworkVerdict, supervisionObservationFields } from './supervision-vocabulary.js';
 import { resolveRunOutcome } from './run-outcome.js';
-import { authorLimitationCountFromGoal, harvestEvidenceLines, harvestedEvidenceObservation, MAX_HARVESTED_EVIDENCE_CHARS, parseOffDiffEvidence, requiredEvidenceFromGoal, runRequiredEvidenceChecks, coverRequiredEvidence, type OffDiffEvidenceParse } from './off-diff-evidence.js';
+import { authorLimitationCountFromGoal, harvestEvidenceLines, harvestedEvidenceObservation, MAX_HARVESTED_EVIDENCE_CHARS, parseOffDiffEvidence, requiredEvidenceFromGoal, runRequiredEvidenceChecks, coverRequiredEvidence, formatUncoveredEvidenceFeedback, type OffDiffEvidenceParse } from './off-diff-evidence.js';
 import { pressDecisionSignals, type DecisionSignalPressResult } from './decision-signal-press.js';
 import { inspectDecisionObservations, inspectDecisionSignalKinds, inspectDecisionSignalObservations } from '../../scripts/ask-marker-check.js';
 
@@ -227,11 +248,12 @@ import { persistReviewArtifact, type ReviewArtifactWriter } from '../agent-subst
 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 { 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, pipelineNodeEntryPayload } from './graph-templates.js';
-import { AMBIGUOUS_STAGES, checkPipelineTraversal, nodesForStage, pipelineGraphIdentity, type PipelineNodeId, type PipelineTraversalCheck } from './pipeline-shape.js';
+import { graphIdentityOf, measureL0Coverage, pipelineNodeEntryPayload } from './graph-templates.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';
 import { format as formatPrComment, type PrCommentRole } from '../agent-substrate/pr-comment-meta.js';
@@ -767,7 +789,9 @@ function changedFileIsInsideDeclaredTarget(changedFile: string, declaredPath: st
   const target = normalizeDeclaredScopePath(declaredPath);
   if (!file || !target) return false;
   return file === target || file.startsWith(`${target}/`)
-    || (target.endsWith('.ts') && !target.endsWith('.test.ts') && file === `${target.slice(0, -3)}.test.ts`);
+    || (target.endsWith('.ts') && !target.endsWith('.test.ts') && file === `${target.slice(0, -3)}.test.ts`)
+    // SCOPE-LOCKFILE-PAIR — 선언한 package.json 을 고치면 같은 폴더의 bun.lock 이 따라 바뀐다(10-11 TSGO-TRIAL 이 bun.lock 하나로 보류).
+    || ((target === 'package.json' || target.endsWith('/package.json')) && file === `${target.slice(0, -'package.json'.length)}bun.lock`);
 }
 
 function parseDeclaredTargetPathsFromAsk(askText: string): { readable: boolean; paths: readonly string[] } {
@@ -784,10 +808,20 @@ function parseDeclaredTargetPathsFromAsk(askText: string): { readable: boolean;
   return { readable: true, paths: [...new Set(paths.filter(Boolean))] };
 }
 
+// SCOPE-NEW-FILES-LINE — 칸 문면은 새로 만들 파일을 «신설:» 줄로 따로 적는다(OP D칸 규칙). 그 줄도 선언 범위다.
+//   10-11 FLEX-SIGNALS run-95799887: 칸이 적은 신설 파일 둘을 «범위 밖»으로 세어 구현을 보류했다.
+const DECLARED_NEW_FILES_LINE = /^\s*(?:신설|new\s*files?)\s*[:：]\s*(.*)$/i;
+
 function declaredPathsFromGoalDocumentText(document: string): { readable: boolean; paths: readonly string[] } {
   const originalAsk = extractVerbatimOriginalAsk(document)?.ask ?? null;
   if (originalAsk === null) return { readable: false, paths: [] };
-  return parseDeclaredTargetPathsFromAsk(originalAsk);
+  const declared = parseDeclaredTargetPathsFromAsk(originalAsk);
+  if (!declared.readable) return declared;
+  const newFiles = originalAsk.split(/\r?\n/).flatMap((line) => {
+    const match = DECLARED_NEW_FILES_LINE.exec(line);
+    return match ? parseDeclaredTargetPathsFromAsk(`대상 경로: ${match[1]}`).paths : [];
+  });
+  return newFiles.length > 0 ? { readable: true, paths: [...new Set([...declared.paths, ...newFiles])] } : declared;
 }
 
 /** Only paths explicitly designated as targets in the ask or piece text protect an intentional revert. */
@@ -817,6 +851,11 @@ function revertGuardTargetPaths(feature: string, goalDocument?: string): string[
   return [...new Set([...declaredRevertGuardPaths(feature), ...(originalAsk ? declaredRevertGuardPaths(originalAsk) : [])])];
 }
 
+/** 하니스가 작업 트리에 잠깐 쓰는 임시물 — 범위 판정·결정 카드에서 뺀다. */
+export function isHarnessTempArtifact(file: string): boolean {
+  return /(^|\/)\.elanous-typecheck-scope-[^/]+\.json$/.test(file);
+}
+
 export function detectDeclaredScopeDiff(input: {
   goalDocument?: string | null;
   changedFiles?: readonly string[] | null;
@@ -2256,6 +2295,7 @@ export interface SelfImplementResult {
   branch?: string;
   gate?: SelfImplementGateResult;
   review?: SelfImplementReview;
+  rework?: ReviewRework;
   /** Worktree commit observed while this review ran; not inferred from the later PR head. */
   reviewedHeadCommit?: string;
   completionDisposition?: SelfImplementCompletionDisposition;
@@ -3545,6 +3585,29 @@ async function autohealRecordedStop(stopEntry: RunLedgerEntry, s: SelfImplementS
   }
 }
 
+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);
+  const seen = new Set<string>();
+  let resurfaced = false;
+  for (let index = 0; index < findings.length; index++) {
+    const ids = new Set(findings[index]!.map((finding) => finding.id));
+    if (index > 0 && [...ids].some((id) => seen.has(id) && !findings[index - 1]!.some((finding) => finding.id === id))) {
+      const prior = findings.slice(0, index - 1).reverse().find((round) => round.some((finding) => ids.has(finding.id)));
+      if (prior && measureReviewFindingRecurrence(findings[index], prior)?.normalizedRepeatedReviewFindingCount) resurfaced = true;
+    }
+    for (const id of ids) seen.add(id);
+  }
+  const trend: ReviewRework['trend'] = resurfaced || directions.some((delta) => delta !== directions[0])
+    ? 'oscillating'
+    : counts.length < 2 ? 'unmeasured'
+    : deltas.every((delta) => delta < 0) ? 'improving'
+    : deltas.every((delta) => delta === 0) ? 'stable'
+    : counts.at(-1)! > counts[0]! && deltas.every((delta) => delta >= 0) ? 'worsening'
+    : 'stable';
+  return { trend, signature: [...new Set((findings.at(-1) ?? []).map((finding) => finding.id))].sort().join(','), rounds: counts.length };
+}
+
 export async function runSelfImplement(opts: SelfImplementOptions): Promise<SelfImplementResult> {
   if (opts.childLlm && (typeof opts.childLlm.provider !== 'string' || !opts.childLlm.provider.trim() || typeof opts.childLlm.model !== 'string' || !opts.childLlm.model.trim())) {
     throw new Error('childLlm.provider and childLlm.model must both be non-empty');
@@ -3609,6 +3672,13 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
   let roundCount = 0;
   let lastTier: EscalateTier | undefined;
   let lastReviewFindings: string[] | undefined;
+  let measuredRework: ReviewRework | undefined;
+  const withMeasuredRework = (result: SelfImplementResult): SelfImplementResult => {
+    if (!measuredRework) return result;
+    const classification = result.abandonedClassification?.classification;
+    // An empty must-fix set stays an empty signature: a bare classification prefix would make two clean reviews «match».
+    return { ...result, rework: { ...measuredRework, signature: `${classification && measuredRework.signature ? `${classification}:` : ''}${measuredRework.signature}` } };
+  };
   let reviewFindingRoundCount = 0;
   const verbatimReviewFindingOccurrences = new Map<string, number>();
   const normalizedReviewFindingFirstSeenRounds = new Map<string, number>();
@@ -3958,6 +4028,62 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
   const finalizeTraversal = (): void => {
     if (traversalFinalized) return;
     traversalFinalized = true;
+    if (terminalResult?.ok && runGraphTemplate?.graphId === 'self-implement') {
+      const entered = new Set<string>(traversedNodes);
+      let journeyRowsRead = false;
+      const path = logsDbPath();
+      if (existsSync(path)) {
+        let store: LogStore | undefined;
+        try {
+          store = LogStore.openReadOnly(path);
+          const join = journeyJoinFields();
+          const rows = [
+            ...store.queryByDataKeys({ exactCategories: ['self-implement'], runIds: [runId] }),
+            ...(join.journeyKey ? store.queryAll({ exactCategories: ['self-implement'], events: ['pipeline-node-entry'], grep: join.journeyKey }) : []),
+            ...(join.queueLaunchId ? store.queryAll({ exactCategories: ['self-implement'], events: ['pipeline-node-entry'], grep: join.queueLaunchId }) : []),
+          ];
+          for (const row of rows) {
+            if (row.event !== 'pipeline-node-entry' || !row.data) continue;
+            let data: { runId?: string; journeyKey?: string; queueLaunchId?: string; graphId?: string; graphVersion?: string; node?: string; phase?: string };
+            try { data = JSON.parse(row.data); } catch { continue; }
+            const sameRun = data.runId === runId || (data.runId === undefined && (
+              (join.journeyKey !== undefined && data.journeyKey === join.journeyKey)
+              || (join.queueLaunchId !== undefined && data.queueLaunchId === join.queueLaunchId)
+            ));
+            if (sameRun && data.phase === 'journey' && data.graphId === runGraphTemplate.graphId && data.graphVersion === runGraphTemplate.version && typeof data.node === 'string') {
+              entered.add(data.node);
+              journeyRowsRead = true;
+            }
+          }
+        } catch { /* observation failure must not fail the run */ }
+        finally { store?.close(); }
+      }
+      // Only nodes this process runs (TERMINAL_STAGES_BY_NODE) can be «skipped» with certainty:
+      // their non-entry here means the condition was false. Nodes run by other processes
+      // (author · intake · dispatch · pod …) that were not joined stay «unjoined» — not
+      // skipped and not accounted — so the walk ratio can fall below 1.0.
+      const skipped = new Set<string>();
+      const unjoined: string[] = [];
+      for (const node of runGraphTemplate.nodes) {
+        if (entered.has(node.nodeId)) continue;
+        if (!Object.hasOwn(TERMINAL_STAGES_BY_NODE, node.nodeId)) { unjoined.push(node.nodeId); continue; }
+        const condition = node.nodeId === 'rework' ? 'gate/review passed'
+          : node.nodeId === 'main-sync' || node.nodeId === 'regate' ? 'mergeMain && commitWork'
+          : 'completion disposition';
+        observeOuter('node-skipped', {
+          ...graphIdentityOf(runGraphTemplate), ...journeyJoinFields(),
+          node: node.nodeId, reason: 'condition', condition,
+        }, { category: 'graph.path' });
+        skipped.add(node.nodeId);
+      }
+      const coverage = measureL0Coverage(runGraphTemplate, entered, skipped);
+      observeOuter('l0-coverage', {
+        ...graphIdentityOf(runGraphTemplate), ...journeyJoinFields(),
+        ...coverage,
+        journeyRowsRead,
+        unjoinedNodes: unjoined,
+      }, { category: 'graph.path' });
+    }
     try {
       const checked = terminalNode
         ? (opts.seams.checkPipelineTraversal ?? checkPipelineTraversal)(traversedNodes, terminalNode)
@@ -4123,6 +4249,7 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
       },
       observeRoundExecution,
       observeReviewFindings,
+      (rework) => { measuredRework = rework; },
       setRunGraphIdentity,
       (template) => { runGraphTemplate = template; },
       // ⭐ 「요구 증거 충족」을 받아 결과에 실어 원장까지 나른다(`JDG-T60`)
@@ -4176,7 +4303,7 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
     if (lastCredentialFailure) {
       observeOuter('credential-failure-observed', { count: credentialFailureCount, ...lastCredentialFailure });
     }
-    terminalResult = withEvidenceCoverage(addressedResult);
+    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 reason = addressedResult.mergeReason;
@@ -4239,7 +4366,7 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
     });
     observeRunRollup(observeOuter, addressedResult, roundClassifications, roundCount, capturedPrNumber, openPrInvoked);
     observeProgressDelivery();
-    return addressedResult;
+    return terminalResult;
   } catch (e) {
     if (e instanceof StepTimeoutError) {
       observeOuter('step-timeout', { step: e.step, ms: e.ms, branch, feature: opts.feature.slice(0, 80) }, { level: 'warn' });
@@ -4272,7 +4399,7 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
       if (lastCredentialFailure) {
         observeOuter('credential-failure-observed', { count: credentialFailureCount, ...lastCredentialFailure });
       }
-      terminalResult = addressedResult;   // ⛔ 이 분기(StepTimeoutError)는 스코프가 달라 부착 헬퍼가 «안 보인다» — 타임아웃 런은 달성 근사값이 «없다»(0 으로 채우지 않는다)
+      terminalResult = withMeasuredRework(addressedResult);   // ⛔ 이 분기(StepTimeoutError)는 스코프가 달라 달성 근사값은 «없다»(0 으로 채우지 않는다)
       observeDeclaredScopeDiff(observeOuter, {
         goalFile: opts.goalFile,
         changedFiles: opts.goalFile && addressedResult.worktreePath
@@ -4314,7 +4441,7 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
       });
       observeRunRollup(observeOuter, addressedResult, roundClassifications, roundCount, capturedPrNumber, openPrInvoked);
       observeProgressDelivery();
-      return addressedResult;
+      return terminalResult;
     }
     recordHitlEvent({
       kind: 'escalation',
@@ -4743,6 +4870,7 @@ async function runSelfImplementInner(
   onWorktreeCreated: (path: string) => void = () => {},
   onRoundExecution: (tier: EscalateTier) => void = () => {},
   onReviewFindings: (round: number, mustFix: readonly string[]) => void = () => {},
+  onReworkMeasured: (rework: ReviewRework) => void = () => {},
   /** ⭐ 이 런이 «따르는» 그래프 신원 — 맥락이 정해진 «직후» 한 번 불린다.
    *  ⛔ 이것이 없으면 걸음은 YAML 을 따르고 «신원은 옛 TS 상수»를 따라 둘이 갈린다. */
   onGraphResolved: (identity: { graphId: string; graphVersion: string }) => void = () => {},
@@ -4834,9 +4962,11 @@ async function runSelfImplementInner(
     writeFileSync(graphFile, stringify({
       graph_id: variantSpec.graphId, version: variantSpec.version,
       entry_node: variantSpec.entryNode, terminal_nodes: variantSpec.terminalNodes,
+      ...(variantSpec.journeyStages ? { journey_stages: variantSpec.journeyStages } : {}),
       ...(variantSpec.runContract ? { run_contract: variantSpec.runContract } : {}),
       nodes: variantSpec.nodes.map(n => ({
         node_id: n.nodeId, kind: n.kind, recipe: n.recipe, max_visits: n.maxVisits,
+        ...(n.journeyStage ? { journey_stage: n.journeyStage } : {}),
         ...(n.progress ? { progress: n.progress } : {}), ...(n.phases ? { phases: n.phases } : {}),
         ...(n.terminalStages ? { terminal_stages: n.terminalStages } : {}),
         ...(n.fanOut ? { fan_out: n.fanOut } : {}), ...(n.contract ? { contract: n.contract } : {}),
@@ -4868,6 +4998,7 @@ async function runSelfImplementInner(
   // ⛔ 승격이 꺼져 있으면 «심지 않는다» — 그러면 예산 관측도 안 난다(운영 원장이 오늘과 같다).
   if (graphAuthority.enabled) onGraphTemplateResolved(graphTemplate);
   // ⛔ 선택을 «전부» 싣는다 — 얹힌 것만 실으면 「왜 안 얹혔나」를 사후에 못 묻는다.
+  let reviewRepeat: number | undefined;
   /** ⭐ ③ «다이나믹» — 라운드마다 runtime 오버레이를 다시 고른다.
    *  ⛔ **매번 «기준 선언»에서 다시 얹는다** — 이전 라운드 결과 위에 겹쳐 얹으면
    *    「이 걸음을 무엇이 만들었나」가 «누적»이 되어 사후에 못 푼다.
@@ -4875,7 +5006,19 @@ async function runSelfImplementInner(
   const applyRuntimeOverlays = (round: number): void => {
     if (!graphAuthority.enabled) return;
     // ⛔ 「지금 아는 것」만 준다 — 없는 값을 0 으로 지어내지 않는다(key-absent 가 그것을 말한다).
-    const runtimeOverlayState = { attempts: round, ...(opts.goalId === undefined ? {} : { goal_id: opts.goalId }) };
+    let stopClass: import('./run-stop.js').RunStopClass | undefined;
+    try {
+      const { runId } = identity ?? resolveRunIdentity({ explicit: opts.runId });
+      const entries = loadRunLedger(runId);
+      const lastStop = entries?.slice().reverse().find((entry) => entry.event === 'stop');
+      if (lastStop && isRunStopClass(lastStop.data.class)) stopClass = readRunStopRecord(lastStop)?.class;
+    } catch { /* Unreadable STOP-RECORD is unknown, not an invented class. */ }
+    const runtimeOverlayState = buildRuntimeOverlayState({
+      attempts: round,
+      ...(opts.goalId === undefined ? {} : { goalId: opts.goalId }),
+      ...(stopClass === undefined ? {} : { stopClass }),
+      ...(reviewRepeat === undefined ? {} : { reviewRepeat }),
+    });
     const decision = decideTemplate({
       goalType: graphGoalType,
       authority: graphAuthority,
@@ -5210,6 +5353,7 @@ async function runSelfImplementInner(
   let offDiffEvidence: OffDiffEvidenceParse = { items: [], discardedMissingVerify: 0, discardedEmptyClaim: 0, missingResult: 0, orphanResult: 0, truncatedResult: 0, anchoredEvidence: 0 };
   let evidenceSource: 'diff-added-lines' | 'harvested' | 'summary-tail' = 'summary-tail';
   // ⛔⭐ 하니스가 센 증거 충족도 — **로그에만 남기면 판정자가 못 본다**(원장 `JDG-S4`·`JDG-S5`).
+  let uncoveredFeedbackUsed = false;
   let evidenceCoverage: {
     required: number;
     covered: number;
@@ -5228,6 +5372,8 @@ async function runSelfImplementInner(
   /** Review-budget leftovers and the body that carried them, so a later merge drafts from the same text. */
   let preparedReviewBudgetPrBody: string | undefined;
   const reviewMustFixCountHistory: number[] = [];
+  const reviewedFindings: RecurrenceFinding[][] = [];
+  const structuredRework = (): ReviewRework => measureReviewRework(reviewMustFixCountHistory, reviewedFindings);
   const reviewMustFixTrend = (): string => {
     if (reviewMustFixCountHistory.length < 2) return '아직 못 잰다';
     return reviewMustFixCountHistory.every((count, index) => index === 0 || count < reviewMustFixCountHistory[index - 1]!)
@@ -5337,6 +5483,7 @@ async function runSelfImplementInner(
   // 직전 gate 실패 라운드의 미검증 집합(정렬 키). 통과하면 비운다 — «연속» 반복만 센다.
   let lastGateUnverifiedKey: string | undefined;
   const reworkHistory: string[] = [];
+  const roundSummaryEntries: RoundSummaryEntry[] = [];
   const supervisorDecisionHistory: Array<{ round: number; verdict: ReworkBudgetVerdict; reason: string }> = [];
   let judgedEffectiveMax: number | undefined;
   let lastReworkVerdict: ReworkBudgetVerdict | undefined;
@@ -6100,7 +6247,7 @@ async function runSelfImplementInner(
     'missing-cited-path': refutations.filter(({ kind }) => kind === 'missing-cited-path').length,
     'found-cited-path': refutations.filter(({ kind }) => kind === 'found-cited-path').length,
   });
-  const acceptReviewBudget = async (unresolvedMustFix: readonly string[], hasNonReviewResidualWork: boolean) => {
+  const acceptReviewBudget = async (unresolvedMustFix: readonly string[], hasNonReviewResidualWork: boolean, repeatedPod = false) => {
     const decision = decideReworkSalvage({
       hardCapBlockedExtend: false,
       reviewBudgetExhausted: true,
@@ -6120,7 +6267,7 @@ async function runSelfImplementInner(
       }, { level: 'warn' });
       return { decision };
     }
-    const followUpMustFix = `\n\n## Follow-up must-fix (${decision.unresolvedMustFix.length})\n${decision.unresolvedMustFix.map((finding) => `- ${finding}`).join('\n')}`;
+    const followUpMustFix = `\n\n## Follow-up must-fix (${decision.unresolvedMustFix.length})\n${decision.unresolvedMustFix.map((finding) => `- ${repeatedPod ? '[repeated] ' : ''}${finding}`).join('\n')}`;
     const releaseNote = releaseNoteForRun(opts.goalFile, opts.feature);
     // openPr's default seam delegates to PrManager.upsertPr, which stages, commits,
     // and pushes this worktree after the note is written and before creating the PR.
@@ -6366,6 +6513,7 @@ async function runSelfImplementInner(
           }
         }
         const before = effectiveMax;
+        const gateBaselineOnly = baselineOnlyGate();
         const budgetDecision = applyReworkBudgetDecision(
           effectiveMax,
           parsedDecision,
@@ -6374,7 +6522,13 @@ async function runSelfImplementInner(
           priorHistory.length,
           consecutiveUnresolvedBudget >= 2 ? false : shadowStop,
           supervisorDecisionHistory.at(-1)?.verdict,
+          gateBaselineOnly,
         );
+        if (reworkKind === 'gate' && parsedDecision?.verdict === 'SUFFICIENT' && gateBaselineOnly && budgetDecision.exit === 'proceed') {
+          debug.log('self-implement.rework-budget', 'gate-sufficient-proceed', {
+            runId, round, preexisting: gate!.baselineFailures!.filter(({ attribution }) => attribution === 'preexisting').length, introduced: 0,
+          });
+        }
         effectiveMax = budgetDecision.effectiveMax;
         if (parsedDecision) {
           if (diagnosisRefutations) {
@@ -6575,12 +6729,14 @@ async function runSelfImplementInner(
             if (isReviewRework(reworkKind)) {
               if (reflectRejectedAudit.length && review) review.shouldFix = [...review.shouldFix, ...reflectRejectedAudit];
               const pr = await preserveBlockedArtifacts({ stage: 'review-blocked', verdict: parsedDecision.verdict, reason: parsedDecision.reason, gate, decomposition: terminalDecomposition, salvageStatusExpected: false });
+              await draftFollowUpAfterBlocked({ runId, prNumber: pr?.number, stage: 'review-blocked', unresolvedMustFix: review?.mustFix, decompositionPieces: terminalDecomposition?.pieces?.map((p) => p.feature), feature: opts.feature, cellId: opts.goalId, goalFile: opts.goalFile }, s.followUp);
               const quotaExhaustionAssessment = quotaExhaustionAssessmentForRun();
               return { ok: false, node: 'rework', ...terminal, ...supervisorOutcome, sessionId, worktreePath: wt.path, branch: wt.branch, gate, review, quotaExhaustionAssessment, ...(lastSupervisorReason ? { supervisorReason: lastSupervisorReason } : {}), ...reviewBlockedResult(pr), detail: `${blockedDraftPrFailure ? `${blockedDraftPrFailure}; ` : ''}rework judged unconvergeable after ${round} rework round(s): ${parsedDecision.reason}` };
             }
             const baselineStop = noRetryBaseline();
             const reason = baselineStop.terminationReason ?? parsedDecision.reason;
             const pr = await preserveBlockedArtifacts({ stage: 'gate-failed', verdict: parsedDecision.verdict, reason, gate, decomposition: terminalDecomposition, salvageStatusExpected: false });
+            await draftFollowUpAfterBlocked({ runId, prNumber: pr?.number, stage: 'gate-failed', decompositionPieces: terminalDecomposition?.pieces?.map((p) => p.feature), feature: opts.feature, cellId: opts.goalId, goalFile: opts.goalFile }, s.followUp);
             const quotaExhaustionAssessment = quotaExhaustionAssessmentForRun();
             return { ok: false, stage: 'gate-failed', node: 'rework', ...terminal, ...supervisorOutcome, ...baselineStop, sessionId, worktreePath: wt.path, branch: wt.branch, gate, quotaExhaustionAssessment, ...(lastSupervisorReason ? { supervisorReason: lastSupervisorReason } : {}), ...(pr ? { prUrl: pr.url, prNumber: pr.number } : {}), detail: baselineStop.terminationReason ?? `rework judged unconvergeable after ${round} rework round(s): ${parsedDecision.reason}` };
           }
@@ -6604,10 +6760,12 @@ async function runSelfImplementInner(
         if (isReviewRework(reworkKind)) {
           if (reflectRejectedAudit.length && review) review.shouldFix = [...review.shouldFix, ...reflectRejectedAudit];
           const pr = await preserveBlockedArtifacts({ stage: 'review-blocked', verdict: lastReworkVerdict, reason, gate, salvageStatusExpected: false });
+          await draftFollowUpAfterBlocked({ runId, prNumber: pr?.number, stage: 'review-blocked', unresolvedMustFix: review?.mustFix, feature: opts.feature, cellId: opts.goalId, goalFile: opts.goalFile }, s.followUp);
           return { ok: false, node: 'rework', ...terminal, sessionId, worktreePath: wt.path, branch: wt.branch, gate, review, quotaExhaustionAssessment: quotaExhaustionAssessmentForRun(), ...(lastSupervisorVerdict === 'CONTRACT-CONFLICT' ? { supervisorVerdict: lastSupervisorVerdict } : {}), ...reviewBlockedResult(pr), detail: blockedDraftPrFailure ?? reason };
         }
         const baselineStop = noRetryBaseline();
         const pr = await preserveBlockedArtifacts({ stage: 'gate-failed', verdict: lastReworkVerdict, reason: baselineStop.terminationReason ?? reason, gate, salvageStatusExpected: false });
+        await draftFollowUpAfterBlocked({ runId, prNumber: pr?.number, stage: 'gate-failed', feature: opts.feature, cellId: opts.goalId, goalFile: opts.goalFile }, s.followUp);
         return { ok: false, stage: 'gate-failed', node: 'rework', ...terminal, ...baselineStop, sessionId, worktreePath: wt.path, branch: wt.branch, gate, quotaExhaustionAssessment: quotaExhaustionAssessmentForRun(), ...(lastSupervisorVerdict === 'CONTRACT-CONFLICT' ? { supervisorVerdict: lastSupervisorVerdict } : {}), ...(pr ? { prUrl: pr.url, prNumber: pr.number } : {}), detail: baselineStop.terminationReason ?? reason };
       }
       const terminal = resolveRunOutcome({ termination: 'budget-exhausted', ...(lastReworkVerdict ? { lastVerdict: lastReworkVerdict } : {}) });
@@ -6620,14 +6778,38 @@ async function runSelfImplementInner(
       if (isReviewRework(reworkKind)) {
         if (reflectRejectedAudit.length && review) review.shouldFix = [...review.shouldFix, ...reflectRejectedAudit];
         const reason = `review must-fix unresolved after ${round - 1} rework round(s)`;
-        // Pod keeps review-blocked work as a labelled draft (or aborts with the preserved branch) instead of
-        // accepting the review budget into a non-draft PR — restored after #24341 (0.2.16 gate shard 5).
-        if (!podReviewBlockedDraft) {
+        const podResidue = podReviewBlockedDraft
+          ? classifyPodReviewBudgetResidue(currentBlockingFindings, previousBlockingFindings)
+          : undefined;
+        // ⛔ 사양 v2(OP 18:1x (a)): Pod 는 «전부 내용 해시(id) 반복»일 때만 수락한다 — 키로만 반복된 지적은 draft.
+        //   수락은 draft→non-draft ⊕ followUpMustFix 기록까지다. 병합 판단은 언제나 hitl(자동 병합 없음 · #25941
+        //   `review-warn-with-must-fix` 와 같은 방향 — must-fix 가 남은 런은 어느 출구로도 자동 병합하지 않는다).
+        const podAcceptable = podResidue?.status === 'all-repeated' && podResidue.keyOnlyRepeatedIds.length === 0;
+        const podDecision = (accepted: boolean) => {
+          if (!podResidue) return;
+          debug.log('self-implement.review-budget', 'pod-accept-decision', {
+            runId, status: podResidue.status, repeatedCount: podResidue.repeatedIds.length,
+            newCount: podResidue.newIds.length, keyOnlyRepeatedCount: podResidue.keyOnlyRepeatedIds.length,
+            accepted, merge: 'hitl',
+          });
+        };
+        if (!podReviewBlockedDraft || podAcceptable) {
           const acceptance = await acceptReviewBudget(
             review?.mustFix ?? [],
             reworkParts.some((part) => part.source === 'supervisor'),
+            podReviewBlockedDraft,
           );
+          podDecision(acceptance.decision.action === 'accept');
           if (acceptance.decision.action === 'accept') {
+            if (podReviewBlockedDraft) {
+              observe('merge-decision', {
+                autoMerge: autoMergeEnabled(opts), reviewed: review?.reviewed === true, verdict: review?.verdict ?? 'none',
+                decision: 'hitl', reason: 'review-budget-follow-up-required',
+                mustFixCount: acceptance.decision.unresolvedMustFix.length,
+                followUpMustFix: acceptance.decision.unresolvedMustFix,
+                ...(acceptance.pr ? { prNumber: acceptance.pr.number } : {}),
+              });
+            }
             if (acceptance.pr) {
               await draftFollowUpAfterMerge({
                 prNumber: acceptance.pr.number,
@@ -6656,7 +6838,7 @@ async function runSelfImplementInner(
               detail: `${reason}; accepted with ${acceptance.decision.unresolvedMustFix.length} follow-up must-fix item(s)`,
             };
           }
-        }
+        } else podDecision(false);
         const pr = await preserveBlockedArtifacts({ stage: 'review-blocked', reason, gate, salvageStatusExpected: true });
         const salvage = blockedDraftNoChanges || blockedDraftPrFailure ? 'parked' : await salvageHardCap(canSalvage, pr);
         const disposition = { ...terminal, ...(salvage ? { salvage } : {}) };
@@ -6689,9 +6871,39 @@ async function runSelfImplementInner(
         }, { level: 'warn' });
       }
     }
-    const feature = round === 0
-      ? round0Feature
+    const reworkFeature = round === 0 ? ''
       : buildReworkFeature(opts.feature, round, effectiveMax, reworkPromptNote, stripReworkBudgetHeaders(diagnosis), appliedLastRound, refutableFindings, pendingPlanRevision, reworkKind, buildRefutationGuidance(), escalationJudgement);
+    const card = round === 0 ? '' : renderRoundSummaryCard(roundSummaryEntries);
+    const feature = round === 0 ? round0Feature : reworkFeature + (card ? `\n\n${card}` : '');
+    if (card) {
+      const latest = roundSummaryEntries[roundSummaryEntries.length - 1]!;
+      const lastKey = latest.failedIds?.length ? JSON.stringify([...new Set(latest.failedIds)].sort()) : undefined;
+      const repeatedWithRound = lastKey === undefined ? undefined : roundSummaryEntries.slice(0, -1)
+        .find((entry) => entry.failedIds?.length && JSON.stringify([...new Set(entry.failedIds)].sort()) === lastKey)?.round;
+      const omittedRounds = Number(/…\(앞 라운드 (\d+)개 생략\)/.exec(card)?.[1] ?? 0);
+      observe('round-card', { round, entries: roundSummaryEntries.length, chars: card.length,
+        ...(repeatedWithRound === undefined ? {} : { repeatedWithRound }), omittedRounds,
+      }, { category: 'self-dev.rework' });
+    }
+    if (round > 0) {
+      // ⛔ 관측 전용 — 계산은 순수 함수가, 기록은 `observe`(= 런 원장)가 한다. 판정·분기·오버레이 상태는 건드리지 않는다.
+      try {
+        const latestEntry = roundSummaryEntries[roundSummaryEntries.length - 1];
+        const gateRoundIds = latestEntry?.kind === 'gate'
+          ? roundSummaryEntries.filter((entry) => entry.kind === 'gate').map((entry) => entry.failedIds)
+          : [];
+        observe('flex-signals', {
+          round,
+          ...computeFlexSignals({
+            gateFailedIdsByRound: gateRoundIds,
+            failureAttributions: reworkKind === 'gate' ? gate.baselineFailures?.map(({ attribution }) => attribution) : undefined,
+            reviewRepeat,
+            round,
+            plannedRounds: effectiveMax,
+          }),
+        });
+      } catch { /* observation must not interrupt rework */ }
+    }
     const refutationGuidanceEligible = round > 0 && refutableFindings.length > 0;
     const dispatchedRefutationGuidance = refutationGuidancePresented(feature, refutationGuidanceEligible);
     pendingPlanRevision = undefined;
@@ -7011,7 +7223,9 @@ async function runSelfImplementInner(
     if (opts.goalFile) {
       let goalDocument: string | undefined;
       try { goalDocument = readFileSync(opts.goalFile, 'utf8'); } catch { /* unknown scope */ }
-      const scope = detectDeclaredScopeDiff({ goalDocument, changedFiles: gateRouteFiles?.filter(file => !harnessSeededPaths.includes(file)), nameCap: gateRouteFiles?.length });
+      // 🩸 10-09: 범위 타입검사 임시 tsconfig(.elanous-typecheck-scope-*.json · scoped-typecheck-config.ts)가 옛 가지에 커밋된 뒤 지워지면
+      //   «추적 파일 삭제» 라 impact=critical → 결정 카드가 «irreversible» 로 대표에게 갔다(D-20·35·43·80). 하니스 임시물은 범위 판정 밖이다.
+      const scope = detectDeclaredScopeDiff({ goalDocument, changedFiles: gateRouteFiles?.filter(file => !harnessSeededPaths.includes(file) && !isHarnessTempArtifact(file)), nameCap: gateRouteFiles?.length });
       if (scope.status === 'known' && scope.outsideCount !== null && scope.outsideCount > 0) {
         const result: ExecutionClarificationResult = await (s.askExecutionClarification ?? askAtExecution)({
           id: 'execution_scope', decision: 'Changing files outside the authored target paths',
@@ -7272,6 +7486,10 @@ async function runSelfImplementInner(
         return { ok: false, stage: 'gate-failed', node: 'rework', ...resolveRunOutcome({ termination: 'abandoned' }), sessionId, worktreePath: wt.path, branch: wt.branch, gate, quotaExhaustionAssessment: quotaExhaustionAssessmentForRun(), ...(pr ? { prUrl: pr.url, prNumber: pr.number } : {}), detail: reason };
       }
       lastGateUnverifiedKey = unverifiedRepeatKey(gate.unverified);
+      roundSummaryEntries.push({ round, kind: 'gate', tried: impl.summary.replace(/\s+/g, ' ').trim().slice(0, 200),
+        failedIds: gate.baselineFailures?.map(({ name, file, attribution }) => `${name}@${file ?? '?'} (${attribution})`),
+        filesTouched: gateRouteFiles,
+      });
       round++;
       continue;
       }
@@ -7425,7 +7643,13 @@ async function runSelfImplementInner(
         ...(review.failureReason !== undefined ? { failureReason: review.failureReason } : {}),
         ...(reviewArtifactPath ? { artifactPath: reviewArtifactPath } : {}),
       });
-      if (review.reviewed) reviewMustFixCountHistory.push(review.mustFix.length);
+      if (review.reviewed) {
+        reviewMustFixCountHistory.push(review.mustFix.length);
+        reviewedFindings.push(review.mustFix.map((item) => ({ id: stableMustFixId(item), item })));
+        onReworkMeasured(structuredRework());
+        // The next runtime overlay sees completed review rounds, not consecutive repeats of one finding.
+        reviewRepeat = reviewMustFixCountHistory.length - 1;
+      }
       progress('reviewed', review.reviewed
         ? `리뷰: ${review.verdict} (must-fix ${review.mustFix.length}·should-fix ${review.shouldFix.length}) · 추이 ${reviewMustFixCountHistory.join('→')} (${reviewMustFixTrend()})`
         : `리뷰 미실행${review.failureReason !== undefined ? ` (${review.failureReason})` : ''}`);
@@ -7555,6 +7779,9 @@ async function runSelfImplementInner(
           break;
         }
         appliedLastRound = [...effectiveMustFix];
+        roundSummaryEntries.push({ round, kind: 'review', tried: impl.summary.replace(/\s+/g, ' ').trim().slice(0, 200),
+          failedIds: effectiveMustFix.map(stableMustFixId), filesTouched: runFacts.changedFiles,
+        });
         refutableFindings = reviewMustFixFindings.filter(({ item }) => effectiveMustFix.includes(item));
         const reviewFindingKeys = effectiveMustFix
           .map(reviewFindingKey)
@@ -7604,6 +7831,18 @@ async function runSelfImplementInner(
         continue;
       }
     }
+    if (gate.passed && autoMergeEnabled(opts) && evidenceCoverage?.uncoveredCount && !uncoveredFeedbackUsed && round < effectiveMax) {
+      const uncovered = [...evidenceCoverage.uncovered];
+      const nextRound = round + 1;
+      setReworkPart('review', formatUncoveredEvidenceFeedback(uncovered));
+      uncoveredFeedbackUsed = true;
+      debug.log('self-implement.evidence', 'uncovered-feedback', { uncovered, round: nextRound });
+      bufferPrComment(round, 'author', `Round ${round}: child implementation completed.`, [
+        `Child completion: ${impl.summary.trim() || '(summary unavailable)'}`,
+      ]);
+      round = nextRound;
+      continue;
+    }
     bufferPrComment(round, 'author', `Round ${round}: child implementation completed.`, [
       `Child completion: ${impl.summary.trim() || '(summary unavailable)'}`,
     ]);
@@ -7636,7 +7875,12 @@ async function runSelfImplementInner(
   const { latestSignalIncomplete } = signalIncompleteState(roundClassifications);
   const autoMerge = autoMergeEnabled(opts);
   const gateTimeoutUnmeasured = isTimeoutOnlyUnmeasuredGate(gate.reflectGateFacts);
-  let canAuto = !gateTimeoutUnmeasured && autoMerge && reviewReal && review!.verdict !== 'fail' && reviewDiffComplete && !requiredEvidenceMissing && !latestSignalIncomplete && !decisionSignalRed;
+  // ⛔⭐ AUTOMERGE-WARN-MUSTFIX(0.2.24): 판정이 warn 이어도 must-fix 가 «남아» 있으면 자동 병합하지 않는다.
+  //   루프 «안»은 `verdict === 'fail'` 일 때만 재작업하므로, warn ⊕ must-fix≥1 은 루프를 그대로 빠져나와
+  //   종전 `verdict !== 'fail'` 만 보던 이 자리에서 auto 가 됐다(#25914 · #25934 · #25918 실물).
+  //   ⭐ 반사가 must-fix 를 «전부» 기각하면 위에서 `review.mustFix = []` 로 비우므로 그 길은 종전 그대로다.
+  const reviewMustFixCount = review?.mustFix?.length ?? 0;
+  let canAuto = !gateTimeoutUnmeasured && autoMerge && reviewReal && review!.verdict !== 'fail' && reviewMustFixCount === 0 && reviewDiffComplete && !requiredEvidenceMissing && !latestSignalIncomplete && !decisionSignalRed;
   // ⭐⭐ 통과의 «이유»를 둘로 가른다 — ⛔ 막지는 «않는다»(대표 판단 2026-08-11: ⓐ 문면만).
   //   📏 근거(`JDG-T36` · merge-decision 300건 전수): `verifyByBreaking` 이 실린 8건의 auto 중 ***5건***이
   //     ***ran=true 인데 distinguishes=0***(아무것도 안 가르는 자기검증)이었고, 그 다섯이 «전부»
@@ -7655,6 +7899,7 @@ async function runSelfImplementInner(
         : latestSignalIncomplete ? 'signal-incomplete'
         : !reviewReal ? 'no-real-review'
           : review!.verdict === 'fail' ? 'review-must-fix'
+          : reviewMustFixCount > 0 ? 'review-warn-with-must-fix'
             : review!.diffTruncated === true ? 'review-diff-truncated'
               : 'review-diff-budget-unknown';
   let mergeSkipReason = canAuto ? undefined : mergeReason;
@@ -7662,6 +7907,7 @@ async function runSelfImplementInner(
   const mergeDecisionObservation = {
     autoMerge, reviewed: reviewReal, verdict: review?.verdict ?? 'none',
     decision: canAuto ? 'auto' : 'hitl', reason: mergeReason,
+    mustFixCount: reviewMustFixCount,
     ...mergeDecisionEvidenceCoverage(evidenceCoverage),
     ...(evidenceCoverage ? {
       evidenceSource,