auto-model-router 0.2.32 → 0.3.0

package/src/cli/config-wizard.ts

@@ -2,8 +2,9 @@
  * Interactive configuration wizard for `auto-model-router config`.
  *
  * Edits the router's OWN config (`~/.auto-model-router/config.yml`), covering every
- * section: server, openrouter, tiers, tasks, filters, classifier, escalation,
- * hysteresis, cache, budget, ledger, logging.
+ * section: server, openrouter, ollama, benchmarks, tiers, tasks, filters, classifier,
+ * escalation, hysteresis, exploration, cache, compaction, context, budget, ledger,
+ * logging. omp's `/router config` walks the same `WIZARD_SECTIONS`.
  *
  * Only fields the user actually changes are written, as a deep-merge partial,
  * so untouched defaults and hand-edited values survive.
@@ -36,16 +37,18 @@ export interface WizardIo {
 export interface FieldSpec {
 	path: string;
 	label: string;
-	kind: "string" | "number" | "boolean" | "enum" | "stringArray";
-	/** For `enum`: the allowed values. */
+	kind: "string" | "number" | "boolean" | "enum" | "stringArray" | "numberArray";
+	/** For `enum`: the allowed values. For `stringArray`: the allowed items, when restricted. */
 	options?: readonly string[];
-	/** For `number`: inclusive bounds. */
+	/** For `number` / `numberArray`: inclusive bounds. */
 	min?: number;
 	max?: number;
 	/** Whether the field may be cleared to "no value". */
 	optional?: boolean;
 	/** Short hint shown with the label. */
 	hint?: string;
+	/** Credential: the current value is shown as set/unset, never echoed. */
+	secret?: boolean;
 }
 
 /** A wizard section: a titled group of fields. */
@@ -55,28 +58,104 @@ export interface SectionSpec {
 }
 
 const AXES = ["coding", "agentic", "intelligence"] as const;
+const TIER_NAMES = ["trivial", "simple", "moderate", "hard"] as const;
+const TASK_NAMES = ["coding", "vision", "documentation", "data", "chat"] as const;
 
-/** Every field the wizard can edit, grouped into the menu's sections. */
+/**
+ * Escalation triggers the orchestrator understands: the `EscalationSignal`
+ * union in `src/router/types.ts`. The schema accepts any string so an
+ * experimental trigger can still be added by hand in YAML.
+ */
+const ESCALATION_TRIGGERS = [
+	"malformed_tool_args",
+	"refusal",
+	"empty_completion",
+	"repeat_tool_call",
+	"length_stop",
+	"missing_expected_tool_call",
+	"upstream_error",
+] as const;
+
+function tierFields(tier: (typeof TIER_NAMES)[number]): FieldSpec[] {
+	const p = `tiers.${tier}`;
+	return [
+		{ path: `${p}.minQuality`, label: `${tier}: min quality`, kind: "number", min: 0, max: 100 },
+		{ path: `${p}.maxInputPerMtok`, label: `${tier}: max input $/Mtok`, kind: "number", min: 0, optional: true },
+		{ path: `${p}.maxOutputPerMtok`, label: `${tier}: max output $/Mtok`, kind: "number", min: 0, optional: true },
+		{ path: `${p}.qualityExponent`, label: `${tier}: quality exponent`, kind: "number", min: 0, hint: "quality^k per $" },
+		{ path: `${p}.qualityNormalization`, label: `${tier}: normalise quality to floor`, kind: "boolean", optional: true },
+		{ path: `${p}.capabilityFloorUsd`, label: `${tier}: capability floor $/Mtok`, kind: "number", min: 0, optional: true, hint: "blended" },
+		{ path: `${p}.pin`, label: `${tier}: pinned slugs`, kind: "stringArray", hint: "comma-separated" },
+	];
+}
+
+function taskFields(task: (typeof TASK_NAMES)[number]): FieldSpec[] {
+	const p = `tasks.${task}`;
+	return [
+		{ path: `${p}.axis`, label: `${task}: axis`, kind: "enum", options: AXES },
+		{ path: `${p}.minQuality`, label: `${task}: quality floor`, kind: "number", min: 0, max: 100, optional: true },
+		{ path: `${p}.requireImage`, label: `${task}: require image input`, kind: "boolean", optional: true },
+		{ path: `${p}.prefer`, label: `${task}: always-eligible slugs`, kind: "stringArray", optional: true, hint: "comma-separated" },
+	];
+}
+
+/**
+ * Every field the wizard can edit, grouped into the menu's sections. This is
+ * the whole of `RouterConfig` except the two Ollama maps (`ollama.prices`,
+ * `ollama.twins`) and the profiles array, which are edited as records
+ * (profiles through the wizard's own profile editor, the maps in YAML).
+ * `test/config-wizard.test.ts` checks that every other config leaf is here.
+ */
 export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 	{
 		title: "Server",
 		fields: [
 			{ path: "server.host", label: "Listen host", kind: "string" },
 			{ path: "server.port", label: "Listen port", kind: "number", min: 1, max: 65535 },
-			{ path: "server.apiKey", label: "Client bearer token", kind: "string", optional: true },
+			{ path: "server.apiKey", label: "Client bearer token", kind: "string", optional: true, secret: true },
 			{ path: "server.harnessId", label: "Default harness id", kind: "string", optional: true },
+			{ path: "server.maxConcurrentTurns", label: "Max concurrent turns", kind: "number", min: 1, hint: "per process, all sessions" },
 		],
 	},
 	{
 		title: "OpenRouter",
 		fields: [
 			{ path: "openrouter.baseUrl", label: "Base URL", kind: "string" },
+			{ path: "openrouter.apiKey", label: "API key", kind: "string", optional: true, secret: true, hint: "or OPENROUTER_API_KEY / omp login" },
+			{ path: "openrouter.referer", label: "Attribution referer", kind: "string", optional: true },
 			{ path: "openrouter.title", label: "Attribution title", kind: "string" },
 			{ path: "openrouter.timeoutMs", label: "Request timeout", kind: "number", min: 1, hint: "ms" },
 			{ path: "openrouter.catalogTtlMs", label: "Catalog TTL", kind: "number", min: 1, hint: "ms" },
 			{ path: "openrouter.catalogRefreshMs", label: "Catalog refresh", kind: "number", min: 0, hint: "ms, 0=off" },
 		],
 	},
+	{
+		title: "Ollama Cloud",
+		fields: [
+			{ path: "ollama.enabled", label: "Enable Ollama Cloud as a second upstream", kind: "boolean" },
+			{ path: "ollama.baseUrl", label: "Base URL", kind: "string", hint: "https://ollama.com/v1 or a local daemon" },
+			{ path: "ollama.apiKey", label: "API key", kind: "string", optional: true, secret: true, hint: "or OLLAMA_API_KEY / omp login ollama-cloud" },
+			{ path: "ollama.timeoutMs", label: "Request timeout", kind: "number", min: 1, hint: "ms" },
+			{ path: "ollama.catalogTtlMs", label: "Catalog TTL", kind: "number", min: 1, hint: "ms" },
+			{ path: "ollama.includeLocal", label: "Include locally pulled models", kind: "boolean", hint: "local daemon only" },
+			{ path: "ollama.costBias", label: "Cost bias while credits remain", kind: "number", min: 0, hint: "0.1 = tenth the cost; 1 = at list" },
+			{ path: "ollama.biasUntilUsage", label: "Apply bias until plan usage", kind: "number", min: 0, max: 1, hint: "0-1 of included credits" },
+			{ path: "ollama.usagePollMs", label: "Plan usage poll", kind: "number", min: 0, hint: "ms, 0=off" },
+			{ path: "ollama.quotaCooldownMs", label: "Quota (402) cooldown", kind: "number", min: 0, hint: "ms" },
+			{ path: "ollama.rateLimitCooldownMs", label: "Rate-limit (429) cooldown", kind: "number", min: 0, hint: "ms" },
+		],
+	},
+	{
+		title: "Benchmarks",
+		fields: [
+			{ path: "benchmarks.enabled", label: "Fetch quality scores", kind: "boolean" },
+			{ path: "benchmarks.artificialAnalysisApiKey", label: "Artificial Analysis API key", kind: "string", optional: true, secret: true },
+			{ path: "benchmarks.benchlm", label: "Use BenchLM scores", kind: "boolean" },
+			{ path: "benchmarks.refreshMs", label: "Refresh interval", kind: "number", min: 0, hint: "ms" },
+			{ path: "benchmarks.timeoutMs", label: "Fetch timeout", kind: "number", min: 1, hint: "ms" },
+			{ path: "benchmarks.useLocalScores", label: "Blend in local eval scores", kind: "boolean" },
+		],
+	},
 	{
 		title: "Tiers",
 		fields: [
@@ -86,30 +165,13 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 				kind: "boolean",
 				hint: "keeps every tier populated",
 			},
-			{ path: "tiers.trivial.minQuality", label: "trivial: min quality", kind: "number", min: 0, max: 100 },
-			{ path: "tiers.trivial.maxInputPerMtok", label: "trivial: max input $/Mtok", kind: "number", min: 0, optional: true },
-			{ path: "tiers.simple.minQuality", label: "simple: min quality", kind: "number", min: 0, max: 100 },
-			{ path: "tiers.simple.maxInputPerMtok", label: "simple: max input $/Mtok", kind: "number", min: 0, optional: true },
-			{ path: "tiers.moderate.minQuality", label: "moderate: min quality", kind: "number", min: 0, max: 100 },
-			{ path: "tiers.moderate.maxInputPerMtok", label: "moderate: max input $/Mtok", kind: "number", min: 0, optional: true },
-			{ path: "tiers.hard.minQuality", label: "hard: min quality", kind: "number", min: 0, max: 100 },
-			{ path: "tiers.hard.maxInputPerMtok", label: "hard: max input $/Mtok", kind: "number", min: 0, optional: true },
+			{ path: "adaptivePriceCeilings", label: "Adaptive price ceilings", kind: "boolean", hint: "derive $/Mtok caps from the catalog" },
+			...TIER_NAMES.flatMap(tierFields),
 		],
 	},
 	{
 		title: "Tasks",
-		fields: [
-			{ path: "tasks.coding.axis", label: "coding: axis", kind: "enum", options: AXES },
-			{ path: "tasks.coding.minQuality", label: "coding: quality floor", kind: "number", min: 0, max: 100, optional: true },
-			{ path: "tasks.vision.axis", label: "vision: axis", kind: "enum", options: AXES },
-			{ path: "tasks.vision.minQuality", label: "vision: quality floor", kind: "number", min: 0, max: 100, optional: true },
-			{ path: "tasks.documentation.axis", label: "documentation: axis", kind: "enum", options: AXES },
-			{ path: "tasks.documentation.minQuality", label: "documentation: quality floor", kind: "number", min: 0, max: 100, optional: true },
-			{ path: "tasks.data.axis", label: "data: axis", kind: "enum", options: AXES },
-			{ path: "tasks.data.minQuality", label: "data: quality floor", kind: "number", min: 0, max: 100, optional: true },
-			{ path: "tasks.chat.axis", label: "chat: axis", kind: "enum", options: AXES },
-			{ path: "tasks.chat.minQuality", label: "chat: quality floor", kind: "number", min: 0, max: 100, optional: true },
-		],
+		fields: TASK_NAMES.flatMap(taskFields),
 	},
 	{
 		title: "Filters",
@@ -121,7 +183,14 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "filters.minTrust", label: "Min trust", kind: "number", min: 0, max: 1 },
 			{ path: "filters.minTrustSamples", label: "Min trust samples", kind: "number", min: 0 },
 			{ path: "filters.trustScopedByHarness", label: "Scope trust per harness", kind: "boolean" },
