elanous 0.2.23 → 0.2.25

package/src/autopilot/mission-feasibility-negotiate.ts

@@ -11,7 +11,7 @@
 // 2 예산(§8-5·config-first): maxStalls(언제 협상) · maxReplans(언제 partial 포기). a6230f 실측 튜닝.
 // 제1원칙: 협상 제안을 debug.log('mission.negotiate')로 관측.
 
-import { getUserConfig } from '../user-config.js';
+import { getUserConfig, resolveRoleLlm } from '../user-config.js';
 import { debug } from '../debug/log.js';
 
 export interface FeasibilityBudget {
@@ -104,16 +104,17 @@ function buildNegotiatePrompt(input: NegotiateInput, overBudget: boolean): strin
   ].filter(Boolean).join('\n');
 }
 
-async function defaultJudge(prompt: string): Promise<string> {
-  // ★ 모델 기반 provider 라우팅(2026-07-14) — 협상은 강한 추론이 핵심이라 기본 opus 4.8(대표 셋업).
-  //   getProvider(model)로 모델 계열 라우팅(claude-* → anthropic·env/config 키)해 활성 provider(codex 등)
-  //   무관하게 지목 모델이 닿는다. resolveDefaultProvider(활성 반환)면 opus 를 codex 로 보내 400→fail-soft.
-  //   env(ELANOUS_NEGOTIATE_MODEL·ELANOUS_DECOMPOSE_MODEL)로 override 가능.
-  const { streamLLM, getProvider } = await import('../llm.js');
-  const model = process.env.ELANOUS_NEGOTIATE_MODEL || process.env.ELANOUS_DECOMPOSE_MODEL || 'claude-opus-4-8';
-  const provider = getProvider(model);
+export async function defaultJudge(prompt: string): Promise<string> {
+  const { streamLLM, getProvider, PROVIDERS } = await import('../llm.js');
+  const override = process.env.ELANOUS_NEGOTIATE_MODEL || process.env.ELANOUS_DECOMPOSE_MODEL;
+  const resolved = override ? undefined : resolveRoleLlm('planning');
+  const model = override || resolved!.model;
+  const provider = override ? getProvider(model) : PROVIDERS[resolved!.provider];
+  const providerName = override ? provider.name : resolved!.provider;
+  if (!provider) throw new Error(`Unknown planning provider: ${providerName}`);
+  debug.log('llm.role-pin', 'resolved', { site: 'feasibility-negotiate', role: 'planning', model, provider: providerName, source: override ? 'env' : resolved!.source });
   return streamLLM([{ role: 'user', content: prompt }], () => {}, {
-    model, reasoningEffort: 'medium', ...(provider ? { provider } : {}),
+    model, provider, usageRole: 'planning', reasoningEffort: 'medium',
   });
 }
 

package/src/autopilot/mission-trace.ts

@@ -91,6 +91,17 @@ export function rollupDerived(derived: DerivedJob[]): MissionRollup {
 
 export interface TracePaths { schedulesDb?: string; tasksDb?: string; surfaceEventsDb?: string }
 
+/** 크론 행 목록 → 파생물(순수 · 행→DerivedJob 매핑의 «단일 소유»).
+ *  ⛔ 목록 화면(`/v1/missions` 카드)도 이 함수를 쓴다 — 크론 매핑을 두 번
+ *  쓰면 「트레이스는 stale 인데 카드는 ok」 갈림이 생긴다.
+ *  `staleIds` 는 `scheduleHealth(rows).stale` 로 «한 번» 구해 넣는다. */
+export function cronRowsToDerived(
+  rows: readonly ScheduleRow[],
+  staleIds: ReadonlySet<string>,
+): DerivedJob[] {
+  return rows.map(r => cronToDerived(r, staleIds.has(r.id)));
+}
+
 /** 크론 파생물 — schedule_registry.autopilot_id = apmId + scheduleHealth 상태. */
 function fetchCronDerived(apmId: string, schedulesDb?: string): DerivedJob[] {
   try {
@@ -98,7 +109,7 @@ function fetchCronDerived(apmId: string, schedulesDb?: string): DerivedJob[] {
     try {
       const rows = listSchedules(db);
       const staleIds = new Set(scheduleHealth(rows).stale.map(s => s.id));
-      return rows.filter(r => r.autopilot_id === apmId).map(r => cronToDerived(r, staleIds.has(r.id)));
+      return cronRowsToDerived(rows.filter(r => r.autopilot_id === apmId), staleIds);
     } finally { db.close(); }
   } catch { return []; }
 }

package/src/autopilot/system-lookback-run.ts

@@ -2,7 +2,7 @@
 //
 // system-lookback.ts 는 순수(의심 소스 매핑 + 프롬프트 빌더)였고, "실제 LLM 조사·소스 read 는
 // 배선측이 수행"이라 명시돼 있었다. 이 모듈이 그 배선이다: 모순 신호 → 의심 소스 파일 READ-ONLY
-// 발췌 → buildLookbackPrompt → Opus(claude-opus-4-8) 조사 → 결함 리포트. 수정 권한 없음(READ-ONLY).
+// 발췌 → buildLookbackPrompt → 역할 audit 이 고른 모델 조사 → 결함 리포트. 수정 권한 없음(READ-ONLY).
 //
 // escalate(mission-tool)가 시스템 결함 의심(systemSuspect) 페이즈에서 이 러너를 호출해 결함
 // 리포트를 얻고, 그 리포트를 수리 미션 골에 실어 스폰한다(system-repair-spawn). 진단 해상도 사다리
@@ -12,18 +12,24 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import type { ContradictionSignal } from './contradiction-detector.js';
 import { buildLookbackPrompt, suspectSourceFiles } from './system-lookback.js';
+import { resolveRoleLlm } from '../user-config.js';
+import { debug } from '../debug/log.js';
 
-/** R3 조사 LLM 호출 seam — 기본은 Opus(claude-opus-4-8·READ-ONLY 진단). 테스트/재사용 위해 주입 가능.
- *  llmReviewCritique(mission-se-bridge) 와 같은 streamLLM 패턴(모델만 Opus·진단은 길게 maxTokens 2500). */
+/** R3 조사 LLM 호출 seam — 역할 audit 모델(READ-ONLY 진단). 테스트/재사용 위해 주입 가능. */
 async function opusLookback(prompt: string): Promise<string> {
-  const { streamLLM, resolveDefaultProvider, getProvider } = await import('../llm.js');
-  const model = process.env.ELANOUS_LOOKBACK_MODEL || 'claude-opus-4-8';
-  // ★ claude 모델은 prefix 매칭(getProvider)으로 anthropic 확정(dogfood 2026-07-13 발견) —
-  //   resolveDefaultProvider 는 user-config provider(codex 등)를 모델 무관하게 반환해 claude 를
-  //   codex 로 오라우팅한다(Codex 400: model not supported). 폴백 방어까지.
-  const provider = model.startsWith('claude-') ? getProvider(model) : resolveDefaultProvider(model);
+  const { streamLLM, resolveDefaultProvider, getProvider, PROVIDERS } = await import('../llm.js');
+  const override = process.env.ELANOUS_LOOKBACK_MODEL;
+  const resolved = override ? undefined : resolveRoleLlm('audit');
+  const model = override || resolved!.model;
+  // 명시 env 모델의 provider 선택은 종전과 동일하다.
+  const provider = override
+    ? (model.startsWith('claude-') ? getProvider(model) : resolveDefaultProvider(model))
+    : PROVIDERS[resolved!.provider];
+  const providerName = override ? provider?.name : resolved!.provider;
+  if (!provider) throw new Error(`Unknown audit provider: ${providerName}`);
+  debug.log('llm.role-pin', 'resolved', { site: 'system-lookback', role: 'audit', model, provider: providerName, source: override ? 'env' : resolved!.source });
   return streamLLM([{ role: 'user', content: prompt }], () => {}, {
-    model, maxTokens: 2500, ...(provider ? { provider } : {}),
+    model, provider, usageRole: 'audit', maxTokens: 2500,
   });
 }
 

package/src/bench/bench.ts

@@ -0,0 +1,183 @@
+/**
+ * BENCH-ISOLATED-ARMS — 같은 골을 모델만 바꿔 여러 «팔»로 쏘는 벤치를 기준선과 떼어 놓는다.
+ *
+ * S: 벤치는 손 스크립트가 base sha 를 `bench/base-night-<sha12>` 로 push 하고 `harness ask --base` 로 쏜다.
+ * C: 그 벤치 가지로 다른 PR 이 squash 병합돼 기준선이 오염됐고(#26022), 팔 PR 이 PR 직전 main 동기화에서
+ *    merge-conflict 로 «실패»로 셈돼 판정이 흐려졌다.
+ * A: 기준선 가지 이름을 `bench/<id>/base` 하나로 고정하고, 그 이름 «자체»를 벤치 표지로 쓴다 —
+ *    호스트 → self orchestrate → Pod → 안쪽 harness ask 까지 `--base` 가 이미 흐르므로 새 배관이 없다.
+ *    - 팔 가지 = `bench/<id>/<arm>` (arm = 자식 모델에서 파생 ⊕ 런 접미 — 같은 모델 n 팔이 안 겹친다)
+ *    - PR base = `bench/<id>/base` · 라벨 `elanous:bench`
+ *    - PR 직전 main 동기화는 건너뛴다(관측 `bench`/`main-sync-skipped`) — 판정은 base 위 게이트·시험·리뷰
+ *    - 원장 = `<config dir>/bench/<id>.jsonl` · 읽기 = `elanous bench ls <id>`
+ *    ⛔ base 는 «자식 작업 가지의 출발점»(⊕ PR base)으로만 쓰인다 — 부모 cwd 를 base 트리로 옮기지 않는다.
+ *      부모·Pod 발사 코드는 지금 도는 코드다(원장 `parentCodeCommit` 이 그 커밋을 base sha 와 따로 적는다).
+ * ⛔ 착지 막기는 여기 몫이 아니다(LAND-BASE-MAIN-GUARD · base≠main 재사용 PR 거부).
+ */
+import { spawnSync } from 'node:child_process';
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export const BENCH_LABEL = 'elanous:bench';
+export const BENCH_LOG_CATEGORY = 'bench';
+
+const BENCH_ID = /^[a-z0-9][a-z0-9._-]{0,63}$/i;
+const SHA = /^[0-9a-f]{7,40}$/i;
+
+export interface BenchSpec { readonly id: string; readonly sha?: string }
+
+/** `--bench <id>[:<base-sha>]` 를 푼다. ⛔ 모르는 꼴은 «거부»한다 — 조용히 고치면 다른 기준선으로 돈다. */
+export function parseBenchSpec(spec: string): BenchSpec {
+  const raw = spec.trim();
+  const colon = raw.indexOf(':');
+  const id = colon < 0 ? raw : raw.slice(0, colon);
+  const sha = colon < 0 ? undefined : raw.slice(colon + 1);
+  if (!BENCH_ID.test(id) || id === 'base') {
+    throw new Error(`--bench id 가 잘못됐다: ${JSON.stringify(id)} — 영숫자로 시작하는 [A-Za-z0-9._-] 64자 이내(슬래시 금지 · 'base' 금지)`);
+  }
+  if (sha !== undefined && !SHA.test(sha)) {
+    throw new Error(`--bench base sha 가 잘못됐다: ${JSON.stringify(sha)} — 16진 7~40자`);
+  }
+  return { id, ...(sha !== undefined ? { sha: sha.toLowerCase() } : {}) };
+}
+
+export function benchBaseBranch(id: string): string { return `bench/${id}/base`; }
+
+function stripRef(ref: string): string {
+  return ref.trim().replace(/^refs\/heads\//, '').replace(/^refs\/remotes\/origin\//, '').replace(/^origin\//, '');
+}
+
+/** `bench/<id>/base` 면 id, 아니면 null. `origin/`·`refs/heads/` 접두는 벗긴다. */
+export function benchIdFromBase(ref: string | undefined | null): string | null {
+  if (!ref) return null;
+  const m = /^bench\/([^/]+)\/base$/.exec(stripRef(ref));
+  return m && BENCH_ID.test(m[1]!) ? m[1]! : null;
+}
+
+/** `bench/<id>/<arm>`(arm ≠ base) 면 {id, arm}, 아니면 null. */
+export function parseBenchArmBranch(ref: string | undefined | null): { id: string; arm: string } | null {
+  if (!ref) return null;
+  const m = /^bench\/([^/]+)\/([^/]+)$/.exec(stripRef(ref));
+  if (!m || m[2] === 'base' || !BENCH_ID.test(m[1]!)) return null;
+  return { id: m[1]!, arm: m[2]! };
+}
+
+/** 팔 이름 — 자식 모델의 마지막 토막(`openrouter/z-ai/glm-5.3-flash` → `glm-5.3-flash`) ⊕ 런 접미 6자.
+ *  ⭐ 접미가 있어야 같은 모델 n 팔(sonnet1~3)이 같은 가지로 겹쳐 서로의 PR 을 덮지 않는다. */
+export function benchArmName(childModel: string | undefined, runId: string | undefined): string {
+  const last = childModel?.trim().split('/').filter(Boolean).at(-1) ?? '';
+  const slug = last.toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^[-.]+|[-.]+$/g, '').slice(0, 40) || 'default';
+  const suffix = (runId ?? '').toLowerCase().replace(/^run-/, '').replace(/[^a-z0-9]/g, '').slice(0, 6);
+  return suffix ? `${slug}-${suffix}` : slug;
+}
+
+/** 벤치 base 위의 런이면 팔 가지 이름, 아니면 undefined(동작 불변). */
+export function benchArmBranchForBase(base: string | undefined, childModel: string | undefined, runId: string | undefined): string | undefined {
+  const id = benchIdFromBase(base);
+  return id ? `bench/${id}/${benchArmName(childModel, runId)}` : undefined;
+}
+
+export type BenchGitRun = (args: readonly string[]) => { status: number | null; stdout: string; stderr: string };
+
+export function defaultBenchGitRun(cwd: string): BenchGitRun {
+  return (args) => {
+    const r = spawnSync('git', [...args], { cwd, encoding: 'utf8', timeout: 120_000 });
+    return { status: r.status, stdout: String(r.stdout ?? ''), stderr: String(r.stderr ?? '') };
+  };
+}
+
+export interface BenchBase { readonly id: string; readonly branch: string; readonly sha: string; readonly created: boolean }
+
+/**
+ * 기준선 가지를 고정한다 — 없으면 만들고, 있으면 sha 일치를 확인한다(불일치 = 거부).
+ * sha 생략: 가지가 «없으면» 발사 시점 origin/main 으로 만들고, «있으면» 그 가지의 sha 를 그대로 쓴다
+ * (첫 팔이 정한 기준선을 뒤 팔이 따라간다 — main 이 그 사이 움직여도 팔끼리 같은 땅).
+ */
+export function ensureBenchBase(spec: BenchSpec, run: BenchGitRun): BenchBase {
+  const branch = benchBaseBranch(spec.id);
+  const must = (args: readonly string[], what: string) => {
+    const r = run(args);
+    if (r.status !== 0) throw new Error(`bench: ${what} 실패 (git ${args.join(' ')} rc=${r.status ?? 'signal'}): ${r.stderr.trim().split('\n')[0] ?? ''}`);
+    return r.stdout.trim();
+  };
+  const trackingFetch = ['fetch', '--no-tags', 'origin', `+refs/heads/${branch}:refs/remotes/origin/${branch}`] as const;
+  const remote = run(['ls-remote', '--exit-code', 'origin', `refs/heads/${branch}`]);
+  if (remote.status !== 0 && remote.status !== 2) {
+    throw new Error(`bench: origin 의 ${branch} 를 못 읽었다 (rc=${remote.status ?? 'signal'}) — 「없다」로 읽지 않는다: ${remote.stderr.trim().split('\n')[0] ?? ''}`);
+  }
+  const existing = remote.status === 0 ? remote.stdout.trim().split(/\s+/)[0]?.toLowerCase() : undefined;
+  if (existing) {
+    if (spec.sha && !existing.startsWith(spec.sha)) {
+      throw new Error(`bench: ${branch} 가 이미 ${existing.slice(0, 12)} 에 있다 — 요청 ${spec.sha.slice(0, 12)} 와 다르다(거부 · 다른 기준선이면 새 bench id 를 써라)`);
+    }
+    must(trackingFetch, `${branch} fetch`);
+    return { id: spec.id, branch, sha: existing, created: false };
+  }
+  must(['fetch', '--no-tags', 'origin', 'main'], 'origin main fetch');
+  const sha = must(['rev-parse', '--verify', `${spec.sha ?? 'origin/main'}^{commit}`], 'base sha 해석').toLowerCase();
+  must(['push', 'origin', `${sha}:refs/heads/${branch}`], `${branch} push`);
+  // push 는 원격 추적 ref 를 안 만든다 — 로컬 기질의 worktree 가 `origin/<branch>` 를 찾도록 한 번 당긴다.
+  must(trackingFetch, `${branch} fetch`);
+  return { id: spec.id, branch, sha, created: true };
+}
+
+export interface BenchLedgerRow {
+  readonly ts: string;
+  readonly event: 'launched' | 'finished';
+  readonly benchId: string;
+  readonly baseBranch: string;
+  readonly baseSha: string;
+  /** 부모(발사 프로세스)가 도는 코드 커밋 — base sha 와 따로 적는다(base 는 작업 가지 출발점에만 쓰인다). */
+  readonly parentCodeCommit?: string | null;
+  /** `harness.imageCommit` (Pod 이미지 pin) — 없으면 null(«못 읽음»과 «없음»을 같은 값으로: 원장엔 설정값만 싣는다). */
+  readonly imageCommit: string | null;
+  readonly childLlmProvider: string | null;
+  readonly childLlmModel: string | null;
+  /** 같은 bench id ⊕ 같은 자식 모델의 몇 번째 발사인가(1부터). */
+  readonly round: number;
+  readonly entrance?: string;
+  readonly substrate?: string;
+  readonly seat?: string;
+  readonly exitCode?: number;
+}
+
+export function benchLedgerPath(id: string, configDir: string): string {
+  return join(configDir, 'bench', `${id}.jsonl`);
+}
+
+export function readBenchLedger(id: string, configDir: string): BenchLedgerRow[] {
+  const path = benchLedgerPath(id, configDir);
+  if (!existsSync(path)) return [];
+  const rows: BenchLedgerRow[] = [];
+  for (const line of readFileSync(path, 'utf8').split('\n')) {
+    if (!line.trim()) continue;
+    try { rows.push(JSON.parse(line) as BenchLedgerRow); } catch { /* 깨진 줄은 건너뛴다 — 수는 renderBenchLs 가 따로 안 센다 */ }
+  }
+  return rows;
+}
+
+export function nextBenchRound(rows: readonly BenchLedgerRow[], childLlmModel: string | null): number {
+  return rows.filter((row) => row.event === 'launched' && (row.childLlmModel ?? null) === childLlmModel).length + 1;
+}
+
+export function appendBenchLedger(row: BenchLedgerRow, configDir: string): void {
+  const path = benchLedgerPath(row.benchId, configDir);
+  mkdirSync(join(configDir, 'bench'), { recursive: true, mode: 0o700 });
+  appendFileSync(path, `${JSON.stringify(row)}\n`, { mode: 0o600 });
+}
+
+export function renderBenchLs(id: string, rows: readonly BenchLedgerRow[]): string {
+  if (rows.length === 0) return `bench ${id}: 원장 줄 0 (기록 없음)`;
+  const lines = [`bench ${id}: ${rows.length}줄`];
+  for (const row of rows) {
+    lines.push([
+      row.ts, row.event, `round=${row.round}`, `base=${row.baseSha.slice(0, 12)}`,
+      `parent=${row.parentCodeCommit ? row.parentCodeCommit.slice(0, 12) : 'unknown'}`,
+      `image=${row.imageCommit ? row.imageCommit.slice(0, 12) : 'none'}`,
+      `child=${row.childLlmProvider ?? '-'}/${row.childLlmModel ?? '-'}`,
+      ...(row.substrate ? [`substrate=${row.substrate}`] : []),
+      ...(row.exitCode !== undefined ? [`rc=${row.exitCode}`] : []),
+    ].join(' '));
+  }
+  return lines.join('\n');
+}

package/src/budget/cost-tier-advisor.ts

@@ -0,0 +1,91 @@
+// Cost-tier advisor — when forecast says warn/throttle, suggest one step down
+// (premium → balanced → economy). Tier table values are estimates until
+// MODEL-BENCH replaces them.
+
+import { debug } from '../debug/log.js';
+import type { ForecastResult } from './forecaster.js';
+
+export type CostTier = 'premium' | 'balanced' | 'economy';
+
+export const COST_TIERS: Record<CostTier, {
+  label: string;
+  stages: { authoring: string; implement: string; review: string; judge: string };
+  usdPerTaskEstimate: number;
+  qualityRisk: string;
+  source: 'estimate';
+}> = {
+  premium: {
+    label: '프리미엄',
+    stages: {
+      authoring: 'claude-opus-4-7',
+      implement: 'gpt-6-astra',
+      review: 'claude-opus-4-7',
+      judge: 'grok-4.7',
+    },
+    usdPerTaskEstimate: 1.2,
+    qualityRisk: '낮음 — 최고 품질 유지',
+    source: 'estimate',
+  },
+  balanced: {
+    label: '균형',
+    stages: {
+      authoring: 'claude-sonnet-4-6',
+      implement: 'gpt-5.6-terra',
+      review: 'claude-sonnet-4-6',
+      judge: 'grok-4.6',
+    },
+    usdPerTaskEstimate: 0.45,
+    qualityRisk: '중간 — 대부분 작업에 충분',
+    source: 'estimate',
+  },
+  economy: {
+    label: '절약',
+    stages: {
+      authoring: 'claude-haiku-4-5',
+      implement: 'gpt-6-luna',
+      review: 'gemini-2.5-flash',
+      judge: 'gemini-3.5-flash-lite',
+    },
+    usdPerTaskEstimate: 0.12,
+    qualityRisk: '높음 — 단순·반복 작업에 적합',
+    source: 'estimate',
+  },
+};
+
+const DOWN_ONE: Record<CostTier, CostTier | null> = {
+  premium: 'balanced',
+  balanced: 'economy',
+  economy: null,
+};
+
+export function adviseCostTier(input: {
+  current: CostTier;
+  forecast: Pick<ForecastResult, 'recommendation' | 'usedPercent' | 'atCurrentPaceReachesLimitAt'>;
+}): {
+  from: CostTier;
+  to: CostTier;
+  savingPercent: number;
+  qualityRisk: string;
+  reason: string;
+} | null {
+  const { current, forecast } = input;
+  if (forecast.recommendation === 'safe') return null;
+
+  const to = DOWN_ONE[current];
+  if (!to) return null;
+
+  const fromTier = COST_TIERS[current];
+  const toTier = COST_TIERS[to];
+  const savingPercent = Math.round((1 - toTier.usdPerTaskEstimate / fromTier.usdPerTaskEstimate) * 100);
+  const reason = `예산 사용 ${forecast.usedPercent}% · 예측 ${forecast.recommendation} → ${toTier.label}로 내리면 약 ${savingPercent}% 절감`;
+
+  debug.log('budget.cost-tier', 'advised', { from: current, to, savingPercent });
+
+  return {
+    from: current,
+    to,
+    savingPercent,
+    qualityRisk: toTier.qualityRisk,
+    reason,
+  };
+}

package/src/budget/fetchers/grok.ts

@@ -1,12 +1,12 @@
 // Grok budget fetcher adapter.
 //
 // Reuses `fetchGrokUsage` (src/grok/usage.ts). Existing subscription token
-// only. Does not infer a subscription-pool remaining/reset and does not
-// scrape a web page. Credit figures stay on the credits axis — they are
-// never written into RateWindow.remainingPercent.
+// only. Maps an explicitly returned weekly period + creditUsagePercent into
+// the provider's weekly quota window; credit balances remain on the credits axis.
 
 import {
   fetchGrokUsage,
+  grokUsageToSubscriptionAxis,
   grokUsageToCreditAxis,
   type GrokUsage,
 } from '../../grok/usage.js';
@@ -36,10 +36,20 @@ export function createGrokFetcher(opts: GrokFetcherOpts = {}): ProviderFetcher {
 
 export function grokUsageToSnapshot(usage: GrokUsage, fetchedAt: number = Date.now()): UsageSnapshot {
   const credits = creditsFromGrokUsage(usage);
+  const subscription = grokUsageToSubscriptionAxis(usage);
+  const windows = subscription.status === 'available'
+    ? [{
+        kind: 'weekly' as const,
+        windowMinutes: 10_080,
+        limit: 100,
+        used: 100 - subscription.remainingPercent,
+        remainingPercent: subscription.remainingPercent,
+        resetsAt: subscription.resetsAt,
+      }]
+    : [];
   return {
     provider: 'grok' as UsageProvider,
-    // ⛔ 크레딧 사용률을 구독 창 잔량처럼 보이게 하는 RateWindow 를 만들지 않는다.
-    windows: [],
+    windows,
     ...(credits ? { credits } : {}),
     fetchedAt,
     source: 'oauth-api',

package/src/budget/llm-cost.ts

@@ -11,6 +11,7 @@ import { findGrokModel } from '../grok/models.js';
 import { getUserConfig } from '../user-config.js';
 import { BUILTIN_CATALOG } from '../intelligence-map/model-catalog.js';
 import { getCatalog } from '../registry/loader.js';
+import { byokCostFor, type ByokActualCost, type ByokPartialCost } from '../llm/openrouter-byok-cost.js';
 
 export interface LlmPricingUsd {
   inputPerM: number;
@@ -23,6 +24,13 @@ export interface LlmPricingUsd {
   longContext?: { thresholdTokens: number; inputPerM: number; outputPerM: number; cacheReadPerM?: number; cacheWritePerM?: number };
 }
 
+/** AWS Bedrock Global Standard prices, USD per million tokens (AWS pricing API, ap-northeast-2). */
+export const BEDROCK_PRICING_USD: Readonly<Record<string, LlmPricingUsd>> = {
+  'claude-haiku-5-5': { inputPerM: 0.1, outputPerM: 0.5, cacheWritePerM: 0.125, cacheReadPerM: 0.01 },
+  'claude-sonnet-5-5': { inputPerM: 2, outputPerM: 10, cacheWritePerM: 2.5, cacheReadPerM: 0.1 },
+  'claude-opus-5-5': { inputPerM: 4, outputPerM: 20, cacheWritePerM: 5, cacheReadPerM: 0.2 },
+};
+
 export interface LlmCostUsage {
   model: string;
   inputTokens?: number;
@@ -46,7 +54,7 @@ export type LlmCostEstimate =
       kind: 'known';
       model: string;
       usd: number;
-      source: 'catalog' | 'config' | 'registry';
+      source: 'catalog' | 'bedrock-catalog' | 'config' | 'registry';
       cacheReadPricedAt: 'cache-read' | 'input-rate';
       cacheWritePricedAt: 'cache-write' | 'input-rate';
       /** 장문맥 단가로 매겼으면 `'long-context'` — 없으면 기본 단가. */
@@ -56,7 +64,7 @@ export type LlmCostEstimate =
       kind: 'partial';
       model: string;
       usd: number;
-      source: 'catalog' | 'config' | 'registry';
+      source: 'catalog' | 'bedrock-catalog' | 'config' | 'registry';
       cacheReadPricedAt: 'cache-read' | 'input-rate';
       cacheWritePricedAt: 'cache-write' | 'input-rate';
       pricedTier?: 'long-context';
@@ -147,6 +155,21 @@ export function normalizePricingModelId(model: string): string {
   return m;
 }
 
+/** Normalize a Bedrock Anthropic model id to its bare Claude pricing id. */
+export function bedrockPricingModelId(model: string): string {
+  return model.trim()
+    .replace(/^bedrock\//, '')
+    .replace(/^[a-z0-9-]+\.anthropic\./i, '')
+    .replace(/^anthropic\./, '')
+    .replace(/-v1:0$/, '');
+}
+
+function isBedrockPricingModel(model: string): boolean {
+  const trimmed = model.trim();
+  return /^(?:bedrock\/|[a-z0-9-]+\.anthropic\.|anthropic\.)/i.test(trimmed)
+    && bedrockPricingModelId(trimmed).startsWith('claude-');
+}
+
 /** 저장소의 모델 정본(intelligence-map BUILTIN_CATALOG) — 손 카탈로그 넷에 없는 모델(Claude 5 계열 등)의 입력·출력 단가.
  *  캐시 단가는 거기 없다 → Anthropic 모델은 공식 규칙(읽기 0.1× · 쓰기 5분 1.25×)으로 파생한다. 다른 벤더는 입력 단가로 매기고
  *  `cacheReadPricedAt: 'input-rate'` 로 그 사실을 드러낸다(추측하지 않는다). */
@@ -174,8 +197,8 @@ function registryPricing(model: string): LlmPricingUsd | undefined {
 function resolvePricing(
   model: string,
   opts?: EstimateLlmCostOptions,
-): { pricing: LlmPricingUsd; source: 'catalog' | 'config' | 'registry' } | undefined {
-  // ⭐ 순서: 손 카탈로그(정확) → 정규화 id → config 오버레이 → 저장소 정본 → 레지스트리. 앞이 이긴다.
+): { pricing: LlmPricingUsd; source: 'catalog' | 'bedrock-catalog' | 'config' | 'registry' } | undefined {
+  // ⭐ 순서: 손 카탈로그(정확) → 정규화 id → config 오버레이 → Bedrock 표 → 저장소 정본 → 레지스트리. 앞이 이긴다.
   const normalized = normalizePricingModelId(model);
   for (const id of normalized === model ? [model] : [model, normalized]) {
     const catalog = catalogPricing(id);
@@ -185,6 +208,10 @@ function resolvePricing(
     const overlay = opts?.configPricing?.[id];
     if (validPricing(overlay)) return { pricing: overlay, source: 'config' };
   }
+  if (isBedrockPricingModel(model)) {
+    const bedrock = BEDROCK_PRICING_USD[bedrockPricingModelId(model)];
+    if (validPricing(bedrock)) return { pricing: bedrock, source: 'bedrock-catalog' };
+  }
   const builtin = builtinCatalogPricing(normalized);
   if (validPricing(builtin)) return { pricing: builtin, source: 'catalog' };
   const registry = registryPricing(model);
@@ -297,11 +324,16 @@ export function llmUsageCostFields(
   usage: Omit<LlmCostUsage, 'model'>,
   opts?: EstimateLlmCostOptions,
   billing?: BillingRoute,
-): { cost: LlmCostEstimate | IncludedLlmCost | ActualLlmCost } {
+): { cost: LlmCostEstimate | IncludedLlmCost | ActualLlmCost | ByokActualCost | ByokPartialCost } {
   const resolved = opts ?? { configPricing: readLlmConfigPricing() };
   const estimate = estimateLlmCost({ model, ...usage }, resolved);
   // ⛔⭐ 구독을 API 단가로 «known» 이라 적지 않는다 — 09-25 벤치에서 codex 구독 팔이 `$7.81 known` 으로 보였다.
   // ⭐ BACKLOG C7 — provider 가 실어 보낸 «실제 청구액»이 있으면 그것이 비용이다(추정은 곁에 남긴다).
+  // OR-BYOK-COST — BYOK 면 «OR 청구 + 상류 청구»가 비용이다(상류를 모르면 partial · 0 으로 가정하지 않는다).
+  if (billing !== 'subscription' && billing !== 'local') {
+    const byok = byokCostFor(model, usage as Parameters<typeof byokCostFor>[1], estimate.kind === 'known' || estimate.kind === 'partial' ? estimate.usd : undefined);
+    if (byok) return { cost: byok };
+  }
   const reported = (usage as { reportedCostUsd?: unknown }).reportedCostUsd;
   if (typeof reported === 'number' && Number.isFinite(reported) && billing !== 'subscription' && billing !== 'local') {
     return { cost: { kind: 'actual', model, usd: reported, source: 'provider-reported', ...(estimate.kind === 'known' || estimate.kind === 'partial' ? { estimateUsd: estimate.usd } : {}) } };

package/src/budget/shadow-arms.ts

@@ -0,0 +1,77 @@
+// Shadow-arm launch plan — estimate which candidate models fit today's
+// shadow budget. Plans only: no live LLM calls.
+
+import { debug } from '../debug/log.js';
+import { estimateLlmCost } from './llm-cost.js';
+
+export type ShadowStage = 'authoring' | 'implement' | 'review' | 'judge';
+
+export type ShadowDifficulty = 'small' | 'medium' | 'umbrella' | 'rework';
+
+export interface PlanShadowArmsInput {
+  stage: ShadowStage;
+  difficulty: ShadowDifficulty;
+  inputTokens: number;
+  expectedOutputTokens: number;
+  candidates: string[];
+  spentTodayUsd: number;
+  dailyCapUsd: number;
+}
+
+export interface ShadowArmFire {
+  model: string;
+  estUsd: number;
+}
+
+export interface ShadowArmSkipped {
+  model: string;
+  reason: 'over-daily-cap' | 'unknown-price';
+}
+
+export interface ShadowArmsPlan {
+  fire: ShadowArmFire[];
+  skipped: ShadowArmSkipped[];
+  remainingUsd: number;
+}
+
+export function planShadowArms(input: PlanShadowArmsInput): ShadowArmsPlan {
+  const fire: ShadowArmFire[] = [];
+  const skipped: ShadowArmSkipped[] = [];
+  let remainingUsd = input.dailyCapUsd - input.spentTodayUsd;
+  let overDailyCap = false;
+
+  for (const model of input.candidates) {
+    // Once the cap is crossed, every later arm is over-daily-cap — even one
+    // whose price is unknown (the cap decision comes first).
+    if (overDailyCap) {
+      skipped.push({ model, reason: 'over-daily-cap' });
+      continue;
+    }
+    const estimate = estimateLlmCost({
+      model,
+      inputTokens: input.inputTokens,
+      outputTokens: input.expectedOutputTokens,
+    });
+    if (estimate.kind !== 'known') {
+      skipped.push({ model, reason: 'unknown-price' });
+      continue;
+    }
+    if (estimate.usd > remainingUsd) {
+      skipped.push({ model, reason: 'over-daily-cap' });
+      overDailyCap = true;
+      continue;
+    }
+    fire.push({ model, estUsd: estimate.usd });
+    remainingUsd -= estimate.usd;
+  }
+
+  debug.log('budget.shadow-arms', 'planned', {
+    stage: input.stage,
+    difficulty: input.difficulty,
+    fire: fire.length,
+    skipped: skipped.length,
+    remainingUsd,
+  });
+
+  return { fire, skipped, remainingUsd };
+}

package/src/budget/types.ts

@@ -158,18 +158,26 @@ export type ResetCreditExpiryAxis =
   | { readonly status: 'expired'; readonly expiresAt: string; readonly hasUnknownExpiry: boolean };
 
 export interface AccountUsageRow {
-  readonly provider: 'codex' | 'grok' | 'openrouter';
+  /** `zai` = GLM Coding Plan(ZAI-CODING-PLAN-PROVIDER) — `ZAI_API_KEY` 가 있을 때만 행이 생긴다.
+   *  `claude` = Claude Code 구독(CLAUDE-USAGE-WINDOW) — OAuth 토큰이 있을 때만 행이 생긴다. */
+  readonly provider: 'codex' | 'claude' | 'grok' | 'openrouter' | 'zai';
   readonly accountName: string;
   readonly accountCount: number;
   readonly soleAccount: boolean;
   readonly credits: CreditAxis;
   readonly subscription: SubscriptionAxis;
   readonly resetCredits: ResetCreditExpiryAxis;
+  /** 행 끝에 붙는 한 줄(출처·실수치) — 없으면 종전 문면과 바이트 동일. */
+  readonly note?: string;
 }
 
 export interface UnifiedUsageReport {
   readonly rows: readonly AccountUsageRow[];
-  readonly accountCounts: Readonly<Record<'codex' | 'grok' | 'openrouter', number>>;
+  /** `zai` 는 키가 있을 때만 실린다(없으면 종전 JSON 과 같다). */
+  /** `claude` 도 토큰이 있을 때만 실린다(없으면 종전 JSON 과 같다). */
+  readonly accountCounts: Readonly<Record<'codex' | 'grok' | 'openrouter', number>> & { readonly claude?: number; readonly zai?: number };
+  /** GLM Coding Plan 상세(창 · 우리 적산 · 잔액 사용 · 마지막 한도 코드) — 키가 있을 때만. */
+  readonly zaiCodingPlan?: import('../llm/zai-coding-plan.js').ZaiUsageView;
 }
 
 export interface TurnSummary {