elanous 0.2.36 → 0.2.37

package/src/self-implement/goal-supervisor-fill.ts

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { extractGoalDocSections } from './goal-doc/section.js';
@@ -8,8 +9,8 @@ export interface SupervisorGoalFillEvidence {
   reviewVerdict: 'pass' | 'warn' | 'fail';
   /** ⭐ 게이트 로그에서 **실제로 읽은** fail 수. 기대값이 아니다(리뷰 must-fix). */
   observedFail: number;
-  /** 게이트 로그의 baseline 행 원문 — 독립 검사기가 **이 문자열을 다시 판정**한다. */
-  baselineLine: string;
+  /** 실패 귀속 baseline이 실제 실행됐을 때만 있는 행. PASS에서는 실행하지 않는다. */
+  baselineLine?: string;
   /** ⭐ **원천 그대로** — 독립 검사기가 writer 의 파싱 결과가 아니라 **로그를 직접** 다시 읽는다. */
   gateLog: string;
 }
@@ -17,28 +18,41 @@ export interface SupervisorGoalFillEvidence {
 export interface SupervisorGoalFillInput {
   path: string;
   round: number;
-  gate: { passed: boolean; log?: string };
+  gate: { passed: boolean; log?: string; testStepExecuted?: boolean; scopeReason?: string };
   review?: { verdict: 'pass' | 'warn' | 'fail' };
   /** An external checker, deliberately separate from this writer/parser. */
   independentlyCheck: (document: string, evidence: SupervisorGoalFillEvidence) => Promise<boolean>;
+  wiring?: 'wired' | 'unwired';
+  observeDeficit?: (observation: SupervisorGoalDeficit) => void;
 }
 
-export type SupervisorGoalFillResult = 'filled' | 'already-filled' | 'unverifiable' | 'rejected';
+export interface SupervisorGoalDeficit {
+  evidenceId: string;
+  kind: 'unmeasured' | 'unwired' | 'unverified';
+  previousEvidence: string;
+  round: number;
+  gateLog?: string;
+  /** Decision branch, without gate log or goal text. */
+  reason?: 'missing-section' | 'missing-invariant-slot' | 'missing-signal-slot' | 'gate-evidence-unverified' | 'review-unavailable' | 'goal-unwired' | 'slot-format' | 'authored-signal-command-mismatch' | 'independent-check-failed';
+  inputSummary?: { gatePassed: boolean; hasGateLog: boolean; hasReview: boolean; invariantSlot: boolean; signalSlot: boolean };
+  gateLogRef?: string;
+}
+
+export type SupervisorGoalFillResult = 'filled' | 'already-filled' | 'not-applicable' | 'unverifiable' | 'rejected';
 
 const UNVERIFIABLE = 'UNVERIFIABLE';
 
 interface VerifiedGateEvidence {
   command: string;
   observedFail: number;
-  baselineLine: string;
+  baselineLine?: string;
 }
 
 /**
  * ⛔ **로그가 스스로 모순이면 채우지 않는다.** 종전 판은 ⓐ `[test] PASS` 접두와 명령 모양만 보고
- * ⓑ baseline 행이 **아예 없어도 통과**시켰다 ⇒ `[test] PASS bun test x — 0 pass | 5 fail` 같은
- * 로그로도 *"fail 0"* 을 채울 수 있었다(리뷰 must-fix).
- * ⇒ **fail 수를 실제로 읽고**, baseline 행을 **필수**로 하고, 그 원문을 증거에 실어 독립 검사기가
- *   같은 로그를 **다시** 판정할 수 있게 한다.
+ * ⓑ PASS 로그의 fail 수를 읽지 않아 `[test] PASS ... 5 fail`도 채울 수 있었다.
+ * ⇒ PASS의 실제 0 fail 요약을 필수로 읽는다. 실패 귀속용 baseline은 실행된 경우에만
+ *   원문을 검증하며, PASS에서 측정하지 않은 baseline 0건을 만들어 적지 않는다.
  */
 function verifiedGateEvidence(gate: SupervisorGoalFillInput['gate']): VerifiedGateEvidence | undefined {
   if (!gate.passed || !gate.log) return undefined;
@@ -54,11 +68,13 @@ function verifiedGateEvidence(gate: SupervisorGoalFillInput['gate']): VerifiedGa
   const observedFail = Number(failMatch[1]);
   if (observedFail !== 0) return undefined;   // PASS 라고 적혀 있어도 fail 이 있으면 모순이다
 
-  // ⛔ baseline 행은 **필수**다 — 없으면 "깨끗하다" 가 아니라 "안 쟀다" 이다.
+  // PASS 자체가 test 0 fail의 측정값이다. 실패 귀속 baseline은 PASS에서 실행되지 않는다.
+  // 행이 있다면 실제 값을 검증하고, 잘못된/모순된 행은 조용히 무시하지 않는다.
+  const rawBaseline = gate.log.split('\n').find((line) => line.startsWith('[gate-baseline]'));
   const baseline = gate.log.match(/^\[gate-baseline\]\s+introduced=(\d+),\s*preexisting=(\d+),\s*unknown=(\d+),\s*precondition-unmet=(\d+).*$/m);
-  if (!baseline) return undefined;
-  if (baseline.slice(1, 5).some((count) => count !== '0')) return undefined;
-  return { command, observedFail, baselineLine: baseline[0].trim() };
+  if (rawBaseline && !baseline) return undefined;
+  if (baseline?.slice(1, 5).some((count) => count !== '0')) return undefined;
+  return { command, observedFail, ...(baseline ? { baselineLine: baseline[0].trim() } : {}) };
 }
 
 function section(document: string, heading: string): { start: number; end: number; body: string } | undefined {
@@ -75,11 +91,11 @@ function section(document: string, heading: string): { start: number; end: numbe
  * ⛔ 그리고 **기대값이 아니라 관측값**을 적는다 — 종전 판은 로그를 안 읽고 `기대 — fail 0` 을 박았다.
  */
 function invariantReplacement(evidence: SupervisorGoalFillEvidence): string {
-  return `- filled-by: supervisor@round-${evidence.round}\n  조건 — ${evidence.command} 가 실패 없이 끝난다\n  이 라운드에서 관측됨 — fail ${evidence.observedFail}\n  근거 — round-${evidence.round} gate [test] PASS ${evidence.command} · ${evidence.baselineLine}`;
+  return `- filled-by: supervisor@round-${evidence.round}\n  조건 — ${evidence.command} 가 실패 없이 끝난다\n  이 라운드에서 관측됨 — fail ${evidence.observedFail}\n  근거 — round-${evidence.round} gate [test] PASS ${evidence.command} · ${evidence.baselineLine ?? 'baseline not run (test PASS)'}`;
 }
 
 function signalReplacement(evidence: SupervisorGoalFillEvidence): string {
-  return `- filled-by: supervisor@round-${evidence.round}\n  관측 — \`${evidence.command}\` 요약 줄의 fail 수\n  이번 라운드 관측값 — fail ${evidence.observedFail}\n  근거 — round-${evidence.round} review ${evidence.reviewVerdict} · ${evidence.baselineLine}`;
+  return `- filled-by: supervisor@round-${evidence.round}\n  관측 — \`${evidence.command}\` 요약 줄의 fail 수\n  이번 라운드 관측값 — fail ${evidence.observedFail}\n  근거 — round-${evidence.round} review ${evidence.reviewVerdict} · ${evidence.baselineLine ?? 'baseline not run (test PASS)'}`;
 }
 
 function replaceUnverifiableSlot(body: string, filled: string): string | undefined {
@@ -88,7 +104,7 @@ function replaceUnverifiableSlot(body: string, filled: string): string | undefin
 }
 
 /**
- * Fill only the two empty authored slots. Gate evidence is accepted only when
+ * Fill an empty invariant and either an empty signal or append an observation to an authored signal. Gate evidence is accepted only when
  * its logged test command and PASS status agree; baseline contradictions keep
  * the original document queued and byte-identical.
  */
@@ -96,27 +112,60 @@ export async function fillUnverifiableGoalSlots(input: SupervisorGoalFillInput):
   const original = readFileSync(input.path, 'utf8');
   const invariant = section(original, '## 불변식');
   const signals = section(original, '## 판정 신호');
-  if (!invariant || !signals) return 'unverifiable';
-  const invariantNeedsFill = invariant.body.includes(UNVERIFIABLE);
-  const signalsNeedFill = signals.body.includes(UNVERIFIABLE);
-  if (!invariantNeedsFill && !signalsNeedFill) return 'already-filled';
-
+  const invariantSlot = Boolean(invariant && /^- UNVERIFIABLE(?:[ \t]*:[^\r\n]*)?[ \t]*$/m.test(invariant.body));
+  const signalSlot = Boolean(signals && /^- UNVERIFIABLE(?:[ \t]*:[^\r\n]*)?[ \t]*$/m.test(signals.body));
   const gateEvidence = verifiedGateEvidence(input.gate);
-  if (!invariantNeedsFill || !signalsNeedFill || !gateEvidence || !input.review) return 'unverifiable';
+  const deficit = (reason: NonNullable<SupervisorGoalDeficit['reason']>): void => input.observeDeficit?.({
+    evidenceId: createHash('sha256').update(JSON.stringify([input.path, input.round, original])).digest('hex').slice(0, 16),
+    kind: !gateEvidence || !input.review ? 'unmeasured' : input.wiring === 'unwired' ? 'unwired' : 'unverified',
+    previousEvidence: original,
+    round: input.round,
+    ...(input.gate.log !== undefined ? { gateLog: input.gate.log } : {}),
+    reason,
+    inputSummary: { gatePassed: input.gate.passed, hasGateLog: Boolean(input.gate.log), hasReview: Boolean(input.review), invariantSlot, signalSlot },
+    ...(input.gate.log ? { gateLogRef: `sha256:${createHash('sha256').update(input.gate.log).digest('hex').slice(0, 16)}` } : {}),
+  });
+  if (!invariant || !signals) {
+    // A sectionless goal has no slot the supervisor can measure or repair.
+    // Report a deficit only when a present section contains an actual slot.
+    if (invariantSlot || signalSlot) deficit('missing-section');
+    return 'unverifiable';
+  }
+  if (!invariantSlot && !signalSlot && !invariant.body.includes(UNVERIFIABLE) && !signals.body.includes(UNVERIFIABLE)
+    && input.wiring !== 'unwired') return 'already-filled';
+  if (!invariantSlot) { deficit('missing-invariant-slot'); return 'unverifiable'; }
+  if (!signalSlot && !signals.body.trim()) { deficit('missing-signal-slot'); return 'unverifiable'; }
+  // A docs-only PASS has no test measurement to put into the authored slots.
+  // Trust the gate's structured scope, never a free-text log line, and leave the goal unchanged.
+  if (input.gate.passed && input.gate.testStepExecuted === false && input.gate.scopeReason === 'docs-only'
+    && input.wiring !== 'unwired') {
+    return 'not-applicable';
+  }
+  if (!gateEvidence) { deficit('gate-evidence-unverified'); return 'unverifiable'; }
+  if (!input.review) { deficit('review-unavailable'); return 'unverifiable'; }
+  if (input.wiring === 'unwired') { deficit('goal-unwired'); return 'unverifiable'; }
+  // The authored completion signal must name the test we actually measured.
+  if (!signalSlot) {
+    const authoredCommand = signals.body.match(/^\s*- Condition:\s*(bun test\s+[^\r\n]+?)(?:\s+를 실행한다)?\s*$/m)?.[1]?.trim();
+    if (!authoredCommand || authoredCommand !== gateEvidence.command) {
+      deficit('authored-signal-command-mismatch'); return 'unverifiable';
+    }
+  }
 
   const evidence: SupervisorGoalFillEvidence = {
     round: input.round,
     command: gateEvidence.command,
     reviewVerdict: input.review.verdict,
     observedFail: gateEvidence.observedFail,
-    baselineLine: gateEvidence.baselineLine,
+    ...(gateEvidence.baselineLine ? { baselineLine: gateEvidence.baselineLine } : {}),
     gateLog: input.gate.log ?? '',
   };
   const invariantBody = replaceUnverifiableSlot(invariant.body, invariantReplacement(evidence));
-  const signalBody = replaceUnverifiableSlot(signals.body, signalReplacement(evidence));
-  if (invariantBody === undefined || signalBody === undefined) return 'unverifiable';
+  const signalBody = signalSlot ? replaceUnverifiableSlot(signals.body, signalReplacement(evidence))
+    : `${signals.body.replace(/\s*$/, '')}\n${signalReplacement(evidence)}\n`;
+  if (invariantBody === undefined || signalBody === undefined) { deficit('slot-format'); return 'unverifiable'; }
   const candidate = `${original.slice(0, invariant.start)}## 불변식${invariantBody}${original.slice(invariant.end, signals.start)}## 판정 신호${signalBody}${original.slice(signals.end)}`;
-  if (!await input.independentlyCheck(candidate, evidence)) return 'rejected';
+  if (!await input.independentlyCheck(candidate, evidence)) { deficit('independent-check-failed'); return 'rejected'; }
 
   const temporary = join(dirname(input.path), `.${Math.random().toString(16).slice(2)}.goal-fill.tmp`);
   try {

package/src/self-implement/importer-test-index.ts

@@ -4,10 +4,42 @@ import ts from 'typescript';
 
 const IMPORTER_TEST_DISPLAY_LIMIT = 20;
 
+/** 런타임 간선 클래스 — 시험이 소스를 **실제 프로세스**·`git`·파일 상태로 건드리는 경우다.
+ *  임포트 그래프에는 이 간선이 «없다»: `import` 문이 없으니 `testsBySource` 에도 안 잡힌다. */
+export type RuntimeEdgeKind = 'spawn' | 'git' | 'file-state';
+
+/** 시험 1건이 만든 런타임 간선 1건. `source` 가 `null` 이면 그 명령은 파일을 지목하지 않는다(`git`). */
+export interface RuntimeEdge {
+  readonly test: string;
+  readonly kind: RuntimeEdgeKind;
+  readonly source: string | null;
+}
+
+/** 런타임 간선의 **영향 크기** — 임포트 그래프가 표현할 수 없는 간선이 변경 감시에 «얼마나 더하는가».
+ *
+ *  ⛔ #28322 착지분(BFS 분포·사람용 표)을 재구현하지 않는다 — 여기는 **수**만 낸다. */
+export interface RuntimeEdgeImpact {
+  /** 변경 소스에 «임포트가 아니라 런타임으로» 닿는 (시험, 소스) 짝의 수 — 임포트 그래프 위에 더해지는 크기. */
+  readonly pairs: number;
+  /** 클래스별 크기 — 그 클래스의 런타임 간선**만**이 변경 소스에 닿는 시험 수. */
+  readonly byKind: Readonly<Record<RuntimeEdgeKind, number>>;
+  /** 손으로 관리하는 착지 열차 spawn-lane 목록(`GATE_SPAWN_LANE_FILES`)이 **빠뜨린** 실측 시험들.
+   *  ⛔ 손 목록은 구조적으로 드리프트한다 — 그 드리프트 «크기»를 재는 자리다(고치지는 않는다). */
+  readonly unlistedSpawnLaneTests: readonly string[];
+  /** 실재 소스로 풀리지 않은 런타임 경로 리터럴 수 — `unresolvedRelativeSpecifiers` 와 «같은» 정직성 계수. */
+  readonly unresolvedRuntimeTargets: number;
+  /** 「쟀다」표 — `runtimeEdges` 가 없는 색인은 «못 잰 것»이므로 `measured: false` 다(`pairs: 0` 과 섞지 않는다). */
+  readonly measured: boolean;
+}
+
 export interface ImporterTestIndex {
   readonly testsBySource: ReadonlyMap<string, readonly string[]>;
   readonly testPaths?: readonly string[];
   readonly unresolvedRelativeSpecifiers: number;
+  /** 측정된 런타임 간선(선택) — 없으면 「안 쟀다」이지 「0건」이 아니다(`measureRuntimeEdgeImpact` 참조). */
+  readonly runtimeEdges?: readonly RuntimeEdge[];
+  /** 소스로 풀리지 않은 런타임 경로 리터럴 수(선택 · 위와 같은 이유로 optional). */
+  readonly unresolvedRuntimeTargets?: number;
 }
 
 // ⛔⭐ `\S+` 를 쓰지 않는다(무인 리뷰 should-fix) — 공백이 든 «유효한» 추적 경로가 «조용히» 빠진다.
@@ -80,10 +112,143 @@ export function sourceCandidates(testPath: string, specifier: string): readonly
   ];
 }
 
+/** 실물 자식 프로세스·파일 상태를 만드는 «런타임 모듈 임포트»의 호출 이름 → 클래스. ⛔⭐ 호출 이름의
+ *  마지막 조각만 보지 않는다(무인 리뷰 must-fix) — 수신 객체·맨살 callee 의 **임포트 바인딩** 출처를
+ *  확인한다(`runtimeEdgeImports`·`declaredRuntimeEdgeKind`). 그래서 `/re/.exec(str)`·`db.exec(...)`·
+ *  `fsMock.readFile(...)` 같은 일반 호출은 이 표와 «이름이 같아도» 간선이 되지 않는다. */
+const RUNTIME_EDGE_CALLS: Readonly<Record<string, RuntimeEdgeKind>> = {
+  spawn: 'spawn', spawnSync: 'spawn', exec: 'spawn', execSync: 'spawn', execFile: 'spawn', execFileSync: 'spawn',
+  readFile: 'file-state', readFileSync: 'file-state', writeFile: 'file-state', writeFileSync: 'file-state',
+  appendFileSync: 'file-state', copyFileSync: 'file-state', cpSync: 'file-state', renameSync: 'file-state',
+  existsSync: 'file-state', statSync: 'file-state', lstatSync: 'file-state', readdir: 'file-state',
+  readdirSync: 'file-state', mkdirSync: 'file-state', rmSync: 'file-state', unlinkSync: 'file-state',
+  accessSync: 'file-state', openSync: 'file-state', chmodSync: 'file-state', truncateSync: 'file-state',
+  readlinkSync: 'file-state', realpathSync: 'file-state',
+};
+
+/** URL·절대경로는 저장소 경로가 아니다 — 후보 해석에도, 「못 풀었다」에도 넣지 않는다. */
+function isRepoRelativeLiteral(literal: string): boolean {
+  if (!literal.includes('/')) return false;
+  if (literal.startsWith('/')) return false;
+  return !/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(literal);
+}
+
+/** 런타임 리터럴 → 실재 소스. 루트 기준 리터럴(`bin/elanous.mjs`)은 «상대 지정자»가 아니므로 `''` 를 기준점으로
+ *  쓴다 — 그래야 확장자·쿼리 규칙이 임포트 해석(`sourceCandidates`)과 **갈리지 않는다**. */
+function resolveRuntimeTarget(testPath: string, literal: string, sources: ReadonlySet<string>): string | null {
+  if (!isRepoRelativeLiteral(literal)) return null;
+  const candidates = literal.startsWith('.')
+    ? sourceCandidates(testPath, literal)
+    : [normalize(stripModuleQuery(literal)), ...sourceCandidates('', literal)];
+  return candidates.find((candidate) => sources.has(candidate)) ?? null;
+}
+
+interface RuntimeEdgeCall { readonly kind: RuntimeEdgeKind; readonly literals: readonly string[] }
+
+/** 런타임 간선을 만드는 모듈 — `node:` 접두사는 벗겨 비교한다. `Bun` 은 전역이라 임포트가 없고, 수신
+ *  객체 이름으로만 허용한다(`declaredRuntimeEdgeKind`). */
+const RUNTIME_EDGE_MODULES: ReadonlySet<string> = new Set(['child_process', 'fs', 'fs/promises', 'bun']);
+
+function isRuntimeEdgeModule(specifier: string): boolean {
+  return RUNTIME_EDGE_MODULES.has(specifier.startsWith('node:') ? specifier.slice('node:'.length) : specifier);
+}
+
+/** 시험 파일의 런타임 모듈 임포트 바인딩 — 로컬 이름 → 임포트된 이름(네임스페이스·기본 임포트는 `'*'`).
+ *  ⛔⭐ 임포트 출처를 알 수 없는 수신 객체는 간선을 만들지 «않는다»(무인 리뷰 must-fix) — `db.exec(...)`·
+ *  `fsMock.readFile(...)` 같은 호출 이름이 spawn·file-state 간선으로 승격되던 오탐을 고치는 자리다. */
+function runtimeEdgeImports(sourceFile: ts.SourceFile): ReadonlyMap<string, string> {
+  const bindings = new Map<string, string>();
+  for (const statement of sourceFile.statements) {
+    if (!ts.isImportDeclaration(statement) || !statement.moduleSpecifier || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+    if (!isRuntimeEdgeModule(statement.moduleSpecifier.text)) continue;
+    const clause = statement.importClause;
+    if (!clause) continue;
+    if (clause.name) bindings.set(clause.name.text, '*');
+    const named = clause.namedBindings;
+    if (!named) continue;
+    if (ts.isNamespaceImport(named)) bindings.set(named.name.text, '*');
+    else for (const element of named.elements) {
+      if (element.isTypeOnly) continue;
+      bindings.set(element.name.text, element.propertyName?.text ?? element.name.text);
+    }
+  }
+  return bindings;
+}
+
+/** 수신 객체·맨살 callee 가 런타임 모듈에서 왔는지 임포트 바인딩으로 확인하고, 그럴 때만 클래스를 낸다.
+ *  - `obj.method`: 수신 객체가 런타임 모듈 바인딩이거나 전역 `Bun` 일 때만.
+ *  - 맨살 `fn(...)`: 런타임 모듈의 named import 이고 «임포트된 이름»이 표에 있을 때만(`as` 별칭도 잡는다).
+ *  - 정규식 리터럴(`/re/.exec`)·출처를 알 수 없는 수신 객체는 `undefined` — 간선이 아니다. */
+function declaredRuntimeEdgeKind(callee: ts.Expression, imports: ReadonlyMap<string, string>): RuntimeEdgeKind | undefined {
+  if (ts.isPropertyAccessExpression(callee)) {
+    const receiver = callee.expression;
+    if (!ts.isIdentifier(receiver)) return undefined;
+    if (receiver.text !== 'Bun' && !imports.has(receiver.text)) return undefined;
+    return RUNTIME_EDGE_CALLS[callee.name.text];
+  }
+  if (ts.isIdentifier(callee)) {
+    const imported = imports.get(callee.text);
+    if (imported === undefined || imported === '*') return undefined;
+    return RUNTIME_EDGE_CALLS[imported];
+  }
+  return undefined;
+}
+
+/** 시험 소스에서 런타임 호출을 찾아 «무엇을 지목했는지»까지 모은다. */
+function runtimeEdgeCalls(text: string, path: string): RuntimeEdgeCall[] {
+  const sourceFile = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, false);
+  const calls: RuntimeEdgeCall[] = [];
+  const literalsOf = (node: ts.Node, out: string[]): void => {
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) out.push(node.text);
+    else ts.forEachChild(node, (child) => literalsOf(child, out));
+  };
+  const runtimeImports = runtimeEdgeImports(sourceFile);
+  const visit = (node: ts.Node): void => {
+    if (ts.isCallExpression(node)) {
+      const declared = declaredRuntimeEdgeKind(node.expression, runtimeImports);
+      if (declared) {
+        const literals: string[] = [];
+        for (const argument of node.arguments) literalsOf(argument, literals);
+        // `git` 은 파일을 «지목하지 않는» 별도 클래스다(`spawnSync('git', ['diff', …])` · `execSync('git …')`).
+        const command = literals[0] ?? '';
+        calls.push({ kind: /^git\b/.test(command) ? 'git' : declared, literals });
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return calls;
+}
+
+/** 시험 1건의 런타임 간선과 «못 푼» 경로 리터럴. 지목한 소스가 하나도 없으면 `source: null` 간선 하나를 남긴다
+ *  — 파일을 안 지목해도 실물 프로세스를 띄운 사실은 사라지지 않는다. */
+function runtimeEdgesOfTest(text: string, testPath: string, sources: ReadonlySet<string>): { edges: RuntimeEdge[]; unresolved: readonly string[] } {
+  const edges: RuntimeEdge[] = [];
+  const unresolved: string[] = [];
+  for (const call of runtimeEdgeCalls(text, testPath)) {
+    const targets = call.literals.map((literal) => resolveRuntimeTarget(testPath, literal, sources));
+    call.literals.forEach((literal, position) => {
+      if (targets[position] !== null) return;
+      if (!isRepoRelativeLiteral(literal) || !isSourceLikeSpecifier(literal)) return;
+      // `.json`·`.css` 같은 자원은 «런타임 대상»이지 못 푼 소스가 아니다(`isSourceLikeSpecifier` 가 이미 거른다).
+      if (!unresolved.includes(literal)) unresolved.push(literal);
+    });
+    const resolved = targets.filter((target): target is string => target !== null);
+    for (const source of resolved.length > 0 ? resolved : [null]) edges.push({ test: testPath, kind: call.kind, source });
+  }
+  return { edges, unresolved };
+}
+
+/** 경로 정렬 — 기존 표시 순서(`localeCompare` 수치)와 같은 자를 쓴다. */
+function comparePaths(left: string, right: string): number { return left.localeCompare(right, undefined, { numeric: true }); }
+
 export function buildImporterTestIndex(cwd: string, testPaths: readonly string[], sourcePaths: readonly string[]): ImporterTestIndex | null {
   const sources = new Set(sourcePaths);
   const testsBySource = new Map<string, string[]>();
   let unresolvedRelativeSpecifiers = 0;
+  const runtimeEdges: RuntimeEdge[] = [];
+  const seenRuntimeEdges = new Set<string>();
+  const unresolvedRuntimeTargets = new Set<string>();
   for (const testPath of testPaths) {
     if (!TEST_PATH_RE.test(testPath)) continue;
     let text: string;
@@ -107,8 +272,16 @@ export function buildImporterTestIndex(cwd: string, testPaths: readonly string[]
       if (!importers.includes(testPath)) importers.push(testPath);
       testsBySource.set(source, importers);
     }
+    const runtime = runtimeEdgesOfTest(text, testPath, sources);
+    for (const edge of runtime.edges) {
+      const key = `${edge.test}\u0000${edge.kind}\u0000${edge.source ?? ''}`;
+      if (seenRuntimeEdges.has(key)) continue;
+      seenRuntimeEdges.add(key);
+      runtimeEdges.push(edge);
+    }
+    for (const literal of runtime.unresolved) unresolvedRuntimeTargets.add(`${testPath}\u0000${literal}`);
   }
-  return { testsBySource, testPaths, unresolvedRelativeSpecifiers };
+  return { testsBySource, testPaths, unresolvedRelativeSpecifiers, runtimeEdges, unresolvedRuntimeTargets: unresolvedRuntimeTargets.size };
 }
 
 export function importerTestsNotInRunSet(
@@ -117,7 +290,47 @@ export function importerTestsNotInRunSet(
   runSet: readonly string[],
 ): { readonly total: number; readonly files: readonly string[]; readonly truncated: boolean; readonly unresolvedRelativeSpecifiers: number } {
   const names = [...new Set(changed.flatMap((source) => index.testsBySource.get(source) ?? []).filter((test) => !runSet.includes(test)))]
-    .sort((left, right) => left.localeCompare(right, undefined, { numeric: true }));
+    .sort(comparePaths);
   const files = names.slice(0, IMPORTER_TEST_DISPLAY_LIMIT);
   return { total: names.length, files, truncated: names.length > files.length, unresolvedRelativeSpecifiers: index.unresolvedRelativeSpecifiers };
 }
+
+/** ⭐ 런타임 간선의 **영향 크기 실측** — 임포트 그래프가 «표현할 수 없는» 간선이 변경 감시에 얼마나 더하는가.
+ *
+ *  ⛔ #28322 착지분(BFS 분포·사람용 표 렌더링)은 여기서 재구현하지 않는다 — 이 함수는 **수**만 낸다.
+ *  ⛔ «색인이 안 실렸다»와 «런타임 간선 0건»은 다른 값이다: `runtimeEdges` 가 없는 색인은 `pairs: 0` 이
+ *    아니라 **못 잰 것**이므로 `measured: false` 로 드러낸다.
+ *
+ *  `handListed` 는 «손으로 관리하는 목록»이다(착지 열차의 `GATE_SPAWN_LANE_FILES`). 그 목록이 빠뜨린
+ *  실측 시험 수가 곧 착지 열차 소비자의 영향 크기다.
+ */
+export function measureRuntimeEdgeImpact(
+  index: ImporterTestIndex,
+  changed: readonly string[],
+  opts: { readonly handListed?: readonly string[] } = {},
+): RuntimeEdgeImpact {
+  const edges = index.runtimeEdges;
+  const changedSet = new Set(changed);
+  const pairs = new Set<string>();
+  const testsByKind: Record<RuntimeEdgeKind, Set<string>> = { spawn: new Set(), git: new Set(), 'file-state': new Set() };
+  for (const edge of edges ?? []) {
+    if (edge.source === null || !changedSet.has(edge.source)) continue;
+    // 이미 «임포트» 간선이 있는 짝은 런타임 간선의 몫이 아니다 — 같은 커버리지를 두 번 세지 않는다.
+    if ((index.testsBySource.get(edge.source) ?? []).includes(edge.test)) continue;
+    pairs.add(`${edge.test}\u0000${edge.source}`);
+    testsByKind[edge.kind].add(edge.test);
+  }
+  const handListed = new Set(opts.handListed ?? []);
+  const unlistedSpawnLaneTests = [...new Set((edges ?? [])
+    .filter((edge) => edge.kind === 'spawn' || edge.kind === 'git')
+    .map((edge) => edge.test))]
+    .filter((test) => !handListed.has(test))
+    .sort(comparePaths);
+  return {
+    measured: edges !== undefined,
+    pairs: pairs.size,
+    byKind: { spawn: testsByKind.spawn.size, git: testsByKind.git.size, 'file-state': testsByKind['file-state'].size },
+    unlistedSpawnLaneTests,
+    unresolvedRuntimeTargets: index.unresolvedRuntimeTargets ?? 0,
+  };
+}

package/src/self-implement/knowhow-pack.ts

@@ -42,8 +42,8 @@ function mentionedPaths(text: string): Set<string> {
   return paths;
 }
 
-function relevance(goal: string, section: string): number {
-  const paths = mentionedPaths(goal);
+function relevance(goal: string, section: string, targetPaths?: readonly string[]): number {
+  const paths = targetPaths === undefined ? mentionedPaths(goal) : new Set(targetPaths);
   const sourcePaths = mentionedPaths(section);
   let score = 0;
   for (const path of paths) {
@@ -58,8 +58,8 @@ function relevance(goal: string, section: string): number {
   return score;
 }
 
-/** Reads only 내부 문서 `KNOWHOW` inside the supplied repository. */
-export function selectKnowhowPack(repo: string, goal: string): KnowhowPack {
+/** Reads only 내부 문서 `KNOWHOW` inside the supplied repository. Verified target paths narrow relevance when supplied. */
+export function selectKnowhowPack(repo: string, goal: string, targetPaths?: readonly string[]): KnowhowPack {
   if (goal.includes(MARKER)) return { text: '', ids: [], bytes: 0 };
   const rolesDir = resolve(repo, 'docs/roles');
   let realRoles: string;
@@ -78,7 +78,7 @@ export function selectKnowhowPack(repo: string, goal: string): KnowhowPack {
       const real = realpathSync(file);
       if (!inside(realRoles, real) || !statSync(real).isFile() || statSync(real).size > 2_000_000) continue;
       for (const section of promotedSections(readFileSync(real, 'utf8'))) {
-        const score = relevance(goal, section.text);
+        const score = relevance(goal, section.text, targetPaths);
         if (score > 0) candidates.push({ ...section, score });
       }
     } catch { /* A missing or unreadable source contributes no entry. */ }