auto-model-router 0.4.0 → 0.4.2

package/test/controls.test.ts

@@ -6,6 +6,7 @@ import { createFeedbackStore } from "../src/cost/feedback.ts";
 import { createLedger } from "../src/cost/ledger.ts";
 import { EMPTY_USAGE, type LedgerEntry } from "../src/cost/types.ts";
 import { startServer, type StartedServer } from "../src/server/http.ts";
+import { resolveProfile } from "../src/router/index.ts";
 import { ollamaRunway } from "../src/server/http.ts";
 import { createSessionOverrides, OVERRIDE_TTL_MS } from "../src/server/overrides.ts";
 import { openDb } from "../src/util/sqlite.ts";
@@ -121,7 +122,7 @@ describe("override and feedback endpoints", () => {
 	beforeAll(() => {
 		const cfg: RouterConfig = {
 			...structuredClone(DEFAULT_CONFIG),
-			server: { host: "127.0.0.1", port: 0, maxConcurrentTurns: 24 },
+			server: { host: "127.0.0.1", port: 0, maxConcurrentTurns: 24, subagentProfile: "auto-sub" },
 			ledger: { ...DEFAULT_CONFIG.ledger, path: ":memory:" },
 			logLevel: "silent",
 		};
@@ -221,3 +222,51 @@ describe("ollamaRunway", () => {
 		expect(ollamaRunway(null, 7, 1)).toBeNull();
 	});
 });
+
+describe("subagent profile", () => {
+	test("a subagent asking for the default profile is routed under server.subagentProfile; explicit profiles are honoured", () => {
+		const cfg = structuredClone(DEFAULT_CONFIG);
+		expect(resolveProfile(cfg, "auto", true).id).toBe("auto-sub");
+		expect(resolveProfile(cfg, "auto", false).id).toBe("auto");
+		expect(resolveProfile(cfg, "auto-max", true).id).toBe("auto-max");
+		expect(resolveProfile(cfg, "unknown", true).id).toBe("auto-sub"); // unknown ids fall back to the default, which a subagent remaps
+		cfg.server.subagentProfile = "";
+		expect(resolveProfile(cfg, "auto", true).id).toBe("auto");
+		cfg.server.subagentProfile = "nope";
+		expect(resolveProfile(cfg, "auto", true).id).toBe("auto");
+	});
+});
+
+describe("digest endpoints", () => {
+	let handle: StartedServer;
+	let baseUrl = "";
+	beforeAll(() => {
+		const cfg: RouterConfig = {
+			...structuredClone(DEFAULT_CONFIG),
+			server: { host: "127.0.0.1", port: 0, maxConcurrentTurns: 24, subagentProfile: "auto-sub" },
+			ledger: { ...DEFAULT_CONFIG.ledger, path: ":memory:" },
+			logLevel: "silent",
+		};
+		cfg.digest = { ...cfg.digest, enabled: true, minBytes: 10 };
+		handle = startServer(cfg);
+		baseUrl = `http://127.0.0.1:${handle.server.port}`;
+	});
+	afterAll(async () => {
+		await handle.stop();
+	});
+
+	test("policy reflects the config; a digest for a session with no turns is declined, a bad body rejected", async () => {
+		const policy = (await (await fetch(`${baseUrl}/v1/router/digest/policy`)).json()) as { enabled: boolean; minBytes: number; tools: string[] };
+		expect(policy.enabled).toBe(true);
+		expect(policy.minBytes).toBe(10);
+		expect(policy.tools).toContain("read");
+		const bad = await fetch(`${baseUrl}/v1/router/digest`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ toolName: "read" }) });
+		expect(bad.status).toBe(400);
+		const res = await fetch(`${baseUrl}/v1/router/digest`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({ ompSessionId: "never", toolName: "read", input: {}, content: "x".repeat(100), query: "q" }),
+		});
+		expect((await res.json()) as unknown).toMatchObject({ digested: false, reason: "no routed turn in this session yet" });
+	});
+});

package/test/digest.test.ts

