elanous 0.2.21 → 0.2.23

package/src/policy/llm-policy.ts

@@ -4,7 +4,7 @@ import { isScalar, parseDocument } from 'yaml';
 import { getElanousConfigDir } from '../elanous-config-dir.js';
 import { DEFAULT_FALLBACK_CHAIN, isFallbackStep, type FallbackStep } from '../oauth/fallback-chain.js';
 import { isCodexQuotaPolicy } from '../oauth/codex-quota-policy.js';
-import { DEFAULT_BUDGET_GATE_MAX_USED_PERCENT, MODEL_ROLES, RUNTIME_LLM_PROVIDER_NAMES, parseRoleLlmEntry, type RoleLlmConfig } from '../user-config.js';
+import { DEFAULT_BUDGET_GATE_MAX_USED_PERCENT, MODEL_ROLES, RUNTIME_LLM_PROVIDER_NAMES, parseRoleLlmEntry, parseSubscriptionReviewerSpec, type RoleLlmConfig, type SubscriptionReviewerSpec } from '../user-config.js';
 
 export interface LlmPolicy {
   version: 1;
@@ -22,7 +22,7 @@ export interface LlmPolicy {
     grants: Array<{ account: string; amount: number; expires: string; source: string }>;
     pace?: { targetPerDay: number; until: string; why?: string };
   };
-  caps: { codex: { harness: number; pod: number; tox: number; intake: number; headroom: number }; grok: { weekly: number; tox: number; intake: number } };
+  caps: { codex: { harness: number; pod: number; tox: number; intake: number; headroom: number }; grok: { weekly: number; tox: number; intake: number }; claude: { harness: number } };
   resetCredits: { redeem: 'human' };
   alerts: { lowRemainingPercent: number; resetCreditExpiryDays: number; creditsStep: number };
 }
@@ -71,6 +71,7 @@ export function defaultLlmPolicy(): LlmPolicy {
     caps: {
       codex: { harness: DEFAULT_BUDGET_GATE_MAX_USED_PERCENT['openai-codex']!, pod: 95, tox: 60, intake: 80, headroom: 15 },
       grok: { weekly: DEFAULT_BUDGET_GATE_MAX_USED_PERCENT.grok!, tox: 50, intake: 48 },
+      claude: { harness: 60 },
     },
     resetCredits: { redeem: 'human' },
     alerts: { lowRemainingPercent: 10, resetCreditExpiryDays: 7, creditsStep: 5000 },
@@ -103,8 +104,10 @@ export function validateLlmPolicy(input: unknown): LlmPolicyValidation {
   const grants = (v: unknown) => Array.isArray(v) && v.every(g => object(g)
     && Object.keys(g).every(k => ['account', 'amount', 'expires', 'source'].includes(k))
     && nonempty(g.account) && positive(g.amount) && date(g.expires) && nonempty(g.source));
-  const roles = (v: unknown) => object(v) && Object.entries(v).every(([role, spec]) => MODEL_ROLES.some(r => r === role)
-    && object(spec) && Object.keys(spec).every(k => ['provider', 'tier', 'model'].includes(k)) && parseRoleLlmEntry(spec).ok);
+  const roles = (v: unknown) => object(v) && Object.entries(v).every(([role, spec]) => role === 'reviewer'
+    ? !!parseSubscriptionReviewerSpec(spec)
+    : MODEL_ROLES.some(r => r === role) && object(spec)
+      && Object.keys(spec).every(k => ['provider', 'tier', 'model'].includes(k)) && parseRoleLlmEntry(spec).ok);
   check(input, 'policy', {
     version: (v: unknown) => v === 1,
     default: { provider: (v: unknown) => nonempty(v) && RUNTIME_LLM_PROVIDER_NAMES.some(p => p === v), model: nonempty },
@@ -122,7 +125,7 @@ export function validateLlmPolicy(input: unknown): LlmPolicyValidation {
         && Object.keys(v).every(k => ['targetPerDay', 'until', 'why'].includes(k)),
     },
     caps: { codex: { harness: percent, pod: percent, tox: percent, intake: percent, headroom: percent },
-      grok: { weekly: percent, tox: percent, intake: percent } },
+      grok: { weekly: percent, tox: percent, intake: percent }, claude: { harness: percent } },
     resetCredits: { redeem: (v: unknown) => v === 'human' },
     alerts: { lowRemainingPercent: percent, resetCreditExpiryDays: positive, creditsStep: positive },
   });
@@ -161,6 +164,19 @@ function removeExpired(input: Obj, now: Date, warnings: string[], prefix = ''):
   }
 }
 
