elanous 0.2.29 → 0.2.32

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

@@ -1,6 +1,7 @@
 import { execFile } from 'node:child_process';
 import { createHash, randomUUID } from 'node:crypto';
 import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
+import { loadSeatPack } from './seat-knowhow.js';
 import { Database } from 'bun:sqlite';
 import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { promisify } from 'node:util';
@@ -28,6 +29,7 @@ import { recordSeatAskShadow } from '../seat-dispatch/seat-ask.js';
 import { appendSeatRequestRows, listSeatRequests, withSeatRequestLedgerLock } from '../seat-dispatch/seat-request-ledger.js';
 import { answerCrossCheck, answerSeat, askCrossCheck, askSeat, crossCheckAnswer, deliveredSeatQuestion, hasSeatAnswer, isSeatId, seatCrossChecks, seatQuestions, type CrossCheckJudgment, type SeatId } from '../seat-dispatch/seat-questions.js';
 import { queryRunningRuns } from '../self-implement/running-runs.js';
+import { collectDraftMetrics, DRAFT_NEEDS_OWNER_SEAT_CAP, shouldHoldSeatNewLaunch, type DraftMetrics } from '../self-dev/draft-sweep.js';
 import { checklistHistory, listChecklist, type Checklist } from '../release-loop/checklist.js';
 import { readSchedules, releasedVersion } from '../release-loop/feature-store.js';
 import { runOpDecide, type OpDecideCandidate } from './op-decide.js';
