elanous 0.2.22 → 0.2.23

package/src/plugins/maker/plugin-maker.ts

@@ -10,6 +10,7 @@ import { dispatchOmniSearch } from '../../skills/tools/omni-search.js';
 import { runGraph } from '../../graph-runner/runner.js';
 import { parseGraphTemplateYaml } from '../../self-implement/graph-yaml.js';
 import { installPlugin } from '../install/plugin-install.js';
+import { inspectPluginSecurity } from '../core/capability-policy.js';
 import { generateWizardFiles, type WizardResearchDraft } from './wizard-generate.js';
 import { bundleInstalledWizardPlugin, type MarketBundleResult } from './market-bundle.js';
 
@@ -127,7 +128,7 @@ export async function validatePluginDir(dir: string): Promise<string[]> {
     if (lstatSync(file).isSymbolicLink()) errors.push('안전하지 않은 plugin.json 링크');
     else manifest = JSON.parse(readFileSync(file, 'utf8'));
   }
-  catch (error) { errors.push(`plugin.json 파싱 실패: ${String(error)}`); }
+  catch { errors.push('plugin.json 파싱 실패'); }
   const extension = isRecord(manifest) && isRecord(manifest.extensions) ? manifest.extensions['ai.elanous'] : undefined;
   const graphs = isRecord(extension) ? extension.graphs : undefined;
   if (isRecord(extension) && extension.contributes !== undefined) errors.push('extension contributes 덮어쓰기 금지');
@@ -143,69 +144,73 @@ export async function validatePluginDir(dir: string): Promise<string[]> {
     if (lstatSync(file).isSymbolicLink()) errors.push('안전하지 않은 recipes.yaml 링크');
     else recipes = parseYaml(readFileSync(file, 'utf8'));
   }
