auto-model-router 0.7.0 → 0.7.2

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.7.0",
+    "version": "0.7.2",
     "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.7.0",
+      "version": "0.7.2",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -907,6 +907,7 @@ Each task (`coding`, `vision`, `documentation`, `data`, `chat`) is a
 | `minTrustSamples` | `12` | Attempts before trust is enforced. |
 | `trustScopedByHarness` | `false` | `true` = each harness reads only its own trust rows. |
 | `contextHeadroom` | `1.25` | Fraction of context kept free (a model must fit prompt × this). |
+| `reasoningCompletionFloor` | `512` | Smallest completion budget a **reasoning** model is dispatched with. A reasoning model spends the budget thinking before it answers, so a caller's tight cap (omp asks ~12 tokens for a conversation title) returns nothing: measured on `ollama/gpt-oss:20b`, which hit the cap having produced no content and cost a dead dispatch plus a failover. Raised only for models that reason, never above the model's own ceiling, and a cap is an upper bound so a direct answer still stops early. 0 disables. |
 | `latencyWeight` | `0` | How hard to penalise slow models in scoring (soft multiplier on effective cost). `0` disables it. |
 | `latencyMinSamples` | `20` | Streamed samples before latency is judged against a model. |
 | `cacheReliabilityMinSamples` | `10` | Warm-expected samples before a model's observed cache hit rate discounts its "stay warm" price in the stay/switch comparison. A model whose cache misses when it should be warm (measured: 5-6% on glm/gemini, 11% on ling, 50% on nex) is kept less eagerly. `0` assumes every cache is reliable. |
@@ -1296,10 +1297,21 @@ adds the Codex provider and the Aider settings, and prints (or with `--profile`
 the environment lines for Claude Code. `--harness omp,hermes` restricts it; `--dry-run`
 shows the changes. Delete `remote.json` to go back to a local router. (`join` is an alias.)
 
+`connect` also writes omp's `models.yml` (a managed block, other providers untouched, the
+previous file backed up). That entry is what makes `auto-model-router/auto` resolvable at
+**startup**: omp builds the main model's handle before extensions load, so without it only
+the late-resolved roles (`smol`, `tiny`) reach the router and the main turns fall back to
+whatever else is authenticated. A local router deliberately gets no such entry — its port
+is ephemeral, so a persisted one names a dead socket next launch — but a remote's URL and
+key are stable. **The file then holds the member key: treat it as a secret.**
+
 In remote mode omp sends `X-Agentdox-Scope` derived from the workspace folder, so one
 remote router serves every repo on the machine with that repo's shared context. The remote
 decides what to do with it: a team edition that pins a scope on the member's group
-overrides it, and one that pins none follows the workspace.
+overrides it, and one that pins none follows the workspace. That header rides on the roles
+the extensions register; the **main** model's handle comes from `models.yml`, which is
+machine-wide, so it carries a scope only if you pass `--scope <slug>` to `connect` — right
+for a single-project machine, wrong for one with several repos.
 
 ## Multiple coding harnesses, one router
 

package/package.json

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

package/src/cli/config-wizard.ts

