elanous 0.2.28 → 0.2.31

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

@@ -24,6 +24,7 @@
 
 import { readdirSync, readFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
+import { debug } from '../debug/log.js';
 import { runLedgerDir } from '../self-implement/run-ledger.js';
 import type { SelfDevGoal, SelfDevJobResult } from './orchestrate.js';
 
@@ -36,10 +37,23 @@ export interface DecomposePiece {
   hotPaths?: readonly string[];
 }
 
+/** 형제 겹침 한 쌍 — 같은 hotPaths 를 만지는 조각 «둘» (a 가 배열에서 앞선 조각이다). */
+export interface HotPathOverlap {
+  a: string;
+  b: string;
+  paths: readonly string[];
+}
+
 export interface DecomposeProposal {
   /** 이 제안을 소비할 키. shardId 가 있으면 그것, 없으면 원장 런의 runId 다. */
   shardId: string;
   pieces: DecomposePiece[];
+  /**
+   * 형제 겹침 — 같은 파일을 만지는 조각쌍 목록. ⓑ 겹침 간선 제거(2026-10-16) 후 겹침은
+   * 직렬화하지 않고 «여기» 남는다(관측 `hot-path-overlap` — 형제 맥락 주입 ②·OVERLAP-SIBLING-CTX MK 가 읽는다).
+   * 겹침이 없으면 빈 배열이다 — 키를 생략하지 않는다.
+   */
+  hotPathOverlaps: readonly HotPathOverlap[];
   /** 몇 번째 라운드의 제안인가(늦게 난 것이 이긴다). 없으면 모른다. */
   round?: number;
 }
@@ -55,7 +69,22 @@ type GoalPlanRevisionObservation = NonNullable<SelfDevJobResult['goalPlanRevisio
 type GoalPlanRevisionReadObservation = Extract<GoalPlanRevisionObservation, { status: 'read' }>;
 type GoalPlanRevisionReadFailureObservation = Extract<GoalPlanRevisionObservation, { status: 'read-failed' }>;
 
-/** 순수: 원장 엔트리들에서 조각별 «가장 늦은» 분해 제안을 뽑는다. */
+/** 형제 겹침을 계산한다 — 같은 hotPaths 를 만지는 조각쌍(«배열 앞선 것»이 a 다). 순수 함수. */
+function hotPathOverlapsOf(pieces: readonly DecomposePiece[]): HotPathOverlap[] {
+  const pairs: HotPathOverlap[] = [];
+  for (let i = 0; i < pieces.length; i++) {
+    const a = pieces[i]!;
+    if (!a.hotPaths?.length) continue;
+    for (let j = i + 1; j < pieces.length; j++) {
+      const b = pieces[j]!;
+      const paths = a.hotPaths.filter((path) => b.hotPaths?.includes(path));
+      if (paths.length) pairs.push({ a: a.id, b: b.id, paths });
+    }
+  }
+  return pairs;
+}
+
+/** 원장 엔트리들에서 조각별 «가장 늦은» 분해 제안을 뽑는다. 형제 겹침이 있으면 hot-path-overlap 관측을 낸다(fail-open). */
 export function pickDecomposeProposals(entries: readonly Ledgerish[]): Map<string, DecomposeProposal> {
   const out = new Map<string, DecomposeProposal>();
   for (const entry of entries) {
@@ -85,7 +114,18 @@ export function pickDecomposeProposals(entries: readonly Ledgerish[]): Map<strin
     const prior = out.get(shardId);
     // 늦은 라운드가 이긴다. 라운드를 모르면 나중에 온 것이 이긴다(원장은 append-only).
     if (prior && round !== undefined && prior.round !== undefined && prior.round > round) continue;
-    out.set(shardId, { shardId, pieces, ...(round === undefined ? {} : { round }) });
+    // ⛔ 겹침은 «버리지 않는다» — 간선을 만들지 않는 대신 형제 겹침으로 따로 세어 관측한다.
+    //    형제 맥락 주입(②·OVERLAP-SIBLING-CTX MK)이 이 목록을 읽는다. 관측이 실패해도 읽기는 막지 않는다.
+    const hotPathOverlaps = hotPathOverlapsOf(pieces);
+    if (hotPathOverlaps.length) {
+      try { debug.log('self-dev.decompose', 'hot-path-overlap', { pairs: hotPathOverlaps }); } catch { /* fail-open */ }
+    }
+    out.set(shardId, {
+      shardId,
+      pieces,
+      hotPathOverlaps,
+      ...(round === undefined ? {} : { round }),
+    });
   }
   return out;
 }
@@ -97,7 +137,7 @@ export interface DecomposePieceOrdering {
   ordered?: DecomposePiece[];
   /** `dependsOn` 에서 «실제로 이어진» 간선 수. */
   dependsOnEdges: number;
-  /** `hotPaths` 겹침에서 파생된 간선 수. ⛔ 위와 «따로» 센다 — 합치면 어느 축이 일했는지 못 본다. */
+  /** `hotPaths` 겹침 간선 수. ⓑ 간선 제거(2026-10-16) 후에는 «항상 0» — 옛 독자를 위해 필드는 남는다. */
   hotPathEdges: number;
   /** `dependsOn` 이 «조각 목록에 없는 id» 를 가리켜 버린 수. 0 이 아니면 분해기 산출이 어긋난 것이다. */
   danglingDependsOn: number;
@@ -113,15 +153,10 @@ export interface DecomposePieceOrdering {
  *   📏 실측(2026-09-06 · `decomposition-shadow-goals` 전수): 분해 표본 13건 중 의존 0 = **0건**
  *     ⇒ 승격 가능 **0/13 = 0%**. 원장 132건 중 `attempted=true` 21건이 «전부» 실패했다.
  *
- * ⛔ 간선은 «두 축»이고 둘 다 「거부」가 아니라 「순서」다:
- *   ⓐ `dependsOn` — 분해기가 «의미»로 명시한 것.
- *   ⓑ `hotPaths` 겹침 — 같은 파일을 만지는 조각은 «앞선 것 먼저». 새로 만든 규칙이 아니라
- *      연합 경로 `orchestrate.ts:1105` 가 이미 쓰던 이 저장소의 «기존 결정»을 단일 경로에도 잇는 것이다.
- *
- * ⛔⭐ **두 축은 방향을 «다른 근거»로 정한다** — ⓐ 는 의미, ⓑ 는 배열 위치다.
- *   그래서 «섞어 걸면 가짜 순환»이 난다(B 가 A 에 의존하는데 B 가 배열 앞이면 A→B ⊕ B→A).
- *   ⇒ ⓐ 를 «먼저 전부» 걸고, ⓑ 는 반대 방향으로 이미 길이 있으면 «건너뛴다».
- *     건너뛰어도 안전한 이유: 길이 있다는 것은 그 둘이 «이미 직렬»이라는 뜻이고, ⓑ 의 목적이 직렬화다.
+ * ⛔ 간선은 «한 축»이다 — ⓐ `dependsOn`, 분해기가 «의미»로 명시한 것만 순서를 만든다.
+ *   ⓑ `hotPaths` 겹침 간선은 «제거됐다»(2026-10-16 · 대표 10-11 «겹침이라 미루는 현상 제거») —
+ *   겹침은 직렬화하지 않고 `DecomposeProposal.hotPathOverlaps` 로 형제 겹침으로 따로 남는다.
+ *   덕분에 ⓐ 와 배열 위치가 반대 방향을 가리켜 가짜 순환을 만들던 충돌 자체가 사라졌다.
  *
  * ⛔ 매달린 `dependsOn`(조각 목록에 없는 id)은 «버리고 센다» — 그것 때문에 승격 전체를 막지 않는다
  *   (연합 경로의 `pruneDanglingDependencies` 와 같은 판단).
@@ -135,7 +170,6 @@ export function orderPiecesTopologically(pieces: readonly DecomposePiece[]): Dec
   const edges: Set<number>[] = pieces.map(() => new Set<number>());
   const indegree = pieces.map(() => 0);
   let dependsOnEdges = 0;
-  let hotPathEdges = 0;
   let danglingDependsOn = 0;
 
   const addEdge = (from: number, to: number): boolean => {
@@ -155,28 +189,8 @@ export function orderPiecesTopologically(pieces: readonly DecomposePiece[]): Dec
     }
   });
 
-  /** `from` 에서 `to` 로 «이미» 갈 수 있나. 조각 상한이 24(maxGoals)라 단순 DFS 로 충분하다. */
-  const reaches = (from: number, to: number): boolean => {
-    const seen = new Set<number>([from]);
-    const stack = [from];
-    while (stack.length) {
-      const at = stack.pop()!;
-      if (at === to) return true;
-      for (const next of edges[at]!) if (!seen.has(next)) { seen.add(next); stack.push(next); }
-    }
-    return false;
-  };
-
-  // ⓑ hotPaths — 반대 방향으로 이미 길이 있으면 건너뛴다(가짜 순환 방지).
-  pieces.forEach((piece, index) => {
-    if (!piece.hotPaths?.length) return;
-    for (let earlier = 0; earlier < index; earlier++) {
-      const other = pieces[earlier]!;
-      if (!other.hotPaths?.some((path) => piece.hotPaths!.includes(path))) continue;
-      if (reaches(index, earlier)) continue;
-      if (addEdge(earlier, index)) hotPathEdges++;
-    }
-  });
+  // ⓑ hotPaths 겹침 간선은 제거됐다(2026-10-16) — 순서는 ⓐ dependsOn 만 만든다.
+  //    겹침은 pickDecomposeProposals 가 hotPathOverlaps 로 따로 세고, 여기서는 간선을 만들지 않는다.
 
   // Kahn — ready 는 «원래 index 오름차순»으로만 꺼낸다.
   const ordered: DecomposePiece[] = [];
@@ -195,12 +209,12 @@ export function orderPiecesTopologically(pieces: readonly DecomposePiece[]): Dec
   if (ordered.length !== pieces.length) {
     return {
       dependsOnEdges,
-      hotPathEdges,
+      hotPathEdges: 0,
       danglingDependsOn,
       cycle: pieces.filter((_, i) => !done[i]).map((piece) => piece.id),
     };
   }
-  return { ordered, dependsOnEdges, hotPathEdges, danglingDependsOn };
+  return { ordered, dependsOnEdges, hotPathEdges: 0, danglingDependsOn };
 }
 
 export interface DecomposeProposalScan {
@@ -423,7 +437,8 @@ export function applyDecomposeProposals(
         feature: inherited.length ? [...inherited, piece.feature].join('\n') : piece.feature,
         ...(piece.dependsOn.length ? { dependsOn: [...piece.dependsOn] } : {}),
         // ⛔⭐ `...goal` 이 «부모의» hotPaths 를 그대로 흘린다 — 그러면 조각 전부가 서로 겹쳐
-        //   `orchestrate.ts` 가 전부를 직렬화한다(위상이 아니라 «한 줄»이 된다).
+        //   «가짜 형제 겹침» 관측을 낸다. 겹침 간선·직렬화는 제거됐다(2026-10-16) — hotPaths 는
+        //   hot-path-overlap 관측의 원천이므로 부모 것을 물려주면 그 관측이 오염된다.
         //   ⇒ 조각 자신의 것이 있으면 그것으로 덮고, 없으면 «지운다»(부모 것을 상속하지 않는다).
         ...(piece.hotPaths?.length ? { hotPaths: [...piece.hotPaths] } : { hotPaths: undefined }),
       } as SelfDevGoal);

package/src/self-dev/decompose.ts

@@ -453,6 +453,22 @@ export function inferHotPaths(text: string): string[] {
   return [...new Set(matches)];
 }
 
+/** A child without implementation targets inherits the parent's explicit target line and ask. */
+export function inheritDecomposedTargetPaths(parentFeature: string, goals: SelfDevGoal[]): SelfDevGoal[] {
+  const declaredTargets = (feature: string) => [...new Set(feature.split(/\r?\n/)
+    .filter((line) => /^\s*(?:[-*]\s*)?대상 경로\s*:/.test(line))
+    .flatMap(inferHotPaths))];
+  const parentTargets = declaredTargets(parentFeature);
+  if (!parentTargets.length) return goals;
+  return goals.map((goal) => {
+    // hotPaths also contains inferred references; only an explicit target line establishes child scope.
+    const own = declaredTargets(goal.feature ?? '');
+    if (own.length) return goal;
+    return { ...goal, hotPaths: [...new Set([...(goal.hotPaths ?? []), ...parentTargets])],
+      feature: `${goal.feature}\n대상 경로: ${parentTargets.join(' · ')}` };
+  });
+}
+
 /** Tolerant JSON extraction — LLM may wrap in a fence or prose. */
 function extractJsonObject(raw: string): unknown | null {
   const trimmed = raw.trim();
@@ -525,6 +541,7 @@ async function finalizeDecomposition(
   arcHint: number | undefined,
   foldedRegistration = 0,
 ): Promise<SelfDevDecomposition> {
+  goals = inheritDecomposedTargetPaths(feature, goals);
   if (arcHint === undefined || goals.length === 0) return observeDecomposition(goals, decomposition, undefined, opts.observation, opts.pathGrounding, foldedRegistration);
   try {
     const arcLlm = opts.arcLlm ?? opts.llm ?? (await defaultDecomposeLlm(opts.model));

package/src/self-dev/dev-pipeline.ts

@@ -21,7 +21,7 @@ import { readFileSync } from 'node:fs';
 import { dispatchTask, type DispatchTaskDeps } from '../execution-loop/dispatch-task.js';
 import { getNestDepth } from '../agent/nest-depth.js';
 import { appendRunLedgerEntry } from '../self-implement/run-ledger.js';
-import { appendEvidenceLocationRequirement, extractVerbatimOriginalAsk, formatGoalFileLintFinding, inspectAskDecisionSignalMarker, leadingGoalMetadata, lintGoalFile, parseGoalId, parseGoalType, tracedPathReferences, SUPERSEDED_BY_LINE, type GoalFileLintFinding, type GoalFileLintResult } from '../self-implement/goal-author.js';
+import { appendEvidenceLocationRequirement, extractVerbatimOriginalAsk, formatGoalFileLintFinding, inspectAskDecisionSignalMarker, inspectGoalDoneBoundary, leadingGoalMetadata, lintGoalFile, markdownSection, parseGoalId, parseGoalType, tracedPathReferences, SUPERSEDED_BY_LINE, type GoalFileLintFinding, type GoalFileLintResult } from '../self-implement/goal-author.js';
 import { createRepositoryReferencedFileReader, type ReferencedFileReader } from '../self-implement/goal-file-reader.js';
 import { parseGoalDocumentClarifications } from '../self-implement/goal-author-clarification.js';
 import { requiredEvidenceFromGoal } from '../self-implement/off-diff-evidence.js';
@@ -164,8 +164,10 @@ export interface DevHarnessOpts {
 export interface DevChatOpts {
   /** 이어갈 세션 id/prefix(explicitSessionId). */
   session?: string;
-  /** 새 세션 강제(reuseActive=!forceNew 로 파생). */
+  /** 새 세션 강제(`--new` · 0.2.31 부터 기본과 같다 — 호환). */
   forceNew?: boolean;
+  /** 활성 세션 이어하기(`--continue`/`--resume` 명시 · 대표 #73). 없으면 새 세션. */
+  continueActive?: boolean;
   /** 단일 JSON 라인 출력. */
   json?: boolean;
   /** tool-loop(Read/Grep/…/Bash) 활성(elanous agent 가 켬). */
@@ -1364,6 +1366,32 @@ export function preflightGoalFileEvidence(input: DevInput, text: string, allowNo
   );
 }
 
+/** TA 발사만 강제한다. 사람의 dev ask/say는 일주일 관측용 경고와 이벤트를 남긴다. */
+export const GOAL_DONE_BOUNDARY_HUMAN_OBSERVATION_START_MS = Date.parse('2026-10-16T00:00:00+09:00');
+export const GOAL_DONE_BOUNDARY_HUMAN_OBSERVATION_END_MS = Date.parse('2026-10-23T00:00:00+09:00');
+
+export function preflightGoalDoneBoundary(input: DevInput, text: string, taskCardId = process.env.ELANOUS_TASK_CARD_ID, entrance?: EntranceId, source: 'goal' | 'request' = 'goal', nowMs = Date.now()): void {
+  if ('text' in input) return;
+  // One-week human observation is scoped to the authored ask/say doors; unrelated
+  // manual-file consumers keep their existing output contract.
+  if (!taskCardId?.trim() && entrance !== 'cli-dev-ask' && entrance !== 'cli-harness-ask' && entrance !== 'cli-harness-say') return;
+  if (!taskCardId?.trim() && (nowMs < GOAL_DONE_BOUNDARY_HUMAN_OBSERVATION_START_MS || nowMs >= GOAL_DONE_BOUNDARY_HUMAN_OBSERVATION_END_MS)) return;
+  const { missing } = inspectGoalDoneBoundary(source === 'request' ? text : markdownSection(text, 'ACCEPTANCE CRITERIA') ?? '');
+  if (missing.length === 0) {
+    debug.log('dev-pipeline', 'goal-done-boundary-ready', { file: input.file, taskCardId: taskCardId?.trim() || null, source });
+    return;
+  }
+  const card = taskCardId?.trim() || null;
+  const location = source === 'request' ? '원 요청' : '## ACCEPTANCE CRITERIA';
+  const reason = `골 완료 경계 누락: ${missing.join(' · ')} (${location} 안에 '- <이름>: <구체적 완료 조건>' 세 행을 적으세요)`;
+  if (card) {
+    debug.log('dev-pipeline', 'goal-done-boundary-rejected', { file: input.file, taskCardId: card, missing, reason, source });
+    throw new DevPipelineError(`${reason} · TA 카드 ${card}`);
+  }
+  debug.log('dev-pipeline', 'goal-done-boundary-warned', { file: input.file, taskCardId: null, missing, reason, source, observationWindow: '2026-10-16/2026-10-23' });
+  process.stderr.write(`[dev] ${reason} — 사람 요청 관측 기간에는 발사를 계속합니다\n`);
+}
+
 /** `--file` 골의 연속된 머리말 메타데이터에서 폐기 backlink를 찾아 발사 직전에 막는다. */
 export function preflightSupersededGoalFile(input: DevInput, text: string, allowSupersededGoal = false): void {
   if ('text' in input) return;
@@ -1967,6 +1995,7 @@ async function runDevPipelineDispatch(
 
   const readFile = deps.readFile ?? ((p: string) => readFileSync(p, 'utf8'));
   const inputText = resolveDevInputText(plan.input, readFile);
+  preflightGoalDoneBoundary(plan.input, inputText, process.env.ELANOUS_TASK_CARD_ID, plan.entrance);
   preflightGoalFileEvidence(plan.input, inputText, spec.allowNoEvidence === true);
   preflightSupersededGoalFile(plan.input, inputText, spec.allowSupersededGoal === true);
   preflightGoalFileLint(plan.input, inputText, plan.dispatch, deps.cwd ?? process.cwd(), spec.allowGoalLintErrors === true, deps);

package/src/self-dev/draft-residue.ts

@@ -92,6 +92,7 @@ export interface DraftResidueAdapters {
   loadLedger(runId: string, ledgerDir: string): readonly RunLedgerEntry[] | null;
   appendLedger(entry: RunLedgerEntry, ledgerDir: string): void;
   getPr(number: number): Promise<ResiduePr | undefined> | ResiduePr | undefined;
+  /** Undefined means the open-draft inventory could not be observed («못 셌음») — never a disguised zero count. */
   listOpenDrafts(repository: string): Promise<readonly ResiduePr[] | undefined> | readonly ResiduePr[] | undefined;
   addLabel(repository: string, number: number, label: string): Promise<void> | void;
   setLabels(repository: string, number: number, change: { add: string; remove: readonly string[] }): Promise<void> | void;
@@ -112,8 +113,15 @@ export interface DraftResidueContext {
 }
 export type DraftResidueResult = { status: 'recorded' | 'skipped' | 'failed'; reason?: string; step?: string };
 
+/** A REST pulls page carries up to 100 full PR bodies; the spawn default buffer (1 MiB) overflowed daily as
+ *  `spawnSync gh ENOBUFS`, so every gh call gets an explicit ceiling that fits a full page of large-bodied drafts. */
+const GH_MAX_BUFFER = 64 * 1024 * 1024;
+/** Only the fields the residue consumes. The raw REST page (base/head repo objects, _links, review metadata, …) is
+ *  several times larger than this projection, so the listing asks gh to project each page down to these fields. */
+const OPEN_DRAFT_FIELDS = '[.[] | {number, title, headRefName: .head.ref, createdAt: .created_at, body, labels: [.labels[] | {name}], draft}]';
+
 function gh(args: string[]): string {
-  const result = spawnSync('gh', args, { cwd: findGitDir(process.cwd())?.root ?? process.cwd(), encoding: 'utf8', timeout: 60_000 });
+  const result = spawnSync('gh', args, { cwd: findGitDir(process.cwd())?.root ?? process.cwd(), encoding: 'utf8', timeout: 60_000, maxBuffer: GH_MAX_BUFFER });
   if (result.status !== 0) throw new Error((result.stderr || result.error?.message || `gh exited ${result.status}`).trim().slice(0, 200));
   return result.stdout.trim();
 }
@@ -173,15 +181,22 @@ export function defaultAdapters(sources: ResidueRunStatusSources = defaultRunSta
     getPr: (number) => ghPr(JSON.parse(gh(['pr', 'view', String(number), '-R', hostRepository() ?? '', '--json', fields]))),
     listOpenDrafts: (repository) => {
       const rows: ResiduePr[] = [];
-      for (let page = 1; page <= 100; page++) {
-        const result = JSON.parse(gh(['api', `repos/${repository}/pulls?state=open&per_page=100&page=${page}`])) as Array<{
-          number: number; title: string; head: { ref: string }; created_at: string; body: string; draft: boolean; labels: Array<{ name: string }>;
-        }>;
-        if (!Array.isArray(result)) throw new Error('Invalid open PR inventory');
-        rows.push(...result.filter((pr) => pr.draft).map((pr) => ghPr({ number: pr.number, title: pr.title, headRefName: pr.head.ref, createdAt: pr.created_at, body: pr.body, labels: pr.labels })));
-        if (result.length < 100) return rows;
+      try {
+        for (let page = 1; page <= 100; page++) {
+          const result = JSON.parse(gh(['api', `repos/${repository}/pulls?state=open&per_page=100&page=${page}`, '--jq', OPEN_DRAFT_FIELDS])) as Array<{
+            number: number; title: string; headRefName: string; createdAt: string; body: string;
+            labels: Array<{ name: string }>; draft: boolean;
+          }>;
+          if (!Array.isArray(result)) throw new Error('Invalid open PR inventory');
+          rows.push(...result.filter((pr) => pr.draft).map((pr) => ghPr({ number: pr.number, title: pr.title, headRefName: pr.headRefName, createdAt: pr.createdAt, body: pr.body, labels: pr.labels })));
+          if (result.length < 100) return rows;
+        }
+        throw new Error('Open PR inventory exceeded pagination limit');
+      } catch (error) {
+        // «못 셌음»: a failed (or truncated) listing is unmeasurable — it must never surface as a counted zero.
+        debug.log('draft.residue', 'list-open-drafts-unobserved', { repository, reason: error instanceof Error ? error.message : String(error) });
+        return undefined;
       }
-      throw new Error('Open PR inventory exceeded pagination limit');
     },
     addLabel: (repository, number, label) => { gh(['pr', 'edit', String(number), '-R', repository, '--add-label', label]); },
     setLabels: (repository, number, change) => { gh(['pr', 'edit', String(number), '-R', repository, '--add-label', change.add, ...change.remove.flatMap((label) => ['--remove-label', label])]); },

package/src/self-dev/draft-sweep.ts

@@ -154,6 +154,12 @@ export interface DraftMetrics {
   readonly inventory: number;
   readonly oldestAgeHours: number | null;
   readonly needsOwner: number;
+  /**
+   * Per-seat needsOwner counts (own keys, finite numbers only). Unattributed drafts
+   * stay in the global `needsOwner` total and are absent here. Optional so existing
+   * screen/ledger constructors stay valid; collectDraftMetrics always fills it.
+   */
+  readonly needsOwnerBySeat?: Readonly<Record<string, number>>;
   /** Open running claims whose last update cannot be read; neither owned nor needs-owner. */
   readonly claimUnobserved?: number;
   readonly converted48h: number;
@@ -164,6 +170,8 @@ export interface DraftMetrics {
 /** Default maximum unclaimed open harness drafts for one seat. */
 export const DRAFT_NEEDS_OWNER_SEAT_CAP = 15;
 
+const NEEDS_OWNER_SEATS = ['OP', 'TC', 'MK', 'UX'] as const;
+
 /** Compare one seat's observed needsOwner count; the caller supplies counts of open drafts by seat. */
 export function isSeatDraftNeedsOwnerOverCap(
   seat: string,
@@ -174,6 +182,50 @@ export function isSeatDraftNeedsOwnerOverCap(
   return typeof count === 'number' && Number.isFinite(count) && count > cap;
 }
 
+/** Hold that seat's new launches when its needsOwner drafts exceed the default cap of 15. */
+export function shouldHoldSeatNewLaunch(
+  seat: string,
+  needsOwnerBySeat: Readonly<Record<string, number>>,
+): boolean {
+  return isSeatDraftNeedsOwnerOverCap(seat, needsOwnerBySeat, DRAFT_NEEDS_OWNER_SEAT_CAP);
+}
+
+function draftNeedsOwner(draft: SweepDraft, owner: string | undefined, now: Date): boolean {
+  const state = draftClaimState(draft, now);
+  return state !== 'unobserved' && (state !== 'claimed' || !owner?.trim());
+}
+
+/** Seat for a needsOwner draft: active claim owner, else a unique `elanous:seat-<자리>` label. */
+function needsOwnerSeatOf(draft: SweepDraft, owner: string | undefined): string | undefined {
+  const claimed = owner?.trim();
+  if (claimed && (NEEDS_OWNER_SEATS as readonly string[]).includes(claimed)) return claimed;
+  const found = new Set<string>();
+  for (const name of draft.labels) {
+    const seat = /^elanous:seat-(OP|TC|MK|UX)$/.exec(name)?.[1];
+    if (seat) found.add(seat);
+  }
+  return found.size === 1 ? [...found][0] : undefined;
+}
+
+/** Own-key, finite-number per-seat counts of drafts that still need an owner. */
+export function aggregateNeedsOwnerBySeat(
+  drafts: readonly SweepDraft[],
+  owners: readonly (string | undefined)[],
+  now: Date,
+): Record<string, number> {
+  const needsOwnerBySeat: Record<string, number> = {};
+  for (let index = 0; index < drafts.length; index++) {
+    const draft = drafts[index]!;
+    if (!draftNeedsOwner(draft, owners[index], now)) continue;
+    const seat = needsOwnerSeatOf(draft, owners[index]);
+    if (typeof seat !== 'string' || !seat) continue;
+    const current = Object.hasOwn(needsOwnerBySeat, seat) ? needsOwnerBySeat[seat] : 0;
+    if (typeof current !== 'number' || !Number.isFinite(current)) continue;
+    needsOwnerBySeat[seat] = current + 1;
+  }
+  return needsOwnerBySeat;
+}
+
 export async function collectDraftMetrics(repository: string, adapters: Pick<DraftSweepAdapters, 'listDrafts' | 'listRecentClosed' | 'getActiveClaimOwner'>, now: Date): Promise<DraftMetrics> {
   const clock = now.getTime();
   if (!Number.isFinite(clock)) throw new Error('Invalid draft metric clock');
@@ -209,13 +261,16 @@ export async function collectDraftMetrics(repository: string, adapters: Pick<Dra
   const converted48h = cohort.filter((pr) => 'mergedAt' in pr && typeof pr.mergedAt === 'string'
     && Date.parse(pr.mergedAt) >= Date.parse(pr.createdAt!) && Date.parse(pr.mergedAt) <= clock
     && Date.parse(pr.mergedAt) - Date.parse(pr.createdAt!) <= 48 * 3_600_000).length;
+  const needsOwnerBySeat = aggregateNeedsOwnerBySeat(open, owners, now);
+  // This observation reports over-cap seats; the dispatchers enforce the hold before launch.
+  const heldSeats = Object.keys(needsOwnerBySeat).filter((seat) =>
+    isSeatDraftNeedsOwnerOverCap(seat, needsOwnerBySeat, DRAFT_NEEDS_OWNER_SEAT_CAP));
+  try { debug.log('self-dev.draft-metrics', 'seat-launch-hold', { heldSeats, needsOwnerBySeat }); } catch { /* fail-soft */ }
   return {
     inventory: open.length,
     oldestAgeHours: open.length ? Math.max(...open.map((pr) => Math.max(0, (clock - Date.parse(pr.createdAt)) / 3_600_000))) : null,
-    needsOwner: open.filter((draft, index) => {
-      const state = draftClaimState(draft, now);
-      return state !== 'unobserved' && (state !== 'claimed' || !owners[index]?.trim());
-    }).length,
+    needsOwner: open.filter((draft, index) => draftNeedsOwner(draft, owners[index], now)).length,
+    needsOwnerBySeat,
     claimUnobserved: open.filter((draft) => draftClaimState(draft, now) === 'unobserved').length,
     converted48h,
     cohort48h: cohort.length,

package/src/self-dev/external-call-zero.ts

@@ -0,0 +1,77 @@
+// ── 외부 호출 0 모드 가드 — LLM·검색·크롤 외부 호출을 «거부하고 남긴다» ─────────────
+//
+// «외부 호출 0 모드»(external-call-zero mode)가 켜져 있으면 LLM·검색·크롤 외부 호출
+// 시도는 전부 거부되고, 거부된 시도마다 감사 원장에 한 줄이 덧붙는다(타임스탬프 ·
+// 호출 범주 · 호출자 맥락). 원장은 append-only — 이력은 «덧붙일 수만» 있고,
+// 읽는 쪽이 고치거나 지울 수는 없다.
+//
+// 이 모듈은 순수 가드다. run-supervisor.ts 로의 배선(LLM/검색/크롤 시도를 이 가드로
+// 돌리는 시임)은 이 정의를 소비하는 별도 의존 조각의 몫이다 — 여기서 운영 경로를
+// 건드리지 않는 것은 의도된 경계다.
+
+export const EXTERNAL_CALL_CATEGORIES = ['llm', 'search', 'crawl'] as const;
+
+export type ExternalCallCategory = (typeof EXTERNAL_CALL_CATEGORIES)[number];
+
+/** 거부된 외부 호출 시도 한 건 — 감사 원장의 한 줄. */
+export interface ExternalCallAuditEntry {
+  /** 0부터 매 거부 시도마다 하나씩 — 같은 원장에서 재사용되지 않는다. */
+  readonly seq: number;
+  /** 시각(ISO 8601). */
+  readonly at: string;
+  /** 시도한 외부 표면(llm | search | crawl). */
+  readonly category: ExternalCallCategory;
+  /** 호출자 맥락 — 누가(어느 파일·함수·지점) 외부 호출을 청했나. */
+  readonly caller: string;
+}
+
+export interface ExternalCallZeroVerdict {
+  readonly denied: boolean;
+  /** 거부되어 원장에 덧붙은 줄 — 거부된 시도에만 있다. */
+  readonly entry?: ExternalCallAuditEntry;
+}
+
+export interface ExternalCallZeroOptions {
+  /** true = 외부 호출 0 모드. 기본 false — 평소 동작(호출 통과 · 기록 없음). */
+  readonly enabled?: boolean;
+  /** 시험용 시계 주입 — 운영은 벽시계를 쓴다. */
+  readonly now?: () => Date;
+}
+
+export class ExternalCallZeroGuard {
+  private readonly zeroMode: boolean;
+  private readonly clock: () => Date;
+  private readonly entries: ExternalCallAuditEntry[] = [];
+
+  constructor(options: ExternalCallZeroOptions = {}) {
+    this.zeroMode = options.enabled ?? false;
+    this.clock = options.now ?? (() => new Date());
+  }
+
+  /** 외부 호출 0 모드가 켜져 있는가. */
+  get enabled(): boolean {
+    return this.zeroMode;
+  }
+
+  /**
+   * 외부 호출 시도를 가드로 돌린다. 켜진 모드에서는 모든 llm/search/crawl 시도를
+   * 거부하고 시도마다 감사 원장에 한 줄을 덧붙인다. 꺼진 모드는 시도를 그대로
+   * 통과시키고 아무것도 기록하지 않는다.
+   */
+  attempt(category: ExternalCallCategory, caller: string): ExternalCallZeroVerdict {
+    if (!this.zeroMode) return { denied: false };
+    const entry: ExternalCallAuditEntry = Object.freeze({
+      seq: this.entries.length,
+      at: this.clock().toISOString(),
+      category,
+      caller,
+    });
+    this.entries.push(entry);
+    return { denied: true, entry };
+  }
+
+  /** Append-only 읽기 뷰 — 얼린 스냅숏. 읽는 쪽은 이력을 못 고친다. */
+  ledger(): readonly ExternalCallAuditEntry[] {
+    return Object.freeze([...this.entries]);
+  }
+}

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

@@ -22,6 +22,12 @@ export interface LaunchPreflightBlocker {
   readonly name: string;
   /** 왜 막혔는지 한 줄 — 경로와 수를 포함한다. */
   readonly detail: string;
+  /** 골 판독 실패(`goal-unreadable`)와 traced-path 오류(`missing-traced-path`)를 가르는 사유 코드. */
+  readonly reasonCode?: 'goal-unreadable' | 'missing-traced-path';
+  /** 어느 검사인지 — 경로를 접지 않은 검사 이름. */
+  readonly checkName?: string;
+  /** 잘리지 않은 대상 경로. 경로 없는 검사(빈 traced paths)는 생략한다. */
+  readonly targetPath?: string;
   /** draft PR 경고가 연 검사 대상 경로. 동일 경로의 경고를 렌더에서 묶는다. */
   readonly draftPaths?: readonly string[];
   /** 라이브 런 충돌의 경로별 역할. ask 대상 표지가 없으면 미상이라 생략한다. */

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

@@ -19,7 +19,7 @@
 import { execFileSync } from 'node:child_process';
 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 { classifyTracedPathToken, 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';
@@ -778,6 +778,18 @@ function isFileShapedTracedPath(path: string): boolean {
   return path.trim().length > 0 && (!/\s/.test(path) || path.includes('/'));
 }
 
+/** Residual, empty-cover, and bare-only twins of an already-declared nested path are not injected into preflight. */
+function isInjectedBareOrResidualTracedPath(path: string, declared: readonly string[], repositoryRoot?: string): boolean {
+  const classification = classifyTracedPathToken(path, repositoryRoot);
+  if (classification.kind === 'residual' || classification.kind === 'empty-cover') return true;
+  if (classification.kind !== 'bare') return false;
+  return declared.some((candidate) => candidate !== path && (candidate.endsWith(`/${path}`) || candidate.endsWith(`\\${path}`)));
+}
+
+function inspectableAuthoredTracedPaths(paths: readonly string[], repositoryRoot?: string): string[] {
+  return paths.filter((path) => !isInjectedBareOrResidualTracedPath(path, paths, repositoryRoot));
+}
+
 // 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}`;
@@ -1097,11 +1109,13 @@ export function decideAskPreflight(
   // 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 authoredTracedPaths = goalDocument === null
+    ? []
+    : inspectableAuthoredTracedPaths(deps.tracedPaths(goalDocument), inspectionRoot);
+  const tracedPathsRaw = opts.pathsOverride ?? authoredTracedPaths;
   const tracedPaths = inspectionRoot && !opts.pathsOverride
     ? tracedPathsRaw.filter((path) => tracedPathExists(path, inspectionRoot) || isFileShapedTracedPath(path))
     : tracedPathsRaw;
@@ -1305,6 +1319,8 @@ export function decideAskPreflight(
       kind: 'missing-traced-path' as const,
       name: '최종 골의 TRACED PATHS 경로 0',
       detail: '정리 후 보존된 traced 경로가 없다 — 실제 파일 또는 유효한 신설: 파일 경로를 골에 선언해야 발사할 수 있다',
+      reasonCode: 'missing-traced-path' as const,
+      checkName: 'empty-traced-paths',
     }] : []),
     ...invalidTracedPaths.map(({ path, reason }) => ({
       kind: 'missing-traced-path' as const,
@@ -1318,12 +1334,18 @@ export function decideAskPreflight(
           : reason === 'inaccessible'
             ? `골의 TRACED PATHS 경로 ${path} 를 검사할 수 없다 — 부모가 파일이거나 접근 권한이 없다. 경로를 바로잡아야 한다`
             : `골의 TRACED PATHS 에 선언됐지만 ${inspectionRoot} 에 없고 유효한 신설: 목록에도 없다 — 발사 전에 골 경로를 바로잡아야 한다. 신설은 파일 경로로(확장자 포함) 선언한다`,
+      reasonCode: 'missing-traced-path' as const,
+      checkName: reason,
+      targetPath: path,
     })),
   ];
   const goalReadBlockers: LaunchPreflightBlocker[] = goalReadFailed ? [{
     kind: 'goal-unreadable',
     name: `골 문서 판독 불가: ${opts.goalFile}`,
     detail: `${goalRulersUnknownReason} — 최종 골의 traced path 를 확인할 수 없어 발사를 멈춘다`,
+    reasonCode: 'goal-unreadable' as const,
+    checkName: 'goal-read',
+    targetPath: resolvedGoalFile,
   }] : [];
   const decisionResult = {
     ...result,