elanous 0.2.28 → 0.2.31

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';
@@ -478,6 +480,69 @@ export function linesOutsideFencedCode(document: string): GoalDocSourceLine[] {
   return outside;
 }
 
+/** TA 완료 경계는 기존 정식 절 안의 세 독립 행이다. 원문에 없는 값을 저작기가 만들지 않는다. */
+export const GOAL_DONE_BOUNDARY_LABELS = ['완료 경계 코드', '완료 경계 실물', '완료 경계 증거 명령'] as const;
+export type GoalDoneBoundaryLabel = typeof GOAL_DONE_BOUNDARY_LABELS[number];
+// This is a declaration check, not a judgement of whether the proposed work
+// is good. Remove only presentation marks before comparing known placeholders.
+const GOAL_DONE_EMPTY_VALUES = new Set(['', 'na', 'ok', 'yes', 'pass', 'done', '완료', '확인']);
+const GOAL_DONE_UNRESOLVED_PREFIXES = ['tbd', 'todo', 'unknown', 'notdeclared', 'notavailable', '미정', '추후', '없음'];
+
+function isGoalDonePlaceholder(value: string): boolean {
+  const normalized = value.normalize('NFKC').toLowerCase().replace(/[\p{P}\p{S}\s]+/gu, '');
+  return GOAL_DONE_EMPTY_VALUES.has(normalized)
+    || GOAL_DONE_UNRESOLVED_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+}
+// Evidence must be an executable command line, not another prose acceptance
+// criterion. Keep this lexical: the preflight cannot safely run the command.
+// An explicit executable is required so prose such as "Check that tests pass"
+// does not become a false completion boundary.
+const GOAL_DONE_EVIDENCE_COMMAND = /^(?:[A-Za-z_][\w-]*=(?:"[^"]*"|'[^']*'|[^\s]+)\s+)*(eln|bun|git|gh|rg|test|npm|pnpm|yarn|node|python|python3|pytest|bash|sh|make|cargo|go|curl|jq|sqlite3|grep|sed|awk|cat|find|ssh|docker|kubectl|(?:\.\/|\/|~\/)[^\s]+)(?:\s+(.*))?$/;
+// The goal boundary parser never invokes commands, so compound shell lines are
+// outside its supported evidence grammar and must not be accepted as proof.
+const GOAL_DONE_UNSUPPORTED_SHELL_OPERATOR = /&&|\|\||[;|><`]|\$\(/;
+// Only the narrow, concrete file predicates are accepted for `test`; the
+// predicate also needs its operand, so `test -f` cannot claim proof.
+const GOAL_DONE_SHELL_TEST_ARGS = /^-(?:f|e)\s+\S+(?:\s|$)/;
+
+function isGoalDoneEvidenceCommand(value: string): boolean {
+  if (GOAL_DONE_UNSUPPORTED_SHELL_OPERATOR.test(value)) return false;
+  const match = GOAL_DONE_EVIDENCE_COMMAND.exec(value);
+  const args = match?.[2]?.trim() ?? '';
+  return !!match && args.length > 0 && (match[1] !== 'test' || GOAL_DONE_SHELL_TEST_ARGS.test(args));
+}
+
+function unwrapGoalDoneValue(value: string): string {
+  let result = value.trim();
+  const wrappers: Array<readonly [string, string]> = [['`', '`'], ['"', '"'], ["'", "'"], ['“', '”'], ['‘', '’']];
+  // Each pass removes two characters. Repeated wrappers cannot hide a marker.
+  while (result.length >= 2) {
+    const pair = wrappers.find(([open, close]) => result.startsWith(open) && result.endsWith(close));
+    if (!pair) break;
+    result = result.slice(pair[0].length, -pair[1].length).trim();
+  }
+  return result;
+}
+
+export function inspectGoalDoneBoundary(document: string): { values: Partial<Record<GoalDoneBoundaryLabel, string>>; missing: GoalDoneBoundaryLabel[] } {
+  const values: Partial<Record<GoalDoneBoundaryLabel, string>> = {};
+  for (const line of linesOutsideFencedCode(document)) {
+    const match = /^\s*(?:[-*]\s*)?(완료 경계 코드|완료 경계 실물|완료 경계 증거 명령)\s*:\s*(.*?)\s*$/.exec(line.text);
+    if (!match) continue;
+    const label = match[1] as GoalDoneBoundaryLabel;
+    const value = match[2]?.trim() ?? '';
+    const inspected = unwrapGoalDoneValue(value);
+    if (!isGoalDonePlaceholder(value)
+      && (label !== '완료 경계 증거 명령' || isGoalDoneEvidenceCommand(inspected))) values[label] = value;
+  }
+  return { values, missing: GOAL_DONE_BOUNDARY_LABELS.filter((label) => !values[label]) };
+}
+
+export function explicitGoalDoneBoundaryLines(ask: string): string[] {
+  const { values } = inspectGoalDoneBoundary(ask);
+  return GOAL_DONE_BOUNDARY_LABELS.flatMap((label) => values[label] ? [`- ${label}: ${values[label]}`] : []);
+}
+
 // CommonMark 펜스는 **한 종류의 문자**가 3개 이상 이어진 런이다 — `[`~]{3,}` 는 혼합(백틱+틸드)까지
 // 펜스로 인정해 진짜 진양성을 펜스 안으로 숨긴다(리뷰 must-fix). 열기/닫기 모두 이 하나를 쓴다.
 const FENCE_RUN = /^ {0,3}(`{3,}|~{3,})(.*)$/;
@@ -792,10 +857,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) => classifyTracedPathToken(path).kind === 'path');
+}
+
 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) : [];
   });
 }
 
@@ -1198,6 +1267,73 @@ interface TracedPathReference {
   endLine: number | null;
 }
 
+/** Every TRACED PATHS declaration token is one of these kinds. Nested repository paths are `path`. */
+export type TracedPathTokenKind = 'path' | 'bare' | 'residual' | 'repository-root' | 'empty-cover';
+
+export interface TracedPathTokenClassification {
+  readonly token: string;
+  readonly kind: TracedPathTokenKind;
+  /** Inspectable path when the token names one; null for an empty cover. */
+  readonly path: string | null;
+  /** Attached residual characters when `kind` is `residual` (for example `???` in `src/a.ts???`). */
+  readonly residual: string | null;
+}
+
+const EMPTY_COVER_TOKEN = '(빈 대상 경로)';
+/** Leftover punctuation after a complete file token (`src/a.ts???`). Must not steal extension letters. */
+const TRACED_PATH_RESIDUAL_TOKEN = /^((?:[A-Za-z0-9_.-]+\/)*[A-Za-z0-9_.-]+\.[A-Za-z0-9]+)([^A-Za-z0-9./\\:\s,;]+)$/;
+
+function isEmptyCoverToken(token: string): boolean {
+  const trimmed = token.trim();
+  return trimmed === '' || trimmed === EMPTY_COVER_TOKEN;
+}
+
+function repositoryRootFileExists(path: string, repositoryRoot: string): boolean {
+  if (path.includes('/') || path.includes('\\') || isAbsolute(path)) return false;
+  try {
+    const realRoot = realpathSync(resolve(repositoryRoot));
+    const absolutePath = resolve(realRoot, path);
+    if (dirname(absolutePath) !== realRoot || !isSameOrNestedPath(absolutePath, realRoot)) return false;
+    return lstatSync(absolutePath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Classify one TRACED PATHS / 대상 경로 declaration token.
+ * Residual characters stay attached until this plate splits them; locators (`file.ts:line`) stay locators.
+ */
+export function classifyTracedPathToken(token: string, repositoryRoot?: string): TracedPathTokenClassification {
+  const trimmed = token.trim();
+  if (isEmptyCoverToken(trimmed)) {
+    return { token: trimmed, kind: 'empty-cover', path: null, residual: null };
+  }
+  const unwrapped = stripInlineCode(trimmed).replace(TRACED_PATH_LEADING_LIST_MARKERS, '').trim();
+  if (isEmptyCoverToken(unwrapped)) {
+    return { token: trimmed, kind: 'empty-cover', path: null, residual: null };
+  }
+  const residualMatch = TRACED_PATH_RESIDUAL_TOKEN.exec(unwrapped);
+  if (residualMatch?.[1] && residualMatch[2]) {
+    return { token: trimmed, kind: 'residual', path: residualMatch[1], residual: residualMatch[2] };
+  }
+  const normalized = unwrapped.replaceAll('\\', '/');
+  if (!normalized.includes('/')) {
+    if (repositoryRoot && repositoryRootFileExists(normalized, repositoryRoot)) {
+      return { token: trimmed, kind: 'repository-root', path: normalized, residual: null };
+    }
+    return { token: trimmed, kind: 'bare', path: normalized, residual: null };
+  }
+  return { token: trimmed, kind: 'path', path: normalized, residual: null };
+}
+
+/** Inspectable traced path: nested or repository-root files only. Residual, bare-only, and empty covers are not injected. */
+export function canonicalTracedPathToken(token: string, repositoryRoot?: string): string | null {
+  const classification = classifyTracedPathToken(token, repositoryRoot);
+  if (classification.kind === 'path' || classification.kind === 'repository-root') return classification.path;
+  return null;
+}
+
 /**
  * Count lines an editor would address. A file's terminating newline closes the last line rather
  * than opening a new one, so `"one\n"` is one addressable line — counting the split remainder
@@ -1303,6 +1439,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 +1485,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,14 +1500,22 @@ 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;
       if (!path) continue;
+      const classification = classifyTracedPathToken(path);
+      if (classification.kind === 'residual' || classification.kind === 'empty-cover') continue;
       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,6 +1846,12 @@ 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 — 문서가 «새로 만들 파일»로 선언한 경로. 실행 쪽 범위 검사와 같은 줄을 읽는다.
     // 저작과 실행은 같은 Original ask 범위만 선언으로 인정한다. 문서의 다른 절은 근거일 뿐이다.
@@ -2277,11 +2430,106 @@ 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
+          && classifyTracedPathToken(token, repositoryRoot).kind !== 'repository-root');
+    });
+  const labeledTargets = declaredTargetPaths(ask);
+  const labeledRootFiles = targetLabels.flatMap((label) => label.split(/\s+[·,]\s*|[·,]\s+/))
+    .flatMap((piece) => piece.trim().split(/\s+/).filter(Boolean))
+    .flatMap((token) => {
+      const classification = classifyTracedPathToken(token, repositoryRoot);
+      return classification.kind === 'repository-root' && classification.path ? [classification.path] : [];
+    });
+  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
+    ? [...new Set([...labeledTargets, ...labeledRootFiles])]
+    : 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 (isAbsolute(path) || path.split('/').some((part) => part === '..' || part === '.')) return false;
+    if (root === null) return false;
+    if (!path.includes('/')) return classifyTracedPathToken(path, root).kind === 'repository-root';
+    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;
@@ -2773,9 +3021,13 @@ interface AbsentFirstImplementationPath {
 }
 
 function askPathTokens(ask: string): string[] {
-  return ask.split(/\s+/)
-    .map((token) => token.replace(/^[`\p{P}]+|[`\p{P}]+$/gu, ''))
-    .filter((token) => token.includes('/') && /\.[^./]+$/.test(token));
+  return ask.split(/\s+/).flatMap((raw) => {
+    const withoutWrap = raw.replace(/^[`([{]+|[`)\]}]+$/g, '');
+    if (classifyTracedPathToken(raw).kind === 'residual' || classifyTracedPathToken(withoutWrap).kind === 'residual') return [];
+    const token = raw.replace(/^[`\p{P}]+|[`\p{P}]+$/gu, '');
+    if (classifyTracedPathToken(token).kind === 'residual') return [];
+    return token.includes('/') && /\.[^./]+$/.test(token) ? [token] : [];
+  });
 }
 
 const ASK_QUANTITY_WORDS = new Set(['모든', '무조건', '전부', '아래의']);
@@ -2854,7 +3106,9 @@ interface NewTargetFile {
 export function isAskPathLocatorToken(path: string): boolean {
   // Evidence (`file.ts:line`) and prefixed (`ref:path`) tokens are not file paths.
   // This plate discards them; it does not strip the colon and retry the remainder.
-  return path.split(/[\\/]/).some((component) => component.includes(':'));
+  if (path.split(/[\\/]/).some((component) => component.includes(':'))) return true;
+  const kind = classifyTracedPathToken(path).kind;
+  return kind === 'residual' || kind === 'empty-cover';
 }
 
 export function classifyAbsentFirstPathPresence(path: string, repositoryRoot?: string): AbsentFirstPathPresence {
@@ -5080,6 +5334,7 @@ async function authorGoalWithSupersededRootIntent(
       '',
       '## ACCEPTANCE CRITERIA',
       ...enhancement.checklist.map(requestedCriterionLine),
+      ...explicitGoalDoneBoundaryLines(ask),
       '',
       '## REQUIRED EVIDENCE',
       '- [requested] Verify the decision signal and the verbatim ask.',
@@ -5530,6 +5785,7 @@ async function authorGoalWithSupersededRootIntent(
       : ['## STEPS', ...(resolvedSteps.length ? resolvedSteps.map((step) => `- ${step}`) : ['- No externally injected steps.']), '']),
     '## ACCEPTANCE CRITERIA',
     ...acceptanceSection,
+    ...explicitGoalDoneBoundaryLines(ask),
     ...preservationAmbiguityCriteria(ambiguities, clarificationAnswers),
     ...preservationAmbiguityNotice(ambiguities),
     ...preservationAmbiguityClarification(clarificationQuestions, clarificationResponses),
@@ -5537,7 +5793,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,
     '',
@@ -5723,23 +5979,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));
 }
@@ -5752,32 +5993,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);
@@ -5790,27 +6005,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/graph-authority.ts

@@ -17,6 +17,7 @@ import {
 import { applyGraphOverlays, selectOverlays, type GraphOverlaySpec, type OverlayRejection, type OverlaySelection, type OverlayStage } from './graph-overlay-yaml.js';
 import type { OverlayPatch } from './graph-overlay.js';
 import type { GraphTemplateSpec } from './graph-yaml.js';
+import { pickSupervisorHealOverlay, type SupervisorOverlayPick } from './heal-triage.js';
 
 /** 2026-09-26 설정 졸업 — 그래프 권위는 항상 켬. 관측 출처는 default로 고정한다. */
 export type GraphAuthoritySource = 'default';
@@ -282,7 +283,10 @@ export function graphAuthorityFields(authority: GraphAuthority, template: GraphT
 /** 오버레이 조건이 «읽을 수 있는» 상태 키. ⛔ 여기 없는 키는 원장에 값이 안 실린다.
  *  🔑 그래서 «떨어뜨리되 말은 한다» — 아래 `stateExtraKeys` 가 그 이름을 남긴다.
  *  ⭐ `author_grade` — 적응형 저작(GRAPH-AUTHOR-GRADE) 첫 조각: 저작 등급을 오버레이 상태의 «이름»으로 싣는다. */
-export const OVERLAY_STATE_KEYS = ['attempts', 'author_grade', 'goal_id'] as const;
+export const OVERLAY_STATE_KEYS = [
+  'attempts', 'author_grade', 'goal_id',
+  'substrate', 'freeze', 'docs_only', 'provider', 'quota', 'machines', 'seats',
+] as const;
 
 /** 저작 등급의 오버레이 어휘 — `goal-author` 의 `GoalAuthorGrade`(`full|lite`) 를 오버레이 등급(`normal`) 로 옮긴다.
  *  ⛔ 모르는 값(빈 값·오타)은 `undefined` — 등급을 «지어내지 않는다». */
@@ -303,7 +307,7 @@ export function normalizeAuthorGrade(value: unknown): 'lite' | 'normal' | 'compl
  *        여기서 «조용히» 떨어뜨리면 같은 병을 한 층 아래에서 다시 짓는 것이다. */
 export function overlayDecisionObservation<T extends Readonly<Record<string, unknown>>>(input: T & {
   readonly state: Readonly<Record<string, unknown>>;
-}): T & { readonly state: Readonly<Record<string, unknown>>; readonly stateExtraKeys?: readonly string[] } {
+}): Omit<T, 'state'> & { 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)) continue;
@@ -313,6 +317,14 @@ export function overlayDecisionObservation<T extends Readonly<Record<string, unk
   return { ...input, state, ...(extra.length > 0 ? { stateExtraKeys: extra } : {}) };
 }
 
+/** ⭐ 칸 GRAPH-SUPERVISOR-PICK(0.2.32) — `graph-overlay-decision` 원장에 실릴 슈퍼바이저 고르기 기록.
+ *  `overlayDecisionObservation` 을 그대로 거친다 — 판단(outcome)·근거(evidence 한 줄)와 함께
+ *  판정에 쓴 상태 칸(`state`/`stateExtraKeys`)이 같이 남는다(예: `stop_class`). */
+export type SupervisorPickRecord = SupervisorOverlayPick & {
+  readonly state: Readonly<Record<string, unknown>>;
+  readonly stateExtraKeys?: readonly string[];
+};
+
 export function decideTemplate(input: {
   readonly goalType: GoalType | undefined;
   readonly authority: GraphAuthority;
@@ -329,22 +341,42 @@ export function decideTemplate(input: {
   readonly rejections: readonly OverlayRejection[];
   readonly appliedIds: readonly string[];
   readonly appliedPatches: readonly OverlayPatch[];
+  /** ⭐ 칸 GRAPH-SUPERVISOR-PICK(0.2.32) — `stage: 'heal'` 판에만 싣는다: 슈퍼바이저가 «선언된»
+   *  오버레이 중에서 고른 판단·근거. 다른 단계는 이 칸이 없다(기본 동작 보존). */
+  readonly supervisorPick?: SupervisorPickRecord;
 } {
   const base = activeTemplate(input.goalType, input.authority);
   if (!input.authority.enabled) return { template: base, selections: [], rejections: [], appliedIds: [], appliedPatches: [] };
+  // ⭐ 칸 GRAPH-SUPERVISOR-PICK(0.2.32) — 슈퍼바이저가 «선언된» heal 오버레이 중 하나를 고른다(능력표 ③b).
+  //   ⛔ 고르기만 한다 — 새 노드를 짓지 않는다. 노드를 더하는 것은 선언의 patch 고, 그 적용은
+  //     아래 기존 selectOverlays/applyGraphOverlays 경로가 그대로 말한다.
+  //   ⛔ 후보는 graphs/overlays/ 선언(loadGraphOverlays) 중 `stage: heal` 뿐이다 — 호출부가 준
+  //     overlays 목록과 무관하게 «선언에서만» 고른다.
+  //   판단·근거는 overlayDecisionObservation(graph-overlay-decision 원장 칸)을 거쳐 기록 형태로 나간다.
+  let supervisorPick: SupervisorPickRecord | undefined;
+  if (input.stage === 'heal') {
+    const chosen = pickSupervisorHealOverlay({ state: input.state, graphId: base.graphId });
+    supervisorPick = overlayDecisionObservation({
+      outcome: chosen.outcome,
+      ...(chosen.overlayId !== undefined ? { overlayId: chosen.overlayId } : {}),
+      evidence: chosen.evidence,
+      state: input.state,
+    });
+  }
+  const pick: { supervisorPick?: SupervisorPickRecord } = supervisorPick === undefined ? {} : { supervisorPick };
   // ⛔ 「최초 결정」은 launch 단계다 — `runtime` 오버레이는 여기서 «후보가 아니다»(③ 다이나믹의 몫).
   const { applied, selections } = selectOverlays(input.overlays, {
     graphId: base.graphId, stage: input.stage, state: input.state,
   });
-  if (applied.length === 0) return { template: base, selections, rejections: [], appliedIds: [], appliedPatches: [] };
+  if (applied.length === 0) return { template: base, selections, rejections: [], appliedIds: [], appliedPatches: [], ...pick };
   const spec = (input.specs ?? GRAPH_SPECS)[base.graphId];
   // ⛔ spec 을 못 얻으면 «변형하지 않는다» — 얹은 척하지 않는다(내장 폴백으로 돌 때가 그렇다).
-  if (spec === undefined) return { template: base, selections, rejections: [], appliedIds: [], appliedPatches: [] };
+  if (spec === undefined) return { template: base, selections, rejections: [], appliedIds: [], appliedPatches: [], ...pick };
   const result = applyGraphOverlays(spec, applied);
   // ⛔ 전부 아니면 전무다 — 하나라도 거절되면 «기준 선언»으로 돈다(반쯤 얹힌 그래프를 만들지 않는다).
   return result.ok
-    ? { template: specToTemplate(result.template), selections, rejections: [], appliedIds: result.overlayIds, appliedPatches: result.patches }
-    : { template: base, selections, rejections: result.rejections, appliedIds: [], appliedPatches: [] };
+    ? { template: specToTemplate(result.template), selections, rejections: [], appliedIds: result.overlayIds, appliedPatches: result.patches, ...pick }
+    : { template: base, selections, rejections: result.rejections, appliedIds: [], appliedPatches: [], ...pick };
 }
 
 /** ⭐ RFC §5 — 노드 «방문 예산»(`max_visits`)을 실행이 «읽게» 한다.