auto-model-router 0.2.10 → 0.2.12

package/.omp-plugin/marketplace.json

@@ -7,14 +7,14 @@
   },
   "metadata": {
     "description": "auto-model-router: a local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
-    "version": "0.2.10",
+    "version": "0.2.12",
     "pluginRoot": "."
   },
   "plugins": [
     {
       "name": "auto-model-router",
       "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter. Runs in-process, routes per turn by price and task complexity, with budget caps, mid-stream escalation, and cache-aware hysteresis.",
-      "version": "0.2.10",
+      "version": "0.2.12",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -580,11 +580,19 @@ and brief:
 ```bash
 export AGENTDOX_URL=http://localhost:3003
 export AGENTDOX_TOKEN=<pat with read+write on the scope>
-export AGENTDOX_SCOPE=ashlands        # optional; the omp extension derives it from the workspace
+export AGENTDOX_SCOPE=ashlands        # fallback only; see below
 ```
 
 Setting a URL and a token is enough to turn it on.
 
+The scope is **derived per workspace** from the directory basename
+(`E:/projects/ashlands` → `ashlands`), and that derivation wins. `AGENTDOX_SCOPE` /
+`context.defaultScope` is only a fallback for workspaces it cannot resolve, because one router
+install serves every project on the machine — a slug pinned there would be sent for all of
+them, injecting one project's context into another's work. A single configured token also
+grants only the scopes it was minted for; for any other project the bridge degrades to inert
+rather than writing somewhere wrong.
+
 ### It does not cost you a cache miss per turn
 
 The context block sits at the front of the prompt, so re-fetching it every turn

package/docs/AGENTDOX-BRIDGE.md

@@ -1,7 +1,7 @@
 # agentdox bridge — handoff
 
-**Status:** implemented, typechecks clean, 438 tests pass, injection verified end-to-end
-through omp. The write-back bug in §5 is **fixed**; `context.recordTurns` is safe to enable.
+**Status:** implemented, typechecks clean, 439 tests pass, injection verified end-to-end
+through omp. The write-back faults in §5 and §6 are **fixed**; `context.recordTurns` is on.
 
 Design rationale (why it is built this way):
 `E:/projects/agentdox/docs/architecture/router-context-bridge.md`.
@@ -110,8 +110,8 @@ Each tool round-trip is its own dispatch, finishing with `tool_calls` and emitti
 record of a fragment rather than a truncated answer. Only the final `stop` dispatch carries
 the synthesis. `recordTurn` fired on all ~13, and the last writer won.
 
-The same root cause explains the §6 pollution: `lastUserText` walks back to the last `user`
-message, which does **not** move while a tool loop runs, so the identical user text was
+The same root cause explains half the duplication in §7: `lastUserText` walks back to the last
+`user` message, which does **not** move while a tool loop runs, so the identical user text was
 appended once per round-trip too.
 
 **Fix.** `TurnRecord` gained `turnEnded` (`finishReason !== "tool_calls"`, set in
@@ -128,13 +128,53 @@ nothing; interleaved conversations buffer independently) and `test/turn.test.ts`
 behavior. `tools/agentdox-e2e.ts` step 6 proves it against a live server: four dispatches →
 exactly one user and one assistant message.
 
-## 6. Also worth doing
+## 6. FIXED — harness utility calls, and the scope that leaked across projects
 
-- **Context pollution.** `context_assemble` includes recent session messages, so recorded
-  test turns feed back into the next block (observed: a block containing `assistant:: high`
-  from a prior run). The §5 fix removes the ~13×-per-turn duplication that made this acute,
-  but noisy *test* turns still compound — `tools/agentdox-e2e.ts` writes real sessions into
-  the scope every run. Consider a `sessionLimit` override for the bridge, or excluding
+Two further faults surfaced the moment `recordTurns` was first switched on, both found by
+reading what actually landed in agentdox.
+
+**Utility calls were recorded as turns.** omp drives more than the agent through this
+provider: it asks for a conversation title and a complexity rating, with `model: auto`, over
+the same embedded router. Those answer *about* a conversation rather than participating in
+one, and they finish with `stop`, so `turnEnded` alone does not exclude them. Three junk
+sessions appeared immediately:
+
+| recorded assistant text | what it really was |
+| --- | --- |
+| `high` | omp's complexity rating — **this is the original `" high"`** |
+| `<title>Read memory and resume work</title>` | omp's title generation |
+| `<title>Resume settlement 2D slice 3 streaming</title>` | omp's title generation |
+
+The discriminator is the tool array: an agent always ships its tool schemas (`toolCount` 12,
+prompts of 60k–90k), while utility calls ship none (`toolCount` 0, prompts of 222–841,
+`task=chat`). `src/server/turn.ts` therefore records only when `req.tools.length > 0`. A
+deliberately tool-less session is not transcribed — silence beats garbage, because every junk
+record is re-injected into every later turn.
+
+**`defaultScope` leaked one project's slug to all of them.** `omp-extension/embed-logic.ts`
+resolved the header as `defaultScope !== "" ? defaultScope : derive(cwd)`, so a *scope-agnostic
+global* overrode the *per-workspace* derivation. One router install serves every workspace, so
+with `defaultScope: omp-router` set, an **ashlands** session shipped
+`X-Agentdox-Scope: omp-router`: it injected omp-router's context into ashlands work and filed
+ashlands turns under omp-router. The server always treated the field as a fallback ("the
+configured default covers harnesses that send none"), so the two sides disagreed about the same
+field. Now the workspace derivation wins and `defaultScope` is its fallback, matching the name
+and the server. Same failure class as the `.mcp.json` lesson: a scope-specific value must never
+live in a scope-agnostic file.
+
+One consequence worth knowing: `context.token` is a single PAT, but a machine-wide router
+serves N scopes. The omp-router PAT gets `403 no read access to scope "ashlands"`, so with the
+scope now correct the bridge degrades to **inert** for other projects. Correct and safe, but it
+means the bridge only helps projects the configured token actually grants. A multi-scope token
+would fix that, at the cost of one credential reaching every project.
+
+## 7. Also worth doing
+
+- **Context pollution from test turns.** `context_assemble` includes recent session messages,
+  so router test turns feed back into the next block. The omp-router scope had accumulated 19
+  sessions of which 18 were noise (`hi`, `say hello`, `Reply with exactly the word: PONG`,
+  injection probes, `bridge e2e …`); they were deleted, and `tools/agentdox-e2e.ts` writes two
+  more every run. Consider a `sessionLimit` override for the bridge, or excluding
   router-authored sessions.
 - **`context.timeoutMs` is 3000ms** and failures degrade silently at `debug` level by design.
   If agentdox is cold this can no-op invisibly. Consider logging the first failure at `warn`.

package/omp-extension/embed-logic.ts

@@ -65,8 +65,9 @@ export interface EmbedConfig {
  *
  * The workspace basename is the one identifier that is already stable, already
  * per-project, and requires no configuration — the same convention agentdox's
- * own `project_ensure` slugs follow. An explicitly configured
- * `context.defaultScope` always wins over this.
+ * own `project_ensure` slugs follow. It WINS over `context.defaultScope`,
+ * which is a fallback for workspaces it cannot resolve; see
+ * `buildProviderConfig`.
  */
 export function deriveAgentdoxScope(cwd: string): string {
 	// Both separators: omp reports a Windows cwd with backslashes.
@@ -165,7 +166,16 @@ export function buildProviderConfig(
 		out.harnessId = cfg.server.harnessId;
 	}
 	if (cfg.context?.enabled === true) {
-		const scope = cfg.context.defaultScope !== "" ? cfg.context.defaultScope : deriveAgentdoxScope(cwd ?? "");
+		// The WORKSPACE wins. `defaultScope` is a scope-agnostic global — one
+		// router install serves every project on the machine — so letting it
+		// override the per-workspace derivation sends one project's slug for all
+		// of them: an ashlands session shipped `X-Agentdox-Scope: omp-router`,
+		// which both injected the wrong project's context and filed its turns
+		// under the wrong scope. The server treats this field as a fallback too
+		// ("the configured default covers harnesses that send none"), so the two
+		// sides now agree: most specific signal first.
+		const derived = deriveAgentdoxScope(cwd ?? "");
+		const scope = derived !== "" ? derived : cfg.context.defaultScope;
 		if (scope !== "") out.agentdoxScope = scope;
 	}
 	return out;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-model-router",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "private": false,
   "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
   "type": "module",

package/src/router/state.ts

@@ -57,13 +57,17 @@ export function createConversationStore(db: Database): ConversationStore {
 	const insertOne: Statement<unknown, [string, string, number]> = db.query(
 		"INSERT INTO conversations (key, session_id, updated_at_ms) VALUES (?, ?, ?)",
 	);
+	// `spent_usd` and `escalations` are ABSENT from this statement on purpose.
+	// They accumulate through `accrueOne` below, so writing a turn-start snapshot
+	// back here would erase whatever a billed-but-uncommitted dispatch added.
+	// The schema defaults both to 0, so the INSERT arm still works.
 	const upsert = db.query(`
 		INSERT INTO conversations (
 			key, session_id, turn, current_slug, current_tier, sticky_until_turn,
-			escalations, spent_usd, last_prompt_tokens, cache_warm_slug, cache_warm_at_ms,
+			last_prompt_tokens, cache_warm_slug, cache_warm_at_ms,
 			context_version, context_fetched_at_ms, updated_at_ms
 		) VALUES ($key, $sessionId, $turn, $currentSlug, $currentTier, $stickyUntilTurn,
-			$escalations, $spentUsd, $lastPromptTokens, $cacheWarmSlug, $cacheWarmAtMs,
+			$lastPromptTokens, $cacheWarmSlug, $cacheWarmAtMs,
 			$contextVersion, $contextFetchedAtMs, $updatedAtMs)
 		ON CONFLICT(key) DO UPDATE SET
 			session_id = excluded.session_id,
@@ -71,8 +75,6 @@ export function createConversationStore(db: Database): ConversationStore {
 			current_slug = excluded.current_slug,
 			current_tier = excluded.current_tier,
 			sticky_until_turn = excluded.sticky_until_turn,
-			escalations = excluded.escalations,
-			spent_usd = excluded.spent_usd,
 			last_prompt_tokens = excluded.last_prompt_tokens,
 			cache_warm_slug = excluded.cache_warm_slug,
 			cache_warm_at_ms = excluded.cache_warm_at_ms,
@@ -80,6 +82,19 @@ export function createConversationStore(db: Database): ConversationStore {
 			context_fetched_at_ms = excluded.context_fetched_at_ms,
 			updated_at_ms = excluded.updated_at_ms
 	`);
+	// Read-modify-write in JS lost money: an aborted or failed dispatch is still
+	// billed by the upstream, but it returns before the commit path, so the next
+	// dispatch loaded a stale total and overwrote it. Measured on live data:
+	// 152 aborted dispatches billing $0.9985 — 30% of all spend — never reached
+	// `spent_usd`, leaving the per-conversation budget guard blind to it.
+	// Accumulating in SQL is correct regardless of who raced whom.
+	const accrueOne = db.query(`
+		UPDATE conversations
+		SET spent_usd = spent_usd + $spentUsd,
+			escalations = escalations + $escalations,
+			updated_at_ms = $updatedAtMs
+		WHERE key = $key
+	`);
 	const deleteStale: Statement<unknown, [number]> = db.query("DELETE FROM conversations WHERE updated_at_ms < ?");
 
 	return {
@@ -103,6 +118,7 @@ export function createConversationStore(db: Database): ConversationStore {
 		save(state) {
 			// bun:sqlite matches named parameters by their literal `$name` key;
 			// bare keys bind nothing at all and every column silently lands NULL.
+			// No $spentUsd / $escalations here — see the statement above.
 			upsert.run({
 				$key: state.key,
 				$sessionId: state.sessionId,
@@ -110,8 +126,6 @@ export function createConversationStore(db: Database): ConversationStore {
 				$currentSlug: state.currentSlug,
 				$currentTier: state.currentTier,
 				$stickyUntilTurn: state.stickyUntilTurn,
-				$escalations: state.escalations,
-				$spentUsd: state.spentUsd,
 				$lastPromptTokens: state.lastPromptTokens,
 				$cacheWarmSlug: state.cacheWarmSlug,
 				$cacheWarmAtMs: state.cacheWarmAtMs,
@@ -121,6 +135,15 @@ export function createConversationStore(db: Database): ConversationStore {
 			});
 		},
 
+		accrue(key, delta) {
+			const spentUsd = delta.spentUsd ?? 0;
+			const escalations = delta.escalations ?? 0;
+			// Nothing to add: skip the write rather than bump updated_at_ms and
+			// keep a dead conversation alive against `prune`.
+			if (spentUsd === 0 && escalations === 0) return;
+			accrueOne.run({ $key: key, $spentUsd: spentUsd, $escalations: escalations, $updatedAtMs: Date.now() });
+		},
+
 		prune(maxAgeMs) {
 			return deleteStale.run(Date.now() - maxAgeMs).changes;
 		},

package/src/router/types.ts

@@ -179,7 +179,21 @@ export interface ConversationStore {
 	get(key: string): ConversationState | null;
 	/** Loads existing state or creates a fresh record. */
 	load(key: string): ConversationState;
+	/**
+	 * Persists the latest-wins fields. Deliberately does NOT write `spentUsd` or
+	 * `escalations` — those accumulate via `accrue`, and writing back a snapshot
+	 * here would clobber what a concurrent or already-billed dispatch added.
+	 */
 	save(state: ConversationState): void;
+	/**
+	 * Adds to the persisted counters, atomically in SQL.
+	 *
+	 * Separate from `save` because a dispatch that never reaches the commit path
+	 * — a client abort, an upstream error — was still BILLED, and its cost must
+	 * reach the per-conversation budget guard anyway. Requires `load` to have
+	 * created the row.
+	 */
+	accrue(key: string, delta: { spentUsd?: number; escalations?: number }): void;
 	/** Drops records untouched for longer than `maxAgeMs`. */
 	prune(maxAgeMs: number): number;
 }

package/src/server/turn.ts

@@ -230,6 +230,13 @@ export async function runTurn(
 				error: fields.error,
 				promptTokensSaved: decision.promptTokensSaved,
 			});
+			// Book the money HERE, beside the ledger row, so the two can never
+			// disagree. Every dispatch that reaches this point was billed —
+			// committed, wasted by an escalation, or aborted mid-stream — but only
+			// the committed path used to reach the state update below, so aborted
+			// dispatches (30% of real spend on live data) stayed invisible to the
+			// per-conversation budget guard.
+			conversations.accrue(req.conversationKey, { spentUsd: reportedUsd ?? decision.forecast.expectedUsd });
 		};
 
 		// "retry" re-enters the attempt loop; "done" means the turn is settled
@@ -422,7 +429,9 @@ export async function runTurn(
 		// hysteresis re-arm below can tell whether this turn changed tier.
 		const prevTier = state.currentTier;
 		state.currentTier = decision.tier;
-		state.escalations += escalations;
+		// Escalations accumulate in SQL for the same reason spend does: `save`
+		// below no longer writes this column, so a snapshot cannot clobber it.
+		conversations.accrue(req.conversationKey, { escalations });
 		// Hysteresis window. Only re-arm when the served tier actually changed
 		// (or this turn escalated). Re-arming on EVERY turn — even a trivial one
 		// served by a held hard model — extends the lock forever: the classifier
@@ -434,9 +443,11 @@ export async function runTurn(
 		if (tierChanged || escalations > 0) {
 			state.stickyUntilTurn = turnNumber + resolveHoldTurns(config, req.conversationKey, escalations > 0).turns;
 		}
-		// Reported cost is authoritative; fall back to the forecast so the
-		// budget guard still works when the provider omits cost.
+		// Spend is already booked in `writeEntry`, beside the ledger row, so it is
+		// deliberately NOT accumulated here — doing both would double-count.
+		// Keep the in-memory copy coherent for anything reading `state` later.
 		state.spentUsd += reportedUsd ?? decision.forecast.expectedUsd;
+		state.escalations += escalations;
 		state.lastPromptTokens = usage.promptTokens;
 		if (usage.cachedTokens > 0 || usage.cacheWriteTokens > 0) {
 			// Non-zero cache traffic is direct evidence the upstream cache exists.
@@ -451,7 +462,17 @@ export async function runTurn(
 		// artifact of the turn, not a precondition for finishing it. A
 		// `tool_calls` finish means the assistant is still working, so the bridge
 		// buffers the fragment rather than writing a near-empty turn.
-		if (doxActive) {
+		//
+		// Only the agent's WORKING conversation is transcribed. A harness also
+		// drives utility calls through this same provider with `model: auto` —
+		// omp asks for a conversation title and a complexity rating — and those
+		// answer ABOUT a conversation instead of participating in one, which is
+		// where the junk records (`high`, `<title>…</title>`) came from. They are
+		// single-shot and carry NO tool schemas, while an agent always ships its
+		// tools, so the tool array is the discriminator. A deliberately
+		// tool-less session is therefore not transcribed: silence beats garbage,
+		// because every junk record is re-injected into every later turn.
+		if (doxActive && req.tools.length > 0) {
 			const userText = lastUserText(req);
 			const turnEnded = finishReason !== "tool_calls";
 			log.debug("agentdox record turn", {

package/test/embed-logic.test.ts

@@ -115,7 +115,11 @@ describe("agentdox scope", () => {
 		expect(deriveAgentdoxScope("")).toBe("");
 	});
 
-	test("an explicit defaultScope wins over the derived one", () => {
+	test("the workspace derivation wins over the scope-agnostic defaultScope", () => {
+		// Regression: one router install serves every project on the machine, so a
+		// global `defaultScope` overriding the derivation made an ashlands session
+		// ship `X-Agentdox-Scope: omp-router` — wrong context injected, turns
+		// filed under the wrong project.
 		const base = {
 			server: { host: "127.0.0.1" },
 			profiles: [],
@@ -123,8 +127,11 @@ describe("agentdox scope", () => {
 		};
 		const derived = buildProviderConfig(1234, { ...base, context: { enabled: true, defaultScope: "" } }, "/x/ashlands");
 		expect(derived.agentdoxScope).toBe("ashlands");
-		const explicit = buildProviderConfig(1234, { ...base, context: { enabled: true, defaultScope: "pinned" } }, "/x/ashlands");
-		expect(explicit.agentdoxScope).toBe("pinned");
+		const both = buildProviderConfig(1234, { ...base, context: { enabled: true, defaultScope: "omp-router" } }, "/x/ashlands");
+		expect(both.agentdoxScope).toBe("ashlands");
+		// The default only applies when the workspace yields nothing.
+		const fallback = buildProviderConfig(1234, { ...base, context: { enabled: true, defaultScope: "pinned" } }, "");
+		expect(fallback.agentdoxScope).toBe("pinned");
 	});
 
 	test("no scope header when the bridge is off", () => {

package/test/failover.test.ts

@@ -275,6 +275,7 @@ function mkConversations(): { store: ConversationStore; map: Map<string, Convers
 		save: (s) => {
 			map.set(s.key, s);
 		},
+		accrue: () => {},
 		prune: () => 0,
 	};
 	return { store, map };

package/test/state.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, test } from "bun:test";
+
+import { createConversationStore } from "../src/router/state.ts";
+import { openDb } from "../src/util/sqlite.ts";
+
+function mkStore() {
+	const db = openDb(":memory:");
+	return { db, store: createConversationStore(db) };
+}
+
+describe("conversation spend accounting", () => {
+	test("accrue accumulates instead of overwriting", () => {
+		const { db, store } = mkStore();
+		try {
+			store.load("k1");
+			store.accrue("k1", { spentUsd: 0.25 });
+			store.accrue("k1", { spentUsd: 0.5 });
+			store.accrue("k1", { escalations: 1 });
+			store.accrue("k1", { escalations: 2 });
+
+			const state = store.get("k1");
+			expect(state?.spentUsd).toBeCloseTo(0.75, 10);
+			expect(state?.escalations).toBe(3);
+		} finally {
+			db.close();
+		}
+	});
+
+	test("save cannot clobber spend booked by a dispatch that never committed", () => {
+		// The live bug: a dispatch is billed by the upstream, aborts mid-stream,
+		// and returns before the commit path. The NEXT dispatch had already loaded
+		// a turn-start snapshot, and `save` wrote that snapshot's stale total back
+		// over the aborted dispatch's cost. 30% of real spend vanished this way.
+		const { db, store } = mkStore();
+		try {
+			const snapshot = store.load("k1");
+			expect(snapshot.spentUsd).toBe(0);
+
+			// An aborted dispatch books its cost while `snapshot` is still in hand.
+			store.accrue("k1", { spentUsd: 0.4, escalations: 1 });
+
+			// The in-flight turn now commits using the state it loaded earlier.
+			snapshot.turn = 1;
+			snapshot.currentSlug = "cheap/model";
+			store.save(snapshot);
+
+			const after = store.get("k1");
+			expect(after?.spentUsd).toBeCloseTo(0.4, 10);
+			expect(after?.escalations).toBe(1);
+			// The latest-wins fields still persist normally.
+			expect(after?.turn).toBe(1);
+			expect(after?.currentSlug).toBe("cheap/model");
+		} finally {
+			db.close();
+		}
+	});
+
+	test("interleaved dispatches both keep their money", () => {
+		const { db, store } = mkStore();
+		try {
+			const a = store.load("k1");
+			const b = store.get("k1");
+			expect(b).not.toBeNull();
+
+			store.accrue("k1", { spentUsd: 0.1 });
+			store.save(a);
+			store.accrue("k1", { spentUsd: 0.2 });
+			if (b !== null) store.save(b);
+
+			expect(store.get("k1")?.spentUsd).toBeCloseTo(0.3, 10);
+		} finally {
+			db.close();
+		}
+	});
+
+	test("a zero delta does not touch the row", () => {
+		// Bumping updated_at_ms for a no-op write would keep a dead conversation
+		// alive against `prune`, which reaps on that timestamp.
+		const { db, store } = mkStore();
+		try {
+			store.load("k1");
+			const before = store.get("k1")?.updatedAtMs ?? 0;
+			expect(before).toBeGreaterThan(0);
+			store.accrue("k1", { spentUsd: 0, escalations: 0 });
+			expect(store.get("k1")?.updatedAtMs).toBe(before);
+		} finally {
+			db.close();
+		}
+	});
+});

package/test/turn.test.ts

@@ -241,8 +241,14 @@ function mkLedger(): { ledger: Ledger; entries: LedgerEntry[] } {
 	return { ledger, entries };
 }
 
-function mkConversations(): { store: ConversationStore; map: Map<string, ConversationState> } {
+function mkConversations(): {
+	store: ConversationStore;
+	map: Map<string, ConversationState>;
+	accrued: Map<string, { spentUsd: number; escalations: number }>;
+} {
 	const map = new Map<string, ConversationState>();
+	// Mirrors the real store: money accumulates here, NOT through `save`.
+	const accrued = new Map<string, { spentUsd: number; escalations: number }>();
 	const store: ConversationStore = {
 		get: (k) => map.get(k) ?? null,
 		load: (k) => {
@@ -270,9 +276,15 @@ function mkConversations(): { store: ConversationStore; map: Map<string, Convers
 		save: (s) => {
 			map.set(s.key, s);
 		},
+		accrue: (k, d) => {
+			const cur = accrued.get(k) ?? { spentUsd: 0, escalations: 0 };
+			cur.spentUsd += d.spentUsd ?? 0;
+			cur.escalations += d.escalations ?? 0;
+			accrued.set(k, cur);
+		},
 		prune: () => 0,
 	};
-	return { store, map };
+	return { store, map, accrued };
 }
 
 function mkSink(): { sink: ResponseSink; chunks: UpstreamChunk[]; errors: WireError[]; finishes: TurnSummary[] } {
@@ -556,6 +568,9 @@ describe("exploration reaches the ledger", () => {
 });
 
 describe("agentdox write-back sees the shape of the turn", () => {
+	/** An agent ships its tool schemas; a harness utility call does not. */
+	const AGENT_TOOL = { name: "read", description: "read a file", schemaBytes: 128 };
+
 	function mkRecordingBridge(): { bridge: ContextBridge; records: TurnRecord[] } {
 		const records: TurnRecord[] = [];
 		return {
@@ -589,8 +604,9 @@ describe("agentdox write-back sees the shape of the turn", () => {
 		const { store } = mkConversations();
 		const { sink, errors } = mkSink();
 		const { bridge, records } = mkRecordingBridge();
-		// doxActive needs a scope; the request header supplies it.
-		const req: NormRequest = { ...mkReq(), agentdoxScope: "proj" };
+		// doxActive needs a scope; the request header supplies it. The tool
+		// schemas mark this as the agent's working conversation.
+		const req: NormRequest = { ...mkReq(), agentdoxScope: "proj", tools: [AGENT_TOOL] };
 		const deps = { config: mkConfig({ enabled: false }), router, upstream, ledger, conversations: store, catalog, context: bridge };
 
 		await runTurn(req, sink, deps, new AbortController().signal);
@@ -603,4 +619,78 @@ describe("agentdox write-back sees the shape of the turn", () => {
 		expect(records[1]?.turnEnded).toBe(true);
 		expect(records[1]?.assistantText).toBe("all done");
 	});
+
+	test("a harness utility call is never transcribed", async () => {
+		// omp drives title generation and complexity rating through this same
+		// provider with `model: auto`. They answer ABOUT the conversation
+		// ("high", "<title>…</title>") and carry NO tool schemas. Recording them
+		// created junk agentdox sessions that then fed back into every later
+		// context block.
+		const { router } = mkRouter([mkDecision("trivial", "cheap/model", { escalateTo: null })]);
+		const { upstream } = mkUpstream([
+			{ kind: "chunks", chunks: [startChunk("cheap/model"), textChunk("high"), finishChunk("stop"), usageChunk({}, 0.0001)] },
+		]);
+		const { ledger } = mkLedger();
+		const { store } = mkConversations();
+		const { sink, errors } = mkSink();
+		const { bridge, records } = mkRecordingBridge();
+		// Same scope, same provider — only the absent tool array differs.
+		const req: NormRequest = { ...mkReq(), agentdoxScope: "proj", tools: [] };
+
+		await runTurn(req, sink, { config: mkConfig({ enabled: false }), router, upstream, ledger, conversations: store, catalog, context: bridge }, new AbortController().signal);
+
+		expect(errors).toHaveLength(0);
+		expect(records).toHaveLength(0);
+	});
+});
+
+describe("spend reaches the conversation total however the dispatch ends", () => {
+	test("a dispatch that dies mid-stream still books what it was billed", async () => {
+		// Live data: 152 aborted dispatches billed $0.9985 — 30% of all spend —
+		// and none of it reached the conversation's running total, because an abort
+		// returns before the commit path. The ledger row and the per-conversation
+		// budget guard must never disagree about money. Probe maxTokens 1 commits
+		// on the first token, so the retryable error below cannot re-enter the
+		// attempt loop and confuse the accounting.
+		const { router } = mkRouter([mkDecision("simple", "cheap/model", { maxTokens: 1, escalateTo: null })]);
+		const { upstream } = mkUpstream([
+			{
+				kind: "die",
+				chunks: [
+					startChunk("cheap/model"),
+					textChunk("plenty of text here, enough to commit on"),
+					usageChunk({ promptTokens: 47_700, completionTokens: 154 }, 0.0071),
+				],
+				error: new UpstreamError("network", 0, "request aborted", true),
+			},
+		]);
+		const { ledger, entries } = mkLedger();
+		const { store, accrued } = mkConversations();
+		const { sink } = mkSink();
+
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
+
+		// The turn never committed: the ledger row carries the error.
+		expect(entries).toHaveLength(1);
+		expect(entries[0]?.error).not.toBeNull();
+		// ...but the money was still booked.
+		expect(accrued.get("conv-test")?.spentUsd).toBeCloseTo(0.0071, 10);
+	});
+
+	test("a committed turn books its cost exactly once", async () => {
+		const { router } = mkRouter([mkDecision("simple", "cheap/model", { escalateTo: null })]);
+		const { upstream } = mkUpstream([
+			{ kind: "chunks", chunks: [startChunk("cheap/model"), textChunk("done"), finishChunk("stop"), usageChunk({}, 0.002)] },
+		]);
+		const { ledger, entries } = mkLedger();
+		const { store, accrued } = mkConversations();
+		const { sink, errors } = mkSink();
+
+		await runTurn(mkReq(), sink, { config: mkConfig(), router, upstream, ledger, conversations: store, catalog, context: createDisabledBridge() }, new AbortController().signal);
+
+		expect(errors).toHaveLength(0);
+		expect(entries).toHaveLength(1);
+		// Booked in writeEntry only — the commit path must not add it again.
+		expect(accrued.get("conv-test")?.spentUsd).toBeCloseTo(0.002, 10);
+	});
 });