elanous 0.2.23 → 0.2.25

package/src/self-implement/orchestrator.ts

@@ -18,6 +18,7 @@ import {
   parseGateLogTestRuns,
   type PrEvidenceInput,
 } from './pr-evidence-artifact.js';
+import { REVIEW_DEFERRED_TO_HOST_MERGE_REASON } from './review-deferred-to-host.js';
 import { assessImplementationArtifactCompleteness } from './implementation-artifact-completeness.js';
 import { runContractAtNode, type RunContract } from './graph-run-contract.js';
 export {
@@ -31,7 +32,8 @@ export {
   type PrEvidenceInput,
 } from './pr-evidence-artifact.js';
 import { judgePredictionAccuracy } from './judge-prediction-accuracy.js';
-import { classifyPodReviewBudgetResidue, 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';
@@ -80,7 +82,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';
@@ -90,6 +92,7 @@ import { classifyError } from '../session-runtime/retry-policy.js';
 import { decomposeSelfDevGoal, inferHotPaths, type SelfDevDecomposeOptions } from '../self-dev/decompose.js';
 import { boundaryGlobs, boundaryViolations } from './goal-boundary.js';
 import { askAtExecution, type ExecutionClarificationResult } from './execution-clarification.js';
+import { classifyOutOfScope } from './scope-adjacency.js';
 import { targetScopedGoalText } from './goal-text-path-scope.js';
 import { dropStaleReverts, type RevertGuardResult } from './revert-guard.js';
 import type { SelfDevGoalType } from '../self-dev/orchestrate.js';
@@ -151,14 +154,16 @@ 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';
 import { createReworkBudgetJudgment, REWORK_BUDGET_JUDGMENT, reworkBudgetEvidenceForObservation, reworkBudgetWorkflow } from './rework-budget-judgment.js';
+import { formatGateFailedId, type PremiseReviewCard, type PremiseReviewInput } from './premise-review.js';
 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, formatUncoveredEvidenceFeedback, type OffDiffEvidenceParse } from './off-diff-evidence.js';
+import { authorLimitationCountFromGoal, harvestEvidenceLines, harvestedEvidenceObservation, MAX_HARVESTED_EVIDENCE_CHARS, parseOffDiffEvidence, requiredEvidenceFromGoal, runRequiredEvidenceChecks, coverRequiredEvidence, settleUncoveredEvidence, 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';
 
@@ -246,11 +251,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';
@@ -577,6 +583,8 @@ export interface SelfImplementReview {
   reviewed: boolean;
   /** 리뷰가 실행되지 않은 실패 사유. 리뷰 엔진이 제공한 경우에만 관측으로 전달한다. */
   failureReason?: string;
+  /** REVIEW-ACP-POD ②-b — 리뷰를 발사 호스트(Claude ACP)로 미뤘다. `reviewed` 는 거짓 그대로다(통과가 아니다). */
+  deferredToHost?: true;
   /** 리뷰 엔진이 실제로 사용한 diff 예산. 없는 값은 미검토/no-diff 등으로, 완전한 diff의 증거가 아니다. */
   diffTruncated?: boolean;
   diffShownChars?: number;
@@ -786,7 +794,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[] } {
@@ -803,10 +813,29 @@ 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 = declaredNewFilePaths(originalAsk);
+  return newFiles.length > 0 ? { readable: true, paths: [...new Set([...declared.paths, ...newFiles])] } : declared;
+}
+
+function declaredNewFilePaths(askText: string): readonly string[] {
+  return askText.split(/\r?\n/).flatMap((line) => {
+    const match = DECLARED_NEW_FILES_LINE.exec(line);
+    return match ? parseDeclaredTargetPathsFromAsk(`대상 경로: ${match[1]}`).paths : [];
+  });
+}
+
+/** P3 전제의 경계 — ask 머리줄 «대상 경로:» ⊕ «신설:» 줄의 합집합. 못 읽으면 빈 목록(그때 P3 는 unknown). */
+function declaredPremiseScopePaths(askText: string): string[] {
+  return [...new Set([...parseDeclaredTargetPathsFromAsk(askText).paths, ...declaredNewFilePaths(askText)])];
 }
 
 /** Only paths explicitly designated as targets in the ask or piece text protect an intentional revert. */
@@ -2280,6 +2309,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;
@@ -3569,6 +3599,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');
@@ -3633,6 +3686,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>();
@@ -3982,6 +4042,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)
@@ -4147,6 +4263,7 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
       },
       observeRoundExecution,
       observeReviewFindings,
