elanous 0.2.27 → 0.2.29

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

@@ -1,4 +1,5 @@
 import { spawnSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
@@ -7,7 +8,7 @@ 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 { detectTestInterference, failedNamesFromStreams, parseFailureCount, runBunTest, type MeasuredRun } from '../../scripts/detect-test-interference.js';
 import { MAX_INSPECTED_TEST_FILES, runTestInterferenceGate } from '../../scripts/ci-test-interference-gate.js';
 import { pwaGraph, pwaReach } from '../../scripts/ci-pwa-build-gate.js';
 import { classifyMergeFailure, clipRegateDetail, parseConflictFiles, type HostRegateFailure } from './regate-detail.js';
@@ -32,6 +33,12 @@ export function provideCheckoutDependencies(candidate: string, sourceRoot: strin
 
 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: HostRegateFailure[]; os: string; status?: 'passed' | 'failed' | 'unmeasured' | 'frozen'; /** verifyOnly: 실제로 얹어 잰 base 끝 */ baseCommit?: string }
+/** Only a missing host repository is recoverable by selecting the run's recorded root. Gate failures are final. */
+export function hostRepositoryUnavailable(result: HostRegateResult): boolean {
+  return !result.passed && result.status === 'unmeasured'
+    && result.failures[0]?.step === 'host-regate'
+    && result.failures[0].detail === 'host repository unavailable';
+}
 export type InterferenceVerdict = { passed: boolean; detail?: string; unmeasured?: boolean; /** neighbour tests left out so the selection fits the inspection cap */ neighborsTrimmed?: number; /** importer tests left out after changed tests and all selected neighbors take priority */ importerTrimmed?: number };
 export type HostRegateDeps = {
   command?: (bin: string, args: readonly string[], cwd: string, env?: NodeJS.ProcessEnv) => { status: number | null; stdout: string; stderr: string };
@@ -57,6 +64,18 @@ const defaultCommand: NonNullable<HostRegateDeps['command']> = (bin, args, cwd,
   return { status: overflow ? null : r.status, stdout: r.stdout ?? '', stderr: (r.stderr ?? '') + (r.error ? `${r.error.message} (${overflow ? `output exceeded ${SPAWN_MAX_BUFFER} bytes` : 'command unavailable'})` : '') };
 };
 
+/** Keep the failure identity in both the returned detail and the host-regate ledger event. */
+function failureNames(runs: readonly MeasuredRun[], fileCap: number, testCap: number): string {
+  const failed = runs.filter((run) => run.fail !== null && run.fail > 0);
+  if (!failed.length) return 'none';
+  const files = [...new Set(failed.flatMap((run) => run.failedFiles ?? []))];
+  const tests = [...new Set(failed.flatMap((run) => run.failedTests ?? []))];
+  const bounded = (names: string[], cap: number): string => names.length
+    ? `${names.slice(0, cap).map((name) => name.slice(0, 120)).join(' | ')}${names.length > cap ? ` | +${names.length - cap} more` : ''}`
+    : 'unknown';
+  return `files=${bounded(files, fileCap)}; tests=${bounded(tests, testCap)}`;
+}
+
 /** The informational pr-land gate always returns zero; enforce its measured report and the combined test result instead. */
 export async function defaultInterference(files: readonly string[], cwd: string, opts: {
   neighbors?: boolean;
@@ -136,7 +155,9 @@ export async function defaultInterference(files: readonly string[], cwd: string,
     const run = await (opts.run ?? ((paths, dir) => runBunTest(paths, undefined, dir)))(selected, cwd);
     const fail = run.signal || run.exitCode === null ? null : parseFailureCount(`${run.stdout}${run.stderr}`);
     if (fail === null) return { passed: false, unmeasured: true, ...trimmed, detail: `single test run unmeasured: ${selected[0]}` };
-    return fail === 0 ? { passed: true, ...trimmed } : { passed: false, ...trimmed, detail: `${selected[0]} — ${fail} fail` };
+    if (fail === 0) return { passed: true, ...trimmed };
+    const names = failedNamesFromStreams(run);
+    return { passed: false, ...trimmed, detail: `single=${fail} fail; ${failureNames([{ files: selected, fail, status: 'measured', failedFiles: names.files, failedTests: names.tests }], 8, 20)}` };
   }
   // The informational pr-land gate always returns zero; its measured report is the verdict.
   let report: Awaited<ReturnType<typeof detectTestInterference>> | undefined;
@@ -146,7 +167,10 @@ export async function defaultInterference(files: readonly string[], cwd: string,
   });
   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, ...trimmed, detail: `isolated=${report.isolatedFailures}, combined=${report.combinedFailures}, interference=${report.status}${trimNote}` };
+    const bothFailed = report.isolatedFailures! > 0 && report.combinedFailures! > 0;
+    const isolatedNames = failureNames(report.isolated, bothFailed ? 4 : 8, bothFailed ? 10 : 20);
+    const combinedNames = failureNames([report.combined], bothFailed ? 4 : 8, bothFailed ? 10 : 20);
+    return { passed: false, ...trimmed, detail: `isolated=${report.isolatedFailures}, combined=${report.combinedFailures}, interference=${report.status}; isolated ${isolatedNames}; combined ${combinedNames}${trimNote}` };
   }
   return { passed: true, ...trimmed, ...(trimNote ? { detail: trimNote.slice(3) } : {}) };
 }