@@ -0,0 +1,207 @@
+import { describe, expect, test } from "bun:test";
+
+import { normalizeCatalogModel } from "../src/catalog/openrouter-catalog.ts";
+import type { CatalogModel, CatalogSnapshot, CatalogSource } from "../src/catalog/types.ts";
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
+import type { RouterConfig } from "../src/config/types.ts";
+import { createLedger } from "../src/cost/ledger.ts";
+import type { LedgerEntry } from "../src/cost/types.ts";
+import { createDigester, digestApplies, digestMarker } from "../src/server/digest.ts";
+import type { UpstreamClient } from "../src/upstream/types.ts";
+import { createLogger } from "../src/util/log.ts";
+import { openDb } from "../src/util/sqlite.ts";
+import { digestToast, parsePolicy, shouldSend, textOf } from "../omp-extension/digest-logic.ts";
+
+/**
+ * The tool-result digest: gates (tool, size, error, session tier, cost),
+ * model choice from the cheap tier, the marker that keeps the full output
+ * reachable, the ledger row every digest leaves, and the extension's
+ * client-side checks.
+ */
+
+const FIXTURE = (await Bun.file("test/fixtures/openrouter-models.json").json()) as { data: unknown[] };
+const MODELS: CatalogModel[] = FIXTURE.data.map(normalizeCatalogModel).filter((m): m is CatalogModel => m !== null);
+const SNAPSHOT: CatalogSnapshot = { models: MODELS, fetchedAtMs: Date.now() };
+const catalog: CatalogSource = {
+	get: async () => SNAPSHOT,
+	refresh: async () => SNAPSHOT,
+	peek: () => SNAPSHOT,
+	find: (slug) => MODELS.find((m) => m.slug === slug),
+};
+const log = createLogger("silent");
+
+function cfgWith(over: Partial<RouterConfig["digest"]> = {}): RouterConfig {
+	const cfg = structuredClone(DEFAULT_CONFIG);
+	cfg.ledger.path = ":memory:";
+	cfg.digest = { ...cfg.digest, enabled: true, minBytes: 100, ...over };
+	return cfg;
+}
+
+function seedSession(ledger: ReturnType<typeof createLedger>, tier: string): void {
+	const e: LedgerEntry = {
+		id: crypto.randomUUID(),
+		createdAtMs: Date.now(),
+		conversationKey: "k",
+		sessionId: "s",
+		turn: 3,
+		requestedModel: "auto",
+		harnessId: "",
+		ompSessionId: "omp-1",
+		slug: "x/y",
+		servedSlug: "x/y",
+		tier,
+		classificationSource: "heuristic",
+		reasons: [],
+		features: null,
+		score: null,
+		confidence: null,
+		task: null,
+		classifierReasons: null,
+		exploredFrom: null,
+		holdArm: null,
+		predictedUsd: 0.01,
+		reportedUsd: 0.01,
+		usage: { promptTokens: 100, cachedTokens: 0, cacheWriteTokens: 0, completionTokens: 10, reasoningTokens: 0, images: 0 },
+		attempt: 0,
+		escalationSignal: null,
+		latencyMs: 100,
+		ttftMs: 50,
+		finishReason: "stop",
+		wasted: false,
+		upstreamGenerationId: null,
+		error: null,
+		promptTokensSaved: 0,
+	};
+	ledger.record(e);
+}
+
+function fakeUpstream(reply: (body: Record<string, unknown>) => string, costUsd: number | null = 0.0004): { upstream: UpstreamClient; calls: Record<string, unknown>[] } {
+	const calls: Record<string, unknown>[] = [];
+	return {
+		calls,
+		upstream: {
+			dispatch: () => Promise.reject(new Error("not used")),
+			complete: async (body) => {
+				calls.push(body);
+				return { text: reply(body), costUsd };
+			},
+			fetchModels: () => Promise.resolve([]),
+			fetchModelsForUser: () => Promise.resolve([]),
+		},
+	};
+}
+
+const BIG = Array.from({ length: 400 }, (_, i) => `${i + 1}: export const value${i} = ${i};`).join("\n");
+
+describe("digestApplies", () => {
+	const d = { ...DEFAULT_CONFIG.digest, enabled: true, minBytes: 100, maxBytes: 1000 };
+	test("gates on switch, error, tool, size and session tier", () => {
+		expect(digestApplies({ ...d, enabled: false }, "read", 500, false, "hard").ok).toBe(false);
+		expect(digestApplies(d, "read", 500, true, "hard").ok).toBe(false);
+		expect(digestApplies(d, "edit", 500, false, "hard").ok).toBe(false);
+		expect(digestApplies(d, "read", 50, false, "hard").ok).toBe(false);
+		expect(digestApplies(d, "read", 5000, false, "hard").ok).toBe(false);
+		expect(digestApplies(d, "read", 500, false, null).ok).toBe(false);
+		expect(digestApplies(d, "read", 500, false, "simple").ok).toBe(false); // below fromTier moderate
+		expect(digestApplies(d, "read", 500, false, "moderate").ok).toBe(true);
+		expect(digestApplies(d, "READ", 500, false, "hard").ok).toBe(true);
+	});
+});
+
+describe("createDigester", () => {
+	test("condenses a large read for a hard-tier session on a cheap model and records a ledger row", async () => {
+		const cfg = cfgWith();
+		const db = openDb(":memory:");
+		const ledger = createLedger(db, cfg);
+		seedSession(ledger, "hard");
+		const { upstream, calls } = fakeUpstream(() => "Omitted 380 trivial constants.\n1: export const value0 = 0;\n...");
+		const d = createDigester({ cfg, catalog, ledger, upstream, log });
+		const r = await d.digest({ ompSessionId: "omp-1", harnessId: "", toolName: "read", input: { path: "src/values.ts" }, content: BIG, query: "find value0" });
+		expect(r.digested).toBe(true);
+		if (!r.digested) return;
+		expect(r.text.startsWith("[digest: read output")).toBe(true);
+		expect(r.text).toContain("re-run read {\"path\":\"src/values.ts\"} (offset/limit for a range)");
+		expect(r.text).toContain("Omitted 380 trivial constants.");
+		expect(r.usd).toBeCloseTo(0.0004, 6);
+		// The cheap tier picked the model; the call carried the task and the raw output.
+		const call = calls[0]!;
+		expect(typeof call.model).toBe("string");
+		expect(catalog.find(call.model as string)?.price.prompt).toBeLessThanOrEqual(cfg.tiers.simple.maxInputPerMtok! / 1e6);
+		expect(JSON.stringify(call.messages)).toContain("Task: find value0");
+		// A ledger row under requestedModel "digest" with the served model and its cost.
+		const rows = ledger.recentEntries(10).filter((e) => e.requestedModel === "digest");
+		expect(rows).toHaveLength(1);
+		expect(rows[0]!.slug).toBe(call.model as string);
+		expect(rows[0]!.reportedUsd).toBeCloseTo(0.0004, 6);
+		expect(rows[0]!.ompSessionId).toBe("omp-1");
+		db.close();
+	});
+
+	test("declines below the session tier, over the cost guard, when the model fails, or when nothing shrinks", async () => {
+		const db = openDb(":memory:");
+		const cfg = cfgWith();
+		const ledger = createLedger(db, cfg);
+		seedSession(ledger, "simple");
+		const cheap = createDigester({ cfg, catalog, ledger, upstream: fakeUpstream(() => "short").upstream, log });
+		expect(await cheap.digest({ ompSessionId: "omp-1", harnessId: "", toolName: "read", input: {}, content: BIG, query: "" })).toMatchObject({ digested: false, reason: expect.stringContaining("below digest.fromTier") });
+
+		const db2 = openDb(":memory:");
+		const strict = cfgWith({ maxCostUsd: 0 });
+		const ledger2 = createLedger(db2, strict);
+		seedSession(ledger2, "hard");
+		expect(await createDigester({ cfg: strict, catalog, ledger: ledger2, upstream: fakeUpstream(() => "x").upstream, log }).digest({ ompSessionId: "omp-1", harnessId: "", toolName: "read", input: {}, content: BIG, query: "" })).toMatchObject({ digested: false, reason: expect.stringContaining("exceeds digest.maxCostUsd") });
+
+		const failing: UpstreamClient = { ...fakeUpstream(() => "x").upstream, complete: () => Promise.reject(new Error("boom")) };
+		expect(await createDigester({ cfg, catalog, ledger: ledger2, upstream: failing, log }).digest({ ompSessionId: "omp-1", harnessId: "", toolName: "read", input: {}, content: BIG, query: "" })).toMatchObject({ digested: false, reason: "digest model failed: boom" });
+		// The failed attempt is still a ledger row, with the error.
+		expect(ledger2.recentEntries(5).find((e) => e.requestedModel === "digest")?.error).toBe("boom");
+
+		const same = createDigester({ cfg, catalog, ledger: ledger2, upstream: fakeUpstream(() => BIG).upstream, log });
+		expect(await same.digest({ ompSessionId: "omp-1", harnessId: "", toolName: "read", input: {}, content: BIG, query: "" })).toMatchObject({ digested: false, reason: "digest did not shrink the output" });
+		db.close();
+		db2.close();
+	});
+
+	test("a pinned digest model is used as-is", async () => {
+		const pinned = MODELS.find((m) => m.price.prompt > 0)!.slug;
+		const cfg = cfgWith({ model: pinned });
+		const db = openDb(":memory:");
+		const ledger = createLedger(db, cfg);
+		seedSession(ledger, "hard");
+		const { upstream, calls } = fakeUpstream(() => "digest");
+		await createDigester({ cfg, catalog, ledger, upstream, log }).digest({ ompSessionId: "omp-1", harnessId: "", toolName: "grep", input: { pattern: "x" }, content: BIG, query: "" });
+		expect(calls[0]?.model as string).toBe(pinned);
+		db.close();
+	});
+});
+
+describe("digest marker and extension logic", () => {
+	test("the marker names the tool, sizes, model and how to get the full output", () => {
+		expect(digestMarker("grep", { pattern: "retry" }, "z-ai/glm-5.3-flash", 48_000, 3_000)).toBe(
+			'[digest: grep output 48,000 bytes → 3,000 chars by z-ai/glm-5.3-flash. Full output: re-run grep {"pattern":"retry"}]',
+		);
+	});
+
+	test("textOf joins text parts and flags images", () => {
+		expect(textOf([{ type: "text", text: "a" }, { type: "text", text: "b" }])).toEqual({ text: "a\nb", hasImage: false });
+		expect(textOf([{ type: "image" }, { type: "text", text: "a" }])).toEqual({ text: "a", hasImage: true });
+	});
+
+	test("shouldSend applies the client-side gate; parsePolicy is defensive", () => {
+		const p = parsePolicy({ enabled: true, minBytes: 10, maxBytes: 100, tools: ["Read", "grep"], fromTier: "hard" });
+		expect(p.tools).toEqual(["read", "grep"]);
+		expect(shouldSend(p, "read", false, "x".repeat(50), false)).toBe(true);
+		expect(shouldSend(p, "read", true, "x".repeat(50), false)).toBe(false);
+		expect(shouldSend(p, "read", false, "x".repeat(50), true)).toBe(false);
+		expect(shouldSend(p, "edit", false, "x".repeat(50), false)).toBe(false);
+		expect(shouldSend(p, "read", false, "x".repeat(5), false)).toBe(false);
+		expect(shouldSend(p, "read", false, "x".repeat(500), false)).toBe(false);
+		expect(parsePolicy({ enabled: false }).enabled).toBe(false);
+		expect(parsePolicy("nope").enabled).toBe(false);
+		expect(parsePolicy({ enabled: true }).minBytes).toBe(12_000);
+	});
+
+	test("digestToast is one readable line", () => {
+		expect(digestToast("read", 48 * 1024, 3 * 1024, "ollama/glm-5.3-flash", 0.00042)).toBe("digested read 48KB → 3KB via glm-5.3-flash ($0.0004)");
+	});
+});