+      (rework) => { measuredRework = rework; },
       setRunGraphIdentity,
       (template) => { runGraphTemplate = template; },
       // ⭐ 「요구 증거 충족」을 받아 결과에 실어 원장까지 나른다(`JDG-T60`)
@@ -4200,7 +4317,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;
@@ -4263,7 +4380,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' });
@@ -4296,7 +4413,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
@@ -4338,7 +4455,7 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
       });
       observeRunRollup(observeOuter, addressedResult, roundClassifications, roundCount, capturedPrNumber, openPrInvoked);
       observeProgressDelivery();
-      return addressedResult;
+      return terminalResult;
     }
     recordHitlEvent({
       kind: 'escalation',
@@ -4767,6 +4884,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 = () => {},
@@ -4858,9 +4976,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 } : {}),
@@ -4907,12 +5027,12 @@ async function runSelfImplementInner(
       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 = {
+    const runtimeOverlayState = buildRuntimeOverlayState({
       attempts: round,
-      ...(opts.goalId === undefined ? {} : { goal_id: opts.goalId }),
-      ...(stopClass === undefined ? {} : { stop_class: stopClass }),
-      ...(reviewRepeat === undefined ? {} : { review_repeat: reviewRepeat }),
-    };
+      ...(opts.goalId === undefined ? {} : { goalId: opts.goalId }),
+      ...(stopClass === undefined ? {} : { stopClass }),
+      ...(reviewRepeat === undefined ? {} : { reviewRepeat }),
+    });
     const decision = decideTemplate({
       goalType: graphGoalType,
       authority: graphAuthority,
@@ -5266,6 +5386,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]!)
@@ -6338,7 +6460,21 @@ async function runSelfImplementInner(
         judgmentStarted = true;
         const judgmentCallLLM = s.judgmentCallLLM;
         if (diagnosedDecision?.verdict !== 'CONTRACT-CONFLICT' && !judgmentCallLLM) throw new Error('rework-budget@v1 requires a judgment provider');
-        const judgmentProvider = judgmentCallLLM ? createReworkBudgetJudgment(judgmentCallLLM) : undefined;
+        // FLEX-RFC §A-③ — UNCONVERGEABLE 직전의 전제 되짚기 입력. 이 루프 뒤쪽 «flex-signals» 관측(6895~)과 같은
+        // 실제 런 값으로 조립한다. 이 생산 배선이 없으면 카드는 시험에서만 세워지고 원장에는 남지 않는다.
+        const premiseLatestEntry = roundSummaryEntries[roundSummaryEntries.length - 1];
+        const premiseInput: PremiseReviewInput = {
+          runId,
+          gateFailedIdsByRound: premiseLatestEntry?.kind === 'gate'
+            ? roundSummaryEntries.filter((entry) => entry.kind === 'gate').map((entry) => entry.failedIds)
+            : [],
+          failureAttributions: reworkKind === 'gate' && gate ? gate.baselineFailures?.map(({ attribution }) => attribution) : undefined,
+          reviewRepeat,
+          round,
+          plannedRounds: effectiveMax,
+          targetPaths: declaredPremiseScopePaths(opts.feature),
+        };
+        const judgmentProvider = judgmentCallLLM ? createReworkBudgetJudgment(judgmentCallLLM, { premiseInput }) : undefined;
         try {
           const result = diagnosedDecision?.verdict === 'CONTRACT-CONFLICT'
             ? undefined
@@ -6520,6 +6656,17 @@ async function runSelfImplementInner(
             : { evidence: null };
           observe('rework-budget', { round, verdict: parsedDecision.verdict, reason: parsedDecision.reason.slice(0, 240), effectiveMaxBefore: before, effectiveMaxAfter: effectiveMax, carriedBudgetBefore, carriedBudgetAfter: judgedEffectiveMax, historyRounds: priorHistory.length, kind: reworkKind, applied: budgetDecision.applied, stopped: budgetDecision.stop, exit: budgetDecision.exit, shadowed: budgetDecision.shadowed === true, repeatedBlockingFindingCount: repeatedBlockingIds?.length ?? null, repeatedBlockingFindingIds: repeatedBlockingIds ?? null, normalizedRepeatedReviewFindingCount: recurrence?.normalizedRepeatedReviewFindingCount ?? null, ordinaryRepeatedReviewFindingCount: recurrence?.ordinaryRepeatedReviewFindingCount ?? null, previouslyDismissedRepeatedReviewFindingCount: recurrence?.previouslyDismissedRepeatedReviewFindingCount ?? null, citedReviewSymbolRepeatCount: recurrence?.citedReviewSymbolRepeatCount ?? null, citedReviewSymbolBaseNameRepeatCount: recurrence?.citedReviewSymbolBaseNameRepeatCount ?? null, reviewFindingComparableCount: recurrence?.comparableFindings ?? null, reviewFindingKeyRepeatCount: recurrence?.reviewFindingKeyRepeatCount ?? null, ...recurrenceDisagreementObservation, ...evidenceObservation, judgePredictedBefore: predictionAccuracyForObservation.predicted, judgeFulfilledBefore: predictionAccuracyForObservation.fulfilled, judgeMissedBefore: predictionAccuracyForObservation.missed, judgePendingBefore: predictionAccuracyForObservation.pending, ...(budgetDecision.shadowed ? { wouldExit: budgetDecision.wouldExit } : {}), ...(budgetDecision.contractConflictDisposition ? { contractConflictDisposition: budgetDecision.contractConflictDisposition } : {}), ...(pendingPlanRevision?.relaxation ? { contractConflictRelaxation: { ...pendingPlanRevision.relaxation, reason: pendingPlanRevision.reason, application: pendingPlanRevision.application?.status ?? 'failed' } } : {}), ...supervisionObservation }, { ...(budgetDecision.exit === 'blocked' ? { level: 'warn' as const } : {}), compact: { stringMax: 256, arrayMax: 6, maxDepth: 5 } });
           if (parsedDecision.verdict === 'UNCONVERGEABLE' && budgetDecision.stop && budgetDecision.exit === 'blocked') {
+            // FLEX-RFC §A-③(0.2.25 FLEX-PREMISE-REVIEW) — 확정된 UNCONVERGEABLE 의 전제 되짚기 카드를
+            // «별도 원장 사건»으로 남긴다. 카드는 판정 provider 가 UNCONVERGEABLE 을 «내기 전에» 세웠다
+            // (createReworkBudgetJudgment 가 premiseInput 으로 buildPremiseCard 를 부른다) — 이 자리는 그
+            // 카드를 원장에 옮기기만 한다. 카드가 없으면 사건도 없다.
+            const evidenceRecord: unknown = evidenceObservation.evidence;
+            const premiseReview = typeof evidenceRecord === 'object' && evidenceRecord !== null
+              ? (evidenceRecord as { premiseReview?: PremiseReviewCard }).premiseReview
+              : undefined;
+            if (premiseReview) {
+              observe('premise-review', { round, runId: premiseReview.runId, findings: premiseReview.findings, proposal: premiseReview.proposal ?? null }, { level: 'warn' as const, compact: { stringMax: 256, arrayMax: 6, maxDepth: 5 } });
+            }
             try {
               const shadow = inferDecompositionShadow(opts.feature);
               observe('decomposition-shadow', { round, ...shadow });
@@ -6777,6 +6924,25 @@ async function runSelfImplementInner(
         ...(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;
@@ -7003,8 +7169,12 @@ async function runSelfImplementInner(
     offDiffEvidence = parseOffDiffEvidence(evidenceText);
     const requiredEvidence = requiredEvidenceFromGoal(opts.feature);
     const limitationCount = authorLimitationCountFromGoal(opts.feature);
-    runRequiredEvidenceChecks(opts.feature, wt.path, runId);
-    const coverage = coverRequiredEvidence(requiredEvidence, offDiffEvidence.items);
+    const evidenceChecks = runRequiredEvidenceChecks(opts.feature, wt.path, runId);
+    const tagCoverage = coverRequiredEvidence(requiredEvidence, offDiffEvidence.items);
+    // EVIDENCE-WIRING-EXEMPT — a requirement whose own `|| bun test …` check passed is covered by what the harness measured.
+    const settledByCheck = settleUncoveredEvidence(tagCoverage.uncovered, { checks: evidenceChecks, required: requiredEvidence });
+    if (settledByCheck.coveredByCheck.length) debug.log('self-implement.evidence', 'covered-by-check', { round, tags: settledByCheck.coveredByCheck });
+    const coverage = { ...tagCoverage, uncovered: settledByCheck.uncovered, uncoveredCount: settledByCheck.uncovered.length };
     evidenceCoverage = requiredEvidence.length || limitationCount
       ? {
         required: requiredEvidence.length,
@@ -7099,21 +7269,35 @@ async function runSelfImplementInner(
       // 🩸 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)({
+      // SCOPE-HELD-DELIVER — no declared target means the declaration was unreadable (e.g. paths listed with spaces), not
+      // that every edit is outside it: treat it like an unknown declaration and go on to the gate.
+      if (scope.status === 'known' && scope.declaredCount === 0 && (scope.outsideCount ?? 0) > 0) {
+        observe('execution-scope-undeclared', { outsideCount: scope.outsideCount });
+        progress('implementing', `⚠️ 대상 경로를 하나도 못 읽었다 — 범위 밖 ${scope.outsideCount}개를 묻지 않고 게이트로 간다`);
+      } else if (scope.status === 'known' && scope.outsideCount !== null && scope.outsideCount > 0) {
+        const impact = scope.outsideNames.some(file => {
+          if (existsSync(join(wt.path, file))) return false;
+          const tracked = runGitCommand(wt.path, ['ls-files', '--error-unmatch', '--', file], { encoding: 'utf8', timeout: 20_000 });
+          return tracked.status === 0;
+        }) ? 'critical' : 'high';
+        const declaredPaths = declaredPathsFromGoalDocumentText(goalDocument!).paths;
+        const { adjacent, other } = classifyOutOfScope(scope.outsideNames, declaredPaths);
+        // Only edits next to a declared file, none of them a deletion: the gate judges them — nobody has to answer first.
+        const adjacentOnly = impact !== 'critical' && !scope.nameCapReached && other.length === 0 && adjacent.length === scope.outsideCount;
+        if (adjacentOnly) {
+          observe('execution-scope-adjacent-accepted', { outsideCount: scope.outsideCount, adjacent });
+          progress('implementing', `범위 밖 인접 편집 ${adjacent.length}개(대상과 같은 폴더) — 묻지 않고 게이트로 간다: ${adjacent.join(' · ')}`);
+        }
+        const result: ExecutionClarificationResult = adjacentOnly ? { choice: 'Expand scope', by: 'assumed' } : await (s.askExecutionClarification ?? askAtExecution)({
           id: 'execution_scope', decision: 'Changing files outside the authored target paths',
           prompt: 'Implementation changed files outside the authored target paths. Keep the original scope or expand it?',
           whyNow: 'Continuing to gate or publish these edits would expand the requested scope.',
-          impact: scope.outsideNames.some(file => {
-            if (existsSync(join(wt.path, file))) return false;
-            const tracked = runGitCommand(wt.path, ['ls-files', '--error-unmatch', '--', file], { encoding: 'utf8', timeout: 20_000 });
-            return tracked.status === 0;
-          }) ? 'critical' : 'high',
+          impact,
           options: [
             { label: 'Stay in scope', description: 'Do not accept out-of-scope changes.', recommended: true },
             { label: 'Expand scope', description: 'Accept the changed files outside the target paths.' },
           ],
-        }, { runId, outsideFiles: scope.outsideNames, outsideCount: scope.outsideCount, declaredPaths: declaredPathsFromGoalDocumentText(goalDocument!).paths }, { writeRunLedger: s.writeRunLedger });
+        }, { runId, outsideFiles: scope.outsideNames, outsideCount: scope.outsideCount, declaredPaths }, { writeRunLedger: s.writeRunLedger });
         if ('parked' in result || 'deferred' in result || result.choice !== 'Expand scope') {
           finalizeSupervisorDeliveries('execution-scope-not-approved');
           observe('execution-scope-held', { outsideCount: scope.outsideCount, disposition: 'parked' in result ? 'parked' : 'in-scope-only' });
@@ -7360,7 +7544,7 @@ async function runSelfImplementInner(
       }
       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})`),
+        failedIds: gate.baselineFailures?.map(formatGateFailedId),
         filesTouched: gateRouteFiles,
       });
       round++;
@@ -7518,6 +7702,8 @@ async function runSelfImplementInner(
       });
       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;
       }
@@ -7702,6 +7888,14 @@ async function runSelfImplementInner(
         continue;
       }
     }
+    // EVIDENCE-WIRING-EXEMPT — a commandless [preservation] is covered once the changed-file gate passed.
+    if (gate.passed && evidenceCoverage?.uncoveredCount) {
+      const settledByGate = settleUncoveredEvidence(evidenceCoverage.uncovered, { gatePassed: true, required: requiredEvidenceFromGoal(opts.feature) });
+      if (settledByGate.coveredByGate.length) {
+        debug.log('self-implement.evidence', 'covered-by-gate', { round, tags: settledByGate.coveredByGate });
+        evidenceCoverage = { ...evidenceCoverage, uncovered: settledByGate.uncovered, uncoveredCount: settledByGate.uncovered.length };
+      }
+    }
     if (gate.passed && autoMergeEnabled(opts) && evidenceCoverage?.uncoveredCount && !uncoveredFeedbackUsed && round < effectiveMax) {
       const uncovered = [...evidenceCoverage.uncovered];
       const nextRound = round + 1;
@@ -7740,8 +7934,11 @@ async function runSelfImplementInner(
     ? { completionDisposition }
     : {};
   const reviewReal = !!review?.reviewed;
+  // REVIEW-ACP-POD ②-b — 호스트가 병합하는(mergeByHost) 런에서만 «미룬 리뷰»를 merge-ready 로 받는다. 판정은 호스트 ACP 리뷰가 한다.
+  //   ⛔ 그 밖의 런에선 종전 그대로 no-real-review(HITL) — 리뷰 없이 병합하는 길을 새로 열지 않는다.
+  const reviewDeferredToHost = !reviewReal && review?.deferredToHost === true && opts.mergeByHost === true && review.mustFix.length === 0;
   const reviewedHeadResult = reviewReal && reviewedHeadCommit ? { reviewedHeadCommit } : {};
-  const reviewDiffComplete = review?.diffTruncated === false;
+  const reviewDiffComplete = review?.diffTruncated === false || reviewDeferredToHost;
   const requiredEvidenceMissing = evidenceCoverage !== undefined && evidenceCoverage.uncoveredCount > 0;
   const { latestSignalIncomplete } = signalIncompleteState(roundClassifications);
   const autoMerge = autoMergeEnabled(opts);
@@ -7751,7 +7948,7 @@ async function runSelfImplementInner(
   //   종전 `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;
+  let canAuto = !gateTimeoutUnmeasured && autoMerge && (reviewReal || reviewDeferredToHost) && 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***(아무것도 안 가르는 자기검증)이었고, 그 다섯이 «전부»
@@ -7762,7 +7959,8 @@ async function runSelfImplementInner(
   //     그건 `skippedReason` 이 이미 가른다. 그래서 여기 조건에 넣지 않는다.
   const verifyInconclusive = gate.verifyByBreaking?.ran === true && (gate.verifyByBreaking.distinguishes ?? 0) === 0;
   const verifyNothingAtBase = verifyInconclusive && (gate.verifyByBreaking?.missingAtBase ?? 0) > 0;
-  let mergeReason = canAuto ? (verifyNothingAtBase ? 'review-clean-verify-nothing-at-base' : verifyInconclusive ? 'review-clean-verify-inconclusive' : 'review-clean-armed')
+  let mergeReason = canAuto && reviewDeferredToHost ? REVIEW_DEFERRED_TO_HOST_MERGE_REASON
+    : canAuto ? (verifyNothingAtBase ? 'review-clean-verify-nothing-at-base' : verifyInconclusive ? 'review-clean-verify-inconclusive' : 'review-clean-armed')
     : gateTimeoutUnmeasured ? GATE_TIMEOUT_UNMEASURED_MERGE_REASON
     : !autoMerge ? 'no-auto-flag'
       : requiredEvidenceMissing ? 'required-evidence-uncovered'
@@ -8182,7 +8380,7 @@ async function runSelfImplementInner(
     if (opts.mergeByHost) {
       observe('merge-ready', { number: pr.number, checkedHeadCommit });
       progress('pr-opened', `호스트 재게이트 대기 (#${pr.number})`);
-      return { ok: true, stage: 'merge-ready', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, checkedHeadCommit: checkedHeadCommit!, prUrl: pr.url, prNumber: pr.number };
+      return { ok: true, stage: 'merge-ready', node: 'open-pr', ...resolveRunOutcome({ termination: 'completed' }), ...decisionSignalResult, ...preservedCompletionResult, ...(completionStatus ? { completionStatus } : {}), sessionId, worktreePath: wt.path, branch: wt.branch, gate, ...(review ? { review } : {}), ...reviewedHeadResult, ...(reviewDeferredToHost ? { mergeReason } : {}), checkedHeadCommit: checkedHeadCommit!, prUrl: pr.url, prNumber: pr.number };
     }
     // Landing freeze: the in-flight marker is written before the freeze is read, so a `freeze on` racing this merge waits.
     // The resume sweep merges from the repository that owns the run worktree (the worktree itself may be cleaned up).