elanous 0.2.21 → 0.2.23

package/src/self-dev/dev-cli.ts

@@ -30,7 +30,8 @@ import type { ReasoningEffortCeiling } from '../intelligence-map/model-catalog.j
 import { tierModel } from '../llm/model-defaults.js';
 import { LLM_TIER_MAP_BY_PROVIDER } from '../model-tier/llm-tier-map.js';
 import { MODEL_TIERS } from '../model-tier/types.js';
-import { getCatalog } from '../registry/loader.js';
+import { getCatalog, isolatedCatalogTestUniverse } from '../registry/loader.js';
+import { isLiveVerifiedOpenRouterModel, liveLookupOpenRouterModel, OPENROUTER_SNAPSHOT_STALE_DAYS, readFoldSnapshotAgeDays, upstreamOpenRouterId } from '../registry/discovery/openrouter-live-resolve.js';
 import { singleRunAsJobResult } from '../self-implement/self-implement-cli.js';
 import { superviseRun, type SupervisorDecision, type SupervisorStopReason } from './run-supervisor.js';
 import { readDecomposeProposals, orderPiecesTopologically } from './decompose-proposal.js';
@@ -45,6 +46,7 @@ import { getUserConfig, type UserConfig } from '../user-config.js';
 import { resolveChildLlmPreference, type ChildLlmPreferenceInput, type ResolvedChildLlmPreference } from '../self-implement/child-llm-preference.js';
 import { applyLaunchOverloadFailover, codexProviderNamed } from '../oauth/overload-failover-launch.js';
 import { readCachedGrokQuota } from '../oauth/codex-account-store.js';
+import { appendRunLedgerEntry } from '../self-implement/run-ledger.js';
 import { queryAbandonedDraftPrs, type AbandonedDraftPr } from '../cli/logs-abandoned-draft-prs.js';
 import { branchLineageSlug } from '../cli/pr-lineage.js';
 import { decideDraft, type DraftTriagePr } from './draft-triage-rules.js';
@@ -62,6 +64,7 @@ import { findGeminiModel, GEMINI_MODELS } from '../gemini/models.js';
 import { findGrokModel, GROK_MODELS } from '../grok/models.js';
 import { resolveModelAlias } from '../intelligence-map/model-alias.js';
 import { BUILTIN_CATALOG } from '../intelligence-map/model-catalog.js';
+import { BEDROCK_DEFAULT_MODEL, BEDROCK_MODELS, findBedrockModel, resolveBedrockModelId } from '../llm/bedrock.js';
 
 /** `dev --plan` 도움말이 가리키는 대응 문. ⛔ 도움말에 이 문자열을 리터럴로 다시 적지 마라. */
 export const DEV_PLAN_REPLACEMENT = 'elanous harness say';
@@ -1338,7 +1341,7 @@ export function normalizeChildLlmProvider(provider: string): string {
 }
 
 function isKnownChildLlmProvider(provider: string): boolean {
-  return ['grok', 'anthropic', 'gemini', 'openai', 'openai-codex', 'local', 'openrouter'].includes(normalizeChildLlmProvider(provider));
+  return ['grok', 'anthropic', 'gemini', 'openai', 'openai-codex', 'local', 'openrouter', 'bedrock'].includes(normalizeChildLlmProvider(provider));
 }
 
 function findPickerCatalogModel(provider: string, id: string): CatalogModelView | undefined {
@@ -1349,16 +1352,27 @@ function findPickerCatalogModel(provider: string, id: string): CatalogModelView
     case 'openai':
     case 'openai-codex': return findCodexModel(id);
     case 'openrouter': return findOpenRouterChildModel(id);
+    case 'bedrock': return findBedrockChildModel(id);
     default: return undefined;
   }
 }
 