@@ -74,6 +76,12 @@ export type SeatDeps = {
   now?: () => Date;
   read?: (path: string) => string;
   run?: (args: string[]) => Promise<string>;
+  /** Current open draft inventory for the launch seat; injected tests avoid live GitHub. */
+  draftMetrics?: (now: Date) => Promise<DraftMetrics>;
+  /** Explicit needs-owner hold gate — the hold is an autonomous-launch guard. The orchestrator launch
+   *  (loops/orchestrator/tick.ts) and the hook wake (hooks/dispatch.ts) pass true; tests assert this
+   *  option instead of inferring the boundary from which seams are injected. */
+  needsOwnerGate?: boolean;
   /** Seat-folder resolver for every process this loop starts; production reads the registry-validated `seats/<role>` view, tests inject an isolated folder. */
   launchSeat?: (seat: string) => string;
   enqueue?: (seat: string, text: string, root: string, idempotencyKey: string, item: SeatItem) => Promise<{ id: string }>;
@@ -614,7 +622,10 @@ export async function gatherSeatInputs(seat: string, deps: SeatDeps = {}, ledger
   for (const request of pending) {
     if (request.source === 'seat-question' && ownedEvidence) request.evidence = ownedEvidence;
   }
-  return { requests: pending, checklist, role: read(join(deps.repo ?? repoRoot, 'docs', 'roles', `${seat}.md`)).slice(0, 4_000) };
+  // SEAT-PACK-LOADER (RFC seat-knowhow §A3): full charter (4,000-char cut abolished) ⊕ knowhow 사실/참고 blocks, top-k on this turn's judgment items.
+  const pack = loadSeatPack(seat, [...pending, ...checklist].map((item) => `${item.title}\n${item.text ?? ''}`).join('\n'),
+    { repo: deps.repo ?? repoRoot, read, now: deps.now ?? (() => new Date()) });
+  return { requests: pending, checklist, role: pack.text };
 }
 
 /** OP-LOOP-DECIDE: filter open decision cards each OP turn. Shadow records; live decides/routes. A failure never blocks the turn. */
@@ -1500,7 +1511,7 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
       ? ledger.find((row) => row.status === 'awaiting-resolution' && row.item && itemKey(row.item) === itemKey(item))?.inquiry ?? null
       : unfinished?.inquiry ?? await (deps.inquire ?? (async (asking: SeatId, work: SeatItem) => { try {
       const output = JSON.parse((await run(['agent', '--json', '--no-tools',
-        `[${asking} 자리 · 역할 docs/roles/${asking}.md] 이 항목을 판단할 근거가 부족한 경우에만 다른 자리 또는 사람에게 질문한다. 근거가 충분하면 null. JSON 객체 하나만 반환: null 또는 {"to":"OP|TC|MK|UX|CEO","question":"필요한 근거를 묻는 질문"}. 항목: ${work.id} ${work.title}\n내용: ${work.text}\n역할: ${(deps.read ?? defaultRead)(join(deps.repo ?? repoRoot, 'docs', 'roles', `${asking}.md`)).slice(0, 4_000)}`])).trim()) as { reply?: unknown };
+        `[${asking} 자리 · 역할 docs/roles/${asking}.md] 이 항목을 판단할 근거가 부족한 경우에만 다른 자리 또는 사람에게 질문한다. 근거가 충분하면 null. JSON 객체 하나만 반환: null 또는 {"to":"OP|TC|MK|UX|CEO","question":"필요한 근거를 묻는 질문"}. 항목: ${work.id} ${work.title}\n내용: ${work.text}\n역할: ${loadSeatPack(asking, `${work.title}\n${work.text}`, { repo: deps.repo ?? repoRoot, read: deps.read ?? defaultRead, now: () => now }).text}`])).trim()) as { reply?: unknown };
       const value: unknown = typeof output?.reply === 'string' ? JSON.parse(output.reply) : output;
       if (value === null) return null;
       if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('invalid seat inquiry');
@@ -1696,6 +1707,34 @@ export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promis
   }
   const action = planned!;
   if (action.kind === 'harness') {
+    // A count is observation until the dispatch boundary uses it. Do not enqueue or call harness say for an over-cap seat.
+    // NEEDS-OWNER-BOUNDARY: the hold is an autonomous-launch guard — the orchestrator launch
+    // (loops/orchestrator/tick.ts) and the hook wake (hooks/dispatch.ts) opt in via deps.needsOwnerGate;
+    // tests assert the option instead of inferring the boundary from which seams are injected.
+    if (deps.needsOwnerGate ?? false) {
+      let metrics: DraftMetrics | undefined;
+      try {
+        metrics = await (deps.draftMetrics ?? (async (clock: Date) => {
+          const [{ resolveRepositoryName }, { githubDraftSweepAdapters }] = await Promise.all([
+            import('../harness/repository-name.js'), import('../harness/harness-cli-command.js'),
+          ]);
+          return collectDraftMetrics(resolveRepositoryName({}), githubDraftSweepAdapters(), clock);
+        }))(now);
+        if (!metrics.needsOwnerBySeat) throw new Error('per-seat draft inventory missing');
+      } catch (error) {
+        // NEEDS-OWNER-POLICY: an unreadable census — gh unavailable, rate-limited, or one unreadable
+        // claim comment — is unobserved, not failed-closed. Unobserved input never holds the seat's
+        // dispatch; only an observed count over the cap does. The next loop pass re-collects.
+        observe('launch-needs-owner-unobserved', { seat, item: item.id, reason: String(error).slice(0, 140) });
+      }
+      if (metrics && shouldHoldSeatNewLaunch(seat, metrics.needsOwnerBySeat ?? {})) {
+        entry.status = 'wait';
+        entry.reason = `needs-owner ${seat}: ${metrics.needsOwnerBySeat?.[seat]} > ${DRAFT_NEEDS_OWNER_SEAT_CAP}`;
+        append(path, entry);
+        observe('launch-held-needs-owner', { seat, item: item.id, count: metrics.needsOwnerBySeat?.[seat] });
+        return entry;
+      }
+    }
     const launchedRunIds = new Set(ledger.flatMap((row) => row.seat === seat && row.status === 'launched' && row.runId ? [row.runId] : []));
     let running: readonly RunningSeatPod[] = [];
     let observationUnavailable = false;

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

@@ -6,6 +6,7 @@ export type TrafficSignal = {
   global: string;
   versions?: string[];
   hold?: string[];
+  order?: string[];
   paused?: Record<string, boolean>;
 };
 export type TrafficSignalRead = TrafficSignal | { unreadable: true } | null;
@@ -17,7 +18,8 @@ export function classifySeatTrafficProposal(message: string): 'hold' | 'UNHOLD'
   return null;
 }
 