+			{ path: "filters.trustWindowDays", label: "Trust window", kind: "number", min: 0, hint: "days, 0=all time" },
 			{ path: "filters.contextHeadroom", label: "Context headroom", kind: "number", min: 1 },
+			{ path: "filters.latencyWeight", label: "Latency weight", kind: "number", min: 0, hint: "0=ignore speed" },
+			{ path: "filters.latencyReferenceMs", label: "Latency reference TTFT", kind: "number", min: 1, hint: "ms" },
+			{ path: "filters.latencyReferenceTokensPerSec", label: "Latency reference speed", kind: "number", min: 1, hint: "tok/s" },
+			{ path: "filters.latencyMinSamples", label: "Latency min samples", kind: "number", min: 0 },
+			{ path: "filters.maxExpectedWaitMs", label: "Max expected wait", kind: "number", min: 1, optional: true, hint: "ms, hard ceiling" },
+			{ path: "filters.escalationCostWeight", label: "Escalation cost weight", kind: "number", min: 0, max: 1 },
 		],
 	},
 	{
@@ -130,9 +199,17 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "classifier.ambiguityThreshold", label: "Ambiguity threshold", kind: "number", min: 0, max: 1 },
 			{ path: "classifier.model", label: "Adjudicator model", kind: "string", optional: true },
 			{ path: "classifier.maxCostFraction", label: "Max cost fraction", kind: "number", min: 0, max: 1 },
