elanous 0.2.23 → 0.2.24

package/src/self-implement/child-context-composition.ts

@@ -0,0 +1,139 @@
+import { debug } from '../debug/log.js';
+
+export const SMALL_CHILD_CONTEXT_TOKEN_BUDGET = 32_000;
+
+export const CHILD_CONTEXT_COMPONENT_NAMES = [
+  'systemPrompt',
+  'agentsMd',
+  'claudeMd',
+  'toolSchemas',
+  'goal',
+  'ledger',
+] as const;
+
+export type ChildContextComponentName = typeof CHILD_CONTEXT_COMPONENT_NAMES[number];
+export type ChildContextProfile = 'default' | 'small';
+
+export interface ChildContextComponents {
+  readonly systemPrompt?: string;
+  readonly agentsMd?: string;
+  readonly claudeMd?: string;
+  readonly toolSchemas?: string;
+  readonly goal?: string;
+  readonly ledger?: string;
+}
+
+export interface ChildContextComponentMeasurement {
+  readonly inputBytes: number;
+  readonly includedBytes: number;
+  readonly truncated: boolean;
+}
+
+export interface ChildContextComposition {
+  readonly text: string;
+  readonly profile: ChildContextProfile;
+  readonly budgetTokens: number | null;
+  /** UTF-8 bytes are a conservative upper bound on tokenizer tokens. */
+  readonly tokenUpperBound: number;
+  readonly components: Readonly<Record<ChildContextComponentName, ChildContextComponentMeasurement>>;
+}
+
+export interface ComposeChildContextOptions {
+  readonly profile?: ChildContextProfile;
+  readonly log?: (event: string, data: Record<string, unknown>) => void;
+}
+
+const JOINER = '\n\n';
+
+function utf8Bytes(value: string): number {
+  return Buffer.byteLength(value, 'utf8');
+}
+
+function prefixWithinUtf8Budget(value: string, byteBudget: number): string {
+  if (byteBudget <= 0) return '';
+  let included = '';
+  let bytes = 0;
+  for (const character of value) {
+    const characterBytes = utf8Bytes(character);
+    if (bytes + characterBytes > byteBudget) break;
+    included += character;
+    bytes += characterBytes;
+  }
+  return included;
+}
+
+function emptyMeasurements(): Record<ChildContextComponentName, ChildContextComponentMeasurement> {
+  return {
+    systemPrompt: { inputBytes: 0, includedBytes: 0, truncated: false },
+    agentsMd: { inputBytes: 0, includedBytes: 0, truncated: false },
+    claudeMd: { inputBytes: 0, includedBytes: 0, truncated: false },
+    toolSchemas: { inputBytes: 0, includedBytes: 0, truncated: false },
+    goal: { inputBytes: 0, includedBytes: 0, truncated: false },
+    ledger: { inputBytes: 0, includedBytes: 0, truncated: false },
+  };
+}
+
+function emitCompositionEvent(
+  log: ((event: string, data: Record<string, unknown>) => void) | undefined,
+  data: Record<string, unknown>,
+): void {
+  try {
+    if (log) log('child.context-composition', data);
+    else debug.log('self-implement', 'child.context-composition', data);
+  } catch {
+    // Context composition must not fail because an observation sink is unavailable.
+  }
+}
+
+/**
+ * Composes the implementation child's first-turn context and records the byte
+ * contribution of every input component. The small profile spends its hard cap
+ * on executable context first and trims repository instruction files last.
+ */
+export function composeChildContext(
+  components: ChildContextComponents,
+  options: ComposeChildContextOptions = {},
+): ChildContextComposition {
+  const profile = options.profile ?? 'default';
+  const budgetBytes = profile === 'small' ? SMALL_CHILD_CONTEXT_TOKEN_BUDGET : null;
+  const measurements = emptyMeasurements();
+  const included: Partial<Record<ChildContextComponentName, string>> = {};
+  const order: readonly ChildContextComponentName[] = profile === 'small'
+    ? ['systemPrompt', 'toolSchemas', 'goal', 'ledger', 'agentsMd', 'claudeMd']
+    : CHILD_CONTEXT_COMPONENT_NAMES;
+  let usedBytes = 0;
+  let includedCount = 0;
+
+  for (const name of order) {
+    const value = components[name] ?? '';
+    const inputBytes = utf8Bytes(value);
+    const separatorBytes = includedCount > 0 && value.length > 0 ? utf8Bytes(JOINER) : 0;
+    const availableBytes = budgetBytes === null ? Number.POSITIVE_INFINITY : Math.max(0, budgetBytes - usedBytes - separatorBytes);
+    const includedValue = inputBytes <= availableBytes ? value : prefixWithinUtf8Budget(value, availableBytes);
+    const includedBytes = utf8Bytes(includedValue);
+    measurements[name] = { inputBytes, includedBytes, truncated: includedBytes < inputBytes };
+    if (includedValue.length === 0) continue;
+    included[name] = includedValue;
+    usedBytes += separatorBytes + includedBytes;
+    includedCount += 1;
+  }
+
+  const text = CHILD_CONTEXT_COMPONENT_NAMES
+    .flatMap((name) => included[name] === undefined ? [] : [included[name]!])
+    .join(JOINER);
+  const tokenUpperBound = utf8Bytes(text);
+  const result: ChildContextComposition = {
+    text,
+    profile,
+    budgetTokens: budgetBytes === null ? null : SMALL_CHILD_CONTEXT_TOKEN_BUDGET,
+    tokenUpperBound,
+    components: measurements,
+  };
+  emitCompositionEvent(options.log, {
+    profile,
+    budgetTokens: result.budgetTokens,
+    tokenUpperBound,
+    components: measurements,
+  });
+  return result;
+}

