auto-model-router 0.9.0 → 0.10.0

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.9.0",
+    "version": "0.10.0",
     "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.9.0",
+      "version": "0.10.0",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -1330,10 +1330,15 @@ short-lived key rotates underneath a running session.
 In remote mode omp sends `X-Agentdox-Scope` derived from the workspace folder, so one
 remote router serves every repo on the machine with that repo's shared context. The remote
 decides what to do with it: a team edition that pins a scope on the member's group
-overrides it, and one that pins none follows the workspace. That header rides on the roles
-the extensions register; the **main** model's handle comes from `models.yml`, which is
-machine-wide, so it carries a scope only if you pass `--scope <slug>` to `connect` — right
-for a single-project machine, wrong for one with several repos.
+overrides it, and one that pins none follows the workspace. The roles the extensions
+register carry the header directly. The **main** model's handle comes from `models.yml`,
+which is machine-wide and resolved before extensions load, so `connect` writes that
+entry's header value as the *name* of an environment variable,
+`AUTO_MODEL_ROUTER_SCOPE`; omp resolves it from the environment on every request, and
+the embed extension sets it from the workspace as it loads. If the variable is unset omp
+sends the name itself, which the router does not accept as a scope (a scope is a
+lowercase slug) and falls back to its default. `--scope <slug>` pins one project for the
+whole machine instead; a refresh keeps a pin, and `connect --scope ""` removes it.
 
 ## Multiple coding harnesses, one router
 
@@ -1471,6 +1476,17 @@ move while the loop runs. So the router buffers the assistant's narration across
 the loop and writes it once, together with the closing synthesis, when the
 assistant actually yields back to the user.
 
+### Utility calls get neither the block nor a transcript
+
+A harness drives more than the agent's conversation through this provider: omp
+asks for a session title and a complexity rating with `model: auto`. Those
+calls answer *about* the conversation, carry no tool schemas, and gain nothing
+from the project block, yet each one paid the whole block — measured at ~6k
+prompt tokens per call, 42k across one turn's seven side calls. So the tool
+array is the discriminator for both directions: a request with no tools is
+neither recorded nor injected. `context.injectWithoutTools: true` restores
+injection into tool-less requests for a deliberately tool-less agent.
+
 Write-backs are queued, bounded, and never awaited: agentdox is an enrichment,
 not a dependency. If it is unreachable the turn routes and dispatches normally,
 and a pinned block keeps being served.

package/docs/AGENTDOX-BRIDGE.md

@@ -169,6 +169,16 @@ scope now correct the bridge degrades to **inert** for other projects. Correct a
 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.
 
+## 6b. FIXED — the same discriminator gates injection (0.10)
+
+Recording skipped tool-less calls from 0.2.11, but injection did not: every scoped
+request received the block, so omp's title and rating calls each carried ~6k tokens of
+project context they could not use. Measured 2026-09-08 on one omp turn: seven side
+calls, 23,412 chars each, 42,417 prompt tokens of context in total. `turn.ts` now
+resolves the block only when `req.tools.length > 0`, the same test recording uses, and
+leaves the conversation's pin untouched otherwise. `context.injectWithoutTools` (default
+off) is the escape hatch for an agent that deliberately ships no tools.
+
 ## 7. Also worth doing
 
 - **Context pollution from test turns.** `context_assemble` includes recent session messages,

package/omp-extension/router-embed.ts

@@ -34,6 +34,19 @@ import type { RouterConfig } from "../src/config/types.ts";
 import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
 
 import { EMBED_DUMMY_API_KEY, EMBED_PROVIDER_ID, buildProviderConfig, deriveAgentdoxScope, embedPortPath, modelsYmlPort, probeEmbed, readEmbedPort, resolveEmbedPort, writeEmbedPort } from "./embed-logic.ts";