+			{ path: "classifier.maxCostUsd", label: "Max adjudication cost $", kind: "number", min: 0 },
 			{ path: "classifier.timeoutMs", label: "Adjudicator timeout", kind: "number", min: 1, hint: "ms" },
+			{ path: "classifier.cacheSize", label: "Adjudication cache size", kind: "number", min: 0 },
 			{ path: "classifier.toolAxis", label: "Tool-call axis", kind: "enum", options: AXES },
 			{ path: "classifier.chatAxis", label: "Chat axis", kind: "enum", options: AXES },
+			{ path: "classifier.agenticLoopDepth", label: "Agentic loop depth", kind: "number", min: 0, hint: "tool rounds before damping" },
+			{ path: "classifier.mechanicalRetryFactor", label: "Mechanical retry factor", kind: "number", min: 0, max: 1 },
+			{ path: "classifier.reasoningWeights.medium", label: "Reasoning weight: medium", kind: "number", min: 0 },
+			{ path: "classifier.reasoningWeights.high", label: "Reasoning weight: high", kind: "number", min: 0 },
+			{ path: "classifier.reasoningWeights.xhigh", label: "Reasoning weight: xhigh", kind: "number", min: 0 },
+			{ path: "classifier.reasoningWeights.max", label: "Reasoning weight: max", kind: "number", min: 0 },
 		],
 	},
 	{
@@ -142,14 +219,34 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "escalation.probeTokens", label: "Probe tokens", kind: "number", min: 1 },
 			{ path: "escalation.maxHoldMs", label: "Max hold", kind: "number", min: 1, hint: "ms" },
 			{ path: "escalation.maxAttempts", label: "Max attempts", kind: "number", min: 1 },
