auto-model-router 0.2.21 → 0.2.23

package/src/router/compaction.ts

@@ -37,6 +37,27 @@ export function compactedBytes(originalBytes: number, edit: CompactionEdit | und
 	return Math.min(originalBytes, kept);
 }
 
+/**
+ * Validates a persisted compaction plan against this turn's messages before it
+ * is re-applied. Every edit must land on a tool-role message whose string
+ * content still has the original byte length the edit was planned against.
+ * A failed check means the client rewrote or truncated its history — the edit
+ * is dropped rather than applied to the wrong bytes.
+ */
+export function validatePlan(
+	plan: readonly CompactionEdit[],
+	messages: readonly NormMessage[],
+): CompactionEdit[] {
+	const valid: CompactionEdit[] = [];
+	for (const e of plan) {
+		const m = messages[e.index];
+		if (m === undefined || m.role !== "tool") continue;
+		if (m.textBytes !== e.bytes) continue;
+		valid.push(e);
+	}
+	return valid;
+}
+
 /**
  * First string value in a tool call's argument JSON — a schema-agnostic proxy
  * for the resource a call operates on (a `path`, `id`, `query`, ...). Used to
@@ -81,6 +102,16 @@ interface ToolResult {
 	key: string | null;
 }
 
+/**
+ * Result for a turn that adds nothing: the carried plan alone, with its
+ * savings recomputed against this turn's messages.
+ */
+function carriedOnly(carried: readonly CompactionEdit[]): CompactionResult {
+	const edits = [...carried].sort((a, b) => a.index - b.index);
+	const savedBytes = edits.reduce((sum, e) => sum + (e.bytes - compactedBytes(e.bytes, e)), 0);
+	return { edits, savedBytes };
+}
+
 /**
  * Plans compaction for a turn's messages toward `targetBytes` of total prompt.
  * Duplicate and superseded elisions (pure stale-data wins) are always applied;
@@ -96,17 +127,27 @@ interface ToolResult {
  * fresh edits at arbitrarily early indices on later turns, rewriting history
  * the upstream had already cached and collapsing cache reads to the system
  * prefix (measured: 61% cache read, bimodal, vs 76-82% before compaction).
+ *
+ * `carried` is the plan already applied to this conversation on a previous
+ * dispatch (validated by `validatePlan`). It is re-emitted verbatim and its
+ * savings count toward the target, so an existing edit is never re-derived
+ * differently and the planner only ever ADDS. Re-applying it costs nothing:
+ * the client re-sends the original bytes every turn, so the same edit produces
+ * the same output.
  */
 export function planCompaction(
 	messages: readonly NormMessage[],
 	cfg: CompactionConfig,
 	targetBytes: number,
 	promptBytes: number,
+	carried: readonly CompactionEdit[] = [],
 ): CompactionResult {
 	if (!cfg.enabled) return EMPTY;
 
 	const protectStart = protectFromIndex(messages, cfg.protectRecentTurns);
-	if (protectStart <= 0) return EMPTY;
+	// Carried edits still apply even when nothing new is eligible this turn:
+	// dropping them would re-inflate bytes the upstream has already cached.
+	if (protectStart <= 0) return carriedOnly(carried);
 
 	// Assistant tool_call id → name/args, to key tool results by their call.
 	const callById = new Map<string, { name: string; args: string }>();
@@ -128,16 +169,19 @@ export function planCompaction(
 			key: call === undefined ? null : primaryArg(call.args),
 		});
 	}
-	if (tools.length === 0) return EMPTY;
-
-	const edits: CompactionEdit[] = [];
-	const done = new Set<number>();
-	let saved = 0;
+	if (tools.length === 0) return carriedOnly(carried);
+
+	// Seed with the carried plan: those indices are settled, and their savings
+	// already count against the target, so the target math asks "how much MORE
+	// is needed" rather than re-deriving the whole plan.
+	const edits: CompactionEdit[] = [...carried];
+	const done = new Set<number>(carried.map((e) => e.index));
+	let saved = carried.reduce((sum, e) => sum + (e.bytes - compactedBytes(e.bytes, e)), 0);
 	const stub = (t: ToolResult, note: string): void => {
 		if (done.has(t.index)) return;
 		const gain = t.bytes - BREADCRUMB_BYTES;
 		if (gain <= 0) return; // already smaller than a breadcrumb
-		edits.push({ index: t.index, mode: "stub", keepHead: 0, keepTail: 0, note });
+		edits.push({ index: t.index, mode: "stub", keepHead: 0, keepTail: 0, note, bytes: t.bytes });
 		done.add(t.index);
 		saved += gain;
 	};