-  catch (error) { errors.push(`recipes.yaml 파싱 실패: ${String(error)}`); }
+  catch { errors.push('recipes.yaml 파싱 실패'); }
   if (!isRecord(recipes)) errors.push('recipes.yaml 은 맵이어야 한다');
   else for (const [id, recipe] of Object.entries(recipes)) {
     if (!isRecord(recipe) ||
       (!(typeof recipe.command === 'string' && recipe.command.trim()) && !(typeof recipe.approval === 'string' && recipe.approval.trim())) ||
       (recipe.command !== undefined && (typeof recipe.command !== 'string' || !recipe.command.trim())) ||
       (recipe.approval !== undefined && (typeof recipe.approval !== 'string' || !recipe.approval.trim())) ||
-      (recipe.timeout_ms !== undefined && (!Number.isSafeInteger(recipe.timeout_ms) || Number(recipe.timeout_ms) <= 0))) errors.push(`잘못된 recipe: ${id}`);
+      (recipe.timeout_ms !== undefined && (!Number.isSafeInteger(recipe.timeout_ms) || Number(recipe.timeout_ms) <= 0))) errors.push(`잘못된 recipe: ${/^[a-zA-Z0-9_-]+$/.test(id) ? id : 'invalid'}`);
   }
   for (const graph of Array.isArray(graphs) ? graphs : []) {
     if (typeof graph !== 'string') continue;
     const file = inside(dir, graph);
-    if (!file || !/^\.\/graphs\/[a-zA-Z0-9_-]+\.ya?ml$/.test(graph)) { errors.push(`안전하지 않은 graph 경로: ${graph}`); continue; }
+    if (!file || !/^\.\/graphs\/[a-zA-Z0-9_-]+\.ya?ml$/.test(graph)) { errors.push('안전하지 않은 graph 경로'); continue; }
     try {
-      if (lstatSync(file).isSymbolicLink()) { errors.push(`안전하지 않은 graph 링크: ${graph}`); continue; }
+      if (lstatSync(file).isSymbolicLink()) { errors.push('안전하지 않은 graph 링크'); continue; }
       const parsed = parseGraphTemplateYaml(readFileSync(file, 'utf8'), file);
-      errors.push(...parsed.errors.map(issue => `${issue.path}: ${issue.message}`));
+      errors.push(...parsed.errors.map(() => 'graph 정의 오류'));
       const template = parsed.template;
       if (!template) continue;
-      if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(template.graphId)) errors.push(`잘못된 graph_id: ${template.graphId}`);
+      if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(template.graphId)) errors.push('잘못된 graph_id');
       if (template.terminalNodes.length !== 2 || !template.terminalNodes.includes('done') || !template.terminalNodes.includes('failed')) errors.push('terminal_nodes 는 done, failed 이어야 한다');
       const executionNodes = template.nodes.filter(node => !template.terminalNodes.includes(node.nodeId));
       if (executionNodes.length < 2) errors.push(`실행 노드는 2개 이상이어야 한다: ${executionNodes.length}개`);
       for (const node of template.nodes) {
         if (node.recipe.startsWith('cmd:')) {
           const id = node.recipe.slice(4);
-          if (!isRecord(recipes) || !isRecord(recipes[id]) || recipes[id].approval !== undefined || typeof recipes[id].command !== 'string' || !recipes[id].command.trim()) errors.push(`recipe ${id} 없음`);
+          if (!isRecord(recipes) || !isRecord(recipes[id]) || recipes[id].approval !== undefined || typeof recipes[id].command !== 'string' || !recipes[id].command.trim()) errors.push(`recipe ${/^[a-zA-Z0-9_-]+$/.test(id) ? id : 'invalid'} 없음`);
         } else if (node.recipe.startsWith('approval:')) {
           const id = node.recipe.slice(9);
-          if (!isRecord(recipes) || !isRecord(recipes[id]) || typeof recipes[id].approval !== 'string' || !recipes[id].approval.trim()) errors.push(`approval recipe ${id} 없음`);
-        } else if (node.recipe !== 'none') errors.push(`지원하지 않는 recipe: ${node.recipe}`);
+          if (!isRecord(recipes) || !isRecord(recipes[id]) || typeof recipes[id].approval !== 'string' || !recipes[id].approval.trim()) errors.push(`approval recipe ${/^[a-zA-Z0-9_-]+$/.test(id) ? id : 'invalid'} 없음`);
+        } else if (node.recipe !== 'none') errors.push(`지원하지 않는 recipe: ${/^[a-zA-Z0-9_:-]+$/.test(node.recipe) ? node.recipe : 'invalid'}`);
       }