+			{ path: "escalation.probeTiers", label: "Tiers that probe", kind: "stringArray", options: TIER_NAMES, hint: "comma-separated" },
+			{ path: "escalation.triggers", label: "Triggers", kind: "stringArray", options: ESCALATION_TRIGGERS, hint: "comma-separated" },
+			{ path: "escalation.escalateOnLengthStop", label: "Escalate on length stop", kind: "boolean" },
 		],
 	},
 	{
 		title: "Hysteresis",
 		fields: [
 			{ path: "hysteresis.holdTurns", label: "Hold turns", kind: "number", min: 0 },
+			{ path: "hysteresis.holdTurnsAfterEscalation", label: "Hold turns after escalation", kind: "number", min: 0 },
 			{ path: "hysteresis.switchMargin", label: "Switch margin", kind: "number", min: 0 },
+			{ path: "hysteresis.switchHorizonTurns", label: "Switch horizon", kind: "number", min: 1, hint: "turns amortised" },
 			{ path: "hysteresis.cacheWarmTtlMs", label: "Cache-warm TTL", kind: "number", min: 0, hint: "ms" },
+			{ path: "hysteresis.maxDowngradePerTurn", label: "Max downgrade per turn", kind: "number", min: 0, hint: "tiers" },
+			{ path: "hysteresis.breakHoldOnMechanical", label: "Break hold on mechanical turns", kind: "boolean" },
+		],
+	},
+	{
+		title: "Exploration",
+		fields: [
+			{ path: "exploration.enabled", label: "Enable exploration", kind: "boolean", hint: "records arms into the ledger" },
+			{ path: "exploration.rates.trivial", label: "Rate: trivial", kind: "number", min: 0, max: 1, optional: true },
+			{ path: "exploration.rates.simple", label: "Rate: simple", kind: "number", min: 0, max: 1, optional: true },
+			{ path: "exploration.rates.moderate", label: "Rate: moderate", kind: "number", min: 0, max: 1, optional: true },
+			{ path: "exploration.rates.hard", label: "Rate: hard", kind: "number", min: 0, max: 1, optional: true },
+			{ path: "exploration.stickyPolicy", label: "Sticky policy", kind: "enum", options: ["never", "cold-cache", "always"] },
+			{ path: "exploration.holdTurns.enabled", label: "Hold-length experiment", kind: "boolean" },
+			{ path: "exploration.holdTurns.values", label: "Hold-length arms", kind: "numberArray", min: 1, hint: "comma-separated turns" },
 		],
 	},
 	{
@@ -158,6 +255,41 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "cache.injectBreakpoints", label: "Inject cache breakpoints", kind: "boolean" },
 			{ path: "cache.maxBreakpoints", label: "Max breakpoints", kind: "number", min: 1 },
 			{ path: "cache.minPromptTokens", label: "Min prompt tokens", kind: "number", min: 0 },