package/src/self-implement/child-llm-preference.ts

@@ -11,9 +11,12 @@ import type {
 import { DEFAULT_BUDGET_GATE } from '../user-config.js';
 import { debug } from '../debug/log.js';
 
+/** 체인 한 칸. `codexCredits` = `llm.fallbackChain` 의 `codex-credits` 칸(codex 를 선불 크레딧으로 · 마지막 수단). */
+export type ChildLlmChainSlot = ChildLlmChainEntry & { readonly codexCredits?: true };
+
 export interface ResolvedChildLlmPreference {
   mode: ChildLlmPreferenceMode;
-  chain: ChildLlmChainEntry[];
+  chain: ChildLlmChainSlot[];
   budgetGate: {
     minHeadroomPercent: number;
     onShortfall: BudgetGateOnShortfall;
@@ -27,6 +30,8 @@ export type ChildLlmPreferenceInput = Pick<UserConfig, 'tools' | 'llm'> & Partia
 const FALLBACK_NAME_TO_PROVIDER: Readonly<Record<string, string>> = {
   'codex-rotate': 'openai-codex',
   grok: 'grok',
+  // CODEX-CREDITS-STEP — provider 는 같은 codex 지만 «크레딧 칸»이라 따로 센다(아래 중복 판정).
+  'codex-credits': 'openai-codex',
 };
 
 function warnPreference(detail: string): void {
@@ -39,15 +44,18 @@ function warnPreference(detail: string): void {
 }
 
 /** `llm.fallbackChain` 이름을 자식 프로바이더 칸으로 옮긴다. 모르는 이름은 경고하고 건너뛴다. */
-export function chainFromFallbackNames(names: readonly string[] | undefined): ChildLlmChainEntry[] {
-  const chain: ChildLlmChainEntry[] = [];
+export function chainFromFallbackNames(names: readonly string[] | undefined): ChildLlmChainSlot[] {
+  const chain: ChildLlmChainSlot[] = [];
   for (const name of names ?? []) {
     const provider = FALLBACK_NAME_TO_PROVIDER[name];
     if (!provider) {
       warnPreference(`llm.fallbackChain 의 모르는 이름 '${name}' 을 건너뜀`);
       continue;
     }
-    if (!chain.some((entry) => entry.provider === provider)) chain.push({ provider });
+    const codexCredits = name === 'codex-credits';
+    if (!chain.some((entry) => entry.provider === provider && (entry.codexCredits === true) === codexCredits)) {
+      chain.push(codexCredits ? { provider, codexCredits: true } : { provider });
+    }
   }
   return chain;
 }
@@ -60,7 +68,7 @@ export function resolveChildLlmPreference(config: ChildLlmPreferenceInput): Reso
   const mode: ChildLlmPreferenceMode = explicitMode ?? (provider ? 'pinned' : 'auto');
   const modeSource: ResolvedChildLlmPreference['source']['mode'] = explicitMode ? 'explicit' : 'inferred';
 
-  let chain: ChildLlmChainEntry[];
+  let chain: ChildLlmChainSlot[];
   let chainSource: ResolvedChildLlmPreference['source']['chain'];
   if (mode === 'pinned') {
     // 계정 회전은 여기 없다. provider 없는 model 은 pinned 가 아니다.

package/src/self-implement/claude-acp-implement.ts

@@ -0,0 +1,67 @@
+// ── CLAUDE-IMPL-LANE — `--child-llm-provider claude-acp` 의 구현 실행 (호스트 레인 · 구독 ACP) ──
+//
+// claude-acp 는 «LLM provider» 가 아니라 구현 실행기 선택이다. 이 갈래는 implement seam 이 PTY 자식
+// (`elanous chat` · getProvider) 대신 부른다 — PTY 자식으로 보내면 getProviderForConfig 가 모델 이름(claude-…)을
+// 보고 anthropic(API 키 provider)으로 풀어 «구독» 런이 API 로 과금된다(10-11 #26277 보류 판독).
+//
+// fail-closed: 구독 확인 실패 · 사용률 미측정 · 상한(기본 85%) 이상 · 프록시 주소 없음이면 거부하고
+// 다른 공급자로 조용히 새지 않는다(거부 사유는 관측 `self-implement.claude-acp` `refused`).
+import { debug } from '../debug/log.js';
+import { makeAcpImplementer, type AcpImplementerOpts, type AcpImplementerResult } from '../agent-substrate/acp-implementer.js';
+import { subscriptionReviewerAvailability, type SubscriptionReviewerDeps } from '../self-dev/review-provider-fallback.js';
+
+/** 구현 레인의 구독 사용률 상한(%) — 대표 10-11 «Claude 구독(ACP) = 계정 둘 · 85 까지». 리뷰어 상한(95)과 별개 값. */
+export const CLAUDE_ACP_IMPLEMENT_CAP_DEFAULT = 85;
+export const CLAUDE_ACP_PROVIDER = 'claude-acp';
+
+export function isClaudeAcpChild(childLlm: { provider?: string } | undefined): boolean {
+  return childLlm?.provider?.trim().toLowerCase() === CLAUDE_ACP_PROVIDER;
+}
+
+/** 상한은 `ELANOUS_CLAUDE_ACP_CAP`(0~100)로만 바꾼다 — 잘못된 값은 기본 85(올려 잡지 않는다). */
+export function claudeAcpImplementCap(env: NodeJS.ProcessEnv = process.env): number {
+  const raw = env.ELANOUS_CLAUDE_ACP_CAP?.trim();
+  const n = raw ? Number(raw) : Number.NaN;
+  return Number.isFinite(n) && n >= 0 && n <= 100 ? n : CLAUDE_ACP_IMPLEMENT_CAP_DEFAULT;
+}
+
+export type ClaudeAcpImplementOutcome =
+  | { kind: 'refused'; reason: string }
+  | { kind: 'ran'; result: AcpImplementerResult };
+
+export interface ClaudeAcpImplementInput {
+  cwd: string;
+  prompt: string;
+  model?: string;
+  runId?: string;
+  env?: NodeJS.ProcessEnv;
+  /** 시험 주입 — 구독 확인·상태 읽기. */
+  availabilityDeps?: SubscriptionReviewerDeps;
+  /** 시험 주입 — ACP 에이전트 생성기(makeAcpImplementer 로 그대로 넘긴다). */
+  createAgent?: AcpImplementerOpts['createAgent'];
+  timeoutMs?: number;
+}
+
+export async function runClaudeAcpImplement(input: ClaudeAcpImplementInput): Promise<ClaudeAcpImplementOutcome> {
+  const env = input.env ?? process.env;
+  const cap = claudeAcpImplementCap(env);
+  const availability = subscriptionReviewerAvailability({ provider: CLAUDE_ACP_PROVIDER }, cap, env, input.availabilityDeps ?? {});
+  if (!availability.spawn) {
+    const reason = availability.reason ?? 'Claude subscription unavailable';
+    debug.log('self-implement.claude-acp', 'refused', { reason, cap, ...(input.runId ? { runId: input.runId } : {}) }, { level: 'warn' });
+    return { kind: 'refused', reason };
+  }
+  const proxyBaseUrl = availability.spawn.env.ANTHROPIC_BASE_URL;
+  debug.log('self-implement.claude-acp', 'start', { cap, proxy: proxyBaseUrl !== undefined, model: input.model ?? '(default)', ...(input.runId ? { runId: input.runId } : {}) });
+  const implement = makeAcpImplementer({
+    worktree: input.cwd,
+    env,
+    ...(proxyBaseUrl ? { proxyBaseUrl } : {}),
+    ...(input.model ? { model: input.model } : {}),
+    ...(input.timeoutMs !== undefined ? { timeoutMs: input.timeoutMs } : {}),
+    ...(input.createAgent ? { createAgent: input.createAgent } : {}),
+  });
+  const result = await implement(input.prompt);
+  debug.log('self-implement.claude-acp', 'done', { chars: result.text.length, allowed: result.allowed, denied: result.denied, ...(input.runId ? { runId: input.runId } : {}) });
+  return { kind: 'ran', result };
+}

package/src/self-implement/flex-signals.ts

@@ -0,0 +1,59 @@
+/**
+ * 재작업 라운드 관측 신호 넷 — 관측 전용 순수 계산(FLEX-RFC §A-①).
+ *
+ * ⛔ 판정·분기·오버레이 상태를 만들지 않는다. 호출자는 결과를 원장에 «남기기만» 한다.
+ * ⛔ 모르는 값은 0 으로 지어내지 않고 키를 뺀다(key-absent) — 0 은 «측정했더니 없었다»의 값이다.
+ */
+
+export interface FlexSignalsInput {
+  /** 오래된 라운드 → 최신 라운드 순의 게이트 실패 id 목록. `undefined`·빈 목록은 «실패 id 를 못 쟀다». */
+  gateFailedIdsByRound: readonly (readonly string[] | undefined)[];
+  /** 최신 게이트 실패들의 base 귀속(`preexisting`·`introduced`·`unknown` …). 못 쟀으면 `undefined`. */
+  failureAttributions?: readonly string[] | undefined;
+  /** 지금 orchestrator 가 알고 있는 review_repeat 값 그대로. */
+  reviewRepeat?: number | undefined;
+  /** 지금까지 쓴 라운드 수. */
+  round: number;
+  /** 계획된 라운드 상한(effectiveMax). 모르면 `undefined`. */
+  plannedRounds?: number | undefined;
+}
+
+export interface FlexSignals {
+  fail_signature_repeat?: number;
+  base_reproduce?: number;
+  review_repeat?: number;
+  budget_burn?: number;
+}
+
+function failureKey(ids: readonly string[] | undefined): string | undefined {
+  return ids?.length ? JSON.stringify([...new Set(ids)].sort()) : undefined;
+}
+
+/** 최신 라운드의 실패 id 집합이 그 이전 라운드들에서 «같은 집합»으로 나온 횟수. 최신 집합을 모르면 `undefined`. */
+function failSignatureRepeat(rounds: FlexSignalsInput['gateFailedIdsByRound']): number | undefined {
+  if (rounds.length === 0) return undefined;
+  const latest = failureKey(rounds[rounds.length - 1]);
+  if (latest === undefined) return undefined;
+  return rounds.slice(0, -1).filter((ids) => failureKey(ids) === latest).length;
+}
+
+/** base 에서도 재현된(`preexisting`) 실패 수. 귀속이 비었거나 하나라도 `unknown` 이면 `undefined`. */
+function baseReproduce(attributions: FlexSignalsInput['failureAttributions']): number | undefined {
+  if (attributions === undefined || attributions.length === 0) return undefined;
+  if (attributions.includes('unknown')) return undefined;
+  return attributions.filter((attribution) => attribution === 'preexisting').length;
+}
+
+export function computeFlexSignals(input: FlexSignalsInput): FlexSignals {
+  const repeat = failSignatureRepeat(input.gateFailedIdsByRound);
+  const reproduce = baseReproduce(input.failureAttributions);
+  const burn = input.plannedRounds !== undefined && input.plannedRounds > 0
+    ? input.round / input.plannedRounds
+    : undefined;
+  return {
+    ...(repeat === undefined ? {} : { fail_signature_repeat: repeat }),
+    ...(reproduce === undefined ? {} : { base_reproduce: reproduce }),
+    ...(input.reviewRepeat === undefined ? {} : { review_repeat: input.reviewRepeat }),
+    ...(burn === undefined ? {} : { budget_burn: burn }),
+  };
+}

package/src/self-implement/frozen-merges.ts

@@ -5,7 +5,7 @@ import { dirname, join, resolve } from 'node:path';
 import { effectiveInstanceRoot, prodInstanceRoot } from '../instance/resolve.js';
 import { debug } from '../debug/log.js';
 import { enterJourneyNode, exitJourneyNode, passJourneyNode, withJourneyNodeSync } from '../self-dev/graph-journey-nodes.js';
-import { routeJourneyEdge } from '../self-dev/graph-journey-route.js';
+import { freezeCheckHolds, routeJourneyEdge } from '../self-dev/graph-journey-route.js';
 import { beginLandingMerge, type LandingFreeze } from '../release-loop/landing-freeze.js';
 
 /** `manual`: the owning repository could not be determined — a sweep never resumes it; a person does. */
@@ -194,8 +194,13 @@ export function admitLandingMerge(
     () => admitLandingMergeUnobserved(heldEntry, root, hooks, claimKey, opts));
   const freezeLabel = admission.kind === 'merge' ? 'open' : admission.kind === 'held' ? 'frozen' : 'taken';
   exitJourneyNode('freeze-check', { provenance: 'admit-landing-merge', outcome: freezeLabel, ...(pr === undefined ? {} : { data: { pr } }) });
-  // 2판: 간선 판독을 남긴다(관측). 승인 요구(open→hold) 강제는 0.2.22 — 보류 사유 값이 먼저다(RFC §3).
-  routeJourneyEdge('freeze-check', freezeLabel, { freeze: freezeLabel });
+  const route = routeJourneyEdge('freeze-check', freezeLabel, { freeze: freezeLabel });
+  // 그래프가 열린 병합을 hold 로 보내면(launch 오버레이의 «승인 요구») 병합하지 않고 보류한다. 답이 없으면 오늘 판정 그대로.
+  if (admission.kind === 'merge' && freezeCheckHolds(freezeLabel, route)) {
+    admission.end();
+    passJourneyNode('hold', { provenance: 'admit-landing-merge', outcome: 'graph-hold', ...(pr === undefined ? {} : { data: { pr } }) });
+    return { kind: 'held', freeze: { reason: 'graph freeze-check → hold', startedAt: new Date().toISOString(), until: null, by: 'graph' } };
+  }
   return admission;
 }
 

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

@@ -5,6 +5,7 @@ import { llmDecomposeSteps } from '../harness/llm-decompose.js';
 import { GOAL_AUTHOR_COARSE_MAX_SLICES } from '../task-orchestrator/generator-prompt.js';
 import { getDefaultLogStore } from '../mss/logging/log-store.js';
 import { emitDecision } from '../live/detail-switch.js';
+import { selectPlanningLlm } from '../prompt-enhance/enhance.js';
 import type { GoalAuthorDeps } from './goal-author.js';
 
 const GOAL_STEPS_DECOMPOSED_EVENT = 'goal-steps-decomposed';
@@ -64,10 +65,17 @@ export function createGoalAuthorDecomposeSteps(
 ): NonNullable<GoalAuthorDeps['decomposeSteps']> {
   return async (objective, options) => {
     const { streamLLM } = await import('../llm.js');
+    // ⭐ AUTHOR-DECOMPOSE-KNOB(0.2.24 · G7 #25848) — 쪼개기·적대 비평의 두 streamLLM 호출이 인핸서와
+    //   «같은 규칙»으로 planning 노브(roleLlm.planning ⊕ ELANOUS_PROMPT_ENHANCE_MODEL/EFFORT)를 따른다.
+    //   미설정이면 종전 그대로 — model 은 아예 전달하지 않는다(streamLLM 기본 모델) ⊕ effort 는 high.
+    const { model, effort } = selectPlanningLlm();
+    const llmOpts: { model?: string; reasoningEffort: 'low' | 'medium' | 'high' } = model === undefined
+      ? { reasoningEffort: effort }
+      : { model, reasoningEffort: effort };
     let decompositionRationale: string | undefined;
     const steps = await llmDecomposeSteps(
       objective,
-      (input) => streamLLM([{ role: 'user', content: input.prompt }], () => {}, { reasoningEffort: 'high' }).then((text) => ({ text })),
+      (input) => streamLLM([{ role: 'user', content: input.prompt }], () => {}, llmOpts).then((text) => ({ text })),
       { ...(options?.context ? { context: options.context } : {}), maxTasks: GOAL_AUTHOR_COARSE_MAX_SLICES, promptProfile: 'goal-author-coarse', ...(signal ? { signal } : {}), onRationale: (rationale) => { decompositionRationale = rationale; } },
     );
     const heft = classifyHeft(objective);
@@ -120,7 +128,7 @@ export function createGoalAuthorDecomposeSteps(
       return finalSteps;
     };
     if (!reviewExecuted) return finalize(steps, decompositionRationale);
-    const critic = (prompt: string) => streamLLM([{ role: 'user', content: prompt }], () => {}, { reasoningEffort: 'high' });
+    const critic = (prompt: string) => streamLLM([{ role: 'user', content: prompt }], () => {}, llmOpts);
 
     try {
       const critique = await adversarialPlanCritique(objective, steps, critic, options?.context);

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

@@ -1233,6 +1233,21 @@ function countAddressableLines(contents: string): number {
 }
 
 const TRACED_PATH_LIST_ITEM = /^\s*(?:[-*+]|\d+[.)])\s+(.+)$/;
+const TRACED_PATH_LEADING_LIST_MARKERS = /^(?:\s*(?:[-*+]|\d+[.)])\s+)+/;
+const TRACED_PATH_EVIDENCE_TAG = /^\[(?:code|skill|memory|doc|pty|unknown)\]\s+/;
+// 2026-10-11 — 저작기가 «목록 기호 두 겹»(`- - src/x.ts` · `- 1. src/x.ts` · `- [code] - src/x.ts`)을 쓰면
+//   한 겹만 벗긴 남은 «- src/…» 를 경로로 읽어 `traced path does not exist: - src/…` ERROR 를 냈다
+//   (Pod 저작에서 자식이 결과 줄 없이 죽음 · 오늘 no-result-line 18건의 공용 원인). 기호·태그를 반복해서 벗긴다.
+function tracedPathListItem(line: string): string | undefined {
+  const item = TRACED_PATH_LIST_ITEM.exec(line)?.[1];
+  if (item === undefined) return undefined;
+  let evidence = item;
+  for (;;) {
+    const next = evidence.replace(TRACED_PATH_LEADING_LIST_MARKERS, '').replace(TRACED_PATH_EVIDENCE_TAG, '');
+    if (next === evidence) return evidence;
+    evidence = next;
+  }
+}
 // ⛔⭐⭐⭐ 2026-08-11 — 이 문면은 «통하지 않는 처방»을 첫 번째로 권하고 있었다.
 //   옛 문면: *"Re-authoring the same input may produce different evidence; **retry before changing the ask**."*
 //   📏 실측(두 트랙 합산): 그 말대로 «재저작»만 반복했더니 ***0/4***. ask 에 «식별자 앵커»를 넣자 ***2/2***.
@@ -1355,9 +1370,8 @@ export function tracedPathReferences(document: string): TracedPathReference[] {
   if (!section) return [];
   const references: TracedPathReference[] = [];
   for (const line of section.split(/\r?\n/)) {
-    const item = TRACED_PATH_LIST_ITEM.exec(line)?.[1];
-    if (!item) continue;
-    const evidence = item.replace(/^\[(?:code|skill|memory|doc|pty|unknown)\]\s+/, '');
+    const evidence = tracedPathListItem(line);
+    if (!evidence) continue;
     if (isTracedPathsEvidenceUnavailable(evidence) || isTracedPathExclusionDescription(evidence)) continue;
     // 설명 구분자는 **공백으로 둘러싼** em dash 또는 hyphen 뿐이다 — 파일명 안의 dash 를 설명 구분자로 오인하지 않는다.
     // 경로 칸 안의 복수 경로는 **공백으로 둘러싼** 가운뎃점만 본다 — 파일명 안의 `·` 를 가르지 않는다.
@@ -1367,10 +1381,12 @@ export function tracedPathReferences(document: string): TracedPathReference[] {
     for (const fragment of pathField.split(' · ')) {
       const trimmed = fragment.trim();
       if (!trimmed) continue;
-      const unwrapped = stripInlineCode(trimmed);
+      // 10-11 재발 — 저작기가 «`- src/…`» 처럼 목록 기호를 백틱 «안»에 쓰면 바깥 기호만 벗긴 뒤 백틱을 벗겨
+      //   «- src/…» 가 경로로 남았다(AUTHOR-DECOMPOSE-KNOB · MODEL-BENCH-SCORES 부검). 백틱을 벗긴 뒤 한 번 더 벗긴다.
+      const unwrapped = stripInlineCode(trimmed).replace(TRACED_PATH_LEADING_LIST_MARKERS, '');
       const match = TRACED_PATH_LINE.exec(unwrapped);
       // 두 번 벗긴다 — 줄번호가 백틱 **안**(`p:42`)일 수도 **밖**(`p`:42)일 수도 있다.
-      const path = match ? stripInlineCode(match[1].trim()) : undefined;
+      const path = match ? stripInlineCode(match[1].trim()).replace(TRACED_PATH_LEADING_LIST_MARKERS, '') : undefined;
       if (!path) continue;
       references.push({ path, line: match?.[2] ? Number(match[2]) : null, endLine: match?.[3] ? Number(match[3]) : null });
     }
@@ -1461,9 +1477,8 @@ export function lintGoalFile(document: string, branch: string, deps: GoalFileLin
   const { prohibitionSymbolStartingLineCount, permissionSymbolStartingLineCount, mixedSymbolLineCount } = symbolStartingLineCounts(document);
   const { exhaustiveRequestWordingCount, blanketBehaviorPreservationCount, namedPreservationTargetCount, removalFormDecisionConditionCount } = goalAuthorKnownShapeCounts(ask);
   const tracedPathExclusionCount = (markdownSection(document, 'TRACED PATHS')?.split(/\r?\n/) ?? [])
-    .map((line) => TRACED_PATH_LIST_ITEM.exec(line)?.[1])
-    .filter((item): item is string => item !== undefined
-      && isTracedPathExclusionDescription(item.replace(/^\[(?:code|skill|memory|doc|pty|unknown)\]\s+/, ''))).length;
+    .map((line) => tracedPathListItem(line))
+    .filter((item): item is string => item !== undefined && isTracedPathExclusionDescription(item)).length;
   const selfQuestionSubjectViolations = detectSelfQuestionSubjectViolations(document);
   const launchDeclarationClassification = artifactLaunchDeclarationClassification(document);
   const headings = canonicalBlocks(document);
@@ -1694,7 +1709,7 @@ export function lintGoalFile(document: string, branch: string, deps: GoalFileLin
     });
   }
   const unavailableTracedPathEvidence = markdownSection(document, 'TRACED PATHS')?.split(/\r?\n/)
-    .map((line) => TRACED_PATH_LIST_ITEM.exec(line)?.[1])
+    .map((line) => tracedPathListItem(line))
     .find((item): item is string => item !== undefined && isTracedPathsEvidenceUnavailable(item));
   if (unavailableTracedPathEvidence) {
     const requiresTracedPaths = goalType === null || goalType === 'implement';

package/src/self-implement/graph-overlay-condition.ts

@@ -1,3 +1,5 @@
+import type { RunStopClass } from './run-stop.js';
+
 /** ⭐ RFC §5 «4단계» — `applies_when` 을 «코드»가 판정한다.
  *
  *  ⛔⭐ **표현식 엔진을 만들지 않는다.** 문법이 넓어지면 오버레이가 «작은 프로그램»이 되고,
@@ -31,6 +33,32 @@ export function parseOverlayCondition(source: string): OverlayConditionParse {
   return { ok: true, condition: { key: key!, operator: operator as OverlayConditionOperator, literal } };
 }
 
+/** Inputs known at a runtime overlay decision. Every field except `attempts` may be unknown. */
+export interface RuntimeOverlayStateInput {
+  readonly attempts: number;
+  readonly goalId?: string;
+  readonly stopClass?: RunStopClass;
+  readonly reviewRepeat?: number;
+  /** Only a real boolean is a measurement. */
+  readonly siblingOverlap?: unknown;
+  readonly mainSyncConflict?: unknown;
+  /** Only a non-empty string is a measurement. */
+  readonly authorGrade?: unknown;
+}
+
+/** ⛔ 아는 값만 싣는다 — 모르면 키를 «뺀다». 0·false·빈 문자열을 지어내지 않는다. */
+export function buildRuntimeOverlayState(input: RuntimeOverlayStateInput): Record<string, unknown> {
+  return {
+    attempts: input.attempts,
+    ...(input.goalId === undefined ? {} : { goal_id: input.goalId }),
+    ...(input.stopClass === undefined ? {} : { stop_class: input.stopClass }),
+    ...(typeof input.reviewRepeat === 'number' && Number.isFinite(input.reviewRepeat) ? { review_repeat: input.reviewRepeat } : {}),
+    ...(typeof input.siblingOverlap === 'boolean' ? { sibling_overlap: input.siblingOverlap } : {}),
+    ...(typeof input.mainSyncConflict === 'boolean' ? { main_sync_conflict: input.mainSyncConflict } : {}),
+    ...(typeof input.authorGrade === 'string' && input.authorGrade.length > 0 ? { author_grade: input.authorGrade } : {}),
+  };
+}
+
 export type OverlayConditionVerdict =
   /** 조건이 참이다 — 얹는다. */
   | { readonly kind: 'applies' }

package/src/self-implement/graph-overlay-yaml.ts

@@ -1,7 +1,7 @@
 import { readFileSync, readdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { parse as parseYaml } from 'yaml';
+import { parse as parseYaml, parseAllDocuments } from 'yaml';
 import { inspectPipelineGraph, type PipelineGraphDefect } from './pipeline-shape.js';
 import { edgeMapOf, type GraphParseIssue, type GraphTemplateSpec } from './graph-yaml.js';
 import { evaluateOverlayCondition } from './graph-overlay-condition.js';
@@ -15,7 +15,8 @@ import type { OverlayPatch } from './graph-overlay.js';
  *    ⑴ 얹은 «결과»에 위상 검사를 다시 건다 — 노드 집합이 그대로여도 도달 가능성은 바뀐다
  *    ⑵ 계약이 빠진 노드를 «거부»한다 — 권한 없는 노드가 조용히 들어오는 것을 막는다
  *    ⑶ 무엇을 얹었는지를 «값»으로 낸다 — 사후에 「왜 이 걸음인가」를 답하려면 필요하다 */
-export type OverlayStage = 'launch' | 'runtime';
+/** `heal` = 멈춤 갈래 사다리 전용 — `stop-autoheal.ts` 만 고른다. 실행기의 launch·runtime 선택에는 «안» 잡힌다. */
+export type OverlayStage = 'launch' | 'runtime' | 'heal';
 
 export interface OverlayPatchOp {
   readonly op: 'add' | 'replace' | 'remove';
@@ -33,19 +34,52 @@ export interface GraphOverlaySpec {
 }
 
 export interface OverlayParseResult {
+  /** 첫 오버레이 — 한 파일에 하나만 둔 기존 선언의 읽기 자리. */
   readonly overlay?: GraphOverlaySpec;
+  /** 파일이 선언한 오버레이 전부. `---` 로 문서를 나누면 한 파일에 여럿이다. 오류가 하나라도 있으면 비어 있다. */
+  readonly overlays: readonly GraphOverlaySpec[];
   readonly errors: readonly GraphParseIssue[];
 }
 
-const STAGES = new Set<OverlayStage>(['launch', 'runtime']);
+const STAGES = new Set<OverlayStage>(['launch', 'runtime', 'heal']);
 const OPS = new Set(['add', 'replace', 'remove']);
 
-/** ⛔ 던지지 않는다 — 파서 계약은 `graph-yaml.ts` 와 같다. */
+/** ⛔ 던지지 않는다 — 파서 계약은 `graph-yaml.ts` 와 같다.
+ *  한 파일 = 문서 하나가 기본이다. `---` 로 나눈 여러 문서는 문서마다 오버레이 하나로 읽는다
+ *  (오류 경로는 `<label>#<문서 번호>`). 문서가 하나면 읽는 법도 오류 문면도 예전과 같다. */
 export function parseGraphOverlayYaml(source: string, label = '<inline>'): OverlayParseResult {
-  const errors: GraphParseIssue[] = [];
   let raw: unknown;
   try { raw = parseYaml(source); }
-  catch (error) { return { errors: [{ path: label, message: `YAML 파싱 실패: ${error instanceof Error ? error.message : String(error)}` }] }; }
+  catch (error) {
+    const documents = parseAllDocuments(source);
+    if (documents.length > 1 && documents.every((document) => document.errors.length === 0)) {
+      return overlaysFromDocuments(documents.map((document) => document.toJS() as unknown), label);
+    }
+    return { overlays: [], errors: [{ path: label, message: `YAML 파싱 실패: ${error instanceof Error ? error.message : String(error)}` }] };
+  }
+  const parsed = overlayFromRaw(raw, label);
+  return { ...(parsed.overlay ? { overlay: parsed.overlay } : {}), overlays: parsed.overlay ? [parsed.overlay] : [], errors: parsed.errors };
+}
+
+function overlaysFromDocuments(raws: readonly unknown[], label: string): OverlayParseResult {
+  const errors: GraphParseIssue[] = [];
+  const overlays: GraphOverlaySpec[] = [];
+  for (const [index, raw] of raws.entries()) {
+    const parsed = overlayFromRaw(raw, `${label}#${index}`);
+    errors.push(...parsed.errors);
+    if (parsed.overlay) overlays.push(parsed.overlay);
+  }
+  const seen = new Set<string>();
+  for (const overlay of overlays) {
+    if (seen.has(overlay.overlayId)) errors.push({ path: `${label}/overlay_id`, message: `overlay_id '${overlay.overlayId}' 가 한 파일에서 중복이다` });
+    seen.add(overlay.overlayId);
+  }
+  if (errors.length > 0) return { overlays: [], errors };
+  return { overlay: overlays[0]!, overlays, errors };
+}
+
+function overlayFromRaw(raw: unknown, label: string): { overlay?: GraphOverlaySpec; errors: GraphParseIssue[] } {
+  const errors: GraphParseIssue[] = [];
   if (raw === null || typeof raw !== 'object') return { errors: [{ path: label, message: 'YAML 최상위가 맵이 아니다' }] };
   const doc = raw as Record<string, unknown>;
 
@@ -198,7 +232,7 @@ export function loadGraphOverlays(dir: string): OverlayLoadResult {
     catch (error) { errors.push({ path: file, message: `읽기 실패: ${error instanceof Error ? error.message : String(error)}` }); continue; }
     const result = parseGraphOverlayYaml(source, file);
     errors.push(...result.errors);
-    if (result.overlay) overlays.push(result.overlay);
+    overlays.push(...result.overlays);
   }
   return { overlays, errors, scannedFiles: files.length };
 }

package/src/self-implement/graph-templates.ts

@@ -23,6 +23,7 @@ export interface GraphTemplateNode {
   readonly kind: GraphNodeSpec['kind'];
   /** 그 노드의 재방문 상한. ⛔ 지금의 rework 상한이 «여기로 올라올» 자리다(RFC §4.1). */
   readonly maxVisits: number;
+  readonly journeyStage?: string;
   /** YAML recipe identifier; existing orchestrator does not execute it. */
   readonly recipe?: string;
   /** YAML이 선언한 선택 계약. 관측용이며 실행 권한을 강제하지 않는다. */
@@ -34,6 +35,7 @@ export interface GraphTemplate {
   readonly version: string;
   readonly entryNode: string;
   readonly terminalNodes: readonly string[];
+  readonly journeyStages?: readonly string[];
   /** YAML 템플릿이 선언한 문서 전용 변경의 gate 건너뛰기 정책. */
   readonly docsOnlyGateSkip?: boolean;
   /** 선언된 런 계약(선택) — 런 시작 때 발사 인자·부모 계약과 함께 한 번 해석된다. */
@@ -104,7 +106,7 @@ export function defaultGraphsDir(): string {
   return join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'graphs');
 }
 
-export type DiscardedGraphNodeField = Exclude<keyof GraphNodeSpec, 'nodeId' | 'kind' | 'maxVisits' | 'recipe' | 'contract'>;
+export type DiscardedGraphNodeField = Exclude<keyof GraphNodeSpec, 'nodeId' | 'kind' | 'maxVisits' | 'journeyStage' | 'recipe' | 'contract'>;
 
 export interface GraphTemplateCompilation {
   readonly template: GraphTemplate;
@@ -129,12 +131,14 @@ export function compileGraphTemplate(spec: GraphTemplateSpec): GraphTemplateComp
       version: String(spec.version),
       entryNode: spec.entryNode,
       terminalNodes: spec.terminalNodes,
+      ...(spec.journeyStages === undefined ? {} : { journeyStages: spec.journeyStages }),
       ...(spec.docsOnlyGateSkip !== undefined ? { docsOnlyGateSkip: spec.docsOnlyGateSkip } : {}),
       ...(spec.runContract !== undefined ? { runContract: spec.runContract } : {}),
       nodes: spec.nodes.map((n) => ({
         nodeId: n.nodeId,
         kind: n.kind,
         maxVisits: n.maxVisits,
+        ...(n.journeyStage === undefined ? {} : { journeyStage: n.journeyStage }),
         ...(n.recipe === undefined ? {} : { recipe: n.recipe }),
         ...(n.contract === undefined ? {} : { contract: n.contract }),
       })),
@@ -324,6 +328,34 @@ export function inspectAllTemplates(): Array<{ graphId: string; defects: Pipelin
     .map((t) => ({ graphId: t.graphId, defects: inspectPipelineGraph(t.edges, t.entryNode) }));
 }
 
+/** L0 ratios are distinct: stages represented by nodes, and nodes accounted for by this run. */
+export function measureL0Coverage(
+  template: GraphTemplate,
+  enteredNodes: Iterable<string>,
+  skippedNodes: Iterable<string>,
+): {
+  declarationCoverage: number | null;
+  traversalCoverage: number | null;
+  declaredStageCount: number;
+  listedStageCount: number;
+  accountedNodeCount: number;
+  declaredNodeCount: number;
+} {
+  const stages = template.journeyStages ?? [];
+  const declaredStages = new Set(template.nodes.map((node) => node.journeyStage).filter((stage): stage is string => stage !== undefined && stages.includes(stage)));
+  const accounted = new Set([...enteredNodes, ...skippedNodes]);
+  const declaredNodeCount = template.nodes.length;
+  const accountedNodeCount = template.nodes.filter((node) => accounted.has(node.nodeId)).length;
+  return {
+    declarationCoverage: stages.length ? declaredStages.size / stages.length : null,
+    traversalCoverage: declaredNodeCount ? accountedNodeCount / declaredNodeCount : null,
+    declaredStageCount: declaredStages.size,
+    listedStageCount: stages.length,
+    accountedNodeCount,
+    declaredNodeCount,
+  };
+}
+
 /** ⭐ 원장에 실을 «그래프 신원» — ⛔ 옛 TS 상수가 아니라 «지금 도는 템플릿»을 따른다.
  *
  *  🩸 계기(2026-09-08): 승격을 켠 research 런이 `investigate` 를 밟았는데 원장의