package/test/embed-lifecycle.test.ts

@@ -29,7 +29,7 @@ import type { ExtensionAPI, ExtensionContext, ProviderRegistration } from "@oh-m
  */
 
 const registrations: { id: string; baseUrl: string }[] = [];
-const handlers = new Map<string, ((event: unknown, ctx: ExtensionContext) => void | Promise<void>)[]>();
+const handlers = new Map<string, ((event: unknown, ctx: ExtensionContext) => unknown)[]>();
 
 const pi: ExtensionAPI = {
 	setLabel: () => {},

package/test/escalate.test.ts

@@ -24,6 +24,7 @@ function req(messages: NormMessage[] = [], over: Partial<NormRequest> = {}): Nor
 		harnessId: "",
 		ompSessionId: "",
 		agentdoxScope: "",
+		isSubagent: false,
 		requestedModel: "auto",
 		messages,
 		tools: [],

package/test/failover.test.ts

@@ -29,7 +29,7 @@ import type {
 
 function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 	return {
-		server: { host: "127.0.0.1", port: 8787, maxConcurrentTurns: 24 },
+		server: { host: "127.0.0.1", port: 8787, maxConcurrentTurns: 24, subagentProfile: "auto-sub" },
 		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, planCreditsUsd: 0 },
 		benchmarks: { enabled: false, artificialAnalysisApiKey: "", benchlm: true, refreshMs: 86_400_000, timeoutMs: 30_000, useLocalScores: false },
@@ -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, 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, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
 		classifier: {
 			ambiguityThreshold: 0,
 			model: "test/adjudicator", learnedModelPath: "",
@@ -57,7 +57,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			toolAxis: "coding",
 			chatAxis: "intelligence",
 			agenticLoopDepth: 3,
-			mechanicalRetryFactor: 0.2,
+			mechanicalRetryFactor: 0.2, readOnlyToolWeight: 0,
 			reasoningWeights: { medium: 0.14, high: 0.24, xhigh: 0.3, max: 0.34 },
 		},
 		escalation: {
@@ -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 },
 		budget: { onExceeded: "downgrade" },
 		report: { baselines: [] },
+		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 },
 		adaptiveTierFloors: true,
@@ -92,6 +93,7 @@ function mkReq(): NormRequest {
 		harnessId: "",
 		ompSessionId: "",
 		agentdoxScope: "",
+		isSubagent: false,
 		requestedModel: "auto",
 		messages: [{ role: "user", text: "hi", images: 0, textBytes: 2, toolCalls: [] }],
 		tools: [],

package/test/features.test.ts

@@ -337,3 +337,35 @@ describe("prompt anatomy", () => {
 		expect(a.olderHalfBytes).toBe(0);
 	});
 });