+			{ path: "cache.milestoneTokens", label: "Milestone tokens", kind: "number", min: 1, hint: "breakpoint spacing" },
+		],
+	},
+	{
+		title: "Compaction",
+		fields: [
+			{ path: "compaction.enabled", label: "Enable compaction", kind: "boolean" },
+			{ path: "compaction.budgetTokens", label: "Budget tokens", kind: "number", min: 1 },
+			{ path: "compaction.floorRatio", label: "Floor ratio", kind: "number", min: 0, max: 1, hint: "of the budget" },
+			{ path: "compaction.replanGrowthRatio", label: "Replan growth ratio", kind: "number", min: 1 },
+			{ path: "compaction.fitToWindow", label: "Fit to model context window", kind: "boolean" },
+			{ path: "compaction.protectRecentTurns", label: "Protect recent turns", kind: "number", min: 1 },
+			{ path: "compaction.maxToolResultBytes", label: "Max tool result bytes", kind: "number", min: 1 },
+			{ path: "compaction.keepHeadBytes", label: "Keep head bytes", kind: "number", min: 0 },
+			{ path: "compaction.keepTailBytes", label: "Keep tail bytes", kind: "number", min: 0 },
+			{ path: "compaction.elideSupersededReads", label: "Elide superseded reads", kind: "boolean" },
+			{ path: "compaction.collapseDuplicateResults", label: "Collapse duplicate results", kind: "boolean" },
+		],
+	},
+	{
+		title: "Context (agentdox)",
+		fields: [
+			{ path: "context.enabled", label: "Inject shared project context", kind: "boolean" },
+			{ path: "context.baseUrl", label: "agentdox URL", kind: "string", optional: true },
+			{ path: "context.token", label: "agentdox token", kind: "string", optional: true, secret: true, hint: "or AGENTDOX_TOKEN" },
+			{ path: "context.defaultScope", label: "Default scope", kind: "string", optional: true },
+			{ path: "context.timeoutMs", label: "Request timeout", kind: "number", min: 1, hint: "ms" },
+			{ path: "context.maxStalenessMs", label: "Max staleness", kind: "number", min: 0, hint: "ms" },
+			{ path: "context.maxBlockChars", label: "Max block chars", kind: "number", min: 1 },
+			{ path: "context.memoryLimit", label: "Memory items", kind: "number", min: 1 },
+			{ path: "context.docsLimit", label: "Doc items", kind: "number", min: 0 },
+			{ path: "context.sessionLimit", label: "Session items", kind: "number", min: 0 },
+			{ path: "context.briefChars", label: "Brief chars", kind: "number", min: 0 },
+			{ path: "context.recordTurns", label: "Record turns back", kind: "boolean" },
+			{ path: "context.maxQueue", label: "Write-back queue", kind: "number", min: 1 },
 		],
 	},
 	{
@@ -172,8 +304,11 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 	{
 		title: "Ledger",
 		fields: [
+			{ path: "ledger.path", label: "Ledger path", kind: "string", hint: "SQLite file" },
 			{ path: "ledger.blendWindowDays", label: "Blend window", kind: "number", min: 1, hint: "days" },
 			{ path: "ledger.blendMinSamples", label: "Blend min samples", kind: "number", min: 0 },
+			{ path: "ledger.fallbackBlend.inputPerMtok", label: "Fallback blend input $/Mtok", kind: "number", min: 0 },
+			{ path: "ledger.fallbackBlend.outputPerMtok", label: "Fallback blend output $/Mtok", kind: "number", min: 0 },
 			{ path: "ledger.conversationTtlMs", label: "Conversation TTL", kind: "number", min: 1, hint: "ms" },
 		],
 	},
@@ -258,8 +393,25 @@ export function validateField(field: FieldSpec, raw: string): FieldResult {
 
 		case "stringArray": {
 			const items = text.split(",").map((s) => s.trim()).filter((s) => s !== "");
+			if (field.options !== undefined) {
+				const bad = items.filter((s) => !field.options?.includes(s));
+				if (bad.length > 0) return { ok: false, error: `unknown: ${bad.join(", ")} (one of: ${field.options.join(", ")})` };
+			}
 			return { ok: true, value: items };
 		}
+
+		case "numberArray": {
+			const items = text.split(",").map((s) => s.trim()).filter((s) => s !== "");
+			const values: number[] = [];
+			for (const item of items) {
+				const n = Number(item);
+				if (!Number.isFinite(n)) return { ok: false, error: `not a number: ${item}` };
+				if (field.min !== undefined && n < field.min) return { ok: false, error: `${item}: must be >= ${field.min}` };
+				if (field.max !== undefined && n > field.max) return { ok: false, error: `${item}: must be <= ${field.max}` };
+				values.push(n);
+			}
+			return { ok: true, value: values };
+		}
 	}
 }
 
@@ -321,10 +473,19 @@ export function formatValue(value: unknown): string {
 	return String(value);
 }
 
+/**
+ * What a prompt shows as the current value: `formatValue`, except that a
+ * secret is never echoed — only whether one is set.
+ */
+export function displayValue(field: FieldSpec, value: unknown): string {
+	if (field.secret === true) return value === undefined || value === null || value === "" ? "unset" : "set";
+	return formatValue(value);
+}
+
 /** Builds the field prompt line, e.g. `  Listen port [8788]: `. */
 function fieldPrompt(field: FieldSpec, current: unknown): string {
 	const hint = field.hint !== undefined ? ` (${field.hint})` : "";
-	return `  ${field.label}${hint} [${formatValue(current)}]: `;
+	return `  ${field.label}${hint} [${displayValue(field, current)}]: `;
 }
 
 /** Renders the top-level section menu. */

package/src/cli/explain.ts

@@ -10,13 +10,12 @@
 
 import { existsSync } from "node:fs";
 
