elanous 0.2.27 → 0.2.29

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

@@ -1,7 +1,7 @@
 import { classifyObservation } from '../design/behaviour-signal.js';
 import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync, type Dirent } from 'node:fs';
 import { spawn } from 'node:child_process';
-import { createHash, randomBytes } from 'node:crypto';
+import { randomBytes } from 'node:crypto';
 import { dirname, isAbsolute, join, normalize, relative, resolve, sep } from 'node:path';
 import { isRepositoryImplementationCandidate, type CodebaseGrounding } from '../autopilot/codebase-grounding.js';
 import { extractSlugSource, generateMissionSlug, slugify } from '../autopilot/mission-registry.js';
@@ -41,7 +41,9 @@ import { resolveGoalAuthorClarification, parseGoalDocumentClarifications, serial
 import { acquireLockSync } from '../storage/file-lock.js';
 import { createRepositoryReferencedFileReader, type ReferencedFileReadResult } from './goal-file-reader.js';
 import { extractGoalDocSections, type GoalDocSourceLine } from './goal-doc/section.js';
-import { isGoalAuthorFileName } from './goal-document.js';
+import { buildGoalFileName, goalFileName, type GoalFileNameSource } from './goal-file-name.js';
+export { goalFileName } from './goal-file-name.js';
+export type { GoalFileNameSource } from './goal-file-name.js';
 import { resolveGoalDocumentsDir } from './goal-documents-dir.js';
 import { REQUIRED_EVIDENCE_COMMAND_SEPARATOR } from './off-diff-evidence.js';
 import { renderLaunchPreflight, siblingTestPath, type LaunchPreflightResult } from '../self-dev/launch-preflight-text.js';
@@ -792,10 +794,14 @@ export type ArtifactLaunchDeclarationClassification = 'declared' | 'absent-witho
 const SERVER_ENTRY_PATH = /(?:^|\/)server[^/]*\.(?:[cm]?[jt]sx?)$/i;
 const LOOPBACK_ADDRESS_WITH_PORT = /(?<![\p{L}\p{N}.-])(?:localhost|127\.0\.0\.1|\[::1\])(?::\d+)(?![\p{L}\p{N}_])/iu;
 
+function targetPathsInLabelPiece(piece: string): string[] {
+  return askPathTokens(piece).filter((path) => path.includes('/'));
+}
+
 function declaredTargetPaths(document: string): string[] {
   return linesOutsideFencedCode(document).flatMap(({ text }) => {
     const match = TARGET_PATH_LABEL.exec(text.trim());
-    return match ? askPathTokens(match[1]) : [];
+    return match ? match[1].split(/\s+[·,]\s*|[·,]\s+/).flatMap(targetPathsInLabelPiece) : [];
   });
 }
 
@@ -1303,6 +1309,8 @@ function isTracedPathsEvidenceUnavailable(entry: string): boolean {
 const TRACED_PATH_LINE = /^(.*?)(?::(\d+)(?:-(\d+))?)?$/;
 const INLINE_CODE_WRAPPED = /^(`+)([^`]*)\1$/;
 const TRACED_PATH_DESCRIPTION_DELIMITER = /\s+(?:—|-)\s+|:\s+/;
+/** Read tool output annotations are prose, never part of a repository path. */
+const TRACED_PATH_READ_ANNOTATION = /\s+\(Read,\s*\d+\s+lines?\)\s*$/i;
 /** 저작기가 「관련 있어 보이지만 여기가 아니다」를 말하려고 적은 항목 — 추적 경로가 아니다.
  *  ⚠️ 지금은 영어 문면만 문다(저작기 산출이 영어다). 한국어 배제 문장은 아직 안 잡는다. */
 const TRACED_PATH_EXCLUSION_DESCRIPTION = /\b(?:related|relevant)\b.*\b(?:but|however)\b.*\b(?:not here|elsewhere|another (?:location|place|path))\b|\b(?:not here|elsewhere|another (?:location|place|path))\b.*\b(?:related|relevant)\b/i;
@@ -1347,10 +1355,11 @@ export function tracedPathReferences(document: string): TracedPathReference[] {
   const section = markdownSection(document, 'TRACED PATHS');
   if (!section) return [];
   const references: TracedPathReference[] = [];
+  let normalizedAnnotationCount = 0;
   for (const line of section.split(/\r?\n/)) {
     const evidence = tracedPathListItem(line);
     if (!evidence) continue;
-    if (isTracedPathsEvidenceUnavailable(evidence) || isTracedPathExclusionDescription(evidence)) continue;
+    if (isTracedPathsEvidenceUnavailable(evidence) || evidence.startsWith('미해석:') || isTracedPathExclusionDescription(evidence)) continue;
     // 설명 구분자는 **공백으로 둘러싼** em dash 또는 hyphen 뿐이다 — 파일명 안의 dash 를 설명 구분자로 오인하지 않는다.
     // 경로 칸 안의 복수 경로는 **공백으로 둘러싼** 가운뎃점만 본다 — 파일명 안의 `·` 를 가르지 않는다.
     // ⭐ 인라인 코드 표기(`path`)를 벗긴다 — 저작기는 맨 경로를 쓰지만 사람이 쓴 골과 이 레포의 다른 문서는
@@ -1361,7 +1370,9 @@ export function tracedPathReferences(document: string): TracedPathReference[] {
       if (!trimmed) continue;
       // 10-11 재발 — 저작기가 «`- src/…`» 처럼 목록 기호를 백틱 «안»에 쓰면 바깥 기호만 벗긴 뒤 백틱을 벗겨
       //   «- src/…» 가 경로로 남았다(AUTHOR-DECOMPOSE-KNOB · MODEL-BENCH-SCORES 부검). 백틱을 벗긴 뒤 한 번 더 벗긴다.
-      const unwrapped = stripInlineCode(trimmed).replace(TRACED_PATH_LEADING_LIST_MARKERS, '');
+      const withoutAnnotation = trimmed.replace(TRACED_PATH_READ_ANNOTATION, '').trim();
+      if (withoutAnnotation !== trimmed) normalizedAnnotationCount += 1;
+      const unwrapped = stripInlineCode(withoutAnnotation).replace(TRACED_PATH_LEADING_LIST_MARKERS, '');
       const match = TRACED_PATH_LINE.exec(unwrapped);
       // 두 번 벗긴다 — 줄번호가 백틱 **안**(`p:42`)일 수도 **밖**(`p`:42)일 수도 있다.
       const path = match ? stripInlineCode(match[1].trim()).replace(TRACED_PATH_LEADING_LIST_MARKERS, '') : undefined;
@@ -1369,6 +1380,10 @@ export function tracedPathReferences(document: string): TracedPathReference[] {
       references.push({ path, line: match?.[2] ? Number(match[2]) : null, endLine: match?.[3] ? Number(match[3]) : null });
     }
   }
+  if (normalizedAnnotationCount > 0) {
+    try { debug.log('goal-author', 'traced-path-annotation-normalized', { count: normalizedAnnotationCount }); }
+    catch { /* observation must not prevent path validation */ }
+  }
   return references;
 }
 
@@ -1699,9 +1714,16 @@ export function lintGoalFile(document: string, branch: string, deps: GoalFileLin
         : `${unavailableTracedPathEvidence} GoalType ${goalType} does not require ## TRACED PATHS.`,
     });
   }
