elanous 0.2.25 → 0.2.28

package/src/self-implement/graph-authority.ts

@@ -280,11 +280,24 @@ export function graphAuthorityFields(authority: GraphAuthority, template: GraphT
  *    (`wrong-stage` · `does-not-apply` · `key-absent` · `unparseable` 이 서로 다른 처방이다).
  *  ⛔ **거절은 조용하지 않다** — 패치가 안 물면 `rejections` 로 나오고 «기준 선언»이 그대로 산다. */
 /** 오버레이 조건이 «읽을 수 있는» 상태 키. ⛔ 여기 없는 키는 원장에 값이 안 실린다.
- *  🔑 그래서 «떨어뜨리되 말은 한다» — 아래 `stateExtraKeys` 가 그 이름을 남긴다. */
-export const OVERLAY_STATE_KEYS = ['attempts', 'goal_id'] as const;
+ *  🔑 그래서 «떨어뜨리되 말은 한다» — 아래 `stateExtraKeys` 가 그 이름을 남긴다.
+ *  ⭐ `author_grade` — 적응형 저작(GRAPH-AUTHOR-GRADE) 첫 조각: 저작 등급을 오버레이 상태의 «이름»으로 싣는다. */
+export const OVERLAY_STATE_KEYS = ['attempts', 'author_grade', 'goal_id'] as const;
+
+/** 저작 등급의 오버레이 어휘 — `goal-author` 의 `GoalAuthorGrade`(`full|lite`) 를 오버레이 등급(`normal`) 로 옮긴다.
+ *  ⛔ 모르는 값(빈 값·오타)은 `undefined` — 등급을 «지어내지 않는다». */
+export function normalizeAuthorGrade(value: unknown): 'lite' | 'normal' | 'complex' | undefined {
+  if (value === 'lite') return 'lite';
+  if (value === 'full') return 'normal';
+  if (value === 'complex') return 'complex';
+  return undefined;
+}
 
 /** `graph-overlay-decision` 원장에 «판정에 실제로 쓴» 상태를 싣는다.
  *  ⛔ `hasOwn` 으로 복사한다 — 그래야 「없음」과 「false」와 「0」이 원장에서 «다른 값»이다.
+ *  ⭐ `author_grade` 만은 `normalizeAuthorGrade` 를 «거쳐» 실린다 — 저작 어휘(`full`)가 원장에
+ *     그대로 «사실»로 남으면 오버레이 어휘(`normal`)와 섞인다. 모르는 등급은 키는 남되 값이
+ *     `undefined` 다(등급을 지어내지 않는다 · «있었다»는 사실도 조용히 버리지 않는다).
  *  ⛔⭐ 목록 밖 키는 값을 «안» 싣지만 ***조용히 버리지 않는다*** — `stateExtraKeys` 로 이름을 남긴다.
  *     🩸 이 골이 생긴 이유가 「원장이 판정의 입력을 안 남겨서 손으로 재현하다 오판했다」이므로,
  *        여기서 «조용히» 떨어뜨리면 같은 병을 한 층 아래에서 다시 짓는 것이다. */
@@ -293,7 +306,8 @@ export function overlayDecisionObservation<T extends Readonly<Record<string, unk
 }): T & { readonly state: Readonly<Record<string, unknown>>; readonly stateExtraKeys?: readonly string[] } {
   const state: Record<string, unknown> = {};
   for (const key of OVERLAY_STATE_KEYS) {
-    if (Object.hasOwn(input.state, key)) state[key] = input.state[key];
+    if (!Object.hasOwn(input.state, key)) continue;
+    state[key] = key === 'author_grade' ? normalizeAuthorGrade(input.state[key]) : input.state[key];
   }
   const extra = Object.keys(input.state).filter((key) => !(OVERLAY_STATE_KEYS as readonly string[]).includes(key)).sort();
   return { ...input, state, ...(extra.length > 0 ? { stateExtraKeys: extra } : {}) };

package/src/self-implement/graph-yaml.ts

@@ -33,6 +33,8 @@ export interface GraphNodeSpec {
   readonly fanOut?: string;
   readonly contract?: GraphNodeContract;
   readonly call?: string;
+  /** Entry selected by this call when a unit exposes more than one entry. */
+  readonly callEntry?: string;
   readonly budget?: { readonly innerSteps: number };
 }
 
@@ -60,7 +62,7 @@ export interface GraphTemplateSpec {
   readonly state?: readonly string[];
   /** ⭐ 런 계약(선택) — 이 그래프가 «기본으로» 요구하는 실행 칸 등. 발사 인자가 덮는다(graph-run-contract.ts). */
   readonly runContract?: GraphRunContractSpec;
-  readonly unit?: { readonly inputs: readonly string[]; readonly outputs: readonly string[]; readonly exits: readonly string[] };
+  readonly unit?: { readonly inputs: readonly string[]; readonly outputs: readonly string[]; readonly exits: readonly string[]; readonly entries?: readonly string[] };
   readonly nodes: readonly GraphNodeSpec[];
   readonly edges: readonly GraphEdgeSpec[];
 }
@@ -155,7 +157,7 @@ export function parseGraphTemplateYaml(source: string, label = '<inline>'): Grap
       : undefined;
     // A subgraph node becomes a unit call only when it names `call:`; without it the node keeps the
     // pre-unit meaning (catalog role / recipe node), so existing declarations stay valid.
-    if (kind === 'subgraph' && (n.call !== undefined || n.budget !== undefined)) {
+    if (kind === 'subgraph' && (n.call !== undefined || n.budget !== undefined || n.call_entry !== undefined)) {
       if (typeof n.call !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._-]*@(?:\^?[1-9]\d*)$/.test(n.call))
         errors.push({ path: `${at}/call`, message: 'call 은 id@정수판 또는 id@^주판이어야 한다' });
       const budget = n.budget as Record<string, unknown> | undefined;
@@ -166,8 +168,10 @@ export function parseGraphTemplateYaml(source: string, label = '<inline>'): Grap
           !Array.isArray(contractRaw.outputs) || !contractRaw.outputs.every(v => typeof v === 'string'))
         errors.push({ path: `${at}/contract`, message: 'subgraph 에는 inputs·outputs 계약이 필요하다' });
       if (recipe !== 'none') errors.push({ path: `${at}/recipe`, message: 'subgraph 는 recipe 를 실행하지 않는다' });
-    } else if (kind !== 'subgraph' && (n.call !== undefined || n.budget !== undefined)) {
-      errors.push({ path: at, message: 'call·budget 은 subgraph 전용이다' });
+      if (n.call_entry !== undefined && (typeof n.call_entry !== 'string' || !n.call_entry.trim()))
+        errors.push({ path: `${at}/call_entry`, message: 'call_entry 는 비어 있지 않은 노드 id 여야 한다' });
+    } else if (kind !== 'subgraph' && (n.call !== undefined || n.budget !== undefined || n.call_entry !== undefined)) {
+      errors.push({ path: at, message: 'call·call_entry·budget 은 subgraph 전용이다' });
     }
     // ⛔ 계약이 없으면 「이 노드가 무엇을 할 수 있나」를 답할 수 없다 — 경고로 남긴다(거절은 오버레이 쪽).
     if (contract === undefined) warnings.push({ path: `${at}/contract`, message: '계약(inputs·tools·outputs)이 없다 — 권한을 코드에서만 알 수 있다' });
