elanous 0.2.38 → 0.2.40

package/src/self-implement/goal-author-decompose.ts

@@ -471,6 +471,7 @@ export function createGoalAuthorDecomposeSteps(
   config: {
     adversarialReview?: boolean;
     adversarialReviewSource?: 'cli' | 'default' | 'unknown';
+    goalId?: string;
     recentStepCounts?: readonly number[];
     onSizedSlices?: (slices: SizedSlice[], redecomposed: number) => void;
     repositoryRoot?: string;
@@ -589,38 +590,46 @@ export function createGoalAuthorDecomposeSteps(
         return parsed ? { sizes: parsed, sizeSource: 'planner-estimate' as const }
           : { sizes: deriveGoalSliceSizes(slices), sizeSource: 'derived' as const };
       };
-      const observe = (event: 'slice-sized' | 'slice-oversize', sizeSource: 'planner-estimate' | 'derived', data: Record<string, unknown>) => {
+      const observe = (event: 'slice-sized' | 'slice-oversize' | 'resplit' | 'slice-oversize-unavoidable', sizeSource: 'planner-estimate' | 'derived', data: Record<string, unknown>) => {
         try { debug.log('goal-author.decompose', event, { surface: 'goal-author', sizeSource, ...data,
           ...(options?.runId === undefined ? {} : { runId: options.runId }) }); } catch { /* observation is fail-soft */ }
       };
       let redecomposed = 0;
       let measured = await measure(candidate);
       let sizes = measured.sizes;
-      if (sizes) observe('slice-sized', measured.sizeSource, { retry: 0, slices: sizes });
-      const oversized = sizes?.flatMap((size, index) => size.tier === 'high' ? [index] : []) ?? [];
-      if (oversized.length || !sizes) {
-        observe('slice-oversize', measured.sizeSource, { retry: 0, indexes: oversized,
+      for (let retry = 0; ; retry++) {
+        if (sizes) observe('slice-sized', measured.sizeSource, { retry, slices: sizes });
+        const oversized = sizes?.flatMap((size, index) => size.tier === 'high' ? [index] : []) ?? [];
+        if (sizes && oversized.length === 0) break;
+        observe('slice-oversize', measured.sizeSource, { retry, indexes: oversized,
           reasons: sizes ? oversized.map((index) => sizes![index]!.unavoidableReason) : [],
           ...(sizes ? {} : { error: 'size metadata missing or inconsistent' }) });
+        if (retry === 2) {
+          if (!sizes) throw new Error('goal-author slice sizing: size metadata missing after 2 resplits');
+          const unavoidableReason = 'auto';
+          for (const index of oversized) sizes[index] = { ...sizes[index]!,
+            unavoidableReason: sizes[index]!.unavoidableReason ?? unavoidableReason };
+          observe('slice-oversize-unavoidable', measured.sizeSource, {
+            goalId: options?.goalId ?? config.goalId ?? null,
+            resplitCount: redecomposed,
+            slices: oversized.map((index) => ({ index, ...sizes![index]! })),
+          });
+          break;
+        }
+        observe('resplit', measured.sizeSource, { retry: retry + 1, indexes: oversized,
+          ...(sizes ? {} : { reason: 'size metadata missing or inconsistent' }) });
         const retryAsk = [objective, '', 'The previous goal-author proposal had missing size metadata or oversized slices.',
           `PREVIOUS_STEPS_JSON: ${JSON.stringify(candidate)}`,
           `OVERSIZED_INDEXES_JSON: ${JSON.stringify(oversized)}`,
-          'Regenerate the full plan once. Preserve fitting slices and split each oversized slice into dependent low/medium slices where possible.',
-          'If an oversized slice truly cannot split, leave it high and state a concrete unavoidable reason.'].join('\n');
+          `RESPLIT_ATTEMPT: ${retry + 1} of 2. Regenerate the full plan; preserve fitting slices and split every oversized slice into dependent low/medium slices. If any oversized slice remains after the second resplit, keep it as high tier; a concrete unavoidable reason is optional because the system marks it unavoidable=auto.`].join('\n');
         const regenerated = await decompose(retryAsk);
         if (!regenerated.length) throw new Error('goal-author slice sizing: regeneration produced no slices');
-        redecomposed = 1;
+        redecomposed++;
         candidate = ensureDeviceFirstSteps(objective, regenerated, config.repositoryRoot).steps;
         rationale = decompositionRationale;
         measured = await measure(candidate);
         sizes = measured.sizes;
-        if (!sizes) throw new Error('goal-author slice sizing: size metadata missing after one retry');
-        observe('slice-sized', measured.sizeSource, { retry: 1, slices: sizes });
-        const remaining = sizes.flatMap((size, index) => size.tier === 'high' ? [index] : []);
-        if (remaining.length) observe('slice-oversize', measured.sizeSource, { retry: 1, indexes: remaining,
-          reasons: remaining.map((index) => sizes![index]!.unavoidableReason) });
-        if (remaining.some((index) => !sizes![index]!.unavoidableReason))
-          throw new Error('goal-author slice sizing: high slice lacks unavoidable reason after one retry');
+        if (!sizes && retry === 1) throw new Error('goal-author slice sizing: size metadata missing after 2 resplits');
       }
       config.onSizedSlices?.(restoreSlicePaths(publicSizedSlices(candidate, sizes), objective), redecomposed);
       return finalize(candidate, rationale);

package/src/self-implement/goal-author.ts

@@ -39,7 +39,7 @@ export function resolveGoalAuthorGrade(flag?: GoalAuthorGrade, configured?: unkn
 import type { ObserveOnlySource } from './observe-only.js';
 import type { Question } from '../ask-user-question/types.js';
 import { requestTestScenario as defaultRequestTestScenario, type TestScenarioRequestInput, type TestScenarioRequestResult } from './test-scenario-request.js';
-import { resolveGoalAuthorClarification, parseGoalDocumentClarifications, serializeGoalAuthorParent, type GoalAuthorClarificationResponse, type GoalAuthorParent, type GoalAuthorSelfResolution } from './goal-author-clarification.js';
+import { defaultGoalAuthorSelfResolve, resolveGoalAuthorClarification, parseGoalDocumentClarifications, serializeGoalAuthorParent, type GoalAuthorClarificationResponse, type GoalAuthorParent, type GoalAuthorSelfResolution } from './goal-author-clarification.js';
 import { acquireLockSync } from '../storage/file-lock.js';
 import { createRepositoryReferencedFileReader, type ReferencedFileReadResult } from './goal-file-reader.js';
 import { extractGoalDocSections, type GoalDocSourceLine } from './goal-doc/section.js';
@@ -59,6 +59,7 @@ import { declaredNewFilePaths } from './goal-new-paths.js';
 import { classifyGoalCommandExecution, type GoalCommandExecutionResult } from './goal-command-execution.js';
 import { identityLines, repositoryIdentifiers } from './goal-author-identity.js';
 import { selectRelevantAuthoringLessons } from './knowhow-pack.js';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
 export { selectRelevantAuthoringLessons } from './knowhow-pack.js';
 export { formatSubmittedAt } from './goal-author-identity.js';
 import { hasUnmetRequirementOutsidePreservationClause } from './goal-author-preservation-obligation.js';
@@ -116,7 +117,7 @@ export interface GoalAuthorDeps {
   /** Optional externally decomposed plan steps rendered verbatim into the authored goal; the author never generates them. */
   steps?: readonly string[];
   /** Optional injected decomposition seam; omitted means authoring never invokes an LLM or decomposition. */
-  decomposeSteps?: (objective: string, opts?: { context?: string; runId?: string }) => Promise<readonly string[]>;
+  decomposeSteps?: (objective: string, opts?: { context?: string; runId?: string; goalId?: string }) => Promise<readonly string[]>;
   /** Optional launch preflight result supplied by the caller; authoring never reads the ledger or logs itself. */
   launchPreflight?: LaunchPreflightResult;
   /** Optional in-process notification for each authored-goal phase transition. */
@@ -3907,6 +3908,8 @@ function renderClarification(
     `  - includeOther: ${question.includeOther !== false}`,
     `  - answer: ${answerValue}`,
     ...(provenance ? [`  - provenance.source: ${provenance.source}`] : []),
+    ...(provenance?.assumption ? [`  - provenance.assumption: ${renderClarificationValue(provenance.assumption)}`] : []),
+    ...(provenance?.assumptionSource ? [`  - provenance.assumption-source: ${provenance.assumptionSource}`] : []),
     ...(provenance?.evidence ?? []).map((evidence) => `  - evidence: ${renderClarificationValue(evidence)}`),
   ];
 }
@@ -6031,6 +6034,7 @@ async function authorGoalWithSupersededRootIntent(
     throw new Error('legacy parent document has no RootIntent; rootIntent is required');
   }
   const rootIntent = validateRootIntent(supersessionRootIntent ?? inheritedRootIntent ?? requestedRootIntent ?? goalSummary(enhancement.original));
+  const assignedGoalId = deps.goalId ?? generateGoalId();
   let resolvedSteps = deps.steps;
   if (resolvedSteps === undefined && goalType === 'implement' && deps.decomposeSteps) {
     const startedAt = Date.now();
@@ -6041,7 +6045,7 @@ async function authorGoalWithSupersededRootIntent(
         ? [device.exists ? `existing: ${device.device}` : `missing: ${device.device}`] : undefined;
       const context = [facts?.context, deviceInventory?.length ? `Device inventory (measured at goal-author repository root): ${deviceInventory.join(', ')}` : undefined]
         .filter(Boolean).join('\n') || undefined;
-      const decomposed = await deps.decomposeSteps(ask, { context, runId: process.env.ELANOUS_RUN_ID?.trim() || authorRunId });
+      const decomposed = await deps.decomposeSteps(ask, { context, runId: process.env.ELANOUS_RUN_ID?.trim() || authorRunId, goalId: assignedGoalId });
       if (decomposed.length > 0) resolvedSteps = decomposed;
     } catch {
       failed = true;
@@ -6270,7 +6274,6 @@ async function authorGoalWithSupersededRootIntent(
   //   ⚠️⭐ 계약 — 이 줄은 조립·린트가 «끝나기 전»에 난다(goalId 가 여기서 정해지므로 더 늦출 수 없다).
   //      ⇒ 저작이 그 «뒤»에 실패하면 이 조인 행만 남는다(dangling). 그러므로 ***집계는 「착지한 골」과의
   //      inner join 으로만 한다*** — 이 행 자체를 「골이 하나 생겼다」로 세면 «실패분까지» 센다(무인 리뷰 지적).
-  const assignedGoalId = deps.goalId ?? generateGoalId();
   const askFile = deps.askFile === undefined ? undefined : validateAskFile(deps.askFile);
   try { observeGoalAuthor('goal-author', 'goal-id-assigned', { authorRunId, goalId: assignedGoalId, superseded: Boolean(deps.goalId) }); }
   catch { /* 관측은 fail-soft */ }
@@ -6565,6 +6568,7 @@ export function defaultGoalAuthorDeps(cwd: string): GoalAuthorDeps {
     },
     readSourceFile: createRepositoryReferencedFileReader(cwd),
     runHelpProbe: (argv) => runDefaultHelpProbe(cwd, argv),
+    selfResolveClarification: defaultGoalAuthorSelfResolve,
   };
 }
 
@@ -6613,7 +6617,7 @@ export async function writeAuthoredGoal(
     repositoryRoot: deps.repositoryRoot ?? groundingRoot,
   };
   const mandatoryGoalContextEvidence = goalContextEvidence(cwd);
-  const authoringLessons = selectRelevantAuthoringLessons(cwd, ask);
+  const authoringLessons = selectRelevantAuthoringLessons(cwd, ask, elanousStateRoot());
   observeGoalAuthor('goal-author', 'authoring-lessons', {
     status: authoringLessons.status,
     invalidRows: authoringLessons.invalidRows,

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,
+  };
+}