+  const unresolvedTracedPathEvidence = markdownSection(document, 'TRACED PATHS')?.split(/\r?\n/)
+    .map((line) => tracedPathListItem(line))
+    .filter((item): item is string => item !== undefined && item.startsWith('미해석:')) ?? [];
+  for (const item of unresolvedTracedPathEvidence) {
+    findings.push({ level: 'WARN', tag: 'traced-path', message: item });
+  }
   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 }
@@ -2276,11 +2298,94 @@ function observePersistentEvidenceSourceKinds(facts: CodebaseGrounding | null, a
   observeGoalAuthor('goal-author', 'persistent-grounding-evidence-source-count', { authorRunId, counts });
 }
 
-function tracedPathsSection(facts: CodebaseGrounding | null, unavailableEvidence: string): string[] {
+function tracedPathsSection(facts: CodebaseGrounding | null, ask: string, repositoryRoot: string | undefined, unavailableEvidence: string): string[] {
   const evidence = persistentEvidenceItems(facts);
-  return evidence.length
-    ? evidence.map(({ text, source }, index) => `${index + 1}. ${renderPersistentEvidence({ text, source })}`)
-    : [`- ${unavailableEvidence}`];
+  // Without a repository root we cannot verify paths. Keep the established
+  // rendering contract for callers that do not supply one.
+  if (repositoryRoot === undefined) {
+    const legacyPaths: string[] = [];
+    for (const item of evidence) {
+      const referenced = [...new Set(Array.from(item.text.matchAll(SOURCE_PATH), (match) => match[0]))]
+        .filter(isRepositoryImplementationCandidate);
+      if (referenced.length === 0 || (referenced.length === 1 && item.text.trim().startsWith(referenced[0]!))) {
+        legacyPaths.push(`${legacyPaths.length + 1}. ${renderPersistentEvidence(item)}`);
+        continue;
+      }
+      referenced.forEach((path, index) => legacyPaths.push(`${legacyPaths.length + 1}. ${path}${index === 0 ? ` — ${renderPersistentEvidence(item)}` : ''}`));
+    }
+    return legacyPaths.length ? legacyPaths : [`- ${unavailableEvidence}`];
+  }
+  const paths: string[] = [];
+  const declaredNew = new Set(declaredNewFilePaths(ask));
+  const targetLabels = linesOutsideFencedCode(ask)
+    .map(({ text }) => /^대상 경로:\s*(.*)$/.exec(text.trim())?.[1])
+    .filter((value): value is string => value !== undefined);
+  const unresolvedTargetPieces = targetLabels.flatMap((label) => label.split(/\s+[·,]\s*|[·,]\s+/))
+    .flatMap((piece) => {
+      const tokens = piece.trim().split(/\s+/).filter(Boolean);
+      return tokens.length === 0 ? ['(빈 대상 경로)'] : tokens.filter((token) => targetPathsInLabelPiece(token).length === 0);
+    });
+  const labeledTargets = declaredTargetPaths(ask);
+  const scopedAskPaths = [...new Set(askPathTokens(targetScopedGoalText(ask)).filter((path) => path.includes('/')))];
+  // A single repository path in an ask without a target label is still an explicit target.
+  // Multiple mentions are ambiguous; do not turn background references into targets.
+  const requestedTargets = targetLabels.length ? labeledTargets : scopedAskPaths.length === 1 ? scopedAskPaths : [];
+  const known = [...new Set([
+    ...requestedTargets, ...scopedAskPaths, ...(facts?.files ?? []),
+    ...evidence.flatMap((item) => Array.from(item.text.matchAll(SOURCE_PATH), (match) => match[0]).filter((path) => path.includes('/'))),
+  ])];
+  let root: string | null;
+  try { root = repositoryRoot === undefined ? null : realpathSync(resolve(repositoryRoot)); }
+  catch { root = null; }
+  const valid = (path: string, allowDeclaredNew: boolean): boolean => {
+    if (!path.includes('/') || isAbsolute(path) || path.split('/').some((part) => part === '..' || part === '.')) return false;
+    if (root === null) return false;
+    if (allowDeclaredNew && declaredNew.has(path) && isSafeNewTargetPath(path, root)) return true;
+    try {
+      const real = realpathSync(resolve(root, path));
+      return isSameOrNestedPath(real, root) && lstatSync(real).isFile();
+    } catch { return false; }
+  };
+  const resolvePath = (path: string, declaredTarget = false): string | null => {
+    if (declaredTarget) return valid(path, true) ? path : null;
+    if (path.includes('/') && valid(path, true)) return path;
+    if (path.includes('/')) return null;
+    const matches = known.filter((candidate) => candidate.endsWith(`/${path}`) && valid(candidate, false));
+    return matches.length === 1 ? matches[0]! : null;
+  };
+  const added = new Map<string, number>();
+  const addPath = (path: string, description?: string): void => {
+    const existing = added.get(path);
+    if (existing !== undefined) {
+      if (description !== undefined) paths[existing] += ` — ${description}`;
+      return;
+    }
+    added.set(path, paths.length);
+    paths.push(`${paths.length + 1}. ${path}${description === undefined ? '' : ` — ${description}`}`);
+  };
+  for (const path of requestedTargets) {
+    const resolved = resolvePath(path, true);
+    if (resolved) addPath(resolved);
+    else paths.push(`${paths.length + 1}. 미해석: ${path} — 요청에 선언된 대상 경로를 저장소 파일 또는 명시적 신설 파일로 확인하지 못함`);
+  }
+  for (const piece of unresolvedTargetPieces) {
+    paths.push(`${paths.length + 1}. 미해석: ${piece} — 요청에 선언된 대상 경로를 파싱하지 못함`);
+  }
+  for (const item of evidence) {
+    const referenced = [...new Set(Array.from(item.text.matchAll(SOURCE_PATH), (match) => match[0]))]
+      .filter(isRepositoryImplementationCandidate);
+    if (referenced.length === 0) {
+      paths.push(`${paths.length + 1}. 미해석: ${renderPersistentEvidence(item)} — 경로가 없는 접지 근거`);
+      continue;
+    }
+    referenced.forEach((path, index) => {
+      const resolved = resolvePath(path);
+      if (resolved) addPath(resolved, index === 0 ? renderPersistentEvidence(item) : undefined);
+      else paths.push(`${paths.length + 1}. 미해석: ${path} — ${renderPersistentEvidence(item)}`);
+    });
+  }
+  if (evidence.length === 0) paths.push(`- ${unavailableEvidence}`);
+  return paths;
 }
 
 const IDENTITY_PREFIX = /^(agent|session|submitted|authored-by|track|roadmap):/i;
@@ -5536,7 +5641,7 @@ async function authorGoalWithSupersededRootIntent(
     '## REQUIRED EVIDENCE',
     ...requiredEvidence(criteria, facts ? implementationCandidates(facts) : [], authorRunId),
     '',
-    ...(goalType === 'implement' ? ['## TRACED PATHS', ...tracedPathsSection(facts, narrative.tracedPathsUnavailableEvidence), ''] : []),
+    ...(goalType === 'implement' ? ['## TRACED PATHS', ...tracedPathsSection(facts, ask, deps.repositoryRoot, narrative.tracedPathsUnavailableEvidence), ''] : []),
     '## SCOPE BOUNDARY',
     ...scopeBoundarySection,
     '',
@@ -5722,23 +5827,8 @@ export function defaultGoalAuthorDeps(cwd: string): GoalAuthorDeps {
   };
 }
 
-const MAX_FILENAME_BYTES = 255;
-// Goal files are listed and reviewed in ASCII-only terminals, so keep the meaningful
-// prefix portable and short even when the request title is Korean.
-const MAX_GOAL_SLUG_BYTES = 64;
-const GOAL_FINGERPRINT_LENGTH = 8;
 const IDENTITY_LINE = /^(agent|track|session|submitted):\s*(.*?)\s*$/i;
 
-function localDate(now: Date): string {
-  return [now.getFullYear(), String(now.getMonth() + 1).padStart(2, '0'), String(now.getDate()).padStart(2, '0')].join('-');
-}
-
-function asciiGoalSlug(title: string): string {
-  return title.normalize('NFKC').toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-}
-
 function missionSlugFallback(goal: string): string {
   return slugify(extractSlugSource(goal));
 }
@@ -5751,32 +5841,6 @@ async function goalSlug(goal: string, slugFn: (goal: string) => Promise<string>)
   }
 }
 