+import { SCOPE_ENV } from "../src/context/scope.ts";
+
+// The workspace's scope for the MAIN model. omp builds that handle from
+// models.yml before this file loads, so its X-Agentdox-Scope cannot come from
+// the provider we register; instead the managed entry names SCOPE_ENV as the
+// header's value, omp resolves that from the environment on every request,
+// and this module runs inside omp's process — so setting it here reaches
+// every turn of this session, main and side roles alike. A workspace that
+// derives no scope (no folder name) leaves whatever the shell set.
+{
+	const workspaceScope = deriveAgentdoxScope(process.cwd());
+	if (workspaceScope !== "") process.env[SCOPE_ENV] = workspaceScope;
+}
 
 /** omp's models.yml as text, or "" when it does not exist / cannot be read. */
 function readModelsYml(): string {

package/package.json

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

package/src/cli/config-cmd.ts

@@ -15,6 +15,7 @@
  * keys survive.
  */
 
+import { SCOPE_ENV } from "../context/scope.ts";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
@@ -59,16 +60,20 @@ export interface SpliceResult {
  */
 /**
  * Headers omp attaches to every request through this provider. Both are
- * optional: absent harness id ⇒ single-harness defaults, absent agentdox scope
- * ⇒ the router falls back to its own `context.defaultScope`.
+ * optional: absent harness id ⇒ single-harness defaults; the agentdox scope
+ * names `SCOPE_ENV`, which omp resolves from its environment per request and
+ * the embed extension sets from the workspace folder, so the MAIN model's turns
+ * carry the repository's own scope rather than one for the whole machine. When
+ * the variable is unset the router ignores the literal and falls back to its
+ * own `context.defaultScope`.
  */
 function providerHeaders(cfg: RouterConfig): Record<string, string> {
 	const headers: Record<string, string> = {};
 	if (cfg.server.harnessId !== undefined && cfg.server.harnessId !== "") {
 		headers["X-Omp-Harness"] = cfg.server.harnessId;
 	}
-	if (cfg.context.enabled && cfg.context.defaultScope !== "") {
-		headers["X-Agentdox-Scope"] = cfg.context.defaultScope;
+	if (cfg.context.enabled) {
+		headers["X-Agentdox-Scope"] = SCOPE_ENV;
 	}
 	return headers;
 }

package/src/cli/config-wizard.ts

@@ -301,6 +301,7 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "context.sessionLimit", label: "Session items", kind: "number", min: 0 },
 			{ path: "context.briefChars", label: "Brief chars", kind: "number", min: 0 },
 			{ path: "context.recordTurns", label: "Record turns back", kind: "boolean" },
+			{ path: "context.injectWithoutTools", label: "Inject into tool-less calls", kind: "boolean" },
 			{ path: "context.maxQueue", label: "Write-back queue", kind: "number", min: 1 },
 		],
 	},

package/src/cli/connect.ts

@@ -29,6 +29,7 @@ import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { refreshAccountOf, remoteFilePath } from "../../omp-extension/remote-logic.ts";
+import { SCOPE_ENV } from "../context/scope.ts";
 import { pickStore, saveRefreshToken, type StoreDeps, type StoreKind } from "./credential-store.ts";
 import { flagString, type CliArgs } from "./args.ts";
 