@@ -189,6 +189,7 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ 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.reasoningCompletionFloor", label: "Reasoning completion floor", kind: "number", min: 0 },
 			{ 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" },

package/src/cli/connect.ts

@@ -4,7 +4,12 @@
  * `<router home>/remote.json` (the omp extensions then run in remote mode and
  * never bind a local router), and configures every harness it finds:
  *
- *   omp         the four extensions are added to ~/.omp/agent/config.yml
+ *   omp         the four extensions are added to ~/.omp/agent/config.yml, and
+ *               the remote is written into ~/.omp/agent/models.yml so
+ *               `auto-model-router/auto` resolves at STARTUP — omp builds the
+ *               main model's handle before extensions load, so without that
+ *               entry only the late-resolved roles (smol, tiny) reach the
+ *               router and the main turns fall back to another provider
  *   Hermes      the provider plugin and the native plugin are copied into
  *               $HERMES_HOME/plugins and .env points them at the remote
  *   Codex       ~/.codex/config.toml gains the auto-model-router provider
@@ -37,6 +42,10 @@ export interface ConnectOptions {
 	home: string;
 	/** Where this package lives (the extensions are referenced from here). */
 	packageDir: string;
+	/** Cost figures omp shows for the remote's virtual models, USD per million tokens. */
+	blend?: { inputPerMtok: number; outputPerMtok: number };
+	/** Adds `X-Agentdox-Scope` to omp's models.yml entry. Machine-wide: only for a single-project machine. */
+	agentdoxScope?: string;
 	platform: string;
 	pathHas: (bin: string) => boolean;
 }
@@ -103,6 +112,90 @@ http_headers = { "X-Omp-Harness" = "codex" }
 `;
 }
 
+/** The models a remote router advertises, and what omp should believe they cost. */
+const REMOTE_MODEL_ROWS: readonly { id: string; name: string }[] = [
+	{ id: "auto", name: "Auto (auto-model-router)" },
+	{ id: "auto-cheap", name: "Auto Cheap (auto-model-router)" },
+	{ id: "auto-max", name: "Auto Max (auto-model-router)" },
+];
+
+const MODELS_YML_BEGIN = "  # BEGIN auto-model-router (remote)";
+const MODELS_YML_END = "  # END auto-model-router (remote)";
+
+/**
+ * omp's `models.yml` entry for a remote router.
+ *
+ * A LOCAL router deliberately never writes this file: its port is ephemeral, so
+ * a persisted entry names a dead socket on the next launch. A remote router has
+ * neither problem — the URL and the key are stable — and the entry is what makes
+ * omp's main model resolvable at startup, before extensions load.
+ *
+ * `scope` adds `X-Agentdox-Scope` to every request through this provider. It is
+ * off by default on purpose: the file is machine-wide, so a scope here would
+ * label turns from every workspace with one project. The extensions still send
+ * the workspace's own scope on the roles that resolve after they load.
+ */
+export function renderRemoteModelsYml(url: string, key: string, blend: { inputPerMtok: number; outputPerMtok: number }, scope = ""): string {
+	const round = (v: number): number => Math.round(v * 1e4) / 1e4;
+	const cost = {
+		input: round(blend.inputPerMtok),
+		output: round(blend.outputPerMtok),
+		cacheRead: round(blend.inputPerMtok * 0.1),
+		cacheWrite: round(blend.inputPerMtok * 1.25),
+	};
+	const lines = [
+		MODELS_YML_BEGIN,
+		"  # Managed by `auto-model-router connect`. Remove this block to stop routing omp through the remote.",
+		"  auto-model-router:",
+		`    baseUrl: ${url.replace(/\/+$/, "")}/v1`,
+		"    api: openai-completions",
+		`    apiKey: ${key}`,
+	];
+	if (scope !== "") lines.push("    headers:", `      X-Agentdox-Scope: ${scope}`);
+	lines.push("    models:");
+	for (const m of REMOTE_MODEL_ROWS) {
+		lines.push(
+			`      - id: ${m.id}`,
+			`        name: ${m.name}`,
+			"        contextWindow: 200000",
+			"        maxTokens: 32000",
+			"        input: [text, image]",
+			`        cost: { input: ${cost.input}, output: ${cost.output}, cacheRead: ${cost.cacheRead}, cacheWrite: ${cost.cacheWrite} }`,
+		);
+	}
+	lines.push(MODELS_YML_END);
+	return lines.join("\n");
+}
+
+/**
+ * Merges the remote block into an existing `models.yml`, replacing a previous
+ * one and leaving every other provider alone. Returns the new file text.
+ */
+export function mergeModelsYml(before: string, blockText: string): string {
+	const eol = before.includes("\r\n") ? "\r\n" : "\n";
+	const body = before.replace(/^\uFEFF/, "");
+	const block = blockText.split("\n").join(eol);
+	const begin = body.indexOf(MODELS_YML_BEGIN);
+	if (begin >= 0) {
+		const endIdx = body.indexOf(MODELS_YML_END, begin);
+		const end = endIdx < 0 ? body.length : endIdx + MODELS_YML_END.length;
+		return `${body.slice(0, begin)}${block}${body.slice(end)}`;
+	}
+	// A provider entry for the same id from an earlier local install would shadow
+	// ours; the caller reports it rather than editing a block it does not own.
+	if (body.trim() === "") return `providers:${eol}${block}${eol}`;
+	if (/^providers:\s*$/m.test(body)) {
+		return body.replace(/^providers:\s*$/m, (m) => `${m}${eol}${block}`);
+	}
+	return `${body.replace(/\s*$/, "")}${eol}providers:${eol}${block}${eol}`;
+}
+
+/** True when the file already defines our provider outside a block we manage. */
+export function hasForeignRouterProvider(text: string): boolean {
+	if (text.includes(MODELS_YML_BEGIN)) return false;
+	return /^\s{2,}auto-model-router:\s*$/m.test(text);
+}
+
 export function connectRemote(o: ConnectOptions): ConnectReport {
 	const report: ConnectReport = { remoteFile: "", configured: [], skipped: [], envLines: [], notes: [] };
 	const write = (path: string, content: string): void => {
@@ -124,7 +217,22 @@ export function connectRemote(o: ConnectOptions): ConnectReport {
 		const before = existsSync(cfgPath) ? readFileSync(cfgPath, "utf8") : "";
 		const after = addExtensions(before, ext);
 		if (after !== before) write(cfgPath, after);
-		report.configured.push(`omp (${cfgPath}; pick auto-model-router/auto as the model)`);
+		// models.yml: what makes the MAIN model resolvable, since omp builds that
+		// handle at startup, before the extensions register anything.
+		const modelsPath = join(agentDir, "models.yml");
+		const modelsBefore = existsSync(modelsPath) ? readFileSync(modelsPath, "utf8") : "";
+		if (hasForeignRouterProvider(modelsBefore)) {
+			report.notes.push(`${modelsPath} already defines an auto-model-router provider by hand; left alone — remove it to let connect manage the remote entry`);
+			report.configured.push(`omp (${cfgPath}; extensions only)`);
+		} else {
+			const modelsAfter = mergeModelsYml(modelsBefore, renderRemoteModelsYml(o.url, o.key, o.blend ?? { inputPerMtok: 1.1, outputPerMtok: 4.4 }, o.agentdoxScope ?? ""));
+			if (modelsAfter !== modelsBefore) {
+				// Never overwrite another provider's work without a way back.
+				if (modelsBefore !== "" && !o.dryRun) writeFileSync(`${modelsPath}.${new Date().toISOString().replaceAll(":", "-")}.bak`, modelsBefore, "utf8");
+				write(modelsPath, modelsAfter);
+			}
+			report.configured.push(`omp (${cfgPath} + ${modelsPath}; auto-model-router/auto is ready to pick)`);
+		}
 	} else report.skipped.push("omp (no ~/.omp/agent)");
 
 	// 3. Hermes
@@ -183,6 +291,7 @@ export function connectRemote(o: ConnectOptions): ConnectReport {
 			report.notes.push(`environment appended to ${rc}; open a new shell or source it`);
 		}
 	} else report.notes.push("add the environment lines to your shell profile, or re-run with --profile");
+	report.notes.push("omp's models.yml now carries the member key; treat that file as a secret");
 	return report;
 }
 
@@ -205,7 +314,10 @@ export async function connectCommand(args: CliArgs): Promise<void> {
 	}
 	// HOME wins when set (Git Bash, WSL, CI) so a caller can redirect every write; the OS profile otherwise.
 	const home = process.env.HOME !== undefined && process.env.HOME !== "" ? process.env.HOME : homedir();
-	const report = connectRemote({ url, key, userId, name, profile: args.flags.has("profile"), dryRun: args.flags.has("dry-run"), only, env: process.env, home, packageDir, platform: process.platform, pathHas });
+	// A single-project machine can label every request; a machine with several
+	// repos should leave it off and let the extensions send the workspace's own.
+	const agentdoxScope = flagString(args, "scope") ?? "";
+	const report = connectRemote({ url, key, userId, name, profile: args.flags.has("profile"), dryRun: args.flags.has("dry-run"), only, env: process.env, home, packageDir, platform: process.platform, pathHas, agentdoxScope });
 	console.log(`${args.flags.has("dry-run") ? "would write" : "wrote"} ${report.remoteFile}${name === "" ? "" : ` for ${name}`}`);
 	for (const c of report.configured) console.log(`  configured ${c}`);
 	for (const s of report.skipped) console.log(`  skipped    ${s}`);

package/src/config/defaults.ts

@@ -114,6 +114,10 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// opt-in after a replay run prices it.
 		trustWindowDays: 0,
 		contextHeadroom: 1.25,
+		// Enough for a short chain of thought plus a brief answer. Measured against
+		// the failure it fixes: gpt-oss:20b and nemotron-3-nano returned empty at a
+		// 12-token cap, then failed over.
+		reasoningCompletionFloor: 512,
 		// Latency scoring is off by default (weight 0): opt in after establishing a
 		// baseline. Expected total wait (TTFT + expected completion / throughput)
 		// above the references inflates a model's effective cost.

package/src/config/schema.ts

@@ -95,6 +95,7 @@ const filters = z.strictObject({
 	trustScopedByHarness: z.boolean().optional(),
 	trustWindowDays: z.number().nonnegative().optional(),
 	contextHeadroom: z.number().positive().optional(),
+	reasoningCompletionFloor: z.number().int().nonnegative().optional(),
 	latencyWeight: z.number().nonnegative().optional(),
 	latencyReferenceMs: z.number().positive().optional(),
 	latencyReferenceTokensPerSec: z.number().positive().optional(),

package/src/config/types.ts

@@ -221,6 +221,21 @@ export interface FilterConfig {
 	includeFree: boolean;
 	/** Require `supported_parameters` to include `tools` whenever the request offers tools. */
 	requireToolSupport: boolean;
+	/**
+	 * Smallest completion budget a REASONING model is dispatched with, tokens.
+	 *
+	 * A reasoning model spends the budget thinking before it answers, so a
+	 * caller's tight cap returns nothing at all: omp asks for ~12 tokens for a
+	 * conversation title, and `ollama/gpt-oss:20b` hit the cap having produced
+	 * no content, which cost a dead dispatch and a failover to another model.
+	 * When the chosen model reasons and the caller asked for less than this, the
+	 * dispatch is raised to this floor (never above the model's own completion
+	 * ceiling). Models that answer directly keep the caller's cap.
+	 *
+	 * A cap is an upper bound, not a target — a model that answers in ten tokens
+	 * still stops at ten. 0 disables the floor.
+	 */
+	reasoningCompletionFloor: number;
 	/** Drop models whose ledger success rate is below this, once `minTrustSamples` is met. */
 	minTrust: number;
 	/**

package/src/index.ts

@@ -26,7 +26,7 @@ Usage: auto-model-router <command> [options]
   stats      Show routed spend, per-model share, and escalation rates
   report     Usage analytics: providers, models, tiers, cost, speed, cache hit rate
   export     One row per day, harness and model as CSV (--json for rows)
-  connect    Point this machine at a remote router (--url, --key; --profile persists the environment)
+  connect    Point this machine at a remote router (--url, --key; --scope labels a single-project machine; --profile persists the environment)
   models     Show what each complexity tier would consider, and why
   explain    Route a saved request without dispatching it, and explain the decision
   config     Interactive wizard over the router's own config.yml

package/src/router/select.ts

@@ -608,6 +608,18 @@ export function select(args: SelectArgs): Decision {
 		// The ceiling is a hard limit anyway; passing it explicitly also caps runaway completions.
 		maxTokens = maxTokens === undefined ? ceiling : Math.min(maxTokens, ceiling);
 	}
+	// A reasoning model spends the budget thinking before it answers, so a caller's
+	// tight cap returns nothing and the turn fails over having paid for the dispatch.
+	// Raise it to the floor for those models only; the ceiling still wins.
+	const floor = cfg.filters.reasoningCompletionFloor;
+	const thinksBeforeAnswering = chosen.model.reasoningMandatory || (chosen.model.supportsReasoning && reasoning !== "off");
+	if (floor > 0 && thinksBeforeAnswering && maxTokens !== undefined && maxTokens < floor) {
+		const raised = ceiling === undefined ? floor : Math.min(floor, ceiling);
+		if (raised > maxTokens) {
+			reasons.push(`completion budget raised ${maxTokens} → ${raised}: ${chosen.model.slug} reasons before it answers`);
+			maxTokens = raised;
+		}
+	}
 	const stripAssistantReasoning = !(chosen.model.supportsReasoning && REASONING_REPLAY_AUTHORS[chosen.model.author] === true);
 
 	// The recorded forecast is the EXPECTED price of this dispatch, not the

package/src/server/turn.ts

@@ -93,13 +93,21 @@ function lastUserText(req: NormRequest): string {
 	return "";
 }
 
-/** Session title: the conversation's opening ask, truncated. */
+/**
+ * Session title: the conversation's opening ask, truncated.
+ *
+ * Read through `userContent`, the same filter the recorded user message uses:
+ * a harness wraps the first message in reminders (omp opens with a
+ * `<system-reminder>` naming the date and cwd), and titling a session with that
+ * wrapper both reads as noise in agentdox and is re-injected into later context
+ * assembly, which lists session titles.
+ */
 function sessionTitle(req: NormRequest): string {
 	for (const m of req.messages) {
-		if (m.role === "user" && m.text.trim() !== "") {
-			const t = m.text.trim().replace(/\s+/g, " ");
-			return t.length > 80 ? `${t.slice(0, 79)}…` : t;
-		}
+		if (m.role !== "user") continue;
+		const t = userContent(m.text);
+		if (t === "") continue;
+		return t.length > 80 ? `${t.slice(0, 79)}…` : t;
 	}
 	return `omp ${req.conversationKey.slice(0, 8)}`;
 }

package/test/failover.test.ts

@@ -46,7 +46,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			data: { axis: "intelligence", minQuality: 0 },
 			chat: { axis: "intelligence", minQuality: 0 },
 		},
-		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, feedbackWeight: 0, feedbackByTask: false, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
+		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, feedbackWeight: 0, feedbackByTask: false, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, reasoningCompletionFloor: 0, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
 		classifier: {
 			ambiguityThreshold: 0,
 			model: "test/adjudicator", learnedModelPath: "",

package/test/remote.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 
 import { addExtensions, codexBlock, connectRemote, setDotenv, type ConnectOptions } from "../src/cli/connect.ts";
 import { parseRemoteRouter, readRemoteRouter, remoteProviderRegistration } from "../omp-extension/remote-logic.ts";
+import { hasForeignRouterProvider, mergeModelsYml, renderRemoteModelsYml } from "../src/cli/connect.ts";
 
 /**
  * Remote mode: remote.json puts the omp extensions on a router elsewhere,
@@ -102,3 +103,47 @@ describe("connect", () => {
 		rmSync(h2, { recursive: true, force: true });
 	});
 });
+
+describe("omp models.yml for a remote router", () => {
+	const BLEND = { inputPerMtok: 1.1, outputPerMtok: 4.4 };
+	const NL = String.fromCharCode(10);
+	const yaml = (...lines: string[]): string => lines.join(NL) + NL;
+
+	test("the block names the remote, the key and the three virtual models; a scope is opt-in", () => {
+		const block = renderRemoteModelsYml("https://team.example/", "amrt_k", BLEND);
+		expect(block).toContain("baseUrl: https://team.example/v1");
+		expect(block).toContain("apiKey: amrt_k");
+		expect(block).toContain("- id: auto");
+		expect(block).toContain("- id: auto-cheap");
+		expect(block).toContain("- id: auto-max");
+		expect(block).toContain("cost: { input: 1.1, output: 4.4, cacheRead: 0.11, cacheWrite: 1.375 }");
+		// Machine-wide file: no scope unless the caller asks for one.
+		expect(block).not.toContain("X-Agentdox-Scope");
+		expect(renderRemoteModelsYml("https://team.example", "k", BLEND, "omp-router")).toContain("X-Agentdox-Scope: omp-router");
+	});
+
+	test("merging keeps other providers, replaces our own block, and is idempotent", () => {
+		const block = renderRemoteModelsYml("https://team.example", "k1", BLEND);
+		const empty = mergeModelsYml("", block);
+		expect(empty.startsWith("providers:")).toBe(true);
+		expect(mergeModelsYml(empty, block)).toBe(empty);
+
+		const existing = yaml("providers:", "  openai:", "    apiKey: sk-x");
+		const merged = mergeModelsYml(existing, block);
+		expect(merged).toContain("openai:");
+		expect(merged).toContain("baseUrl: https://team.example/v1");
+
+		// A later connect with a new key replaces the block in place, not a second copy.
+		const rekeyed = mergeModelsYml(merged, renderRemoteModelsYml("https://team.example", "k2", BLEND));
+		expect(rekeyed).toContain("apiKey: k2");
+		expect(rekeyed).not.toContain("apiKey: k1");
+		expect(rekeyed.match(/auto-model-router:/g)).toHaveLength(1);
+		expect(rekeyed).toContain("openai:");
+	});
+
+	test("a hand-written provider of the same name is left alone", () => {
+		expect(hasForeignRouterProvider(yaml("providers:", "  auto-model-router:", "    baseUrl: http://127.0.0.1:1/v1"))).toBe(true);
+		expect(hasForeignRouterProvider(mergeModelsYml("", renderRemoteModelsYml("https://t", "k", BLEND)))).toBe(false);
+		expect(hasForeignRouterProvider(yaml("providers:", "  openai: {}"))).toBe(false);
+	});
+});

package/test/select.test.ts

@@ -82,9 +82,11 @@ function run(opts: {
 	tier?: Tier;
 	ledger?: Ledger | null;
 	harnessId?: string;
+	maxTokens?: number;
 }) {
 	const cfg = opts.cfg ?? BASE;
-	const req = request(opts.userText ?? "tidy the retry helper");
+	const base = request(opts.userText ?? "tidy the retry helper");
+	const req = opts.maxTokens === undefined ? base : { ...base, maxTokens: opts.maxTokens };
 	const features = extractFeatures(req, opts.promptTokens ?? 4000);
 	const heuristic = scoreHeuristic(features, cfg);
 	const classification = opts.tier === undefined ? heuristic : { ...heuristic, tier: opts.tier };
@@ -353,6 +355,31 @@ describe("decision shape", () => {
 		}
 	});
 
+	test("a reasoning model gets the completion floor; a direct one keeps the caller's cap", () => {
+		const usable = (m: (typeof MODELS)[number]): boolean => m.supportsTools && m.contextLength >= 32_000 && (m.maxCompletionTokens ?? 100_000) >= 4096;
+		const thinker = MODELS.find((m) => usable(m) && m.supportsReasoning);
+		const direct = MODELS.find((m) => usable(m) && !m.supportsReasoning && !m.reasoningMandatory);
+		expect(thinker).toBeDefined();
+		expect(direct).toBeDefined();
+		const withFloor = (slug: string, floor: number): RouterConfig => ({ ...BASE, filters: { ...BASE.filters, allow: [slug], reasoningCompletionFloor: floor } });
+
+		// omp asks for a dozen tokens for a title; a reasoning model would spend them thinking
+		// and return nothing, so the dispatch is raised.
+		const raised = run({ tier: "trivial", cfg: withFloor(thinker!.slug, 512), maxTokens: 12 });
+		expect(raised.slug).toBe(thinker!.slug);
+		expect(raised.maxTokens).toBe(512);
+		expect(raised.reasons.some((r) => r.includes("reasons before it answers"))).toBe(true);
+
+		// A model that answers directly is untouched: its cap is the caller's.
+		const kept = run({ tier: "trivial", cfg: withFloor(direct!.slug, 512), maxTokens: 12 });
+		expect(kept.slug).toBe(direct!.slug);
+		expect(kept.maxTokens).toBe(12);
+
+		// The floor never raises past what the caller already asked for, and 0 disables it.
+		expect(run({ tier: "trivial", cfg: withFloor(thinker!.slug, 512), maxTokens: 4000 }).maxTokens).toBe(4000);
+		expect(run({ tier: "trivial", cfg: withFloor(thinker!.slug, 0), maxTokens: 12 }).maxTokens).toBe(12);
+	});
+
 	test("plans a probe for cheap tiers and leaves the top tier unprobed", () => {
 		expect(run({ tier: "trivial" }).probe.enabled).toBe(true);
 		// Nothing above `hard` to escalate into, so probing it would only add latency.

package/test/turn.test.ts

@@ -46,7 +46,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			data: { axis: "intelligence", minQuality: 0 },
 			chat: { axis: "intelligence", minQuality: 0 },
 		},
-		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, feedbackWeight: 0, feedbackByTask: false, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
+		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, feedbackWeight: 0, feedbackByTask: false, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, reasoningCompletionFloor: 0, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
 		classifier: {
 			ambiguityThreshold: 0,
 			model: "test/adjudicator", learnedModelPath: "",