-function slugWithinUtf8Budget(normalizedSlug: string, byteBudget: number): string {
-  let slug = '';
-  let bytes = 0;
-  const graphemes = new Intl.Segmenter(undefined, { granularity: 'grapheme' }).segment(normalizedSlug);
-  for (const { segment } of graphemes) {
-    const segmentBytes = Buffer.byteLength(segment, 'utf8');
-    if (bytes + segmentBytes > byteBudget) break;
-    slug += segment;
-    bytes += segmentBytes;
-  }
-  return slug.replace(/-+$/g, '');
-}
-
-function goalFingerprint(source: string): string {
-  return createHash('sha256').update(source, 'utf8').digest('hex').slice(0, GOAL_FINGERPRINT_LENGTH);
-}
-
-export interface GoalFileNameSource {
-  /** Human-readable generated goal title used for the ASCII slug. */
-  title: string;
-  /** Complete generated artifact used to distinguish semantically different results from one ask. */
-  document: string;
-  /** Repository identifiers from the original ask, retained before a generated title slug. */
-  repositoryIdentifiers?: readonly string[];
-}
-
 function repositoryIdentifiers(ask: string): string[] {
   const lines = ask.split(/\r?\n/);
   const metadata = leadingIdentityMetadata(ask);
@@ -5789,27 +5853,6 @@ function repositoryIdentifiers(ask: string): string[] {
     .match(/[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*/g) ?? [];
 }
 
-function buildGoalFileName(source: GoalFileNameSource, now: Date, collisionSuffix = ''): string {
-  const date = localDate(now);
-  const fingerprint = goalFingerprint(source.document);
-  const fixed = `GOAL--${fingerprint}${collisionSuffix}-${date}.md`;
-  const byteBudget = Math.min(
-    MAX_GOAL_SLUG_BYTES,
-    MAX_FILENAME_BYTES - Buffer.byteLength(fixed, 'utf8'),
-  );
-  const identifierPrefix = source.repositoryIdentifiers?.map(asciiGoalSlug).filter(Boolean).join('-');
-  const titleSlug = asciiGoalSlug(source.title);
-  const slug = slugWithinUtf8Budget([identifierPrefix, titleSlug].filter(Boolean).join('-'), byteBudget) || 'goal';
-  return `GOAL-${slug}-${fingerprint}${collisionSuffix}-${date}.md`;
-}
-
-/** Single filename contract shared by helper callers and the filesystem writer. */
-export function goalFileName(source: GoalFileNameSource, now: Date): string {
-  const fileName = buildGoalFileName(source, now);
-  if (!isGoalAuthorFileName(fileName)) throw new Error(`goal filename violates document contract: ${fileName}`);
-  return fileName;
-}
-
 function leadingIdentityMetadata(ask: string): Map<string, string> {
   const lines = ask.split(/\r?\n/);
   let candidates: string[] = [];

package/src/self-implement/goal-authoring-grounding.ts

@@ -11,7 +11,7 @@ const MAX_MEMORY_ITEMS = 5;
 const MAX_EXTERNAL_SOURCES = 3;
 const LOCAL_REFERENCE_CANDIDATES = [
   'openclaw', 'codex', 'hermess', 'hermes', 'hermes-agent',
-  'claude', 'claude-code-fork', 'grok', 'grok-cli', 'grok-build',
+  'claude', 'grok', 'grok-cli', 'grok-build',
 ] as const;
 
 export interface GoalAuthoringExternalSource {

package/src/self-implement/goal-file-name.ts

@@ -0,0 +1,65 @@
+import { createHash } from 'node:crypto';
+import { isGoalAuthorFileName } from './goal-document.js';
+
+const MAX_FILENAME_BYTES = 255;
+// Goal files are listed and reviewed in ASCII-only terminals, so keep the meaningful
+// prefix portable and short even when the request title is Korean.
+const MAX_GOAL_SLUG_BYTES = 64;
+const GOAL_FINGERPRINT_LENGTH = 8;
+
+function localDate(now: Date): string {
+  return [now.getFullYear(), String(now.getMonth() + 1).padStart(2, '0'), String(now.getDate()).padStart(2, '0')].join('-');
+}
+
+function asciiGoalSlug(title: string): string {
+  return title.normalize('NFKC').toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+function slugWithinUtf8Budget(normalizedSlug: string, byteBudget: number): string {
+  let slug = '';
+  let bytes = 0;
+  const graphemes = new Intl.Segmenter(undefined, { granularity: 'grapheme' }).segment(normalizedSlug);
+  for (const { segment } of graphemes) {
+    const segmentBytes = Buffer.byteLength(segment, 'utf8');
+    if (bytes + segmentBytes > byteBudget) break;
+    slug += segment;
+    bytes += segmentBytes;
+  }
+  return slug.replace(/-+$/g, '');
+}
+
+function goalFingerprint(source: string): string {
+  return createHash('sha256').update(source, 'utf8').digest('hex').slice(0, GOAL_FINGERPRINT_LENGTH);
+}
+
+export interface GoalFileNameSource {
+  /** Human-readable generated goal title used for the ASCII slug. */
+  title: string;
+  /** Complete generated artifact used to distinguish semantically different results from one ask. */
+  document: string;
+  /** Repository identifiers from the original ask, retained before a generated title slug. */
+  repositoryIdentifiers?: readonly string[];
+}
+
+export function buildGoalFileName(source: GoalFileNameSource, now: Date, collisionSuffix = ''): string {
+  const date = localDate(now);
+  const fingerprint = goalFingerprint(source.document);
+  const fixed = `GOAL--${fingerprint}${collisionSuffix}-${date}.md`;
+  const byteBudget = Math.min(
+    MAX_GOAL_SLUG_BYTES,
+    MAX_FILENAME_BYTES - Buffer.byteLength(fixed, 'utf8'),
+  );
+  const identifierPrefix = source.repositoryIdentifiers?.map(asciiGoalSlug).filter(Boolean).join('-');
+  const titleSlug = asciiGoalSlug(source.title);
+  const slug = slugWithinUtf8Budget([identifierPrefix, titleSlug].filter(Boolean).join('-'), byteBudget) || 'goal';
+  return `GOAL-${slug}-${fingerprint}${collisionSuffix}-${date}.md`;
+}
+
+/** Single filename contract shared by helper callers and the filesystem writer. */
+export function goalFileName(source: GoalFileNameSource, now: Date): string {
+  const fileName = buildGoalFileName(source, now);
+  if (!isGoalAuthorFileName(fileName)) throw new Error(`goal filename violates document contract: ${fileName}`);
+  return fileName;
+}

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/ground-goal.ts

@@ -45,7 +45,8 @@ export async function groundGoalInCodebase(goalText: string, deps: GroundGoalDep
     );
     const persistentElapsedMs = performance.now() - persistentStartedAt;
     if (!persistent?.files.length) {
-      safeObserve('empty', { cwd: deps.cwd, reason: persistent ? 'no-candidates' : 'failed-or-no-candidates', candidates: 0 });
+      safeObserve('empty', { cwd: deps.cwd, reason: persistent ? 'no-candidates' : 'failed-or-no-candidates',
+        persistentStopReason: persistent?.stopReason ?? null, candidates: 0 });
       return '';
     }
     const renderingStartedAt = performance.now();

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 {