@@ -182,6 +186,7 @@ export function parseGraphTemplateYaml(source: string, label = '<inline>'): Grap
       ...(typeof n.fan_out === 'string' ? { fanOut: n.fan_out } : {}),
       ...(contract ? { contract } : {}),
       ...(kind === 'subgraph' && typeof n.call === 'string' ? { call: n.call } : {}),
+      ...(kind === 'subgraph' && typeof n.call_entry === 'string' ? { callEntry: n.call_entry } : {}),
       ...(kind === 'subgraph' && n.budget && typeof n.budget === 'object' && !Array.isArray(n.budget) &&
         typeof (n.budget as Record<string, unknown>).inner_steps === 'number'
         ? { budget: { innerSteps: (n.budget as { inner_steps: number }).inner_steps } } : {}),
@@ -242,15 +247,18 @@ export function parseGraphTemplateYaml(source: string, label = '<inline>'): Grap
   if (doc.unit !== undefined) {
     const rawUnit = doc.unit as Record<string, unknown>;
     if (!rawUnit || typeof rawUnit !== 'object' || Array.isArray(rawUnit) ||
-        Object.keys(rawUnit).some(key => !['inputs', 'outputs', 'exits'].includes(key)) ||
+        Object.keys(rawUnit).some(key => !['inputs', 'outputs', 'exits', 'entries'].includes(key)) ||
         !['inputs', 'outputs', 'exits'].every(key => Array.isArray(rawUnit[key]) &&
           (rawUnit[key] as unknown[]).every(v => typeof v === 'string' && v.length > 0) &&
           new Set(rawUnit[key] as string[]).size === (rawUnit[key] as string[]).length) ||
         !(rawUnit.exits as string[]).length ||
         (rawUnit.exits as string[]).some(exit => !terminalNodes.includes(exit)) ||
-        terminalNodes.some(exit => !(rawUnit.exits as string[]).includes(exit))) {
+        terminalNodes.some(exit => !(rawUnit.exits as string[]).includes(exit)) ||
+        (rawUnit.entries !== undefined && (!Array.isArray(rawUnit.entries) || !(rawUnit.entries as unknown[]).every(v => typeof v === 'string' && v.length > 0 && known.has(v)) ||
+          new Set(rawUnit.entries as string[]).size !== (rawUnit.entries as string[]).length || !(rawUnit.entries as string[]).includes(entryNode!)))) {
       errors.push({ path: `${label}/unit`, message: 'unit 의 inputs·outputs·exits 및 terminal_nodes 가 일치해야 한다' });
-    } else unit = { inputs: rawUnit.inputs as string[], outputs: rawUnit.outputs as string[], exits: rawUnit.exits as string[] };
+    } else unit = { inputs: rawUnit.inputs as string[], outputs: rawUnit.outputs as string[], exits: rawUnit.exits as string[],
+      ...(rawUnit.entries === undefined ? {} : { entries: rawUnit.entries as string[] }) };
   }
   const runContract = parseGraphRunContract(doc.run_contract);
   if (runContract.error) errors.push({ path: `${label}/run_contract`, message: runContract.error });

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