+
+describe("subagent and read-only tool loop signals", () => {
+	test("a tool-result tail behind read-only calls is flagged; a write call clears it", () => {
+		const reads = req([
+			SYSTEM,
+			{ role: "user", content: "find the retry helper" },
+			{ role: "assistant", content: null, tool_calls: [
+				{ id: "a", type: "function", function: { name: "grep", arguments: "{\"pattern\":\"retry\"}" } },
+				{ id: "b", type: "function", function: { name: "read", arguments: "{\"path\":\"x.ts\"}" } },
+			] },
+			{ role: "tool", tool_call_id: "a", content: "x.ts:12" },
+			{ role: "tool", tool_call_id: "b", content: "export function retry() {}" },
+		]);
+		expect(extractFeatures(reads, 1000).readOnlyToolTail).toBe(true);
+		const write = req([
+			SYSTEM,
+			{ role: "user", content: "fix it" },
+			toolCall("c", "edit", "{\"path\":\"x.ts\"}"),
+			{ role: "tool", tool_call_id: "c", content: "ok" },
+		]);
+		expect(extractFeatures(write, 1000).readOnlyToolTail).toBe(false);
+		// A fresh user turn is never a read-only tail, whatever came before.
+		expect(extractFeatures(req([SYSTEM, { role: "user", content: "now what?" }]), 100).readOnlyToolTail).toBe(false);
+	});
+
+	test("the subagent marker rides on the request", () => {
+		const r = parseChatRequest({ model: "auto", messages: [SYSTEM, { role: "user", content: "hi" }], tools: TOOLS }, new Headers({ "x-omp-subagent": "1" }));
+		expect(r.isSubagent).toBe(true);
+		expect(extractFeatures(r, 100).isSubagent).toBe(true);
+		expect(req([SYSTEM, { role: "user", content: "hi" }]).isSubagent).toBe(false);
+	});
+});