-import { createCatalog } from "../catalog/openrouter-catalog.ts";
+import { createProviders } from "../server/providers.ts";
 import { loadConfig } from "../config/load.ts";
 import { createLedger } from "../cost/ledger.ts";
 import { createRouter } from "../router/index.ts";
 import { createConversationStore } from "../router/state.ts";
 import type { Candidate, Decision, Features, Rejection } from "../router/types.ts";
-import { createOpenRouterClient } from "../upstream/openrouter.ts";
 import { openDb } from "../util/sqlite.ts";
 import { parseChatRequest } from "../wire/openai/request.ts";
 import { configOpts, flagString, type CliArgs } from "./args.ts";
@@ -133,8 +132,7 @@ export async function explainCommand(args: CliArgs): Promise<void> {
 	const db = openDb(cfg.ledger.path);
 	try {
 		const ledger = createLedger(db, cfg);
-		const upstream = createOpenRouterClient(cfg);
-		const catalog = createCatalog(cfg, upstream, db);
+		const { upstream, catalog } = createProviders(cfg, db);
 		const conversations = createConversationStore(db);
 		const router = createRouter({ config: cfg, catalog, ledger, conversations, upstream });
 

package/src/cli/models.ts

@@ -10,7 +10,7 @@
 import { existsSync } from "node:fs";
 import type { Database } from "bun:sqlite";
 
-import { createCatalog } from "../catalog/openrouter-catalog.ts";
+import { createProviders } from "../server/providers.ts";
 import { effectiveQualityFloor, tierPlanFor } from "../router/tier-plan.ts";
 import { loadConfig } from "../config/load.ts";
 import type { QualityAxis, RouterConfig } from "../config/types.ts";
@@ -21,7 +21,6 @@ import { classifyTask } from "../router/classify.ts";
 import { extractFeatures } from "../router/features.ts";
 import { TIER_ORDER, type Candidate, type Rejection, type Tier } from "../router/types.ts";
 import { estimatePromptTokens } from "../tokens/estimate.ts";
-import { createOpenRouterClient } from "../upstream/openrouter.ts";
 import { openDb } from "../util/sqlite.ts";
 import { parseChatRequest } from "../wire/openai/request.ts";
 import { configOpts, flagInt, flagString, type CliArgs } from "./args.ts";
@@ -156,8 +155,7 @@ export async function modelsCommand(args: CliArgs): Promise<void> {
 	const db: Database = openDb(cfg.ledger.path);
 	const ledger: Ledger | null = existsSync(cfg.ledger.path) ? createLedger(db, cfg) : null;
 	try {
-		const upstream = createOpenRouterClient(cfg);
-		const catalog = createCatalog(cfg, upstream, db);
+		const { catalog } = createProviders(cfg, db);
 		const snapshot = await catalog.get();
 
 		const req = syntheticRequest();

package/src/cli/report.ts

@@ -0,0 +1,37 @@
+/**
+ * `auto-model-router report`: usage analytics over the ledger — which
+ * providers and models were routed, what they cost, how fast they were, how
+ * much of the prompt was served from cache, and the tier mix. The same
+ * aggregation backs `GET /v1/router/report` and omp's `/router report`.
+ */
+
+import { existsSync } from "node:fs";
+import { loadConfig } from "../config/load.ts";
+import { buildUsageReport, renderUsageReport } from "../cost/report.ts";
+import { openDb } from "../util/sqlite.ts";
+import { configOpts, flagInt, flagString, type CliArgs } from "./args.ts";
+
+export async function reportCommand(args: CliArgs): Promise<void> {
+	const days = flagInt(args, "days") ?? 7;
+	const harnessId = flagString(args, "harness") ?? "";
+	const cfg = loadConfig(configOpts(args));
+
+	// Looking must not create the ledger file.
+	if (!existsSync(cfg.ledger.path)) {
+		if (args.flags.has("json")) {
+			console.log(JSON.stringify({ windowDays: days, harnessId, totals: null, providers: [], models: [], tiers: [], days: [] }, null, 2));
+		} else {
+			console.log(`no ledger at ${cfg.ledger.path} yet`);
+		}
+		return;
+	}
+
+	const db = openDb(cfg.ledger.path);
+	try {
+		const report = buildUsageReport(db, { windowDays: days, harnessId });
+		if (args.flags.has("json")) console.log(JSON.stringify(report, null, 2));
+		else console.log(renderUsageReport(report));
+	} finally {
+		db.close();
+	}
+}

package/src/config/defaults.ts

@@ -31,6 +31,32 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// guardrail changes are picked up without waiting for traffic + TTL.
 		catalogRefreshMs: 5 * 60 * 1000,
 	},
+	ollama: {
+		// Off: a second upstream changes what every turn can route to.
+		enabled: false,
+		// The local daemon proxies `:cloud` models under the account it is signed
+		// in to and publishes their context/capabilities in `/api/tags`. Point at
+		// `https://ollama.com/v1` (with `apiKey`) to skip the daemon.
+		baseUrl: "http://127.0.0.1:11434/v1",
+		apiKey: "",
+		timeoutMs: 600_000,
+		catalogTtlMs: 5 * 60 * 1000,
+		includeLocal: false,
+		prices: {},
+		twins: {},
+		costBias: 1,
+		// Bias off once 90% of the month's included credits are used: the last
+		// slice is left for the plan to absorb overage-free, and anything past it
+		// bills at list price, where OpenRouter is usually cheaper.
+		biasUntilUsage: 0.9,
+		// The usage endpoint aggregates with a lag and rounds to whole percents;
+		// polling faster than this learns nothing.
+		usagePollMs: 10 * 60 * 1000,
+		// Credits reset monthly; 15 minutes keeps a topped-up account from waiting long.
+		quotaCooldownMs: 15 * 60 * 1000,
+		// Concurrency caps clear as soon as an in-flight request finishes.
+		rateLimitCooldownMs: 60 * 1000,
+	},
 	benchmarks: {
 		// Keyless BenchLM alone fills real gaps, so this is on by default; the AA
 		// feed only actually fires once a key is present (config or env).
@@ -89,6 +115,10 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// slow models (e.g. deepseek-v4-flash ~20 tok/s) fall under it.
 		latencyReferenceTokensPerSec: 30,
 		latencyMinSamples: 20,
+		// Off: pricing a model's measured escalation rate at what an escalated
+		// retry actually costs changes rankings, so it is opt-in after a replay
+		// run prices it. See FilterConfig.escalationCostWeight.
+		escalationCostWeight: 0,
 	},
 	classifier: {
 		ambiguityThreshold: 0.6,
@@ -101,8 +131,11 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		toolAxis: "coding",
 		chatAxis: "intelligence",
 		agenticLoopDepth: 3,
-		// Shipped values, unchanged. See ClassifierConfig.reasoningWeights: a
-		// harness that pins the level for a whole session turns these into a
+		// A mechanical retry (failed tool call + tool-result continuation) keeps
+		// only a fifth of the +0.26; a user-visible failure keeps the full weight.
+		mechanicalRetryFactor: 0.2,
+		// Shipped reasoning values, unchanged. See ClassifierConfig.reasoningWeights:
+		// a harness that pins the level for a whole session turns these into a
 		// constant tier offset, in which case `medium` belongs near 0.
 		reasoningWeights: { medium: 0.14, high: 0.24, xhigh: 0.3, max: 0.34 },
 	},
@@ -135,6 +168,9 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		holdTurns: 2,
 		holdTurnsAfterEscalation: 4,
 		switchMargin: 1.3,
+		// 1 = the shipped one-turn comparison. Raise to amortise a switch over the
+		// turns that follow it; see HysteresisConfig.switchHorizonTurns.
+		switchHorizonTurns: 1,
 		// OpenRouter sticky sessions expire in 5-10 minutes.
 		cacheWarmTtlMs: 300_000,
 		maxDowngradePerTurn: 1,
@@ -226,6 +262,11 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// here — the same reason `enabled` is false. 0.75 is the recommended
 		// setting once a deployment has watched its own ledger.
 		floorRatio: 1,
+		// 1 = re-plan whenever the compacted prompt is over budget (the shipped
+		// behaviour). Above 1, a plan is only extended once the compacted prompt
+		// has grown by that factor since it was last planned; see
+		// CompactionConfig.replanGrowthRatio.
+		replanGrowthRatio: 1,
 		fitToWindow: true,
 		protectRecentTurns: 4,
 		maxToolResultBytes: 4_096,

package/src/config/load.ts

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import { parse as parseYaml } from "yaml";
 import { DEFAULT_CONFIG } from "./defaults.ts";
 import { configInputSchema } from "./schema.ts";
-import { resolveOpenRouterKey, type ResolvedCredential } from "./omp-credentials.ts";
+import { resolveOllamaKey, resolveOpenRouterKey, type ResolvedCredential } from "./omp-credentials.ts";
 import type { RouterConfig } from "./types.ts";
 
 const LOG_LEVELS: readonly RouterConfig["logLevel"][] = ["silent", "error", "warn", "info", "debug"];
@@ -103,6 +103,10 @@ export function loadConfig(opts?: { path?: string; overrides?: DeepPartial<Route
 	if (envApiKey !== undefined && envApiKey !== "") putSection("openrouter", "apiKey", envApiKey);
 	const envAaKey = process.env.ARTIFICIAL_ANALYSIS_API_KEY;
 	if (envAaKey !== undefined && envAaKey !== "") putSection("benchmarks", "artificialAnalysisApiKey", envAaKey);
+	// Ollama's own convention for its cloud key. Only fills the key; enabling
+	// the upstream stays an explicit `ollama.enabled: true`.
+	const envOllamaKey = process.env.OLLAMA_API_KEY;
+	if (envOllamaKey !== undefined && envOllamaKey !== "") putSection("ollama", "apiKey", envOllamaKey);
 	const envPort = process.env.AUTO_MODEL_ROUTER_PORT;
 	if (envPort !== undefined && envPort !== "") {
 		const port = Number.parseInt(envPort, 10);
@@ -151,9 +155,29 @@ export function loadConfig(opts?: { path?: string; overrides?: DeepPartial<Route
 	cfg.openrouter.apiKey = credential.apiKey;
 	apiKeyProvenance.set(cfg, credential);
 
+	// Same borrowing for Ollama Cloud: `/login ollama-cloud` in omp is all the
+	// setup a direct ollama.com connection needs. Resolved even when the
+	// upstream is disabled, so enabling it later needs no extra step.
+	const ollamaCredential = resolveOllamaKey(cfg.ollama.apiKey);
+	cfg.ollama.apiKey = ollamaCredential.apiKey;
+	ollamaKeyProvenance.set(cfg, ollamaCredential);
+
 	return cfg;
 }
 
+const ollamaKeyProvenance = new WeakMap<RouterConfig, ResolvedCredential>();
+
+/** Where a config's Ollama Cloud key came from; never the key itself. */
+export function ollamaKeySource(cfg: RouterConfig): ResolvedCredential {
+	return (
+		ollamaKeyProvenance.get(cfg) ?? {
+			apiKey: cfg.ollama.apiKey,
+			source: cfg.ollama.apiKey === "" ? "none" : "config",
+			detail: cfg.ollama.apiKey === "" ? "no key configured" : "config",
+		}
+	);
+}
+
 /**
  * Where a config's OpenRouter key came from, for startup logs and `/health`.
  * Keyed weakly off the config object so the provenance never has to travel

package/src/config/omp-credentials.ts

@@ -95,23 +95,33 @@ export function readOmpCredential(provider: string, storePath = ompAuthStorePath
 	}
 }
 
+interface ProviderKeySpec {
+	/** omp's provider id in the auth store. */
+	ompProvider: string;
+	/** Environment variable the key may have come from. */
+	envVar: string;
+	/** What to tell the operator when nothing resolves. */
+	loginHint: string;
+}
+
 /**
- * Full precedence chain for the OpenRouter key. Explicit configuration always
- * beats the borrowed credential, so a project can point at a different account
+ * Full precedence chain for a provider key: explicit configuration (attributed
+ * to the environment when it matches the env var) beats the credential
+ * borrowed from omp's store, so a project can point at a different account
  * without touching omp.
  */
-export function resolveOpenRouterKey(configured: string): ResolvedCredential {
+function resolveProviderKey(configured: string, spec: ProviderKeySpec): ResolvedCredential {
 	if (configured !== "") {
-		const fromEnv = process.env.OPENROUTER_API_KEY;
+		const fromEnv = process.env[spec.envVar];
 		const source: CredentialSource = fromEnv !== undefined && fromEnv === configured ? "env" : "config";
 		return {
 			apiKey: configured,
 			source,
-			detail: source === "env" ? "OPENROUTER_API_KEY" : "config file",
+			detail: source === "env" ? spec.envVar : "config file",
 		};
 	}
 
-	const borrowed = readOmpCredential("openrouter");
+	const borrowed = readOmpCredential(spec.ompProvider);
 	if (borrowed !== null) {
 		return { apiKey: borrowed, source: "omp-auth-store", detail: `omp auth store (${ompAuthStorePath()})` };
 	}
@@ -119,6 +129,20 @@ export function resolveOpenRouterKey(configured: string): ResolvedCredential {
 	return {
 		apiKey: "",
 		source: "none",
-		detail: "no key: set OPENROUTER_API_KEY, or run `/login openrouter` inside omp",
+		detail: `no key: set ${spec.envVar}, or run \`/login ${spec.loginHint}\` inside omp`,
 	};
 }
+
+export function resolveOpenRouterKey(configured: string): ResolvedCredential {
+	return resolveProviderKey(configured, { ompProvider: "openrouter", envVar: "OPENROUTER_API_KEY", loginHint: "openrouter" });
+}
+
+/**
+ * The Ollama Cloud key, borrowed from omp's `ollama-cloud` provider once
+ * `/login ollama-cloud` has been run there. Only needed when `ollama.baseUrl`
+ * points at ollama.com; the local daemon authenticates with its own sign-in
+ * and ignores a bearer.
+ */
+export function resolveOllamaKey(configured: string): ResolvedCredential {
+	return resolveProviderKey(configured, { ompProvider: "ollama-cloud", envVar: "OLLAMA_API_KEY", loginHint: "ollama-cloud" });
+}