-    } catch (error) { errors.push(`${graph} 파싱 실패: ${String(error)}`); }
+    } catch { errors.push('graph 파싱 실패'); }
   }
   const visit = (path: string): void => {
     for (const entry of readdirSync(path, { withFileTypes: true })) {
       const file = join(path, entry.name);
-      if (entry.isSymbolicLink() || (!entry.isDirectory() && !entry.isFile())) { errors.push(`안전하지 않은 파일: ${file}`); continue; }
+      if (entry.isSymbolicLink() || (!entry.isDirectory() && !entry.isFile())) { errors.push('안전하지 않은 파일'); continue; }
       if (entry.isDirectory()) visit(file);
       else if (/\.[cm]?[jt]sx?$/.test(entry.name)) {
         const source = readFileSync(file, 'utf8');
         for (const match of source.matchAll(/\b(?:import|export)\s*(?:[\s\S]*?\s+from\s*)?["']([^"']+)["']|\b(?:import|require)\s*\(\s*["']([^"']+)["']/g)) {
           const target = match[1] ?? match[2]!;
-          if (/(?:^|\/)src\//.test(target) && (target.startsWith('/') || target.startsWith('.'))) errors.push(`src import 금지: ${file}: ${target}`);
+          if (/(?:^|\/)src\//.test(target) && (target.startsWith('/') || target.startsWith('.'))) errors.push('src import 금지');
         }
       }
     }
   };
-  try { visit(dir); } catch (error) { errors.push(`파일 검사 실패: ${String(error)}`); }
+  try { visit(dir); } catch { errors.push('파일 검사 실패'); }
   try {
     const example = join(dir, 'examples', 'input.json');
     if (lstatSync(example).isSymbolicLink()) errors.push('안전하지 않은 examples/input.json 링크');
     else JSON.parse(readFileSync(example, 'utf8'));
-  } catch (error) { errors.push(`examples/input.json 파싱 실패: ${String(error)}`); }
+  } catch { errors.push('examples/input.json 파싱 실패'); }
+  let security: ReturnType<typeof inspectPluginSecurity>;
+  try { security = inspectPluginSecurity(dir); }
+  catch { errors.push('보안 검사 실패'); return errors; }
+  if (security.scan === 'dangerous') errors.push(...security.findings.filter(f => f.level === 'dangerous').map(f => `보안 검사 차단: ${f.code}`));
   const step = join(dir, 'graphs', 'run-step.ts');
   try {
     if (!existsSync(step)) errors.push('run-step.ts 없음');
-    else if (errors.some(error => error.startsWith('안전하지 않은 파일:'))) return errors;
+    else if (errors.some(error => error.startsWith('안전하지 않은 파일'))) return errors;
     else {
       const build = await Bun.build({ entrypoints: [step], target: 'bun' });
-      if (!build.success) errors.push(...build.logs.map(log => `run-step.ts 문법 오류: ${log.message}`));
+      if (!build.success) errors.push('run-step.ts 문법 오류');
     }
-  } catch (error) { errors.push(`run-step.ts 문법 오류: ${String(error)}`); }
+  } catch { errors.push('run-step.ts 문법 오류'); }
   return errors;
 }
 
