auto-model-router 0.2.32 → 0.3.0

package/test/configure-logic.test.ts

@@ -3,7 +3,7 @@ import { describe, expect, test } from "bun:test";
 import { WIZARD_SECTIONS } from "../src/cli/config-wizard.ts";
 import type { FieldSpec } from "../src/cli/config-wizard.ts";
 
-import { editProfile, walkSection, type ConfigUi } from "../omp-extension/configure-logic.ts";
+import { editProfile, editSectionMenu, walkSection, type ConfigUi, type SelectOption } from "../omp-extension/configure-logic.ts";
 
 function makeUi(script: Array<{ type: "select" | "input" | "confirm"; value?: string | boolean | undefined }>): ConfigUi {
 	const calls = script.slice();
@@ -14,7 +14,7 @@ function makeUi(script: Array<{ type: "select" | "input" | "confirm"; value?: st
 			if (call.value === undefined) return undefined;
 			return call.value as string;
 		},
-		async input(_title, _placeholder, _initial) {
+		async input(_title, _placeholder) {
 			const call = calls.shift();
 			if (call?.type !== "input") throw new Error("expected input, got " + JSON.stringify(call));
 			if (call.value === undefined) return undefined;
@@ -28,6 +28,19 @@ function makeUi(script: Array<{ type: "select" | "input" | "confirm"; value?: st
 		notify(_text, _level) {},
 	};
 }
+/** One "keep" answer per field of a section, with overrides by dotted path. */
+function keepAll(section: { fields: readonly FieldSpec[] }, overrides: Record<string, string> = {}) {
+	return section.fields.map((f) => {
+		const value = overrides[f.path] ?? "";
+		if (f.kind === "boolean" || f.kind === "enum") {
+			// A cancelled select aborts the walk, so an optional boolean keeps
+			// "unset" and everything else must be given a value by the caller.
+			return { type: "select" as const, value: value !== "" ? value : f.kind === "boolean" && f.optional === true ? "unset" : undefined };
+		}
+		return { type: "input" as const, value };
+	});
+}
+
 const baseCfg = {
 	server: { host: "127.0.0.1", port: 8788, apiKey: undefined, harnessId: undefined },
 	openrouter: {
@@ -55,12 +68,7 @@ const serverSection = WIZARD_SECTIONS.find((s) => s.title === "Server")!;
 
 describe("promptField via walkSection", () => {
 	test("empty answer keeps the current value (no change)", async () => {
-		const ui = makeUi([
-			{ type: "input", value: "" }, // keep host
-			{ type: "input", value: "" }, // keep port
-			{ type: "input", value: "" }, // keep apiKey
-			{ type: "input", value: "" }, // keep harnessId
-		]);
+		const ui = makeUi(keepAll(serverSection));
 		const answers: Record<string, unknown> = {};
 		const changed = await walkSection(ui, serverSection, baseCfg, answers);
 		expect(changed).toBe(false);
@@ -68,12 +76,7 @@ describe("promptField via walkSection", () => {
 	});
 
 	test("an edit is collected under its dotted path", async () => {
-		const ui = makeUi([
-			{ type: "input", value: "127.0.0.2" }, // host
-			{ type: "input", value: "" }, // keep port
-			{ type: "input", value: "" }, // keep apiKey
-			{ type: "input", value: "" }, // keep harnessId
-		]);
+		const ui = makeUi(keepAll(serverSection, { "server.host": "127.0.0.2" }));
 		const answers: Record<string, unknown> = {};
 		const changed = await walkSection(ui, serverSection, baseCfg, answers);
 		expect(changed).toBe(true);
@@ -89,12 +92,7 @@ describe("promptField via walkSection", () => {
 	});
 
 	test("CLEAR_TOKEN clears an optional field to null", async () => {
-		const ui = makeUi([
-			{ type: "input", value: "" }, // host
-			{ type: "input", value: "" }, // port
-			{ type: "input", value: "-" }, // clear apiKey
-			{ type: "input", value: "" }, // harnessId
-		]);
+		const ui = makeUi(keepAll(serverSection, { "server.apiKey": "-" }));
 		const answers: Record<string, unknown> = {};
 		const changed = await walkSection(ui, serverSection, baseCfg, answers);
 		expect(changed).toBe(true);
@@ -102,22 +100,120 @@ describe("promptField via walkSection", () => {
 	});
 
 	test("boolean fields use the select dialog", async () => {
-		const adaptive = WIZARD_SECTIONS.find((s) => s.title === "Tiers")!;
-		const ui = makeUi([
-			{ type: "select", value: "false" }, // adaptiveTierFloors
-			{ type: "input", value: "" }, // trivial minQuality
-			{ type: "input", value: "" }, // trivial maxInputPerMtok
-			{ type: "input", value: "" }, // simple minQuality
-			{ type: "input", value: "" }, // simple maxInputPerMtok
-			{ type: "input", value: "" }, // moderate minQuality
-			{ type: "input", value: "" }, // moderate maxInputPerMtok
-			{ type: "input", value: "" }, // hard minQuality
-			{ type: "input", value: "" }, // hard maxInputPerMtok
-		]);
+		const tiers = WIZARD_SECTIONS.find((s) => s.title === "Tiers")!;
+		// Booleans and enums prompt through select; a cancelled select would
+		// abort, so every boolean/enum in the section is answered with its
+		// current value except the one under test.
+		const script = keepAll(tiers, { adaptiveTierFloors: "false", adaptivePriceCeilings: "false" });
+		for (const call of script) if (call.type === "select" && call.value === undefined) call.value = "false";
+		const ui = makeUi(script);
 		const answers: Record<string, unknown> = {};
-		await walkSection(ui, adaptive, baseCfg, answers);
+		await walkSection(ui, tiers, { ...(baseCfg as object), adaptivePriceCeilings: false } as never, answers);
 		expect(answers).toEqual({ adaptiveTierFloors: false });
 	});
+
+	test("an optional boolean can be cleared back to unset", async () => {
+		const field: FieldSpec = { path: "tiers.hard.qualityNormalization", label: "norm", kind: "boolean", optional: true };
+		const section = { title: "t", fields: [field] };
+		const answers: Record<string, unknown> = {};
+		await walkSection(makeUi([{ type: "select", value: "unset" }]), section, { tiers: { hard: { qualityNormalization: true } } } as never, answers);
+		expect(answers).toEqual({ "tiers.hard.qualityNormalization": null });
+		const none: Record<string, unknown> = {};
+		await walkSection(makeUi([{ type: "select", value: "unset" }]), section, { tiers: { hard: {} } } as never, none);
+		expect(none).toEqual({});
+	});
+
+	test("re-entering an unchanged array is not an edit", async () => {
+		const field: FieldSpec = { path: "filters.deny", label: "deny", kind: "stringArray" };
+		const section = { title: "t", fields: [field] };
+		const answers: Record<string, unknown> = {};
+		const changed = await walkSection(makeUi([{ type: "input", value: "a, b" }]), section, { filters: { deny: ["a", "b"] } } as never, answers);
+		expect(changed).toBe(false);
+		expect(answers).toEqual({});
+	});
+
+	test("a secret field is prompted with set/unset, never its value", async () => {
+		const field: FieldSpec = { path: "openrouter.apiKey", label: "key", kind: "string", optional: true, secret: true };
+		const placeholders: string[] = [];
+		const ui: ConfigUi = {
+			async select() { return undefined; },
+			async input(_t, placeholder) { placeholders.push(placeholder ?? ""); return ""; },
+			async confirm() { return false; },
+			notify() {},
+		};
+		await walkSection(ui, { title: "t", fields: [field] }, { openrouter: { apiKey: "sk-secret" } } as never, {});
+		expect(placeholders[0]).toStartWith("set  (");
+		expect(placeholders[0]).not.toContain("sk-secret");
+	});
+});
+
+describe("current value is visible in every dialog", () => {
+	/** A UI that records what each dialog showed and answers from a script. */
+	function recordingUi(script: Array<string | undefined>) {
+		const shown: { title: string; options?: SelectOption[]; placeholder?: string }[] = [];
+		const ui: ConfigUi = {
+			async select(title, options) { shown.push({ title, options }); return script.shift(); },
+			async input(title, placeholder) { shown.push({ title, ...(placeholder === undefined ? {} : { placeholder }) }); return script.shift(); },
+			async confirm() { return false; },
+			notify() {},
+		};
+		return { ui, shown };
+	}
+	const cfg = { server: { host: "127.0.0.1", port: 8788 }, budget: { onExceeded: "downgrade" }, cache: { injectBreakpoints: true } } as never;
+
+	test("text prompts carry the current value in the title and placeholder", async () => {
+		const { ui, shown } = recordingUi([""]);
+		const field: FieldSpec = { path: "server.port", label: "Listen port", kind: "number", min: 1, max: 65535 };
+		await walkSection(ui, { title: "Server", fields: [field] }, cfg, {});
+		expect(shown[0]?.title).toBe("Listen port · current: 8788");
+		expect(shown[0]?.placeholder).toContain("8788");
+		expect(shown[0]?.placeholder).toContain("Enter keeps");
+	});
+
+	test("enum and boolean pickers mark the current option instead of relying on a preselect index", async () => {
+		const { ui, shown } = recordingUi(["reject", "false"]);
+		const en: FieldSpec = { path: "budget.onExceeded", label: "On exceeded", kind: "enum", options: ["downgrade", "reject"] };
+		const bo: FieldSpec = { path: "cache.injectBreakpoints", label: "Inject cache breakpoints", kind: "boolean" };
+		const answers: Record<string, unknown> = {};
+		await walkSection(ui, { title: "t", fields: [en, bo] }, cfg, answers);
+		expect(shown[0]?.title).toBe("On exceeded · current: downgrade");
+		expect(shown[0]?.options).toEqual([{ label: "downgrade", description: "current" }, "reject"]);
+		expect(shown[1]?.options).toEqual([{ label: "true", description: "current" }, "false"]);
+		expect(answers).toEqual({ "budget.onExceeded": "reject", "cache.injectBreakpoints": false });
+	});
+
+	test("editSectionMenu lists every field with its current value, edits one, and marks it pending", async () => {
+		const section = {
+			title: "Server",
+			fields: [
+				{ path: "server.host", label: "Listen host", kind: "string" },
+				{ path: "server.port", label: "Listen port", kind: "number", min: 1 },
+			] as FieldSpec[],
+		};
+		// pick port → type 9000 → picker again → Back
+		const { ui, shown } = recordingUi(["Listen port", "9000", "Back"]);
+		const answers: Record<string, unknown> = {};
+		const changed = await editSectionMenu(ui, section, cfg, answers);
+		expect(changed).toBe(true);
+		expect(answers).toEqual({ "server.port": 9000 });
+		expect(shown[0]?.options).toEqual([
+			{ label: "Listen host", description: "127.0.0.1" },
+			{ label: "Listen port", description: "8788" },
+			"Back",
+		]);
+		expect(shown[1]?.title).toBe("Listen port · current: 8788");
+		// Second picker shows the pending edit, not the on-disk value.
+		expect(shown[2]?.title).toBe("Server (edited)");
+		expect(shown[2]?.options?.[1]).toEqual({ label: "Listen port", description: "9000  (pending)" });
+	});
+
+	test("cancelling a field dialog returns to the picker; cancelling the picker returns", async () => {
+		const section = { title: "Server", fields: [{ path: "server.host", label: "Listen host", kind: "string" }] as FieldSpec[] };
+		const { ui, shown } = recordingUi(["Listen host", undefined, undefined]);
+		const changed = await editSectionMenu(ui, section, cfg, {});
+		expect(changed).toBe(false);
+		expect(shown).toHaveLength(3);
+	});
 });
 
 describe("editProfile", () => {

package/test/embed-lifecycle.test.ts

@@ -33,6 +33,7 @@ const handlers = new Map<string, ((event: unknown, ctx: ExtensionContext) => voi
 
 const pi: ExtensionAPI = {
 	setLabel: () => {},
+	sendMessage: () => {},
 	on: (event, handler) => {
 		const list = handlers.get(event) ?? [];
 		list.push(handler);

package/test/failover.test.ts

@@ -13,6 +13,7 @@ import type {
 	Tier,
 } from "../src/router/types.ts";
 import { runTurn } from "../src/server/turn.ts";
+import { classifyUpstreamStatus } from "../src/upstream/openrouter.ts";
 import { UpstreamError, type DispatchOptions, type UpstreamClient } from "../src/upstream/types.ts";
 import type {
 	FinishReason,
@@ -30,6 +31,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 	return {
 		server: { host: "127.0.0.1", port: 8787, maxConcurrentTurns: 24 },
 		openrouter: { baseUrl: "https://openrouter.ai/api/v1", apiKey: "", title: "test", timeoutMs: 30_000, catalogTtlMs: 3_600_000, catalogRefreshMs: 0 },
+		ollama: { enabled: false, baseUrl: "http://127.0.0.1:11434/v1", apiKey: "", timeoutMs: 30_000, catalogTtlMs: 300_000, includeLocal: false, prices: {}, twins: {}, costBias: 1, biasUntilUsage: 0.9, usagePollMs: 0, quotaCooldownMs: 0, rateLimitCooldownMs: 0 },
 		benchmarks: { enabled: false, artificialAnalysisApiKey: "", benchlm: true, refreshMs: 86_400_000, timeoutMs: 30_000, useLocalScores: false },
 		tiers: {
 			trivial: { minQuality: 0, maxInputPerMtok: 0.3, qualityExponent: 0, pin: [] },
@@ -44,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, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, latencyMinSamples: 20 },
+		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, latencyMinSamples: 20, escalationCostWeight: 0 },
 		classifier: {
 			ambiguityThreshold: 0,
 			model: "test/adjudicator",
@@ -55,6 +57,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			toolAxis: "coding",
 			chatAxis: "intelligence",
 			agenticLoopDepth: 3,
+			mechanicalRetryFactor: 0.2,
 			reasoningWeights: { medium: 0.14, high: 0.24, xhigh: 0.3, max: 0.34 },
 		},
 		escalation: {
@@ -67,11 +70,11 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			escalateOnLengthStop: false,
 			...escalation,
 		},
-		hysteresis: { holdTurns: 2, holdTurnsAfterEscalation: 4, switchMargin: 1.5, cacheWarmTtlMs: 600_000, maxDowngradePerTurn: 1, breakHoldOnMechanical: false },
+		hysteresis: { holdTurns: 2, holdTurnsAfterEscalation: 4, switchMargin: 1.5, cacheWarmTtlMs: 600_000, maxDowngradePerTurn: 1, breakHoldOnMechanical: false, switchHorizonTurns: 1 },
 		exploration: { enabled: false, rates: {}, stickyPolicy: "never", holdTurns: { enabled: false, values: [2, 3, 4] } },
 		cache: { injectBreakpoints: true, maxBreakpoints: 4, minPromptTokens: 1024, milestoneTokens: 20_000 },
 		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, memoryLimit: 8, docsLimit: 2, sessionLimit: 6, briefChars: 0, recordTurns: false, maxQueue: 64 },
-		compaction: { enabled: false, budgetTokens: 40_000, floorRatio: 1, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true },
+		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 },
 		budget: { onExceeded: "downgrade" },
 		profiles: [],
 		ledger: { path: ":memory:", blendWindowDays: 7, blendMinSamples: 20, fallbackBlend: { inputPerMtok: 1, outputPerMtok: 4 }, conversationTtlMs: 86_400_000 },
@@ -146,6 +149,8 @@ function mkDecision(tier: Tier, slug: string, probe: Partial<ProbePlan> = {}): D
 		cacheBreakpointMessageIndices: [],
 		compactionPlan: [],
 		promptTokensSaved: 0,
+		compactionSavedBytes: 0,
+		compactionPlanTokens: 0,
 		reasoning: undefined,
 		maxTokens: undefined,
 		stripAssistantReasoning: false,
@@ -545,4 +550,144 @@ describe("same-tier failover", () => {
 		expect(finishes).toHaveLength(1);
 		expect(finishes[0]!.servedSlug).toBe("b/model");
 	});
+
+	test("an empty completion tries a different model in the SAME tier before escalating", async () => {
+		// An empty stream indicts the provider, not the tier. Measured: 49 of 71
+		// escalations in a week re-dispatched the very slug that had just
+		// failed, one tier up, paying the tier premium for a provider hiccup.
+		const { router, calls } = mkRouter([
+			mkDecision("trivial", "a/model", { escalateTo: "simple" }),
+			mkDecision("trivial", "b/model", { escalateTo: "simple" }),
+		]);
+		const { upstream, calls: dispatches } = mkUpstream([
+			{ kind: "chunks", chunks: [startChunk("a/model"), finishChunk("stop")] },
+			{ kind: "chunks", chunks: okChunks("b/model") },
+		]);
+		const { ledger, entries } = mkLedger();
+		const { store } = mkConversations();
+		const { sink, chunks, errors, finishes } = mkSink();
+
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
+
+		expect(errors).toHaveLength(0);
+		expect(calls).toHaveLength(2);
+		expect(calls[0]).toEqual({ attempt: 0 });
+		// Same tier, the failed slug excluded, no escalateFrom.
+		expect(calls[1]).toEqual({ attempt: 1, excludeSlugs: ["a/model"] });
+		expect(dispatches.map((d) => d.body.model)).toEqual(["a/model", "b/model"]);
+
+		expect(entries).toHaveLength(2);
+		expect(entries[0]!.wasted).toBe(true);
+		expect(entries[0]!.escalationSignal).toBe("empty_completion"); // still counts against a/model's trust
+		expect(entries[0]!.error).toBeNull();
+		expect(entries[1]!.slug).toBe("b/model");
+		expect(entries[1]!.tier).toBe("trivial");
+		expect(entries[1]!.reasons.some((r) => r.startsWith("failover: a/model empty_completion"))).toBe(true);
+
+		expect(textOut(chunks)).toBe("done");
+		expect(finishes).toHaveLength(1);
+		expect(finishes[0]!.escalated).toBe(false);
+		expect(finishes[0]!.servedSlug).toBe("b/model");
+	});
+
+	test("a provider signal with no sibling at this tier escalates, still excluding the failed slug", async () => {
+		const { router, calls } = mkRouter([
+			mkDecision("trivial", "a/model", { escalateTo: "simple" }),
+			mkDecision("simple", "b/model", { escalateTo: "moderate" }), // failover probe: router widened (wrong tier)
+			mkDecision("simple", "b/model", { escalateTo: "moderate" }), // real escalation
+		]);
+		const { upstream, calls: dispatches } = mkUpstream([
+			{ kind: "chunks", chunks: [startChunk("a/model"), finishChunk("stop")] },
+			{ kind: "chunks", chunks: okChunks("b/model") },
+		]);
+		const { ledger, entries } = mkLedger();
+		const { store } = mkConversations();
+		const { sink, errors, finishes } = mkSink();
+
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
+
+		expect(errors).toHaveLength(0);
+		expect(calls).toHaveLength(3);
+		expect(calls[1]).toEqual({ attempt: 1, excludeSlugs: ["a/model"] });
+		expect(calls[2]).toEqual({ attempt: 1, escalateFrom: "trivial", excludeSlugs: ["a/model"] });
+		expect(dispatches.map((d) => d.body.model)).toEqual(["a/model", "b/model"]);
+		expect(entries).toHaveLength(2);
+		expect(entries[0]!.escalationSignal).toBe("empty_completion");
+		expect(entries[1]!.tier).toBe("simple");
+		expect(finishes[0]!.escalated).toBe(true);
+	});
+
+	test("a structural signal escalates a tier directly, with the failed slug excluded", async () => {
+		// Malformed tool arguments are the model's own doing; a stronger model
+		// is the remedy, so no same-tier probe — but the failing slug must not
+		// be the one that serves the escalated attempt.
+		const { router, calls } = mkRouter([
+			mkDecision("trivial", "a/model", { escalateTo: "simple" }),
+			mkDecision("simple", "b/model", { escalateTo: "moderate" }),
+		]);
+		const { upstream, calls: dispatches } = mkUpstream([
+			{
+				kind: "chunks",
+				chunks: [
+					startChunk("a/model"),
+					chunk([{ type: "tool_call", index: 0, id: "c1", name: "read", argsDelta: "{\"path\": " }]),
+					finishChunk("tool_calls"),
+				],
+			},
+			{ kind: "chunks", chunks: okChunks("b/model") },
+		]);
+		const { ledger, entries } = mkLedger();
+		const { store } = mkConversations();
+		const { sink, errors, finishes } = mkSink();
+
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
+
+		expect(errors).toHaveLength(0);
+		expect(calls).toHaveLength(2);
+		expect(calls[1]).toEqual({ attempt: 1, escalateFrom: "trivial", excludeSlugs: ["a/model"] });
+		expect(dispatches.map((d) => d.body.model)).toEqual(["a/model", "b/model"]);
+		expect(entries[0]!.escalationSignal).toBe("malformed_tool_args");
+		expect(finishes[0]!.escalated).toBe(true);
+	});
+
+});
+
+describe("400 classification (review 2026-09-05 follow-up)", () => {
+	test("a 400 naming a model capability limit is retryable, so failover picks a sibling", () => {
+		const e = classifyUpstreamStatus(400, { error: { message: "This model only supports single tool-calls at once!" } });
+		expect(e.kind).toBe("invalid_request");
+		expect(e.retryable).toBe(true);
+	});
+
+	test("a 400 for a malformed request stays non-retryable", () => {
+		const e = classifyUpstreamStatus(400, { error: { message: "messages[3].content: invalid type" } });
+		expect(e.kind).toBe("invalid_request");
+		expect(e.retryable).toBe(false);
+	});
+
+	test("a 400 for context overflow is still context_length", () => {
+		const e = classifyUpstreamStatus(400, { error: { message: "This endpoint's maximum context length is 131072 tokens" } });
+		expect(e.kind).toBe("context_length");
+		expect(e.retryable).toBe(false);
+	});
+
+	test("a capability 400 before commit fails over in the same tier, excluding the model", async () => {
+		const { router, calls } = mkRouter([mkDecision("trivial", "a/model"), mkDecision("trivial", "b/model")]);
+		const { upstream, calls: dispatches } = mkUpstream([
+			{ kind: "fail", error: classifyUpstreamStatus(400, { error: { message: "This model only supports single tool-calls at once!" } }) },
+			{ kind: "chunks", chunks: okChunks("b/model") },
+		]);
+		const { ledger, entries } = mkLedger();
+		const { store } = mkConversations();
+		const { sink, errors, finishes } = mkSink();
+
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
+
+		expect(errors).toHaveLength(0);
+		expect(calls[1]).toEqual({ attempt: 1, excludeSlugs: ["a/model"] });
+		expect(dispatches.map((d) => d.body.model)).toEqual(["a/model", "b/model"]);
+		expect(entries[0]!.error).toContain("invalid_request"); // attributable: trust learns the limitation
+		expect(finishes[0]!.servedSlug).toBe("b/model");
+	});
 });
+

package/test/features.test.ts

@@ -271,3 +271,38 @@ describe("newest-content scoping", () => {
 		expect(f.isToolResultContinuation).toBe(true);
 	});
 });
+
+describe("user-visible tool failure (review 2026-09-05)", () => {
+	test("a failed tool run the user is now responding to still counts as failed", () => {
+		// The classifier keeps the FULL failed-tool weight when the failure is
+		// user-visible (not a mechanical continuation); that branch was dead
+		// while the scan ran only on tool-result tails.
+		const f = extractFeatures(
+			req([
+				SYSTEM,
+				{ role: "user", content: "build it" },
+				toolCall("c1", "bash", '{"command":"make"}'),
+				{ role: "tool", tool_call_id: "c1", content: "make: *** [all] Error 2" },
+				{ role: "user", content: "that failed, try a different approach" },
+			]),
+			100,
+		);
+		expect(f.isToolResultContinuation).toBe(false);
+		expect(f.lastToolFailed).toBe(true);
+	});
+
+	test("an assistant reply between the failed run and the user resets the failure signal", () => {
+		const f = extractFeatures(
+			req([
+				SYSTEM,
+				{ role: "user", content: "build it" },
+				toolCall("c1", "bash", '{"command":"make"}'),
+				{ role: "tool", tool_call_id: "c1", content: "make: *** [all] Error 2" },
+				{ role: "assistant", content: "The build failed because cc is missing." },
+				{ role: "user", content: "ok, install it" },
+			]),
+			100,
+		);
+		expect(f.lastToolFailed).toBe(false);
+	});
+});

package/test/http-resilience.test.ts

@@ -55,4 +55,28 @@ describe("HTTP server resilience against dead streams", () => {
 		const json = (await modelsRes.json()) as { data: unknown[] };
 		expect(Array.isArray(json.data)).toBe(true);
 	});
+
+	test("a malformed request body does not consume a concurrency slot", async () => {
+		// Regression: the slot was acquired before the body was parsed and only
+		// released in runTurn's finally, so every rejected body leaked one slot
+		// and 24 of them turned the router into a permanent 429.
+		for (let i = 0; i < 30; i++) {
+			const res = await fetch(`${baseUrl}/v1/chat/completions`, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: "this is not json",
+			});
+			expect(res.status).toBe(400);
+		}
+		const res = await fetch(`${baseUrl}/v1/chat/completions`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({ model: "auto", stream: false, messages: [{ role: "user", content: "hello" }] }),
+		});
+		// Anything but "too many concurrent turns"; with no API key the turn
+		// itself fails at dispatch, which is fine here.
+		expect(res.status).not.toBe(429);
+		await res.text();
+	});
+
 });