elanous 0.2.24 → 0.2.27

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 {
@@ -91,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';
@@ -157,10 +159,11 @@ import { resolveAdaptiveMaxReworkDecision, resolveEscalateTier, resolveEscalateT
 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';
 
@@ -580,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;
@@ -817,11 +822,20 @@ function declaredPathsFromGoalDocumentText(document: string): { readable: boolea
   if (originalAsk === null) return { readable: false, paths: [] };
   const declared = parseDeclaredTargetPathsFromAsk(originalAsk);
   if (!declared.readable) return declared;
-  const newFiles = originalAsk.split(/\r?\n/).flatMap((line) => {
+  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 : [];
   });
-  return newFiles.length > 0 ? { readable: true, paths: [...new Set([...declared.paths, ...newFiles])] } : declared;
+}
+
+/** 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. */
@@ -3633,7 +3647,8 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
   try {
     // 10-05 PODPROVIDER: record which child provider this run uses — «default» when the launch named none.
     const launch = opts.launch ?? resolveLaunchStamp();
-    const origin = { ...runOriginData(), childProvider: opts.childLlm?.provider ?? 'default', ...(opts.childLlm?.model ? { childModel: opts.childLlm.model } : {}), launch };
+    const origin = { ...runOriginData(), childProvider: opts.childLlm?.provider ?? 'default', ...(opts.childLlm?.model ? { childModel: opts.childLlm.model } : {}),
+      ...(process.env.ELANOUS_TASK_CARD_ID ? { taskCardId: process.env.ELANOUS_TASK_CARD_ID } : {}), launch };
     (opts.seams.writeRunLedger ?? appendRunLedgerEntry)({
       timestamp: new Date().toISOString(), runId, event: 'run-origin', data: origin,
       ...(opts.goalId ? { goalId: opts.goalId } : {}), ...shardIdentity,
@@ -6446,7 +6461,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
@@ -6628,6 +6657,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 });
@@ -7130,8 +7170,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,
@@ -7226,21 +7270,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' });
@@ -7487,7 +7545,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++;
@@ -7831,6 +7889,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;
@@ -7869,8 +7935,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);
@@ -7880,7 +7949,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***(아무것도 안 가르는 자기검증)이었고, 그 다섯이 «전부»
@@ -7891,7 +7960,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'
@@ -8311,7 +8381,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).

package/src/self-implement/premise-review.ts

@@ -0,0 +1,159 @@
+/**
+ * 전제 다섯 되짚기 — premise-review 카드 순수 계산(FLEX-RFC §A-③).
+ *
+ * P1 골 · P2 자(판정 시험) · P3 범위(대상 경로) · P4 쪼갬 · P5 환경.
+ * ⛔ LLM 없이 잴 수 있는 둘만 판정한다 — P3(범위) · P2(preexisting 자).
+ * ⛔ unknown 은 «맞다(ok)»가 아니다 — 못 잰 전제는 ok 로 지어내지 않는다.
+ */
+
+import type { FlexSignalsInput } from './flex-signals.js';
+
+/** 못 잰 근거의 표기 — P1·P4·P5 는 이 값으로 unknown 으로만 나간다. */
+const UNMEASURED = '못 잼';
+
+export type PremiseKey = 'P1' | 'P2' | 'P3' | 'P4' | 'P5';
+export type PremiseVerdict = 'ok' | 'wrong' | 'unknown';
+
+export interface PremiseFinding {
+  premise: PremiseKey;
+  verdict: PremiseVerdict;
+  evidence: string;
+}
+
+/** `computeFlexSignals` 와 같은 꼴의 값 객체 + 카드가 가리킬 run 식별자와 P3 판정의 경계. */
+export interface PremiseReviewInput extends FlexSignalsInput {
+  runId: string;
+  /** 이 골이 선언한 대상 경로 — 없으면 P3 는 unknown(경계를 못 잼). */
+  targetPaths?: readonly string[] | undefined;
+}
+
+export interface PremiseReviewCard {
+  runId: string;
+  findings: PremiseFinding[];
+  /** wrong 이 있을 때만 «가장 좁은 것» 하나 — wrong 이 없으면 undefined. */
+  proposal: PremiseFinding | undefined;
+}
+
+/** 최신 라운드의 실패 id 목록 — `gateFailedIdsByRound` 의 마지막 칸이 최신(`computeFlexSignals` 와 같은 순서). */
+function latestFailingIds(input: FlexSignalsInput): readonly string[] | undefined {
+  const latest = input.gateFailedIdsByRound.length === 0
+    ? undefined
+    : input.gateFailedIdsByRound[input.gateFailedIdsByRound.length - 1];
+  return latest !== undefined && latest.length > 0 ? latest : undefined;
+}
+
+/**
+ * 게이트 실패 id — 생산자(orchestrator 의 roundSummaryEntries.failedIds)와 P3 파서가 «같은 꼴»을 쓰도록
+ * 둘 다 이 함수 짝을 거친다. 꼴: `${name}@${file ?? '?'} (${attribution})`.
+ */
+export function formatGateFailedId(failure: { name: string; file?: string | undefined; attribution: string }): string {
+  return `${failure.name}@${failure.file ?? '?'} (${failure.attribution})`;
+}
+
+/**
+ * 실패 id 에서 시험 파일을 뽑는다 — `name@` 접두와 ` (귀속)` 접미를 뗀다. 이름에 `@` 가 섞여도
+ * (`user@example.com`·`@scope/pkg`)·경로에 `@`(`src/@scope/x.ts`)가 있어도 가른다: 경로 안의 `@` 는
+ * 세그먼트 머리(맨 앞 또는 `/` 바로 뒤)에만 온다. 그래서 «공백 없고 · 확장자로 끝나고 · 안의 `@` 가 전부
+ * 세그먼트 머리인» 후보를 처음 주는 `@` 가 구분자다. 그런 `@` 가 없거나 파일이 `?`·빈 값이면 undefined
+ * (못 잼) — fail-closed. 남는 모호함: 이름이 `/` 로 끝나면(`a/@src/x.ts`) 구분자를 경로로 읽는다.
+ */
+export function gateFailedIdFile(id: string): string | undefined {
+  const withoutAttribution = id.replace(/\s*\([^)]*\)\s*$/, '');
+  for (let at = withoutAttribution.indexOf('@'); at >= 0; at = withoutAttribution.indexOf('@', at + 1)) {
+    const file = withoutAttribution.slice(at + 1);
+    if (file === '' || file === '?' || /\s/.test(file)) continue;
+    if (!/\.[A-Za-z0-9]+$/.test(file)) continue;
+    if (/[^/]@/.test(file)) continue;
+    return file;
+  }
+  return undefined;
+}
+
+/**
+ * 시험 파일 → 짝 소스. `dir/x.test.ts` → `dir/x.ts`(같은 폴더). 시험 전용 폴더(`test/`·`__tests__/`)의 시험은
+ * 짝을 추측하지 않는다(undefined · fail-closed). 시험 꼴이 아닌 파일은 그 자신이 소스다.
+ */
+export function pairedSourceOf(file: string): string | undefined {
+  const normalized = file.replace(/^\.\//, '');
+  const testMatch = /^(.*)\.test\.([cm]?[jt]sx?)$/.exec(normalized);
+  if (!testMatch) return normalized;
+  if (/(^|\/)(test|tests|__tests__)\//.test(normalized)) return undefined;
+  return `${testMatch[1]}.${testMatch[2]}`;
+}
+
+function insideTargets(path: string, targets: readonly string[]): boolean {
+  return targets.some((target) => {
+    const t = target.replace(/^\.\//, '').replace(/\/+$/, '');
+    return path === t || path.startsWith(`${t}/`);
+  });
+}
+
+/** P2 자 — 판정 시험이 base 에서도 실패(preexisting)면 wrong. 귀속을 못 잼·하나라도 unknown 이면 unknown. */
+function judgeP2(input: PremiseReviewInput): PremiseFinding {
+  const attributions = input.failureAttributions;
+  if (attributions === undefined || attributions.length === 0) {
+    return { premise: 'P2', verdict: 'unknown', evidence: UNMEASURED };
+  }
+  const preexistingIndex = attributions.indexOf('preexisting');
+  if (preexistingIndex >= 0) {
+    const latest = latestFailingIds(input);
+    const evidence = latest !== undefined && preexistingIndex < latest.length
+      ? latest[preexistingIndex]!
+      : 'preexisting';
+    return { premise: 'P2', verdict: 'wrong', evidence };
+  }
+  if (attributions.includes('unknown')) {
+    return { premise: 'P2', verdict: 'unknown', evidence: UNMEASURED };
+  }
+  return { premise: 'P2', verdict: 'ok', evidence: `preexisting 0/${attributions.length}` };
+}
+
+/**
+ * P3 범위 — 실패 시험 파일을 짝 소스로 옮겨 대상 경로와 견준다. 짝지은 소스(또는 시험 파일 자체)가
+ * 대상 경로 안이면 in · 짝은 지었는데 밖이면 wrong(그 시험 파일을 근거로). 파일을 못 읽거나 짝을 못 지은
+ * 실패가 하나라도 있고 wrong 이 없으면 unknown — 추측으로 ok 를 만들지 않는다.
+ */
+function judgeP3(input: PremiseReviewInput): PremiseFinding {
+  const latest = latestFailingIds(input);
+  const targets = input.targetPaths;
+  if (latest === undefined) return { premise: 'P3', verdict: 'unknown', evidence: UNMEASURED };
+  if (targets === undefined || targets.length === 0) return { premise: 'P3', verdict: 'unknown', evidence: UNMEASURED };
+  let unmeasured: string | undefined;
+  for (const id of latest) {
+    const file = gateFailedIdFile(id);
+    if (file === undefined) { unmeasured ??= `${UNMEASURED}: 실패 파일 없음 (${id})`; continue; }
+    if (insideTargets(file, targets)) continue;
+    const source = pairedSourceOf(file);
+    if (source === undefined) { unmeasured ??= `${UNMEASURED}: 짝 소스 없음 (${file})`; continue; }
+    if (!insideTargets(source, targets)) return { premise: 'P3', verdict: 'wrong', evidence: file };
+  }
+  if (unmeasured !== undefined) return { premise: 'P3', verdict: 'unknown', evidence: unmeasured };
+  return { premise: 'P3', verdict: 'ok', evidence: `failing files all inside target paths (${latest.length})` };
+}
+
+/**
+ * wrong 이 여럿이면 «가장 좁은 것» 하나만 제안한다(RFC §A-③ — F6 카드 → F7 조치). 좁음 = 수정 폭:
+ * P2 자가 가장 좁다(판정 자만 고친다 · 골을 안 건드린다) → P5 환경(재무대) → P4 쪼갬 → P3 범위(경계를 넓힌다)
+ * → P1 골(요구 자체를 바꾼다)이 가장 넓다. findings 배열 순서에 우연히 맡기지 않고 이 rank 로 고른다.
+ */
+const NARROWEST_FIRST: readonly PremiseKey[] = ['P2', 'P5', 'P4', 'P3', 'P1'];
+
+export function narrowestWrong(findings: readonly PremiseFinding[]): PremiseFinding | undefined {
+  for (const premise of NARROWEST_FIRST) {
+    const wrong = findings.find((finding) => finding.premise === premise && finding.verdict === 'wrong');
+    if (wrong !== undefined) return wrong;
+  }
+  return undefined;
+}
+
+/** 전제 다섯을 되짚어 카드를 세운다 — 순수 계산, LLM 을 부르지 않는다. */
+export function buildPremiseCard(input: PremiseReviewInput): PremiseReviewCard {
+  const findings: PremiseFinding[] = [
+    { premise: 'P1', verdict: 'unknown', evidence: UNMEASURED },
+    judgeP2(input),
+    judgeP3(input),
+    { premise: 'P4', verdict: 'unknown', evidence: UNMEASURED },
+    { premise: 'P5', verdict: 'unknown', evidence: UNMEASURED },
+  ];
+  return { runId: input.runId, findings, proposal: narrowestWrong(findings) };
+}

package/src/self-implement/pwa-import-graph.ts

@@ -1,5 +1,7 @@
-import { readdirSync, readFileSync } from 'node:fs';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { dirname, join, relative, resolve, sep } from 'node:path';
+import ts from 'typescript';
+import { debug } from '../debug/log.js';
 
 type GraphFiles = {
   readFile?: (path: string) => string;
@@ -24,6 +26,16 @@ function sourceFiles(cwd: string): string[] {
   return files;
 }
 
+const IMPORT_SPECIFIER = /\b(?:import|export)\s+(?:[^;'"]*?\s+from\s*)?['"](\.[^'"]+)['"]|\bimport\s*\(\s*['"](\.[^'"]+)['"]\s*\)/g;
+
+/** Repo-relative file candidates a relative import specifier (already joined to its importer's directory) can resolve to. */
+function importCandidates(base: string): string[] {
+  return /\.js$/.test(base)
+    // A real .js file wins over a same-named .ts source (the actual resolution order).
+    ? [base, base.replace(/\.js$/, '.ts'), base.replace(/\.js$/, '.tsx'), `${base.slice(0, -3)}/index.ts`, `${base.slice(0, -3)}/index.tsx`, `${base.slice(0, -3)}/index.js`]
+    : /\.tsx?$/.test(base) ? [base] : [base + '.ts', base + '.tsx', base + '.js', base + '/index.ts', base + '/index.tsx', base + '/index.js'];
+}
+
 /** PWA source entrypoints and the transitive relative imports they resolve inside repository src/. */
 export function pwaReachableSrcFiles(cwd: string, { readFile = (path) => readFileSync(path, 'utf8'), listFiles = sourceFiles }: GraphFiles = {}): Set<string> {
   const root = resolve(cwd);
@@ -33,7 +45,6 @@ export function pwaReachableSrcFiles(cwd: string, { readFile = (path) => readFil
   // Start from everything apps/pwa/tsconfig.json `include`s — its `src/**/*.ts(x)` also matches *.test.* files, and the Next
   // build type-checks them. Excluding tests hid the real entry (tool-result-chain.test.ts → src/nexus/api/meta-api → most of src).
   const queue = [...available].filter((file) => /^apps\/pwa\/src\/.*\.tsx?$/.test(file));
-  const imports = /\b(?:import|export)\s+(?:[^;'"]*?\s+from\s*)?['"](\.[^'"]+)['"]|\bimport\s*\(\s*['"](\.[^'"]+)['"]\s*\)/g;
   while (queue.length) {
     const file = queue.pop()!;
     if (visited.has(file)) continue;
@@ -42,16 +53,13 @@ export function pwaReachableSrcFiles(cwd: string, { readFile = (path) => readFil
     let content: string;
     try { content = readFile(join(root, file)); }
     catch { continue; }
-    for (const match of content.matchAll(imports)) {
+    for (const match of content.matchAll(IMPORT_SPECIFIER)) {
       const specifier = match[1] ?? match[2];
       if (!specifier) continue;
       const target = resolve(root, dirname(file), specifier);
       const base = relative(root, target).split(sep).join('/');
       if (!base.startsWith('src/')) continue;
-      const candidates = /\.js$/.test(base)
-        // A real .js file wins over a same-named .ts source (the actual resolution order).
-        ? [base, base.replace(/\.js$/, '.ts'), base.replace(/\.js$/, '.tsx'), `${base.slice(0, -3)}/index.ts`, `${base.slice(0, -3)}/index.tsx`, `${base.slice(0, -3)}/index.js`]
-        : /\.tsx?$/.test(base) ? [base] : [base + '.ts', base + '.tsx', base + '.js', base + '/index.ts', base + '/index.tsx', base + '/index.js'];
+      const candidates = importCandidates(base);
       const resolved = candidates.find((candidate) => available.has(candidate));
       if (resolved) {
         if (!visited.has(resolved)) queue.push(resolved);
@@ -63,3 +71,182 @@ export function pwaReachableSrcFiles(cwd: string, { readFile = (path) => readFil
   }
   return reached;
 }
+
+export type AffectedRoots = { roots: Set<string>; failure?: undefined } | { roots?: undefined; failure: string };
+
+function astImportSpecifiers(source: ts.SourceFile): { imports: string[]; ignoredDynamic: number; failure?: string } {
+  const parseError = (source as ts.SourceFile & { parseDiagnostics?: readonly ts.Diagnostic[] }).parseDiagnostics?.[0];
+  if (parseError) return { imports: [], ignoredDynamic: 0, failure: `${source.fileName} AST 파싱 실패: ${ts.flattenDiagnosticMessageText(parseError.messageText, ' ')}` };
+  const imports: string[] = [];
+  let ignoredDynamic = 0;
+  const literal = (node: ts.Node | undefined): string | undefined => node && (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) ? node.text : undefined;
+  const visit = (node: ts.Node): void => {
+    if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
+      const specifier = literal(node.moduleSpecifier);
+      if (specifier) imports.push(specifier);
+    } else if (ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference)) {
+      const specifier = literal(node.moduleReference.expression);
+      if (specifier) imports.push(specifier);
+    } else if (ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument)) {
+      const specifier = literal(node.argument.literal);
+      if (specifier) imports.push(specifier);
+    } else if (ts.isCallExpression(node) && (node.expression.kind === ts.SyntaxKind.ImportKeyword
+      || (ts.isIdentifier(node.expression) && node.expression.text === 'require'))) {
+      const specifier = literal(node.arguments[0]);
+      if (specifier) imports.push(specifier);
+      else ignoredDynamic += 1;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return { imports, ignoredDynamic };
+}
+
+function reExportSpecifiers(source: ts.SourceFile): string[] {
+  const importedLocals = new Map<string, string>();
+  for (const statement of source.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+    const from = statement.moduleSpecifier.text;
+    const clause = statement.importClause;
+    if (clause?.name) importedLocals.set(clause.name.text, from);
+    const bindings = clause?.namedBindings;
+    if (bindings && ts.isNamespaceImport(bindings)) importedLocals.set(bindings.name.text, from);
+    if (bindings && ts.isNamedImports(bindings)) {
+      for (const element of bindings.elements) importedLocals.set(element.name.text, from);
+    }
+  }
+  const specifiers: string[] = [];
+  for (const statement of source.statements) {
+    if (ts.isExportDeclaration(statement)) {
+      if (statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)) specifiers.push(statement.moduleSpecifier.text);
+      else if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+        for (const element of statement.exportClause.elements) {
+          const from = importedLocals.get((element.propertyName ?? element.name).text);
+          if (from) specifiers.push(from);
+        }
+      }
+    } else if (ts.isExportAssignment(statement) && ts.isIdentifier(statement.expression)) {
+      const from = importedLocals.get(statement.expression.text);
+      if (from) specifiers.push(from);
+    }
+  }
+  return specifiers;
+}
+
+/** Declarations visible without an import edge must enter every scoped program. */
+function suppliesAmbientTypes(source: ts.SourceFile): boolean {
+  if (source.fileName.endsWith('.d.ts') || !ts.isExternalModule(source)) return true;
+  const visit = (node: ts.Node): boolean => {
+    if (ts.isModuleDeclaration(node) && (node.name.text === 'global' || ts.isStringLiteral(node.name))) return true;
+    return ts.forEachChild(node, visit) ?? false;
+  };
+  return visit(source);
+}
+
+function gateTypeScriptSources(cwd: string): string[] {
+  const files: string[] = [];
+  const walk = (dir: string): void => {
+    // A partial directory walk is not a valid affected-root measurement: an
+    // unreadable subtree may contain the only importer of a changed file.
+    const entries = readdirSync(join(cwd, dir), { withFileTypes: true });
+    for (const entry of entries) {
+      const path = `${dir}/${entry.name}`;
+      if (entry.isDirectory() && entry.name !== 'node_modules' && !entry.name.startsWith('.')) walk(path);
+      else if (entry.isFile() && /\.ts$/.test(path)) files.push(path);
+    }
+  };
+  for (const root of ['src', 'scripts', 'test']) {
+    // An optional include glob may match no directory in a fixture. Only a
+    // confirmed ENOENT is empty; permission/I/O errors must fail closed.
+    try { statSync(join(cwd, root)); }
+    catch (cause) {
+      if ((cause as NodeJS.ErrnoException).code === 'ENOENT') continue;
+      throw cause;
+    }
+    walk(root);
+  }
+  return files;
+}
+
+/**
+ * Changed .ts files plus the listed files that import one of them directly (one reverse-import step).
+ * Every changed file and every listed file must be readable — an unreadable file could be a hidden importer, so the
+ * result is a failure the caller turns into a full-program run, never a smaller root set.
+ */
+export function reverseImportAffectedRoots(cwd: string, changed: ReadonlySet<string>, { readFile = (path) => readFileSync(path, 'utf8'), listFiles = gateTypeScriptSources }: GraphFiles = {}): AffectedRoots {
+  const root = resolve(cwd);
+  const normalize = (file: string): string => file.replaceAll('\\', '/').replace(/^\.\//, '');
+  const read = (file: string): string | { failure: string } => {
+    try { return readFile(join(root, file)); }
+    catch (cause) { return { failure: `${file} 을 읽지 못했다: ${cause instanceof Error ? cause.message : String(cause)}` }; }
+  };
+  let listed: string[];
+  try { listed = listFiles(cwd).map(normalize); }
+  catch (cause) { return { failure: `소스 목록을 읽지 못했다: ${cause instanceof Error ? cause.message : String(cause)}` }; }
+  const available = new Set(listed);
+  const targets = new Set([...changed].map(normalize));
+  for (const file of targets) {
+    const content = read(file);
+    if (typeof content !== 'string') return content;
+  }
+  const importsByFile = new Map<string, Set<string>>();
+  const barrelsByTarget = new Map<string, Set<string>>();
+  const ambientRoots = new Set<string>();
+  let ignoredDynamic = 0;
+  const resolveImport = (file: string, specifier: string): { target?: string; ignored?: true; unresolved?: true } => {
+    if (!specifier.startsWith('.')) return { ignored: true };
+    const base = relative(root, resolve(root, dirname(file), specifier)).split(sep).join('/');
+    // The gate's tsconfig includes these roots. A relative import outside them
+    // cannot lead back to a changed gate source; asset imports are not TS
+    // source edges either.
+    if (!/^(?:src|scripts|test)\//.test(base) || /\.(?:css|json|svg|png|jpg|jpeg|webp|wasm)$/.test(base)) return { ignored: true };
+    const target = importCandidates(base).find((candidate) => available.has(candidate));
+    return target ? { target } : { unresolved: true };
+  };
+  for (const file of listed) {
+    const content = read(file);
+    if (typeof content !== 'string') return content;
+    let source: ts.SourceFile;
+    try { source = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true); }
+    catch (cause) { return { failure: `${file} AST 파싱 실패: ${cause instanceof Error ? cause.message : String(cause)}` }; }
+    const scanned = astImportSpecifiers(source);
+    if (scanned.failure) return { failure: scanned.failure };
+    if (suppliesAmbientTypes(source)) ambientRoots.add(file);
+    ignoredDynamic += scanned.ignoredDynamic;
+    const imports = new Set<string>();
+    for (const specifier of scanned.imports) {
+      if (!specifier.startsWith('.')) continue;
+      const resolved = resolveImport(file, specifier);
+      if (resolved.unresolved) return { failure: `${file} 의 리터럴 import ${specifier} 해석 실패` };
+      if (resolved.target) imports.add(resolved.target);
+    }
+    importsByFile.set(file, imports);
+    for (const specifier of reExportSpecifiers(source)) {
+      const resolved = resolveImport(file, specifier);
+      if (resolved.unresolved) return { failure: `${file} 의 리터럴 re-export ${specifier} 해석 실패` };
+      if (!resolved.target) continue;
+      const barrels = barrelsByTarget.get(resolved.target) ?? new Set<string>();
+      barrels.add(file);
+      barrelsByTarget.set(resolved.target, barrels);
+    }
+  }
+  if (ignoredDynamic) debug.log('typecheck.gate', 'nonliteral-import-ignored', { count: ignoredDynamic });
+  // A changed export can break an importer through any number of re-export
+  // barrels. Walk that chain to a fixed point, then include direct importers
+  // of each barrel. The visited set also terminates circular barrels.
+  const exported = new Set(targets);
+  const queue = [...targets];
+  while (queue.length) {
+    const target = queue.pop()!;
+    for (const barrel of barrelsByTarget.get(target) ?? []) {
+      if (exported.has(barrel)) continue;
+      exported.add(barrel);
+      queue.push(barrel);
+    }
+  }
+  const roots = new Set([...exported, ...ambientRoots]);
+  for (const [file, imports] of importsByFile) {
+    if ([...imports].some((target) => exported.has(target))) roots.add(file);
+  }
+  return { roots };
+}