elanous 0.2.21 → 0.2.23

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

@@ -3,7 +3,7 @@ import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSy
 import { spawn } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
 import { dirname, isAbsolute, join, normalize, relative, resolve, sep } from 'node:path';
-import { groundMissionInCodebase, isRepositoryImplementationCandidate, type CodebaseGrounding } from '../autopilot/mission-codebase-gate.js';
+import { isRepositoryImplementationCandidate, type CodebaseGrounding } from '../autopilot/codebase-grounding.js';
 import { extractSlugSource, generateMissionSlug, slugify } from '../autopilot/mission-registry.js';
 import { enhancePrompt, type EnhanceOpts, type EnhanceResult } from '../prompt-enhance/enhance.js';
 import type { LLMUsage } from '../prompt-cache/types.js';
@@ -44,7 +44,7 @@ import { extractGoalDocSections, type GoalDocSourceLine } from './goal-doc/secti
 import { isGoalAuthorFileName } from './goal-document.js';
 import { resolveGoalDocumentsDir } from './goal-documents-dir.js';
 import { REQUIRED_EVIDENCE_COMMAND_SEPARATOR } from './off-diff-evidence.js';
-import { renderLaunchPreflight, siblingTestPath, type LaunchPreflightResult } from '../self-dev/launch-preflight.js';
+import { renderLaunchPreflight, siblingTestPath, type LaunchPreflightResult } from '../self-dev/launch-preflight-text.js';
 import { quoteShellArg } from '../cli/logs-cli.js';
 import type { HarnessGroundingProvenance } from './context-capsule.js';
 import { hasGoalStepCodeName } from './goal-step-code-name.js';
@@ -121,6 +121,21 @@ export interface GoalAuthorGroundingResult {
   facts: CodebaseGrounding;
 }
 