-const defaultPath = (name: string): string => join(homedir(), 'elanous-hq', 'seat-state', 'OP', name);
+export const opSeatStatePath = (name: string): string => join(homedir(), 'elanous-hq', 'seat-state', 'OP', name);
+const defaultPath = opSeatStatePath;
 const missing = (error: unknown): boolean => (error as NodeJS.ErrnoException).code === 'ENOENT';
 
 /** A missing installation has no signal; an invalid or unreadable one cannot authorize a checklist launch. */
@@ -29,10 +31,12 @@ export function readTrafficSignal(path?: string): TrafficSignalRead {
     if (typeof row.global !== 'string'
       || (row.versions !== undefined && (!Array.isArray(row.versions) || !row.versions.every((version) => typeof version === 'string')))
       || (row.hold !== undefined && (!Array.isArray(row.hold) || !row.hold.every((id) => typeof id === 'string')))
+      || (row.order !== undefined && (!Array.isArray(row.order) || !row.order.every((id) => typeof id === 'string')))
       || (row.paused !== undefined && (!row.paused || typeof row.paused !== 'object' || Array.isArray(row.paused)
         || !Object.values(row.paused).every((paused) => typeof paused === 'boolean')))) return { unreadable: true };
     return { global: row.global, ...(row.versions !== undefined ? { versions: row.versions as string[] } : {}),
       ...(row.hold !== undefined ? { hold: row.hold as string[] } : {}),
+      ...(row.order !== undefined ? { order: row.order as string[] } : {}),
       ...(row.paused !== undefined ? { paused: row.paused as Record<string, boolean> } : {}) };
   } catch (error) {
     return missing(error) ? null : { unreadable: true };

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

@@ -13,6 +13,7 @@
 import { linesOutsideFencedCode } from '../self-implement/goal-author.js';
 import { existsSync } from 'node:fs';
 import { debug } from '../debug/log.js';
+import { appendRunLedgerEntry, runLedgerDir } from '../self-implement/run-ledger.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';
@@ -81,14 +82,35 @@ export type InvokerBehindDefaultBranch =
   | { readonly state: 'measured'; readonly commits: number; readonly baseRef: string }
   | { readonly state: 'unmeasurable'; readonly reason: string };
 
+/** Ambient git location vars override `git -C <cwd>`; the invoker tree is the given cwd only. */
+const GIT_LOCATION_ENV_KEYS = [
+  'GIT_DIR', 'GIT_WORK_TREE', 'GIT_COMMON_DIR', 'GIT_INDEX_FILE',
+  'GIT_OBJECT_DIRECTORY', 'GIT_ALTERNATE_OBJECT_DIRECTORIES',
+] as const;
+
+function gitReadEnv(): NodeJS.ProcessEnv {
+  const env = { ...process.env };
+  for (const key of GIT_LOCATION_ENV_KEYS) delete env[key];
+  return env;
+}
+
+function gitRead(cwd: string, args: readonly string[]): string {
+  // git-spawn-allow: Reads only the given cwd after dropping ambient GIT_DIR/GIT_WORK_TREE so the invoker tree is that cwd, not the parent harness checkout.
+  return execFileSync('git', ['-C', cwd, ...args], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: gitReadEnv(),
+  }).trim();
+}
+
 /** 현재 인보커 작업 트리의 HEAD를 이미 알려진 원격 기본 브랜치 ref와만 비교한다. */
 export function measureInvokerBehindDefaultBranch(cwd: string): InvokerBehindDefaultBranch {
   try {
     // git-spawn-allow: Reads the known origin/HEAD remote-tracking ref without fetching or changing repository state.
-    const baseRef = execFileSync('git', ['-C', cwd, 'rev-parse', '--abbrev-ref', 'origin/HEAD'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+    const baseRef = gitRead(cwd, ['rev-parse', '--abbrev-ref', 'origin/HEAD']);
     if (!baseRef || baseRef === 'origin/HEAD') throw new Error('원격 기본 브랜치 ref를 해석하지 못했다');
     // git-spawn-allow: Counts commits reachable from the known remote default branch but not local HEAD without changing repository state.
-    const raw = execFileSync('git', ['-C', cwd, 'rev-list', '--count', `HEAD..${baseRef}`], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+    const raw = gitRead(cwd, ['rev-list', '--count', `HEAD..${baseRef}`]);
     const commits = Number(raw);
     if (!Number.isSafeInteger(commits) || commits < 0) throw new Error(`뒤처진 커밋 수가 유효하지 않다: ${raw || '(빈 값)'}`);
     return { state: 'measured', commits, baseRef };
@@ -102,7 +124,7 @@ export function measureInvokerBehindDefaultBranch(cwd: string): InvokerBehindDef
 function gitTopLevel(dir: string): string | null {
   try {
     // git-spawn-allow: Reads the repository top-level path without changing repository state.
-    return execFileSync('git', ['-C', dir, 'rev-parse', '--show-toplevel'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim() || null;
+    return gitRead(dir, ['rev-parse', '--show-toplevel']) || null;
   } catch { return null; }
 }
 
@@ -828,6 +850,15 @@ export async function runAskLaunchFlow(
   const entrance = input.entrance;
   const askStartedAt = deps.now();
   const selfResolveClarifications = resolveSelfResolveClarifications(input.selfResolveClarifications);
+  // The Pod's logs.db disappears with the Job. Journal the two auto-authoring boundaries in its
+  // existing run ledger so the host's terminal collection can reemit them even on a failed Job.
+  const recordPodAuthoring = (event: 'ask-auto-target-candidates' | 'ask-auto-reauthor', data: Record<string, unknown>): void => {
+    if (process.env.ELANOUS_SUBSTRATE !== 'pod') return;
+    const runId = process.env.ELANOUS_RUN_ID ?? input.runId;
+    if (!runId) return;
+    try { appendRunLedgerEntry({ runId, event, data }, runLedgerDir()); }
+    catch (error) { deps.log('ask-auto-author-ledger-unavailable', { event, reason: error instanceof Error ? error.message : String(error) }, 'warn'); }
+  };
   deps.log('harness.entrance', {
     entrance: entrance.id,
     entranceStatus: entrance.status,
@@ -1061,6 +1092,7 @@ export async function runAskLaunchFlow(
         selection: { path: selectedPath ?? null, reason: selectionReason },
         ...(candidates.error === undefined ? {} : { error: candidates.error }),
       }, candidates.error === undefined && selectedPath ? 'info' : 'warn');
+      recordPodAuthoring('ask-auto-target-candidates', { candidatePathCount: candidates.paths.length, selected: Boolean(selectedPath), outcome: selectionReason });
     }
     const selectedPaths = candidates.selection?.path
       ? [candidates.selection.path]
@@ -1072,6 +1104,7 @@ export async function runAskLaunchFlow(
     } else {
       deps.print('[ask] ⑴ ⚠️ 자동 재저작에 넣을 대상 경로 후보가 없다. 대상 경로를 확인해야 한다');
     }
+    recordPodAuthoring('ask-auto-reauthor', { candidatePathCount: candidates.paths.length, firstPathCount: first.decision.result.paths.length, outcome: 'started' });
     authored = await authorAndPreflight(selectedPaths.length > 0
       ? `대상 경로: ${selectedPaths.join(' · ')}\n${input.askText}`
       : input.askText, selectedPaths);
@@ -1083,6 +1116,7 @@ export async function runAskLaunchFlow(
       secondPathCount: authored.decision.result.paths.length,
       helped: authored.decision.shouldLaunch,
     }, authored.decision.shouldLaunch ? 'info' : 'warn');
+    recordPodAuthoring('ask-auto-reauthor', { candidatePathCount: candidates.paths.length, firstPathCount: first.decision.result.paths.length, secondPathCount: authored.decision.result.paths.length, helped: authored.decision.shouldLaunch });
   }
 
   const { goalFile: effectiveGoalFile, decision } = authored;

package/src/self-dev/decompose-compose-graph.ts

@@ -5,7 +5,8 @@ import { orderPiecesTopologically, type DecomposePiece } from './decompose-propo
 /** ⭐ RFC §5 «5단계» — `compose` 부모 그래프.
  *
  *  RFC §4.4 는 ***"compose 그래프가 «부모»가 되고, 조각마다 자식 그래프 인스턴스를 연다"*** 라고 적었다.
- *  겹침→간선 파생은 `orderPiecesTopologically` 가 «이미» 한다(`#15782`). 여기서 더하는 것은 둘이다:
+ *  ⛔ 겹침→간선 파생은 «없다»(2026-10-16 제거 · 대표 10-11 «겹침이라 미루는 현상 제거») — 순서 간선은 dependsOn 만 만든다.
+ *  여기서 더하는 것은 둘이다:
  *
  *  ⓐ 그 순서를 ***`GraphTemplate` 로 세워*** 2단계 위상 검사를 «그대로» 걸 수 있게 한다.
  *  ⓑ RFC 가 요구한 두 분모를 ***정적으로*** 잰다(원장 타임스탬프 대신 그래프 «경로»로).
@@ -42,22 +43,8 @@ export function composeGraphFromPieces(pieces: readonly DecomposePiece[], graphI
       if (!edges[dep]!.includes(piece.id)) { edges[dep]!.push(piece.id); hasIncoming.add(piece.id); }
     }
   }
-  // hotPaths 겹침 — 파생기와 «같은 규칙»(배열 앞선 것 먼저 · 이미 길이 있으면 건너뛴다)을 쓴다.
-  const reaches = (from: string, to: string): boolean => {
-    const seen = new Set([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;
-  };
-  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(piece.id, other.id)) continue;
-      if (!edges[other.id]!.includes(piece.id)) { edges[other.id]!.push(piece.id); hasIncoming.add(piece.id); }
-    }
-  });
+  // ⛔ hotPaths 겹침 간선은 만들지 않는다(2026-10-16 제거 · 대표 10-11 «겹침이라 미루는 현상 제거»).
+  //    순서는 «의미 의존 dependsOn» 만 만든다 — 겹침은 pickDecomposeProposals 가 형제 겹침으로 따로 센다.
 
   for (const piece of pieces) {
     if (!hasIncoming.has(piece.id)) edges[COMPOSE_START]!.push(piece.id);
@@ -80,10 +67,11 @@ export function composeGraphFromPieces(pieces: readonly DecomposePiece[], graphI
 }
 
 /** RFC §5 5단계의 두 분모 — ⛔ 타임스탬프가 아니라 그래프 «경로»로 잰다.
- *  A = 겹치는 조각쌍(전부 직렬이어야 한다) · B = 겹치지 않는 쌍(하나 이상이 «나란히 갈 수» 있어야 한다).
+ *  A = 겹치는 조각쌍(선언된 의존 «외» 에는 직렬이어야 «하지 않는다») · B = 겹치지 않는 쌍(하나 이상이 «나란히 갈 수» 있어야 한다).
  *  ⛔ A=0 이거나 B=0 이면 «통과가 아니라» `unmeasured` 다. */
 export interface ComposeConcurrencyReport {
   readonly overlappingPairs: number;
+  /** 겹치는 쌍 중 «선언된 의존 외» 이유로 그래프에서 직렬로 남은 것 — 간선이 dependsOn 뿐이므로 구조적으로 0 이다(방어 관측). */
   readonly overlappingSerialized: number;
   readonly nonOverlappingPairs: number;
   readonly nonOverlappingConcurrent: number;
@@ -102,9 +90,9 @@ export function analyzeComposeConcurrency(pieces: readonly DecomposePiece[]): Co
     return false;
   };
 
-  // ⛔⭐ 「선언된 의존」과 「겹침에서 파생된 순서」를 «갈라» 본다.
-  //   분해기가 dependsOn 으로 «의미로» 정한 순서는 결함이 아니다 — 그것을 「불필요한 직렬화」로 세면
-  //   분모 B 가 거짓으로 0 이 되고, 통과할 판이 fail 로 뒤집힌다(이 갈림을 안 두었더니 실제로 그랬다).
+  // ⛔⭐ 「선언된 의존」으로 직렬된 쌍은 결함이 «아니다» — 분해기가 dependsOn 으로 «의미로» 정한 순서다.
+  //   겹침 간선이 사라진(2026-10-16) 그래프에서 남는 직렬은 전부 선언에서 오므로,
+  //   overlappingSerialized 는 «선언 외 직렬»만 센다 — 0 이 아니면 새 간선 원천이 생겼다는 방어 관측이다.
   const ids = new Set(pieces.map((p) => p.id));
   const declared: Record<string, string[]> = Object.fromEntries(pieces.map((p) => [p.id, [] as string[]]));
   for (const piece of pieces) {
@@ -120,16 +108,29 @@ export function analyzeComposeConcurrency(pieces: readonly DecomposePiece[]): Co
       const a = pieces[i]!, b = pieces[j]!;
       const overlaps = Boolean(a.hotPaths?.some((p) => b.hotPaths?.includes(p)));
       const serial = reachIn(edges, a.id, b.id) || reachIn(edges, b.id, a.id);
-      if (overlaps) { overlappingPairs++; if (serial) overlappingSerialized++; continue; }
+      if (overlaps) {
+        overlappingPairs++;
+        // ⛔ 선언된 의존으로 직렬된 겹침은 결함이 아니다 — «선언 외» 직렬만 센다.
+        if (!(reachIn(declared, a.id, b.id) || reachIn(declared, b.id, a.id)) && serial) overlappingSerialized++;
+        continue;
+      }
       // 선언된 의존으로 이미 순서가 있는 쌍은 분모 B 에서 «뺀다» — 나란히 갈 이유가 없는 쌍이다.
       if (reachIn(declared, a.id, b.id) || reachIn(declared, b.id, a.id)) continue;
       nonOverlappingPairs++;
       if (!serial) nonOverlappingConcurrent++;
     }
   }
-  const verdict: ComposeConcurrencyReport['verdict'] =
-    overlappingPairs === 0 || nonOverlappingPairs === 0 ? 'unmeasured'
-      : overlappingSerialized === overlappingPairs && nonOverlappingConcurrent >= 1 ? 'pass'
-        : 'fail';
-  return { overlappingPairs, overlappingSerialized, nonOverlappingPairs, nonOverlappingConcurrent, verdict };
+  return {
+    overlappingPairs, overlappingSerialized, nonOverlappingPairs, nonOverlappingConcurrent,
+    verdict: composeConcurrencyVerdict({ overlappingPairs, overlappingSerialized, nonOverlappingPairs, nonOverlappingConcurrent }),
+  };
+}
+
+/** RFC §5 5단계 판정식 — 파생 그래프에서 fail 이 구조적으로 안 나와도 식 자체는 살아 있다. */
+export function composeConcurrencyVerdict(
+  counts: Pick<ComposeConcurrencyReport, 'overlappingPairs' | 'overlappingSerialized' | 'nonOverlappingPairs' | 'nonOverlappingConcurrent'>,
+): ComposeConcurrencyReport['verdict'] {
+  return counts.overlappingPairs === 0 || counts.nonOverlappingPairs === 0 ? 'unmeasured'
+    : counts.overlappingSerialized === 0 && counts.nonOverlappingConcurrent >= 1 ? 'pass'
+      : 'fail';
 }

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