+/** BEDROCK-PROVIDER — `anthropic.claude-sonnet-5-5` · `bedrock/claude-sonnet-5-5` · (provider=bedrock 일 때) `claude-sonnet-5-5`
+ *  를 받아 와이어 id(`anthropic.` 접두)로 해석한다. 표 밖은 «모른다» → 거부(다른 provider 와 같은 규율). */
+function findBedrockChildModel(id: string): CatalogModelView | undefined {
+  const entry = findBedrockModel(id);
+  if (!entry) return undefined;
+  // 지역 접두(`us.anthropic.…`)를 줬으면 그 와이어 id 를 그대로 쓴다(데이터 거주 선택 보존).
+  return { id: resolveBedrockModelId(id), tier: entry.tier, supportsThinking: entry.supportsThinking, recommended: entry.id === BEDROCK_DEFAULT_MODEL };
+}
+
 /** 결정 2026-09-23 — openrouter 는 피커 목록이 없다(454개 게이트웨이). 받는 것 = ⑴ openrouter 사다리의 모델
  *  ⊕ ⑵ 카탈로그 폴드에 있는 `openrouter/*`(운영 스냅숏이 갱신됐을 때). 둘 다 아니면 «모른다» → 거부. */
 function findOpenRouterChildModel(id: string): CatalogModelView | undefined {
   const ladder = MODEL_TIERS.map((t) => LLM_TIER_MAP_BY_PROVIDER.openrouter[t].model);
   const folded = getCatalog().models.get(id);
-  if (!ladder.includes(id) && folded?.provider !== 'openrouter') return undefined;
+  if (!ladder.includes(id) && folded?.provider !== 'openrouter' && !isLiveVerifiedOpenRouterModel(id)
+    && !(isolatedCatalogTestUniverse() && !process.env.ELANOUS_CATALOG_DISCOVERY_SNAPSHOT?.trim() && /^openrouter\/[^/\s]+\/[^/\s]+$/.test(id))) return undefined;
   return {
     id,
     tier: id === LLM_TIER_MAP_BY_PROVIDER.openrouter.balanced.model ? 'balanced' : 'standard',
@@ -1403,6 +1417,7 @@ function listImplementationChildModelCandidates(provider: string): string[] {
       case 'openai':
       case 'openai-codex': return CODEX_MODELS.map((model) => model.id);
       case 'openrouter': return [...new Set(MODEL_TIERS.map((t) => LLM_TIER_MAP_BY_PROVIDER.openrouter[t].model))];
+      case 'bedrock': return BEDROCK_MODELS.map((model) => model.id);
       default: return [];
     }
   })();
@@ -1443,6 +1458,56 @@ export function resolveImplementationChildModel(provider: string, model: string)
   };
 }
 
