auto-model-router 0.2.2 → 0.2.8

package/test/failover.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { createDisabledBridge } from "../src/context/bridge.ts";
 import type { CatalogSource } from "../src/catalog/types.ts";
 import type { EscalationConfig, RouterConfig } from "../src/config/types.ts";
 import { EMPTY_USAGE, type Ledger, type LedgerEntry, type UsageCounts } from "../src/cost/types.ts";
@@ -43,7 +44,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, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyMinSamples: 20 },
+		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, minTrustSamples: 5, trustScopedByHarness: false, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, latencyMinSamples: 20 },
 		classifier: {
 			ambiguityThreshold: 0,
 			model: "test/adjudicator",
@@ -68,6 +69,8 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		hysteresis: { holdTurns: 2, holdTurnsAfterEscalation: 4, switchMargin: 1.5, cacheWarmTtlMs: 600_000, maxDowngradePerTurn: 1 },
 		exploration: { enabled: false, rates: {}, stickyPolicy: "never", holdTurns: { enabled: false, values: [2, 3, 4] } },
 		cache: { injectBreakpoints: true, maxBreakpoints: 4, minPromptTokens: 1024 },
+		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, recordTurns: false, maxQueue: 64 },
+		compaction: { enabled: false, budgetTokens: 40_000, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true },
 		budget: { onExceeded: "downgrade" },
 		profiles: [],
 		ledger: { path: ":memory:", blendWindowDays: 7, blendMinSamples: 20, fallbackBlend: { inputPerMtok: 1, outputPerMtok: 4 }, conversationTtlMs: 86_400_000 },
