elanous 0.2.25 → 0.2.28

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/draft-sweep.ts

@@ -33,7 +33,7 @@ export interface DraftSweepAdapters {
   /** Undefined means liveness could not be established. */
   listLiveBranches(repository: string): Promise<ReadonlySet<string> | undefined>;
   setLabels(repository: string, number: number, change: { add: string; remove: readonly string[] }): Promise<void>;
-  closeDraft(repository: string, number: number, comment: string): Promise<void>;
+  closeDraft(repository: string, number: number): Promise<void>;
   /** Resolve the latest claim comment owner; a failed lookup must not authorize a close. */
   getClaimOwner?(repository: string, number: number): Promise<string | undefined>;
   /** Current owner, accounting for a later claim release; only draft metrics need this distinction. */
@@ -478,6 +478,23 @@ const label = (action: 'mark-stalled' | 'close', name?: string): string => {
 const runningLabel = label('mark-stalled');
 const stalledLabel = label('close', 'stalled');
 const supersededLabel = label('close', 'superseded');
+
+/** Keep repository labels bounded; the complete reason and PR number live in the closed event. */
+export function sweptReasonLabel(reason: string): string {
+  const kinds = ['superseded-by', 'duplicate-of-open', 'claim-expired', 'stale-unobserved',
+    'harvest-expired', 'stale-ended-run'] as const;
+  const kind = kinds.find((name) => reason === name || reason.startsWith(`${name} `)) ?? 'other';
+  return `elanous:swept:${kind}`;
+}
+
+async function closeSweptDraft(adapters: Pick<DraftSweepAdapters, 'setLabels' | 'closeDraft'>,
+  repository: string, number: number, reason: string, onLabelApplied?: () => void): Promise<void> {
+  await adapters.setLabels(repository, number, { add: sweptReasonLabel(reason), remove: [] });
+  onLabelApplied?.();
+  await adapters.closeDraft(repository, number);
+  try { debug.log('self-dev.draft-sweep', 'closed', { pr: number, reason }); } catch { /* fail-soft */ }
+}
+
 const approvalLabel = PR_LABELS.find((entry) => entry.axis === 'state' && entry.sweep.action === 'none')?.name;
 const keepLabel = PR_LABELS.find((entry) => entry.sweep.action === 'exclude')?.name;
 const benchLabel = PR_LABELS.find((entry) => entry.name === 'elanous:bench')!.name;
@@ -572,8 +589,7 @@ export async function supersedeDraftsOnMerge(input: {
       try {
         // Label first: a failed label write must never strand a closed, unlabelled PR outside open-draft sweeps.
         if (!draft.labels.includes(supersededLabel)) await adapters.setLabels(repository, draft.number, { add: supersededLabel, remove });
-        await adapters.closeDraft(repository, draft.number,
-          `Draft sweep: superseded-by #${merged.number} (https://github.com/${repository}/pull/${merged.number}). Branch preserved.`);
+        await closeSweptDraft(adapters, repository, draft.number, decision.reason);
         closed.push(draft.number);
       } catch (failure) {
         kept.push(draft.number);
@@ -975,8 +991,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
                 });
                 labelsChanged = true;
               }
-              await adapters.closeDraft(repository, draft.number,
-                `Draft sweep: ${reason} (https://github.com/${repository}/pull/${lineageNewer.number}). Branch preserved.`);
+              await closeSweptDraft(adapters, repository, draft.number, reason, () => { labelsChanged = true; });
               entry.applied = true;
             } catch (error) {
               if (labelsChanged) entry.partialApplied = true;
@@ -1035,11 +1050,10 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       if (!apply || action !== 'close') continue;
       let labelsChanged = false;
       try {
-        const owner = await adapters.getClaimOwner?.(repository, draft.number) ?? '미상';
+        await adapters.getClaimOwner?.(repository, draft.number);
         await adapters.setLabels(repository, draft.number, { add: stalledLabel, remove: [runningLabel] });
         labelsChanged = true;
-        await adapters.closeDraft(repository, draft.number,
-          `Draft sweep: 처리 중 표식이 ${CLAIM_IDLE_HOURS}시간 갱신 없음 — ${runStatus === 'self-implement.result final' ? 'self-implement.result final · 남은 워크트리는 live 아님' : '런·워크트리 없음'} · 주인 ${owner}. Closed as stalled. Branch preserved; reopen to restore.`);
+        await closeSweptDraft(adapters, repository, draft.number, entry.reason, () => { labelsChanged = true; });
         entry.applied = true;
       } catch (error) {
         if (labelsChanged) entry.partialApplied = true;
@@ -1085,12 +1099,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
         labelsChanged = true;
       }
       if (action === 'close') {
-        await adapters.closeDraft(repository, draft.number, decision.reason === 'stale-unobserved'
-          ? `Draft sweep: run unobserved — no run record reachable here, no host worktree for this branch, idle ≥${STALLED_DRAFT_HOURS}h. Closed as stalled. Branch preserved; reopen to restore.`
-          : decision.reason === 'harvest-expired'
-          ? `Draft sweep: harvest-expired — 종단이 수확 대상으로 표시한 뒤 ${STALLED_DRAFT_HOURS}h 동안 수확 없음. Branch preserved; reopen to restore.`
-          : `Draft sweep: ${decision.reason}${decision.reason.startsWith('superseded-by #')
-            ? ` (https://github.com/${repository}/pull/${decision.reason.slice('superseded-by #'.length).match(/^\d+/)![0]})` : ''}. Branch preserved.`);
+        await closeSweptDraft(adapters, repository, draft.number, reason, () => { labelsChanged = true; });
       }
       entry.applied = labelsChanged || action === 'close';
     } catch (error) {

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');

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

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

package/src/self-dev/orchestrate.ts

@@ -23,6 +23,7 @@ import { parentUnlandedProgressLine } from './run-supervisor.js';
 import { mkdirSync, openSync, writeFileSync, closeSync, renameSync, unlinkSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { goalPathFromArgv, launchRegistryDir, removeLaunchBinding, writeLaunchBinding } from '../harness/launch-registry.js';
+import { psProcessStartMs } from '../harness/harness-stop.js';
 import { adoptRunCard } from '../task-agent/run-adopt.js';
 import { availableParallelism, cpus } from 'node:os';
 import { selfDevRunsDir } from './run-store.js';
@@ -912,12 +913,15 @@ async function deleteLabelledJobs(runId: string, selectedTargets: readonly { con
  *  take minutes before that, and a stop in that window found «no process» (10-01 · three runs). */
 export function writeRunPidRecord(runId: string, runsDir: string = selfDevRunsDir(), registryDir: string | null = launchRegistryDir()): string {
   const pidPath = join(runsDir, runId, 'pid.json');
+  // The observer reads `ps -o lstart=`, whose precision is one second. Record that same
+  // process birth value when available so a launch near a second boundary still matches.
+  const startedAt = psProcessStartMs(process.pid) ?? Date.now() - Math.floor(process.uptime() * 1000);
   mkdirSync(join(runsDir, runId), { recursive: true });
   const temporary = `${pidPath}.${process.pid}.${randomUUID()}.tmp`;
   const fd = openSync(temporary, 'wx', 0o600);
   try {
     try {
-      writeFileSync(fd, JSON.stringify({ pid: process.pid, startedAt: Date.now() - Math.floor(process.uptime() * 1000), argv0: process.argv0 }));
+      writeFileSync(fd, JSON.stringify({ pid: process.pid, startedAt, argv0: process.argv0 }));
     } finally { closeSync(fd); }
     renameSync(temporary, pidPath);
   } catch (error) { unlinkSync(temporary); throw error; }
@@ -925,7 +929,7 @@ export function writeRunPidRecord(runId: string, runsDir: string = selfDevRunsDi
   if (registryDir !== null) {
     const cwd = process.cwd();
     const goalPath = goalPathFromArgv(process.argv, cwd);
-    writeLaunchBinding(runId, { pid: process.pid, startedAt: Date.now() - Math.floor(process.uptime() * 1000), argv0: process.argv0,
+    writeLaunchBinding(runId, { pid: process.pid, startedAt, argv0: process.argv0,
       cwd, ...(goalPath ? { goalPath } : {}), runsDir: resolve(runsDir),
       ...(process.env.ELANOUS_POD_NAME ? { podName: process.env.ELANOUS_POD_NAME } : {}),
       ...(process.env.ELANOUS_TASK_CARD_ID ? { taskCardId: process.env.ELANOUS_TASK_CARD_ID } : {}) }, registryDir);

package/src/self-dev/run-supervisor.ts

@@ -9,7 +9,8 @@ import { recordSelfDevRunSupervisorStop, selfDevRunsDir } from './run-store.js';
 import { debug } from '../debug/log.js';
 import { sweepFrozenMerges } from '../self-implement/frozen-merges.js';
 import { routeSupervisorVerdict } from './supervisor-verdict-edges.js';
-import { recordTaskAgentShadowMove, type TaskAgentShadowInput } from '../task-agent/shadow.js';
+import { recordTaskAgentShadowMove, runCardFor, type TaskAgentShadowInput } from '../task-agent/shadow.js';
+import { cardPrNumber, taskAgentStatePath } from '../task-agent/task-hand.js';
 
 export interface SupervisorRound {
   round: number;
@@ -641,6 +642,12 @@ export interface SuperviseRunOptions {
    * `false` 면 끈다. 던져도 런의 결말은 바뀌지 않는다(fail-soft).
    */
   taskAgentShadow?: ((input: TaskAgentShadowInput) => unknown) | false;
+  /** TA-LAND-AFTER-REVIEW — false disables the hook; function replaces only the final rejudge for isolated tests. */
+  taskAgentRejudge?: ((cardId: string, statePath: string) => Promise<unknown>) | false;
+  /** Test-only external I/O for the real completion rejudge. The decision and shadow gate remain production code. */
+  taskAgentRejudgeExternal?: Parameters<typeof import('../task-agent/rejudge-on-head.js').rejudgeAsyncResultCard>[2];
+  /** Isolated state ledger for the terminal rejudge test; production uses the active instance. */
+  taskAgentStatePath?: string;
   observeDeliverables?: () => Promise<{
     readonly deployFindings: ReadonlyMap<string, { target: string; findings?: readonly DeployVerifyFinding[] | readonly unknown[] }>;
     readonly unmeasured: readonly unknown[];
@@ -658,6 +665,23 @@ function resolveSupervisorStopStorage(runStore: SuperviseRunOptions['runStore'])
   return { path: selfDevRunsDir(), source: 'process-default' };
 }
 
+/** The supervisor's terminal hook, limited to a uniquely run-bound TA land card. */
+export async function rejudgeTerminalTaskCard(runId: string | null, deps: {
+  statePath?: string;
+  env?: NodeJS.ProcessEnv;
+  rejudgeCard?: (cardId: string, statePath: string) => Promise<unknown>;
+  external?: Parameters<typeof import('../task-agent/rejudge-on-head.js').rejudgeAsyncResultCard>[2];
+} = {}): Promise<void> {
+  const statePath = deps.statePath ?? taskAgentStatePath();
+  const card = runCardFor(runId, { statePath, ...(deps.env ? { env: deps.env } : {}) });
+  if (!card || card.status !== 'launched' || card.taLand !== true || cardPrNumber(card) === undefined) return;
+  const { rejudgeAsyncResultCard } = await import('../task-agent/rejudge-on-head.js');
+  const result = await (deps.rejudgeCard ?? ((id, path) => rejudgeAsyncResultCard(id, path, deps.external)))(card.id, statePath);
+  const { requireSuccessfulRejudge } = await import('../task-agent/rejudge-on-head.js');
+  requireSuccessfulRejudge(result);
+  try { debug.log('task-agent', 'terminal-rejudge', { runId, card: card.id }); } catch { /* fail-soft */ }
+}
+
 export async function superviseRun(opts: SuperviseRunOptions): Promise<SupervisorJobResult[]> {
   let results = [...opts.initial];
   let history: SupervisorRound[] = [];
@@ -808,6 +832,16 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
         } catch (error) {
           try { debug.log('task-agent', 'shadow-move-failed', { runId, stopReason: decision.stopReason, error: String(error) }); } catch { /* fail-open */ }
         }
+        if (opts.taskAgentRejudge !== false) {
+          const rejudgeOptions = { ...(opts.taskAgentStatePath ? { statePath: opts.taskAgentStatePath } : {}), ...(opts.taskAgentRejudge ? { rejudgeCard: opts.taskAgentRejudge } : {}), ...(opts.taskAgentRejudgeExternal ? { external: opts.taskAgentRejudgeExternal } : {}) };
+          try { await rejudgeTerminalTaskCard(runId, rejudgeOptions); }
+          catch (error) {
+            try { await rejudgeTerminalTaskCard(runId, rejudgeOptions); }
+            catch (retryError) {
+              try { debug.log('task-agent', 'terminal-rejudge-failed', { runId, stopReason: decision.stopReason, error: String(retryError), firstError: String(error), attempts: 2 }); } catch { /* fail-open */ }
+            }
+          }
+        }
       }
       return results;
     }

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

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

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

@@ -51,6 +51,9 @@ import { hasGoalStepCodeName } from './goal-step-code-name.js';
 import { targetScopedGoalText } from './goal-text-path-scope.js';
 import { parseReleaseNoteSection } from '../release-loop/release-note.js';
 import { declaredNewFilePaths } from './goal-new-paths.js';
+import { classifyGoalCommandExecution, type GoalCommandExecutionResult } from './goal-command-execution.js';
+export { classifyGoalCommandExecution } from './goal-command-execution.js';
+export type { GoalCommandExecutionKind, GoalCommandExecutionResult, GoalCommandExecutionClassification } from './goal-command-execution.js';
 
 // ⭐ `situation`/`complication` 은 **선택**이다 — 안 오면 `scqaNarrative` 가 종전 문면을 쓴다.
 //   ⛔ 필수로 만들지 않는다: 그러면 인핸싱이 폴백으로 떨어진 저작(LLM 실패·`disabled`)이 전부 죽는다.
@@ -439,33 +442,6 @@ export function canonicalStructureFinding(
   return finding;
 }
 
-export type GoalCommandExecutionKind = 'success' | 'missing-command' | 'argument-problem' | 'execution-failure';
-
-export interface GoalCommandExecutionResult {
-  readonly status: number | null;
-  readonly stderr: string;
-}
-
-export interface GoalCommandExecutionClassification {
-  readonly kind: GoalCommandExecutionKind;
-  readonly log: string;
-}
-
-/** Classifies an already-observed Commander result without executing a command. */
-export function classifyGoalCommandExecution(result: GoalCommandExecutionResult): GoalCommandExecutionClassification {
-  // A clean exit is authoritative: stderr text from a successful command is not a failure signal.
-  if (result.status === 0) return { kind: 'success', log: 'command completed successfully' };
-
-  const stderr = result.stderr;
-  if (stderr.includes('unknown command') || stderr.includes('unknown option')) {
-    return { kind: 'missing-command', log: 'command is not recognized; this may be not yet implemented rather than a defect' };
-  }
-  if (stderr.includes('missing required argument') || stderr.includes('required option')) {
-    return { kind: 'argument-problem', log: 'command requires a missing argument or option' };
-  }
-  return { kind: 'execution-failure', log: `command execution failed with code ${String(result.status)}` };
-}
-
 /** Optional repository-bounded source reader. Legacy null means the referenced path is missing. */
 export interface GoalFileLintDeps {
   readReferencedFile?: (repositoryRelativePath: string) => string | null | ReferencedFileReadResult;
@@ -1725,7 +1701,8 @@ export function lintGoalFile(document: string, branch: string, deps: GoalFileLin
   }
   if (deps.readReferencedFile) {
     // AUTHOR-NEW-FILE-PATHS — 문서가 «새로 만들 파일»로 선언한 경로. 실행 쪽 범위 검사와 같은 줄을 읽는다.
-    const declaredNew = new Set(declaredNewFilePaths(document));
+    // 저작과 실행은 같은 Original ask 범위만 선언으로 인정한다. 문서의 다른 절은 근거일 뿐이다.
+    const declaredNew = new Set(declaredNewFilePaths(extractVerbatimOriginalAsk(document)?.ask ?? ''));
     for (const reference of tracedPathReferences(document)) {
       const result = deps.readReferencedFile(reference.path);
       const normalized = typeof result === 'string' ? { kind: 'ok' as const, contents: result }

package/src/self-implement/goal-command-execution.ts

@@ -0,0 +1,26 @@
+export type GoalCommandExecutionKind = 'success' | 'missing-command' | 'argument-problem' | 'execution-failure';
+
+export interface GoalCommandExecutionResult {
+  readonly status: number | null;
+  readonly stderr: string;
+}
+
+export interface GoalCommandExecutionClassification {
+  readonly kind: GoalCommandExecutionKind;
+  readonly log: string;
+}
+
+/** Classifies an already-observed Commander result without executing a command. */
+export function classifyGoalCommandExecution(result: GoalCommandExecutionResult): GoalCommandExecutionClassification {
+  // A clean exit is authoritative: stderr text from a successful command is not a failure signal.
+  if (result.status === 0) return { kind: 'success', log: 'command completed successfully' };
+
+  const stderr = result.stderr;
+  if (stderr.includes('unknown command') || stderr.includes('unknown option')) {
+    return { kind: 'missing-command', log: 'command is not recognized; this may be not yet implemented rather than a defect' };
+  }
+  if (stderr.includes('missing required argument') || stderr.includes('required option')) {
+    return { kind: 'argument-problem', log: 'command requires a missing argument or option' };
+  }
+  return { kind: 'execution-failure', log: `command execution failed with code ${String(result.status)}` };
+}

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);