+/**
+ * The reviewer ACP lane (`roleLlm.reviewer`) and its usage cap, resolved once for every caller.
+ * The harness (`dev-pipeline`) and `elanous self review` read the same policy row, so the two
+ * reviewers cannot drift apart on which config selects the subscription reviewer.
+ */
+export function resolveSubscriptionReviewer(
+  loaded: LoadedLlmPolicy,
+  userRoleLlm?: RoleLlmConfig,
+): { spec: SubscriptionReviewerSpec; cap: number } | undefined {
+  const spec = loaded.policy.roles.reviewer ?? userRoleLlm?.reviewer;
+  return spec ? { spec, cap: loaded.policy.caps.claude.harness } : undefined;
+}
+
 export function loadLlmPolicy(opts: LoadLlmPolicyOptions = {}): LoadedLlmPolicy {
   const configDir = opts.configDir ?? getElanousConfigDir();
   const path = opts.path ?? join(configDir, 'policy', 'llm.yaml');
@@ -191,7 +207,9 @@ export function loadLlmPolicy(opts: LoadLlmPolicyOptions = {}): LoadedLlmPolicy
     add('llm.provider', llm.provider, base, 'provider', v => nonempty(v) && RUNTIME_LLM_PROVIDER_NAMES.some(p => p === v));
     add('llm.model', llm.model, base, 'model', nonempty);
     if (Object.keys(base).length) overlay.default = base;
-    add('roleLlm', legacy.roleLlm, overlay, 'roles', v => object(v) && Object.entries(v).every(([r, spec]) => MODEL_ROLES.some(k => k === r) && parseRoleLlmEntry(spec).ok));
+    add('roleLlm', legacy.roleLlm, overlay, 'roles', v => object(v) && Object.entries(v).every(([r, spec]) => r === 'reviewer'
+      ? !!parseSubscriptionReviewerSpec(spec)
+      : MODEL_ROLES.some(k => k === r) && parseRoleLlmEntry(spec).ok));
     add('llm.fallbackChain', llm.fallbackChain, overlay, 'fallback', v => Array.isArray(v) && v.length > 0 && v.every(isFallbackStep) && new Set(v).size === v.length);
     const codex: Obj = {};
     add('llm.codexAccountOrder', llm.codexAccountOrder, codex, 'order', v => Array.isArray(v) && v.every(nonempty));

package/src/process/pid-liveness.ts

@@ -14,7 +14,6 @@
  *  ⚠️ 이 판정은 «같은 호스트»에서만 뜻이 있다 — pid 는 호스트 지역 값이다.
  *     락처럼 호스트가 섞이는 소비자는 호스트를 «먼저» 가른 뒤 이걸 부른다.
  */
-import { debug } from '../debug/log.js';
 
 /** ⛔ 두 값이 아니라 «셋»이다 — 「살아 있는데 내가 못 건드린다」는 별도의 사실이다.
  *  그것을 `alive` 나 `dead` 어느 쪽으로도 접지 않는 것이 이 타입의 존재 이유다. */
@@ -58,6 +57,7 @@ export function pidLiveness(pid: number): PidLiveness {
   if (verdict === 'alive-not-mine') {
     // ⛔ 「살아 있는데 남의 것」은 조용히 지나가면 안 된다 — 🅢 요청(2026-09-20):
     //   원장에 «대상 pid 와 소유자 축»이 남아야 A 구간(남의 트리에서 도는 자식)과 닿는다.
+    const { debug } = require('../debug/log.js') as { debug: { log: (category: string, event: string, data: Record<string, unknown>) => void } };
     debug.log('process.liveness', 'kill-refused', { pid, myUid: myUid(), errno });
     observer?.({ pid, liveness: verdict, myUid: myUid(), errno });
   }

package/src/prompt-cache/openai.ts

@@ -35,7 +35,8 @@ export function parseOpenAIUsage(event: unknown): LLMUsage | null {
   const r = raw as {
     prompt_tokens?: number;
     completion_tokens?: number;
-    prompt_tokens_details?: { cached_tokens?: number };
+    /** OpenRouter 는 캐시 쓰기를 `cache_write_tokens` 로 싣는다(Anthropic 상류 · OR-ANTHROPIC-CACHE). */
+    prompt_tokens_details?: { cached_tokens?: number; cache_write_tokens?: number };
     completion_tokens_details?: { reasoning_tokens?: number };
     /** Kimi(Moonshot) — 최상위에 싣는다. */
     cached_tokens?: number;
@@ -50,14 +51,17 @@ export function parseOpenAIUsage(event: unknown): LLMUsage | null {
   //   캐시 단가로 또 한 번 매겨진다(BACKLOG C4 · opencode openai-chat.ts · hermes normalize_usage 와 같은 처리).
   const cached = [r.prompt_tokens_details?.cached_tokens, r.cached_tokens, r.prompt_cache_hit_tokens]
     .find((v): v is number => typeof v === 'number');
-  if (typeof r.prompt_tokens === 'number') out.inputTokens = Math.max(0, r.prompt_tokens - (cached ?? 0));
+  // OR-ANTHROPIC-CACHE — OpenRouter(Anthropic 상류)의 캐시 «쓰기»도 prompt_tokens 에 포함돼 온다 → 새 입력에서 빼고
+  //   cacheCreationInputTokens 로 옮긴다(Anthropic 규약). 칸이 없으면(OpenAI·Grok·DeepSeek …) 종전과 같다.
+  const written = typeof r.prompt_tokens_details?.cache_write_tokens === 'number' ? r.prompt_tokens_details.cache_write_tokens : undefined;
+  if (typeof r.prompt_tokens === 'number') out.inputTokens = Math.max(0, r.prompt_tokens - (cached ?? 0) - (written ?? 0));
   if (typeof r.completion_tokens === 'number') out.outputTokens = r.completion_tokens;
-  if (cached !== undefined) {
-    out.cacheReadInputTokens = cached;
+  if (cached !== undefined || written !== undefined) {
+    out.cacheReadInputTokens = cached ?? 0;
     // OpenAI caches are free-on-hit and rolled into prompt_tokens for
     // creation — we set creation to 0 so metrics math (hit-rate) works
-    // uniformly across providers.
-    out.cacheCreationInputTokens = 0;
+    // uniformly across providers. OpenRouter→Anthropic reports writes.
+    out.cacheCreationInputTokens = written ?? 0;
   }
   // Reasoning tokens — OpenAI o1/o3, qwen 3.6 (LM Studio surfaces this
   // even though qwen calls it `reasoning_content` rather than the

package/src/prompt-cache/openrouter.ts

@@ -0,0 +1,94 @@
+// OR-ANTHROPIC-CACHE (2026-10-10) — OpenRouter 경유 Anthropic·Moonshot(Kimi) 호출의 프롬프트 캐시 중단점.
+//
+// OpenRouter 는 OpenAI 꼴 본문을 받아 상류(Anthropic·Moonshot)로 옮긴다. 이 두 계열은 «요청이 청해야»
+// 캐시를 쓴다 — 본문에 `cache_control` 이 없으면 적중 0 이다(10-10 벤치: Haiku·Sonnet 5.5 팔 cachedInput 0).
+//
+// 배치(참고 구현 대조):
+//   - opencode `provider/transform.ts` applyCaching — system 앞 2 ⊕ 비-system 끝 2 (상한 4).
+//   - hermes `agent/prompt_caching.py` envelope layout — OpenRouter 는 «content 파트»의 cache_control 만 따른다.
+//     · role:tool 의 «최상위» cache_control 은 OpenRouter 에서 조용히 멎는다 → 파트에만 단다(OpenRouter 가
+//       tool_result 블록으로 옮긴다).
+//     · content 가 비거나 null 인 assistant(순수 tool_calls)는 중단점을 낭비하므로 건너뛴다.
+//     · Kimi(moonshotai/*) 도 같은 envelope 꼴로 적중 1% → 97% (hermes #25970).
+//   - tools: 따로 표시하지 않는다. Anthropic 접두 순서가 tools → system → messages 라 system 끝 중단점이
+//     도구 정의까지 덮는다. hermes 도 tools 배열 표시는 «직접 Anthropic» 경로에만 쓴다.
+//
+// ⛔ 순수 함수 — 입력 배열·메시지를 고치지 않고 바뀐 메시지만 새로 만든다.
+
+/** Anthropic 상한. */
+export const OPENROUTER_MAX_CACHE_BREAKPOINTS = 4;
+
+export type OpenRouterCacheFamily = 'anthropic' | 'moonshotai';
+
+/** wire 모델(`anthropic/claude-haiku-5.5`)이 캐시 중단점 대상인가. 대상이 아니면 null. */
+export function openRouterPromptCacheFamily(wireModel: string): OpenRouterCacheFamily | null {
+  if (wireModel.startsWith('anthropic/')) return 'anthropic';
+  if (wireModel.startsWith('moonshotai/')) return 'moonshotai';
+  return null;
+}
+
+type WireMessage = Record<string, unknown>;
+type CacheMarker = { type: 'ephemeral'; ttl?: '1h' };
+
+function isMarkablePart(part: unknown): boolean {
+  // 텍스트 파트에만 단다 — image_url 파트 위 cache_control 의 OpenRouter 전달은 확인하지 않았다(보수).
+  return !!part && typeof part === 'object' && (part as { type?: unknown }).type === 'text';
+}
+
+function canCarryMarker(msg: WireMessage): boolean {
+  const content = msg.content;
+  if (typeof content === 'string') return content.length > 0;
+  if (Array.isArray(content) && content.length > 0) return isMarkablePart(content[content.length - 1]);
+  return false;
+}
+
+function withMarker(msg: WireMessage, marker: CacheMarker): WireMessage {
+  const content = msg.content;
+  if (typeof content === 'string') {
+    return { ...msg, content: [{ type: 'text', text: content, cache_control: { ...marker } }] };
+  }
+  const parts = (content as Array<Record<string, unknown>>).slice();
+  parts[parts.length - 1] = { ...parts[parts.length - 1], cache_control: { ...marker } };
+  return { ...msg, content: parts };
+}
+
+export interface OpenRouterCachePlan {
+  messages: WireMessage[];
+  /** 실제로 단 중단점 수(0~4). */
+  breakpoints: number;
+  systemBreakpoints: number;
+  tailBreakpoints: number;
+}
+
+/** system 앞 2 ⊕ 비-system 끝 2 (합 ≤ 4) 의 마지막 텍스트 파트에 `cache_control` 을 단다.
+ *  `ttl:'1h'` 은 anthropic 계열에만 싣는다(Moonshot 의 1h 계층은 확인하지 않았다 → 기본 5m). */
+export function applyOpenRouterCacheControl(
+  messages: readonly WireMessage[],
+  opts: { family: OpenRouterCacheFamily; ttl?: '5m' | '1h' },
+): OpenRouterCachePlan {
+  const marker: CacheMarker = opts.family === 'anthropic' && opts.ttl === '1h'
+    ? { type: 'ephemeral', ttl: '1h' }
+    : { type: 'ephemeral' };
+  const out = messages.slice();
+  let systemBreakpoints = 0;
+  for (let i = 0; i < out.length && systemBreakpoints < 2; i++) {
+    if (out[i]!.role !== 'system') continue;
+    if (!canCarryMarker(out[i]!)) continue;
+    out[i] = withMarker(out[i]!, marker);
+    systemBreakpoints++;
+  }
+  const remaining = Math.min(2, OPENROUTER_MAX_CACHE_BREAKPOINTS - systemBreakpoints);
+  const tail: number[] = [];
+  for (let i = out.length - 1; i >= 0 && tail.length < remaining; i--) {
+    const m = out[i]!;
+    if (m.role === 'system') continue;
+    if (canCarryMarker(m)) tail.push(i);
+  }
+  for (const i of tail) out[i] = withMarker(out[i]!, marker);
+  return {
+    messages: out,
+    breakpoints: systemBreakpoints + tail.length,
+    systemBreakpoints,
+    tailBreakpoints: tail.length,
+  };
+}

package/src/prompt-enhance/enhance.ts

@@ -16,6 +16,7 @@ import { streamLLM, type LLMMessage } from '../llm.js';
 import { debug } from '../debug/log.js';
 import type { LLMUsage } from '../prompt-cache/types.js';
 import { llmUsageCostFields } from '../budget/llm-cost.js';
+import { getUserConfig, resolveRoleLlm, type UserConfig } from '../user-config.js';
 
 function logLlmUsage(model: string, usage: LLMUsage): void {
   try {
@@ -97,6 +98,8 @@ export interface EnhanceOpts {
    */
   checklistUse?: ChecklistUse;
   reasoningEffort?: 'low' | 'medium' | 'high';
+  /** 호출자의 저작 시점 config. 생략 시 현재 사용자 설정을 읽는다. */
+  config?: UserConfig;
   /** 산출물 유형 힌트(선택) — 예: 'PPT 발표덱', 'PLAN 문서'. 제약 문구 조정. */
   deliverableHint?: string;
   /** Optional usage observer for the caller's authoring phase; missing usage stays unknown. */
@@ -115,6 +118,8 @@ export interface EnhanceOpts {
    * ⭐ 새 LLM 경로를 만들지 않는다 — 이 모듈이 이미 그 자리의 유일한 LLM 단계다.
    */
   groundedFacts?: readonly string[];
+  /** Clock seam for the first-token observation (ms epoch); defaults to `Date.now`. */
+  now?: () => number;
 }
 
 const FENCE = '```';
@@ -129,8 +134,29 @@ function askMarkerCount(ask: string): number {
   return (ask.match(/(?:^|\s)(?:불변식|경계|판정\s*신호|invariant|boundary|decision\s+signal)\s*:/gi) ?? []).length;
 }
 
-const defaultModel = (): string =>
-  process.env.ELANOUS_PROMPT_ENHANCE_MODEL || process.env.ELANOUS_PR_REVIEW_MODEL || tierModel('better');
+type EnhanceSelectionSource = 'opts' | 'env' | 'config-role' | 'default';
+
+/** Select the authoring knobs independently; a planning effort alone cannot change the model. */
+export function selectEnhanceLlm(
+  opts: Pick<EnhanceOpts, 'model' | 'reasoningEffort' | 'config'> = {},
+  env: NodeJS.ProcessEnv = process.env,
+): { model: string; effort: 'low' | 'medium' | 'high'; modelSource: EnhanceSelectionSource; effortSource: EnhanceSelectionSource } {
+  const config = opts.config ?? getUserConfig();
+  const planning = config.roleLlm?.planning;
+  const configuredModel = opts.model === undefined && !env.ELANOUS_PROMPT_ENHANCE_MODEL
+    && planning && (planning.model || planning.tier || planning.provider)
+    ? resolveRoleLlm('planning', { config, overrides: {} }).model : undefined;
+  const modelSource: EnhanceSelectionSource = opts.model !== undefined ? 'opts'
+    : env.ELANOUS_PROMPT_ENHANCE_MODEL ? 'env'
+    : configuredModel !== undefined ? 'config-role' : 'default';
+  const model = opts.model ?? (env.ELANOUS_PROMPT_ENHANCE_MODEL || configuredModel || env.ELANOUS_PR_REVIEW_MODEL || tierModel('better'));
+  const envEffort = env.ELANOUS_PROMPT_ENHANCE_EFFORT;
+  const validEnvEffort = envEffort === 'low' || envEffort === 'medium' || envEffort === 'high' ? envEffort : undefined;
+  const effortSource: EnhanceSelectionSource = opts.reasoningEffort !== undefined ? 'opts'
+    : validEnvEffort !== undefined ? 'env'
+    : planning?.effort !== undefined ? 'config-role' : 'default';
+  return { model, effort: opts.reasoningEffort ?? validEnvEffort ?? planning?.effort ?? 'high', modelSource, effortSource };
+}
 
 /** 스캐폴드 생성 LLM 시스템 프롬프트 — 가산·원문불가침 규율. */
 const enhanceSystem = (deliverableHint?: string, wantsScqa = false, checklistUse: ChecklistUse = 'coverage-gate'): string =>
@@ -332,7 +358,10 @@ export async function enhancePrompt(raw: string, opts: EnhanceOpts = {}): Promis
     return { original, enhanced, checklist: [], verbatimPreserved: true, enhancedBy: 'fallback', model: null };
   }
 
-  const model = opts.model ?? defaultModel();
+  // Selected only when an LLM call will actually be attempted — the disabled path never records a selection.
+  const { model, effort, modelSource, effortSource } = selectEnhanceLlm(opts);
+  debug.log('prompt-enhance.model', 'selected', { model, effort, modelSource, effortSource });
+
   let goal = '';
   let constraints: string[] = [];
   let checklist: string[] = [];
@@ -367,9 +396,21 @@ export async function enhancePrompt(raw: string, opts: EnhanceOpts = {}): Promis
         ].join('\n'),
       },
     ];
-    const rawOut = await streamLLM(messages, () => {}, {
+    // ⭐ OPENROUTER-OPTIMIZE G13 — 첫 토큰까지 걸린 시간(TTFT)을 호출마다 «한 번» 남긴다.
+    //   총 소요만으로는 「대기(큐·라우팅)」와 「생성」을 못 가른다. 본문은 싣지 않는다(길이도 안 싣는다).
+    //   ⚠️ 첫 «텍스트» 델타까지다 — 추론(reasoning) 토큰을 먼저 내는 모델은 그 생성 시간도 여기 들어간다
+    //   (순수 대기·라우팅 시간으로 읽지 않는다).
+    const now = opts.now ?? Date.now;
+    const requestStartedAt = now();
+    let firstTokenLogged = false;
+    const onChunk = (delta: string): void => {
+      if (firstTokenLogged || delta.length === 0) return;
+      firstTokenLogged = true;
+      debug.log('prompt-enhance.stream', 'first-token', { model, ttftMs: Math.max(0, now() - requestStartedAt) });
+    };
+    const rawOut = await streamLLM(messages, onChunk, {
       model,
-      reasoningEffort: opts.reasoningEffort ?? 'high',
+      reasoningEffort: effort,
       onUsage: (usage) => {
         logLlmUsage(model, usage);
         try { opts.onUsage?.(usage); } catch { /* usage observation must not change enhancement */ }

package/src/prompt-library/family-prompt-coverage.ts

@@ -31,6 +31,7 @@ export const FAMILY_PROBE_MODEL_IDS: Readonly<Record<Exclude<ModelFamily, 'other
   grok: 'grok-4.7',
   gemini: 'gemini-3-pro',
   local: 'local:qwen',
+  'open-weight': 'openrouter/z-ai/glm-5.3',
 };
 
 export interface FamilyPromptCoverage {

package/src/prompt-library/universal-preamble.ts

@@ -32,11 +32,11 @@ import { buildGrokFamilyAddendum } from './grok-family-addendum.js';
 import { buildSessionGuidanceAddendum } from './session-guidance.js';
 import { getHarnessSpace } from '../harness/harness-space.js';
 
-export const PROJECT_ANCHOR_MAX_CHARS = 32 * 1024;
+export const PROJECT_ANCHOR_MAX_CHARS = 36 * 1024; // 10-10 증액(32K→36K) — 줄이기는 AGENTS-CLAUDE-DIET(0.2.24)
 /** «lean» 예산(BACKLOG L2 · 2026-09-25) — 로컬 모델 구현 자식은 매 턴 이것을 prefill 한다.
  *  📏 09-25 node-b 기록 프록시: 시스템 50,068자 중 AGENTS.md 앵커 ~32K · 트리 ~8K 가 상위 둘이었다.
  *  ⭐ 켜는 법: env `ELANOUS_PROMPT_BUDGET=lean` — 하니스 구현 자식 spawn 이 child provider 가 local 일 때 준다.
- *  ⛔ API 모델 경로의 기본(32K·8K)은 그대로다 — 잘 도는 것을 바꾸지 않는다. */
+ *  ⛔ API 모델 경로의 기본(36K·8K)은 그대로다 — 잘 도는 것을 바꾸지 않는다. */
 export const PROJECT_ANCHOR_LEAN_MAX_CHARS = 8 * 1024;
 export const PROJECT_TREE_LEAN_MAX_CHARS = 2 * 1024;
 function promptBudgetLean(): boolean { return process.env.ELANOUS_PROMPT_BUDGET?.trim() === 'lean'; }

package/src/registry/discovery/openrouter-live-resolve.ts

@@ -0,0 +1,122 @@
+// OR-MODEL-NAMESPACE (대표 2026-10-10 «OpenRouter 로 Claude 계열이 안 도는 이유를 먼저 고쳐라»).
+//
+// S: 구현 자식 모델 해석(`resolveImplementationChildModel`)은 `openrouter/<vendor>/<model>` 을 호스트의
+//    `discovery-snapshot.json` 에 «있는 id» 로만 받는다.
+// C: 스냅숏은 갱신이 멎으면 늙는다(09-23 판) — 그 뒤 OpenRouter 에 올라온 모델(claude-haiku-5.5 등)은
+//    «있는데도» 거부된다. 거부 사유는 「없다」지만 사실은 「우리 스냅숏이 모른다」다.
+// A: 스냅숏에 없을 때만 공개 `/api/v1/models` 를 «한 번» 묻는다(기존 `openrouterSource` 재사용 · 키 불요).
+//    있으면 그 항목을 스냅숏에 합치고 카탈로그를 다시 읽는다. 없으면 지금처럼 거부.
+//    ⛔ 네트워크 실패·시간 초과는 «거부»(fail-closed) — 「확인 못 함」을 「있다」로 접지 않는다.
+
+import { mkdirSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { debug } from '../../debug/log.js';
+import { isolatedCatalogTestUniverse, reloadCatalog } from '../loader.js';
+import { defaultDiscoveryCachePath, readDiscoveryCache, type DiscoverySnapshot } from './cache.js';
+import { openrouterSource } from './sources/openrouter.js';
+import type { DiscoveredModel } from './types.js';
+
+export const OPENROUTER_LIVE_RESOLVE_TIMEOUT_MS = 10_000;
+export const OPENROUTER_SNAPSHOT_STALE_DAYS = 7;
+const NAMESPACED_OPENROUTER_ID = /^openrouter\/([^/\s]+\/[^/\s]+)$/;
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+/** 이 프로세스에서 라이브로 확인한 id — 스냅숏 쓰기가 실패해도 같은 프로세스의 재해석은 통과시킨다. */
+const liveVerified = new Set<string>();
+
+export function isLiveVerifiedOpenRouterModel(id: string): boolean {
+  return liveVerified.has(id);
+}
+
+export function __resetOpenRouterLiveResolveForTests(): void {
+  liveVerified.clear();
+}
+
+/** `openrouter/<vendor>/<model>` → `<vendor>/<model>`(스냅숏·OpenRouter 의 id). 형식이 아니면 undefined. */
+export function upstreamOpenRouterId(id: string): string | undefined {
+  return NAMESPACED_OPENROUTER_ID.exec(id)?.[1];
+}
+
+/** 카탈로그 로더가 «접는» 스냅숏 경로. 시험 런타임에서 명시 경로가 없으면 undefined(실 `~/.elanous` 를 안 건드린다). */
+export function foldSnapshotPath(): string | undefined {
+  const explicit = process.env.ELANOUS_CATALOG_DISCOVERY_SNAPSHOT?.trim();
+  if (explicit) return explicit;
+  if (isolatedCatalogTestUniverse()) return undefined;
+  return defaultDiscoveryCachePath();
+}
+
+export function snapshotAgeDays(snapshot: DiscoverySnapshot | null, now: number = Date.now()): number | undefined {
+  if (!snapshot?.generatedAt) return undefined;
+  const t = Date.parse(snapshot.generatedAt);
+  if (!Number.isFinite(t)) return undefined;
+  return Math.max(0, Math.floor((now - t) / DAY_MS));
+}
+
+export function readFoldSnapshotAgeDays(now: number = Date.now()): number | undefined {
+  const path = foldSnapshotPath();
+  return path ? snapshotAgeDays(readDiscoveryCache({ cachePath: path }), now) : undefined;
+}
+
+function persistMergedModel(path: string, model: DiscoveredModel, now: number): boolean {
+  try {
+    const existing = readDiscoveryCache({ cachePath: path });
+    const snapshot: DiscoverySnapshot = existing ?? {
+      version: 1,
+      generatedAt: new Date(now).toISOString(),
+      sources: [],
+      models: [],
+    };
+    if (!snapshot.models.some((m) => m.provider === 'openrouter' && m.id === model.id)) {
+      snapshot.models.push(model);
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(snapshot, null, 2), 'utf-8');
+    renameSync(tmp, path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export type OpenRouterLiveLookup =
+  | { found: true; id: string; merged: DiscoveredModel; persisted: boolean; snapshotAgeDays?: number }
+  | { found: false; id: string; error?: string; snapshotAgeDays?: number };
+
+/** 스냅숏에 없는 `openrouter/<vendor>/<model>` 을 공개 `/models` 에 «한 번» 묻는다.
+ *  found → 스냅숏에 합치고(가능하면) 카탈로그를 다시 읽는다. error → 확인 못 함(호출자가 거부). */
+export async function liveLookupOpenRouterModel(
+  id: string,
+  opts: { fetchImpl?: typeof fetch; timeoutMs?: number; now?: () => number; persist?: boolean } = {},
+): Promise<OpenRouterLiveLookup> {
+  const now = opts.now ?? Date.now;
+  const path = foldSnapshotPath();
+  const ageDays = path ? snapshotAgeDays(readDiscoveryCache({ cachePath: path }), now()) : undefined;
+  const age = ageDays !== undefined ? { snapshotAgeDays: ageDays } : {};
+  const upstream = upstreamOpenRouterId(id);
+  if (!upstream) {
+    debug.log('registry.discovery', 'child-model-live-resolve', { id, found: false, ...age, error: 'not-namespaced' });
+    return { found: false, id, error: 'not-namespaced', ...age };
+  }
+  const result = await openrouterSource.run({
+    timeoutMs: opts.timeoutMs ?? OPENROUTER_LIVE_RESOLVE_TIMEOUT_MS,
+    ...(opts.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
+    now,
+  });
+  if (!result.ok) {
+    const error = result.error ?? 'unknown';
+    debug.log('registry.discovery', 'child-model-live-resolve', { id, found: false, ...age, error });
+    return { found: false, id, error, ...age };
+  }
+  const merged = result.models.find((m) => m.id === upstream);
+  if (!merged) {
+    debug.log('registry.discovery', 'child-model-live-resolve', { id, found: false, ...age });
+    return { found: false, id, ...age };
+  }
+  liveVerified.add(id);
+  // ⚠️ 잠금 없는 read-modify-write — discovery 크론과 같은 순간이면 한쪽 쓰기가 사라질 수 있다(감시 항목 · 다음 조회가 다시 합친다).
+  const persisted = path && opts.persist !== false ? persistMergedModel(path, merged, now()) : false;
+  if (persisted) reloadCatalog();
+  debug.log('registry.discovery', 'child-model-live-resolve', { id, found: true, ...age, persisted });
+  return { found: true, id, merged, persisted, ...age };
+}

package/src/registry/loader.ts

@@ -385,13 +385,18 @@ function buildCatalog(): Catalog {
   };
 }
 
+/** 시험 런타임(NODE_ENV=test)은 카탈로그 스냅숏을 기본 경로에서 접지 않는다 — 이 판정을 쓰는 쪽(자식 모델 형식 검사)과 공유한다. */
+export function isolatedCatalogTestUniverse(): boolean {
+  return process.env.NODE_ENV === 'test';
+}
+
 /** 폴드할 스냅숏을 고른다. ⛔ 시험 런타임은 preload 가 config-dir 를 격리하지 않아 실제
  *  `~/.elanous/discovery-snapshot.json` 을 읽게 되므로(=기계마다 다른 카탈로그), 경로를 «명시»했을
  *  때만 접는다. 운영은 기본 경로를 읽고, 없으면 «모른다»(null) — 접을 것이 없을 뿐 오류가 아니다. */
 function loadFoldSnapshot(): DiscoverySnapshot | null {
   const explicit = process.env.ELANOUS_CATALOG_DISCOVERY_SNAPSHOT?.trim();
   if (explicit) return readDiscoveryCache({ cachePath: explicit });
-  if (process.env.NODE_ENV === 'test') return null;
+  if (isolatedCatalogTestUniverse()) return null;
   return readDiscoveryCache();
 }
 

package/src/release-loop/checklist-board.ts

@@ -0,0 +1,27 @@
+import { debug } from '../debug/log.js';
+import { checklistDevVersion, listChecklist, summarizeChecklist, type Checklist } from './checklist.js';
+
+/** One text board shared by the Telegram and TUI slash surfaces. */
+export function renderChecklistBoard(checklist: Checklist): string {
+  const { green, yellow, red, done, blocked } = summarizeChecklist(checklist);
+  const { bySeat } = summarizeChecklist({
+    ...checklist,
+    items: checklist.items.filter((item) => item.status === 'yellow'),
+  });
+  return [
+    `판 ${checklist.version} · 초록 ${green} · 노랑 ${yellow} · 빨강 ${red} · 끝 ${done}`,
+    `빨강 칸: ${blocked.join(', ') || '-'}`,
+    `자리별 노랑: ${Object.entries(bySeat).sort(([a], [b]) => a.localeCompare(b)).map(([seat, count]) => `${seat} ${count}`).join(' · ') || '-'}`,
+  ].join('\n');
+}
+
+/** Read and render the selected board without turning failures into zero counts. */
+export function checklistBoardSlash(args: readonly string[], read: (version: string) => Checklist = listChecklist): string {
+  if (args.length > 1) return '사용법: /board [판]';
+  try {
+    return renderChecklistBoard(read(args[0] ?? checklistDevVersion()));
+  } catch (error) {
+    debug.log('release.checklist', 'board-read-failed', { version: args[0] ?? null, error: error instanceof Error ? error.message : String(error) });
+    return '판 체크리스트를 못 읽었다 — 「없다」가 아니다';
+  }
+}

package/src/release-loop/checklist.ts

@@ -7,8 +7,9 @@ import { CliUserError } from '../cli/cli-user-error.js';
 
 export type ChecklistStatus = 'green' | 'yellow' | 'red' | 'done';
 export type ChecklistDisposition = 'move' | 'known-issue' | 'block';
-/** `screen` = a five-surface feature cell — its evidence carries a `짝:` line (MANUAL-five-surface-parity §A). */
-export type ChecklistKind = 'screen';
+/** `screen` = a five-surface feature cell — its evidence carries a `짝:` line (MANUAL-five-surface-parity §A). `postpub` = measured after publication, outside the pre-publication gate. */
+export type ChecklistKind = 'screen' | 'postpub';
+const CHECKLIST_KINDS: readonly ChecklistKind[] = ['screen', 'postpub'];
 export interface ChecklistItem {
   id: string;
   title: string;
@@ -175,6 +176,44 @@ export function cellsReferencingDoc(doc: string, checklists: readonly Checklist[
   return rows;
 }
 
+/** 문서 절과 판 칸의 `#절` 인용을 양방향으로 대조한다. 원장은 전달받은 스냅샷만 읽는다. */
+export function lintDocRefs(docPath: string, docText: string, checklists: readonly Checklist[]): {
+  sections: string[];
+  uncoveredSections: string[];
+  danglingRefs: Array<{ version: string; id: string; ref: string }>;
+} {
+  const path = splitRef(docPath.trim()).path;
+  const sections: string[] = [];
+  let fence: { marker: string; length: number } | null = null;
+  for (const line of docText.split(/\r?\n/)) {
+    const marker = /^ {0,3}(`{3,}|~{3,})/.exec(line)?.[1];
+    if (fence) {
+      if (marker?.[0] === fence.marker && marker.length >= fence.length && /^\s*$/.test(line.slice(line.indexOf(marker) + marker.length))) fence = null;
+      continue;
+    }
+    if (marker) { fence = { marker: marker[0]!, length: marker.length }; continue; }
+    const heading = /^ {0,3}#{2,4}[ \t]+(\S+)/.exec(line);
+    if (heading) {
+      const section = heading[1]!.replace(/[.:]$/, '');
+      if (!sections.includes(section)) sections.push(section);
+    }
+  }
+  const known = new Set(sections);
+  const cited = new Set<string>();
+  const danglingRefs: Array<{ version: string; id: string; ref: string }> = [];
+  for (const data of checklists) {
+    for (const item of data.items) {
+      for (const ref of item.refs ?? []) {
+        const got = splitRef(ref);
+        if (got.path !== path || !got.section) continue;
+        if (known.has(got.section)) cited.add(got.section);
+        else danglingRefs.push({ version: data.version, id: item.id, ref });
+      }
+    }
+  }
+  return { sections, uncoveredSections: sections.filter((section) => !cited.has(section)), danglingRefs };
+}
+
 /** `| 판 | 칸 | 상태 | 절 | 제목 |` 마크다운 표 — 행이 없으면 머리줄 둘만. */
 export function renderRefsStatus(rows: readonly DocRefRow[]): string {
   const cell = (value: string) => value.replace(/\|/g, '\\|').replace(/\r?\n/g, ' ');
@@ -189,7 +228,7 @@ export function validateCeoLoad(input: { ceoMinutes?: number; ceoDate?: string }
 export function addItem(v: string, input: { id: string; title: string; refs?: string[]; owner?: string; kind?: ChecklistKind; priority?: ChecklistItem['priority']; predecessors?: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string; accelerator?: boolean }, options: { allowDuplicateId?: boolean } = {}): Checklist {
   if (!input.id.trim()) throw new CliUserError('칸 id 가 비었다');
   if (!input.title.trim()) throw new CliUserError('칸 제목이 비었다');
-  if (input.kind !== undefined && input.kind !== 'screen') throw new CliUserError(`잘못된 종류: ${input.kind}`, 'screen');
+  if (input.kind !== undefined && !CHECKLIST_KINDS.includes(input.kind)) throw new CliUserError(`잘못된 종류: ${input.kind}`, 'screen|postpub');
   if (input.owner !== undefined) parseOwner(input.owner);
   if (input.priority !== undefined && !['P0', 'P1', 'P2'].includes(input.priority)) throw new CliUserError(`잘못된 우선순위: ${input.priority}`);
   if (input.predecessors !== undefined && (!Array.isArray(input.predecessors) || input.predecessors.some((p) => typeof p !== 'string' || !p.trim() || p === input.id))) throw new CliUserError('잘못된 선행 칸');
@@ -220,7 +259,7 @@ export function setItem(v: string, id: string, patch: { status?: ChecklistStatus
     if (!item) throw new CliUserError(`없는 칸: ${id}`, 'list 로 칸 목록을 본다');
     if (patch.status !== undefined && !['green', 'yellow', 'red', 'done'].includes(patch.status)) throw new CliUserError(`잘못된 상태: ${patch.status}`);
     if (patch.disposition !== undefined && !['move', 'known-issue', 'block'].includes(patch.disposition)) throw new CliUserError(`잘못된 처분: ${patch.disposition}`);
-    if (patch.kind !== undefined && patch.kind !== 'screen') throw new CliUserError(`잘못된 종류: ${patch.kind}`, 'screen');
+    if (patch.kind !== undefined && !CHECKLIST_KINDS.includes(patch.kind)) throw new CliUserError(`잘못된 종류: ${patch.kind}`, 'screen|postpub');
     if (patch.priority !== undefined && !['P0', 'P1', 'P2'].includes(patch.priority)) throw new CliUserError(`잘못된 우선순위: ${patch.priority}`);
     if (patch.predecessors !== undefined && (!Array.isArray(patch.predecessors) || patch.predecessors.some((p) => typeof p !== 'string' || !p.trim() || p === id))) throw new CliUserError('잘못된 선행 칸');
     if (patch.deadlineVersion !== undefined) store.validateVersion(patch.deadlineVersion);
@@ -319,6 +358,8 @@ export interface ChecklistGate {
   blocked: string[];
   moved: string[];
   knownIssues: Array<{ id: string; title: string; evidence: string }>;
+  /** Post-publication cells excluded from the pre-publication judgement. */
+  postpub?: string[];
   /** Screen cells whose `짝:` line is missing or has an untracked ⏳ — a warning; it never changes `ok`. */
   parity?: Array<{ id: string; why: string }>;
 }
@@ -336,8 +377,9 @@ export function parityGap(evidence: string | undefined): string | null {
 }
 
 export function checklistGate(v: string): ChecklistGate {
-  const result: ChecklistGate = { ok: true, red: [], undecided: [], blocked: [], moved: [], knownIssues: [], parity: [] };
+  const result: ChecklistGate = { ok: true, red: [], undecided: [], blocked: [], moved: [], knownIssues: [], postpub: [], parity: [] };
   for (const item of listChecklist(v).items) {
+    if (item.kind === 'postpub') { result.postpub!.push(item.id); continue; }
     if (item.kind === 'screen') {
       const why = parityGap(item.evidence);
       if (why) result.parity!.push({ id: item.id, why });
@@ -350,16 +392,27 @@ export function checklistGate(v: string): ChecklistGate {
     else result.undecided.push(item.id);
   }
   result.ok = result.red.length === 0 && result.undecided.length === 0 && result.blocked.length === 0;
+  if (result.postpub!.length) debug.log('release-loop.checklist', 'gate-postpub-excluded', { version: v, ids: result.postpub });
   return result;
 }
 
 /** GATE-ENTRY-ALIGN: the cut-time judgement shared by `release run`'s entry check and the checklist-gate node —
- *  past the landing deadline a non-P0 yellow without a disposition is carried (moved), and a P0 yellow always blocks. */
+ *  past the landing deadline a non-P0 yellow without a disposition is carried (moved); P0 yellow blocks unless OP recorded known-issue. */
 export function cutChecklistGate(v: string, landBy: string | null | undefined, now: Date = new Date()): ChecklistGate & { autoMoved: string[] } {
-  const items = listChecklist(v).items;
+  const { items, history } = listChecklist(v);
   const overdue = landBy !== null && landBy !== undefined && now.getTime() > Date.parse(landBy);
-  const autoMoved = overdue ? items.filter((item) => item.status === 'yellow' && item.priority !== 'P0' && item.disposition === undefined).map((item) => item.id) : [];
-  const p0 = items.filter((item) => item.status === 'yellow' && item.priority === 'P0').map((item) => item.id);
+  const autoMoved = overdue ? items.filter((item) => item.kind !== 'postpub' && item.status === 'yellow' && item.priority !== 'P0' && item.disposition === undefined).map((item) => item.id) : [];
+  const p0 = items.filter((item) => {
+    if (item.kind === 'postpub' || item.status !== 'yellow' || item.priority !== 'P0') return false;
+    if (item.disposition === 'known-issue') {
+      const decision = [...history].reverse().find((entry) => entry.id === item.id && entry.field === 'disposition' && entry.to === 'known-issue');
+      if (decision?.by === 'OP') {
+        debug.log('release-loop.checklist', 'p0-known-issue-allowed', { version: v, id: item.id, by: decision.by, at: decision.at });
+        return false;
+      }
+    }
+    return true;
+  }).map((item) => item.id);
   const gate = checklistGate(v);
   gate.undecided = gate.undecided.filter((id) => !autoMoved.includes(id) && !p0.includes(id));
   gate.moved = gate.moved.filter((id) => !p0.includes(id)).concat(autoMoved);