@@ -359,7 +364,7 @@ export async function makePlugin({ request, draftFile, name, parentDir, run, mar
   const step = async (stage: keyof MakePluginResult['timings'], action: () => void | Promise<void>): Promise<void> => {
     const start = performance.now();
     try { await action(); }
-    finally { const ms = Math.round(performance.now() - start); timings[stage] = ms; debug.log('plugin.maker', stage, { ms, errors: result.errors }); }
+    finally { const ms = Math.round(performance.now() - start); timings[stage] = ms; debug.log('plugin.maker', stage, { ms, errors: redactSecrets(result.errors) }); }
   };
   try {
     emit('request', request);
@@ -461,7 +466,7 @@ export async function makePlugin({ request, draftFile, name, parentDir, run, mar
     }
   } catch (error) {
     result.status = 'failed';
-    result.errors.push(error instanceof Error ? error.message : String(error));
+    result.errors.push(redactSecretText(error instanceof Error ? error.message : String(error)));
   } finally {
     emit('done', result.status, { errors: result.errors });
   }

package/src/plugins/maker/wizard-generate.ts

@@ -10,6 +10,7 @@ export interface WizardResearchDraft {
     credentials?: Array<{ name: string }>;
   }>;
   skill?: { description: string; instructions: string; requires?: string[] };
+  requires?: { knowledgePacks?: string[] };
 }
 
 const SLUG = /^[a-z0-9][a-z0-9-]{1,31}$/;
@@ -46,9 +47,16 @@ export function generateWizardFiles(dir: string, slug: string, draft: WizardRese
   if (!Array.isArray(requires) || requires.some(resource => typeof resource !== 'string' || !knownResources.has(resource))) {
     throw new Error('wizard requires must reference existing resource ids');
   }
+  if (draft.requires !== undefined && (!draft.requires || typeof draft.requires !== 'object' || Array.isArray(draft.requires) ||
+    Object.keys(draft.requires).some(key => key !== 'knowledgePacks') ||
+    (draft.requires.knowledgePacks !== undefined && (!Array.isArray(draft.requires.knowledgePacks) ||
+      draft.requires.knowledgePacks.some(pack => typeof pack !== 'string' || !pack.trim()))))) {
+    throw new Error('wizard knowledge packs must be non-empty names');
+  }
   const manifestPath = join(dir, 'plugin.json');
   const existing = existsSync(manifestPath) ? JSON.parse(readFileSync(manifestPath, 'utf8')) as {
-    name: string; description?: string; extensions: { 'ai.elanous': { connectors?: unknown[]; graphs?: string[]; researchDraft?: boolean } };
+    name: string; description?: string; requires?: { knowledgePacks?: string[]; [key: string]: unknown };
+    extensions: { 'ai.elanous': { connectors?: unknown[]; graphs?: string[]; researchDraft?: boolean } };
   } : undefined;
   if (existing && (existing.name !== slug || !existing.extensions?.['ai.elanous'])) {
     throw new Error('wizard scaffold name or extension mismatch');
@@ -69,9 +77,13 @@ export function generateWizardFiles(dir: string, slug: string, draft: WizardRese
     throw new Error('wizard cannot replace existing scaffold connectors');
   }
   const manifest = existing ?? { name: slug, version: '0.1.0', description: draft.description,
+    requires: undefined as { knowledgePacks?: string[]; [key: string]: unknown } | undefined,
     extensions: { 'ai.elanous': { graphs: [`./graphs/${slug}.yaml`],
       capabilities: ['fs:workdir', 'proc:bun', 'proc:elanous'], connectors: [] as unknown[], researchDraft: true } } };
   if (options.regenerate) manifest.description = draft.description;
+  if (draft.requires?.knowledgePacks !== undefined) {
+    manifest.requires = { ...manifest.requires, knowledgePacks: [...new Set(draft.requires.knowledgePacks)] };
+  }
   manifest.extensions['ai.elanous'].connectors = connectors;
   manifest.extensions['ai.elanous'].researchDraft = true;
 
@@ -125,7 +137,8 @@ export function listWizardDrafts(parent: string): Array<{ name: string; descript
       const skillPath = join(skillDir, 'SKILL.md');
       if (lstatSync(manifestPath).isSymbolicLink() || lstatSync(skillDir).isSymbolicLink() || lstatSync(skillPath).isSymbolicLink()) return [];
       const manifest = JSON.parse(readFileSync(manifestPath, 'utf8')) as {
-        name?: string; description?: string; extensions?: { 'ai.elanous'?: { researchDraft?: boolean; connectors?: Array<{ id: string; fields: Array<{ name: string }> }> } } };
+        name?: string; description?: string; requires?: { knowledgePacks?: string[] };
+        extensions?: { 'ai.elanous'?: { researchDraft?: boolean; connectors?: Array<{ id: string; fields: Array<{ name: string }> }> } } };
       if (manifest.name !== entry.name || manifest.extensions?.['ai.elanous']?.researchDraft !== true) return [];
       const skill = readFileSync(skillPath, 'utf8');
       const parts = /^---\n([\s\S]*?)---\n\n([\s\S]*)$/.exec(skill);
@@ -134,6 +147,7 @@ export function listWizardDrafts(parent: string): Array<{ name: string; descript
       return [{ name: entry.name, description: manifest.description, draft: {
         description: manifest.description,
         connectors: manifest.extensions['ai.elanous'].connectors?.map(connector => ({ id: connector.id, credentials: connector.fields.map(field => ({ name: field.name })) })) ?? [],
+        ...(manifest.requires?.knowledgePacks !== undefined ? { requires: { knowledgePacks: manifest.requires.knowledgePacks } } : {}),
         skill: { description: meta.description ?? manifest.description, instructions: parts[2]!.trimEnd(), requires: meta.requires ?? [] },
       } }];
     } catch { return []; }

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, parseSubscriptionReviewerSpec, 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;
@@ -164,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');

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