+let staleOpenRouterSnapshotWarned = false;
+
+/** OR-MODEL-NAMESPACE — 발사 «전» 비동기 관문. 동기 해석(`resolveImplementationChildModel`)이 스냅숏 밖의
+ *  `openrouter/<vendor>/<model>` 을 거부할 때만 공개 `/models` 를 한 번 묻는다.
+ *  ⛔ openrouter 가 아닌 provider · 스냅숏에 이미 있는 id 는 네트워크 0 · 해석 결과 불변.
+ *  ⛔ 확인 못 함(네트워크·시간 초과·봉투 오류)은 거부(fail-closed) ⊕ 사유 «카탈로그 확인 못 함». */
+export async function ensureOpenRouterChildModelLive(
+  provider: string | undefined,
+  model: string | undefined,
+  deps: { fetchImpl?: typeof fetch; timeoutMs?: number; write?: (line: string) => void; now?: () => number; persist?: boolean } = {},
+): Promise<void> {
+  if (!provider?.trim() || !model?.trim()) return;
+  if (normalizeChildLlmProvider(provider) !== 'openrouter') return;
+  const write = deps.write ?? ((line: string) => process.stderr.write(line));
+  const ageDays = readFoldSnapshotAgeDays((deps.now ?? Date.now)());
+  if (ageDays !== undefined && ageDays > OPENROUTER_SNAPSHOT_STALE_DAYS && !staleOpenRouterSnapshotWarned) {
+    staleOpenRouterSnapshotWarned = true;
+    write(`[dev] ⚠️ OpenRouter 모델 스냅숏이 ${ageDays}일 묵었다(discovery-snapshot.json) — 없는 모델은 공개 카탈로그로 한 번 확인한다\n`);
+  }
+  try {
+    resolveImplementationChildModel(provider, model);
+    return;
+  } catch (err) {
+    const entered = model.trim();
+    const aliased = resolveModelAlias(entered) ?? entered;
+    if (!upstreamOpenRouterId(aliased)) throw err;
+    const lookup = await liveLookupOpenRouterModel(aliased, {
+      ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}),
+      ...(deps.timeoutMs !== undefined ? { timeoutMs: deps.timeoutMs } : {}),
+      ...(deps.now ? { now: deps.now } : {}),
+      ...(deps.persist !== undefined ? { persist: deps.persist } : {}),
+    });
+    if (lookup.found) {
+      if (!lookup.persisted && deps.persist !== false) {
+        write(`[dev] ⚠️ ${aliased} 은 OpenRouter 에서 확인했지만 스냅숏에 못 합쳤다 — 이 프로세스에서만 통과(자식·Pod 재해석은 거부될 수 있다)\n`);
+      }
+      resolveImplementationChildModel(provider, model);
+      return;
+    }
+    if (lookup.error) {
+      throw new DevPipelineError(`${err instanceof Error ? err.message : String(err)} · 카탈로그 확인 못 함(${lookup.error})`);
+    }
+    throw err;
+  }
+}
+
+export function __resetStaleOpenRouterSnapshotWarningForTests(): void {
+  staleOpenRouterSnapshotWarned = false;
+}
+
 export const CHILD_LLM_EFFORT_LADDER = ['minimal', 'low', 'medium', 'high', 'xhigh', 'max'] as const;
 
 export function childLlmEffortCeiling(_provider: string, model: string): ReasoningEffortCeiling {
@@ -1494,6 +1559,20 @@ export function formatChildLlmInterpretationLine(
   return `[dev] child-llm: entered=${resolution.entered} · resolved=${resolution.resolvedId} · tier=${resolution.tier} · thinking=${resolution.supportsThinking}${tail}`;
 }
 
+/** Only the weekly Grok credits period measures the weekly cap; missing or malformed periods are unmeasured. */
+export function grokWeeklyUsedPctFromUsageJson(stdout: string): number | undefined {
+  try {
+    const parsed = JSON.parse(stdout) as { rows?: Array<{ provider?: string; credits?: { status?: string; periodType?: string | null; usedPercent?: unknown } }> };
+    if (!Array.isArray(parsed.rows)) return undefined;
+    const percents = parsed.rows
+      .filter((row) => row?.provider === 'grok' && row.credits?.status === 'ok'
+        && row.credits.periodType === 'USAGE_PERIOD_TYPE_WEEKLY')
+      .map((row) => row.credits?.usedPercent)
+      .filter((pct): pct is number => typeof pct === 'number' && Number.isFinite(pct) && pct >= 0 && pct <= 100);
+    return percents.length > 0 ? Math.max(...percents) : undefined;
+  } catch { return undefined; }
+}
+
 /** `elanous usage --json` 의 grok 행 → 잔량 판정. 한 행이라도 100% 미만이면 usable, 모두 100% 이상이면 exhausted. */
 export function grokQuotaFromUsageJson(stdout: string): 'usable' | 'exhausted' | 'unknown' {
   try {
@@ -1519,17 +1598,75 @@ export function setLaunchGrokQuotaReaderForTesting(reader: (() => 'usable' | 'ex
   launchGrokQuotaReaderForTesting = reader;
 }
 
+let launchGrokWeeklyReaderForTesting: (() => number | undefined) | undefined;
+export function setLaunchGrokWeeklyReaderForTesting(reader: (() => number | undefined) | undefined): void {
+  launchGrokWeeklyReaderForTesting = reader;
+}
+
+/**
+ * 발사 한 번에 `elanous usage --json`(약 3초) 을 «한 번만» 부른다 — 주간 사용률(재배분)과 잔량(경고)이 같은 출력을 나눈다.
+ * 한 CLI 프로세스 = 한 발사이므로 프로세스 안 60초 캐시로 충분하다(실패 null 도 캐시 — 같은 발사에서 20초 타임아웃을 두 번 물지 않게).
+ */
+let launchUsageJsonCache: { at: number; stdout: string | null } | undefined;
+const LAUNCH_USAGE_CACHE_MS = 60_000;
+export function runLaunchUsageJsonOnce(): string | null {
+  const now = Date.now();
+  if (launchUsageJsonCache && now - launchUsageJsonCache.at < LAUNCH_USAGE_CACHE_MS) return launchUsageJsonCache.stdout;
+  let stdout: string | null = null;
+  try {
+    const cli = new URL('../../bin/elanous.mjs', import.meta.url).pathname;
+    const r = spawnSync(process.execPath, [cli, ...(IN_TEST_PROCESS() || process.env.ELANOUS_TEST_MODE === '1' ? ['--test'] : []), 'usage', '--json'], { encoding: 'utf8', timeout: 20_000 });
+    stdout = r.status === 0 ? r.stdout : null;
+  } catch { stdout = null; }
+  launchUsageJsonCache = { at: now, stdout };
+  return stdout;
+}
+
+/** Launch's weekly percentage comes from the live usage period, not the coarse cached usable flag. */
+export function readGrokWeeklyUsedPctForLaunch(runUsage?: () => string | null): number | undefined {
+  if (launchGrokWeeklyReaderForTesting && !runUsage) return launchGrokWeeklyReaderForTesting();
+  try {
+    const stdout = (runUsage ?? runLaunchUsageJsonOnce)();
+    return stdout ? grokWeeklyUsedPctFromUsageJson(stdout) : undefined;
+  } catch { return undefined; }
+}
+
+export function rebalanceGrokChildForLaunch(
+  child: ChildLlmSelection,
+  cap: number,
+  used: number | undefined,
+  runId?: string,
+  deps: { write?: (line: string) => void; record?: typeof appendRunLedgerEntry } = {},
+): ChildLlmSelection {
+  if (child.provider !== 'grok') return child;
+  const measured = typeof used === 'number' && Number.isFinite(used) && used >= 0 && used <= 100;
+  const rebalanced = measured && used >= cap;
+  const selected = rebalanced
+    ? { ...child, provider: 'openai-codex', model: defaultChildLlmModel('openai-codex'), codexQuotaPolicy: 'credits' as const }
+    : child;
+  const reason = !measured ? '측정 불가' : rebalanced ? `grok 주간 사용률 ${used}% ≥ 상한 ${cap}%` : `grok 주간 사용률 ${used}% < 상한 ${cap}%`;
+  if (rebalanced || !measured) (deps.write ?? ((line) => process.stderr.write(line)))(
+    `[dev] child-llm ${child.provider} → ${selected.provider} · ${reason}\n`,
+  );
+  if (rebalanced || !measured) {
+    const data = { requestedProvider: child.provider, selectedProvider: selected.provider,
+      weeklyUsedPct: measured ? used : null, capPct: cap, reason, selection: child.source };
+    // 실제 전환과 «측정 못 해 그대로 둠» 을 다른 이벤트로 — 관측에서 둘을 섞지 않는다.
+    const event = rebalanced ? 'launch-provider-rebalanced' : 'launch-provider-weekly-unmeasured';
+    debug.log('self-implement', event, { runId: runId ?? null, ...data });
+    if (runId) (deps.record ?? appendRunLedgerEntry)({ timestamp: new Date().toISOString(), runId,
+      event, data: { runId, ...data } });
+  }
+  return selected;
+}
+
 export function readGrokQuotaForLaunch(
   deps: { readCached?: typeof readCachedGrokQuota; runUsage?: () => string | null } = {},
 ): 'usable' | 'exhausted' | 'unknown' {
   if (launchGrokQuotaReaderForTesting && !deps.readCached && !deps.runUsage) return launchGrokQuotaReaderForTesting();
   const cached = (deps.readCached ?? readCachedGrokQuota)();
   if (cached !== 'unknown') return cached;
-  const runUsage = deps.runUsage ?? (() => {
-    const cli = new URL('../../bin/elanous.mjs', import.meta.url).pathname;
-    const r = spawnSync(process.execPath, [cli, 'usage', '--json'], { encoding: 'utf8', timeout: 20_000 });
-    return r.status === 0 ? r.stdout : null;
-  });
+  const runUsage = deps.runUsage ?? runLaunchUsageJsonOnce;
   let stdout: string | null = null;
   try { stdout = runUsage(); } catch { stdout = null; }
   return stdout ? grokQuotaFromUsageJson(stdout) : 'unknown';
@@ -1851,6 +1988,7 @@ export function buildDriveAliasDevSpec(
   command: string | undefined,
   opts: DevCliOpts,
   explicitOptionNames?: readonly string[],
+  runId?: string,
 ): DevPipelineSpec {
   if (opts.elanous === true) {
     throw new DevPipelineError('drive: --elanous 는 지원하지 않음 — TUI target은 elanous dev --elanous 를 사용');
@@ -1861,7 +1999,7 @@ export function buildDriveAliasDevSpec(
   if (!opts.goal?.trim()) {
     throw new DevPipelineError('drive: --goal 필요');
   }
-  const spec = buildDevCliSpec({ text: command.trim() }, { kind: 'self' }, opts, explicitOptionNames, 'cli-drive');
+  const spec = buildDevCliSpec({ text: command.trim() }, { kind: 'self' }, opts, explicitOptionNames, 'cli-drive', undefined, undefined, runId);
   return { ...spec, completion: 'worktree-only', autoReview: false };
 }
 
@@ -1872,6 +2010,9 @@ export function buildDevCliSpec(
   explicitOptionNames?: readonly string[],
   entrance: EntranceId = 'cli-dev-ask',
   readGrokQuota: typeof readCachedGrokQuota = readGrokQuotaForLaunch,
+  readGrokWeekly: () => number | undefined = readGrokWeeklyUsedPctForLaunch,
+  runId?: string,
+  recordLaunch?: typeof appendRunLedgerEntry,
 ): DevPipelineSpec {
   if (opts.plan === true) {
     throw new DevPipelineError(`--plan 은 은퇴했고 명시적으로 거부됨 · 대응 문: ${DEV_PLAN_REPLACEMENT}`);
@@ -2016,8 +2157,13 @@ export function buildDevCliSpec(
   }
 
   if (path === 'self-mission') {
-    const builtChild = buildChildLlmSelection({ ...opts, readPreference: () => getUserConfig() });
-    const childLlm = applyLaunchOverloadFailover(builtChild, {
+    const requestedChildLlm = buildChildLlmSelection({ ...opts, readPreference: () => getUserConfig() });
+    // 주간 상한 재배분(grok → codex)을 먼저, 과부하 페일오버(codex → grok)를 그 뒤에 — 과부하는 «지금 실패 중»이라 더 강한 신호다.
+    const capped = requestedChildLlm?.provider === 'grok'
+      ? rebalanceGrokChildForLaunch(requestedChildLlm, getUserConfig().llm.grokWeeklyCapPct ?? 80, readGrokWeekly(), runId,
+        recordLaunch ? { record: recordLaunch } : {})
+      : requestedChildLlm;
+    const childLlm = applyLaunchOverloadFailover(capped, {
       provider: opts.childLlmProvider,
       model: opts.childLlmModel,
       codexPinned: childLlmCodexPinned(opts.childLlmProvider),

package/src/self-dev/dev-pipeline.ts

@@ -43,7 +43,8 @@ import { addSelfDevRunParticipant, processBirthId, saveSelfDevRun } from './run-
 import { getUserConfig, resolveRoleLlm } from '../user-config.js';
 import { reviewReasoningEffort } from '../model-tier/review-effort.js';
 import { getProvider, inferProviderFromModel } from '../llm.js';
-import { buildReviewProviderAttempts, defaultReviewFallbackModel, runReviewWithFallback, reviewFallbackModelsFromConfig } from './review-provider-fallback.js';
+import { buildReviewProviderAttempts, defaultReviewFallbackModel, runReviewWithFallback, reviewFallbackModelsFromConfig, runSubscriptionReviewer, type SubscriptionReviewerDeps } from './review-provider-fallback.js';
+import { loadLlmPolicy, resolveSubscriptionReviewer } from '../policy/llm-policy.js';
 import type { DefaultSeamsOptions } from '../self-implement/seams.js';
 import { harnessTargetOptions, resolveHarnessTarget, revalidateHarnessTarget, type HarnessTargetResolution } from '../self-implement/harness-target-options.js';
 import { provisionRepository, type RepoProvisionResult } from '../self-implement/repo-provision.js';
@@ -1077,6 +1078,8 @@ export async function buildDefaultSelfImplementSeams(
     toolReviewerRoll?: () => number;
     /** Tool-reviewer factory (same prompt→text shape as llmReview). Tests stub this; default is ACP. */
     makeToolReviewLLM?: () => UnmannedToolReviewLLM | Promise<UnmannedToolReviewLLM>;
+    subscriptionReviewerDeps?: SubscriptionReviewerDeps;
+    makeSubscriptionReviewLLM?: (spawn: ReturnType<typeof import('./review-provider-fallback.js').subscriptionReviewerSpawn>) => (prompt: string) => Promise<string>;
   } = {},
 ): Promise<SelfImplementSeams> {
   const { defaultSeams } = await import('../self-implement/seams.js');
@@ -1143,6 +1146,19 @@ export async function buildDefaultSelfImplementSeams(
       reviewerCanSelfRead = false;
     }
   }
+  let subscriptionReviewLLM: ((prompt: string) => Promise<string>) | undefined;
+  if (reviewerIsDefaultApiCall) {
+    const reviewer = resolveSubscriptionReviewer(loadLlmPolicy(), getUserConfig().roleLlm);
+    if (reviewer) {
+      const { spec, cap } = reviewer;
+      subscriptionReviewLLM = (prompt) => runSubscriptionReviewer(spec, cap, prompt, defaultApiReview, async (text, spawn) => {
+        if (deps.makeSubscriptionReviewLLM) return deps.makeSubscriptionReviewLLM(spawn)(text);
+        const { makeAcpReviewLLM } = await import('../agent-substrate/acp-reviewer.js');
+        return makeAcpReviewLLM({ cwd: targetOptions?.repoRoot ?? childScope.elanousBinRoot, backend: 'claude', backendSpec: spawn.backendSpec, env: spawn.env })(text);
+      }, process.env, deps.subscriptionReviewerDeps);
+      reviewerCanSelfRead = undefined;
+    }
+  }
   const opensPr = plan.completion !== 'worktree-only';
   const target = plan.target === undefined ? undefined : revalidateHarnessTarget(plan.target);
   if (target?.status === 'outside-home') {
@@ -1159,6 +1175,7 @@ export async function buildDefaultSelfImplementSeams(
     ...(plan.self?.maxWaitSec !== undefined ? { implementMaxWaitSec: plan.self.maxWaitSec } : {}),
     ...(plan.self?.activityGraceSec !== undefined ? { implementActivityGraceSec: plan.self.activityGraceSec } : {}),
     llmReview,
+    ...(subscriptionReviewLLM ? { subscriptionReviewLLM } : {}),
     ...(reviewerCanSelfRead !== undefined ? { reviewerCanSelfRead } : {}),
     ...(deps.reviewScopeDiff ? { reviewScopeDiff: deps.reviewScopeDiff } : {}),
     onProgress: ({ stage, message }) => {