@@ -237,6 +261,10 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
   let endLanding: ((merged?: boolean) => void) | undefined;
   let landed = false;
   let verifiedBase: string | undefined;
+  // Two host-regate slots may fetch in the same repository at once. FETCH_HEAD is shared;
+  // each measurement needs its own ref so another fetch cannot replace its evidence.
+  const fetchNamespace = `refs/elanous/regate/${process.pid}-${randomUUID()}`;
+  const fetchedRefs = new Set<string>();
   let interferenceNote: Record<string, unknown> = {};
   // HOST-REGATE-REASON-LOST: `facts` carries the expected/actual head, conflict files and merge failure kind of the
   //   pr-head · merge-conflict · merge steps; the detail keeps a bounded head ⊕ tail instead of the first 300 characters.
@@ -250,6 +278,12 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
     if (r.status !== 0) throw new Error(clipRegateDetail((r.stderr || r.stdout || `${bin} exited ${r.status}`).trim()));
     return r.stdout.trim();
   };
+  const fetchRef = (source: string, name: 'base' | 'head'): string => {
+    const ref = `${fetchNamespace}/${name}`;
+    fetchedRefs.add(ref);
+    run('git', ['fetch', '--no-write-fetch-head', 'origin', `+${source}:${ref}`], input.repoRoot);
+    return run('git', ['rev-parse', ref], input.repoRoot);
+  };
   try {
     if (!Number.isSafeInteger(input.prNumber) || input.prNumber <= 0 || !/^[0-9a-f]{40}$/i.test(input.headCommit)) return result('unmeasured', 'input', 'invalid PR number or checked head SHA');
     release = await (deps.acquire ?? acquireSlot)(input.repoRoot);
@@ -272,8 +306,7 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
     const initialPrBase = baseCommit;
     let buildPwa = false;
     try {
-      run('git', ['fetch', 'origin', `refs/heads/${baseRefName}`], input.repoRoot);
-      let fetchedBase = run('git', ['rev-parse', 'FETCH_HEAD'], input.repoRoot);
+      let fetchedBase = fetchRef(`refs/heads/${baseRefName}`, 'base');
       if (input.verifyOnly) { baseCommit = fetchedBase; verifiedBase = fetchedBase; }
       else {
         for (let attempt = 1; fetchedBase !== baseCommit; attempt++) {
@@ -290,12 +323,10 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
             return prHeadFailure(view);
           }
           baseCommit = view.baseRefOid!;
-          run('git', ['fetch', 'origin', `refs/heads/${baseRefName}`], input.repoRoot);
-          fetchedBase = run('git', ['rev-parse', 'FETCH_HEAD'], input.repoRoot);
+          fetchedBase = fetchRef(`refs/heads/${baseRefName}`, 'base');
         }
       }
-      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');
+      if (fetchRef(`refs/pull/${input.prNumber}/head`, 'head') !== input.headCommit) throw new Error('fetched PR head differs from checked SHA');
       const slotWorktree = (release as (() => void) & { worktree?: string }).worktree;
       ephemeral = !!deps.makeTemp || !slotWorktree;
       worktree = deps.makeTemp?.() ?? slotWorktree ?? mkdtempSync(join(tmpdir(), 'host-regate-'));
@@ -394,6 +425,20 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
         (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 && !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: input.verifyOnly ? baseCommit : base }); }