@@ -47,7 +48,7 @@ export interface ConnectOptions {
 	packageDir: string;
 	/** Cost figures omp shows for the remote's virtual models, USD per million tokens. */
 	blend?: { inputPerMtok: number; outputPerMtok: number };
-	/** Adds `X-Agentdox-Scope` to omp's models.yml entry. Machine-wide: only for a single-project machine. Undefined keeps what the managed block already has. */
+	/** Pins `X-Agentdox-Scope` in omp's models.yml entry to one slug, machine-wide. Without it the entry follows the workspace (see renderRemoteModelsYml). Undefined keeps what the managed block already has. */
 	agentdoxScope?: string;
 	/** Short-lived credential fields from a remote that issues them; absent for a permanent key. */
 	refreshToken?: string;
@@ -141,10 +142,13 @@ const MODELS_YML_END = "  # END auto-model-router (remote)";
  * neither problem — the URL and the key are stable — and the entry is what makes
  * omp's main model resolvable at startup, before extensions load.
  *
- * `scope` adds `X-Agentdox-Scope` to every request through this provider. It is
- * off by default on purpose: the file is machine-wide, so a scope here would
- * label turns from every workspace with one project. The extensions still send
- * the workspace's own scope on the roles that resolve after they load.
+ * `X-Agentdox-Scope` on this entry reaches the MAIN model's turns, which the
+ * extensions' own registration cannot (they load after the handle is built).
+ * The file is machine-wide, so a literal slug here would label every
+ * workspace's turns with one project; by default the value is the NAME of
+ * `SCOPE_ENV`, which omp resolves from its environment per request, and the
+ * embed extension sets that variable from the workspace folder as it loads.
+ * `scope` pins a literal slug instead, for a single-project machine.
  */
 export function renderRemoteModelsYml(url: string, key: string, blend: { inputPerMtok: number; outputPerMtok: number }, scope = ""): string {
 	const round = (v: number): number => Math.round(v * 1e4) / 1e4;
@@ -162,7 +166,7 @@ export function renderRemoteModelsYml(url: string, key: string, blend: { inputPe
 		"    api: openai-completions",
 		`    apiKey: ${key}`,
 	];
-	if (scope !== "") lines.push("    headers:", `      X-Agentdox-Scope: ${scope}`);
+	lines.push("    headers:", `      X-Agentdox-Scope: ${scope !== "" ? scope : SCOPE_ENV}`);
 	lines.push("    models:");
 	for (const m of REMOTE_MODEL_ROWS) {
 		lines.push(
@@ -201,14 +205,15 @@ export function mergeModelsYml(before: string, blockText: string): string {
 	return `${body.replace(/\s*$/, "")}${eol}providers:${eol}${block}${eol}`;
 }
 
-/** The `X-Agentdox-Scope` the managed block carries, or "" when none. */
+/** The literal `X-Agentdox-Scope` the managed block pins, or "" when it follows the workspace (or has none). */
 export function existingBlockScope(text: string): string {
 	const begin = text.indexOf(MODELS_YML_BEGIN);
 	if (begin < 0) return "";
 	const end = text.indexOf(MODELS_YML_END, begin);
 	const block = text.slice(begin, end < 0 ? text.length : end);
 	const m = /X-Agentdox-Scope:\s*(\S+)/.exec(block);
-	return m?.[1] ?? "";
+	const value = m?.[1] ?? "";
+	return value === SCOPE_ENV ? "" : value;
 }
 
 /** True when the file already defines our provider outside a block we manage. */

package/src/config/defaults.ts

@@ -263,6 +263,14 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// the query-relevant memory/docs tail. 0 omits the brief.
 		briefChars: 12_000,
 		recordTurns: true,
+		// A request with no tool schemas is a harness utility call — omp asks for
+		// a session title or a complexity rating through the same provider — and
+		// it answers ABOUT the conversation, so the project block cannot help it.
+		// Recording already skips those calls (turn.ts); injection did not, and
+		// one omp turn measured seven side calls at ~6k tokens of context each,
+		// 42k prompt tokens for nothing. Off: the block goes only to turns that
+		// ship tools. On: every scoped turn gets it, as before 0.10.
+		injectWithoutTools: false,
 		maxQueue: 64,
 	},
 	compaction: {

package/src/config/schema.ts

@@ -192,6 +192,7 @@ const context = z.strictObject({
 	sessionLimit: z.number().int().nonnegative().optional(),
 	briefChars: z.number().int().nonnegative().optional(),
 	recordTurns: z.boolean().optional(),
+	injectWithoutTools: z.boolean().optional(),
 	maxQueue: z.number().int().positive().optional(),
 });
 

package/src/config/types.ts

@@ -769,6 +769,13 @@ export interface ContextConfig {
 	briefChars: number;
 	/** Write settled turns back to agentdox sessions, tagged with the served model. */
 	recordTurns: boolean;
+	/**
+	 * Inject the block into turns that carry NO tool schemas too. Those are
+	 * harness utility calls (titles, ratings), which recording already skips;
+	 * default off, because each one paid the whole block for an answer that is
+	 * about the conversation, not part of it.
+	 */
+	injectWithoutTools: boolean;
 	/** Bound on queued write-backs; excess turns are dropped, never buffered unbounded. */
 	maxQueue: number;
 }

package/src/context/scope.ts

@@ -0,0 +1,29 @@
+/**
+ * The agentdox scope a request names, and where omp's main model gets it from.
+ *
+ * omp resolves its MAIN model from `models.yml` at startup, before any extension
+ * loads, so the `X-Agentdox-Scope` header on that provider entry cannot be set
+ * by the extension per workspace — but omp resolves a header VALUE that names
+ * an environment variable from the environment on every request, and the
+ * extension runs inside omp's process. So `connect` (and the local sync) write
+ * the header's value as the NAME below, and the extension sets that variable
+ * from the workspace folder when it loads. One machine-wide file, one scope
+ * per repository.
+ */
+export const SCOPE_ENV = "AUTO_MODEL_ROUTER_SCOPE";
+
+/**
+ * A scope is an agentdox project slug: lowercase, starting alphanumeric. The
+ * shape matters because omp sends the header's literal value when the variable
+ * it names is unset — `AUTO_MODEL_ROUTER_SCOPE` itself — and that must never
+ * become a project. Uppercase never passes, so the sentinel cannot.
+ */
+export function isScopeSlug(value: string): boolean {
+	return /^[a-z0-9][a-z0-9._-]{0,127}$/.test(value);
+}
+
+/** The scope to trust from a request header: a slug, or "" for anything else. */
+export function acceptScope(raw: string | null | undefined): string {
+	const s = (raw ?? "").trim();
+	return isScopeSlug(s) ? s : "";
+}

package/src/index.ts

@@ -27,7 +27,7 @@ Usage: auto-model-router <command> [options]
   stats      Show routed spend, per-model share, and escalation rates
   report     Usage analytics: providers, models, tiers, cost, speed, cache hit rate
   export     One row per day, harness and model as CSV (--json for rows)
-  connect    Point this machine at a remote router (--url, --key[, --refresh-token]; --scope labels a single-project machine; --profile persists the environment)
+  connect    Point this machine at a remote router (--url, --key[, --refresh-token]; --scope pins one project for the whole machine (default: each workspace's own); --profile persists the environment)
   refresh    Trade the refresh token for a new access key and re-write every harness config (--force: even when not near expiry)
   token      Print an access key that is good right now, refreshing first if needed (for a harness key-helper)
   models     Show what each complexity tier would consider, and why

package/src/server/turn.ts

@@ -136,6 +136,12 @@ export async function runTurn(
 	// Request header wins; the configured default covers harnesses that send none.
 	const doxScope = req.agentdoxScope !== "" ? req.agentdoxScope : config.context.defaultScope;
 	const doxActive = bridge.enabled && doxScope !== "";
+	// Injection shares recording's discriminator (explained at the record call
+	// below): a tool-less harness utility call answers ABOUT the conversation
+	// and gains nothing from the project block, yet paid its full ~6k tokens on
+	// every title and rating — 42k prompt tokens across one omp turn's seven
+	// side calls. `context.injectWithoutTools` restores the old behaviour.
+	const doxInject = doxActive && (req.tools.length > 0 || config.context.injectWithoutTools);
 
 	// The trigger list is the source of truth for enabled signals, except
 	// length_stop, which rides on its own toggle (escalation.escalateOnLengthStop).
@@ -209,7 +215,7 @@ export async function runTurn(
 		// turn's prefix is already cold — a model switch or a retry — so the
 		// injected bytes stay identical while the cache is worth keeping.
 		let contextBlock: string | undefined;
-		if (doxActive) {
+		if (doxInject) {
 			const pin = await bridge.resolve({
 				scope: doxScope,
 				conversationKey: req.conversationKey,
@@ -233,6 +239,7 @@ export async function runTurn(
 		log.debug("agentdox context", {
 			active: doxActive,
 			scope: doxScope === "" ? "(none)" : doxScope,
+			utilityCall: doxActive && !doxInject,
 			injected: contextBlock !== undefined,
 			chars: contextBlock?.length ?? 0,
 		});

package/src/wire/openai/request.ts

@@ -1,3 +1,4 @@
+import { acceptScope } from "../../context/scope.ts";
 import type {
 	RequestPolicy,
 	CompactionEdit,
@@ -329,8 +330,10 @@ export function parseChatRequest(body: unknown, headers: Headers): NormRequest {
 	const ompSessionId = (headers.get("x-omp-session") ?? "").trim();
 
 	// agentdox project scope. Selects whose shared context is injected; absent
-	// ⇒ the server falls back to its configured default scope.
-	const agentdoxScope = (headers.get("x-agentdox-scope") ?? "").trim();
+	// or not a slug (omp sends the literal env-var NAME when the variable that
+	// models.yml names is unset — see src/context/scope.ts) ⇒ the server falls
+	// back to its configured default scope.
+	const agentdoxScope = acceptScope(headers.get("x-agentdox-scope"));
 
 	// Subagent marker from the embed extension (sessions without a UI).
 	const isSubagent = (headers.get("x-omp-subagent") ?? "").trim() === "1";

package/test/failover.test.ts

@@ -73,7 +73,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		hysteresis: { holdTurns: 2, holdTurnsAfterEscalation: 4, switchMargin: 1.5, cacheWarmTtlMs: 600_000, maxDowngradePerTurn: 1, breakHoldOnMechanical: false, switchHorizonTurns: 1, confirmUpgradesBelowConfidence: 0.6 },
 		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 },
+		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, injectWithoutTools: false, maxQueue: 64 },
 		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, digestToolResults: false, digestMaxPerTurn: 2 },
 		budget: { onExceeded: "downgrade" },
 		report: { baselines: [], dailySummary: false },

package/test/remote.test.ts

@@ -6,6 +6,7 @@ import { join } from "node:path";
 import { addExtensions, codexBlock, connectRemote, setDotenv, type ConnectOptions } from "../src/cli/connect.ts";
 import { parseRemoteRouter, readRemoteRouter, remoteProviderRegistration } from "../omp-extension/remote-logic.ts";
 import { existingBlockScope, hasForeignRouterProvider, mergeModelsYml, renderRemoteModelsYml } from "../src/cli/connect.ts";
+import { SCOPE_ENV } from "../src/context/scope.ts";
 import { refreshAndRewrite, refreshCredential, RefreshError, resolveRefreshToken, shouldRefresh } from "../src/cli/refresh.ts";
 import { loadRefreshToken, pickStore, removeRefreshToken, saveRefreshToken } from "../src/cli/credential-store.ts";
 import { hasRefresh, refreshAccountOf } from "../omp-extension/remote-logic.ts";
@@ -114,7 +115,7 @@ describe("omp models.yml for a remote router", () => {
 	const NL = String.fromCharCode(10);
 	const yaml = (...lines: string[]): string => lines.join(NL) + NL;
 
-	test("the block names the remote, the key and the three virtual models; a scope is opt-in", () => {
+	test("the block names the remote, the key and the three virtual models; the scope follows the workspace unless pinned", () => {
 		const block = renderRemoteModelsYml("https://team.example/", "amrt_k", BLEND);
 		expect(block).toContain("baseUrl: https://team.example/v1");
 		expect(block).toContain("apiKey: amrt_k");
@@ -122,9 +123,15 @@ describe("omp models.yml for a remote router", () => {
 		expect(block).toContain("- id: auto-cheap");
 		expect(block).toContain("- id: auto-max");
 		expect(block).toContain("cost: { input: 1.1, output: 4.4, cacheRead: 0.11, cacheWrite: 1.375 }");
-		// Machine-wide file: no scope unless the caller asks for one.
-		expect(block).not.toContain("X-Agentdox-Scope");
-		expect(renderRemoteModelsYml("https://team.example", "k", BLEND, "omp-router")).toContain("X-Agentdox-Scope: omp-router");
+		// Machine-wide file: the header names the env var the extension sets per
+		// workspace, so the MAIN model's turns carry each repo's own scope.
+		expect(block).toContain(`X-Agentdox-Scope: ${SCOPE_ENV}`);
+		expect(existingBlockScope(mergeModelsYml("", block))).toBe("");
+		// --scope pins one slug for the whole machine.
+		const pinned = renderRemoteModelsYml("https://team.example", "k", BLEND, "omp-router");
+		expect(pinned).toContain("X-Agentdox-Scope: omp-router");
+		expect(pinned).not.toContain(SCOPE_ENV);
+		expect(existingBlockScope(mergeModelsYml("", pinned))).toBe("omp-router");
 	});
 
 	test("merging keeps other providers, replaces our own block, and is idempotent", () => {

package/test/scope.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import { SCOPE_ENV, acceptScope, isScopeSlug } from "../src/context/scope.ts";
+import { parseChatRequest } from "../src/wire/openai/request.ts";
+
+describe("the scope a request may name", () => {
+	test("a slug passes; the env-var sentinel and other non-slugs do not", () => {
+		expect(isScopeSlug("omp-router")).toBe(true);
+		expect(isScopeSlug("ashlands")).toBe(true);
+		expect(isScopeSlug("my.app_v2")).toBe(true);
+		// omp sends the header's literal value when the variable it names is
+		// unset: the NAME must never become a project.
+		expect(isScopeSlug(SCOPE_ENV)).toBe(false);
+		expect(isScopeSlug("")).toBe(false);
+		expect(isScopeSlug("-leading")).toBe(false);
+		expect(isScopeSlug("Has Spaces")).toBe(false);
+		expect(isScopeSlug("a".repeat(129))).toBe(false);
+	});
+
+	test("acceptScope trims and rejects", () => {
+		expect(acceptScope(" omp-router ")).toBe("omp-router");
+		expect(acceptScope(SCOPE_ENV)).toBe("");
+		expect(acceptScope(null)).toBe("");
+	});
+
+	test("the wire parser drops a non-slug X-Agentdox-Scope", () => {
+		const body = { model: "auto", messages: [{ role: "user", content: "hi" }] };
+		const parse = (scope: string) => parseChatRequest(body, new Headers({ "x-agentdox-scope": scope }));
+		expect(parse("omp-router").agentdoxScope).toBe("omp-router");
+		expect(parse(SCOPE_ENV).agentdoxScope).toBe("");
+	});
+});

package/test/turn.test.ts

@@ -73,7 +73,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		hysteresis: { holdTurns: 2, holdTurnsAfterEscalation: 4, switchMargin: 1.5, cacheWarmTtlMs: 600_000, maxDowngradePerTurn: 1, breakHoldOnMechanical: false, switchHorizonTurns: 1, confirmUpgradesBelowConfidence: 0.6 },
 		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 },
+		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, injectWithoutTools: false, maxQueue: 64 },
 		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, digestToolResults: false, digestMaxPerTurn: 2 },
 		budget: { onExceeded: "downgrade" },
 		report: { baselines: [], dailySummary: false },
@@ -660,6 +660,81 @@ describe("agentdox write-back sees the shape of the turn", () => {
 	});
 });
 
+describe("agentdox injection sees the shape of the turn", () => {
+	const AGENT_TOOL = { name: "read", description: "read a file", schemaBytes: 128 };
+
+	/** A bridge that always has a block, counting how often it is asked. */
+	function mkServingBridge(): { bridge: ContextBridge; resolves: number[] } {
+		const resolves: number[] = [];
+		return {
+			resolves,
+			bridge: {
+				enabled: true,
+				resolve: () => {
+					resolves.push(1);
+					return Promise.resolve({ block: "<project-context>ctx</project-context>", version: "v1", fetchedAtMs: 1 });
+				},
+				recordTurn: () => {},
+				flush: () => Promise.resolve(),
+				pruneBlocks: () => 0,
+				close: () => {},
+			},
+		};
+	}
+
+	function oneDispatch() {
+		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();
+		return { router, upstream, ledger, store, sink, errors };
+	}
+
+	test("a harness utility call gets no context block", async () => {
+		// Measured on one omp turn: seven tool-less side calls (title, ratings)
+		// each received the whole ~6k-token block — 42k prompt tokens for
+		// answers ABOUT the conversation. The tool array is the discriminator,
+		// exactly as for recording.
+		const { router, upstream, ledger, store, sink, errors } = oneDispatch();
+		const { bridge, resolves } = mkServingBridge();
+		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(resolves).toHaveLength(0);
+		expect(store.load(req.conversationKey).contextVersion).toBeNull();
+	});
+
+	test("an agent turn with tools is injected", async () => {
+		const { router, upstream, ledger, store, sink, errors } = oneDispatch();
+		const { bridge, resolves } = mkServingBridge();
+		const req: NormRequest = { ...mkReq(), agentdoxScope: "proj", tools: [AGENT_TOOL] };
+
+		await runTurn(req, sink, { config: mkConfig({ enabled: false }), router, upstream, ledger, conversations: store, catalog, context: bridge }, new AbortController().signal);
+
+		expect(errors).toHaveLength(0);
+		expect(resolves).toHaveLength(1);
+		expect(store.load(req.conversationKey).contextVersion).toBe("v1");
+	});
+
+	test("context.injectWithoutTools restores injection into tool-less calls", async () => {
+		const { router, upstream, ledger, store, sink, errors } = oneDispatch();
+		const { bridge, resolves } = mkServingBridge();
+		const base = mkConfig({ enabled: false });
+		const config: RouterConfig = { ...base, context: { ...base.context, injectWithoutTools: true } };
+		const req: NormRequest = { ...mkReq(), agentdoxScope: "proj", tools: [] };
+
+		await runTurn(req, sink, { config, router, upstream, ledger, conversations: store, catalog, context: bridge }, new AbortController().signal);
+
+		expect(errors).toHaveLength(0);
+		expect(resolves).toHaveLength(1);
+	});
+});
+
 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 —