auto-model-router 0.2.10 → 0.2.11

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.11",
     "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.11",
       "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.11",
   "private": false,
   "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
   "type": "module",

package/src/server/turn.ts

@@ -451,7 +451,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/turn.test.ts

@@ -556,6 +556,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 +592,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 +607,27 @@ 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);
+	});
 });