package/test/http-resilience.test.ts

@@ -10,7 +10,7 @@ describe("HTTP server resilience against dead streams", () => {
 	beforeAll(() => {
 		const cfg: RouterConfig = {
 			...DEFAULT_CONFIG,
-			server: { host: "127.0.0.1", port: 0, maxConcurrentTurns: 24 },
+			server: { host: "127.0.0.1", port: 0, maxConcurrentTurns: 24, subagentProfile: "auto-sub" },
 			ledger: { ...DEFAULT_CONFIG.ledger, path: ":memory:" },
 			context: { ...DEFAULT_CONFIG.context, enabled: false },
 			logLevel: "silent",

package/test/report-hub.test.ts

@@ -76,6 +76,11 @@ function report(over: Partial<UsageReport> = {}): UsageReport {
 			aborted: 0,
 			modelSwitches: 1,
 			cacheEstimated: false,
+			subagentDispatches: 0,
+			subagentSpendUsd: 0,
+			digests: 0,
+			digestSpendUsd: 0,
+			digestInputTokens: 0,
 		},
 		providers: [row("openrouter", 2), row("ollama", 1)],
 		models: [

package/test/report.test.ts

@@ -197,6 +197,18 @@ describe("buildUsageReport", () => {
 		db.close();
 	});
 
+	test("subagent turns are counted with their spend", () => {
+		const { db, ledger } = seeded();
+		ledger.record(entry({ reportedUsd: 0.01, features: { isSubagent: true } }));
+		ledger.record(entry({ reportedUsd: 0.03, features: { isSubagent: false } }));
+		ledger.record(entry({ reportedUsd: 0.06 }));
+		const r = buildUsageReport(db, { windowDays: 7, nowMs: NOW });
+		expect(r.totals.subagentDispatches).toBe(1);
+		expect(r.totals.subagentSpendUsd).toBeCloseTo(0.01, 6);
+		expect(renderUsageReport(r)).toContain("subagents: 1 dispatches, $0.0100 (10% of spend)");
+		db.close();
+	});
+
 	test("empty ledger yields zeroed totals and null speeds", () => {
 		const { db } = seeded();
 		const r = buildUsageReport(db, { windowDays: 7, nowMs: NOW });
@@ -213,6 +225,11 @@ describe("buildUsageReport", () => {
 			aborted: 0,
 			modelSwitches: 0,
 			cacheEstimated: false,
+			subagentDispatches: 0,
+			subagentSpendUsd: 0,
+			digests: 0,
+			digestSpendUsd: 0,
+			digestInputTokens: 0,
 		});
 		expect(r.providers).toEqual([]);
 		expect(r.models).toEqual([]);

package/test/trust-attribution.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test";
+import { createFeedbackStore } from "../src/cost/feedback.ts";
 
 import { loadConfig } from "../src/config/load.ts";
 import { createLedger, LATENCY_WINDOW_ROWS } from "../src/cost/ledger.ts";
@@ -410,3 +411,55 @@ describe("cache reliability signal", () => {
 		db.close();
 	});
 });
+
+describe("feedback in trust", () => {
+	// A user verdict counts as filters.feedbackWeight attempts of that outcome.
+	function trustWith(weight: number, verdicts: Array<"good" | "bad">): { rate: number; good: number; bad: number } {
+		const db = openDb(":memory:");
+		try {
+			const c = structuredClone(cfg);
+			c.filters.feedbackWeight = weight;
+			const ledger = createLedger(db, c);
+			const fb = createFeedbackStore(db);
+			let last = "";
+			for (let i = 0; i < 10; i++) {
+				const e = entry({ error: null });
+				last = e.id;
+				ledger.record(e);
+			}
+			for (const v of verdicts) fb.record({ ledgerId: last, ompSessionId: "s", slug: "vendor/model", tier: "simple", verdict: v, note: "" });
+			const t = ledger.trust("vendor/model")!;
+			return { rate: t.successRate, good: t.feedbackGood ?? -1, bad: t.feedbackBad ?? -1 };
+		} finally {
+			db.close();
+		}
+	}
+
+	test("weight 0 records verdicts without moving the rate", () => {
+		const base = trustWith(0, []);
+		expect(base.rate).toBeCloseTo(11 / 12, 6); // (10 - 0 + 1) / (10 + 2)
+		expect(trustWith(0, ["bad", "bad"]).rate).toBeCloseTo(base.rate, 6);
+	});
+
+	test("a bad verdict counts as `weight` failures, a good one as `weight` successes", () => {
+		// 10 clean attempts + one bad verdict at weight 3: attempts 13, failures 3.
+		const bad = trustWith(3, ["bad"]);
+		expect(bad.rate).toBeCloseTo((13 - 3 + 1) / (13 + 2), 6);
+		expect(bad.bad).toBe(1);
+		const good = trustWith(3, ["good"]);
+		expect(good.rate).toBeCloseTo((13 - 0 + 1) / (13 + 2), 6);
+		expect(good.good).toBe(1);
+		// allTrust and signals agree with trust().
+		const db = openDb(":memory:");
+		const c = structuredClone(cfg);
+		c.filters.feedbackWeight = 3;
+		const ledger = createLedger(db, c);
+		const fb = createFeedbackStore(db);
+		const e = entry({ error: null });
+		ledger.record(e);
+		fb.record({ ledgerId: e.id, ompSessionId: "s", slug: "vendor/model", tier: "simple", verdict: "bad", note: "" });
+		expect(ledger.allTrust()[0]?.successRate).toBeCloseTo(ledger.trust("vendor/model")!.successRate, 9);
+		expect(ledger.signals?.(["vendor/model"]).get("vendor/model")?.trust?.successRate).toBeCloseTo(ledger.trust("vendor/model")!.successRate, 9);
+		db.close();
+	});
+});

package/test/turn.test.ts

@@ -29,7 +29,7 @@ import type {
 
 function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 	return {
-		server: { host: "127.0.0.1", port: 8787, maxConcurrentTurns: 24 },
+		server: { host: "127.0.0.1", port: 8787, maxConcurrentTurns: 24, subagentProfile: "auto-sub" },
 		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, planCreditsUsd: 0 },
 		benchmarks: { enabled: false, artificialAnalysisApiKey: "", benchlm: true, refreshMs: 86_400_000, timeoutMs: 30_000, useLocalScores: false },
@@ -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, 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, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
 		classifier: {
 			ambiguityThreshold: 0,
 			model: "test/adjudicator", learnedModelPath: "",
@@ -57,7 +57,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			toolAxis: "coding",
 			chatAxis: "intelligence",
 			agenticLoopDepth: 3,
-			mechanicalRetryFactor: 0.2,
+			mechanicalRetryFactor: 0.2, readOnlyToolWeight: 0,
 			reasoningWeights: { medium: 0.14, high: 0.24, xhigh: 0.3, max: 0.34 },
 		},
 		escalation: {
@@ -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 },
 		budget: { onExceeded: "downgrade" },
 		report: { baselines: [] },
+		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 },
 		adaptiveTierFloors: true,
@@ -92,6 +93,7 @@ function mkReq(): NormRequest {
 		harnessId: "",
 		ompSessionId: "",
 		agentdoxScope: "",
+		isSubagent: false,
 		requestedModel: "auto",
 		messages: [{ role: "user", text: "hi", images: 0, textBytes: 2, toolCalls: [] }],
 		tools: [],

package/tools/replay.ts

@@ -197,6 +197,7 @@ function requestOf(row: Row, f: Features): NormRequest {
 		harnessId: row.harness_id,
 		ompSessionId: "",
 		agentdoxScope: "",
+		isSubagent: false,
 		requestedModel: row.requested_model,
 		messages,
 		tools,