@@ -1361,7 +1361,22 @@ export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions):
           return {};
         }
         const target = childLlm
-          ? resolveExplicitChildEscalateTarget(tier, process.env, { provider: childLlm.provider, model: childLlm.model, ...(childLlm.effort ? { effort: childLlm.effort } : {}) })
+          ? resolveExplicitChildEscalateTarget(tier, process.env,
+            { provider: childLlm.provider, model: childLlm.model, ...(childLlm.effort ? { effort: childLlm.effort } : {}) },
+            {
+              escalateChild: tier === 'none' ? undefined : (() => {
+                try { return getUserConfig().tools.selfImplement.escalateChild; }
+                catch (error) {
+                  try { debug.log('self-dev.rework', 'escalate-config-unavailable', { reason: errorMessage(error) }); }
+                  catch { /* Observability cannot block child launch. */ }
+                  return undefined;
+                }
+              })(),
+              observe: observation => {
+                try { debug.log(observation.category, observation.event, observation.data); }
+                catch { /* Observability cannot block child launch. */ }
+              },
+            })
           : resolveEscalateTarget(tier);
         if (!target) return {};
         return {

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-'));
@@ -463,6 +494,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)])];
@@ -3647,7 +3639,8 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
   try {
     // 10-05 PODPROVIDER: record which child provider this run uses — «default» when the launch named none.
     const launch = opts.launch ?? resolveLaunchStamp();
-    const origin = { ...runOriginData(), childProvider: opts.childLlm?.provider ?? 'default', ...(opts.childLlm?.model ? { childModel: opts.childLlm.model } : {}), launch };
+    const origin = { ...runOriginData(), childProvider: opts.childLlm?.provider ?? 'default', ...(opts.childLlm?.model ? { childModel: opts.childLlm.model } : {}),
+      ...(process.env.ELANOUS_TASK_CARD_ID ? { taskCardId: process.env.ELANOUS_TASK_CARD_ID } : {}), launch };
     (opts.seams.writeRunLedger ?? appendRunLedgerEntry)({
       timestamp: new Date().toISOString(), runId, event: 'run-origin', data: origin,
       ...(opts.goalId ? { goalId: opts.goalId } : {}), ...shardIdentity,
@@ -8262,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/pwa-import-graph.ts

@@ -1,5 +1,7 @@
-import { readdirSync, readFileSync } from 'node:fs';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { dirname, join, relative, resolve, sep } from 'node:path';
+import ts from 'typescript';
+import { debug } from '../debug/log.js';
 
 type GraphFiles = {
   readFile?: (path: string) => string;
@@ -24,6 +26,16 @@ function sourceFiles(cwd: string): string[] {
   return files;
 }
 
+const IMPORT_SPECIFIER = /\b(?:import|export)\s+(?:[^;'"]*?\s+from\s*)?['"](\.[^'"]+)['"]|\bimport\s*\(\s*['"](\.[^'"]+)['"]\s*\)/g;
+
+/** Repo-relative file candidates a relative import specifier (already joined to its importer's directory) can resolve to. */
+function importCandidates(base: string): string[] {
+  return /\.js$/.test(base)
+    // A real .js file wins over a same-named .ts source (the actual resolution order).
+    ? [base, base.replace(/\.js$/, '.ts'), base.replace(/\.js$/, '.tsx'), `${base.slice(0, -3)}/index.ts`, `${base.slice(0, -3)}/index.tsx`, `${base.slice(0, -3)}/index.js`]
+    : /\.tsx?$/.test(base) ? [base] : [base + '.ts', base + '.tsx', base + '.js', base + '/index.ts', base + '/index.tsx', base + '/index.js'];
+}
+
 /** PWA source entrypoints and the transitive relative imports they resolve inside repository src/. */
 export function pwaReachableSrcFiles(cwd: string, { readFile = (path) => readFileSync(path, 'utf8'), listFiles = sourceFiles }: GraphFiles = {}): Set<string> {
   const root = resolve(cwd);
@@ -33,7 +45,6 @@ export function pwaReachableSrcFiles(cwd: string, { readFile = (path) => readFil
   // Start from everything apps/pwa/tsconfig.json `include`s — its `src/**/*.ts(x)` also matches *.test.* files, and the Next
   // build type-checks them. Excluding tests hid the real entry (tool-result-chain.test.ts → src/nexus/api/meta-api → most of src).
   const queue = [...available].filter((file) => /^apps\/pwa\/src\/.*\.tsx?$/.test(file));
-  const imports = /\b(?:import|export)\s+(?:[^;'"]*?\s+from\s*)?['"](\.[^'"]+)['"]|\bimport\s*\(\s*['"](\.[^'"]+)['"]\s*\)/g;
   while (queue.length) {
     const file = queue.pop()!;
     if (visited.has(file)) continue;
@@ -42,16 +53,13 @@ export function pwaReachableSrcFiles(cwd: string, { readFile = (path) => readFil
     let content: string;
     try { content = readFile(join(root, file)); }
     catch { continue; }
-    for (const match of content.matchAll(imports)) {
+    for (const match of content.matchAll(IMPORT_SPECIFIER)) {
       const specifier = match[1] ?? match[2];
       if (!specifier) continue;
       const target = resolve(root, dirname(file), specifier);
       const base = relative(root, target).split(sep).join('/');
       if (!base.startsWith('src/')) continue;
-      const candidates = /\.js$/.test(base)
-        // A real .js file wins over a same-named .ts source (the actual resolution order).
-        ? [base, base.replace(/\.js$/, '.ts'), base.replace(/\.js$/, '.tsx'), `${base.slice(0, -3)}/index.ts`, `${base.slice(0, -3)}/index.tsx`, `${base.slice(0, -3)}/index.js`]
-        : /\.tsx?$/.test(base) ? [base] : [base + '.ts', base + '.tsx', base + '.js', base + '/index.ts', base + '/index.tsx', base + '/index.js'];
+      const candidates = importCandidates(base);
       const resolved = candidates.find((candidate) => available.has(candidate));
       if (resolved) {
         if (!visited.has(resolved)) queue.push(resolved);
@@ -63,3 +71,182 @@ export function pwaReachableSrcFiles(cwd: string, { readFile = (path) => readFil
   }
   return reached;
 }
+
+export type AffectedRoots = { roots: Set<string>; failure?: undefined } | { roots?: undefined; failure: string };
+
+function astImportSpecifiers(source: ts.SourceFile): { imports: string[]; ignoredDynamic: number; failure?: string } {
+  const parseError = (source as ts.SourceFile & { parseDiagnostics?: readonly ts.Diagnostic[] }).parseDiagnostics?.[0];
+  if (parseError) return { imports: [], ignoredDynamic: 0, failure: `${source.fileName} AST 파싱 실패: ${ts.flattenDiagnosticMessageText(parseError.messageText, ' ')}` };
+  const imports: string[] = [];
+  let ignoredDynamic = 0;
+  const literal = (node: ts.Node | undefined): string | undefined => node && (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) ? node.text : undefined;
+  const visit = (node: ts.Node): void => {
+    if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
+      const specifier = literal(node.moduleSpecifier);
+      if (specifier) imports.push(specifier);
+    } else if (ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference)) {
+      const specifier = literal(node.moduleReference.expression);
+      if (specifier) imports.push(specifier);
+    } else if (ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument)) {
+      const specifier = literal(node.argument.literal);
+      if (specifier) imports.push(specifier);
+    } else if (ts.isCallExpression(node) && (node.expression.kind === ts.SyntaxKind.ImportKeyword
+      || (ts.isIdentifier(node.expression) && node.expression.text === 'require'))) {
+      const specifier = literal(node.arguments[0]);
+      if (specifier) imports.push(specifier);
+      else ignoredDynamic += 1;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return { imports, ignoredDynamic };
+}
+
+function reExportSpecifiers(source: ts.SourceFile): string[] {
+  const importedLocals = new Map<string, string>();
+  for (const statement of source.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+    const from = statement.moduleSpecifier.text;
+    const clause = statement.importClause;
+    if (clause?.name) importedLocals.set(clause.name.text, from);
+    const bindings = clause?.namedBindings;
+    if (bindings && ts.isNamespaceImport(bindings)) importedLocals.set(bindings.name.text, from);
+    if (bindings && ts.isNamedImports(bindings)) {
+      for (const element of bindings.elements) importedLocals.set(element.name.text, from);
+    }
+  }
+  const specifiers: string[] = [];
+  for (const statement of source.statements) {
+    if (ts.isExportDeclaration(statement)) {
+      if (statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)) specifiers.push(statement.moduleSpecifier.text);
+      else if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+        for (const element of statement.exportClause.elements) {
+          const from = importedLocals.get((element.propertyName ?? element.name).text);
+          if (from) specifiers.push(from);
+        }
+      }
+    } else if (ts.isExportAssignment(statement) && ts.isIdentifier(statement.expression)) {
+      const from = importedLocals.get(statement.expression.text);
+      if (from) specifiers.push(from);
+    }
+  }
+  return specifiers;
+}
+
+/** Declarations visible without an import edge must enter every scoped program. */
+function suppliesAmbientTypes(source: ts.SourceFile): boolean {
+  if (source.fileName.endsWith('.d.ts') || !ts.isExternalModule(source)) return true;
+  const visit = (node: ts.Node): boolean => {
+    if (ts.isModuleDeclaration(node) && (node.name.text === 'global' || ts.isStringLiteral(node.name))) return true;
+    return ts.forEachChild(node, visit) ?? false;
+  };
+  return visit(source);
+}
+
+function gateTypeScriptSources(cwd: string): string[] {
+  const files: string[] = [];
+  const walk = (dir: string): void => {
+    // A partial directory walk is not a valid affected-root measurement: an
+    // unreadable subtree may contain the only importer of a changed file.
+    const entries = readdirSync(join(cwd, dir), { withFileTypes: true });
+    for (const entry of entries) {
+      const path = `${dir}/${entry.name}`;
+      if (entry.isDirectory() && entry.name !== 'node_modules' && !entry.name.startsWith('.')) walk(path);
+      else if (entry.isFile() && /\.ts$/.test(path)) files.push(path);
+    }
+  };
+  for (const root of ['src', 'scripts', 'test']) {
+    // An optional include glob may match no directory in a fixture. Only a
+    // confirmed ENOENT is empty; permission/I/O errors must fail closed.
+    try { statSync(join(cwd, root)); }
+    catch (cause) {
+      if ((cause as NodeJS.ErrnoException).code === 'ENOENT') continue;
+      throw cause;
+    }
+    walk(root);
+  }
+  return files;
+}
+
+/**
+ * Changed .ts files plus the listed files that import one of them directly (one reverse-import step).
+ * Every changed file and every listed file must be readable — an unreadable file could be a hidden importer, so the
+ * result is a failure the caller turns into a full-program run, never a smaller root set.
+ */
+export function reverseImportAffectedRoots(cwd: string, changed: ReadonlySet<string>, { readFile = (path) => readFileSync(path, 'utf8'), listFiles = gateTypeScriptSources }: GraphFiles = {}): AffectedRoots {
+  const root = resolve(cwd);
+  const normalize = (file: string): string => file.replaceAll('\\', '/').replace(/^\.\//, '');
+  const read = (file: string): string | { failure: string } => {
+    try { return readFile(join(root, file)); }
+    catch (cause) { return { failure: `${file} 을 읽지 못했다: ${cause instanceof Error ? cause.message : String(cause)}` }; }
+  };
+  let listed: string[];
+  try { listed = listFiles(cwd).map(normalize); }
+  catch (cause) { return { failure: `소스 목록을 읽지 못했다: ${cause instanceof Error ? cause.message : String(cause)}` }; }
+  const available = new Set(listed);
+  const targets = new Set([...changed].map(normalize));
+  for (const file of targets) {
+    const content = read(file);
+    if (typeof content !== 'string') return content;
+  }
+  const importsByFile = new Map<string, Set<string>>();
+  const barrelsByTarget = new Map<string, Set<string>>();
+  const ambientRoots = new Set<string>();
+  let ignoredDynamic = 0;
+  const resolveImport = (file: string, specifier: string): { target?: string; ignored?: true; unresolved?: true } => {
+    if (!specifier.startsWith('.')) return { ignored: true };
+    const base = relative(root, resolve(root, dirname(file), specifier)).split(sep).join('/');
+    // The gate's tsconfig includes these roots. A relative import outside them
+    // cannot lead back to a changed gate source; asset imports are not TS
+    // source edges either.
+    if (!/^(?:src|scripts|test)\//.test(base) || /\.(?:css|json|svg|png|jpg|jpeg|webp|wasm)$/.test(base)) return { ignored: true };
+    const target = importCandidates(base).find((candidate) => available.has(candidate));
+    return target ? { target } : { unresolved: true };
+  };
+  for (const file of listed) {
+    const content = read(file);
+    if (typeof content !== 'string') return content;
+    let source: ts.SourceFile;
+    try { source = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true); }
+    catch (cause) { return { failure: `${file} AST 파싱 실패: ${cause instanceof Error ? cause.message : String(cause)}` }; }
+    const scanned = astImportSpecifiers(source);
+    if (scanned.failure) return { failure: scanned.failure };
+    if (suppliesAmbientTypes(source)) ambientRoots.add(file);
+    ignoredDynamic += scanned.ignoredDynamic;
+    const imports = new Set<string>();
+    for (const specifier of scanned.imports) {
+      if (!specifier.startsWith('.')) continue;
+      const resolved = resolveImport(file, specifier);
+      if (resolved.unresolved) return { failure: `${file} 의 리터럴 import ${specifier} 해석 실패` };
+      if (resolved.target) imports.add(resolved.target);
+    }
+    importsByFile.set(file, imports);
+    for (const specifier of reExportSpecifiers(source)) {
+      const resolved = resolveImport(file, specifier);
+      if (resolved.unresolved) return { failure: `${file} 의 리터럴 re-export ${specifier} 해석 실패` };
+      if (!resolved.target) continue;
+      const barrels = barrelsByTarget.get(resolved.target) ?? new Set<string>();
+      barrels.add(file);
+      barrelsByTarget.set(resolved.target, barrels);
+    }
+  }
+  if (ignoredDynamic) debug.log('typecheck.gate', 'nonliteral-import-ignored', { count: ignoredDynamic });
+  // A changed export can break an importer through any number of re-export
+  // barrels. Walk that chain to a fixed point, then include direct importers
+  // of each barrel. The visited set also terminates circular barrels.
+  const exported = new Set(targets);
+  const queue = [...targets];
+  while (queue.length) {
+    const target = queue.pop()!;
+    for (const barrel of barrelsByTarget.get(target) ?? []) {
+      if (exported.has(barrel)) continue;
+      exported.add(barrel);
+      queue.push(barrel);
+    }
+  }
+  const roots = new Set([...exported, ...ambientRoots]);
+  for (const [file, imports] of importsByFile) {
+    if ([...imports].some((target) => exported.has(target))) roots.add(file);
+  }
+  return { roots };
+}