elanous 0.2.37 → 0.2.40

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

@@ -1,7 +1,7 @@
 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';
+import { authoredSignalCommandFromBody, extractGoalDocSections } from './goal-doc/section.js';
 
 export interface SupervisorGoalFillEvidence {
   round: number;
@@ -13,6 +13,7 @@ export interface SupervisorGoalFillEvidence {
   baselineLine?: string;
   /** ⭐ **원천 그대로** — 독립 검사기가 writer 의 파싱 결과가 아니라 **로그를 직접** 다시 읽는다. */
   gateLog: string;
+  authoredSignal?: { command: string; exitCode: number | null; stdout: string; stderr: string };
 }
 
 export interface SupervisorGoalFillInput {
@@ -20,6 +21,7 @@ export interface SupervisorGoalFillInput {
   round: number;
   gate: { passed: boolean; log?: string; testStepExecuted?: boolean; scopeReason?: string };
   review?: { verdict: 'pass' | 'warn' | 'fail' };
+  authoredSignal?: SupervisorGoalFillEvidence['authoredSignal'];
   /** An external checker, deliberately separate from this writer/parser. */
   independentlyCheck: (document: string, evidence: SupervisorGoalFillEvidence) => Promise<boolean>;
   wiring?: 'wired' | 'unwired';
@@ -34,6 +36,8 @@ export interface SupervisorGoalDeficit {
   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';
+  /** Safe, bounded detail for a decision branch (for example, the authored test files absent from the measured command). */
+  reasonDetail?: string;
   inputSummary?: { gatePassed: boolean; hasGateLog: boolean; hasReview: boolean; invariantSlot: boolean; signalSlot: boolean };
   gateLogRef?: string;
 }
@@ -85,6 +89,15 @@ function section(document: string, heading: string): { start: number; end: numbe
   })[0];
 }
 
+/** Accept only explicit Bun test-file lists; never interpret shell syntax or options as file coverage. */
+function testFiles(command: string): string[] | undefined {
+  const match = command.trim().match(/^bun\s+test\s+(.+)$/);
+  if (!match) return undefined;
+  const files = match[1].trim().split(/\s+/);
+  if (!files.length || files.some((file) => !/^[A-Za-z0-9_./-]+\.test\.(?:ts|tsx|js|jsx|mjs|cjs)$/.test(file))) return undefined;
+  return [...new Set(files)];
+}
+
 /**
  * ⛔ **두 절은 서로 다른 것을 말한다** — 같은 문자열을 양쪽에 넣으면 무엇도 검증하지 않는다(리뷰 must-fix).
  *   `불변식` = 이 골이 **지켜야 할 조건** · `판정 신호` = 그것을 **어떻게 관측하나**.
@@ -95,6 +108,10 @@ function invariantReplacement(evidence: SupervisorGoalFillEvidence): string {
 }
 
 function signalReplacement(evidence: SupervisorGoalFillEvidence): string {
+  if (evidence.authoredSignal) {
+    const output = `${evidence.authoredSignal.stdout}\n${evidence.authoredSignal.stderr}`.trim().slice(-1200) || '(출력 없음)';
+    return `- filled-by: supervisor@round-${evidence.round}\n  관측 — \`${evidence.authoredSignal.command}\` 실행 결과\n  이번 라운드 관측값 — exit ${evidence.authoredSignal.exitCode}\n  원문 출력 — ${output.replace(/\r?\n/g, ' ⏎ ')}\n  gate 검증 — ${evidence.command} · fail ${evidence.observedFail} · ${evidence.baselineLine ?? 'baseline not run (test PASS)'}\n  근거 — authored signal command executed in this run · review ${evidence.reviewVerdict}`;
+  }
   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)'}`;
 }
 
@@ -146,9 +163,25 @@ export async function fillUnverifiableGoalSlots(input: SupervisorGoalFillInput):
   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 authoredCommand = authoredSignalCommandFromBody(signals.body);
+    const authoredFiles = authoredCommand ? testFiles(authoredCommand) : undefined;
+    const measuredFiles = testFiles(gateEvidence.command);
+    const missingFiles = authoredFiles && measuredFiles ? authoredFiles.filter((file) => !measuredFiles.includes(file)) : [];
+    const signalRun = input.authoredSignal;
+    const signalMeasured = authoredCommand && signalRun?.command === authoredCommand && signalRun.exitCode === 0;
+    if (!signalMeasured) {
+      const observation: SupervisorGoalDeficit = {
+        evidenceId: createHash('sha256').update(JSON.stringify([input.path, input.round, original])).digest('hex').slice(0, 16),
+        kind: 'unverified', previousEvidence: original, round: input.round,
+        ...(input.gate.log !== undefined ? { gateLog: input.gate.log } : {}),
+        reason: 'authored-signal-command-mismatch',
+        reasonDetail: missingFiles.length ? `authored test file(s) absent from passing gate command: ${missingFiles.join(', ')}`
+          : 'authored command has no matching successful execution evidence',
+        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)}` } : {}),
+      };
+      input.observeDeficit?.(observation);
+      return 'unverifiable';
     }
   }
 
@@ -159,6 +192,7 @@ export async function fillUnverifiableGoalSlots(input: SupervisorGoalFillInput):
     observedFail: gateEvidence.observedFail,
     ...(gateEvidence.baselineLine ? { baselineLine: gateEvidence.baselineLine } : {}),
     gateLog: input.gate.log ?? '',
+    ...(input.authoredSignal ? { authoredSignal: input.authoredSignal } : {}),
   };
   const invariantBody = replaceUnverifiableSlot(invariant.body, invariantReplacement(evidence));
   const signalBody = signalSlot ? replaceUnverifiableSlot(signals.body, signalReplacement(evidence))

package/src/self-implement/host-regate.ts

@@ -14,6 +14,7 @@ import { pwaGraph, pwaReach } from '../../scripts/ci-pwa-build-gate.js';
 import { changedPathPairs, changedTsFiles, readGitFile, requiredExportFieldsInChanges } from '../../scripts/ci-typecheck-changed.js';
 import { classifyMergeFailure, clipRegateDetail, parseConflictFiles, type HostRegateFailure } from './regate-detail.js';
 import { buildImporterTestIndex, isTestPath } from './importer-test-index.js';
+import type { GateReceipt, GateReceiptIdentity } from './gate-receipt-registry.js';
 
 /** Use pr-land's PWA reachability (including its undecidable-graph build fallback), not a blanket src/** trigger. */
 export function needsPwaBuild(files: readonly string[], repoRoot: string, graph: (root: string) => ReturnType<typeof pwaGraph> = pwaGraph): boolean {
@@ -86,6 +87,10 @@ export type HostRegateDeps = {
   prodFreezeRoot?: string;
   runExposeGate?: typeof runExposeGate;
   syncMergedChecklist?: typeof import('../release-loop/merged-pr-checklist.js').syncMergedPrChecklist;
+  /** GATE-ONCE-PER-HEAD (OP 10-27 23:0x): persistent passed-receipt registry file. Default: <git-common-dir>/elanous-host-regate/gate-receipts.json. */
+  gateReceiptPath?: string;
+  /** Environment the receipt fingerprint reads; production uses the host process env. */
+  gateReceiptEnv?: NodeJS.ProcessEnv;
 };
 
 /**
@@ -308,6 +313,20 @@ function removeBrokenSlotRegistration(repoRoot: string, worktree: string): void
   }
 }
 
+/** GATE-ONCE-PER-HEAD: 생산 등록부는 host-regate 슬롯과 같은 Git common directory 에 산다. 못 찾으면 승계 없이 원래 검사로 연다. */
+function defaultGateReceiptPath(repoRoot: string, command: NonNullable<HostRegateDeps['command']>): string | undefined {
+  const r = command('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], repoRoot);
+  const dir = r.status === 0 ? r.stdout.trim() : '';
+  return dir ? join(dir, 'elanous-host-regate', 'gate-receipts.json') : undefined;
+}
+
+/** 영수증의 Bun 식별값 — 검사를 실제로 돌릴 그 Bun. 못 재면 null 로 승계를 닫는다(빈 값으로 흐리지 않는다). */
+function commandBunVersion(command: NonNullable<HostRegateDeps['command']>, cwd: string): string | null {
+  const r = command('bun', ['--version'], cwd);
+  const version = r.status === 0 ? r.stdout.trim() : '';
+  return version || null;
+}
+
 /** Callers: podSelfImplementSpawn in src/task-orchestrator/surfaces/self-implement-pod.ts calls
  *  (options.hostRegate ?? runHostRegate)({ prNumber, headCommit, repoRoot: hostRoot, ... });
  *  sweepFrozenMerges in frozen-merges.ts also calls runHostRegate(entry); landing queue serialization stays there. */
@@ -383,6 +402,7 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
     let stalePrBase: string | undefined;
     const initialPrBase = baseCommit;
     let buildPwa = false;
+    let typecheckBase = '';
     // REGATE-PWA-DEPS-FOR-TSC (#26698 → #27484 must-fix): the typecheck gate picks its own changed set and its own
     // whole-repository promotion triggers — TSC_BASE_REF..HEAD — which can carry apps/pwa files that landed on
     // main after this PR branched, and root-file export changes that widen the inspection to the whole repository.
@@ -494,54 +514,109 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
       // apps/pwa/ OR any of its whole-repository promotion triggers (필수 export 필드 추가 · exported 심볼 삭제 ·
       // exported 함수 매개변수 증가, in ANY changed file), even when buildPwa never turns on: without app deps
       // the gate fails such runs as «의존성 없음» for environment reasons, not code defects.
-      const typecheckBase = input.verifyOnly ? baseCommit : base;
+      typecheckBase = input.verifyOnly ? baseCommit : base;
       typecheckTouchesPwa = typecheckGateTouchesPwa(worktree, typecheckBase, command);
       if ((buildPwa || typecheckTouchesPwa) && existsSync(join(worktree, 'apps/pwa'))) provide('apps/pwa', 'next');
     } catch (e) { return result('unmeasured', 'worktree', String(e)); }
-    try {
-      const interferenceOptions = { neighbors: !input.verifyOnly };
-      const interference = await (deps.interference ?? ((f: readonly string[], c: string) => defaultInterference(f, c, interferenceOptions)))(files, worktree);
-      if (interference.neighborsTrimmed || interference.importerTrimmed) interferenceNote = {
-        ...(interference.neighborsTrimmed ? { neighborsTrimmed: interference.neighborsTrimmed } : {}),
-        ...(interference.importerTrimmed ? { importerTrimmed: interference.importerTrimmed } : {}),
-        interferenceDetail: (interference.detail ?? '').slice(0, 300),
-      };
-      if (!interference.passed) return result(interference.unmeasured ? 'unmeasured' : 'failed', 'test-interference', interference.detail);
-    } catch (e) { return result('unmeasured', 'test-interference', String(e)); }
-    // Landing can also be initiated by the host after the child gate; judge the checked PR here too.
-    if (publicExposureFiles(files).length > 0) {
-      const exposure = (deps.runExposeGate ?? runExposeGate)(worktree, files,
-        getUserConfig().harness?.exposeGate === 'strict' ? 'strict' : 'warn',
-        (bin, args, dir) => command(bin, args, dir));
-      if (!exposure.passed) return result('failed', 'expose', exposure.log);
-    }
-    // The checked checkout is shared with interference/exposure gates. Verify dependencies at the
-    // typecheck boundary as well: a missing PWA link here made #27414 fail as an unmeasured host regate.
-    if ((buildPwa || typecheckTouchesPwa) && !existsSync(join(worktree, 'apps/pwa/node_modules'))) {
-      let failure: string | null = null;
+    // GATE-ONCE-PER-HEAD (0.2.40 첫 조각 · OP 10-27 23:0x 지시): 입장 검사(PR open/ready·head/base 재검증)와
+    // 통합 후보 구성이 끝난 뒤, 지속 등록부에서 이 측정의 key 로 통과 영수증을 찾는다. 정확히 같은
+    // head·측정 base·Bun/lockfile·radius·검사 범위·환경의 통과 영수증만 아래 비용 큰 검사를 승계하고,
+    // 불일치·결손·불완전·실패/측정불가 영수증은 원래 검사를 그대로 실행한다 — 영수증이 커버하지 않는
+    // 검사는 승계하지 않는다. 등록부를 못 쓰는 경우도 검사 쪽으로 실패 열린다.
+    const gateReceiptPath = deps.gateReceiptPath ?? defaultGateReceiptPath(input.repoRoot, command);
+    // Gate receipt support is optional for this host path. Keep its registry and test-env helpers
+    // outside the Next TUI's static startup closure, loading them only when receipt lookup is enabled.
+    const gateReceiptRegistry = gateReceiptPath ? await import('./gate-receipt-registry.js') : null;
+    const gateChecks = [
+      `test-interference:${input.verifyOnly ? 'changed-only' : 'with-neighbours'}`,
+      ...(publicExposureFiles(files).length > 0 ? ['expose'] : []),
+      `typecheck@${typecheckBase}`,
+      ...((deps.command || existsSync(join(worktree, 'scripts/ci-isolation-hardcode-gate.ts'))) ? ['isolation-gate'] : []),
+      ...(buildPwa ? ['nexus-build'] : []),
+    ];
+    let gateReceiptIdentity: GateReceiptIdentity | undefined;
+    let gateReceiptKey = '';
+    let gateReceiptReused = false;
+    let gateReceiptDecline = 'gate receipt registry unavailable';
+    if (gateReceiptPath) {
       try {
-        if (existsSync(join(worktree, 'apps/pwa'))) {
-          provideCheckoutDependencies(worktree, input.repoRoot, 'apps/pwa', 'next', (cwd) => { run('bun', ['install', '--frozen-lockfile'], cwd); });
-        } else failure = 'apps/pwa absent before typecheck';
-      } catch (e) { failure = String(e); }
-      const ready = existsSync(join(worktree, 'apps/pwa/node_modules'));
-      if (!ready && !failure) failure = 'apps/pwa/node_modules absent after provision before typecheck';
-      try { debug.log('harness.host-regate', 'pwa-dependencies-before-typecheck', { pr: input.prNumber, restored: ready, failure }); } catch { /* observation must not block regate */ }
-      if (!ready) return result('unmeasured', 'dependencies', failure!);
-    }
-    // verifyOnly: 통합 후보는 «지금 main 끝»(baseCommit)에 얹은 것이다 — 옛 merge-base 로 비교하면 그사이 main 착지분
-    //   수백 파일이 «이 PR 의 변경»으로 잡혀 저장소 전체 검사로 승격된다(2026-09-28 #21239 실측: 456파일 · PWA 636건).
-    try { run('bun', ['scripts/ci-typecheck-changed.ts'], worktree, { ...process.env, TSC_BASE_REF: input.verifyOnly ? baseCommit : base }); }
-    catch (e) { return result(String(e).includes('error TS') ? 'failed' : 'unmeasured', 'typecheck', String(e)); }
-    // ⛔ 2026-09-28: a Pod landing brought `join(home, '.elanous', …)` into main without this gate, and every human
-    //    `pr land` after it failed the isolation gate regardless of its own files (#21336 → #21343).
-    if (deps.command || existsSync(join(worktree, 'scripts/ci-isolation-hardcode-gate.ts'))) {
-      try { run('bun', ['scripts/ci-isolation-hardcode-gate.ts', '--changed-files', ...files], worktree); }
-      catch (e) { return result(/\[isolation-gate\] FAIL/.test(String(e)) ? 'failed' : 'unmeasured', 'isolation-gate', String(e)); }
+        const bunVersion = commandBunVersion(command, worktree);
+        if (bunVersion === null) gateReceiptDecline = 'bun version unavailable';
+        else {
+          gateReceiptIdentity = {
+            headCommit: input.headCommit,
+            baseCommit,
+            bunVersion,
+            lockfileHash: gateReceiptRegistry!.gateLockfileHash(worktree),
+            radiusFiles: [...new Set(files)].sort(),
+            checks: gateChecks,
+            envFingerprint: gateReceiptRegistry!.gateEnvFingerprint(deps.gateReceiptEnv ?? process.env),
+          };
+          gateReceiptKey = gateReceiptRegistry!.computeReceiptKey(gateReceiptIdentity, 'passed');
+          const registry = gateReceiptRegistry!.loadGateReceipts(gateReceiptPath);
+          const stored = registry[gateReceiptKey];
+          if (stored && gateReceiptRegistry!.gateReceiptSelfKey(stored) === gateReceiptKey) gateReceiptReused = true;
+          else gateReceiptDecline = stored ? 'stored receipt does not recompute to its own key' : gateReceiptRegistry!.describeGateReceiptDecline(gateReceiptIdentity, registry);
+        }
+      } catch (e) { gateReceiptDecline = `gate receipt lookup failed: ${String(e).slice(0, 200)}`; }
     }
-    if (buildPwa) {
-      try { run('bun', ['bin/elanous.mjs', '--test', 'nexus', 'build'], worktree); }
-      catch (e) { return result(String(e).includes('command unavailable') ? 'unmeasured' : 'failed', 'nexus-build', String(e)); }
+    if (gateReceiptReused) debug.log('harness.host-regate', 'gate-receipt-reuse', { pr: input.prNumber, key: gateReceiptKey, checks: gateChecks });
+    else debug.log('harness.host-regate', 'gate-receipt-decline', { pr: input.prNumber, ...(gateReceiptKey ? { key: gateReceiptKey } : {}), reason: gateReceiptDecline });
+    if (!gateReceiptReused) {
+      try {
+        const interferenceOptions = { neighbors: !input.verifyOnly };
+        const interference = await (deps.interference ?? ((f: readonly string[], c: string) => defaultInterference(f, c, interferenceOptions)))(files, worktree);
+        if (interference.neighborsTrimmed || interference.importerTrimmed) interferenceNote = {
+          ...(interference.neighborsTrimmed ? { neighborsTrimmed: interference.neighborsTrimmed } : {}),
+          ...(interference.importerTrimmed ? { importerTrimmed: interference.importerTrimmed } : {}),
+          interferenceDetail: (interference.detail ?? '').slice(0, 300),
+        };
+        if (!interference.passed) return result(interference.unmeasured ? 'unmeasured' : 'failed', 'test-interference', interference.detail);
+      } catch (e) { return result('unmeasured', 'test-interference', String(e)); }
+      // Landing can also be initiated by the host after the child gate; judge the checked PR here too.
+      if (publicExposureFiles(files).length > 0) {
+        const exposure = (deps.runExposeGate ?? runExposeGate)(worktree, files,
+          getUserConfig().harness?.exposeGate === 'strict' ? 'strict' : 'warn',
+          (bin, args, dir) => command(bin, args, dir));
+        if (!exposure.passed) return result('failed', 'expose', exposure.log);
+      }
+      // The checked checkout is shared with interference/exposure gates. Verify dependencies at the
+      // typecheck boundary as well: a missing PWA link here made #27414 fail as an unmeasured host regate.
+      if ((buildPwa || typecheckTouchesPwa) && !existsSync(join(worktree, 'apps/pwa/node_modules'))) {
+        let failure: string | null = null;
+        try {
+          if (existsSync(join(worktree, 'apps/pwa'))) {
+            provideCheckoutDependencies(worktree, input.repoRoot, 'apps/pwa', 'next', (cwd) => { run('bun', ['install', '--frozen-lockfile'], cwd); });
+          } else failure = 'apps/pwa absent before typecheck';
+        } catch (e) { failure = String(e); }
+        const ready = existsSync(join(worktree, 'apps/pwa/node_modules'));
+        if (!ready && !failure) failure = 'apps/pwa/node_modules absent after provision before typecheck';
+        try { debug.log('harness.host-regate', 'pwa-dependencies-before-typecheck', { pr: input.prNumber, restored: ready, failure }); } catch { /* observation must not block regate */ }
+        if (!ready) return result('unmeasured', 'dependencies', failure!);
+      }
+      // verifyOnly: 통합 후보는 «지금 main 끝»(baseCommit)에 얹은 것이다 — 옛 merge-base 로 비교하면 그사이 main 착지분
+      //   수백 파일이 «이 PR 의 변경»으로 잡혀 저장소 전체 검사로 승격된다(2026-09-28 #21239 실측: 456파일 · PWA 636건).
+      try { run('bun', ['scripts/ci-typecheck-changed.ts'], worktree, { ...process.env, TSC_BASE_REF: typecheckBase }); }
+      catch (e) { return result(String(e).includes('error TS') ? 'failed' : 'unmeasured', 'typecheck', String(e)); }
+      // ⛔ 2026-09-28: a Pod landing brought `join(home, '.elanous', …)` into main without this gate, and every human
+      //    `pr land` after it failed the isolation gate regardless of its own files (#21336 → #21343).
+      if (deps.command || existsSync(join(worktree, 'scripts/ci-isolation-hardcode-gate.ts'))) {
+        try { run('bun', ['scripts/ci-isolation-hardcode-gate.ts', '--changed-files', ...files], worktree); }
+        catch (e) { return result(/\[isolation-gate\] FAIL/.test(String(e)) ? 'failed' : 'unmeasured', 'isolation-gate', String(e)); }
+      }
+      if (buildPwa) {
+        try { run('bun', ['bin/elanous.mjs', '--test', 'nexus', 'build'], worktree); }
+        catch (e) { return result(String(e).includes('command unavailable') ? 'unmeasured' : 'failed', 'nexus-build', String(e)); }
+      }
+      // 원래 검사가 모두 통과했다 — 이 측정의 통과 영수증을 지속 등록부에 원자적으로 남긴다.
+      // 저장 실패는 영수증 최적화의 실패일 뿐 게이트 판정이 아니므로 관측만 남긴다.
+      if (gateReceiptPath && gateReceiptIdentity && gateReceiptRegistry) {
+        try {
+          const receipt: GateReceipt = { ...gateReceiptIdentity, schema: gateReceiptRegistry.GATE_RECEIPT_SCHEMA, key: gateReceiptRegistry.computeReceiptKey(gateReceiptIdentity, 'passed'), verdict: 'passed', savedAt: new Date().toISOString() };
+          gateReceiptRegistry.saveGateReceipt(gateReceiptPath, receipt);
+          debug.log('harness.host-regate', 'gate-receipt-saved', { pr: input.prNumber, key: receipt.key, checks: gateChecks });
+        } catch (e) { debug.log('harness.host-regate', 'gate-receipt-save-failed', { pr: input.prNumber, error: String(e).slice(0, 200) }); }
+      }
     }
     let current: PrView;
     try { current = readPr(); }
@@ -576,8 +651,8 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
     if (merged.state !== 'MERGED') return result('unmeasured', 'merge-confirm', `PR state after merge is ${merged.state ?? 'unknown'}`);
     landed = true;
     try {
-      const sync = deps.syncMergedChecklist ?? (await import('../release-loop/merged-pr-checklist.js')).syncMergedPrChecklist;
-      sync(input.prNumber, input.repoRoot, input.goalFile);
+      const sync = deps.syncMergedChecklist ?? (await import('../release-loop/merged-pr-checklist.js')).syncMergedPrChecklistWithFeedback;
+      await sync(input.prNumber, input.repoRoot, input.goalFile);
     } catch (error) {
       debug.log('release.checklist', 'merged-pr-sync-failed', { pr: input.prNumber, error: String(error) });
     }

package/src/self-implement/impl-findings-feedback.ts

@@ -0,0 +1,188 @@
+/**
+ * IMPL-FINDINGS-FEEDBACK — 병합 PR 본문의 «구현이 밝힌 요구사항»·«새 범위»·«남은 것» 절을
+ * idempotent 원장(`appendRunLedgerEntryChecked`)에 1회 기록하고, 관련 기록만 다음 저작
+ * (goal-author) 입력에 주입하며, 남은 것에서 후속 초안을 만든다(자동 발사 없음 — shadow 기본).
+ *
+ * 절 파싱은 `markdownSection`(goal-author)과 `remainingPiecesFromPrBody`(follow-up-goals)을
+ * 재사용하고, 관련 교훈 선택은 `selectRelevantAuthoringLessons`(knowhow-pack)을 재사용한다.
+ * 모든 관측은 `self-implement.impl-findings-feedback` 범주로 `debug.log` 에 남는다.
+ */
+import { debug } from '../debug/log.js';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { markdownSection } from './goal-author.js';
+import { selectRelevantAuthoringLessons, type SelectedAuthoringLessons } from './knowhow-pack.js';
+import { appendRunLedgerEntryChecked, type RunLedgerCheckedAppendDecision, type RunLedgerEntry } from './run-ledger.js';
+import { recordFollowUpOnMerge, remainingPiecesFromPrBody, type FollowUpDraftRecord, type FollowUpMergeInput, type FollowUpSeams } from './follow-up-goals.js';
+
+/** 원장 이벤트 이름 — 같은 PR 의 되먹임 기록은 이 이벤트로 정확히 한 번만 남는다. */
+export const IMPL_FINDINGS_LEDGER_EVENT = 'impl-findings-feedback';
+export const IMPL_FINDINGS_REQUIREMENTS_SECTION = '구현이 밝힌 요구사항';
+export const IMPL_FINDINGS_NEW_SCOPE_SECTION = '새 범위';
+export const IMPL_FINDINGS_REMAINING_SECTION = '남은 것';
+
+/** 병합 PR 본문에서 파싱한 세 절. */
+export interface ImplFindings {
+  /** «구현이 밝힌 요구사항» 절 본문(verbatim trim). */
+  requirements: string;
+  /** «새 범위» 절 본문(verbatim trim). */
+  newScope: string;
+  /** «남은 것» 절(⊕ follow-up-goals 의 «남은 조각» 절)의 항목 — 순서 보존·중복 제거. */
+  remaining: string[];
+}
+
+function sectionBullets(body: string): string[] {
+  return body
+    .split(/\r?\n/)
+    .map((line) => line.match(/^\s*[-*]\s+(.+?)\s*$/)?.[1] ?? '')
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+/** 병합 PR 본문의 세 절을 exact-trimmed `## ` 제목으로 파싱한다 — 펜스 안 본문은 건너뛴다. */
+export function parseImplFindings(prBody: string): ImplFindings {
+  const requirements = (markdownSection(prBody, IMPL_FINDINGS_REQUIREMENTS_SECTION) ?? '').trim();
+  const newScope = (markdownSection(prBody, IMPL_FINDINGS_NEW_SCOPE_SECTION) ?? '').trim();
+  const remainingSection = (markdownSection(prBody, IMPL_FINDINGS_REMAINING_SECTION) ?? '');
+  const remaining = [...sectionBullets(remainingSection), ...remainingPiecesFromPrBody(prBody)]
+    .map((item) => item.trim())
+    .filter(Boolean);
+  return { requirements, newScope, remaining: [...new Set(remaining)] };
+}
+
+export interface ImplFindingsFeedbackInput {
+  runId: string;
+  prNumber: number;
+  /** 병합 PR 본문 원문 — 세 절을 여기서 파싱한다. */
+  prBody: string;
+  /** 다음 저작 입력의 원문 ask — 관련 교훈 선택의 경로 힌트로 쓴다. */
+  ask: string;
+  goalId?: string;
+}
+
+export type ImplFindingsLog = (category: string, event: string, data?: unknown) => void;
+
+export interface ImplFindingsFeedbackSeams {
+  /** 원장 디렉터리 — 생략하면 정본 run ledger dir. */
+  dir?: string;
+  log?: ImplFindingsLog;
+  /** 관련 교훈 선택 심 — 생략하면 정본 `selectRelevantAuthoringLessons`. */
+  selectLessons?: (root: string, ask: string) => SelectedAuthoringLessons;
+  /** 후속 초안 기록 심 — 생략하면 정본 `recordFollowUpOnMerge`(shadow 기본, 자동 발사 없음). */
+  followUp?: (input: FollowUpMergeInput, seams?: FollowUpSeams) => Promise<FollowUpDraftRecord | null>;
+}
+
+export interface ImplFindingsFeedbackResult {
+  findings: ImplFindings;
+  /** 이 호출로 원장에 새 기록을 남겼는가 — 같은 PR 재주입이면 false(중복 억제). */
+  appended: boolean;
+  refusal: 'ledger-write-refused' | null;
+  /** 다음 저작(goal-author `authoringLessons`) 입력에 싣는 프롬프트 — 관련 기록만 담는다. */
+  authoringInjection: string;
+  lessonIds: readonly string[];
+  /** 주입한 절 이름(비어 있지 않은 것만). */
+  injectedSections: readonly string[];
+  /** 생략한 절 이름(비어 있어 주입하지 않은 것). */
+  skippedSections: readonly string[];
+  /** 후속 초안 기록 — 자동 발사는 하지 않는다(`queued:false`). */
+  followUp: FollowUpDraftRecord | null;
+}
+
+/**
+ * 병합 PR 착지(postland) 때 구현이 밝힌 절을 되먹임한다:
+ * ① 세 절을 idempotent 원장에 1회 기록(같은 PR 재주입은 중복 억제),
+ * ② 비어 있지 않은 절(관련 기록)만 다음 저작 입력 프롬프트에 주입하고 선택·생략 수를 로그에 남긴다,
+ * ③ 남은 것에서 후속 초안을 만든다 — 자동 발사는 하지 않는다(`recordFollowUpOnMerge` shadow 기본).
+ */
+export async function recordImplFindingsFeedback(
+  input: ImplFindingsFeedbackInput,
+  seams: ImplFindingsFeedbackSeams = {},
+): Promise<ImplFindingsFeedbackResult> {
+  const log = seams.log ?? ((category, event, data) => { debug.log(category, event, data); });
+  const findings = parseImplFindings(input.prBody);
+
+  // ① idempotent 원장 1회 기록 — 같은 PR 번호의 되먹임 기록이 이미 있으면 append 하지 않는다.
+  const decide = (entries: RunLedgerEntry[] | null): RunLedgerCheckedAppendDecision<'duplicate'> => {
+    const duplicate = (entries ?? []).some((entry) => entry.event === IMPL_FINDINGS_LEDGER_EVENT
+      && entry.data.prNumber === input.prNumber);
+    if (duplicate) return { append: false, result: 'duplicate' as const };
+    return {
+      append: true,
+      entry: {
+        timestamp: new Date().toISOString(),
+        runId: input.runId,
+        event: IMPL_FINDINGS_LEDGER_EVENT,
+        data: {
+          prNumber: input.prNumber,
+          paths: [...new Set(input.ask.match(/(?<![\w./~-])([\w.-]+(?:\/[\w.-]+)+\.[\w-]+)/gu)?.map((match) => match.replace(/[.,;:!?]+$/u, '')) ?? [])],
+          requirements: findings.requirements,
+          newScope: findings.newScope,
+          remaining: findings.remaining,
+        },
+        ...(input.goalId ? { goalId: input.goalId } : {}),
+      },
+    };
+  };
+  const outcome = appendRunLedgerEntryChecked(input.runId, decide, seams.dir);
+  log('self-implement.impl-findings-feedback', outcome.refusal ? 'ledger-write-refused' : outcome.appended ? 'recorded' : 'duplicate-suppressed', {
+    prNumber: input.prNumber,
+    appended: outcome.appended,
+    remainingCount: findings.remaining.length,
+  });
+
+  // ② 관련 기록만 다음 저작 입력에 주입 — 비어 있지 않은 절 ⊕ 관련 교훈 프롬프트.
+  const injectedSections: string[] = [];
+  const skippedSections: string[] = [];
+  const sectionTexts: string[] = [];
+  const sections: readonly (readonly [string, string])[] = [
+    [IMPL_FINDINGS_REQUIREMENTS_SECTION, findings.requirements],
+    [IMPL_FINDINGS_NEW_SCOPE_SECTION, findings.newScope],
+  ];
+  for (const [name, text] of sections) {
+    if (!text) { skippedSections.push(name); continue; }
+    injectedSections.push(name);
+    sectionTexts.push(`### ${name}\n${text}`);
+  }
+  const lessons = (seams.selectLessons ?? selectRelevantAuthoringLessons)(process.cwd(), input.ask, elanousStateRoot());
+  const authoringInjection = [
+    `## 구현이 밝힌 요구사항·새 범위(착지 PR #${input.prNumber})`,
+    ...sectionTexts,
+    ...(lessons.prompt ? [lessons.prompt] : []),
+  ].join('\n\n');
+  log('self-implement.impl-findings-feedback', 'authoring-injection', {
+    prNumber: input.prNumber,
+    injectedSections,
+    skippedSections,
+    selected: lessons.ids.length,
+    status: lessons.status,
+    invalidRows: lessons.invalidRows,
+    lessonIds: lessons.ids,
+  });
+
+  // ③ 남은 것에서 후속 초안 — 자동 발사 없음(shadow 기본, `queued:false`).
+  const followUpInput = {
+    prNumber: input.prNumber,
+    prBody: input.prBody,
+    feature: input.ask,
+    followUpMustFix: findings.remaining,
+    ...(input.goalId ? { cellId: input.goalId } : {}),
+  };
+  const followUp = await (seams.followUp
+    ? seams.followUp(followUpInput)
+    : recordFollowUpOnMerge(followUpInput, { mode: 'shadow' }));
+  log('self-implement.impl-findings-feedback', followUp ? 'follow-up-drafted' : 'follow-up-none', {
+    prNumber: input.prNumber,
+    remainingCount: findings.remaining.length,
+    queued: followUp?.queued ?? null,
+  });
+
+  return {
+    findings,
+    appended: outcome.appended,
+    refusal: outcome.refusal,
+    authoringInjection,
+    lessonIds: lessons.ids,
+    injectedSections,
+    skippedSections,
+    followUp,
+  };
+}