@@ -83,6 +86,7 @@ function mkReq(): NormRequest {
 		conversationKey: "conv-test",
 		harnessId: "",
 		ompSessionId: "",
+		agentdoxScope: "",
 		requestedModel: "auto",
 		messages: [{ role: "user", text: "hi", images: 0, textBytes: 2, toolCalls: [] }],
 		tools: [],
@@ -107,7 +111,9 @@ const FEATURES: Features = {
 	distinctToolsUsed: 0,
 	lastToolFailed: false,
 	repeatedToolCall: false,
+	circularToolCall: false,
 	hasImages: false,
+	hasNewImage: false,
 	codeBlocks: 0,
 	codeBytes: 0,
 	looksLikeDiff: false,
@@ -137,6 +143,8 @@ function mkDecision(tier: Tier, slug: string, probe: Partial<ProbePlan> = {}): D
 		sessionId: "omp-conv-test",
 		sticky: false,
 		cacheBreakpointMessageIndices: [],
+		compactionPlan: [],
+		promptTokensSaved: 0,
 		reasoning: undefined,
 		maxTokens: undefined,
 		stripAssistantReasoning: false,
@@ -257,6 +265,8 @@ function mkConversations(): { store: ConversationStore; map: Map<string, Convers
 				lastPromptTokens: 0,
 				cacheWarmSlug: null,
 				cacheWarmAtMs: 0,
+				contextVersion: null,
+				contextFetchedAtMs: 0,
 				updatedAtMs: 0,
 			};
 			map.set(k, fresh);
@@ -320,7 +330,7 @@ describe("same-tier failover", () => {
 		const { store } = mkConversations();
 		const { sink, errors, finishes } = mkSink();
 
-		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog }, new AbortController().signal);
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
 
 		expect(errors).toHaveLength(0);
 		expect(finishes).toHaveLength(1);
@@ -350,6 +360,41 @@ describe("same-tier failover", () => {
 		expect(finishes[0]!.attempts).toBe(2);
 	});
 
+	test("a 403 moderation block fails over to a different model in the same tier", async () => {
+		const { router, calls } = mkRouter([mkDecision("trivial", "a/model"), mkDecision("trivial", "b/model")]);
+		const { upstream, calls: dispatches } = mkUpstream([
+			{ kind: "fail", error: new UpstreamError("moderation", 403, "Request blocked: prompt injection", true) },
+			{ 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(finishes).toHaveLength(1);
+
+		// A per-model policy block indicts the slug, not the tier: the retry
+		// re-routes with the blocked slug excluded and serves a sibling.
+		expect(calls).toHaveLength(2);
+		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]!.slug).toBe("a/model");
+		expect(entries[0]!.wasted).toBe(true);
+		expect(entries[0]!.escalationSignal).toBeNull(); // failover, not escalation
+		expect(entries[0]!.error).toContain("moderation");
+		expect(entries[1]!.slug).toBe("b/model");
+		expect(entries[1]!.tier).toBe("trivial");
+		expect(entries[1]!.wasted).toBe(false);
+		expect(entries[1]!.reasons).toContain("failover: a/model returned moderation; retrying b/model in trivial");
+
+		expect(finishes[0]!.servedSlug).toBe("b/model");
+		expect(finishes[0]!.escalated).toBe(false);
+	});
+
 	test("a tier with no other eligible model falls back to tier escalation", async () => {
 		// The router widens to "simple" when "trivial" excludes a/model: the
 		// failover probe's decision is discarded and the normal escalation path
@@ -367,7 +412,7 @@ describe("same-tier failover", () => {
 		const { store } = mkConversations();
 		const { sink, errors, finishes } = mkSink();
 
-		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog }, new AbortController().signal);
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
 
 		expect(errors).toHaveLength(0);
 		expect(finishes).toHaveLength(1);
@@ -401,7 +446,7 @@ describe("same-tier failover", () => {
 		const { store } = mkConversations();
 		const { sink, errors, finishes } = mkSink();
 
-		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog }, new AbortController().signal);
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
 
 		expect(calls).toHaveLength(1);
 		expect(calls[0]).toEqual({ attempt: 0 }); // never re-routed, never given excludeSlugs
@@ -434,7 +479,7 @@ describe("same-tier failover", () => {
 		await runTurn(
 			mkReq(),
 			sink,
-			{ config: mkConfig({ maxAttempts: 5 }), router, upstream, ledger, conversations: store, catalog },
+			{ config: mkConfig({ maxAttempts: 5 }), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() },
 			new AbortController().signal,
 		);
 
@@ -480,7 +525,7 @@ describe("same-tier failover", () => {
 		const { store } = mkConversations();
 		const { sink, chunks, errors, finishes } = mkSink();
 
-		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog }, new AbortController().signal);
+		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);

package/test/features.test.ts

@@ -133,6 +133,7 @@ describe("failure and loop signals", () => {
 			100,
 		);
 		expect(f.repeatedToolCall).toBe(true);
+		expect(f.circularToolCall).toBe(true);
 	});
 
 	test("different arguments to the same tool are not a loop", () => {
@@ -148,6 +149,26 @@ describe("failure and loop signals", () => {
 			100,
 		);
 		expect(f.repeatedToolCall).toBe(false);
+		expect(f.circularToolCall).toBe(false);
+	});
+
+	test("a non-adjacent re-issued call is circular but not an adjacent repeat", () => {
+		const f = extractFeatures(
+			req([
+				SYSTEM,
+				{ role: "user", content: "go" },
+				toolCall("c1", "read", '{"path":"same.ts"}'),
+				{ role: "tool", tool_call_id: "c1", content: "x" },
+				toolCall("c2", "bash", '{"command":"ls"}'),
+				{ role: "tool", tool_call_id: "c2", content: "a.txt" },
+				toolCall("c3", "read", '{"path":"same.ts"}'),
+				{ role: "tool", tool_call_id: "c3", content: "x" },
+			]),
+			100,
+		);
+		// c3 repeats c1 verbatim with c2 in between: not adjacent, but circular.
+		expect(f.repeatedToolCall).toBe(false);
+		expect(f.circularToolCall).toBe(true);
 	});
 });
 
@@ -223,6 +244,30 @@ describe("newest-content scoping", () => {
 			100,
 		);
 		expect(f.hasImages).toBe(true);
+		expect(f.hasNewImage).toBe(true);
 		expect(f.requestedReasoning).toBe("high");
 	});
+
+	test("a stale image in history is not new visual work on a tool continuation", () => {
+		const f = extractFeatures(
+			req([
+				SYSTEM,
+				{
+					role: "user",
+					content: [
+						{ type: "text", text: "implement this screen" },
+						{ type: "image_url", image_url: { url: "data:image/png;base64,AA" } },
+					],
+				},
+				toolCall("c1", "read", '{"path":"src/app.tsx"}'),
+				{ role: "tool", tool_call_id: "c1", name: "read", content: "export const App = () => null;" },
+			]),
+			100,
+		);
+		// The image is still in context (capability), but the current turn is a
+		// mechanical continuation, not fresh visual work (task axis).
+		expect(f.hasImages).toBe(true);
+		expect(f.hasNewImage).toBe(false);
+		expect(f.isToolResultContinuation).toBe(true);
+	});
 });

package/test/helpers/inject.ts

@@ -0,0 +1,23 @@
+/**
+ * Exercises the wire's context injection through the public render path, so
+ * the test covers the real ordering (inject, then apply cache breakpoints).
+ */
+import { parseChatRequest } from "../../src/wire/openai/request.ts";
+
+export function injectForTest(
+	body: Record<string, unknown>,
+	block: string,
+	breakpoints: number[],
+): Record<string, unknown> {
+	const req = parseChatRequest(body, new Headers());
+	return req.renderUpstreamBody({
+		slug: "vendor/model",
+		fallbacks: [],
+		sessionId: "s",
+		cacheBreakpointMessageIndices: breakpoints,
+		reasoning: undefined,
+		maxTokens: undefined,
+		stripAssistantReasoning: false,
+		contextBlock: block,
+	});
+}

package/test/hold-exploration.test.ts

@@ -1,10 +1,12 @@
 import { describe, expect, test } from "bun:test";
 
-import { loadConfig } from "../src/config/load.ts";
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
 import type { RouterConfig } from "../src/config/types.ts";
 import { explorationDraw, resolveHoldTurns } from "../src/router/explore.ts";
 
-const BASE = loadConfig({});
+// Shipped defaults, not loadConfig({}) — the latter merges the live home
+// config.yml and makes this suite depend on the developer's local settings.
+const BASE = DEFAULT_CONFIG;
 
 function withHold(over: { enabled?: boolean; values?: number[] }, enabled = true): RouterConfig {
 	return {

package/test/select.test.ts

@@ -64,6 +64,8 @@ function state(over: Partial<ConversationState> = {}): ConversationState {
 		lastPromptTokens: 0,
 		cacheWarmSlug: null,
 		cacheWarmAtMs: 0,
+		contextVersion: null,
+		contextFetchedAtMs: 0,
 		updatedAtMs: Date.now(),
 		...over,
 	};
@@ -541,7 +543,7 @@ describe("task-type routing", () => {
 });
 
 describe("latency scoring", () => {
-	function ledgerWithLatency(ttftBySlug: Record<string, { ttftMs: number; samples: number }>): Ledger {
+	function ledgerWithLatency(bySlug: Record<string, { ttftMs: number; samples: number; tokensPerSec?: number }>): Ledger {
 		return {
 			record: () => {},
 			conversationSpend: () => 0,
@@ -550,8 +552,10 @@ describe("latency scoring", () => {
 			trust: () => null,
 			allTrust: () => [],
 			latency: (slug) => {
-				const v = ttftBySlug[slug];
-				return v === undefined ? null : { slug, samples: v.samples, ttftMs: v.ttftMs };
+				const v = bySlug[slug];
+				// Default throughput is fast, so these cases isolate the TTFT axis
+				// unless a test sets tokensPerSec explicitly.
+				return v === undefined ? null : { slug, samples: v.samples, ttftMs: v.ttftMs, tokensPerSec: v.tokensPerSec ?? 1000 };
 			},
 			tokenRatio: () => null,
 			recentEntries: () => [],
@@ -581,4 +585,83 @@ describe("latency scoring", () => {
 		const ledger = ledgerWithLatency({ [slow]: { ttftMs: 60_000, samples: 5 } });
 		expect(run({ tier: "simple", cfg: withWeight(2), ledger }).slug).toBe(slow);
 	});
+
+	test("penalises a model that starts fast but streams slowly", () => {
+		// The case TTFT-only scoring misses: quick first token, slow body.
+		const slow = run({ tier: "simple" }).slug;
+		const ledger = ledgerWithLatency({ [slow]: { ttftMs: 1500, samples: 50, tokensPerSec: 12 } });
+		const d = run({ tier: "simple", cfg: withWeight(2), ledger });
+		expect(d.slug).not.toBe(slow);
+	});
+});
+
+describe("context compaction", () => {
+	const COMPACT_CFG: RouterConfig = {
+		...BASE,
+		compaction: {
+			enabled: true,
+			budgetTokens: 1_000,
+			fitToWindow: false,
+			protectRecentTurns: 1,
+			maxToolResultBytes: 100,
+			keepHeadBytes: 20,
+			keepTailBytes: 20,
+			elideSupersededReads: true,
+			collapseDuplicateResults: true,
+		},
+	};
+
+	function loopReq(): NormRequest {
+		return parseChatRequest(
+			{
+				model: "auto",
+				tools: TOOLS,
+				messages: [
+					{ role: "system", content: "You are a coding agent." },
+					{ role: "user", content: "read the file" },
+					{ role: "assistant", content: null, tool_calls: [{ id: "c1", type: "function", function: { name: "read", arguments: '{"path":"big.ts"}' } }] },
+					{ role: "tool", tool_call_id: "c1", content: "x".repeat(4000) },
+					{ role: "user", content: "continue" },
+				],
+			},
+			new Headers(),
+		);
+	}
+
+	test("an over-budget turn produces a compaction plan and records savings", () => {
+		const req = loopReq();
+		const features = extractFeatures(req, 5_000); // over budgetTokens=1000
+		const d = select({
+			req,
+			features,
+			classification: scoreHeuristic(features, COMPACT_CFG),
+			profile: PROFILE,
+			state: state(),
+			snapshot: SNAPSHOT,
+			ledger: null,
+			cfg: COMPACT_CFG,
+			nowMs: Date.now(),
+		});
+		expect(d.compactionPlan.length).toBeGreaterThan(0);
+		expect(d.promptTokensSaved).toBeGreaterThan(0);
+		expect(d.reasons.some((r) => r.startsWith("compaction:"))).toBe(true);
+	});
+
+	test("a small turn is left untouched", () => {
+		const req = loopReq();
+		const features = extractFeatures(req, 500); // under budgetTokens=1000
+		const d = select({
+			req,
+			features,
+			classification: scoreHeuristic(features, COMPACT_CFG),
+			profile: PROFILE,
+			state: state(),
+			snapshot: SNAPSHOT,
+			ledger: null,
+			cfg: COMPACT_CFG,
+			nowMs: Date.now(),
+		});
+		expect(d.compactionPlan).toEqual([]);
+		expect(d.promptTokensSaved).toBe(0);
+	});
 });

package/test/tokens.test.ts

@@ -42,6 +42,7 @@ function entry(over: Partial<LedgerEntry>): LedgerEntry {
 		wasted: false,
 		upstreamGenerationId: null,
 		error: null,
+		promptTokensSaved: 0,
 		...over,
 	};
 }

package/test/trust-attribution.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
 import { loadConfig } from "../src/config/load.ts";
-import { createLedger } from "../src/cost/ledger.ts";
+import { createLedger, LATENCY_WINDOW_ROWS } from "../src/cost/ledger.ts";
 import { EMPTY_USAGE, type LedgerEntry } from "../src/cost/types.ts";
 import { openDb } from "../src/util/sqlite.ts";
 
@@ -40,6 +40,7 @@ function entry(over: Partial<LedgerEntry>): LedgerEntry {
 		wasted: false,
 		upstreamGenerationId: null,
 		error: null,
+		promptTokensSaved: 0,
 		...over,
 	};
 }
@@ -75,8 +76,19 @@ describe("trust attribution", () => {
 			trustAfter([
 				null,
 				null,
-				"auth: Request blocked: prompt injection patterns detected",
-				"auth: This model requires 18+ age confirmation",
+				"auth: No auth credentials found",
+				"auth: Insufficient credits",
+			]),
+		).toBe(CLEAN);
+	});
+
+	test("provider moderation/policy blocks do not count against the model", () => {
+		expect(
+			trustAfter([
+				null,
+				null,
+				"moderation: Request blocked: prompt injection patterns detected",
+				"moderation: This model requires 18+ age confirmation",
 			]),
 		).toBe(CLEAN);
 	});
@@ -146,20 +158,20 @@ describe("trust attribution", () => {
 });
 
 describe("latency signal", () => {
-	function latencyOf(rows: Array<Partial<LedgerEntry>>): { samples: number; ttftMs: number } | null {
+	function latencyOf(rows: Array<Partial<LedgerEntry>>): { samples: number; ttftMs: number; tokensPerSec: number } | null {
 		const db = openDb(":memory:");
 		try {
 			const ledger = createLedger(db, cfg);
 			for (const r of rows) ledger.record(entry(r));
 			const l = ledger.latency("vendor/model");
-			return l === null ? null : { samples: l.samples, ttftMs: l.ttftMs };
+			return l === null ? null : { samples: l.samples, ttftMs: l.ttftMs, tokensPerSec: l.tokensPerSec };
 		} finally {
 			db.close();
 		}
 	}
 
 	test("averages TTFT over streamed, non-errored turns", () => {
-		expect(latencyOf([{ ttftMs: 50 }, { ttftMs: 100 }, { ttftMs: 150 }])).toEqual({ samples: 3, ttftMs: 100 });
+		expect(latencyOf([{ ttftMs: 50 }, { ttftMs: 100 }, { ttftMs: 150 }])).toEqual({ samples: 3, ttftMs: 100, tokensPerSec: 0 });
 	});
 
 	test("excludes errored, aborted, and non-streamed (null TTFT) rows", () => {
@@ -170,12 +182,38 @@ describe("latency signal", () => {
 				{ ttftMs: 9999, error: "request aborted" },
 				{ ttftMs: null },
 			]),
-		).toEqual({ samples: 1, ttftMs: 100 });
+		).toEqual({ samples: 1, ttftMs: 100, tokensPerSec: 0 });
 	});
 
 	test("null when no streamed sample exists", () => {
 		expect(latencyOf([{ ttftMs: null }, { ttftMs: 0 }])).toBeNull();
 	});
+
+	test("throughput is aggregate completion tokens per post-TTFT second", () => {
+		const l = latencyOf([
+			{ ttftMs: 1000, latencyMs: 3000, usage: { ...EMPTY_USAGE, completionTokens: 200 } },
+			{ ttftMs: 1000, latencyMs: 3000, usage: { ...EMPTY_USAGE, completionTokens: 200 } },
+		]);
+		// 400 completion tokens over 4000ms of post-TTFT time = 100 tok/s.
+		expect(l?.tokensPerSec).toBeCloseTo(100, 5);
+		expect(l?.samples).toBe(2);
+	});
+
+	test("throughput and ttft track a recent window, not the lifetime average", () => {
+		// Old rows are fast; the recent window is slow. Latency must reflect the
+		// recent (slow) behaviour so a degraded model is penalised, not masked by
+		// its history. Lifetime blend here would be ~57 tok/s; the window is 10.
+		const rows: Array<Partial<LedgerEntry>> = [];
+		let t = 1;
+		for (let i = 0; i < 50; i++)
+			rows.push({ createdAtMs: t++, ttftMs: 200, latencyMs: 1200, usage: { ...EMPTY_USAGE, completionTokens: 1000 } });
+		for (let i = 0; i < LATENCY_WINDOW_ROWS; i++)
+			rows.push({ createdAtMs: t++, ttftMs: 4000, latencyMs: 14000, usage: { ...EMPTY_USAGE, completionTokens: 100 } });
+		const l = latencyOf(rows);
+		expect(l?.samples).toBe(LATENCY_WINDOW_ROWS);
+		expect(l?.tokensPerSec).toBeCloseTo(10, 0);
+		expect(l?.ttftMs).toBeCloseTo(4000, 5);
+	});
 });
 
 describe("v4 migration", () => {
@@ -185,6 +223,7 @@ describe("v4 migration", () => {
 			const ledger = createLedger(db, cfg);
 			ledger.record(entry({ error: "request aborted" }));
 			ledger.record(entry({ error: "auth: nope" }));
+			ledger.record(entry({ error: "moderation: Request blocked: prompt injection" }));
 			ledger.record(entry({ error: "model_unavailable: guardrail" }));
 			ledger.record(entry({ error: "upstream_error: boom" }));
 			ledger.record(entry({ error: null }));
@@ -195,6 +234,7 @@ describe("v4 migration", () => {
 			expect(rows.map((r) => r.error_kind)).toEqual([
 				"aborted",
 				"auth",
+				"moderation",
 				"model_unavailable",
 				"upstream_error",
 				null,
@@ -204,11 +244,11 @@ describe("v4 migration", () => {
 		}
 	});
 
-	test("schema is at user_version 10", () => {
+	test("schema is at user_version 12", () => {
 		const db = openDb(":memory:");
 		try {
 			const row = db.query("PRAGMA user_version").get() as { user_version: number };
-			expect(row.user_version).toBe(10);
+			expect(row.user_version).toBe(12);
 		} finally {
 			db.close();
 		}

package/test/turn.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { createDisabledBridge } from "../src/context/bridge.ts";
 import type { CatalogSource } from "../src/catalog/types.ts";
 import type { EscalationConfig, RouterConfig } from "../src/config/types.ts";
 import { EMPTY_USAGE, type Ledger, type LedgerEntry, type UsageCounts } from "../src/cost/types.ts";
@@ -43,7 +44,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, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyMinSamples: 20 },
+		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, minTrustSamples: 5, trustScopedByHarness: false, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, latencyMinSamples: 20 },
 		classifier: {
 			ambiguityThreshold: 0,
 			model: "test/adjudicator",
@@ -68,6 +69,8 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		hysteresis: { holdTurns: 2, holdTurnsAfterEscalation: 4, switchMargin: 1.5, cacheWarmTtlMs: 600_000, maxDowngradePerTurn: 1 },
 		exploration: { enabled: false, rates: {}, stickyPolicy: "never", holdTurns: { enabled: false, values: [2, 3, 4] } },
 		cache: { injectBreakpoints: true, maxBreakpoints: 4, minPromptTokens: 1024 },
+		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, recordTurns: false, maxQueue: 64 },
+		compaction: { enabled: false, budgetTokens: 40_000, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true },
 		budget: { onExceeded: "downgrade" },
 		profiles: [],
 		ledger: { path: ":memory:", blendWindowDays: 7, blendMinSamples: 20, fallbackBlend: { inputPerMtok: 1, outputPerMtok: 4 }, conversationTtlMs: 86_400_000 },
@@ -83,6 +86,7 @@ function mkReq(): NormRequest {
 		conversationKey: "conv-test",
 		harnessId: "",
 		ompSessionId: "",
+		agentdoxScope: "",
 		requestedModel: "auto",
 		messages: [{ role: "user", text: "hi", images: 0, textBytes: 2, toolCalls: [] }],
 		tools: [],
@@ -107,7 +111,9 @@ const FEATURES: Features = {
 	distinctToolsUsed: 0,
 	lastToolFailed: false,
 	repeatedToolCall: false,
+	circularToolCall: false,
 	hasImages: false,
+	hasNewImage: false,
 	codeBlocks: 0,
 	codeBytes: 0,
 	looksLikeDiff: false,
@@ -137,6 +143,8 @@ function mkDecision(tier: Tier, slug: string, probe: Partial<ProbePlan> = {}): D
 		sessionId: "omp-conv-test",
 		sticky: false,
 		cacheBreakpointMessageIndices: [],
+		compactionPlan: [],
+		promptTokensSaved: 0,
 		reasoning: undefined,
 		maxTokens: undefined,
 		stripAssistantReasoning: false,
@@ -251,6 +259,8 @@ function mkConversations(): { store: ConversationStore; map: Map<string, Convers
 				lastPromptTokens: 0,
 				cacheWarmSlug: null,
 				cacheWarmAtMs: 0,
+				contextVersion: null,
+				contextFetchedAtMs: 0,
 				updatedAtMs: 0,
 			};
 			map.set(k, fresh);
@@ -317,7 +327,7 @@ describe("runTurn", () => {
 		const { store, map } = mkConversations();
 		const { sink, chunks, errors, finishes } = mkSink();
 
-		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog }, new AbortController().signal);
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
 
 		expect(errors).toHaveLength(0);
 		expect(finishes).toHaveLength(1);
@@ -366,7 +376,7 @@ describe("runTurn", () => {
 		const { store } = mkConversations();
 		const { sink, chunks, errors, finishes } = mkSink();
 
-		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog }, new AbortController().signal);
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
 
 		expect(errors).toHaveLength(0);
 		expect(entries).toHaveLength(2);
@@ -404,7 +414,7 @@ describe("runTurn", () => {
 		const { store } = mkConversations();
 		const { sink, chunks, errors, finishes } = mkSink();
 
-		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog }, new AbortController().signal);
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
 
 		// Bytes reached the client, so the 429 mid-stream is surfaced, not retried.
 		expect(calls).toHaveLength(1);
@@ -424,7 +434,7 @@ describe("runTurn", () => {
 		const { store } = mkConversations();
 		const { sink, errors, finishes } = mkSink();
 
-		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog }, new AbortController().signal);
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
 
 		expect(calls).toHaveLength(1); // no retry, no escalation on auth
 		expect(finishes).toHaveLength(0);
@@ -448,7 +458,7 @@ describe("runTurn", () => {
 		const { store } = mkConversations();
 		const { sink, errors, finishes } = mkSink();
 
-		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog }, new AbortController().signal);
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
 
 		expect(errors).toHaveLength(0);
 		expect(finishes).toHaveLength(1);
@@ -488,14 +498,14 @@ describe("runTurn", () => {
 		const { sink, errors } = mkSink();
 
 		// Turn 1: first turn, no prior tier → re-arms (tierChanged true).
-		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog }, new AbortController().signal);
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
 		const afterFirst = map.get("conv-test")!;
 		expect(afterFirst.currentTier).toBe("hard");
 		expect(afterFirst.stickyUntilTurn).toBe(1 + 2); // holdTurns=2
 
 		// Turn 2: same tier served again → must NOT re-arm. The window should
 		// stay at its previous expiry (turn 3), not extend to turn 4.
-		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog }, new AbortController().signal);
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
 		const afterSecond = map.get("conv-test")!;
 		expect(afterSecond.currentTier).toBe("hard");
 		expect(afterSecond.stickyUntilTurn).toBe(3); // unchanged, not 4
@@ -517,7 +527,7 @@ describe("exploration reaches the ledger", () => {
 		const { store } = mkConversations();
 		const { sink } = mkSink();
 
-		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog }, new AbortController().signal);
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
 
 		expect(entries).toHaveLength(1);
 		// The counterfactual pair: what the classifier wanted, and what actually ran.
@@ -537,7 +547,7 @@ describe("exploration reaches the ledger", () => {
 		const { store } = mkConversations();
 		const { sink } = mkSink();
 
-		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog }, new AbortController().signal);
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
 
 		expect(entries).toHaveLength(1);
 		expect(entries[0]?.exploredFrom).toBeNull();