@@ -172,7 +216,7 @@ export function planCompaction(
 	const truncatable = tools.filter((t) => !done.has(t.index) && t.bytes > cfg.maxToolResultBytes && t.bytes > keepBudget);
 	for (const t of truncatable) {
 		if (promptBytes - saved <= targetBytes) break;
-		edits.push({ index: t.index, mode: "truncate", keepHead: cfg.keepHeadBytes, keepTail: cfg.keepTailBytes, note: `large ${t.name || "tool"} result` });
+		edits.push({ index: t.index, mode: "truncate", keepHead: cfg.keepHeadBytes, keepTail: cfg.keepTailBytes, note: `large ${t.name || "tool"} result`, bytes: t.bytes });
 		done.add(t.index);
 		saved += t.bytes - keepBudget;
 	}

package/src/router/select.ts

@@ -12,7 +12,7 @@ import { priceAt } from "../cost/forecast.ts";
 import type { Ledger } from "../cost/types.ts";
 import { explorationDraw } from "./explore.ts";
 import type { CompactionEdit, NormRequest, ReasoningLevel } from "../wire/types.ts";
-import { planCompaction } from "./compaction.ts";
+import { compactedBytes, planCompaction, validatePlan, type CompactionResult } from "./compaction.ts";
 import { planCacheBreakpoints } from "./cache-control.ts";
 import { buildCandidates } from "./candidates.ts";
 import {
@@ -153,28 +153,54 @@ export function select(args: SelectArgs): Decision {
 	//     Deterministic and content-only (never removes a message), so downstream
 	//     forecasting, the context_too_small filter, cache breakpoints, and the
 	//     agentdox block append all operate on the compacted size / stay valid.
+	//
+	//     Two properties make this cache-safe, and both are load-bearing:
+	//
+	//     1. The plan is PERSISTED per conversation and re-applied verbatim. omp
+	//        re-sends the original bytes every turn, so a re-applied edit yields
+	//        byte-identical output; a plan re-derived from scratch could differ
+	//        (a looser target, a re-tuned knob) and rewrite already-cached bytes.
+	//     2. Compaction is triggered on the COMPACTED size and then overshoots
+	//        to `floorRatio` of the budget. Comparing the RAW prompt against the
+	//        budget re-planned on every single turn, so the plan gained one more
+	//        edit per turn — and each plan change rewrites cached prompt bytes.
+	//        Measured on live ledger data (7 long conversations, 894 compacted
+	//        dispatches): a turn whose plan changed ran 15.4% cold vs 8.9% when
+	//        the plan held, and a cold prompt costs 4.34x a warm one per token.
+	//        Overshooting buys several byte-stable turns per plan change.
 	let compactionPlan: CompactionEdit[] = [];
 	let promptTokensSaved = 0;
 	let effFeatures = features;
 	if (cfg.compaction.enabled && req.promptBytes > 0 && features.promptTokens > 0) {
+		const bytesPerToken = req.promptBytes / features.promptTokens;
+		const carried = validatePlan(state.compactionPlan ?? [], req.messages);
+		const carriedSavedBytes = carried.reduce((sum, e) => sum + (e.bytes - compactedBytes(e.bytes, e)), 0);
+		const tokensOf = (savedBytes: number): number =>
+			Math.min(features.promptTokens - 1, Math.round(features.promptTokens * (savedBytes / req.promptBytes)));
+		// What the upstream would actually receive if nothing new were planned.
+		const compactedTokens = features.promptTokens - tokensOf(carriedSavedBytes);
+
 		const headroom = cfg.filters.contextHeadroom;
-		const overBudget = features.promptTokens > cfg.compaction.budgetTokens;
+		const overBudget = compactedTokens > cfg.compaction.budgetTokens;
 		const overWindow =
-			cfg.compaction.fitToWindow && features.promptTokens * headroom + EXPECTED_COMPLETION_TOKENS > profile.contextWindow;
+			cfg.compaction.fitToWindow && compactedTokens * headroom + EXPECTED_COMPLETION_TOKENS > profile.contextWindow;
+		let plan: CompactionResult = { edits: carried, savedBytes: carriedSavedBytes };
 		if (overBudget || overWindow) {
 			const targets: number[] = [];
-			if (overBudget) targets.push(cfg.compaction.budgetTokens);
+			// Overshoot the budget so the next re-plan is several turns away.
+			if (overBudget) targets.push(Math.max(1, Math.floor(cfg.compaction.budgetTokens * cfg.compaction.floorRatio)));
 			if (overWindow) targets.push(Math.max(1, Math.floor((profile.contextWindow - EXPECTED_COMPLETION_TOKENS) / headroom)));
-			const targetBytes = Math.min(...targets) * (req.promptBytes / features.promptTokens);
-			const plan = planCompaction(req.messages, cfg.compaction, targetBytes, req.promptBytes);
-			if (plan.edits.length > 0) {
-				compactionPlan = plan.edits;
-				promptTokensSaved = Math.min(features.promptTokens - 1, Math.round(features.promptTokens * (plan.savedBytes / req.promptBytes)));
-				effFeatures = { ...features, promptTokens: features.promptTokens - promptTokensSaved };
-				reasons.push(
-					`compaction: ${plan.edits.length} tool result(s) shrunk, ~${promptTokensSaved} tokens saved (prompt ${features.promptTokens}→${effFeatures.promptTokens})`,
-				);
-			}
+			const targetBytes = Math.min(...targets) * bytesPerToken;
+			plan = planCompaction(req.messages, cfg.compaction, targetBytes, req.promptBytes, carried);
+		}
+		if (plan.edits.length > 0) {
+			compactionPlan = [...plan.edits];
+			promptTokensSaved = tokensOf(plan.savedBytes);
+			effFeatures = { ...features, promptTokens: features.promptTokens - promptTokensSaved };
+			const added = plan.edits.length - carried.length;
+			reasons.push(
+				`compaction: ${plan.edits.length} tool result(s) shrunk (${carried.length} carried, ${added} new), ~${promptTokensSaved} tokens saved (prompt ${features.promptTokens}→${effFeatures.promptTokens})`,
+			);
 		}
 	}
 

package/src/router/state.ts

@@ -11,8 +11,10 @@
 
 import type { Database, Statement } from "bun:sqlite";
 
+import type { CompactionEdit } from "../wire/types.ts";
 import type { ConversationState, ConversationStore, Tier } from "./types.ts";
 
+
 /** Row shape as stored; column names are snake_case per the schema. */
 interface Row {
 	key: string;
@@ -28,6 +30,7 @@ interface Row {
 	cache_warm_at_ms: number;
 	context_version: string | null;
 	context_fetched_at_ms: number;
+	compaction_plan: string | null;
 	updated_at_ms: number;
 }
 
@@ -47,6 +50,7 @@ function toState(row: Row): ConversationState {
 		cacheWarmAtMs: row.cache_warm_at_ms,
 		contextVersion: row.context_version,
 		contextFetchedAtMs: row.context_fetched_at_ms,
+		compactionPlan: row.compaction_plan === null ? null : (JSON.parse(row.compaction_plan) as CompactionEdit[]),
 		updatedAtMs: row.updated_at_ms,
 	};
 }
@@ -65,10 +69,10 @@ export function createConversationStore(db: Database): ConversationStore {
 		INSERT INTO conversations (
 			key, session_id, turn, current_slug, current_tier, sticky_until_turn,
 			last_prompt_tokens, cache_warm_slug, cache_warm_at_ms,
-			context_version, context_fetched_at_ms, updated_at_ms
+			context_version, context_fetched_at_ms, compaction_plan, updated_at_ms
 		) VALUES ($key, $sessionId, $turn, $currentSlug, $currentTier, $stickyUntilTurn,
 			$lastPromptTokens, $cacheWarmSlug, $cacheWarmAtMs,
-			$contextVersion, $contextFetchedAtMs, $updatedAtMs)
+			$contextVersion, $contextFetchedAtMs, $compactionPlan, $updatedAtMs)
 		ON CONFLICT(key) DO UPDATE SET
 			session_id = excluded.session_id,
 			turn = excluded.turn,
@@ -80,6 +84,7 @@ export function createConversationStore(db: Database): ConversationStore {
 			cache_warm_at_ms = excluded.cache_warm_at_ms,
 			context_version = excluded.context_version,
 			context_fetched_at_ms = excluded.context_fetched_at_ms,
+			compaction_plan = excluded.compaction_plan,
 			updated_at_ms = excluded.updated_at_ms
 	`);
 	// Read-modify-write in JS lost money: an aborted or failed dispatch is still
@@ -127,6 +132,7 @@ export function createConversationStore(db: Database): ConversationStore {
 				$currentTier: state.currentTier,
 				$stickyUntilTurn: state.stickyUntilTurn,
 				$lastPromptTokens: state.lastPromptTokens,
+				$compactionPlan: state.compactionPlan === null ? null : JSON.stringify(state.compactionPlan),
 				$cacheWarmSlug: state.cacheWarmSlug,
 				$cacheWarmAtMs: state.cacheWarmAtMs,
 				$contextVersion: state.contextVersion,

package/src/router/types.ts

@@ -170,6 +170,13 @@ export interface ConversationState {
 	 * cache survives; refreshed only when the cache is already cold.
 	 */
 	contextVersion: string | null;
+	/**
+	 * The compaction plan applied on the previous dispatch. Re-applied verbatim
+	 * each turn (after byte-length validation) so already-shrunk tool results
+	 * stay shrunk: dropping them re-inflates mid-prefix bytes, which both breaks
+	 * the prompt cache and un-saves the tokens. Fresh planning only extends it.
+	 */
+	compactionPlan: CompactionEdit[] | null;
 	/** When that block was fetched, for the staleness TTL. */
 	contextFetchedAtMs: number;
 	updatedAtMs: number;

package/src/server/turn.ts

@@ -457,6 +457,10 @@ export async function runTurn(
 		state.spentUsd += reportedUsd ?? decision.forecast.expectedUsd;
 		state.escalations += escalations;
 		state.lastPromptTokens = usage.promptTokens;
+		// Persist the plan that was actually dispatched. The next turn re-applies
+		// it verbatim (after byte-length validation), keeping shrunk tool results
+		// shrunk so the prompt cache survives and the savings compound.
+		state.compactionPlan = decision.compactionPlan.length > 0 ? decision.compactionPlan : null;
 		if (usage.cachedTokens > 0 || usage.cacheWriteTokens > 0) {
 			// Non-zero cache traffic is direct evidence the upstream cache exists.
 			state.cacheWarmSlug = servedSlug ?? decision.slug;

package/src/util/sqlite.ts

@@ -18,7 +18,7 @@ import { mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 
 /** Bump when a migration is added; guarded below so reopening never regresses it. */
-const USER_VERSION = 12;
+const USER_VERSION = 13;
 
 const MIGRATIONS = `
 CREATE TABLE IF NOT EXISTS catalog_cache (
@@ -211,6 +211,14 @@ const MIGRATE_V12 = `
 ALTER TABLE ledger ADD COLUMN prompt_tokens_saved INTEGER;
 `;
 
+// v13: conversations persist the last compaction plan (JSON array of
+// CompactionEdit). Re-applying it verbatim each turn keeps already-shrunk tool
+// results shrunk — without it, protectRecentTurns drift drops edits and
+// re-inflates mid-prefix bytes, breaking the prompt cache for zero savings.
+const MIGRATE_V13 = `
+ALTER TABLE conversations ADD COLUMN compaction_plan TEXT;
+`;
+
 // v9: benchmark_cache holds the external benchmark feeds (Artificial Analysis,
 // BenchLM) that backfill quality scores OpenRouter leaves unpublished. It is a
 // whole new table, created idempotently by the MIGRATIONS block above, so there
@@ -242,9 +250,10 @@ export function openDb(path: string): Database {
 		if (!ledgerCols.some((c) => c.name === "features")) db.exec(MIGRATE_V6);
 		if (!ledgerCols.some((c) => c.name === "explored_from")) db.exec(MIGRATE_V7);
 		if (!ledgerCols.some((c) => c.name === "hold_arm")) db.exec(MIGRATE_V8);
+		if (!ledgerCols.some((c) => c.name === "prompt_tokens_saved")) db.exec(MIGRATE_V12);
 		const convCols = db.query("PRAGMA table_info(conversations)").all() as { name: string }[];
 		if (!convCols.some((c) => c.name === "context_version")) db.exec(MIGRATE_V11);
-		if (!ledgerCols.some((c) => c.name === "prompt_tokens_saved")) db.exec(MIGRATE_V12);
+		if (!convCols.some((c) => c.name === "compaction_plan")) db.exec(MIGRATE_V13);
 		db.exec(`PRAGMA user_version = ${USER_VERSION}`);
 	}
 	return db;

package/src/wire/types.ts

@@ -148,6 +148,14 @@ export interface CompactionEdit {
 	keepHead: number;
 	keepTail: number;
 	note: string;
+	/**
+	 * Original (pre-edit) byte length of the targeted message's string content,
+	 * captured when the edit was planned. Persisted with the plan so a later
+	 * turn can verify the history it is re-applying to is byte-identical before
+	 * re-applying — a client-side rewrite or an upstream difference invalidates
+	 * the edit instead of corrupting the prompt.
+	 */
+	bytes: number;
 }
 
 export type FinishReason = "stop" | "length" | "tool_calls" | "content_filter" | "error";

package/test/compaction.test.ts

@@ -1,13 +1,14 @@
 import { describe, expect, test } from "bun:test";
 
 import type { CompactionConfig } from "../src/config/types.ts";
-import { planCompaction } from "../src/router/compaction.ts";
+import { planCompaction, validatePlan } from "../src/router/compaction.ts";
 import { parseChatRequest } from "../src/wire/openai/request.ts";
 import type { NormMessage } from "../src/wire/types.ts";
 
 const CFG: CompactionConfig = {
 	enabled: true,
 	budgetTokens: 1,
+	floorRatio: 1,
 	fitToWindow: false,
 	protectRecentTurns: 2,
 	maxToolResultBytes: 50,
@@ -159,7 +160,7 @@ describe("renderUpstreamBody applies compaction", () => {
 			{ role: "tool", tool_call_id: "c1", content: "HEAD" + "x".repeat(500) + "TAIL" },
 		];
 		const req = parseChatRequest(bodyWith(raw), new Headers());
-		const out = req.renderUpstreamBody({ ...MUT, compactionPlan: [{ index: 2, mode: "truncate", keepHead: 4, keepTail: 4, note: "large read result" }] });
+		const out = req.renderUpstreamBody({ ...MUT, compactionPlan: [{ index: 2, mode: "truncate", keepHead: 4, keepTail: 4, note: "large read result", bytes: 508 }] });
 		const messages = out.messages as { role: string; content: unknown }[];
 		expect(messages).toHaveLength(3); // no message removed → pairing intact
 		const content = messages[2]?.content;
@@ -178,8 +179,93 @@ describe("renderUpstreamBody applies compaction", () => {
 			{ role: "tool", tool_call_id: "c1", content: "a".repeat(300) },
 		];
 		const req = parseChatRequest(bodyWith(raw), new Headers());
-		const out = req.renderUpstreamBody({ ...MUT, compactionPlan: [{ index: 2, mode: "stub", keepHead: 0, keepTail: 0, note: "identical repeated read result" }] });
+		const out = req.renderUpstreamBody({ ...MUT, compactionPlan: [{ index: 2, mode: "stub", keepHead: 0, keepTail: 0, note: "identical repeated read result", bytes: 300 }] });
 		const messages = out.messages as { content: string }[];
 		expect(messages[2]?.content).toBe("[omp-router: identical repeated read result elided to save context; re-run the tool to restore]");
 	});
 });
+
+describe("plan byte-stability across turns", () => {
+	// The prompt cache is a byte-prefix cache: changing any already-sent byte
+	// invalidates everything after it. So an edit, once dispatched, must be
+	// re-emitted identically on every later turn — which means the planner has
+	// to be told what it already did rather than re-deriving it.
+	test("edits carry their original byte length for persistence", () => {
+		const msgs = [user("go"), asst("c1", "read", '{"path":"a.ts"}'), toolMsg("c1", "read", big("A")), ...PAD];
+		const { edits } = planCompaction(msgs, CFG, 1, 10_000);
+		expect(edits).toHaveLength(1);
+		expect(edits[0]?.bytes).toBe(Buffer.byteLength(big("A")));
+	});
+
+	test("validatePlan keeps edits whose target is byte-identical and role-correct", () => {
+		const msgs = [user("go"), asst("c1", "read", '{"path":"a.ts"}'), toolMsg("c1", "read", big("A")), ...PAD];
+		const { edits } = planCompaction(msgs, CFG, 1, 10_000);
+		expect(validatePlan(edits, msgs)).toEqual(edits);
+	});
+
+	test("validatePlan drops edits when history changed under them", () => {
+		const msgs = [user("go"), asst("c1", "read", '{"path":"a.ts"}'), toolMsg("c1", "read", big("A")), ...PAD];
+		const { edits } = planCompaction(msgs, CFG, 1, 10_000);
+		// Client re-wrote history: the tool result is a different length now.
+		const rewritten = [user("go"), asst("c1", "read", '{"path":"a.ts"}'), toolMsg("c1", "read", "short"), ...PAD];
+		expect(validatePlan(edits, rewritten)).toEqual([]);
+	});
+
+	test("validatePlan drops edits that fall off the message array", () => {
+		const msgs = [user("go"), asst("c1", "read", '{"path":"a.ts"}'), toolMsg("c1", "read", big("A")), ...PAD];
+		const { edits } = planCompaction(msgs, CFG, 1, 10_000);
+		// Conversation compacted away client-side: index 2 no longer exists.
+		expect(validatePlan(edits, [user("go"), ...PAD.slice(1)])).toEqual([]);
+	});
+
+	test("a carried plan produces identical edits to a fresh plan over the same bytes", () => {
+		// Determinism contract: re-planning over unchanged bytes re-derives the
+		// persisted plan, so the merge in select.ts is a no-op, not a rewrite.
+		const msgs = [
+			user("go"),
+			asst("c1", "read", '{"path":"a.ts"}'),
+			toolMsg("c1", "read", big("A")),
+			asst("c2", "read", '{"path":"b.ts"}'),
+			toolMsg("c2", "read", big("B")),
+			...PAD,
+		];
+		const first = planCompaction(msgs, CFG, 1, 10_000);
+		const again = planCompaction(msgs, CFG, 1, 10_000);
+		expect(again.edits).toEqual(first.edits);
+	});
+
+	test("a carried edit is re-emitted verbatim even when nothing new is eligible", () => {
+		const msgs = [user("go"), asst("c1", "read", '{"path":"a.ts"}'), toolMsg("c1", "read", big("A")), ...PAD];
+		const carried = planCompaction(msgs, CFG, 1, 10_000).edits;
+		// Target already met, so a stateless planner would emit nothing at all.
+		const next = planCompaction(msgs, CFG, 1_000_000, 10_000, carried);
+		expect(next.edits).toEqual(carried);
+		expect(next.savedBytes).toBeGreaterThan(0);
+	});
+
+	test("carried savings count toward the target, so the planner only adds what is still needed", () => {
+		const msgs = [
+			user("go"),
+			asst("c1", "read", '{"path":"a.ts"}'),
+			toolMsg("c1", "read", big("A")),
+			asst("c2", "read", '{"path":"b.ts"}'),
+			toolMsg("c2", "read", big("B")),
+			...PAD,
+		];
+		const promptBytes = 10_000;
+		// Carry the first edit, then re-plan with a target the carried edit alone
+		// already satisfies: no second edit may be added.
+		const carried = [planCompaction(msgs, CFG, 1, promptBytes).edits[0]!];
+		const target = promptBytes - (carried[0]!.bytes - CFG.keepHeadBytes - CFG.keepTailBytes - 120);
+		const next = planCompaction(msgs, CFG, target, promptBytes, carried);
+		expect(next.edits.map((e) => e.index)).toEqual(carried.map((e) => e.index));
+	});
+
+	test("a carried edit is never re-planned into a different shape", () => {
+		const msgs = [user("go"), asst("c1", "read", '{"path":"a.ts"}'), toolMsg("c1", "read", big("A")), ...PAD];
+		// Carried as a stub; a fresh plan would have chosen truncate.
+		const carried = [{ index: 2, mode: "stub" as const, keepHead: 0, keepTail: 0, note: "carried", bytes: Buffer.byteLength(big("A")) }];
+		const next = planCompaction(msgs, CFG, 1, 10_000, carried);
+		expect(next.edits.filter((e) => e.index === 2)).toEqual(carried);
+	});
+});

package/test/embed-logic.test.ts

@@ -16,7 +16,7 @@ import {
 } from "../omp-extension/embed-logic.ts";
 
 describe("resolveEmbedPort", () => {
-	test("returns 0 (let the OS assign a free port) when AUTO_MODEL_ROUTER_PORT is absent", () => {
+	test("returns 0 (let the OS assign a free port) when nothing is configured", () => {
 		expect(resolveEmbedPort(undefined)).toBe(0);
 		expect(resolveEmbedPort("")).toBe(0);
 	});
@@ -31,6 +31,28 @@ describe("resolveEmbedPort", () => {
 		expect(resolveEmbedPort("-1")).toBe(0);
 		expect(resolveEmbedPort("70000")).toBe(0);
 	});
+
+	// A stable port is what keeps omp's PRE-extension model resolution correct:
+	// it reads models.yml before this extension can bind and rewrite it, so an
+	// ephemeral port leaves that block naming the previous session's dead port.
+	test("uses the configured server.port when no env override is set", () => {
+		expect(resolveEmbedPort(undefined, 8788)).toBe(8788);
+		expect(resolveEmbedPort("", 8788)).toBe(8788);
+	});
+
+	test("the env var wins over the configured port", () => {
+		expect(resolveEmbedPort("8812", 8788)).toBe(8812);
+	});
+
+	test("an explicit env 0 wins, so an ephemeral port stays requestable", () => {
+		expect(resolveEmbedPort("0", 8788)).toBe(0);
+	});
+
+	test("ignores a nonsense configured port rather than binding it", () => {
+		expect(resolveEmbedPort(undefined, 0)).toBe(0);
+		expect(resolveEmbedPort(undefined, -5)).toBe(0);
+		expect(resolveEmbedPort(undefined, 70_000)).toBe(0);
+	});
 });
 
 describe("embed port file", () => {

package/test/exploration.test.ts

@@ -56,6 +56,7 @@ function state(over: Partial<ConversationState> = {}): ConversationState {
 		cacheWarmAtMs: 0,
 		contextVersion: null,
 		contextFetchedAtMs: 0,
+		compactionPlan: null,
 		updatedAtMs: NOW,
 		...over,
 	};

package/test/failover.test.ts

@@ -70,7 +70,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		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, 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 },
 		budget: { onExceeded: "downgrade" },
 		profiles: [],
 		ledger: { path: ":memory:", blendWindowDays: 7, blendMinSamples: 20, fallbackBlend: { inputPerMtok: 1, outputPerMtok: 4 }, conversationTtlMs: 86_400_000 },
@@ -267,6 +267,7 @@ function mkConversations(): { store: ConversationStore; map: Map<string, Convers
 				cacheWarmAtMs: 0,
 				contextVersion: null,
 				contextFetchedAtMs: 0,
+				compactionPlan: null,
 				updatedAtMs: 0,
 			};
 			map.set(k, fresh);

package/test/select.test.ts

@@ -66,6 +66,7 @@ function state(over: Partial<ConversationState> = {}): ConversationState {
 		cacheWarmAtMs: 0,
 		contextVersion: null,
 		contextFetchedAtMs: 0,
+		compactionPlan: null,
 		updatedAtMs: Date.now(),
 		...over,
 	};
@@ -601,6 +602,7 @@ describe("context compaction", () => {
 		compaction: {
 			enabled: true,
 			budgetTokens: 1_000,
+			floorRatio: 1,
 			fitToWindow: false,
 			protectRecentTurns: 1,
 			maxToolResultBytes: 100,
@@ -664,4 +666,80 @@ describe("context compaction", () => {
 		expect(d.compactionPlan).toEqual([]);
 		expect(d.promptTokensSaved).toBe(0);
 	});
+
+	test("a carried plan is re-applied even when the turn is now under budget", () => {
+		// The prompt cache is a byte-prefix cache: dropping an edit that was
+		// already dispatched rewrites history the upstream had cached, and
+		// re-sends the tokens the edit saved. So a carried plan survives a turn
+		// that would not have triggered compaction on its own.
+		const req = loopReq();
+		const over = extractFeatures(req, 5_000);
+		const first = select({
+			req,
+			features: over,
+			classification: scoreHeuristic(over, COMPACT_CFG),
+			profile: PROFILE,
+			state: state(),
+			snapshot: SNAPSHOT,
+			ledger: null,
+			cfg: COMPACT_CFG,
+			nowMs: Date.now(),
+		});
+		expect(first.compactionPlan.length).toBeGreaterThan(0);
+
+		const under = extractFeatures(req, 500); // under budgetTokens=1000
+		const second = select({
+			req,
+			features: under,
+			classification: scoreHeuristic(under, COMPACT_CFG),
+			profile: PROFILE,
+			state: state({ compactionPlan: first.compactionPlan }),
+			snapshot: SNAPSHOT,
+			ledger: null,
+			cfg: COMPACT_CFG,
+			nowMs: Date.now(),
+		});
+		expect(second.compactionPlan).toEqual(first.compactionPlan);
+		expect(second.promptTokensSaved).toBeGreaterThan(0);
+	});
+
+	test("floorRatio below 1 compacts strictly past the budget so the plan holds longer", () => {
+		// Each plan change rewrites cached prompt bytes, so compaction overshoots
+		// deliberately: eliding more now buys byte-stable turns later.
+		const req = parseChatRequest(
+			{
+				model: "auto",
+				tools: TOOLS,
+				messages: [
+					{ role: "system", content: "You are a coding agent." },
+					{ role: "user", content: "read the files" },
+					...[1, 2, 3, 4, 5, 6].flatMap((n) => [
+						{ role: "assistant", content: null, tool_calls: [{ id: `c${n}`, type: "function", function: { name: "read", arguments: `{"path":"f${n}.ts"}` } }] },
+						{ role: "tool", tool_call_id: `c${n}`, content: `F${n}${"x".repeat(2000)}` },
+					]),
+					{ role: "user", content: "continue" },
+				],
+			},
+			new Headers(),
+		);
+		// Prompt is ~12k bytes; claim 4000 tokens against a 1000-token budget, so
+		// floorRatio 1 targets 1000 and floorRatio 0.5 targets 500.
+		const features = extractFeatures(req, 4_000);
+		const run = (floorRatio: number) =>
+			select({
+				req,
+				features,
+				classification: scoreHeuristic(features, COMPACT_CFG),
+				profile: PROFILE,
+				state: state(),
+				snapshot: SNAPSHOT,
+				ledger: null,
+				cfg: { ...COMPACT_CFG, compaction: { ...COMPACT_CFG.compaction, floorRatio } },
+				nowMs: Date.now(),
+			});
+		const tight = run(0.5);
+		const loose = run(1);
+		expect(tight.compactionPlan.length).toBeGreaterThan(loose.compactionPlan.length);
+		expect(tight.promptTokensSaved).toBeGreaterThan(loose.promptTokensSaved);
+	});
 });

package/test/trust-attribution.test.ts

@@ -244,11 +244,11 @@ describe("v4 migration", () => {
 		}
 	});
 
-	test("schema is at user_version 12", () => {
+	test("schema is at user_version 13", () => {
 		const db = openDb(":memory:");
 		try {
 			const row = db.query("PRAGMA user_version").get() as { user_version: number };
-			expect(row.user_version).toBe(12);
+			expect(row.user_version).toBe(13);
 		} finally {
 			db.close();
 		}

package/test/turn.test.ts

@@ -71,7 +71,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		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, 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 },
 		budget: { onExceeded: "downgrade" },
 		profiles: [],
 		ledger: { path: ":memory:", blendWindowDays: 7, blendMinSamples: 20, fallbackBlend: { inputPerMtok: 1, outputPerMtok: 4 }, conversationTtlMs: 86_400_000 },
@@ -268,6 +268,7 @@ function mkConversations(): {
 				cacheWarmAtMs: 0,
 				contextVersion: null,
 				contextFetchedAtMs: 0,
+				compactionPlan: null,
 				updatedAtMs: 0,
 			};
 			map.set(k, fresh);