+// A function-local slot is initialized only on access, after cyclic ESM evaluation has finished.
+function goalAuthorGroundMissionSlot(): { fn?: NonNullable<GoalAuthorGroundingDeps['groundMission']> } {
+  const key = Symbol.for('elanous.goalAuthor.groundMission');
+  const registry = globalThis as typeof globalThis & { [key: symbol]: { fn?: NonNullable<GoalAuthorGroundingDeps['groundMission']> } };
+  return registry[key] ??= {};
+}
+
+export function registerGoalAuthorGroundMission(fn: NonNullable<GoalAuthorGroundingDeps['groundMission']> | undefined): void {
+  goalAuthorGroundMissionSlot().fn = fn;
+}
+
+export function hasGoalAuthorGroundMission(): boolean {
+  return goalAuthorGroundMissionSlot().fn !== undefined;
+}
+
 export interface GoalAuthorPersistentGroundingDecision {
   readonly enabled: boolean;
   readonly source: ObserveOnlySource;
@@ -5583,12 +5598,17 @@ export async function groundForGoalAuthor(
   cwd: string,
   deps: GoalAuthorGroundingDeps = {},
 ): Promise<GoalAuthorGroundingResult> {
+  const groundMission = deps.groundMission ?? goalAuthorGroundMissionSlot().fn;
+  if (!groundMission) {
+    debug.log('goal-author.grounding', 'route-unregistered', { cwd });
+    throw new Error('route-unregistered: mission-codebase-gate 를 로드하라');
+  }
   return {
     path: 'groundMissionInCodebase',
     // ⛔⭐ 사람이 ask 에 «이름을 댄» 경로를 접지에 «넘긴다» — 접지가 그것을 후보로 쓴다.
     //   ⛔ 추출기를 «새로 만들지 않는다» — 이 파일이 이미 갖고 있는 askPathTokens 하나를 쓴다
     //     (2026-08-11 72차: 같은 것에 두 이름을 준 병을 하루에 여섯 번 셌다).
-    facts: await (deps.groundMission ?? groundMissionInCodebase)(ask, {
+    facts: await groundMission(ask, {
       cwd,
       seedPaths: askPathTokens(ask),
       ...(deps.persistent !== undefined ? { persistent: deps.persistent } : {}),
@@ -5694,7 +5714,7 @@ export function defaultGoalAuthorDeps(cwd: string): GoalAuthorDeps {
      *   이 칸을 «안 주므로» 기본값 `coverage-gate` 로 종전 문면을 그대로 받는다.
      */
     enhance(ask, opts) {
-      return enhancePrompt(ask, { ...opts, checklistUse: 'authoring' });
+      return enhancePrompt(ask, { ...opts, checklistUse: 'authoring', config: opts?.config ?? getUserConfig() });
     },
     readSourceFile: createRepositoryReferencedFileReader(cwd),
     runHelpProbe: (argv) => runDefaultHelpProbe(cwd, argv),

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

@@ -89,6 +89,25 @@ function scaled(limit: number): { reserved: number; minSection: number } {
   return { reserved: Math.floor(RESERVED_FOR_NOTICE * k), minSection: Math.max(40, Math.floor(MIN_SECTION_CHARS * k)) };
 }
 
+/** 골 문서에서 `판정 신호` 절만 뽑아 리뷰 acceptance 로 쓴다. 계보 = self-implement seams. */
+export function extractHarnessReviewAcceptance(goalDocument: string | undefined): { goal: string | undefined; acceptance: string | undefined } {
+  let goal: string | undefined;
+  try {
+    goal = goalDocument?.trim() || undefined;
+  } catch {
+    return { goal: undefined, acceptance: undefined };
+  }
+  if (!goal) return { goal: undefined, acceptance: undefined };
+  try {
+    const acceptance = splitGoalSections(supervisorGoalDigest(goal, 3000).text)
+      .find((section) => isSupervisorDecisionSection(section.title) && section.title.includes('판정 신호'))
+      ?.body.trim() || undefined;
+    return { goal, acceptance };
+  } catch {
+    return { goal, acceptance: undefined };
+  }
+}
+
 /** `## <제목>` 기준으로 절을 가른다. 헤더 앞 서두는 제목 `''` 로 담는다. */
 export function splitGoalSections(goal: string): Section[] {
   return extractGoalDocSections(goal, {

package/src/self-implement/graph-overlay-condition.ts

@@ -53,6 +53,10 @@ export function evaluateOverlayCondition(
   const { key, operator, literal } = parsed.condition;
   if (!(key in state)) return { kind: 'key-absent', key };
   const actual = state[key];
+  if (actual === undefined || actual === null) return { kind: 'key-absent', key };
+  // Measured boolean branch keys accept only a real boolean observation — any textual lookalike
+  // ('true', 'TRUE', 'yes', 1) is unknown, whatever the literal spelling in the condition.
+  if ((key === 'sibling_overlap' || key === 'main_sync_conflict') && typeof actual !== 'boolean') return { kind: 'key-absent', key };
 
   if (typeof literal === 'number') {
     // ⛔ 수 비교인데 값이 수가 아니면 「비교 불가」다 — 거짓으로 접지 않는다.

package/src/self-implement/harness-policy-gates.ts

@@ -5,16 +5,17 @@ import { runMockModuleRestoreGate } from '../../scripts/ci-mock-module-restore-g
 import { runModelHardcodeGate } from '../../scripts/ci-model-hardcode-gate.js';
 import { runDaemonPortGate } from '../../scripts/ci-daemon-port-gate.js';
 import { runPublicExportLeakGate } from '../../scripts/ci-public-export-leak-gate.js';
+import { runPublicExportImportGate } from '../../scripts/ci-public-export-import-gate.js';
 
-type GateName = 'isolation-gate' | 'mock-module-restore-gate' | 'model-hardcode-gate' | 'daemon-port-gate' | 'public-export-leak';
+type GateName = 'isolation-gate' | 'mock-module-restore-gate' | 'model-hardcode-gate' | 'daemon-port-gate' | 'public-export-leak' | 'public-export-import';
 type GateOutput = { args: string[]; cwd: string; log: (line: string) => void; error: (line: string) => void };
-type GateRunner = (out: GateOutput) => number;
+type GateRunner = (out: GateOutput) => number | Promise<number>;
 
-export function runHarnessPolicyGates(input: {
+export async function runHarnessPolicyGates(input: {
   cwd: string;
   changedFiles: readonly string[];
   gates?: Partial<Record<GateName, GateRunner>>;
-}): { passed: boolean; failures: Array<{ gate: GateName; lines: string[] }>; skipped?: string } {
+}): Promise<{ passed: boolean; failures: Array<{ gate: GateName; lines: string[] }>; skipped?: string }> {
   try {
     if (!statSync(join(input.cwd, 'scripts')).isDirectory()) {
       return { passed: true, failures: [], skipped: 'no-scripts' };
@@ -30,12 +31,13 @@ export function runHarnessPolicyGates(input: {
     ['daemon-port-gate', input.gates?.['daemon-port-gate'] ?? ((out) => runDaemonPortGate({ log: out.log, error: out.error, cwd: out.cwd, args: [] }))],
     // LEAK1 — the same pre-export check as pr land; an unmeasured result is a nonzero failure, not a pass.
     ['public-export-leak', input.gates?.['public-export-leak'] ?? runPublicExportLeakGate],
+    ['public-export-import', input.gates?.['public-export-import'] ?? runPublicExportImportGate],
   ];
   const failures: Array<{ gate: GateName; lines: string[] }> = [];
   for (const [gate, run] of runners) {
     const lines: string[] = [];
     try {
-      const status = run({ cwd: input.cwd, args: ['--changed-files', ...input.changedFiles], log: (line) => lines.push(line), error: (line) => lines.push(line) });
+      const status = await run({ cwd: input.cwd, args: ['--changed-files', ...input.changedFiles], log: (line) => lines.push(line), error: (line) => lines.push(line) });
       if (status !== 0) failures.push({ gate, lines: [...lines, `✗ ${gate}: violation detected`] });
     } catch (error) {
       failures.push({ gate, lines: [...lines, `⚠ ${gate}: 게이트가 «못 쟀다» — ${error instanceof Error ? error.message : String(error)}`] });

package/src/self-implement/headless-elanous-driver.ts

@@ -996,8 +996,8 @@ export interface HeadlessGoalLoopPtyOptions {
   /** 밖에서 쓴 이력 조회 심 — 기본은 실물(`pty-control-ipc`). ⭐ 테스트가 전역을 찌르지 않게
    *  `spawn`·`ptyAvailable` 과 **같은 방식**으로 주입한다(새 패턴 아님 · 테스트 전용 export 도 아님). */
   externalWriteProvenance?: (ptyId: string) => { externalWrites: number; externalWriteAgoMs: number; externalWriteActor: string } | undefined;
-  /** ★S4 P2b — brain 상담 1회 최대 대기(ms·기본 15초). 초과 시 abort + fail-soft(`brain.fail`).
-   *  ⚠️ **테스트 seam 겸용**(리뷰 must-fix — 이게 없으면 timeout fail-soft 경로를 15초 없이 검증할 수
+  /** ★S4 P2b — brain 상담 1회 최대 대기(ms·기본 45초). 초과 시 abort + fail-soft(`brain.fail`).
+   *  ⚠️ **테스트 seam 겸용**(리뷰 must-fix — 이게 없으면 timeout fail-soft 경로를 45초 없이 검증할 수
    *  없다). 프로덕션은 기본값을 쓴다(호출부 미지정). */
   brainTimeoutMs?: number;
   /** ★S4 P3 **관측 시계 seam**(테스트 전용·기본 `Date.now`).
@@ -1520,8 +1520,8 @@ export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions):
     let previousStallMetrics: { toolCalls: number; chars: number } | undefined;
     let keyframeSeq = 0; // 이 run 의 키프레임 순번(파일 키·seq 순 추출).
     // ⭐⭐ **wall-clock 상한**(리뷰 must-fix 2026-07-26) — 이 루프의 회계는 `i`(≈초·pollMs≈1000ms 가정)
-    //   기반이다. S4 P2b brain 상담이 tick 당 최대 `brainTimeoutMs`(기본 15초)를 **직렬 await** 하므로
-    //   전이가 반복되면 1 tick 이 ~16초가 되어 `maxWaitSec` 계약을 **최대 16배 초과**한다(600s → ~2.7h).
+    //   기반이다. S4 P2b brain 상담이 tick 당 최대 `brainTimeoutMs`(기본 45초)를 **직렬 await** 하므로
+    //   전이가 반복되면 1 tick 이 ~46초가 되어 `maxWaitSec` 계약을 초과할 수 있다.
     //   ⇒ 기존 활동-grace 의미(i 기반)는 **그대로 두고** 절대 경과시간을 **추가 상한**으로만 얹는다.
     //   단조 안전: 더 **일찍** 멈출 뿐 늦게 멈추는 경우가 없다. brain 미주입이면 i≈초라 두 조건이 일치
     //   (무회귀). ROADMAP §2 P1(종료 지연)의 회계 구조를 재작성하지 않는 최소 개입이다.
@@ -1563,7 +1563,7 @@ export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions):
         debug.log('self-implement', 'poll.heartbeat', { ptyId, runId, i, alive: h.isAlive(), lastActivityI, silentFor, ...parentObservation });
       }
       // #24 finer 마커 — stall 시 "poll 루프 안(자식 구동·정상)" vs "다른 동기 op" 구분.
-      setEventLoopActivity(`headless:poll-${i}:alive-${h.isAlive() ? 1 : 0}`);
+      setEventLoopActivity(`headless:poll:alive-${h.isAlive() ? 1 : 0}`);
       const delta = h.drainDelta();
       phase = 'snapshot';
       const snap = h.snapshot();   // ★ 1회 캡처 — 화면 릴레이 + GOAL-COMPLETE 공용(중복 snapshot 제거)
@@ -1697,6 +1697,7 @@ export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions):
                 if (opts.signal?.aborted) onBrainAbort();
                 else opts.signal?.addEventListener('abort', onBrainAbort, { once: true });
                 let timer: ReturnType<typeof setTimeout> | undefined;
+                const brainStartedMs = Date.now();
                 try {
                   // Lost and unknown are the same ownership axis exercised by the stalled-screen
                   // tests, not separate stances. Preserve their measured ownership and observation
@@ -1709,12 +1710,12 @@ export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions):
                     Promise.resolve(opts.brain.decide(controlObs, controller.signal)),
                     new Promise<ControlDecision>((_, reject) => {
                       // ⭐ **남은 절대 예산으로 clamp**(리뷰 must-fix 2R) — wall-clock 상한은 **tick 시작**에서만
-                      //   검사하므로, deadline 직전에 시작된 상담이 그대로면 최대 brainTimeoutMs(기본 15초)만큼
+                      //   검사하므로, deadline 직전에 시작된 상담이 그대로면 최대 brainTimeoutMs(기본 45초)만큼
                       //   hard deadline 을 **초과**한다. 상담 자체를 남은 예산 안으로 묶어 창을 닫는다.
                       //   최소 1ms(음수·0 이면 즉시 timeout → 다음 tick 상단 wall-clock 체크가 루프를 끊는다).
                       const remainMs = Math.max(1, hardI * 1000 - (Date.now() - loopStartedMs));
                       timer = setTimeout(() => { controller.abort(); reject(new Error('brain suggestion timeout')); },
-                        Math.min(opts.brainTimeoutMs ?? 15_000, remainMs));
+                        Math.min(opts.brainTimeoutMs ?? 45_000, remainMs));
                     }),
                     ...(parentAbort ? [parentAbort] : []),
                   ]);
@@ -1761,6 +1762,7 @@ export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions):
                     // 관측 계약은 화면 분류 원문을 보존한다. 완료 정보량·자동 정지는 아래의
                     // `completionState` 폐쇄형 정규화만 소비하므로 blocked/idle 기록을 잃지 않는다.
                     ptyId: h.id, runId, moment: 'in-round', step: i, trigger, state: curState, action: decision.action,
+                    durationMs: Date.now() - brainStartedMs,
                     // `delivery-outcome` is a follow-up observation, not another verdict. Consumers count
                     // either initial stage once per decision and can distinguish verdicts without input.
                     supervisionRecordStage: decision.action === 'input' ? 'verdict-input' : 'verdict-no-input',
@@ -1848,7 +1850,7 @@ export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions):
                   }
                 } catch (e) {
                   // Parent cancel outranks suggestion observation: leave the poll loop immediately so PTY cleanup is not
-                  // held by the 15s consultation timeout, even when a custom brain ignores its AbortSignal.
+                  // held by the 45s consultation timeout, even when a custom brain ignores its AbortSignal.
                   if (opts.signal?.aborted) {
                     timedOut = false;
                     exitReason = 'abort';
@@ -1856,7 +1858,7 @@ export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions):
                   }
                   debug.log('self-implement', 'brain.fail', {
                     ptyId: h.id, runId, step: i, trigger, state: curState,
-                    roundContextPresent,
+                    roundContextPresent, durationMs: Date.now() - brainStartedMs,
                     error: String(e instanceof Error ? e.message : e).slice(0, 120),
                   });
                 } finally {

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

@@ -1,30 +1,40 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { debug } from '../debug/log.js';
 import { getUserConfig } from '../user-config.js';
 import { publicExposureFiles, runExposeGate } from './expose-gate.js';
 import { admitLandingMerge } from './frozen-merges.js';
 import { releaseGitDiffPaths, releasePathHold, releasePathHoldShouldPost, releasePathHoldComment, releasePathHoldCommentsArgs, RELEASE_PATH_LABEL } from '../self-dev/release-path-guard.js';
 import { detectTestInterference, parseFailureCount, runBunTest } from '../../scripts/detect-test-interference.js';
-import { runTestInterferenceGate } from '../../scripts/ci-test-interference-gate.js';
+import { MAX_INSPECTED_TEST_FILES, runTestInterferenceGate } from '../../scripts/ci-test-interference-gate.js';
+import { pwaGraph, pwaReach } from '../../scripts/ci-pwa-build-gate.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 {
+  return pwaReach(files, () => graph(repoRoot)).reaches;
+}
 
 /**
- * The PWA's static build type-checks every `src/**` file it imports, under Next's stricter
- * `ProcessEnv` — a change that only touches `src/**` can break it while tsc and bun test stay
- * green (2026-09-27: two such changes kept main's PWA build red for two hours). Build whenever
- * app code or non-test source changed; test files are never imported by the PWA.
+ * Give a temporary checkout the source checkout's dependencies: link `<dir>/node_modules` when it is really installed
+ * there (its `marker` package exists), otherwise install into the candidate. Shared by host regate and the task agent's
+ * land worktree (TA-LAND-WORKTREE).
  */
-export function needsPwaBuild(files: readonly string[]): boolean {
-  return files.some((file) => file.startsWith('apps/pwa/') || (file.startsWith('src/') && !/\.test\.tsx?$/.test(file)));
+export function provideCheckoutDependencies(candidate: string, sourceRoot: string, dir: string, marker: string, install: (cwd: string) => void): void {
+  if (existsSync(join(candidate, dir, 'node_modules'))) return;
+  if (existsSync(join(sourceRoot, dir, 'node_modules', marker, 'package.json'))) {
+    symlinkSync(join(sourceRoot, dir, 'node_modules'), join(candidate, dir, 'node_modules'), 'dir');
+  } else install(join(candidate, dir));
 }
 
-export interface HostRegateInput { prNumber: number; headCommit: string; repoRoot: string; goalFile?: string; verifyOnly?: boolean; /** Called by a resume sweep that already holds this PR's claim. */ resumed?: true }
+export interface HostRegateInput { prNumber: number; headCommit: string; repoRoot: string; goalFile?: string; verifyOnly?: boolean; /** TA-LIVE-LAND-2: run the full landing gates (release-path hold · neighbours · PR re-read) but stop before the freeze admission and `gh pr merge` — the task agent lands it later via `pr land --expected-head`. */ noMerge?: true; /** Called by a resume sweep that already holds this PR's claim. */ resumed?: true }
 export interface HostRegateResult { passed: boolean; failures: Array<{ step: string; detail: string }>; os: string; status?: 'passed' | 'failed' | 'unmeasured' | 'frozen'; /** verifyOnly: 실제로 얹어 잰 base 끝 */ baseCommit?: string }
+export type InterferenceVerdict = { passed: boolean; detail?: string; unmeasured?: boolean; /** neighbour tests left out so the selection fits the inspection cap */ neighborsTrimmed?: number };
 export type HostRegateDeps = {
   command?: (bin: string, args: readonly string[], cwd: string, env?: NodeJS.ProcessEnv) => { status: number | null; stdout: string; stderr: string };
-  interference?: (files: readonly string[], cwd: string) => Promise<{ passed: boolean; detail?: string; unmeasured?: boolean }>;
+  interference?: (files: readonly string[], cwd: string) => Promise<InterferenceVerdict>;
+  /** Legacy injection for callers that supply an ephemeral worktree instead of a locked slot. */
   makeTemp?: () => string;
   removeTemp?: (path: string) => void;
   acquire?: (repoRoot: string) => Promise<() => void>;
@@ -46,17 +56,28 @@ const defaultCommand: NonNullable<HostRegateDeps['command']> = (bin, args, cwd,
 };
 
 /** The informational pr-land gate always returns zero; enforce its measured report and the combined test result instead. */
-async function defaultInterference(files: readonly string[], cwd: string, opts: { neighbors?: boolean } = {}): Promise<{ passed: boolean; detail?: string; unmeasured?: boolean }> {
-  const tests = files.filter((file) => /\.test\.tsx?$/.test(file));
-  const neighbors = new Set<string>(tests);
-  // verifyOnly(승인 탭)는 «이 PR 이 바꾼 시험»만 잰다 — 이웃 시험을 넣으면 간섭 관문의 상한(8)에 잘려 영영 «측정 불가»가 되고,
-  //   이웃의 기존 실패가 이 PR 을 막는다(2026-09-28 #21239 실측: scripts/lib 이웃 9 → 상한 8 · nl-routing-measurement 기존 1 fail).
+export async function defaultInterference(files: readonly string[], cwd: string, opts: { neighbors?: boolean; detect?: typeof detectTestInterference } = {}): Promise<InterferenceVerdict> {
+  const tests = [...new Set(files.filter((file) => /\.test\.tsx?$/.test(file)))].sort();
+  const changed = new Set(tests);
+  const neighbors = new Set<string>();
+  // verifyOnly(승인 탭)는 «이 PR 이 바꾼 시험»만 잰다 — 이웃의 기존 실패가 이 PR 을 막지 않게
+  //   (2026-09-28 #21239 실측: scripts/lib 이웃 9 · nl-routing-measurement 기존 1 fail).
   if (opts.neighbors !== false) for (const file of tests) {
     for (const sibling of readdirSync(join(cwd, dirname(file)))) {
-      if (/\.test\.tsx?$/.test(sibling)) neighbors.add(join(dirname(file), sibling));
+      const path = join(dirname(file), sibling);
+      if (/\.test\.tsx?$/.test(sibling) && !changed.has(path)) neighbors.add(path);
     }
   }
-  const selected = [...neighbors].sort();
+  // 이웃이 간섭 관문의 상한(MAX_INSPECTED_TEST_FILES)을 넘기면 그 관문이 잘라 «영영 측정 불가»가 된다
+  //   (2026-10-08 #25180·#25187 실측: src/self-implement 시험 175 · src/seat-loop 11). 바뀐 시험은 전부 두고 남는 칸만 이웃으로 채운다.
+  //   바뀐 시험만으로 상한을 넘으면 정직하게 «측정 불가»로 남는다.
+  const sortedNeighbors = [...neighbors].sort();
+  const room = Math.max(0, MAX_INSPECTED_TEST_FILES - tests.length);
+  const kept = tests.length > MAX_INSPECTED_TEST_FILES ? sortedNeighbors : sortedNeighbors.slice(0, room);
+  const neighborsTrimmed = sortedNeighbors.length - kept.length;
+  const trimmed = neighborsTrimmed > 0 ? { neighborsTrimmed } : {};
+  const trimNote = neighborsTrimmed > 0 ? ` · neighbours trimmed ${neighborsTrimmed} to fit inspection cap ${MAX_INSPECTED_TEST_FILES}` : '';
+  const selected = [...tests, ...kept].sort();
   if (!selected.length) return { passed: true };
   // 간섭 관문은 시험 파일이 둘 이상일 때만 잰다 — 하나면 간섭이라는 말이 없으니 그 파일을 한 번 돌려 실패 수로 본다.
   if (selected.length === 1) {
@@ -69,13 +90,13 @@ async function defaultInterference(files: readonly string[], cwd: string, opts:
   let report: Awaited<ReturnType<typeof detectTestInterference>> | undefined;
   await runTestInterferenceGate({
     args: ['--changed-files', ...selected], log: () => {},
-    detect: async (paths) => (report = await detectTestInterference(paths, (batch) => runBunTest(batch, undefined, cwd))),
+    detect: async (paths) => (report = await (opts.detect ?? detectTestInterference)(paths, (batch) => runBunTest(batch, undefined, cwd))),
   });
-  if (!report || report.status === 'unmeasurable' || selected.length > report.order.length) return { passed: false, unmeasured: true, detail: 'test interference measurement unavailable or truncated' };
+  if (!report || report.status === 'unmeasurable' || selected.length > report.order.length) return { passed: false, unmeasured: true, ...trimmed, detail: `test interference measurement unavailable or truncated (selected ${selected.length}, changed tests ${tests.length}, cap ${MAX_INSPECTED_TEST_FILES})${trimNote}` };
   if (report.isolatedFailures !== 0 || report.combinedFailures !== 0 || report.status === 'interference') {
-    return { passed: false, detail: `isolated=${report.isolatedFailures}, combined=${report.combinedFailures}, interference=${report.status}` };
+    return { passed: false, ...trimmed, detail: `isolated=${report.isolatedFailures}, combined=${report.combinedFailures}, interference=${report.status}${trimNote}` };
   }
-  return { passed: true };
+  return { passed: true, ...trimmed, ...(trimNote ? { detail: trimNote.slice(3) } : {}) };
 }
 
 const SLOT_WAIT_MS = 30 * 60_000;
@@ -92,7 +113,7 @@ function slotOwnerAlive(slot: string): boolean {
   }
 }
 
-export async function acquireSlot(repoRoot: string, opts: { waitMs?: number; pollMs?: number; now?: () => number } = {}): Promise<() => void> {
+export async function acquireSlot(repoRoot: string, opts: { waitMs?: number; pollMs?: number; now?: () => number } = {}): Promise<(() => void) & { worktree: string }> {
   const gitDir = spawnSync('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], { cwd: repoRoot, encoding: 'utf8' });
   if (gitDir.status !== 0 || !gitDir.stdout.trim()) throw new Error('git common directory unavailable for host regate lock');
   const root = join(gitDir.stdout.trim(), 'elanous-host-regate');
@@ -105,7 +126,7 @@ export async function acquireSlot(repoRoot: string, opts: { waitMs?: number; pol
       try {
         mkdirSync(slot);
         writeFileSync(join(slot, 'pid'), String(process.pid));
-        return () => rmSync(slot, { recursive: true, force: true });
+        return Object.assign(() => rmSync(slot, { recursive: true, force: true }), { worktree: join(root, `worktree-${i}`) });
       } catch (error) {
         if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
         // A slot left by a crashed host process would otherwise block every later run.
@@ -121,6 +142,24 @@ export async function acquireSlot(repoRoot: string, opts: { waitMs?: number; pol
   }
 }
 
+function removeBrokenSlotRegistration(repoRoot: string, worktree: string): void {
+  const gitDir = spawnSync('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], { cwd: repoRoot, encoding: 'utf8' });
+  if (gitDir.status !== 0 || !gitDir.stdout.trim()) throw new Error('git common directory unavailable for slot repair');
+  const registrations = join(gitDir.stdout.trim(), 'worktrees');
+  if (!existsSync(registrations)) return;
+  for (const name of readdirSync(registrations)) {
+    const registration = join(registrations, name);
+    if (!lstatSync(registration).isDirectory()) continue;
+    const pointer = join(registration, 'gitdir');
+    if (!existsSync(pointer) || lstatSync(pointer).isSymbolicLink()) continue;
+    if (resolve(readFileSync(pointer, 'utf8').trim()) !== resolve(worktree, '.git')) continue;
+    rmSync(registration, { recursive: true });
+  }
+}
+
+/** 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. */
 export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps = {}): Promise<HostRegateResult> {
   const command = deps.command ?? defaultCommand;
   const log = deps.log ?? ((event: 'passed' | 'failed' | 'unmeasured' | 'base-raced', data: Record<string, unknown>) => debug.log('harness.host-regate', event, data));
@@ -129,13 +168,27 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
   let base = '';
   let worktree: string | undefined;
   let attached = false;
+  let ephemeral = false;
+  let slotCommonDir: string | undefined;
+  const verifySlot = (): void => {
+    if (!worktree || !slotCommonDir || lstatSync(worktree).isSymbolicLink() || !lstatSync(worktree).isDirectory()) throw new Error('slot worktree mismatch');
+    const pointer = join(worktree, '.git');
+    if (!lstatSync(pointer).isFile() || lstatSync(pointer).isSymbolicLink()) throw new Error('slot worktree mismatch');
+    const common = realpathSync(run('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], worktree));
+    const registration = realpathSync(run('git', ['rev-parse', '--path-format=absolute', '--git-dir'], worktree));
+    if (common !== slotCommonDir || dirname(registration) !== join(slotCommonDir, 'worktrees')
+      || resolve(readFileSync(join(registration, 'gitdir'), 'utf8').trim()) !== resolve(pointer)
+      || resolve(readFileSync(pointer, 'utf8').trim().replace(/^gitdir: /, '')) !== registration
+      || run('git', ['rev-parse', '--show-toplevel'], worktree) !== worktree) throw new Error('slot worktree mismatch');
+  };
   let release: (() => void) | undefined;
   let endLanding: ((merged?: boolean) => void) | undefined;
   let landed = false;
   let verifiedBase: string | undefined;
+  let interferenceNote: Record<string, unknown> = {};
   const result = (event: 'passed' | 'failed' | 'unmeasured', step?: string, detail?: string): HostRegateResult => {
     if (step) failures.push({ step, detail: detail ?? 'unknown' });
-    log(event, { pr: input.prNumber, files, os: process.platform, ...(step ? { failedStep: step } : {}) });
+    log(event, { pr: input.prNumber, files, os: process.platform, ...interferenceNote, ...(step ? { failedStep: step, detail: (detail ?? 'unknown').slice(0, 300) } : {}) });
     return { passed: event === 'passed', failures, os: process.platform, ...(input.verifyOnly ? { status: event, ...(verifiedBase ? { baseCommit: verifiedBase } : {}) } : {}) };
   };
   const run = (bin: string, args: readonly string[], cwd: string, env?: NodeJS.ProcessEnv): string => {
@@ -155,16 +208,57 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
     const baseRefName = view.baseRefName;
     // verifyOnly(승인 탭): PR 에 기록된 base(baseRefOid)는 main 의 «지금 끝»보다 늙을 수 있다 — 지금 끝에 얹어 잰다.
     let baseCommit = view.baseRefOid!;
+    // REGATE-STALE-BASE: GitHub's baseRefOid can stay at the PR-open tip after main moves. After the bounded re-reads the
+    // regate measures on the fetched base tip (what the squash merge lands on) and records the stale PR base instead of failing.
+    // The closing PR re-read must still show the last PR base seen here (a PR that changed again is not the PR we measured).
+    let stalePrBase: string | undefined;
+    const initialPrBase = baseCommit;
+    let buildPwa = false;
     try {
       run('git', ['fetch', 'origin', `refs/heads/${baseRefName}`], input.repoRoot);
-      const fetchedBase = run('git', ['rev-parse', 'FETCH_HEAD'], input.repoRoot);
+      let fetchedBase = run('git', ['rev-parse', 'FETCH_HEAD'], input.repoRoot);
       if (input.verifyOnly) { baseCommit = fetchedBase; verifiedBase = fetchedBase; }
-      else if (fetchedBase !== baseCommit) throw new Error('fetched PR base differs from checked SHA');
+      else {
+        for (let attempt = 1; fetchedBase !== baseCommit; attempt++) {
+          debug.log('harness.host-regate', 'base-moved-retry', { pr: input.prNumber, attempt, checked: baseCommit, fetched: fetchedBase });
+          if (attempt === 3) {
+            stalePrBase = baseCommit;
+            debug.log('harness.host-regate', 'base-stale', { pr: input.prNumber, prBaseRefOidInitial: initialPrBase, prBaseRefOid: baseCommit, fetched: fetchedBase, candidateBase: fetchedBase });
+            baseCommit = fetchedBase;
+            break;
+          }
+          await new Promise((resolve) => setTimeout(resolve, 1_000));
+          view = readPr();
+          if (view.headRefOid !== input.headCommit || view.state !== 'OPEN' || view.isDraft !== false || view.baseRefName !== baseRefName || !/^[0-9a-f]{40}$/i.test(view.baseRefOid ?? '')) {
+            return result('unmeasured', 'pr-head', 'PR head, base commit, ready state or open state unavailable or changed');
+          }
+          baseCommit = view.baseRefOid!;
+          run('git', ['fetch', 'origin', `refs/heads/${baseRefName}`], input.repoRoot);
+          fetchedBase = run('git', ['rev-parse', 'FETCH_HEAD'], input.repoRoot);
+        }
+      }
       run('git', ['fetch', 'origin', `refs/pull/${input.prNumber}/head`], input.repoRoot);
       if (run('git', ['rev-parse', 'FETCH_HEAD'], input.repoRoot) !== input.headCommit) throw new Error('fetched PR head differs from checked SHA');
-      worktree = (deps.makeTemp ?? (() => mkdtempSync(join(tmpdir(), 'elanous-host-regate-'))))();
-      run('git', ['worktree', 'add', '--detach', worktree, baseCommit], input.repoRoot);
-      attached = true;
+      const slotWorktree = (release as (() => void) & { worktree?: string }).worktree;
+      ephemeral = !!deps.makeTemp || !slotWorktree;
+      worktree = deps.makeTemp?.() ?? slotWorktree ?? mkdtempSync(join(tmpdir(), 'host-regate-'));
+      if (ephemeral && slotWorktree && resolve(worktree) === resolve(slotWorktree)) throw new Error('temporary worktree overlaps locked slot');
+      if (!ephemeral && !deps.acquire) {
+        slotCommonDir = realpathSync(run('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], input.repoRoot));
+      }
+      if (!ephemeral && existsSync(worktree)) {
+        if (slotCommonDir) verifySlot();
+        attached = true;
+        // A previous host may have died mid-merge; never carry its index or untracked files into this run.
+        run('git', ['reset', '--hard'], worktree);
+        run('git', ['clean', '-fdx', '-e', 'node_modules', '-e', '.next', '-e', '*.tsbuildinfo'], worktree);
+        run('git', ['checkout', '--detach', baseCommit], worktree);
+      }
+      if (!attached) {
+        if (!ephemeral && !deps.acquire) removeBrokenSlotRegistration(input.repoRoot, worktree);
+        run('git', ['worktree', 'add', '--detach', worktree, baseCommit], input.repoRoot);
+        attached = true;
+      }
       if (run('git', ['rev-parse', 'HEAD'], worktree) !== baseCommit) throw new Error('worktree base HEAD mismatch');
       base = run('git', ['merge-base', baseCommit, input.headCommit], worktree);
       files = run('git', ['diff', '--name-only', base, input.headCommit], worktree).split('\n').filter(Boolean);
@@ -200,17 +294,14 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
       // a temporary checkout whose node_modules is empty or purged; linking it turned every gate into
       // «Cannot find package 'typescript'» (unmeasured · 2026-09-29 #21239). Install into the candidate instead.
       const candidate = worktree;
-      const provide = (dir: string, marker: string): void => {
-        if (existsSync(join(candidate, dir, 'node_modules'))) return;
-        if (existsSync(join(input.repoRoot, dir, 'node_modules', marker, 'package.json'))) {
-          symlinkSync(join(input.repoRoot, dir, 'node_modules'), join(candidate, dir, 'node_modules'), 'dir');
-        } else run('bun', ['install', '--frozen-lockfile'], join(candidate, dir));
-      };
+      const provide = (dir: string, marker: string): void => provideCheckoutDependencies(candidate, input.repoRoot, dir, marker, (cwd) => { run('bun', ['install', '--frozen-lockfile'], cwd); });
       provide('', 'typescript');
-      if (needsPwaBuild(files) && existsSync(join(worktree, 'apps/pwa'))) provide('apps/pwa', 'next');
+      buildPwa = needsPwaBuild(files, worktree);
+      if (buildPwa && existsSync(join(worktree, 'apps/pwa'))) provide('apps/pwa', 'next');
     } catch (e) { return result('unmeasured', 'worktree', String(e)); }
     try {
       const interference = await (deps.interference ?? ((f: readonly string[], c: string) => defaultInterference(f, c, { neighbors: !input.verifyOnly })))(files, worktree);
+      if (interference.neighborsTrimmed) interferenceNote = { neighborsTrimmed: interference.neighborsTrimmed, 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.
@@ -230,19 +321,21 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
       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 (needsPwaBuild(files)) {
+    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)); }
     }
     let current: PrView;
     try { current = readPr(); }
     catch (e) { return result('unmeasured', 'pr-view', String(e)); }
-    if (current.headRefOid !== input.headCommit || current.baseRefName !== baseRefName || (!input.verifyOnly && current.baseRefOid !== baseCommit) || current.state !== 'OPEN' || current.isDraft !== false) {
+    if (current.headRefOid !== input.headCommit || current.baseRefName !== baseRefName || (!input.verifyOnly && current.baseRefOid !== (stalePrBase ?? baseCommit)) || current.state !== 'OPEN' || current.isDraft !== false) {
       return result('unmeasured', 'pr-base-changed', 'PR head or base changed during host regate; rerun against the new base');
     }
     // --match-head-commit pins the head. gh has no base pin, so the base was re-read just
     // above; the seconds between that read and the merge are checked after the fact below.
     if (input.verifyOnly) return result('passed');
+    // TA-REJUDGE-ON-HEAD — 병합 없는 재게이트는 «잰 base 끝»을 같이 낸다(겹침 증거의 gate.baseCommit).
+    if (input.noMerge) return { ...result('passed'), status: 'passed', baseCommit };
     const landing = admitLandingMerge({ prNumber: input.prNumber, headCommit: input.headCommit, repoRoot: input.repoRoot, ...(input.goalFile ? { goalFile: input.goalFile } : {}) }, deps.freezeRoot, {}, input.resumed ? undefined : { prNumber: input.prNumber, repoRoot: input.repoRoot, headCommit: input.headCommit }, { prodFreezeRoot: deps.prodFreezeRoot });
     if (landing.kind !== 'merge') {
       debug.log('harness.merge', 'frozen', { pr: input.prNumber, ...(landing.kind === 'held' ? { reason: landing.freeze.reason, until: landing.freeze.until } : { resumedElsewhere: true }) });
@@ -281,10 +374,22 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
     return result('unmeasured', 'host-regate', String(e));
   } finally {
     try { endLanding?.(landed); } catch (e) { log('unmeasured', { pr: input.prNumber, files, os: process.platform, failedStep: 'landing-release', detail: String(e) }); }
-    try { if (attached && worktree) run('git', ['worktree', 'remove', '--force', worktree], input.repoRoot); }
-    catch (e) { log('unmeasured', { pr: input.prNumber, files, os: process.platform, failedStep: 'cleanup', detail: String(e) }); }
-    try { if (worktree) (deps.removeTemp ?? ((path) => rmSync(path, { recursive: true, force: true })))(worktree); }
-    catch (e) { log('unmeasured', { pr: input.prNumber, files, os: process.platform, failedStep: 'cleanup', detail: String(e) }); }
+    try {
+      if (attached && worktree) {
+        if (slotCommonDir) verifySlot();
+        run('git', ['reset', '--hard'], worktree);
+        run('git', ['clean', '-fdx', '-e', 'node_modules', '-e', '.next', '-e', '*.tsbuildinfo'], worktree);
+      }
+    } catch (e) { log('unmeasured', { pr: input.prNumber, files, os: process.platform, failedStep: 'cleanup', detail: String(e) }); }
+    if (ephemeral && worktree) {
+      try {
+        if (attached) run('git', ['worktree', 'remove', '--force', worktree], input.repoRoot);
+      } catch (e) { log('unmeasured', { pr: input.prNumber, files, os: process.platform, failedStep: 'cleanup', detail: String(e) }); }
+      try {
+        if (deps.removeTemp) deps.removeTemp(worktree);
+        else rmSync(worktree, { recursive: true, force: true });
+      } catch (e) { log('unmeasured', { pr: input.prNumber, files, os: process.platform, failedStep: 'cleanup', detail: String(e) }); }
+    }
     try { release?.(); }
     catch (e) { log('unmeasured', { pr: input.prNumber, files, os: process.platform, failedStep: 'lock', detail: String(e) }); }
     if (failures.length && failures[0]?.step !== 'release-path-hold') {