auto-model-router 0.4.4 → 0.4.5

package/.omp-plugin/marketplace.json

@@ -7,14 +7,14 @@
   },
   "metadata": {
     "description": "auto-model-router: a local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
-    "version": "0.4.4",
+    "version": "0.4.5",
     "pluginRoot": "."
   },
   "plugins": [
     {
       "name": "auto-model-router",
       "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter. Runs in-process, routes per turn by price and task complexity, with budget caps, mid-stream escalation, and cache-aware hysteresis.",
-      "version": "0.4.4",
+      "version": "0.4.5",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -837,6 +837,14 @@ task needed, and `digest.maxOutputTokens` or `digest.model` is the lever.
 | `baselines` | `anthropic/claude-opus-5`, `anthropic/claude-sonnet-5` | Models the report prices the window's traffic on as a single-model counterfactual. Unknown slugs are skipped. |
 | `dailySummary` | `true` | Post the daily summary (below) into the transcript at the first interactive omp session start of each day. Hot-reloads. |
 
+### `harnessSwitch` — harness-side model switch (experimental)
+
+| Key | Default | Meaning |
+| --- | --- | --- |
+| `enabled` | `false` | Let the `router-switch` extension move omp's active model for mapped tiers. |
+| `models` | `{}` | Tier → harness model as `provider/id` in omp's own registry, e.g. `hard: anthropic/claude-opus-4-8`. A tier serves itself and every tier above it up to the next mapped one; unmapped tiers stay on the router. |
+| `minConfidence` | `0.6` | Advice below this heuristic confidence leaves the model where it is. |
+
 ### `ledger` — cost measurement
 
 | Key | Default | Meaning |
@@ -929,6 +937,35 @@ router handles for you: no `models[]` fallback cascade, no `tool_choice`,
 `reasoning_effort` instead of the `reasoning` object, and no `cache_control`
 markers (they are stripped before dispatch).
 
+## Harness-side model switch (experimental)
+
+Most engineers reach Claude through a subscription, not an API key, and a
+subscription model cannot be proxied: the router would have to translate to
+Anthropic's wire format and carry omp's OAuth token through a third-party
+process. The `router-switch` extension takes the other route. Before omp
+starts a turn on a user prompt it asks the router which tier the prompt is
+(`POST /v1/router/advise`, the heuristic classifier over the prompt text,
+nothing dispatched or recorded). When that tier is mapped in
+`harnessSwitch.models`, the extension moves omp's active model to the mapped
+harness model; when a later prompt is advised below every mapped tier, it
+moves back to the router model it left. A model the user picked by hand is
+never touched. Native turns bill the subscription and never reach the
+ledger; the router serves and accounts for the rest.
+
+```yaml
+# ~/.auto-model-router/config.yml
+harnessSwitch:
+  enabled: true
+  models:
+    hard: anthropic/claude-opus-4-8
+```
+
+Install `omp-extension/router-switch.ts` beside the embed extension and
+restart omp. Known limits of the prototype: the advice sees only the prompt
+text, not the conversation, so a hard task that only becomes hard three tool
+calls in stays on the router (the router's own escalation still applies
+there); and the switch happens at prompt boundaries, never mid-turn.
+
 ## Multiple coding harnesses, one router
 
 A single embedded router can serve several omp sessions without them stepping

package/omp-extension/pi-coding-agent.d.ts

@@ -109,6 +109,12 @@ declare module "@oh-my-pi/pi-coding-agent" {
 		/** Interval whose errors omp isolates, and whose handle `clearTimer` cancels. */
 		setInterval(handler: () => void | Promise<void>, ms: number): unknown;
 		clearTimer(timer: unknown): void;
+		/** The active model, when one is set. (Real type: `Model`.) */
+		model: { provider: string; id: string } | undefined;
+		/** Looks a model up in omp's registry by provider and id. */
+		modelRegistry: { find(provider: string, modelId: string): unknown };
+		/** Sets the session's active model; false when omp has no key for it. */
+		setModel(model: unknown): Promise<boolean>;
 	}
 
 	export interface CommandDefinition {

package/omp-extension/router-switch.ts

@@ -0,0 +1,100 @@
+/**
+ * omp extension: harness-side model switch (experimental).
+ *
+ * Before omp starts a turn on a user prompt, ask the router which tier the
+ * prompt is, and when that tier is mapped to a harness-native model in the
+ * router's `harnessSwitch.models` (a Claude subscription model, typically),
+ * move omp's active model there; when a later prompt is advised below the
+ * mapped tiers, move back to the router model we left. A model the user
+ * picked by hand is never touched.
+ *
+ * Nothing is proxied and no token leaves omp: the native turns bill the
+ * subscription, the router serves the rest and keeps the ledger for those.
+ * Off unless `harnessSwitch.enabled` is set in the router config.
+ *
+ *   # ~/.omp/agent/config.yml
+ *   extensions:
+ *     - /path/to/auto-model-router/omp-extension/router-embed.ts
+ *     - /path/to/auto-model-router/omp-extension/router-switch.ts
+ */
+
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+
+import { EMBED_PROVIDER_ID } from "./embed-logic.ts";
+import { routerAuthHeaders, routerBaseUrl } from "./router-url.ts";
+import { DISABLED_SWITCH, decideSwitch, parseSwitchPolicy, type SwitchPolicy, type TierName } from "./switch-logic.ts";
+
+const HARNESS_ID = process.env.OMP_HARNESS_ID ?? "";
+const POLICY_TTL_MS = 60_000;
+
+export default function (pi: ExtensionAPI): void {
+	pi.setLabel("auto-model-router switch");
+
+	let policy: SwitchPolicy = DISABLED_SWITCH;
+	let policyAtMs = 0;
+	let switchedTo: string | null = null;
+	let returnTo: string | null = null;
+
+	async function refreshPolicy(): Promise<void> {
+		if (Date.now() - policyAtMs < POLICY_TTL_MS) return;
+		policyAtMs = Date.now();
+		try {
+			const res = await fetch(`${routerBaseUrl()}/v1/router/advise/policy`, { headers: routerAuthHeaders(), signal: AbortSignal.timeout(2_000) });
+			policy = res.ok ? parseSwitchPolicy(await res.json()) : DISABLED_SWITCH;
+		} catch {
+			policy = DISABLED_SWITCH;
+		}
+	}
+
+	pi.on("session_start", async () => {
+		policyAtMs = 0;
+		switchedTo = null;
+		returnTo = null;
+		await refreshPolicy();
+	});
+
+	pi.on("before_agent_start", async (event, ctx) => {
+		const e = event as { prompt?: string };
+		if (typeof e.prompt !== "string" || e.prompt.trim() === "") return undefined;
+		await refreshPolicy();
+		if (!policy.enabled) return undefined;
+		const activeModel = ctx.model;
+		const active = activeModel === undefined ? null : `${activeModel.provider}/${activeModel.id}`;
+		const activeIsRouter = activeModel?.provider === EMBED_PROVIDER_ID;
+		let advised: { tier: TierName; confidence: number };
+		try {
+			const res = await fetch(`${routerBaseUrl()}/v1/router/advise`, {
+				method: "POST",
+				headers: { ...routerAuthHeaders(), "content-type": "application/json" },
+				body: JSON.stringify({ ompSessionId: ctx.sessionManager.getSessionId(), harnessId: HARNESS_ID, text: e.prompt.slice(0, 8_000) }),
+				signal: AbortSignal.timeout(2_000),
+			});
+			if (!res.ok) return undefined;
+			advised = (await res.json()) as { tier: TierName; confidence: number };
+		} catch {
+			return undefined;
+		}
+		const decision = decideSwitch({ policy, advised, active, activeIsRouter, switchedTo, returnTo });
+		if (decision.action === "none") return undefined;
+		const [provider = "", ...rest] = decision.model.split("/");
+		const target = ctx.modelRegistry.find(provider, rest.join("/"));
+		if (target === undefined) {
+			if (ctx.hasUI) ctx.ui.notify(`router switch: ${decision.model} is not in omp's model registry`, "warn");
+			return undefined;
+		}
+		const ok = await ctx.setModel(target);
+		if (!ok) {
+			if (ctx.hasUI) ctx.ui.notify(`router switch: omp has no key for ${decision.model}`, "warn");
+			return undefined;
+		}
+		if (decision.action === "up") {
+			if (activeIsRouter) returnTo = active;
+			switchedTo = decision.model;
+		} else {
+			switchedTo = null;
+			returnTo = null;
+		}
+		if (ctx.hasUI) ctx.ui.notify(`router switch: ${decision.reason}`, "info");
+		return undefined;
+	});
+}

package/omp-extension/switch-logic.ts

@@ -0,0 +1,81 @@
+/**
+ * Pure decision logic behind the harness-side model switch (router-switch.ts):
+ * given the router's advice for a prompt and what model omp is on, say whether
+ * to move up to a harness-native model, back to the router, or stay put.
+ * Free of omp types so it is unit-testable.
+ */
+
+export const TIERS = ["trivial", "simple", "moderate", "hard"] as const;
+export type TierName = (typeof TIERS)[number];
+
+export interface SwitchPolicy {
+	enabled: boolean;
+	/** Tier → harness model (`provider/id`) that serves that tier and above, up to the next configured tier. */
+	models: Partial<Record<TierName, string>>;
+	/** Advice below this confidence never moves the model. */
+	minConfidence: number;
+}
+
+export const DISABLED_SWITCH: SwitchPolicy = { enabled: false, models: {}, minConfidence: 1 };
+
+export function parseSwitchPolicy(raw: unknown): SwitchPolicy {
+	if (raw === null || typeof raw !== "object") return DISABLED_SWITCH;
+	const r = raw as Record<string, unknown>;
+	const models: Partial<Record<TierName, string>> = {};
+	if (r.models !== null && typeof r.models === "object") {
+		for (const t of TIERS) {
+			const v = (r.models as Record<string, unknown>)[t];
+			if (typeof v === "string" && v.includes("/")) models[t] = v;
+		}
+	}
+	return {
+		enabled: r.enabled === true,
+		models,
+		minConfidence: typeof r.minConfidence === "number" ? r.minConfidence : 0.6,
+	};
+}
+
+/** The harness model configured for the highest tier at or below `tier`, if any. */
+export function nativeModelFor(policy: SwitchPolicy, tier: TierName): string | undefined {
+	for (let i = TIERS.indexOf(tier); i >= 0; i--) {
+		const m = policy.models[TIERS[i]!];
+		if (m !== undefined) return m;
+	}
+	return undefined;
+}
+
+export interface SwitchInput {
+	policy: SwitchPolicy;
+	advised: { tier: TierName; confidence: number };
+	/** omp's active model as `provider/id`, or null when none. */
+	active: string | null;
+	/** True when the active model belongs to the router's provider. */
+	activeIsRouter: boolean;
+	/** The harness model this extension last switched TO, if omp is still on it. */
+	switchedTo: string | null;
+	/** The router model omp was on before the switch, to return to. */
+	returnTo: string | null;
+}
+
+export type SwitchDecision =
+	| { action: "up"; model: string; reason: string }
+	| { action: "back"; model: string; reason: string }
+	| { action: "none"; reason: string };
+
+export function decideSwitch(input: SwitchInput): SwitchDecision {
+	const { policy, advised, active, activeIsRouter, switchedTo, returnTo } = input;
+	if (!policy.enabled) return { action: "none", reason: "harnessSwitch.enabled is off" };
+	const onOurSwitch = switchedTo !== null && active === switchedTo;
+	// The user picked something else by hand: never fight a manual choice.
+	if (!activeIsRouter && !onOurSwitch) return { action: "none", reason: `active model ${active ?? "(none)"} was chosen by the user` };
+	const native = nativeModelFor(policy, advised.tier);
+	if (native === undefined) {
+		if (onOurSwitch && returnTo !== null) return { action: "back", model: returnTo, reason: `${advised.tier} work: back to the router` };
+		return { action: "none", reason: `${advised.tier} work stays on the router` };
+	}
+	if (advised.confidence < policy.minConfidence) {
+		return { action: "none", reason: `${advised.tier} at confidence ${advised.confidence.toFixed(2)} < ${policy.minConfidence}` };
+	}
+	if (active === native) return { action: "none", reason: `already on ${native}` };
+	return { action: "up", model: native, reason: `${advised.tier} work (confidence ${advised.confidence.toFixed(2)}) → ${native}` };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-model-router",
-  "version": "0.4.4",
+  "version": "0.4.5",
   "private": false,
   "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
   "type": "module",

package/src/cli/config-wizard.ts

@@ -335,6 +335,14 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "report.dailySummary", label: "Daily summary at session start", kind: "boolean" },
 		],
 	},
+	{
+		title: "Harness switch",
+		fields: [
+			{ path: "harnessSwitch.enabled", label: "Switch omp's model for mapped tiers (experimental)", kind: "boolean" },
+			{ path: "harnessSwitch.minConfidence", label: "Minimum advice confidence to switch", kind: "number", min: 0, max: 1 },
+			...TIER_NAMES.map((t): FieldSpec => ({ path: `harnessSwitch.models.${t}`, label: `${t}: harness model (provider/id)`, kind: "string", optional: true, hint: "e.g. anthropic/claude-opus-4-8" })),
+		],
+	},
 	{
 		title: "Ledger",
 		fields: [

package/src/config/defaults.ts

@@ -316,6 +316,12 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// One transcript message per day, at the first interactive session start.
 		dailySummary: true,
 	},
+	harnessSwitch: {
+		// Off: moving the harness's own model is a visible change the operator opts into.
+		enabled: false,
+		models: {},
+		minConfidence: 0.6,
+	},
 	budget: {
 		// No caps by default; at a configured ceiling, downgrade rather than fail.
 		onExceeded: "downgrade",

package/src/config/schema.ts

@@ -277,6 +277,13 @@ export const configInputSchema = z.strictObject({
 	budget: budget.optional(),
 	profiles: z.array(profile).optional(),
 	report: z.strictObject({ baselines: z.array(z.string()).optional(), dailySummary: z.boolean().optional() }).optional(),
+	harnessSwitch: z
+		.strictObject({
+			enabled: z.boolean().optional(),
+			models: z.record(tier, z.string().regex(/^[^/]+\/.+$/, "provider/id")).optional(),
+			minConfidence: z.number().min(0).max(1).optional(),
+		})
+		.optional(),
 	digest: z
 		.strictObject({
 			enabled: z.boolean().optional(),

package/src/config/types.ts

@@ -607,6 +607,25 @@ export interface ReportConfig {
 	dailySummary: boolean;
 }
 
+/**
+ * Harness-side model switch (experimental): the router advises a tier for
+ * each user prompt and the harness moves its own active model to a
+ * harness-native one for the mapped tiers. See omp-extension/router-switch.ts.
+ */
+export interface HarnessSwitchConfig {
+	enabled: boolean;
+	/**
+	 * Tier → harness model as `provider/id` in the harness's own registry
+	 * (e.g. `hard: anthropic/claude-opus-4-8`). A tier serves itself and every
+	 * tier above it up to the next mapped one; unmapped low tiers stay on the
+	 * router. Turns on a native model bill the harness's own provider (a
+	 * subscription, typically) and never reach the ledger.
+	 */
+	models: Partial<Record<"trivial" | "simple" | "moderate" | "hard", string>>;
+	/** Advice below this heuristic confidence leaves the model where it is. */
+	minConfidence: number;
+}
+
 export interface BudgetConfig {
 	/** Reject or downgrade when a turn's cold forecast exceeds this, USD. */
 	perTurnUsd?: number;
@@ -802,6 +821,7 @@ export interface RouterConfig {
 	budget: BudgetConfig;
 	report: ReportConfig;
 	digest: DigestConfig;
+	harnessSwitch: HarnessSwitchConfig;
 	profiles: ProfileConfig[];
 	ledger: LedgerConfig;
 	/**

package/src/server/advise.ts

@@ -0,0 +1,82 @@
+/**
+ * Harness-side model switch: the router advises a tier for a prompt BEFORE
+ * the harness dispatches it, so the harness can move its active model to one
+ * the router cannot proxy (a Claude subscription model, say) for hard work
+ * and back to the router for the rest.
+ *
+ * Why this shape: proxying a subscription upstream would mean translating
+ * the OpenAI wire to that provider's and carrying its OAuth token through a
+ * third-party process. Advising is cheaper and keeps the token where it
+ * belongs. The cost of a native turn lands on the subscription, not the
+ * ledger; the router only sees the turns it serves.
+ *
+ * The advice is the heuristic classifier over the user's prompt text alone
+ * (the harness has not built the request yet), plus the session's last
+ * routed tier for context. No adjudicator call, no dispatch, nothing recorded.
+ */
+
+import type { RouterConfig } from "../config/types.ts";
+import type { Ledger } from "../cost/types.ts";
+import { scoreHeuristic } from "../router/classify.ts";
+import { extractFeatures } from "../router/features.ts";
+import { estimateTokens } from "../tokens/estimate.ts";
+import type { TaskType, Tier } from "../router/types.ts";
+import type { NormRequest } from "../wire/types.ts";
+
+export interface AdviseRequest {
+	ompSessionId: string;
+	harnessId: string;
+	/** The user's prompt as submitted. */
+	text: string;
+}
+
+export interface Advice {
+	tier: Tier;
+	task: TaskType;
+	confidence: number;
+	score: number;
+	reasons: string[];
+	/** The tier this session's last routed turn ran at, when the router served one. */
+	lastTier: Tier | null;
+}
+
+const SYSTEM_STUB = "You are a coding agent.";
+
+function requestOf(req: AdviseRequest): NormRequest {
+	const text = req.text;
+	return {
+		protocol: "openai-chat",
+		conversationKey: `advise:${req.ompSessionId}`,
+		harnessId: req.harnessId,
+		ompSessionId: req.ompSessionId,
+		agentdoxScope: "",
+		isSubagent: false,
+		requestedModel: "auto",
+		messages: [
+			{ role: "system", text: SYSTEM_STUB, images: 0, textBytes: Buffer.byteLength(SYSTEM_STUB), toolCalls: [] },
+			{ role: "user", text, images: 0, textBytes: Buffer.byteLength(text), toolCalls: [] },
+		],
+		tools: [],
+		forcedToolChoice: false,
+		stream: false,
+		hasImages: false,
+		promptBytes: Buffer.byteLength(SYSTEM_STUB) + Buffer.byteLength(text),
+		renderUpstreamBody: () => ({}),
+	};
+}
+
+/** Classifies a prompt the way the first turn of a conversation would be, without dispatching anything. */
+export function advise(cfg: RouterConfig, ledger: Ledger | null, req: AdviseRequest): Advice {
+	const norm = requestOf(req);
+	const features = extractFeatures(norm, estimateTokens(norm.promptBytes, "unknown", ledger));
+	const cls = scoreHeuristic(features, cfg);
+	const last = req.ompSessionId === "" ? null : (ledger?.latestForSession?.(req.ompSessionId)?.tier ?? null);
+	return {
+		tier: cls.tier,
+		task: cls.task,
+		confidence: cls.confidence,
+		score: cls.score,
+		reasons: cls.reasons,
+		lastTier: last === null ? null : (last as Tier),
+	};
+}

package/src/server/http.ts

@@ -7,6 +7,7 @@ import { createFeedbackStore, type Verdict } from "../cost/feedback.ts";
 import { createLedger } from "../cost/ledger.ts";
 import { createSessionOverrides } from "./overrides.ts";
 import { createDigester } from "./digest.ts";
+import { advise } from "./advise.ts";
 import { TIER_ORDER, type Tier } from "../router/types.ts";
 import { baselinePrices, buildUsageReport } from "../cost/report.ts";
 import { buildDailySummary, createKv, markSummaryShown, summaryDue, summaryHasNews, type SummaryOllama } from "../cost/summary.ts";
@@ -415,6 +416,25 @@ export function startServer(cfg: RouterConfig): StartedServer {
 					const harnessId = url.searchParams.get("harness") ?? "";
 					return json(buildUsageReport(db, { windowDays, harnessId, baselines: baselinePrices(cfg.report.baselines, (s) => catalog.find(s)) }));
 				}
+				if (req.method === "GET" && url.pathname === "/v1/router/advise/policy") {
+					const h = cfg.harnessSwitch;
+					return json({ enabled: h.enabled, models: h.models, minConfidence: h.minConfidence });
+				}
+				if (req.method === "POST" && url.pathname === "/v1/router/advise") {
+					// Harness-side switch: classify a prompt before the harness builds
+					// the request. Heuristic only; nothing is dispatched or recorded.
+					const body = (await req.json().catch(() => null)) as Record<string, unknown> | null;
+					if (body === null || typeof body.text !== "string") {
+						return wireErrorResponse({ status: 400, code: "invalid_request_error", message: "text required" });
+					}
+					return json(
+						advise(cfg, ledger, {
+							ompSessionId: typeof body.ompSessionId === "string" ? body.ompSessionId : "",
+							harnessId: typeof body.harnessId === "string" ? body.harnessId : "",
+							text: body.text.slice(0, 16_000),
+						}),
+					);
+				}
 				if (req.method === "GET" && url.pathname === "/v1/router/summary") {
 					// The last 24 hours in a few lines. `auto=1` is the session-start
 					// caller: it gets `due: false` unless report.dailySummary is on, no

package/test/config-wizard.test.ts

@@ -172,6 +172,7 @@ describe("WIZARD_SECTIONS coverage", () => {
 			]),
 			...["coding", "vision", "documentation", "data", "chat"].flatMap((t) => [`tasks.${t}.minQuality`, `tasks.${t}.requireImage`, `tasks.${t}.prefer`]),
 			...["trivial", "simple", "moderate", "hard"].map((t) => `exploration.rates.${t}`),
+			...["trivial", "simple", "moderate", "hard"].map((t) => `harnessSwitch.models.${t}`),
 		]);
 		const known = new Set(leaves(DEFAULT_CONFIG));
 		const unknown = WIZARD_SECTIONS.flatMap((s) => s.fields.map((f) => f.path)).filter((p) => !known.has(p) && !KNOWN_OPTIONAL.has(p));

package/test/failover.test.ts

@@ -77,6 +77,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		compaction: { enabled: false, budgetTokens: 40_000, floorRatio: 1, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true, replanGrowthRatio: 1, digestToolResults: false, digestMaxPerTurn: 2 },
 		budget: { onExceeded: "downgrade" },
 		report: { baselines: [], dailySummary: false },
+		harnessSwitch: { enabled: false, models: {}, minConfidence: 0.6 },
 		digest: { enabled: false, minBytes: 12_000, maxBytes: 400_000, tools: ["read"], fromTier: "moderate", tier: "simple", model: "", maxOutputTokens: 700, maxCostUsd: 0.02, timeoutMs: 25_000 },
 		profiles: [],
 		ledger: { path: ":memory:", blendWindowDays: 7, blendMinSamples: 20, fallbackBlend: { inputPerMtok: 1, outputPerMtok: 4 }, conversationTtlMs: 86_400_000 , retentionDays: 0,},

package/test/harness-switch.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test";
+
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
+import { TIER_ORDER } from "../src/router/types.ts";
+import { advise } from "../src/server/advise.ts";
+import { decideSwitch, nativeModelFor, parseSwitchPolicy, type SwitchPolicy } from "../omp-extension/switch-logic.ts";
+
+/**
+ * Harness-side model switch: the router's prompt-only advice, and the
+ * extension's decision about moving omp's active model.
+ */
+
+describe("advise", () => {
+	test("classifies a prompt without a ledger or dispatch and reports the shape the extension reads", () => {
+		const a = advise(DEFAULT_CONFIG, null, { ompSessionId: "s", harnessId: "", text: "Redesign the routing pipeline so escalation and failover share one retry loop; consider cache costs and write the migration plan." });
+		expect(TIER_ORDER).toContain(a.tier);
+		expect(a.confidence).toBeGreaterThanOrEqual(0);
+		expect(a.confidence).toBeLessThanOrEqual(1);
+		expect(a.reasons.length).toBeGreaterThan(0);
+		expect(a.lastTier).toBeNull();
+		const terse = advise(DEFAULT_CONFIG, null, { ompSessionId: "", harnessId: "", text: "ok" });
+		expect(TIER_ORDER.indexOf(terse.tier)).toBeLessThanOrEqual(TIER_ORDER.indexOf(a.tier));
+	});
+});
+
+describe("switch policy", () => {
+	test("parses defensively and maps a tier to the nearest configured tier at or below it", () => {
+		expect(parseSwitchPolicy(null).enabled).toBe(false);
+		const p = parseSwitchPolicy({ enabled: true, models: { moderate: "anthropic/claude-sonnet-5", hard: "anthropic/claude-opus-4-8", simple: "no-slash" }, minConfidence: 0.5 });
+		expect(p.models).toEqual({ moderate: "anthropic/claude-sonnet-5", hard: "anthropic/claude-opus-4-8" });
+		expect(nativeModelFor(p, "hard")).toBe("anthropic/claude-opus-4-8");
+		expect(nativeModelFor(p, "moderate")).toBe("anthropic/claude-sonnet-5");
+		expect(nativeModelFor(p, "simple")).toBeUndefined();
+		expect(nativeModelFor(p, "trivial")).toBeUndefined();
+	});
+});
+
+describe("decideSwitch", () => {
+	const policy: SwitchPolicy = { enabled: true, models: { hard: "anthropic/claude-opus-4-8" }, minConfidence: 0.6 };
+	const router = "auto-model-router/auto";
+
+	test("moves up from the router for confident hard work, back for lighter work, and never past a manual choice", () => {
+		const up = decideSwitch({ policy, advised: { tier: "hard", confidence: 0.8 }, active: router, activeIsRouter: true, switchedTo: null, returnTo: null });
+		expect(up).toMatchObject({ action: "up", model: "anthropic/claude-opus-4-8" });
+		// Low confidence: stay.
+		expect(decideSwitch({ policy, advised: { tier: "hard", confidence: 0.3 }, active: router, activeIsRouter: true, switchedTo: null, returnTo: null }).action).toBe("none");
+		// Unmapped tier while on the router: stay.
+		expect(decideSwitch({ policy, advised: { tier: "moderate", confidence: 0.9 }, active: router, activeIsRouter: true, switchedTo: null, returnTo: null }).action).toBe("none");
+		// On our own switch, hard again: already there.
+		expect(decideSwitch({ policy, advised: { tier: "hard", confidence: 0.9 }, active: "anthropic/claude-opus-4-8", activeIsRouter: false, switchedTo: "anthropic/claude-opus-4-8", returnTo: router }).action).toBe("none");
+		// On our own switch, lighter work: back to the router model we left.
+		expect(decideSwitch({ policy, advised: { tier: "simple", confidence: 0.9 }, active: "anthropic/claude-opus-4-8", activeIsRouter: false, switchedTo: "anthropic/claude-opus-4-8", returnTo: router })).toMatchObject({ action: "back", model: router });
+		// The user chose a model by hand: leave it alone whatever the advice.
+		expect(decideSwitch({ policy, advised: { tier: "hard", confidence: 0.9 }, active: "openai/gpt-5", activeIsRouter: false, switchedTo: null, returnTo: null }).action).toBe("none");
+		expect(decideSwitch({ policy, advised: { tier: "trivial", confidence: 0.9 }, active: "openai/gpt-5", activeIsRouter: false, switchedTo: "anthropic/claude-opus-4-8", returnTo: router }).action).toBe("none");
+		// Disabled: nothing moves.
+		expect(decideSwitch({ policy: { ...policy, enabled: false }, advised: { tier: "hard", confidence: 0.9 }, active: router, activeIsRouter: true, switchedTo: null, returnTo: null }).action).toBe("none");
+	});
+});

package/test/turn.test.ts

@@ -77,6 +77,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		compaction: { enabled: false, budgetTokens: 40_000, floorRatio: 1, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true, replanGrowthRatio: 1, digestToolResults: false, digestMaxPerTurn: 2 },
 		budget: { onExceeded: "downgrade" },
 		report: { baselines: [], dailySummary: false },
+		harnessSwitch: { enabled: false, models: {}, minConfidence: 0.6 },
 		digest: { enabled: false, minBytes: 12_000, maxBytes: 400_000, tools: ["read"], fromTier: "moderate", tier: "simple", model: "", maxOutputTokens: 700, maxCostUsd: 0.02, timeoutMs: 25_000 },
 		profiles: [],
 		ledger: { path: ":memory:", blendWindowDays: 7, blendMinSamples: 20, fallbackBlend: { inputPerMtok: 1, outputPerMtok: 4 }, conversationTtlMs: 86_400_000 , retentionDays: 0,},