auto-model-router 0.2.16 → 0.2.21

package/src/config/hot-reload.ts

@@ -0,0 +1,163 @@
+/**
+ * Hot reload for `config.yml`.
+ *
+ * The router is long-lived (an omp session embeds it), and the ranking knobs —
+ * tiers, filters, escalation, budgets, hysteresis — are exactly what a tuning
+ * session wants to change without restarting the harness. This module watches
+ * the config file, re-validates it through the same schema `loadConfig` uses,
+ * and mutates the SHARED config object in place.
+ *
+ * In-place mutation is the design: every consumer reads `cfg.tiers`,
+ * `cfg.filters`, `cfg.escalation` … at call time through the same object
+ * reference, so field assignment makes every per-turn read live with zero
+ * call-site changes. What is deliberately NOT reloaded is anything captured at
+ * construction — the listening socket (server.*), the OpenRouter client
+ * (openrouter.*), and the agentdox bridge (context.*). Those still require a
+ * restart; the watcher re-pinns them from the live object and reports skips.
+ *
+ * Safety properties:
+ *  - Schema validation BEFORE any mutation; an invalid file leaves the running
+ *    config untouched and logs the zod issues, exactly like loadConfig.
+ *  - fs.watch fires several times per save; a trailing debounce collapses them.
+ *  - A half-written or invalid file never throws into the watcher: the reload
+ *    is skipped and the previous config keeps serving.
+ *  - A deleted or emptied knob reverts to its DEFAULT, mirroring loadConfig's
+ *    merge order (defaults <- file): the file is the source of truth, so
+ *    disabling a feature by deleting its key works.
+ */
+
+import { existsSync, readFileSync, watch, type FSWatcher } from "node:fs";
+import { parse as parseYaml } from "yaml";
+import { configInputSchema } from "./schema.ts";
+import { DEFAULT_CONFIG } from "./defaults.ts";
+import { deepMerge, resolveTilde } from "./load.ts";
+import type { RouterConfig } from "./types.ts";
+
+/** Milliseconds of quiet after the last fs event before a reload actually runs. */
+const DEBOUNCE_MS = 250;
+
+/** The validated file input, or why it could not be used. */
+export type ConfigRead =
+	| { ok: true; cfg: RouterConfig }
+	| { ok: false; error: string };
+
+/**
+ * Re-reads and schema-validates the config file. Exported for tests: this is
+ * the exact gate a file must pass before it may touch the running config.
+ *
+ * The result is merged over DEFAULT_CONFIG — the file is the full source of
+ * truth, so a knob REMOVED from the file reverts to its default, matching what
+ * a restart would do. `server`/`openrouter`/`context` come back too, but the
+ * applier re-pinns those blocks from the live object, since they were captured
+ * by construction.
+ */
+export function readValidatedConfig(path: string): ConfigRead {
+	try {
+		if (!existsSync(path)) return { ok: false, error: "file missing" };
+		const raw: unknown = parseYaml(readFileSync(path, "utf8"));
+		if (raw === null || raw === undefined) return { ok: false, error: "file empty" };
+		const parsed = configInputSchema.safeParse(raw);
+		if (!parsed.success) {
+			const lines = parsed.error.issues
+				.slice(0, 5)
+				.map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`)
+				.join("\n");
+			return { ok: false, error: `schema validation failed:\n${lines}` };
+		}
+		return { ok: true, cfg: deepMerge(DEFAULT_CONFIG, parsed.data) };
+	} catch (err) {
+		return { ok: false, error: err instanceof Error ? err.message : String(err) };
+	}
+}
+
+/** What changed in a reload, for logging. */
+export interface ReloadSummary {
+	changed: string[];
+}
+
+/** A live config file watcher. */
+export interface ConfigWatcher {
+	/** Stops watching. Idempotent. */
+	close(): void;
+}
+
+/** Options for watchConfig. */
+export interface WatchConfigOptions {
+	/** Called after a successful in-place reload that changed something. */
+	onReload?: (summary: ReloadSummary) => void;
+	/** Called when a file could not be applied (invalid, unreadable). */
+	onError?: (message: string) => void;
+}
+
+/**
+ * Watches `path` and applies valid changes to `live` in place. `frozen` blocks
+ * (top-level names) are re-copied from `pinned` after every reload so file
+ * edits to construction-captured blocks cannot silently diverge.
+ */
+export function watchConfig(
+	path: string,
+	live: RouterConfig,
+	pinned: RouterConfig,
+	frozen: readonly (keyof RouterConfig)[],
+	opts: WatchConfigOptions = {},
+): ConfigWatcher {
+	let closed = false;
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	let lastError = "";
+
+	const apply = (): void => {
+		if (closed) return;
+		const result = readValidatedConfig(path);
+		if (!result.ok) {
+			// A half-written file is normal (editors truncate-then-write): stay on
+			// the current config. Report each distinct error once.
+			if (result.error !== lastError) {
+				lastError = result.error;
+				opts.onError?.(result.error);
+			}
+			return;
+		}
+		lastError = "";
+
+		const frozenSet = new Set(frozen);
+		const changed: string[] = [];
+		const next = result.cfg as unknown as Record<string, unknown>;
+		for (const key of Object.keys(next)) {
+			// Frozen blocks belong to construction: keep the pinned values.
+			const value = frozenSet.has(key as keyof RouterConfig)
+				? (pinned as unknown as Record<string, unknown>)[key]
+				: next[key];
+			const before = JSON.stringify((live as unknown as Record<string, unknown>)[key]);
+			const after = JSON.stringify(value);
+			if (before !== after) changed.push(key);
+			(live as unknown as Record<string, unknown>)[key] = value;
+		}
+		if (changed.length > 0) opts.onReload?.({ changed });
+	};
+
+	const schedule = (): void => {
+		clearTimeout(timer);
+		timer = setTimeout(() => {
+			timer = undefined;
+			apply();
+		}, DEBOUNCE_MS);
+	};
+
+	let watcher: FSWatcher | null = null;
+	try {
+		watcher = watch(resolveTilde(path), { persistent: false }, schedule);
+	} catch {
+		// Unwatchable file is not fatal: the router keeps its boot config.
+	}
+
+	return {
+		close() {
+			closed = true;
+			clearTimeout(timer);
+			timer = undefined;
+			watcher?.close();
+			watcher = null;
+		},
+	};
+}
+

package/src/config/load.ts

@@ -36,7 +36,7 @@ function mergeValue(base: unknown, override: unknown): unknown {
 	return override;
 }
 
-function deepMerge(base: RouterConfig, override: unknown): RouterConfig {
+export function deepMerge(base: RouterConfig, override: unknown): RouterConfig {
 	return mergeValue(base, override) as RouterConfig;
 }
 

package/src/config/schema.ts

@@ -46,6 +46,8 @@ const tierConfig = z.strictObject({
 	maxInputPerMtok: z.number().nonnegative().optional(),
 	maxOutputPerMtok: z.number().nonnegative().optional(),
 	qualityExponent: z.number().nonnegative().optional(),
+	qualityNormalization: z.boolean().optional(),
+	capabilityFloorUsd: z.number().positive().optional(),
 	pin: z.array(z.string()).optional(),
 });
 
@@ -141,6 +143,7 @@ const context = z.strictObject({
 	memoryLimit: z.number().int().positive().optional(),
 	docsLimit: z.number().int().nonnegative().optional(),
 	sessionLimit: z.number().int().nonnegative().optional(),
+	briefChars: z.number().int().nonnegative().optional(),
 	recordTurns: z.boolean().optional(),
 	maxQueue: z.number().int().positive().optional(),
 });

package/src/config/types.ts

@@ -108,6 +108,32 @@ export interface TierConfig {
 	 * above the floor (Pareto-style). Higher ⇒ pay for headroom above it.
 	 */
 	qualityExponent: number;
+	/**
+	 * Rank on quality NORMALISED WITHIN the candidate set instead of on the raw
+	 * 0-100 index. Default false (raw).
+	 *
+	 * Why it exists: raw scores occupy a narrow band (69-78 on the coding axis)
+	 * while prices span ~250x ($0.02-$5.00/MTok), so `(quality/100)^exponent`
+	 * over a forecast cost is a bounded numerator over an unbounded denominator
+	 * — price wins unless the exponent is enormous (measured: ~140 to select a
+	 * frontier model, where 0.715^140 is ~1e-20 and numerically fragile).
+	 * Normalising maps the set's worst quality to 0 and its best to 1, so the
+	 * exponent becomes a legible "how much do I pay for the best available
+	 * model" dial at single digits instead of triple.
+	 */
+	qualityNormalization?: boolean;
+	/**
+	 * Treat this tier as a CAPABILITY FLOOR rather than a cost ranking: pick the
+	 * highest-quality candidate whose forecast turn cost is within this many USD,
+	 * ignoring quality-per-dollar entirely. Unset ⇒ normal ranking.
+	 *
+	 * This is the top tier's real job. `hard` exists because the work needs a
+	 * capable model, so "best quality under a spend cap" states the intent
+	 * directly; ranking by quality/price cannot, since a bargain model always
+	 * wins on the ratio however weak it is. Falls back to the ranked winner when
+	 * no candidate fits the budget, so this can only ever upgrade a choice.
+	 */
+	capabilityFloorUsd?: number;
 	/** Slugs always allowed in this tier regardless of the quality floor. */
 	pin: string[];
 }
@@ -379,6 +405,16 @@ export interface ContextConfig {
 	docsLimit: number;
 	/** Max recent session messages agentdox may select for the block. */
 	sessionLimit: number;
+	/**
+	 * Character budget for the project brief inside the assembled block, 0 to
+	 * omit. The brief is query-independent curated context (overview, style,
+	 * gotchas, decision log) that renders FIRST, where the prompt cache holds it.
+	 * It grows by one entry per recorded decision, so it takes an explicit
+	 * budget; measured on two live scopes, static sections ~1.6k-8.6k chars and
+	 * the decision log the rest. Keep this well inside `maxBlockChars` so the
+	 * query-relevant tail always fits too.
+	 */
+	briefChars: number;
 	/** Write settled turns back to agentdox sessions, tagged with the served model. */
 	recordTurns: boolean;
 	/** Bound on queued write-backs; excess turns are dropped, never buffered unbounded. */

package/src/context/agentdox.ts

@@ -20,6 +20,8 @@ export interface AssembleLimits {
 	memoryLimit: number;
 	docsLimit: number;
 	sessionLimit: number;
+	/** Character budget for the project brief; 0 omits it (pre-brief servers ignore it). */
+	briefChars: number;
 }
 
 export interface AgentDoxClient {
@@ -84,13 +86,16 @@ export function createAgentDoxClient(opts: AgentDoxClientOptions): AgentDoxClien
 	return {
 		async assemble(scope, query, limits) {
 			// camelCase: the REST endpoint ignores snake_case limit keys entirely,
-			// which silently reads as "unbounded".
+			// which silently reads as "unbounded". briefChars is sent even when 0:
+			// an older server ignores the unknown key, and 0 is the documented
+			// "no brief" value there.
 			const res = await request("POST", "/context/assemble", {
 				scope,
 				query,
 				memoryLimit: limits.memoryLimit,
 				docsLimit: limits.docsLimit,
 				sessionLimit: limits.sessionLimit,
+				briefChars: limits.briefChars,
 			});
 			if (res !== null && res.status === 200) {
 				const prompt = promptOf(res.json);

package/src/context/bridge.ts

@@ -38,6 +38,8 @@ export interface BridgeOptions {
 	memoryLimit: number;
 	docsLimit: number;
 	sessionLimit: number;
+	/** Character budget for the project brief rendered first in the block; 0 omits it. */
+	briefChars: number;
 	/** Record settled turns back into agentdox sessions. */
 	recordTurns: boolean;
 	/** Bound on queued write-backs; excess is dropped rather than grown unbounded. */
@@ -81,7 +83,7 @@ function appendFragment(prior: string, next: string): string {
 }
 
 export function createContextBridge(opts: BridgeOptions): ContextBridge {
-	const { client, store, log, maxStalenessMs, maxBlockChars, memoryLimit, docsLimit, sessionLimit, recordTurns, maxQueue } = opts;
+	const { client, store, log, maxStalenessMs, maxBlockChars, memoryLimit, docsLimit, sessionLimit, briefChars, recordTurns, maxQueue } = opts;
 
 	// Serialized write-back queue. Session appends for one conversation must
 	// stay ordered, and agentdox is a local service — one worker is plenty.
@@ -119,7 +121,7 @@ export function createContextBridge(opts: BridgeOptions): ContextBridge {
 				return { ...pinned, fetchedAtMs: input.pinnedFetchedAtMs };
 			}
 
-			const raw = await client.assemble(input.scope, input.query, { memoryLimit, docsLimit, sessionLimit });
+			const raw = await client.assemble(input.scope, input.query, { memoryLimit, docsLimit, sessionLimit, briefChars });
 			if (raw === null) {
 				// agentdox unreachable or empty. Keep serving the pinned block if we
 				// have one: stale shared context beats none, and re-using it also

package/src/context/index.ts

@@ -30,6 +30,7 @@ export function createBridgeFromConfig(cfg: RouterConfig, db: Database): Context
 		memoryLimit: c.memoryLimit,
 		docsLimit: c.docsLimit,
 		sessionLimit: c.sessionLimit,
+		briefChars: c.briefChars,
 		recordTurns: c.recordTurns,
 		maxQueue: c.maxQueue,
 	});

package/src/cost/types.ts

@@ -124,7 +124,12 @@ export interface LedgerEntry {
 	/** Time to first content token, ms. */
 	ttftMs: number | null;
 	finishReason: string | null;
-	/** Tokens billed but discarded because the attempt was aborted and retried. */
+	/**
+	 * Attempt superseded by a retry or escalation. NOT a cost figure: by design
+	 * these rows never carry reported_usd, so "wasted spend" sums to $0.00.
+	 * The meaningful waste measure is retry spend — rows with attempt > 0 that
+	 * DID bill. Kept for compatibility; do not read it as money.
+	 */
 	wasted: boolean;
 	upstreamGenerationId: string | null;
 	error: string | null;

package/src/router/candidates.ts

@@ -134,6 +134,8 @@ export function buildCandidates(args: BuildCandidatesArgs): { candidates: Candid
 
 	const candidates: Candidate[] = [];
 	const rejected: Rejection[] = [];
+	// Carries the trust/latency-adjusted cost into the second scoring pass.
+	const effectiveUsdBySlug = new Map<string, number>();
 
 	for (const model of snapshot.models) {
 		const slug = model.slug;
@@ -231,6 +233,20 @@ export function buildCandidates(args: BuildCandidatesArgs): { candidates: Candid
 			continue;
 		}
 
+		// Every candidate is priced COLD, deliberately, and this has been measured
+		// rather than assumed. Two reasons:
+		//  1. `coldUsd` feeds the budget guard in select.ts, and a budget must
+		//     survive a cache miss.
+		//  2. Discounting the warm slug here only ever LOWERS its effective cost,
+		//     so it can only make the warm model win more often — and the warm
+		//     model is already either the cheapest candidate or kept by the
+		//     dedicated stay-vs-switch comparison in select.ts step 4, which does
+		//     price staying at `cacheRead` against switching at cold+`cacheWrite`.
+		//     So the ranking change has no headroom to alter an outcome.
+		// Verified with tools/replay.ts: scoring the warm candidate at hit rates
+		// 0.5 / 0.8 / 0.95 changed 0 of 897 decisions, and 0 of 702 on the subset
+		// whose conversations ran the expensive model. Cache economics belong in
+		// the switch decision, not in candidate scoring — do not "fix" this.
 		const fc = forecast(model, {
 			promptTokens: features.promptTokens,
 			completionTokens: expectedCompletionTokens,
@@ -249,7 +265,10 @@ export function buildCandidates(args: BuildCandidatesArgs): { candidates: Candid
 				: null;
 		const latencyMult = latencyMultiplier(latency, filters, expectedCompletionTokens);
 		const effectiveUsd = (fc.expectedUsd / Math.max(trustScore, 0.5)) * latencyMult;
-		const score = Math.pow(qualityScore / 100, tierCfg.qualityExponent) / Math.max(effectiveUsd, 1e-9);
+		// Score is assigned in a SECOND PASS below: both qualityNormalization and
+		// capabilityFloorUsd are properties of the candidate SET, not of one
+		// model, so no per-model value can be computed here. Placeholder only.
+		const score = 0;
 
 		const reasons: string[] = [
 			quality === null
@@ -267,6 +286,30 @@ export function buildCandidates(args: BuildCandidatesArgs): { candidates: Candid
 		}
 		if (pinned) reasons.push("pinned into tier");
 		candidates.push({ model, forecast: fc, qualityScore, trustScore, score, reasons });
+		effectiveUsdBySlug.set(slug, effectiveUsd);
+	}
+
+	// Second pass: both new tier modes need the whole set.
+	//  - qualityNormalization rescales quality to the set's own [worst, best]
+	//    range, so the exponent operates on a full 0-1 spread instead of the
+	//    raw index's compressed 69-78 band.
+	//  - capabilityFloorUsd ignores the ratio entirely and takes the highest
+	//    quality candidate affordable within the cap.
+	const qualities = candidates.map((c) => c.qualityScore);
+	const qMin = qualities.length > 0 ? Math.min(...qualities) : 0;
+	const qMax = qualities.length > 0 ? Math.max(...qualities) : 0;
+	const qSpread = qMax - qMin;
+	const normalize = tierCfg.qualityNormalization === true && qSpread > 0;
+	for (const c of candidates) {
+		const effectiveUsd = effectiveUsdBySlug.get(c.model.slug) ?? c.forecast.expectedUsd;
+		// Normalised quality is unitless in [0,1]: the set's cheapest-quality
+		// model scores 0, its best scores 1. A single-model set has no spread,
+		// so it keeps the raw path (guarded by qSpread > 0).
+		const q = normalize ? (c.qualityScore - qMin) / qSpread : c.qualityScore / 100;
+		c.score = Math.pow(q, tierCfg.qualityExponent) / Math.max(effectiveUsd, 1e-9);
+		if (normalize) {
+			c.reasons.push(`quality normalised ${q.toFixed(3)} within set [${qMin}, ${qMax}]`);
+		}
 	}
 
 	candidates.sort((a, b) => {
@@ -285,5 +328,28 @@ export function buildCandidates(args: BuildCandidatesArgs): { candidates: Candid
 		if (b.model.slug === warmSlug) return 1;
 		return a.model.slug < b.model.slug ? -1 : 1;
 	});
+
+	// Capability-floor mode: the top tier's job is "best model the work needs",
+	// which quality-per-dollar cannot express — a bargain model always wins the
+	// ratio however weak it is. Promote the highest-quality candidate whose
+	// forecast turn cost fits the cap to the front. Strictly an upgrade: when
+	// nothing is affordable, or the ranked winner is already the best quality,
+	// the order is untouched.
+	const floorUsd = tierCfg.capabilityFloorUsd;
+	if (floorUsd !== undefined && candidates.length > 1) {
+		let best: Candidate | undefined;
+		for (const c of candidates) {
+			if (c.forecast.coldUsd > floorUsd) continue;
+			if (best === undefined || c.qualityScore > best.qualityScore) best = c;
+		}
+		if (best !== undefined && best !== candidates[0]) {
+			const idx = candidates.indexOf(best);
+			candidates.splice(idx, 1);
+			candidates.unshift(best);
+			best.reasons.push(
+				`capability floor: highest quality ${best.qualityScore} within $${floorUsd}/turn (cold $${best.forecast.coldUsd.toFixed(4)})`,
+			);
+		}
+	}
 	return { candidates, rejected };
 }

package/src/server/http.ts

@@ -10,6 +10,8 @@ import { createConversationStore } from "../router/state.ts";
 import { createOpenRouterClient } from "../upstream/openrouter.ts";
 import { UpstreamError } from "../upstream/types.ts";
 import { apiKeySource } from "../config/load.ts";
+import { routerConfigPath } from "../cli/config-cmd.ts";
+import { watchConfig } from "../config/hot-reload.ts";
 import type { RouterConfig } from "../config/types.ts";
 import { createLogger } from "../util/log.ts";
 import { openDb } from "../util/sqlite.ts";
@@ -167,7 +169,7 @@ function isLoopbackHostHeader(hostHeader: string | null): boolean {
 export function startServer(cfg: RouterConfig): StartedServer {
 	const log = createLogger(cfg.logLevel);
 
-	mkdirSync(dirname(cfg.ledger.path), { recursive: true });
+	if (cfg.ledger.path !== ":memory:") mkdirSync(dirname(cfg.ledger.path), { recursive: true });
 	const db = openDb(cfg.ledger.path);
 	const ledger = createLedger(db, cfg);
 	const upstream = createOpenRouterClient(cfg);
@@ -177,6 +179,27 @@ export function startServer(cfg: RouterConfig): StartedServer {
 	const context = createBridgeFromConfig(cfg, db);
 	const turnDeps = { config: cfg, router, upstream, ledger, conversations, catalog, context };
 
+	// Hot reload: ranking knobs (tiers, filters, escalation, budgets, …) take
+	// effect on the next turn without a restart, because every consumer reads
+	// the shared config object at call time. Construction-captured blocks
+	// (server socket, OpenRouter client, agentdox bridge) are pinned — editing
+	// those still requires a restart, and the watcher says so explicitly.
+	const pinned = { ...cfg };
+	const configWatcher = watchConfig(
+		routerConfigPath(),
+		cfg,
+		pinned,
+		["server", "openrouter", "context", "ledger"],
+		{
+			onReload: ({ changed }) => {
+				log.info("config reloaded", { changed: changed.join(", ") });
+			},
+			onError: (message) => {
+				log.warn("config reload rejected; keeping the running config", { error: message });
+			},
+		},
+	);
+
 	if (context.enabled) {
 		log.info("agentdox context bridge enabled", {
 			url: cfg.context.baseUrl,
@@ -258,7 +281,14 @@ export function startServer(cfg: RouterConfig): StartedServer {
 		runTurn(normReq, sink, turnDeps, req.signal)
 			.catch((err: unknown) => {
 				log.error("turn failed", { error: err instanceof Error ? err.message : String(err) });
-				return Promise.resolve(sink.error(toWireError(err))).catch(() => {});
+				// sink.error() is SYNCHRONOUS: it runs before Promise.resolve wraps
+				// anything, so a throw out of it escapes this .catch() handler and
+				// becomes an unhandled rejection that kills the process. Wrap it.
+				try {
+					Promise.resolve(sink.error(toWireError(err))).catch(() => {});
+				} catch {
+					// Stream already gone; the response cannot carry the error.
+				}
 			})
 			.finally(() => {
 				// Release the concurrency slot when the turn settles, not when the
@@ -348,8 +378,8 @@ export function startServer(cfg: RouterConfig): StartedServer {
 	return {
 		server,
 		stop: async () => {
+			configWatcher.close();
 			clearInterval(pruneTimer);
-			clearInterval(catalogRefreshTimer);
 			await server.stop(true);
 			// Drain queued agentdox write-backs before the DB closes under them.
 			context.close();

package/src/wire/openai/sink.ts

@@ -26,12 +26,25 @@ export function createStreamingSink(virtualModel: string): { sink: ResponseSink;
 		},
 	});
 	const send = (bytes: Uint8Array): void => {
-		if (!closed) controller?.enqueue(bytes);
+		if (closed) return;
+		try {
+			controller?.enqueue(bytes);
+		} catch {
+			// The runtime can close the controller under us — a client cancelling
+			// the stream (reader.cancel()) is not exceptional and nothing above us
+			// observes it. Mark closed and drop the write; measured to throw
+			// ERR_INVALID_STATE synchronously on Bun 1.x otherwise.
+			closed = true;
+		}
 	};
 	const close = (): void => {
 		if (!closed) {
 			closed = true;
-			controller?.close();
+			try {
+				controller?.close();
+			} catch {
+				// Already closed by the runtime; nothing left to do.
+			}
 		}
 	};
 

package/test/context-bridge.test.ts

@@ -55,6 +55,7 @@ function mkBridge(client: AgentDoxClient, over: Partial<BridgeOpts> = {}) {
 		memoryLimit: 8,
 		docsLimit: 2,
 		sessionLimit: 6,
+		briefChars: 0,
 		recordTurns: true,
 		maxQueue: 64,
 		...over,
@@ -102,12 +103,12 @@ describe("context bridge refresh policy", () => {
 		// especially: docs are WHOLE documents and were left unbounded, and a single
 		// ashlands note-doc measured 41,921 chars — over the whole cap by itself.
 		// The REST endpoint also ignores snake_case limit keys, which silently reads
-		// as unbounded, so pin that all three limits actually reach the client.
+		// as unbounded, so pin that all four limits actually reach the client.
 		const client = mkClient();
-		const { bridge, db } = mkBridge(client, { memoryLimit: 5, docsLimit: 1, sessionLimit: 2 });
+		const { bridge, db } = mkBridge(client, { memoryLimit: 5, docsLimit: 1, sessionLimit: 2, briefChars: 9000 });
 		try {
 			await bridge.resolve(input());
-			expect(client.lastLimits).toEqual({ memoryLimit: 5, docsLimit: 1, sessionLimit: 2 });
+			expect(client.lastLimits).toEqual({ memoryLimit: 5, docsLimit: 1, sessionLimit: 2, briefChars: 9000 });
 		} finally {
 			db.close();
 		}
@@ -244,6 +245,7 @@ describe("context bridge refresh policy", () => {
 				memoryLimit: 8,
 				docsLimit: 2,
 				sessionLimit: 6,
+				briefChars: 0,
 				recordTurns: true,
 				maxQueue: 64,
 			};

package/test/failover.test.ts

@@ -69,7 +69,7 @@ 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, milestoneTokens: 20_000 },
-		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, memoryLimit: 8, docsLimit: 2, sessionLimit: 6, recordTurns: false, maxQueue: 64 },
+		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, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true },
 		budget: { onExceeded: "downgrade" },
 		profiles: [],