elanous 0.2.27 → 0.2.28

package/src/self-dev/launch-preflight.ts

@@ -17,8 +17,10 @@
 //      ⛔ 그래도 관측·산출에는 «그대로» 남긴다 — 「지나갔다」와 「없었다」는 다른 값이다.
 
 import { execFileSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { isAbsolute, resolve } from 'node:path';
+import { closeSync, existsSync, lstatSync, openSync, readSync, statSync } from 'node:fs';
+import { dirname, isAbsolute, resolve, sep } from 'node:path';
+import { linesOutsideFencedCode } from '../self-implement/goal-author.js';
+import { declaredNewFilePaths } from '../self-implement/goal-new-paths.js';
 import { resolveLogTargets } from '../cli/logs-cli.js';
 import { debug } from '../debug/log.js';
 import { siblingTestPath, normalizePreexistingFailureObservedAt, normalizePreexistingFailureRecords, emitAskMarkerObservation, emittedAskMarkerObservations, setAskMarkerObserver } from './launch-preflight-text.js';
@@ -734,8 +736,9 @@ export interface AskPreflightOptions {
   readonly openPrsLimit?: number;
   /** 중단 런 원장 조회의 최대 반환 행 수. 상한 도달은 결과의 `truncated` 상태로 남는다. */
   readonly interruptedRunsLimit?: number;
-  /** ⛔ 저작 «전» 예비 검사용 — 주면 골 문서를 읽지 않고 이 경로로 판정한다(ask 힌트).
-   *  ⚠️ 이것은 «추정»이다. 정본은 저작된 골의 TRACED PATHS 이고 발사 직전에 다시 판정한다. */
+  /** ⛔ 저작 «전» 예비 검사용 — 충돌 판정에는 이 ask 힌트 경로를 쓴다.
+   *  골 파일이 이미 있으면 문서의 TRACED PATHS 는 별도로 읽어 누락을 검사한다.
+   *  ⚠️ 힌트는 «추정»이다. 정본은 저작된 골의 TRACED PATHS 이고 발사 직전에 다시 판정한다. */
   readonly pathsOverride?: readonly string[];
   /** 원 ask 경로와 최종 대상의 차이를 ask-outside-path 경고에 보인다. */
   readonly askOutsidePathHints?: readonly string[];
@@ -770,6 +773,78 @@ export interface AskPreflightDecision {
   readonly plannedBranchResolution?: PlannedBranchResolution;
 }
 
+/** OP #980: fragments kept by cleanup remain inspectable traced targets, including bare names. */
+function isFileShapedTracedPath(path: string): boolean {
+  return path.trim().length > 0 && (!/\s/.test(path) || path.includes('/'));
+}
+
+// Keep lexical `..`/`.` segments: resolving them first hides ENOTDIR behind a file parent.
+function tracedFsPath(path: string, root: string): string {
+  return isAbsolute(path) ? path : `${root}${root.endsWith(sep) ? '' : sep}${path}`;
+}
+
+function tracedPathExists(path: string, root: string): boolean {
+  try {
+    const target = tracedFsPath(path, root);
+    if (!statSync(target).isFile()) return false;
+    const fd = openSync(target, 'r');
+    try { readSync(fd, Buffer.alloc(1), 0, 1, 0); }
+    finally { closeSync(fd); }
+    return true;
+  }
+  catch { return false; }
+}
+
+function tracedPathIsFile(path: string, root: string): boolean {
+  try { return statSync(tracedFsPath(path, root)).isFile(); }
+  catch { return false; }
+}
+
+function tracedPathOccupation(path: string, root: string): 'occupied' | 'missing' | 'inaccessible' {
+  const target = tracedFsPath(path, root);
+  try { lstatSync(target); return 'occupied'; }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') return 'inaccessible';
+    for (let parent = dirname(target); parent !== dirname(parent); parent = dirname(parent)) {
+      try {
+        if (lstatSync(parent).isSymbolicLink()) {
+          try { statSync(parent); } catch { return 'inaccessible'; }
+        }
+      } catch (parentError) {
+        if ((parentError as NodeJS.ErrnoException).code !== 'ENOENT') return 'inaccessible';
+      }
+    }
+    return 'missing';
+  }
+}
+
+/** Remove only malformed TRACED PATHS fragments before the child reads the goal file again. */
+export function discardNonFileTracedPathItems(document: string, _root: string): { document: string; dropped: string[] } {
+  const dropped: string[] = [];
+  let inTracedPaths = false;
+  const outsideStarts = new Set(linesOutsideFencedCode(document).map((line) => line.start));
+  let offset = 0;
+  const lines = document.split('\n').flatMap((line) => {
+    const lineStart = offset;
+    offset += line.length + 1;
+    if (!outsideStarts.has(lineStart)) return [line];
+    const body = line.replace(/\r$/, '');
+    if (/^\s*##\s+TRACED PATHS\s*$/.test(body)) { inTracedPaths = true; return [line]; }
+    if (inTracedPaths && /^\s*#{1,6}\s/.test(body)) inTracedPaths = false;
+    if (!inTracedPaths) return [line];
+    const item = /^(\s*(?:[-*+]|\d+[.)])\s+)(.*)$/.exec(body);
+    if (!item) return [line];
+    // OP #980: a fragment with whitespace and no slash is prose; all other forms stay verbatim.
+    const fragments = item[2]!.split(' · ');
+    const kept = fragments.filter((fragment) => !(/\s/.test(fragment.trim()) && !fragment.includes('/')));
+    if (kept.length === fragments.length) return [line];
+    if (kept.length === 0) { dropped.push(line); return []; }
+    dropped.push(line);
+    return [`${item[1]}${kept.join(' · ')}${line.endsWith('\r') ? '\r' : ''}`];
+  });
+  return { document: lines.join('\n'), dropped };
+}
+
 /** 인자 검증 — ⛔ 잘못된 값을 «조용히» 기본값으로 바꾸지 않는다(리뷰 should-fix). */
 /** ⛔ 기본값은 «내부 상수»다 — 아무도 안 넘기는 인자를 계약 표면으로 두지 않는다(리뷰 must-fix). */
 export const DEFAULT_LIVE_RUN_WINDOW_MINUTES = 30;
@@ -1001,20 +1076,48 @@ export function decideAskPreflight(
 ): AskPreflightDecision {
   const limit = opts.openPrsLimit ?? 200;
   const interruptedRunsLimit = resolveInterruptedRunsLimit(opts.interruptedRunsLimit);
-  // ⛔⭐ 「저작 전 예비 검사」 경로 — 골 파일이 «아직 없다». 그때는 ask 힌트를 대상 경로로 쓴다.
-  //   ⚠️ 골 문서를 읽지 «않는다» — 없는 파일을 읽으려 하면 여기서 던져 저작 자체가 막힌다.
+  // pathsOverride is an independent pre-authoring inspection, even if a stale goal file exists.
   let goalDocument: string | null = null;
   let goalRulersUnknownReason: string | undefined;
+  let goalReadFailed = false;
+  const resolvedGoalFile = opts.declaredPathsRoot?.trim() && !isAbsolute(opts.goalFile)
+    ? resolve(opts.declaredPathsRoot, opts.goalFile)
+    : opts.goalFile;
   if (!opts.pathsOverride) {
     try {
-      goalDocument = deps.readGoalDocument(opts.goalFile);
+      goalDocument = deps.readGoalDocument(resolvedGoalFile);
     } catch (error) {
+      goalReadFailed = true;
       goalRulersUnknownReason = `골 문서 판독 불가: ${error instanceof Error ? error.message.split('\n')[0] : String(error)}`;
     }
   } else {
     goalRulersUnknownReason = '저작 전 예비 검사에는 골 문서가 없다';
   }
-  const tracedPaths = opts.pathsOverride ?? (goalDocument === null ? [] : deps.tracedPaths(goalDocument));
+  // Resolve against the caller's root, but keep injected virtual goal documents out of
+  // filesystem checks when no authored file exists there.
+  const hasAuthoredGoal = !opts.pathsOverride && opts.goalFile !== '' && goalDocument !== null
+    && existsSync(resolvedGoalFile);
+  const authoredTracedPaths = goalDocument === null ? [] : deps.tracedPaths(goalDocument);
+  const tracedPathsRaw = opts.pathsOverride ?? authoredTracedPaths;
+  const inspectionRoot = goalDocument === null || !hasAuthoredGoal
+    ? undefined
+    : opts.declaredPathsRoot?.trim() || process.cwd();
+  const tracedPaths = inspectionRoot && !opts.pathsOverride
+    ? tracedPathsRaw.filter((path) => tracedPathExists(path, inspectionRoot) || isFileShapedTracedPath(path))
+    : tracedPathsRaw;
+  const declaredNewPaths = goalDocument === null ? new Set<string>() : new Set(declaredNewFilePaths(goalDocument));
+  const invalidTracedPaths: Array<{ path: string; reason: 'occupied-new' | 'not-file' | 'missing' | 'inaccessible' }> = inspectionRoot
+    ? authoredTracedPaths.flatMap<{ path: string; reason: 'occupied-new' | 'not-file' | 'missing' | 'inaccessible' }>((path) => {
+      const occupation = tracedPathOccupation(path, inspectionRoot);
+      if (!isFileShapedTracedPath(path) && occupation !== 'occupied') return [];
+      const isDeclaredNew = declaredNewPaths.has(path.replace(/^\.\//, ''));
+      if (isDeclaredNew) return occupation === 'missing' ? [] : [{ path, reason: occupation === 'occupied' ? 'occupied-new' as const : 'inaccessible' as const }];
+      if (tracedPathExists(path, inspectionRoot)) return [];
+      return [{ path, reason: occupation === 'occupied'
+        ? (tracedPathIsFile(path, inspectionRoot) ? 'inaccessible' as const : 'not-file' as const)
+        : occupation }];
+    })
+    : [];
   let premiseMockedBySignal: number | null = null;
   let invariantFunctionExits: number | null = null;
   if (goalDocument !== null) {
@@ -1197,11 +1300,41 @@ export function decideAskPreflight(
     ...(interruptedRunsUnknownReason ? { interruptedRunsUnknownReason } : {}),
     ...(recentChangesUnknownReason ? { recentChangesUnknownReason } : {}),
   });
-  const decisionResult = { ...result, warnings: [...result.warnings, ...askMarkerWarnings], runningRunsConfidenceAppendix: runningRunsConfidence.appendix };
+  const missingTracedPathBlockers: LaunchPreflightBlocker[] = [
+    ...(hasAuthoredGoal && authoredTracedPaths.length === 0 ? [{
+      kind: 'missing-traced-path' as const,
+      name: '최종 골의 TRACED PATHS 경로 0',
+      detail: '정리 후 보존된 traced 경로가 없다 — 실제 파일 또는 유효한 신설: 파일 경로를 골에 선언해야 발사할 수 있다',
+    }] : []),
+    ...invalidTracedPaths.map(({ path, reason }) => ({
+      kind: 'missing-traced-path' as const,
+      name: reason === 'occupied-new' ? `신설 traced path 가 이미 점유됨: ${path}`
+        : reason === 'not-file' ? `traced path 가 파일이 아님: ${path}`
+          : reason === 'inaccessible' ? `traced path 경로 접근 불가: ${path}` : `실재하지 않는 traced path: ${path}`,
+      detail: reason === 'occupied-new'
+        ? `골의 신설: 경로 ${path} 가 이미 파일·디렉터리·링크로 점유돼 있다 — 새 파일 경로를 바로잡아야 한다`
+        : reason === 'not-file'
+          ? `골의 TRACED PATHS 경로 ${path} 가 존재하지만 읽을 수 있는 파일이 아니다 — 파일 경로를 바로잡아야 한다`
+          : reason === 'inaccessible'
+            ? `골의 TRACED PATHS 경로 ${path} 를 검사할 수 없다 — 부모가 파일이거나 접근 권한이 없다. 경로를 바로잡아야 한다`
+            : `골의 TRACED PATHS 에 선언됐지만 ${inspectionRoot} 에 없고 유효한 신설: 목록에도 없다 — 발사 전에 골 경로를 바로잡아야 한다. 신설은 파일 경로로(확장자 포함) 선언한다`,
+    })),
+  ];
+  const goalReadBlockers: LaunchPreflightBlocker[] = goalReadFailed ? [{
+    kind: 'goal-unreadable',
+    name: `골 문서 판독 불가: ${opts.goalFile}`,
+    detail: `${goalRulersUnknownReason} — 최종 골의 traced path 를 확인할 수 없어 발사를 멈춘다`,
+  }] : [];
+  const decisionResult = {
+    ...result,
+    blockers: [...result.blockers, ...missingTracedPathBlockers, ...goalReadBlockers],
+    warnings: [...result.warnings, ...askMarkerWarnings],
+    runningRunsConfidenceAppendix: runningRunsConfidence.appendix,
+  };
   emittedAskMarkerObservations.add(decisionResult);
   return {
     result: decisionResult,
-    shouldLaunch: result.blockers.length === 0 || force,
+    shouldLaunch: missingTracedPathBlockers.length === 0 && goalReadBlockers.length === 0 && (result.blockers.length === 0 || force),
     plannedBranchResolution,
   };
 }

package/src/self-implement/gate-cli.ts

@@ -426,6 +426,7 @@ function changedTestCountNote(
 
 const IMPORTER_GREP_PATHS = ['*.test.ts', '*.test.tsx', '*.test.mts', '*.test.mtsx', '*.test.cts', '*.test.ctsx', '*.test.js', '*.test.jsx', '*.test.mjs', '*.test.mjsx', '*.test.cjs', '*.test.cjsx'];
 const SOURCE_PATH_RE = /^src\/.+\.(?:[cm]?[jt]sx?)$/;
+const SCRIPT_SOURCE_PATH_RE = /^scripts\/.+\.(?:[cm]?[jt]sx?)$/;
 const SOURCE_FILE_RE = /\.(?:[cm]?[jt]sx?)$/;
 
 function buildGateImporterTestIndex(
@@ -433,7 +434,7 @@ function buildGateImporterTestIndex(
   cwd: string,
   runCommand: SelfGateCliDeps['runCommand'],
 ): ImporterTestIndex | null | { readonly lookupFailed: string } {
-  const sources = changed.filter((path) => SOURCE_PATH_RE.test(path) && !isTestPath(path));
+  const sources = changed.filter((path) => (SOURCE_PATH_RE.test(path) || SCRIPT_SOURCE_PATH_RE.test(path)) && !isTestPath(path));
   if (sources.length === 0) return null;
   const result = (runCommand ?? defaultRunCommand)('git', ['grep', '-l', '-e', '', '--', ...IMPORTER_GREP_PATHS], cwd);
   if ((result.status !== 0 && result.status !== 1) || result.error) {
@@ -596,7 +597,10 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
   if (options.shards !== undefined && (!Number.isSafeInteger(options.shards) || options.shards < 1)) throw new Error('invalid --shards count');
   const selection = (deps.changedFiles ?? ((dir, input) => defaultChangedFiles(dir, input, deps.runCommand)))(cwd, options);
   const exists = deps.exists ?? ((path) => existsSync(`${cwd}/${path}`));
-  const importerIndex = buildGateImporterTestIndex(selection.files, cwd, deps.runCommand);
+  // Caller: src/release-loop/light-rc.ts runLightRc → runSelfGateCli(dir, { ..., includeImporterTests: true }).
+  // scripts/ joins the existing importer index only for that opt-in path.
+  const importerIndex = buildGateImporterTestIndex(options.includeImporterTests
+    ? selection.files : selection.files.filter((path) => !SCRIPT_SOURCE_PATH_RE.test(path)), cwd, deps.runCommand);
   const lookupFailed = importerIndex && 'lookupFailed' in importerIndex ? importerIndex.lookupFailed : undefined;
   const availableIndex = importerIndex && !('lookupFailed' in importerIndex) ? importerIndex : undefined;
   const routeIndex = availableIndex?.testPaths

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

@@ -1701,7 +1701,8 @@ export function lintGoalFile(document: string, branch: string, deps: GoalFileLin
   }
   if (deps.readReferencedFile) {
     // AUTHOR-NEW-FILE-PATHS — 문서가 «새로 만들 파일»로 선언한 경로. 실행 쪽 범위 검사와 같은 줄을 읽는다.
-    const declaredNew = new Set(declaredNewFilePaths(document));
+    // 저작과 실행은 같은 Original ask 범위만 선언으로 인정한다. 문서의 다른 절은 근거일 뿐이다.
+    const declaredNew = new Set(declaredNewFilePaths(extractVerbatimOriginalAsk(document)?.ask ?? ''));
     for (const reference of tracedPathReferences(document)) {
       const result = deps.readReferencedFile(reference.path);
       const normalized = typeof result === 'string' ? { kind: 'ok' as const, contents: result }

package/src/self-implement/goal-new-paths.ts

@@ -1,13 +1,12 @@
 /**
  * ⭐ AUTHOR-NEW-FILE-PATHS — 저작 골 문서가 «새로 만들 파일»로 선언한 경로.
  *
- * 저작(TRACED PATHS 존재 검사)과 실행(orchestrator 범위 검사)이 **같은 줄**을 읽어야
- * 저작 통과·실행 보류가 다시 갈리지 않는다(TC 13:50). 줄 인식은 실행 쪽
- * src/self-implement/orchestrator.ts 의 DECLARED_NEW_FILES_LINE 와 같은 꼴을 쓴다.
+ * 저작(TRACED PATHS 존재 검사)과 실행(orchestrator 범위 검사)이 **같은 함수**로
+ * 신설 경로를 읽어야 저작 통과·실행 보류가 다시 갈리지 않는다(TC 13:50).
  */
 
 // SCOPE-NEW-FILES-LINE — 칸 문면은 새로 만들 파일을 «신설:» 줄로 따로 적는다(OP D칸 규칙).
-//    orchestrator.ts 의 DECLARED_NEW_FILES_LINE 와 같은 정규식이다(한쪽만 읽으면 저작과 실행이 갈린다).
+//    저작과 실행이 이 함수를 공유한다(한쪽만 읽으면 저작과 실행이 갈린다).
 export const DECLARED_NEW_FILES_LINE = /^\s*(?:신설|new\s*files?)\s*[:：]\s*(.*)$/i;
 
 /** 목록 기호 «- »·굵게 «**» 는 장식이다 — 그것만 벗기고 같은 정규식으로 문는다. */
@@ -32,7 +31,7 @@ export function declaredNewFilePaths(document: string): string[] {
     const match = DECLARED_NEW_FILES_LINE.exec(bareDeclarationLine(rawLine));
     if (!match) continue;
     for (const fragment of match[1]!.split(/[·,]/)) {
-      // 실행 쪽 범위 검사(parseDeclaredTargetPathsFromAsk)와 같은 정규화 — 등 코드, ./ 접두.
+      // 저작·실행 공통 정규화 — 등 코드, ./ 접두.
       const piece = fragment.trim().replace(/^`+|`+$/g, '').replace(/\\/g, '/').replace(/^\.\//, '');
       if (!isRepositoryFileCandidate(piece)) continue;
       paths.push(piece);

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)])];
@@ -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 } : {}),