elanous 0.2.27 → 0.2.28

package/src/seat-dispatch/seat-request-ledger.ts

@@ -11,6 +11,10 @@ export type SeatRequestRow = {
   text: string;
   queuedAt: string;
   reason?: string;
+  /** One-line explanation of the automated action recorded on this row. */
+  why?: string;
+  /** Pointer to the evidence supporting the action (log line, run id, ledger path, …). */
+  evidenceRef?: string;
   closedAt?: string;
   [field: string]: unknown;
 };

package/src/seat-loop/knowhow-lint.ts

@@ -0,0 +1,233 @@
+import { seatPackLeakPatterns } from './seat-pack.js';
+
+/** 필수 칸 — 형식 v2 선언(각 자리 KNOWHOW 머리글)의 공통 아홉. 괄호 수식어(신호(관측) 등)는 정규화해서 비교한다. */
+const REQUIRED_FIELDS = ['상황', '신호', '원인', '처방', '재는 명령', '기대', '유효 조건', '검증', '출처'] as const;
+
+/** Only commands whose executable and subcommand are known to be observational are accepted. */
+const READ_COMMANDS: Record<string, ReadonlySet<string> | null> = {
+  cat: null, echo: null, rg: null, grep: null, head: null, tail: null,
+  wc: null, sort: null, uniq: null, cut: null, jq: null, ls: null, stat: null,
+  readlink: null, pwd: null, test: null,
+  git: new Set(['rev-parse', 'status', 'log', 'show', 'merge-base']),
+  eln: new Set(['logs', 'where', 'tasks', 'config', 'release']),
+  'bun bin/elanous.mjs': new Set(['logs', 'where', 'release']),
+};
+
+/** Git's options are commands too: e.g. show --textconv runs a configured external driver. */
+const READ_GIT_OPTIONS: Record<string, ReadonlySet<string>> = {
+  'rev-parse': new Set(['--git-dir', '--show-toplevel', '--is-inside-work-tree', '--verify', '--short', '--abbrev-ref', '--show-prefix']),
+  status: new Set(['--short', '--porcelain', '--branch', '--untracked-files=all', '--untracked-files=no']),
+  log: new Set(['--oneline', '--no-patch', '--stat', '--name-only', '--name-status', '--all', '--decorate']),
+  show: new Set(['--no-patch', '--stat', '--name-only', '--name-status', '--oneline']),
+  'merge-base': new Set(['--is-ancestor', '--fork-point', '--all']),
+};
+
+/** `logs level <value>` changes daemon state. Accept only the top-level query options. */
+const LOGS_QUERY_FLAGS = new Set([
+  '--follow', '-f', '--list-categories', '--list-events', '--explain', '--top-failures',
+  '--json', '--json-data', '--test', '--all', '--include-test', '-r', '--help', '-h',
+]);
+const LOGS_QUERY_VALUES = new Set([
+  '--level', '--surface', '--space', '--category', '--exact-category', '--axis', '--event',
+  '--grep', '--rework-recurrence-disagreement', '--since', '--until', '--before',
+  '--session', '--limit', '--threshold', '--instance', '--remote',
+]);
+
+function readOnlyLogs(args: string[]): boolean {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]!;
+    if (LOGS_QUERY_FLAGS.has(arg)) continue;
+    if (LOGS_QUERY_VALUES.has(arg) && args[i + 1] && !args[i + 1]!.startsWith('-')) { i++; continue; }
+    return false;
+  }
+  return true;
+}
+
+function readOnlyGit(rest: string[]): boolean {
+  const [subcommand, ...args] = rest;
+  const options = READ_GIT_OPTIONS[subcommand ?? ''];
+  if (!options) return false;
+  return args.every((arg) => !arg.startsWith('-') || options.has(arg)
+    || ((subcommand === 'log' || subcommand === 'show')
+      && (/^--(?:format|pretty|grep|since|until|max-count)=.+$/u.test(arg) || /^-[1-9][0-9]*$/u.test(arg))));
+}
+
+/** Do not execute the measurement here: parse only a small, fail-closed shell subset. */
+function readOnlyMeasure(command: string): boolean {
+  const source = command.trim().replace(/^`|`$/gu, '');
+  const tokens: string[] = [];
+  let word = '';
+  let quote: '"' | "'" | null = null;
+  for (let i = 0; i < source.length; i++) {
+    const char = source[i]!;
+    if (char === '\\' || char === '`' || char === '$' || char === '\n') return false;
+    if (quote) {
+      if (char === quote) quote = null;
+      else word += char;
+    } else if (char === '"' || char === "'") {
+      quote = char;
+    } else if (/\s/u.test(char)) {
+      if (word) { tokens.push(word); word = ''; }
+    } else if ('|&;<>()[{}]'.includes(char)) {
+      if (word) { tokens.push(word); word = ''; }
+      if (char === '|' || char === '&') {
+        if (source[i + 1] === char) { tokens.push(char + char); i++; }
+        else if (char === '|') tokens.push('|');
+        else return false;
+      } else if (char === '>') {
+        if (source[i + 1] === '>') return false;
+        if (source.slice(i + 1, i + 3) === '&1') { tokens.push('>&1'); i += 2; }
+        else tokens.push('>');
+      } else return false;
+    } else word += char;
+  }
+  if (quote) return false;
+  if (word) tokens.push(word);
+  if (!tokens.length) return false;
+  const segments: string[][] = [[]];
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i]!;
+    if (token === '>' && tokens[i + 1] === '/dev/null') { i++; continue; }
+    if (token === '2' && tokens[i + 1] === '>&1') { i++; continue; }
+    if (token === '&&' || token === '||' || token === '|') {
+      if (!segments.at(-1)!.length) return false;
+      segments.push([]);
+    } else if (token === '>' || token === '>&1') return false;
+    else segments.at(-1)!.push(token);
+  }
+  return segments.every((args) => {
+    if (!args.length || args.some((arg) => /^(?:--pre|--output|--ext-diff|--exec|--config|--config-env|--write)(?:=|$)/u.test(arg))) return false;
+    if (args.some((arg) => /^(?:--output(?:=\S*)?|--replace|--in-place)$/u.test(arg))) return false;
+    if (args[0] === 'sort' && args.some((arg) => /^-o\S*|^--compress-program(?:=|$)/u.test(arg))) return false;
+    let executable = args[0]!;
+    let rest = args.slice(1);
+    if (executable === 'bun' && rest[0] === 'bin/elanous.mjs') { executable = 'bun bin/elanous.mjs'; rest = rest.slice(1); }
+    if (!Object.hasOwn(READ_COMMANDS, executable)) return false;
+    const allowed = READ_COMMANDS[executable]!;
+    if (allowed === null) return true;
+    if (executable === 'bun bin/elanous.mjs' && rest[0] === '--test') rest = rest.slice(1);
+    if (!allowed.has(rest[0] ?? '')) return false;
+    if (executable === 'git') return readOnlyGit(rest);
+    if ((executable === 'eln' || executable === 'bun bin/elanous.mjs') && rest[0] === 'logs') return readOnlyLogs(rest.slice(1));
+    if ((executable === 'eln' || executable === 'bun bin/elanous.mjs') && rest[0] === 'tasks') return rest[1] === 'close' && rest[2] === '--help';
+    if ((executable === 'eln' || executable === 'bun bin/elanous.mjs') && rest[0] === 'config') return rest[1] === 'get';
+    if ((executable === 'eln' || executable === 'bun bin/elanous.mjs') && rest[0] === 'release') return rest[1] === 'checklist' && rest[2] === 'status';
+    return true;
+  });
+}
+
+/** 비밀 표식 — 팩 스캔 표식(seatPackLeakPatterns)에 실제 자격 모양을 더한 집합. */
+const SECRET_SHAPE_PATTERNS: Array<[string, RegExp]> = [
+  ['api key', /\b(?:sk|rk)-(?:proj-)?[A-Za-z0-9_-]{16,}\b/u],
+  ['github token', /\b(?:gh[pousr]_[A-Za-z0-9]{16,}|github_pat_[A-Za-z0-9_]{16,})\b/u],
+  ['slack token', /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/u],
+  ['aws key id', /\bAKIA[0-9A-Z]{12,}\b/u],
+  ['private key block', /-----BEGIN [A-Z ]*PRIVATE KEY-----/u],
+  ['credential assignment', /\b(?:api[_-]?key|secret|token|password)\s*[:=]\s*["']?[A-Za-z0-9][A-Za-z0-9._/+~-]{11,}/iu],
+];
+
+export class KnowhowLintError extends Error {
+  constructor(file: string, card: string, reason: string) {
+    super(`knowhow lint: ${file} ${card} — ${reason}`);
+    this.name = 'KnowhowLintError';
+  }
+}
+
+interface KnowhowCard {
+  id: string;
+  lines: Array<[number, string]>;
+}
+
+/** 카드 제목 — `## K-<자리>-<번호>` 뒤에는 줄 끝·공백·콜론·em 대시만 온다. */
+const CARD_HEADING = /^[ \t]{0,3}##\s+(K-[A-Za-z]+-\d+)(?=$|\s|:|—)/u;
+/** 카드처럼 보이는 `##` 제목(예: `## K-OP-7a`) — CARD_HEADING 을 벗어나면 인식 실패로 명시 거부한다. */
+const CARD_HEADING_LIKE = /^[ \t]{0,3}##\s*(K-[^\s:]*)/iu;
+
+function parseCards(body: string, file: string): KnowhowCard[] {
+  const cards: KnowhowCard[] = [];
+  let current: KnowhowCard | null = null;
+  let fence: { marker: string; length: number } | null = null;
+  for (const [index, line] of body.split(/\r?\n/u).entries()) {
+    const fenceLine = line.match(/^ {0,3}(`{3,}|~{3,})(.*)$/u);
+    if (fence) {
+      if (fenceLine && fenceLine[1]![0] === fence.marker && fenceLine[1]!.length >= fence.length
+        && /^[ \t]*$/u.test(fenceLine[2]!)) fence = null;
+      continue;
+    }
+    if (fenceLine) {
+      fence = { marker: fenceLine[1]![0]!, length: fenceLine[1]!.length };
+      continue;
+    }
+    const heading = line.match(CARD_HEADING);
+    if (heading) {
+      current = { id: heading[1]!, lines: [] };
+      cards.push(current);
+      continue;
+    }
+    if (/^[ \t]{0,3}#/u.test(line)) {
+      const like = line.match(CARD_HEADING_LIKE);
+      if (like) throw new KnowhowLintError(file, like[1]!, '카드 제목 형식이 K-<자리>-<번호>를 벗어남');
+      current = null;
+    } else if (current) current.lines.push([index + 1, line]);
+  }
+  return cards;
+}
+
+function parseField(line: string): { label: string; value: string } | null {
+  const match = line.match(/^-\s*([^:—]+?)\s*[—:]\s*(.*)$/u);
+  if (!match) return null;
+  return { label: match[1]!.replace(/\s*\([^)]*\)/gu, '').trim(), value: match[2]!.trim() };
+}
+
+/** 자리 KNOWHOW.md 카드를 내보내기 전에 검증한다 — 카드 제목 형식 · 필수 칸 · 읽기 전용 재는 명령(이어 적은 여러 줄 포함) · 비밀 표식. */
+export function lintKnowhow(body: string, file: string): void {
+  const secrets = [...seatPackLeakPatterns(), ...SECRET_SHAPE_PATTERNS];
+  for (const [index, line] of body.split(/\r?\n/u).entries()) {
+    for (const [label, pattern] of secrets) {
+      if (pattern.test(line)) throw new KnowhowLintError(file, 'file', `비밀 표식 (${label}) — ${file}:${index + 1}`);
+    }
+  }
+  const cards = parseCards(body, file);
+  if (!cards.length) throw new KnowhowLintError(file, 'file', '카드가 0개 — 최소 한 개의 K-<자리>-<번호> 카드가 필요함');
+  for (const card of cards) {
+    const fields = new Map<string, string>();
+    const fieldEntries: Array<{ label: string; value: string }> = [];
+    let current: { label: string; value: string } | null = null;
+    for (const [, line] of card.lines) {
+      const field = parseField(line);
+      if (field) {
+        if (current) fieldEntries.push(current);
+        current = { label: field.label, value: field.value };
+      } else if (current && /^\s+\S/u.test(line)) {
+        current.value += `\n${line.trim()}`;
+      } else if (current) {
+        fieldEntries.push(current);
+        current = null;
+      }
+    }
+    if (current) fieldEntries.push(current);
+    for (const field of fieldEntries) {
+      if (fields.has(field.label)) throw new KnowhowLintError(file, card.id, `중복 칸: ${field.label}`);
+      if ((REQUIRED_FIELDS as readonly string[]).includes(field.label) || field.label === '상태') {
+        if (!field.value) throw new KnowhowLintError(file, card.id, `필수 칸 누락: ${field.label}`);
+      }
+      if (field.label === '재는 명령'
+        && !field.value.split('\n').every((command) => readOnlyMeasure(command))) {
+        throw new KnowhowLintError(file, card.id, '재는 명령이 읽기 전용이 아님');
+      }
+      fields.set(field.label, field.value);
+    }
+    for (const required of REQUIRED_FIELDS) {
+      if (!fields.get(required)) throw new KnowhowLintError(file, card.id, `필수 칸 누락: ${required}`);
+    }
+    const source = fields.get('출처') ?? '';
+    const statusInSource = source.match(/(?:^|[· \t])상태[ \t]*[:—][ \t]*([^·\n]*)/u);
+    if (!source.slice(0, statusInSource?.index ?? source.length).replace(/[·\s]+$/u, '').trim()) {
+      throw new KnowhowLintError(file, card.id, '필수 칸 누락: 출처');
+    }
+    const combinedStatus = statusInSource?.[1]?.trim();
+    if (!fields.get('상태') && !combinedStatus) {
+      throw new KnowhowLintError(file, card.id, '필수 칸 누락: 상태');
+    }
+  }
+}

package/src/seat-loop/seat-pack.ts

@@ -1,8 +1,9 @@
 import { createHash } from 'node:crypto';
 import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
-import { dirname, join, relative, resolve, sep } from 'node:path';
+import { basename, dirname, join, relative, resolve, sep } from 'node:path';
 import { userInfo } from 'node:os';
 import { DEFAULT_CONCURRENT_PODS, DEFAULT_DAILY_GOALS } from '../org/seat-budget.js';
+import { lintKnowhow } from './knowhow-lint.js';
 
 export interface SeatPackManifest {
   name: string;
@@ -31,13 +32,20 @@ function walk(directory: string, root: string): string[] {
     });
 }
 
+/** Static leak markers shared by the pack scan and the KNOWHOW lint. Account-name patterns stay in `scan` — they depend on the exporting host's user. */
+export function seatPackLeakPatterns(): Array<[string, RegExp]> {
+  return [
+    ['royal marker', /\u{1F451}/u],
+    ['track marker', /(?:🅞|🅣|🅢|🅕|\*\*\[(?:OP|TC|MK|UX|S|T|O|F)\]\*\*|\[(?:OP|TC|MK|UX|S|T|O|F)\])/u],
+    ['absolute user path', /\/Users\/[A-Za-z0-9._-]+/u],
+  ];
+}
+
 function scan(file: string, body: string): void {
   const usernames = new Set([userInfo().username, process.env.ELANOUS_LEAK_HOME_USER].filter((name): name is string => Boolean(name)));
   const accountPatterns = [...usernames].map((name) => new RegExp(`(?<![A-Za-z0-9._-])${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![A-Za-z0-9._-])`, 'iu'));
   const patterns: Array<[string, RegExp]> = [
-    ['royal marker', /\u{1F451}/u],
-    ['track marker', /(?:🅞|🅣|🅢|🅕|\*\*\[(?:OP|TC|MK|UX|S|T|O|F)\]\*\*|\[(?:OP|TC|MK|UX|S|T|O|F)\])/u],
-    ['absolute user path', /\/Users\/[A-Za-z0-9._-]+/u],
+    ...seatPackLeakPatterns(),
     ...accountPatterns.map((pattern): [string, RegExp] => ['account name', pattern]),
   ];
   for (const [index, line] of body.split(/\r?\n/u).entries()) {
@@ -61,6 +69,10 @@ export function exportSeatPack(seat: string, out: string, root = resolve(import.
   for (const file of roleFiles) {
     const body = readFileSync(join(repo, file));
     contents.set(file, body);
+    // Public leak markers take precedence over formatting errors: callers need
+    // the file:line and exit 2 before an export directory can be created.
+    scan(file, body.toString('utf8'));
+    if (basename(file) === 'KNOWHOW.md') lintKnowhow(body.toString('utf8'), file);
     for (const match of body.toString('utf8').matchAll(/graphs\/([A-Za-z0-9_./-]+(?:\.ya?ml|\/\*\*))/gu)) {
       const ref = `graphs/${match[1]!}`;
       if (ref.split('/').includes('..')) throw new Error(`invalid seat graph: ${ref}`);

package/src/seat-loop/traffic-signal.ts

@@ -10,6 +10,13 @@ export type TrafficSignal = {
 };
 export type TrafficSignalRead = TrafficSignal | { unreadable: true } | null;
 
+/** Pure proposal classification; applying a proposal belongs to the downstream seat-message caller. */
+export function classifySeatTrafficProposal(message: string): 'hold' | 'UNHOLD' | null {
+  if (message.includes('첫 줄 확정')) return 'UNHOLD';
+  if (message.includes('손 구현 착수')) return 'hold';
+  return null;
+}
+
 const defaultPath = (name: string): string => join(homedir(), 'elanous-hq', 'seat-state', 'OP', name);
 const missing = (error: unknown): boolean => (error as NodeJS.ErrnoException).code === 'ENOENT';
 

package/src/self-dev/ask-launch-flow.ts

@@ -11,6 +11,8 @@
 // ⛔ 종료(`process.exit`)는 여기가 «안» 한다 — 호출자가 자기 표면에 맞게 끝낸다.
 //   그래서 결과를 «세 값»으로 낸다: 발사 / 저작 전 중단 / 전제 검사 중단.
 import { linesOutsideFencedCode } from '../self-implement/goal-author.js';
+import { existsSync } from 'node:fs';
+import { debug } from '../debug/log.js';
 import { recordAuthoredGoal } from './authored-goal-trace.js';
 import { findAskPathCandidates, type AskPathCandidateOptions } from './ask-path-candidates.js';
 import { retiredEntranceNotice, type EntranceDeclaration } from './entrance-registry.js';
@@ -18,6 +20,7 @@ import {
   classifyConcurrentAuthoring,
   countRepeatedBlocks,
   decideAskPreflight,
+  discardNonFileTracedPathItems,
   parseAskTargetPathHintsResult,
   parseBlockedChoice,
   planBlockedPrompt,
@@ -797,10 +800,10 @@ async function intakeClarifications(
     selfResolveClarifications: selfResolveClarifications.value,
   });
   const parentDocument = document;
-  effectiveGoalFile = reauthored.path;
+  effectiveGoalFile = isAbsolutePath(reauthored.path) ? reauthored.path : resolvePath(deps.cwd(), reauthored.path);
   deps.print(`[ask] ⑴b 재저작됨: ${reauthored.path}`);
   // ⛔ 「재저작이 «났다»」와 「재저작이 «옳았다»」는 다른 물음이다(JDG-T35 3단 ⑶).
-  const childDocument = reauthored.authored?.document ?? deps.readFile(reauthored.path);
+  const childDocument = reauthored.authored?.document ?? deps.readFile(effectiveGoalFile);
   const askFidelity = classifyReauthoredAsk(parentDocument, childDocument);
   if (askFidelity !== 'preserved') {
     deps.print(`[ask] ⑴b ⚠️ 재저작 ask 판정: ${askFidelity} — ⛔ 「preserved」가 아니면 사람의 ask 가 살아남았는지 «확인하라»`);
@@ -939,7 +942,31 @@ export async function runAskLaunchFlow(
     }, markerCounts !== null && markerCounts.missingMarkers > 0 ? 'warn' : 'info');
 
     // ⛔ 되묻기에 답하면 «새 골»이 나온다 — 아래 전제 검사·발사는 그 «최종» 골을 써야 한다.
-    const goalFile = await intakeClarifications(authored, input, deps, selfResolveClarifications);
+    const goalFile = await intakeClarifications({
+      ...authored,
+      path: isAbsolutePath(authored.path) ? authored.path : resolvePath(deps.cwd(), authored.path),
+    }, input, deps, selfResolveClarifications);
+    // The child reads this file again. Filtering only preflight.paths would leave the same bogus
+    // TRACED PATHS prose in the child and repeat its missing-file failure.
+    let sanitizeFailed = false;
+    let sanitizeFailure: unknown;
+    if (existsSync(goalFile)) {
+      try {
+        const original = deps.readFile(goalFile);
+        const sanitized = discardNonFileTracedPathItems(original, deps.cwd());
+        if (sanitized.dropped.length > 0) {
+          // The child reads this same file, so a failed rewrite must stop launch.
+          (deps.writeGoalDocument ?? deps.writeFile)(goalFile, sanitized.document);
+          for (const dropped of sanitized.dropped) {
+            try { debug.log('harness.preflight', 'traced-path-discarded', { goalFile, dropped }); }
+            catch { /* observation must not change launch */ }
+          }
+        }
+      } catch (error) {
+        sanitizeFailed = true;
+        sanitizeFailure = error;
+      }
+    }
     const preflightDeps = await deps.buildPreflightDeps();
     observeLaunchingTree(deps, preflightDeps);
     const askOutsidePathHints = parseAskTargetPathHintsResult(input.askText).paths;
@@ -954,11 +981,11 @@ export async function runAskLaunchFlow(
         ...(machineSuggestedTargetPaths.length > 0 ? { machineSuggestedTargetPaths } : {}),
         declaredPathsRoot: deps.cwd(),
       },
-      preflightDeps,
+      sanitizeFailed ? { ...preflightDeps, readGoalDocument: () => { throw sanitizeFailure; } } : preflightDeps,
       input.forceRequested,
     );
     const preflight = decision.result;
-    deps.print(renderLaunchPreflight(preflight, input.forceRequested && preflight.blockers.length > 0, 'before-launch'));
+    deps.print(renderLaunchPreflight(preflight, input.forceRequested && decision.shouldLaunch && preflight.blockers.length > 0, 'before-launch'));
     observeLaunchPreflight(deps, 'before-launch', decision);
     // ⛔ 자식 격리 worktree를 만들기 전, 이 흐름을 호출한 작업 트리에서만 센다.
     //    이 관측은 발사 판정의 입력이 아니다 — 의도적으로 옛 판에서 쏘는 경우도 있다.
@@ -1001,7 +1028,7 @@ export async function runAskLaunchFlow(
       liveRunWindowMs: preflight.liveRunWindowMs,
       // ⛔ 「플래그를 줬다」와 「실제로 뚫었다」는 다른 값이다(리뷰 should-fix).
       forceRequested: input.forceRequested,
-      bypassed: input.forceRequested && preflight.blockers.length > 0,
+      bypassed: input.forceRequested && decision.shouldLaunch && preflight.blockers.length > 0,
     }, preflight.blockers.length > 0 ? 'warn' : 'info');
     return { goalFile, decision };
   };
@@ -1023,14 +1050,27 @@ export async function runAskLaunchFlow(
       } catch (error) {
         candidates = { tokens: [], paths: [], error: error instanceof Error ? error.message : String(error) };
       }
+      const selectedPath = candidates.selection?.path
+        ?? (!candidates.selection && candidates.paths.length === 1 ? candidates.paths[0] : undefined);
+      const selectionReason = candidates.selection?.reason
+        ?? (candidates.error ? 'search-error' : selectedPath ? 'only-candidate'
+          : candidates.paths.length > 0 ? 'ambiguous-without-evidence' : 'no-candidates');
       deps.log('ask-auto-target-candidates', {
         tokens: candidates.tokens, paths: candidates.paths,
+        evidence: candidates.evidence ?? [],
+        selection: { path: selectedPath ?? null, reason: selectionReason },
         ...(candidates.error === undefined ? {} : { error: candidates.error }),
-      }, candidates.error === undefined ? 'info' : 'warn');
+      }, candidates.error === undefined && selectedPath ? 'info' : 'warn');
     }
-    const selectedPaths = candidates.paths.slice(0, 1);
+    const selectedPaths = candidates.selection?.path
+      ? [candidates.selection.path]
+      : !candidates.selection && candidates.paths.length === 1 ? [candidates.paths[0]!] : [];
     if (selectedPaths.length > 0) {
       deps.print(`[ask] ⑴ 코드에서 후보 경로 ${selectedPaths.length}개를 찾아 넣고 다시 저작한다: ${selectedPaths.join(' · ')}`);
+    } else if (candidates.paths.length > 0) {
+      deps.print(`[ask] ⑴ ⚠️ 후보 경로를 하나로 판정할 근거가 없다. 대상 경로를 확인해야 한다: ${candidates.paths.join(' · ')}`);
+    } else {
+      deps.print('[ask] ⑴ ⚠️ 자동 재저작에 넣을 대상 경로 후보가 없다. 대상 경로를 확인해야 한다');
     }
     authored = await authorAndPreflight(selectedPaths.length > 0
       ? `대상 경로: ${selectedPaths.join(' · ')}\n${input.askText}`

package/src/self-dev/ask-path-candidates.ts

@@ -1,15 +1,31 @@
 import { execFileSync } from 'node:child_process';
 import { statSync } from 'node:fs';
-import { isAbsolute, relative, resolve } from 'node:path';
+import { basename, extname, isAbsolute, relative, resolve } from 'node:path';
 
 export interface AskPathCandidateOptions {
   readonly cwd: string;
   readonly run?: (command: string, args: readonly string[], options: { cwd: string; encoding: 'utf8' }) => string;
 }
 
-export type AskPathCandidates =
-  | { readonly tokens: string[]; readonly paths: string[]; readonly error?: undefined }
-  | { readonly tokens: string[]; readonly paths: string[]; readonly error: string };
+export interface AskPathCandidates {
+  readonly tokens: string[];
+  readonly paths: string[];
+  readonly evidence?: AskPathEvidence[];
+  readonly selection?: AskPathSelection;
+  readonly error?: string;
+}
+
+export interface AskPathEvidence {
+  readonly path: string;
+  readonly pathTokens: string[];
+  readonly strongestPathMatch: 'explicit-file' | 'filename' | 'directory' | null;
+  readonly contentTokens: string[];
+  readonly score: number;
+}
+
+export type AskPathSelection =
+  | { readonly path: string; readonly reason: 'unique-strongest-evidence' }
+  | { readonly path: null; readonly reason: 'tied-strongest-evidence' };
 
 const STOP_WORDS = new Set(['the', 'and', 'test', 'src', 'scripts', 'file', 'path', 'paths', 'code', 'with', 'from', 'this', 'that', 'into', 'for', 'then', 'when', 'have', 'does', 'should', 'will', 'please', 'target', 'change']);
 const WORD = /[-/]?[A-Za-z][A-Za-z0-9_.-]*(?:\/[A-Za-z0-9_.-]+)*/g;
@@ -63,7 +79,15 @@ function existingFile(fragment: string, cwd: string): string | null {
 
 /** Find existing code paths by lexical evidence from an unmodified ask. */
 export function findAskPathCandidates(askText: string, { cwd, run = execFileSync }: AskPathCandidateOptions): AskPathCandidates {
-  const scores = new Map<string, Set<string>>();
+  const scores = new Map<string, { explicit: Set<string>; filename: Set<string>; directory: Set<string>; content: Set<string> }>();
+  const hitsFor = (path: string) => {
+    let hits = scores.get(path);
+    if (!hits) {
+      hits = { explicit: new Set(), filename: new Set(), directory: new Set(), content: new Set() };
+      scores.set(path, hits);
+    }
+    return hits;
+  };
   const tokens: string[] = [];
   const seen = new Set<string>();
   const body = stripAskWrapper(askText);
@@ -73,11 +97,7 @@ export function findAskPathCandidates(askText: string, { cwd, run = execFileSync
       const raw = match[0];
       const token = raw.replace(/^\//, '');
       const file = existingFile(token, cwd);
-      if (file) {
-        const hits = scores.get(file) ?? new Set<string>();
-        hits.add(token);
-        scores.set(file, hits);
-      }
+      if (file) hitsFor(file).explicit.add(token);
       if (STOP_WORDS.has(token.toLowerCase()) || isGenericToken(token) || seen.has(token)) continue;
       if (!file && !token.includes('/') && !token.includes('.') && !token.includes('-') && !token.includes('_')
         && !/[a-z][A-Z]/.test(token) && token.length < 4) continue;
@@ -85,6 +105,24 @@ export function findAskPathCandidates(askText: string, { cwd, run = execFileSync
       tokens.push(token);
     }
   }
+  if (tokens.length > 0) {
+    let files: string;
+    try {
+      files = run('rg', ['--files', '--glob', '!*.test.ts', 'src', 'scripts'], { cwd, encoding: 'utf8' });
+    } catch (error) {
+      if ((error as { status?: number }).status === 1) files = '';
+      else return { tokens, paths: [], error: error instanceof Error ? error.message : String(error) };
+    }
+    for (const path of files.split(/\r?\n/).filter(Boolean)) {
+      const fileStem = basename(path, extname(path)).toLowerCase();
+      const directories = path.toLowerCase().split('/').slice(0, -1);
+      for (const token of tokens) {
+        const lower = token.toLowerCase();
+        if (fileStem === lower || basename(path).toLowerCase() === lower) hitsFor(path).filename.add(token);
+        else if (directories.includes(lower)) hitsFor(path).directory.add(token);
+      }
+    }
+  }
   for (const token of tokens) {
     let matches: string;
     try {
@@ -94,13 +132,30 @@ export function findAskPathCandidates(askText: string, { cwd, run = execFileSync
       return { tokens, paths: [], error: error instanceof Error ? error.message : String(error) };
     }
     for (const path of matches.split(/\r?\n/).filter(Boolean)) {
-      const hits = scores.get(path) ?? new Set<string>();
-      hits.add(token);
-      scores.set(path, hits);
+      hitsFor(path).content.add(token);
     }
   }
+  const evidence = [...scores].map<AskPathEvidence>(([path, hits]) => {
+    const tier = hits.explicit.size > 0 ? 3 : hits.filename.size > 0 ? 2 : hits.directory.size > 0 ? 1 : 0;
+    return {
+      path,
+      pathTokens: [...new Set([...hits.explicit, ...hits.filename, ...hits.directory])],
+      strongestPathMatch: tier === 3 ? 'explicit-file' : tier === 2 ? 'filename' : tier === 1 ? 'directory' : null,
+      contentTokens: [...hits.content],
+      // Lexicographic tiers: even many directory hits cannot outrank one filename hit.
+      score: tier * 1000 + Math.min(hits.explicit.size + hits.filename.size + hits.directory.size, 9) * 100
+        + Math.min(hits.content.size, 99),
+    };
+  }).sort((a, b) => b.score - a.score || a.path.localeCompare(b.path, 'en'));
+  const top = evidence[0];
   return {
     tokens,
-    paths: [...scores].sort(([a, aHits], [b, bHits]) => bHits.size - aHits.size || a.localeCompare(b, 'en')).slice(0, 5).map(([path]) => path),
+    paths: evidence.slice(0, 5).map(({ path }) => path),
+    ...(top ? {
+      evidence: evidence.slice(0, 5),
+      selection: evidence[1]?.score === top.score
+        ? { path: null, reason: 'tied-strongest-evidence' as const }
+        : { path: top.path, reason: 'unique-strongest-evidence' as const },
+    } : {}),
   };
 }

package/src/self-dev/decompose-proposal.ts

@@ -348,7 +348,31 @@ export interface DecomposeApplication {
  *   ⓐ 같은 goal 을 «두 번» 쪼개지 않는다(alreadyDecomposed)
  *   ⓑ 조각이 둘 미만인 제안은 애초에 안 온다(pickDecomposeProposals 가 거른다)
  *   ⓒ 상한을 넘기면 «쪼개지 않는다» — 조각이 무한히 불어나는 것을 막는다
+ *
+ * ⭐ **조각은 원 골의 «대상 경로:» 머리줄을 물려받는다** (DECOMPOSE-PIECE-TARGET-LINE · 10-11 부검 run-76941fca):
+ *   조각 feature 가 골을 «통째로» 갈아 끼우면 첫 줄 선언이 사라져 Pod 예비 검사가 «대상 경로 0» →
+ *   재저작 NOT-GROUNDED 로 조각 전부가 exit 1 했다. 좁히는 규칙 = 원 선언 경로 중 조각 문장에
+ *   나오는 것만(없으면 원 선언 전부) · «신설:» 줄도 같은 규칙 · 첫 줄이 라벨이 아니면 지금 그대로.
  */
+
+// ── 머리줄 선언을 읽고 좁히는 순수 조각 (위 규칙의 실물) ──────────────────────────
+const TARGET_PATHS_LINE = /^대상 경로:[ \t]*(.*)$/;
+const NEW_PATHS_LINE = /^신설:[ \t]*(.*)$/;
+
+/** 선언 줄의 경로를 나눈다 — « · »·쉼표(`goal-new-paths` 와 같은 분리 규칙). 유효성은 걸러내지 않는다: 선언 그대로다. */
+function splitDeclaredPaths(payload: string): string[] {
+  return payload.split(/[·,]/).map((token) => token.trim()).filter((token) => token.length > 0);
+}
+
+/** 조각 문장에 «나오는» 선언 경로만 남긴다. 하나도 안 나오면 원 선언 전부 — 선언 밖 경로는 지어내지 않는다. */
+function narrowDeclaredPaths(declared: readonly string[], pieceFeature: string): string[] {
+  const mentioned = declared.filter((path) => {
+    const escaped = path.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`(^|[^\\w./-])${escaped}(?=$|[^\\w./-]|\\.(?:\\s|$))`).test(pieceFeature);
+  });
+  return mentioned.length ? mentioned : [...declared];
+}
+
 export function applyDecomposeProposals(
   goals: readonly SelfDevGoal[],
   results: readonly SelfDevJobResult[],
@@ -374,11 +398,29 @@ export function applyDecomposeProposals(
     // ⛔ 상한을 넘기면 «쪼개지 않는다» — 조용히 자르지 않고 원본을 그대로 둔다.
     if (out.length + pieces.length + (goals.length - out.length - 1) > maxGoals) { out.push(goal); continue; }
     decomposed.push(goal.feature);
+    // 원 골의 머리줄 선언 — 첫 줄이 «대상 경로:» 가 아니면 조각은 지금 그대로(바이트 불변)다.
+    const goalLines = goal.feature.split('\n');
+    const targetLine = TARGET_PATHS_LINE.exec(goalLines[0] ?? '');
+    // «신설:» 상속은 머리줄 선언이 «있을 때만» — 첫 줄이 라벨이 아니면 조각은 바이트 불변이어야 한다.
+    const newLine = targetLine ? goalLines.map((line) => NEW_PATHS_LINE.exec(line)).find((m) => m !== null) : null;
     for (const piece of pieces) {
+      const inherited: string[] = [];
+      let paths: string[] = [];
+      if (targetLine) {
+        const declared = splitDeclaredPaths(targetLine[1]!);
+        paths = declared.length ? narrowDeclaredPaths(declared, piece.feature) : declared;
+        // 선언이 비어 있으면 원 줄을 그대로 실는다 — 라벨만이라도 예비 검사가 읽게 한다.
+        inherited.push(declared.length ? `대상 경로: ${paths.join(' · ')}` : goalLines[0]!);
+      }
+      if (newLine) {
+        const declaredNew = splitDeclaredPaths(newLine[1]!);
+        const narrowedNew = declaredNew.length ? narrowDeclaredPaths(declaredNew, piece.feature) : declaredNew;
+        inherited.push(declaredNew.length ? `신설: ${narrowedNew.join(' · ')}` : newLine[0]!);
+      }
       out.push({
         ...goal,                       // 승격 플래그(openPr·autoReview·autoMerge·base)를 물려받는다
         id: piece.id,
-        feature: piece.feature,
+        feature: inherited.length ? [...inherited, piece.feature].join('\n') : piece.feature,
         ...(piece.dependsOn.length ? { dependsOn: [...piece.dependsOn] } : {}),
         // ⛔⭐ `...goal` 이 «부모의» hotPaths 를 그대로 흘린다 — 그러면 조각 전부가 서로 겹쳐
         //   `orchestrate.ts` 가 전부를 직렬화한다(위상이 아니라 «한 줄»이 된다).

package/src/self-dev/graph-journey-nodes.ts

@@ -37,6 +37,8 @@ export const JOURNEY_NODE_IDS = [
   'salvage',
   'heal',
   'next-move',
+  'ready',
+  'pr-head-checkout',
   'stopped',
 ] as const;
 export type JourneyNodeId = typeof JOURNEY_NODE_IDS[number];

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

@@ -17,7 +17,7 @@ export interface LiveRunOverlapPath {
 
 /** 검사 대상 한 건이 막힌 이유. `name` 은 사람이 바로 열어 볼 수 있는 식별자다. */
 export interface LaunchPreflightBlocker {
-  readonly kind: 'open-pr' | 'sibling-pr' | 'live-run' | 'no-target-paths' | 'recent-change' | 'ask-outside-path' | 'ask-marker';
+  readonly kind: 'open-pr' | 'sibling-pr' | 'live-run' | 'no-target-paths' | 'missing-traced-path' | 'goal-unreadable' | 'recent-change' | 'ask-outside-path' | 'ask-marker';
   /** `#8100` · `run-6ce5765b…` 처럼 «바로 조회 가능한» 이름. */
   readonly name: string;
   /** 왜 막혔는지 한 줄 — 경로와 수를 포함한다. */
@@ -490,6 +490,10 @@ export function renderLaunchPreflight(
   }
   lines.push(`[preflight] ⛔ 막는 것 ${result.blockers.length}건${forced ? '' : ' — 발사하지 않는다'}`);
   for (const blocker of result.blockers) lines.push(`[preflight]   · ${blocker.name} — ${blocker.detail}`);
+  if (result.blockers.some((blocker) => blocker.kind === 'missing-traced-path' || blocker.kind === 'goal-unreadable')) {
+    lines.push('[preflight] 골 판독 실패 또는 traced path 오류는 --force-preflight 로 우회할 수 없다 — 골 문서와 경로를 바로잡아야 한다');
+    return lines.join('\n');
+  }
   lines.push(forced
     ? '[preflight] ⚠️ --force-preflight — 위 막힘을 «뚫고» 발사한다 (이 우회는 관측에 남는다)'
     : '[preflight] 그래도 가려면 --force-preflight (그 우회는 관측에 남는다) — elanous dev');