@@ -463,6 +508,10 @@ 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) }); }
+    for (const ref of fetchedRefs) {
+      try { run('git', ['update-ref', '-d', ref], input.repoRoot); }
+      catch (e) { log('unmeasured', { pr: input.prNumber, files, os: process.platform, failedStep: 'fetch-ref-cleanup', detail: String(e) }); }
+    }
     try {
       if (attached && worktree) {
         if (slotCommonDir) verifySlot();

package/src/self-implement/orchestrator.ts

@@ -94,6 +94,7 @@ import { boundaryGlobs, boundaryViolations } from './goal-boundary.js';
 import { askAtExecution, type ExecutionClarificationResult } from './execution-clarification.js';
 import { classifyOutOfScope } from './scope-adjacency.js';
 import { targetScopedGoalText } from './goal-text-path-scope.js';
+import { declaredNewFilePaths } from './goal-new-paths.js';
 import { dropStaleReverts, type RevertGuardResult } from './revert-guard.js';
 import type { SelfDevGoalType } from '../self-dev/orchestrate.js';
 import { DEFAULT_BRANCH_WORKTREE_BASE, gateGitResidue, observeGitResidue } from '../git-fs/worktree.js';
@@ -813,10 +814,8 @@ function parseDeclaredTargetPathsFromAsk(askText: string): { readable: boolean;
   return { readable: true, paths: [...new Set(paths.filter(Boolean))] };
 }
 
-// SCOPE-NEW-FILES-LINE — 칸 문면은 새로 만들 파일을 «신설:» 줄로 따로 적는다(OP D칸 규칙). 그 줄도 선언 범위다.
+// SCOPE-NEW-FILES-LINE — 칸 문면의 신설 경로도 선언 범위다.
 //   10-11 FLEX-SIGNALS run-95799887: 칸이 적은 신설 파일 둘을 «범위 밖»으로 세어 구현을 보류했다.
-const DECLARED_NEW_FILES_LINE = /^\s*(?:신설|new\s*files?)\s*[:：]\s*(.*)$/i;
-
 function declaredPathsFromGoalDocumentText(document: string): { readable: boolean; paths: readonly string[] } {
   const originalAsk = extractVerbatimOriginalAsk(document)?.ask ?? null;
   if (originalAsk === null) return { readable: false, paths: [] };
@@ -826,13 +825,6 @@ function declaredPathsFromGoalDocumentText(document: string): { readable: boolea
   return newFiles.length > 0 ? { readable: true, paths: [...new Set([...declared.paths, ...newFiles])] } : declared;
 }
 
-function declaredNewFilePaths(askText: string): readonly string[] {
-  return askText.split(/\r?\n/).flatMap((line) => {
-    const match = DECLARED_NEW_FILES_LINE.exec(line);
-    return match ? parseDeclaredTargetPathsFromAsk(`대상 경로: ${match[1]}`).paths : [];
-  });
-}
-
 /** P3 전제의 경계 — ask 머리줄 «대상 경로:» ⊕ «신설:» 줄의 합집합. 못 읽으면 빈 목록(그때 P3 는 unknown). */
 function declaredPremiseScopePaths(askText: string): string[] {
   return [...new Set([...parseDeclaredTargetPathsFromAsk(askText).paths, ...declaredNewFilePaths(askText)])];
@@ -8263,6 +8255,7 @@ async function runSelfImplementInner(
     url: pr.url,
     number: pr.number,
     branch: wt.branch,
+    headCommit: runGitCommand(wt.path, ['rev-parse', '--verify', 'HEAD'], { encoding: 'utf8', timeout: 10_000 }).stdout.trim(),
     autoMerge: canAuto,
     autoReview: !!labels,
     ...(preparedPrBody.truncated ? { prBodyTruncated: true, prBodyOriginalChars: preparedPrBody.originalChars } : {}),

package/src/self-implement/review-mustfix-class.ts

@@ -0,0 +1,115 @@
+// ── REVIEW-MUSTFIX-CLASSIFY — 리뷰 must-fix 를 «수의 추이»가 아니라 «회차 짝»으로 가른다 ──
+//
+// 수의 추이(improving·stable·worsening·oscillating)는 «새 실결함이 매번 나오는 정상 수렴»과
+// «원리상 못 닫는 요구»를 못 가른다(#26644 · 10-12 · 5→3→2→3). 이 판정은 회차 짝으로 가른다:
+//
+//   ① new-defect        앞 회차에 없던 새 지적 — 그대로 수렴 간다(계속).
+//   ② post-land-evidence 착지 뒤에만 낼 수 있는 증거(운영 소비·실물 착지·live 호출자)를 요구하는
+//                          지적 — 같은 런 재수리 0 · «그림자 착지 → 관측 → live» 쪼개기 결정.
+//   ③ recurring          수리 뒤 같은 지적이 다시 나옴 — intent 경계 자동 명시 ⊕ 다른 모델 교차 리뷰 제안.
+//   unmeasured           이 회차 must-fix 를 안 쟀다 — 분류 불가, 슈퍼바이저 지금 동작 그대로.
+//
+// ⛔ 임의 임계(«두 번») 금지 — 짝은 «정규화 문면이 같다»는 사실 하나로 맞는다.
+
+/** Evidence a must-fix item demands that only a landing can produce. */
+export type MustFixEvidenceKind = 'ops-consumption' | 'artifact-landing' | 'live-caller';
+
+export interface MustFixItem {
+  /** Verbatim reviewer must-fix text. */
+  readonly text: string;
+  /** Evidence this item demands that only a landing can produce. */
+  readonly evidence?: MustFixEvidenceKind;
+  /** Pairing scope — the task that raised it (supervisor ledger); pairing never crosses tasks. */
+  readonly taskId?: string;
+}
+
+/** One round's observed must-fix list; `items` undefined/empty = the round's review was not observed. */
+export interface MustFixRoundObservation {
+  readonly items?: readonly MustFixItem[];
+}
+
+export type MustFixClass = 'new-defect' | 'post-land-evidence' | 'recurring' | 'unmeasured';
+
+export interface MustFixRoundClassification {
+  readonly class: MustFixClass;
+  readonly reason: string;
+  /** ② post-land-evidence — 같은 런 재수리 0, «그림자 착지 → 관측 → live» 쪼개기 결정. */
+  readonly split?: 'shadow-land → observe → live';
+  /** ③ recurring — intent 경계 자동 명시 ⊕ 다른 모델 교차 리뷰 제안. */
+  readonly crossReview?: true;
+  /** Evidence kinds this round's items demand (②). */
+  readonly evidence?: readonly MustFixEvidenceKind[];
+  /** Recurring item texts, normalized (③). */
+  readonly recurring?: readonly string[];
+}
+
+/** Evidence subjects, each matched as a whole word group. */
+const EVIDENCE_SUBJECTS: ReadonlyArray<readonly [MustFixEvidenceKind, string]> = [
+  ['live-caller', String.raw`(?:live|라이브)\s*(?:호출자|caller)`],
+  ['ops-consumption', String.raw`(?:운영(?:에서)?\s*소비|(?:prod(?:uction)?|ops)\s*consumption)`],
+  ['artifact-landing', String.raw`(?:(?:실물|실제)\s*착지|artifact\s*landing)`],
+];
+/** Korean: «<대상>[ 증거](를|을)? <요구>» or «<대상> 증거가 없다». */
+const KO_DEMAND = String.raw`(?:\s*(?:증거|증명)\s*(?:를|을)?|\s*(?:를|을))?\s*(?:보여라|보여\s*달라|대라|증명하라|입증하라|못\s*봤다|관측되지\s*않았다|확인되지\s*않았다)`;
+const KO_MISSING = String.raw`\s*(?:증거|증명)\s*(?:가|이)?\s*없다`;
+/** English: «show|prove|demonstrate [the] <subject> [evidence]» or «no <subject> evidence». */
+const EN_PREFIX = String.raw`(?:show|prove|demonstrate)\s+(?:the\s+)?`;
+
+/**
+ * Derive the post-land evidence kind a must-fix text *demands* — allow-list only: the WHOLE text (trimmed,
+ * one optional terminal «.»/«!») must be one of the pure evidence-demand forms above. Anything else — a second
+ * sentence, a comma, «그리고», a defect word, a different verb — stays undefined, i.e. ① same-run repair
+ * (의심스러우면 ① = 안전한 기본). Widening the recognised forms is a follow-up; outside them is ① on purpose.
+ */
+export function inferMustFixEvidence(text: string): MustFixEvidenceKind | undefined {
+  const t = text.trim().toLowerCase().replace(/\s+/gu, ' ').replace(/[.!]$/u, '');
+  for (const [kind, subject] of EVIDENCE_SUBJECTS) {
+    const forms = [
+      `${subject}${KO_DEMAND}`,
+      `${subject}${KO_MISSING}`,
+      `${EN_PREFIX}${subject}(?:\\s+evidence)?`,
+      `no\\s+${subject}\\s+evidence`,
+    ];
+    if (forms.some((form) => new RegExp(`^${form}$`, 'u').test(t))) return kind;
+  }
+  return undefined;
+}
+
+/** Pairing key: whitespace collapsed, lower-cased — same discipline as `noPrStreakKey`. */
+function mustFixKey(text: string): string {
+  return text.trim().replace(/\s+/gu, ' ').toLowerCase();
+}
+
+export function classifyMustFixRound(
+  prev: MustFixRoundObservation | undefined,
+  cur: MustFixRoundObservation,
+): MustFixRoundClassification {
+  const curItems = cur.items ?? [];
+  if (curItems.length === 0) {
+    return { class: 'unmeasured', reason: '이 회차 리뷰 must-fix 를 안 쟀다 — 분류 불가, 슈퍼바이저 지금 동작 그대로' };
+  }
+  const prevItems = prev?.items ?? [];
+  // Pairing never crosses tasks: same normalized text AND both sides name the same task — unknown origin never pairs.
+  const pairs = (p: MustFixItem, c: MustFixItem): boolean => mustFixKey(p.text) === mustFixKey(c.text)
+    && p.taskId !== undefined && c.taskId !== undefined && p.taskId === c.taskId;
+  const recurring = curItems.filter((item) => prevItems.some((p) => pairs(p, item)));
+  if (prevItems.length > 0 && recurring.length > 0) {
+    return {
+      class: 'recurring',
+      reason: `같은 지적이 수리 뒤에 다시 나왔다(${recurring.length}) — intent 경계를 명시하고 다른 모델 교차 리뷰를 제안한다`,
+      crossReview: true,
+      recurring: recurring.map((item) => mustFixKey(item.text)),
+    };
+  }
+  // ② only when every item demands post-land evidence — a real defect mixed in still gets its same-run repair (①).
+  const evidence = [...new Set(curItems.flatMap((item) => (item.evidence ? [item.evidence] : [])))];
+  if (curItems.every((item) => item.evidence !== undefined)) {
+    return {
+      class: 'post-land-evidence',
+      reason: `증거는 착지 뒤에만 난다(${evidence.join(' · ')}) — 같은 런 재수리 0, 그림자 착지 → 관측 → live 로 쪼갠다`,
+      evidence,
+      split: 'shadow-land → observe → live',
+    };
+  }
+  return { class: 'new-defect', reason: '앞 회차에 없던 새 지적 — 새 실결함 수렴으로 그대로 간다' };
+}

package/src/self-implement/rework-policy.ts

@@ -628,17 +628,74 @@ function sameProviderStep(child: ExplicitChildForEscalation): EscalateTarget | n
   return null;
 }
 
+/** escalateChild 매핑 해석 근원 — `env` 가 `config` 를 이기고, 둘 다 없으면 같은 provider 사다리(`ladder`). */
+export type EscalateTargetSource = 'config' | 'env' | 'ladder';
+
+/** `self-dev.rework`/`escalate-target` 관측 한 건. 관측 전용 — 판정·분기는 이 값을 읽지 않는다. */
+export interface EscalateTargetObservation {
+  readonly category: 'self-dev.rework';
+  readonly event: 'escalate-target';
+  readonly data: {
+    readonly source: EscalateTargetSource;
+    readonly from: string;
+    readonly to: string;
+    readonly applied: boolean;
+    /** `applied=false` 의 이유 — provider 경계 또는 불완전한 모델 ID. */
+    readonly reason?: 'cross-provider' | 'invalid-target';
+  };
+}
+
+/** 명시 자식 승급 해석 옵션. `escalateChild`(`tools.selfImplement.escalateChild` from→to 맵)는 호출부가
+ *  config 에서 읽어 전달한다 — ⚠️ Pod 안엔 운영 config 가 없다(POD-CONFIG-SNAPSHOT 전) → Pod 자식은
+ *  `ELANOUS_SELFDEV_ESCALATE_CHILD` env 로만 받는다. 관측 싱크도 호출부가 주입한다(정책은 순수 유지). */
+export interface ExplicitChildEscalateOptions {
+  readonly escalateChild?: Readonly<Record<string, string>>;
+  readonly observe?: (observation: EscalateTargetObservation) => void;
+}
+
+/** 모델 id(`openrouter/z-ai/glm-5.3` 등)의 provider 세그먼트 — 첫 `/` 앞. */
+function escalateModelProvider(model: string): string {
+  return (model.split('/')[0] ?? '').trim();
+}
+
+/** 명시 매핑은 provider/model, OpenRouter 는 openrouter/vendor/model 형태의 완전한 ID 여야 한다. */
+function validEscalateModelId(model: string): boolean {
+  const segments = model.split('/');
+  const required = segments[0] === 'openrouter' ? 3 : 2;
+  return segments.length === required && segments.every((segment) => segment.length > 0 && !/\s/.test(segment));
+}
+
+/** `ELANOUS_SELFDEV_ESCALATE_CHILD=<from>=<to>` 해석 — 첫 `=` 기준. 빈 조각·구문 파손은 매핑 없음. */
+function parseEscalateChildEnv(raw: string | undefined): { from: string; to: string } | undefined {
+  const value = raw?.trim();
+  if (!value) return undefined;
+  const separator = value.indexOf('=');
+  if (separator <= 0) return undefined;
+  const from = value.slice(0, separator).trim();
+  const to = value.slice(separator + 1).trim();
+  return from && to ? { from, to } : undefined;
+}
+
 /** 명시 자식의 승급 타깃 — 같은 provider 안에서만(위 규칙). `ELANOUS_SELFDEV_SOL_*` 는 운영자의 명시
  *  덮어쓰기라 그대로 우선한다. ⛔ `effort` 가 빈 문자열이면 «안 보낸다»는 뜻이다(OpenRouter 는 노력을
- *  보내면 덜 생각했다 — 2026-09-23 실측). */
+ *  보내면 덜 생각했다 — 2026-09-23 실측).
+ *  escalateChild 짝지기(env 가 config 를 이긴다)는 사다리(`sameProviderStep`)보다 «먼저» —
+ *  같은 provider 타깃이면 그 타깃으로, provider 가 다르면 무시 ⊕ 관측하고 사다리로 돌아간다.
+ *  둘 다 없으면 종전 그대로(바이트 불변). */
 export function resolveExplicitChildEscalateTarget(
   tier: EscalateTier,
   env: Record<string, string | undefined> = process.env,
   child?: ExplicitChildForEscalation,
+  options?: ExplicitChildEscalateOptions,
 ): EscalateTarget | null {
   if (tier === 'none') return null;
+  const sink = options?.observe;
+  const emit = sink
+    ? (data: EscalateTargetObservation['data']): void => sink({ category: 'self-dev.rework', event: 'escalate-target', data })
+    : undefined;
   const overrideModel = env.ELANOUS_SELFDEV_SOL_MODEL?.trim();
   if (overrideModel) {
+    if (child) emit?.({ source: 'env', from: child.model, to: overrideModel, applied: true });
     return {
       model: overrideModel,
       provider: env.ELANOUS_SELFDEV_SOL_PROVIDER?.trim() || child?.provider || 'openai-codex',
@@ -646,9 +703,30 @@ export function resolveExplicitChildEscalateTarget(
     };
   }
   if (child === undefined) return null;
+  const effortOverride = env.ELANOUS_SELFDEV_SOL_EFFORT?.trim();
+  // env → config 순서로 이 자식 모델에 대한 매핑을 모은다(없는 층은 건너뛴다).
+  const pairings: Array<{ source: 'env' | 'config'; to: string }> = [];
+  const envPairing = parseEscalateChildEnv(env.ELANOUS_SELFDEV_ESCALATE_CHILD);
+  if (envPairing && envPairing.from === child.model) pairings.push({ source: 'env', to: envPairing.to });
+  const configMap = options?.escalateChild;
+  const configTo = configMap && Object.hasOwn(configMap, child.model) ? configMap[child.model]?.trim() : undefined;
+  if (configTo) pairings.push({ source: 'config', to: configTo });
+  for (const pairing of pairings) {
+    if (!validEscalateModelId(pairing.to)) {
+      emit?.({ source: pairing.source, from: child.model, to: pairing.to, applied: false, reason: 'invalid-target' });
+      continue;
+    }
+    if (escalateModelProvider(pairing.to) === child.provider) {
+      emit?.({ source: pairing.source, from: child.model, to: pairing.to, applied: true });
+      return effortOverride
+        ? { model: pairing.to, provider: child.provider, effort: effortOverride }
+        : { model: pairing.to, provider: child.provider, effort: '' };
+    }
+    emit?.({ source: pairing.source, from: child.model, to: pairing.to, applied: false, reason: 'cross-provider' });
+  }
   const step = sameProviderStep(child);
   if (step === null) return null;
-  const effortOverride = env.ELANOUS_SELFDEV_SOL_EFFORT?.trim();
+  emit?.({ source: 'ladder', from: child.model, to: step.model, applied: true });
   return effortOverride ? { ...step, effort: effortOverride } : step;
 }
 

package/src/self-implement/run-ledger.ts

@@ -260,6 +260,8 @@ export interface FederatedRunLedgerLookupOptions {
 
 export interface RunLedgerLookupOptions extends FederatedRunLedgerLookupOptions {
   all?: boolean;
+  /** Single-directory scope for the non-federated lookup; default = `runLedgerDir()`. */
+  dir?: string;
   list?: (path: string) => string[];
 }
 
@@ -306,7 +308,7 @@ export function loadFederatedRunLedger(runId: string, options: FederatedRunLedge
 }
 
 function lookupRunLedgerTargets(options: RunLedgerLookupOptions): RunLedgerLookupTarget[] {
-  return options.all ? resolveFederatedRunLedgerTargets(options) : [{ ledgerDirectory: runLedgerDir(), targetName: null }];
+  return options.all ? resolveFederatedRunLedgerTargets(options) : [{ ledgerDirectory: options.dir ?? runLedgerDir(), targetName: null }];
 }
 
 /** Find exact canonical IDs first; otherwise scan canonical ledger filenames for a normalized unique prefix. */
@@ -433,6 +435,95 @@ export function recordHumanStoppedRun(runId: string, options: HumanStopRunLedger
   }, options.dir);
 }
 
+/** Ledger-recording options shared by the non-blocking observers — never part of the recorded entry payload. */
+export interface NonBlockingRunLedgerOptions {
+  /** 관측 시각 — 생략하면 now */
+  timestamp?: string;
+  /** 원장 디렉터리 — 생략하면 정본 run ledger dir */
+  dir?: string;
+}
+
+/** The settled-result payload a non-blocking request records under its requestId. */
+export interface NonBlockingRunResultLedgerEntry {
+  kind: string;
+  reason?: string;
+  /** 런이 실제로 산출한 next만 담는다 — 값이 없으면 키를 생략한다(unknown 보존). */
+  next?: string;
+  ok?: boolean;
+  runId?: string;
+}
+
+/**
+ * Record a non-blocking request's immediate pending state under its minted requestId.
+ * Event-kind naming follows the `recordHumanStoppedRun` observer-event precedent; never changes a run itself.
+ */
+export function recordNonBlockingRunPending(requestId: string, options: NonBlockingRunLedgerOptions = {}): void {
+  const recordedAt = options.timestamp ?? new Date().toISOString();
+  appendRunLedgerEntry({
+    timestamp: recordedAt,
+    runId: requestId,
+    event: 'non-blocking-pending',
+    data: { requestId, kind: 'pending', recordedAt },
+  }, options.dir);
+}
+
+/**
+ * Record a non-blocking request's settled result (kind·reason·next) under the same requestId.
+ * The payload is the second argument; ledger placement options (timestamp·dir) stay a separate third argument
+ * so no option ever leaks into the recorded entry (RunLedgerEntry format stays unchanged).
+ * Event-kind naming follows the `recordHumanStoppedRun` observer-event precedent; never changes a run itself.
+ */
+export function recordNonBlockingRunResult(
+  requestId: string,
+  entry: NonBlockingRunResultLedgerEntry,
+  options: NonBlockingRunLedgerOptions = {},
+): void {
+  const recordedAt = options.timestamp ?? new Date().toISOString();
+  appendRunLedgerEntry({
+    timestamp: recordedAt,
+    runId: requestId,
+    event: 'non-blocking-result',
+    data: {
+      requestId,
+      kind: entry.kind,
+      ...(entry.reason === undefined ? {} : { reason: entry.reason }),
+      ...(entry.next === undefined ? {} : { next: entry.next }),
+      ...(entry.ok === undefined ? {} : { ok: entry.ok }),
+      ...(entry.runId === undefined ? {} : { runId: entry.runId }),
+      recordedAt,
+    },
+  }, options.dir);
+}
+
+/** The non-blocking request record a ledger carries for its runId; latest result wins over the pending entry. */
+export interface NonBlockingRunLedgerRecord {
+  requestId: string;
+  kind: string;
+  reason?: string;
+  /** next는 런이 실제로 산출한 값만 담는다 — 원장에 적힌 값이 없으면 이 키도 없다(unknown 보존). */
+  next?: string | null;
+}
+
+/** Read the non-blocking request record from an already-loaded ledger; null when the ledger carries none. */
+export function readNonBlockingRunRecord(ledger: readonly RunLedgerEntry[]): NonBlockingRunLedgerRecord | null {
+  let record: NonBlockingRunLedgerRecord | null = null;
+  for (const entry of ledger) {
+    if (entry.event === 'non-blocking-pending' && record === null) {
+      record = { requestId: entry.runId, kind: 'pending', next: null };
+      continue;
+    }
+    if (entry.event !== 'non-blocking-result' || typeof entry.data.kind !== 'string') continue;
+    const reason = typeof entry.data.reason === 'string' ? entry.data.reason : undefined;
+    record = {
+      requestId: entry.runId,
+      kind: entry.data.kind,
+      ...(reason === undefined ? {} : { reason }),
+      ...(typeof entry.data.next === 'string' ? { next: entry.data.next } : {}),
+    };
+  }
+  return record;
+}
+
 function parseRunLedgerEntry(line: string, lineNumber: number, expectedRunId: string): RunLedgerEntry {
   let parsed: unknown;
   try {
@@ -1210,6 +1301,8 @@ export interface UnfinishedRunLedgerEntry {
   lastActivityStatus: LastActivityStatus;
   /** ⭐ 「남은 것」을 «가려» 보여 주는 등급 — 종전엔 이 조회가 한 값뿐이라 회고에서 못 갈랐다. */
   lifecycle: UnfinishedRunLifecycle;
+  /** Non-blocking request record (kind·reason·next) carried by this runId's ledger; absent for runs without one. */
+  nonBlocking?: NonBlockingRunLedgerRecord;
 }
 
 export interface UnfinishedRunLedgerQuery {
@@ -1294,7 +1387,10 @@ function hasCanonicalRunStatus(ledger: readonly RunLedgerEntry[]): boolean {
 }
 
 /** Events that may follow a terminal run-status without reopening the run. Anything else stays unfinished. */
-export const TRAILING_BOOKKEEPING_EVENTS = ['pipeline-traversal-shadow', 'run-rollup', 'progress-delivery', 'progress-delivery-outcome'] as const;
+// `non-blocking-pending`/`non-blocking-result` are observer records of the non-blocking request
+// surface (#26634 칸 NONBLOCKING-RESULT-LEDGER). They carry the requestId result, never a run
+// lifecycle, so appending them after a terminal run-status must not reopen the run.
+export const TRAILING_BOOKKEEPING_EVENTS = ['pipeline-traversal-shadow', 'run-rollup', 'progress-delivery', 'progress-delivery-outcome', 'non-blocking-pending', 'non-blocking-result'] as const;
 
 const TRAILING_BOOKKEEPING_EVENT_SET = new Set<string>(TRAILING_BOOKKEEPING_EVENTS);
 
@@ -1559,6 +1655,7 @@ interface UnfinishedLedgerFacts {
   targetRoot: string | null;
   goalFile: string | null;
   fixedLifecycle: UnfinishedRunLifecycle;
+  nonBlocking: NonBlockingRunLedgerRecord | null;
 }
 
 // A full federated scan can exceed 5,000 files; keep the previous scan resident for mtime-checked reuse.
@@ -1589,6 +1686,7 @@ function unfinishedLedgerFacts(ledger: readonly RunLedgerEntry[]): UnfinishedLed
     targetRoot: ledgerTargetRoot(ledger),
     goalFile: ledgerGoalDocument(ledger),
     fixedLifecycle: classifyUnfinishedLifecycle(ledger, null, 0),
+    nonBlocking: readNonBlockingRunRecord(ledger),
   };
 }
 
@@ -1698,7 +1796,9 @@ export function queryUnfinishedRunLedgers(options: UnfinishedRunLedgerQueryOptio
     if (facts.terminal) {
       terminal += 1;
       if (facts.terminalByTrailingRunStatus) terminalByTrailingRunStatus += 1;
-      continue;
+      // A run carrying a non-blocking request record stays queryable by requestId even after its
+      // terminal run-status; runs without one keep the exact previous skip behavior.
+      if (!facts.nonBlocking) continue;
     }
 
     const branch = facts.branch;
@@ -1726,7 +1826,7 @@ export function queryUnfinishedRunLedgers(options: UnfinishedRunLedgerQueryOptio
           : goalDocument.status === 'directory-unreadable'
             ? 'goal-directory-unreadable'
             : 'goal-document-not-found';
-      entries.push({ runId, branch, status: 'terminal-status-missing', plannedPaths: [], plannedPathStatus, ...unknownDeclaredPaths(), pathMatchReasons: {}, goalDocumentPath: null, goalLookupBasis, goalDocumentSearchDirectory: searchDirectory, ...activity, lifecycle });
+      entries.push({ runId, branch, status: 'terminal-status-missing', plannedPaths: [], plannedPathStatus, ...unknownDeclaredPaths(), pathMatchReasons: {}, goalDocumentPath: null, goalLookupBasis, goalDocumentSearchDirectory: searchDirectory, ...activity, lifecycle, ...(facts.nonBlocking ? { nonBlocking: facts.nonBlocking } : {}) });
       continue;
     }
     try {
@@ -1734,9 +1834,9 @@ export function queryUnfinishedRunLedgers(options: UnfinishedRunLedgerQueryOptio
       const text = typeof document === 'string' ? document : document.toString('utf8');
       const paths = [...new Set(tracedPathReferences(text).map((reference) => reference.path))];
       const declared = declaredPathsFromGoalDocument(text);
-      entries.push({ runId, branch, status: 'terminal-status-missing', plannedPaths: paths, plannedPathStatus: paths.length > 0 ? goalDocument.source === 'ledger' ? 'found-ledger-goal-file' : 'found-branch-fallback' : 'no-traced-paths', ...declared, pathMatchReasons: pathMatchReasons(declared.declaredPaths, paths), goalDocumentPath: goalDocument.path, goalLookupBasis, goalDocumentSearchDirectory: searchDirectory, ...activity, lifecycle });
+      entries.push({ runId, branch, status: 'terminal-status-missing', plannedPaths: paths, plannedPathStatus: paths.length > 0 ? goalDocument.source === 'ledger' ? 'found-ledger-goal-file' : 'found-branch-fallback' : 'no-traced-paths', ...declared, pathMatchReasons: pathMatchReasons(declared.declaredPaths, paths), goalDocumentPath: goalDocument.path, goalLookupBasis, goalDocumentSearchDirectory: searchDirectory, ...activity, lifecycle, ...(facts.nonBlocking ? { nonBlocking: facts.nonBlocking } : {}) });
     } catch {
-      entries.push({ runId, branch, status: 'terminal-status-missing', plannedPaths: [], plannedPathStatus: 'goal-document-unreadable', declaredPaths: [], declaredPathStatus: 'goal-document-unreadable', pathMatchReasons: {}, goalDocumentPath: goalDocument.path, goalLookupBasis, goalDocumentSearchDirectory: searchDirectory, ...activity, lifecycle });
+      entries.push({ runId, branch, status: 'terminal-status-missing', plannedPaths: [], plannedPathStatus: 'goal-document-unreadable', declaredPaths: [], declaredPathStatus: 'goal-document-unreadable', pathMatchReasons: {}, goalDocumentPath: goalDocument.path, goalLookupBasis, goalDocumentSearchDirectory: searchDirectory, ...activity, lifecycle, ...(facts.nonBlocking ? { nonBlocking: facts.nonBlocking } : {}) });
     }
   }
   entries.sort((left, right) => left.runId.localeCompare(right.runId));
@@ -1885,7 +1985,11 @@ export function queryFederatedUnfinishedRunLedgers(options: FederatedUnfinishedR
   //   📏 실측(2026-08-11): 미완 57 중 ***7*** 이 다른 원장에 종결을 갖고 있었다.
   // ⛔ 판정 술어는 스캐너와 «같은 것»을 쓴다(`run-status` 또는 `terminal`) — 어휘를 새로 만들지 않는다.
   const terminatedElsewhere = new Set<string>();
-  const unfinishedRunIds = requestedRunIds === undefined ? new Set(entries.map((entry) => entry.runId)) : new Set([...requestedRunIds].filter((runId) => entries.some((entry) => entry.runId === runId)));
+  // Runs carrying a non-blocking request record never drop out of the union: their requestId
+  // reason·next must survive restarts and cross-directory reconciliation alike.
+  const unfinishedRunIds = requestedRunIds === undefined
+    ? new Set(entries.filter((entry) => !entry.nonBlocking).map((entry) => entry.runId))
+    : new Set([...requestedRunIds].filter((runId) => entries.some((entry) => entry.runId === runId && !entry.nonBlocking)));
   for (const runId of unfinishedRunIds) {
     for (const ledgerDirectory of ledgerDirectories) {
       try {