auto-model-router 0.2.13 → 0.2.15

package/.claude/skills/agentdox/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: agentdox
-description: "Use agentdox — the shared memory, docs, and context server — the same way every session. Trigger on connect in any repo whose CLAUDE.md or .env.agentdox names an agentdox scope, and whenever the user mentions agentdox, project memory, remembering/recalling facts, project docs, the project brief, decisions, or session history. Also trigger BEFORE asking the user something they may have already told you, and BEFORE finishing any task that changed architecture, conventions, or decisions."
+description: "Use agentdox — the shared memory, docs, and context server — the same way every session. Trigger on connect in any repo — the scope comes from .env.agentdox, CLAUDE.md, or the repo folder name, and you create it if it has never been set — and whenever the user mentions agentdox, project memory, remembering/recalling facts, project docs, the project brief, decisions, or session history. Also trigger BEFORE asking the user something they may have already told you, and BEFORE finishing any task that changed architecture, conventions, or decisions."
 ---
 
 # agentdox — the standard interaction protocol
@@ -13,16 +13,93 @@ store collapses if each session writes it differently.
 
 ## 0. Resolve the scope before anything else
 
-Everything is namespaced by a **scope** = the project slug. Get it, in this order:
+Everything is namespaced by a **scope** = the project slug, and **the scope is derived from the
+project folder you are working in — never from your credential.** Resolve it in this order and
+stop at the first hit:
 
 1. `AGENTDOX_SCOPE` in the repo's `.env.agentdox`
 2. The slug named in the repo's `CLAUDE.md`
-3. List projects and match the repo name
+3. `project_list` — an existing project whose slug matches the repo folder name
+4. **Nothing yet → derive it from the folder name and create it** (below). Don't ask first;
+   a folder with no scope is just a project that hasn't been onboarded, and the global token
+   already covers it.
 
 Known scopes: `ashlands` (E:/projects/ashlands/ashlands), `omp-router` (E:/projects/omp-router).
 
-**Never write outside your scope.** If you cannot determine it, ask — do not guess, and do not
-fall back to a default.
+### Creating the scope for a folder that has never had one
+
+Deterministic, so the same folder always resolves to the same slug:
+
+1. Take the **repo root** folder name — `git rev-parse --show-toplevel`, not the cwd. A
+   subdirectory must never become its own project.
+2. Slugify it: lowercase, every run of non-alphanumerics → a single `-`, trim leading/trailing
+   `-`. `E:/projects/My_App` → `my-app`.
+3. `project_list` **before creating.**
+   - **Exact match** — usually this repo, already onboarded elsewhere; adopt it. But an exact
+     match reached from a folder that has never been onboarded can also be a *collision*: two
+     unrelated repos with the same folder name (`E:/projects/foo/api` and `E:/work/api`) both
+     slugify to `api`, and adopting blindly merges two projects into one namespace. Check the
+     existing project's brief/description first; if it clearly describes a different codebase,
+     stop and ask for a distinguishing slug.
+   - **Near match** (`my-app` vs `my-app-v2`) — a stop sign: ask, rather than fork a second
+     namespace for one project.
+4. `project_ensure {slug, name}` — `name` is the readable form of the folder.
+5. **Make `.env.agentdox` un-committable *before* writing it.** Run `git check-ignore -v
+   .env.agentdox`. If it is not ignored, **add `.env.agentdox` to `.gitignore`** (create that
+   file if there is none) — do not merely check and move on. Patterns like `.env` and
+   `.env.*.local` do **not** match `.env.agentdox`; that exact gap existed in the agentdox repo
+   itself. This file carries the global token, which is instance admin: committing it is the
+   worst outcome available here.
+6. **Persist the scope, or the next session redoes all of this.** Write `.env.agentdox` at the
+   repo root:
+
+   ```ini
+   AGENTDOX_URL=http://localhost:3003
+   AGENTDOX_SCOPE=<slug>
+   AGENTDOX_TOKEN=<the global PAT>
+   ```
+
+   Take the token value from the `AGENTDOX_TOKEN` environment variable (`$env:AGENTDOX_TOKEN` on
+   Windows), or copy it from another agentdox repo's `.env.agentdox`. If neither exists, this
+   machine has no global PAT yet — stop and ask the user to mint one. Never invent a token.
+7. Add the `.mcp.json` from §1 if the repo has none. **It does not take effect this session** —
+   MCP config is read once, at harness startup. Finish *this* session over REST, and tell the
+   user to restart the harness to get the MCP tools.
+8. Copy the skill into the repo: `~/.claude/skills/agentdox/SKILL.md` →
+   `.claude/skills/agentdox/SKILL.md`. Claude Code finds the user-level copy anyway, but omp and
+   other harnesses only discover **project-relative** skills — without this, the protocol
+   silently stops applying there.
+9. Add an agentdox section to the repo's `CLAUDE.md` (create the file if absent). This is
+   resolution step 2 above, and it is what makes the *next* agent, in any harness, follow the
+   protocol:
+
+   > ## agentdox — shared context/memory (**MANDATORY to keep updated**)
+   >
+   > agentdox is this repo's memory + docs + live-conversation system. The project slug is
+   > **`<slug>`** — ALWAYS scope agentdox writes to it. `.mcp.json` uses **`AGENTDOX_TOKEN`**,
+   > one global bearer token shared by every agentdox-wired repo; the scope comes from *this
+   > folder* (`AGENTDOX_SCOPE` in `.env.agentdox`, gitignored), not from the token. That token
+   > grants every scope, so a wrong slug is **not** rejected — it silently writes into another
+   > project.
+   >
+   > Keeping agentdox current is part of completing a task, not optional. Full protocol:
+   > `.claude/skills/agentdox/SKILL.md`.
+10. Give the brief an overview. `context_brief_seed {scope}` builds one **from existing memory
+    and docs**, so on a scope you just created it returns 200 and an *empty* brief — there is
+    nothing to seed from yet. Write it directly instead:
+    `PUT /context/brief {scope, overview, repoLayout?, buildTest?, gotchas?}`. Seed later, once
+    the scope has material.
+11. **Verify before you claim it works:** write one memory in the new scope and read it back
+    (`memory_add` → `memory_search`, or `POST /memory` → `GET /memory?category=<slug>`). A 401
+    here means `AGENTDOX_TOKEN` is missing from the environment, not that onboarding failed.
+
+Then tell the user, briefly: the scope you created, the files you added, and that the MCP tools
+need a harness restart. Don't make them discover that a new project appeared.
+
+**Never write outside your scope.** The bearer token is global (see §1) and grants *every*
+scope, so a wrong slug will **not** be rejected — it will silently succeed and file this
+project's data under another project's namespace. Nothing catches that but you. If you cannot
+determine the scope, ask — do not guess, and do not fall back to a default.
 
 ## 1. Pick your transport — MCP or REST
 
@@ -35,13 +112,15 @@ Both hit the same live store with the same RBAC. **Check which you have, then us
 - **No such tools** — **use the REST API directly.** Never skip recording just because MCP
   tools are absent; that is the most likely way this protocol silently stops happening.
 
-If you expected MCP tools and don't have them, the usual cause is the bearer env var missing
+If you expected MCP tools and don't have them, the usual cause is `AGENTDOX_TOKEN` missing
 from the **launching shell's** environment. A Windows *User*-scope variable only reaches
 processes started after it was set, so an already-running terminal won't have it. Either
 restart the shell/harness or fall back to REST for this session — don't just skip the writes.
 
-REST auth: `Authorization: Bearer <token>`, where the token is `AGENTDOX_TOKEN` from the
-repo's `.env.agentdox`.
+REST auth: `Authorization: Bearer <token>`, where the token is `AGENTDOX_TOKEN` — **one
+global PAT shared by every repo** (non-expiring, wildcard grants), held in the Windows User
+environment and mirrored into each repo's `.env.agentdox`. It is deliberately *not*
+project-scoped: a new project folder needs no new token, only its own `AGENTDOX_SCOPE`.
 
 Cleanest REST call path — a throwaway `bun` script, which avoids PowerShell mangling `$` in
 inline JSON and avoids quoting pain in `curl`:
@@ -128,10 +207,11 @@ facts. Record the *why* of a decision, not just the *what*.
 
 ## When agentdox fails
 
-- **401** → the bearer token env var referenced by `.mcp.json` is missing from the
-  environment. Re-set it from the repo's `.env.agentdox` and restart the harness (`${VAR}`
-  substitution happens once, at MCP-server startup).
-- **403** → you are writing outside your granted scope. Re-check the slug.
+- **401** → `AGENTDOX_TOKEN` is missing from the launching shell's environment. Re-set it from
+  the repo's `.env.agentdox` and restart the harness (`${VAR}` substitution happens once, at
+  MCP-server startup).
+- **403** → should not happen with the global token. If it does, that token was revoked or
+  replaced by a scoped one — check `.env.agentdox` against agentdox's `/auth/tokens` list.
 - **Connection refused** → the `agentdox-server` Docker container is not running.
 
 Report the failure rather than proceeding as if the store were up to date.
@@ -141,3 +221,9 @@ Report the failure rather than proceeding as if the store were up to date.
 *Canonical copy: `~/.claude/skills/agentdox/SKILL.md`. omp only discovers skills from
 **project-relative** dirs (`.claude/skills/`, `.omp/skills`, `.agent/skills`, …), so this file
 is copied into each participating repo. Edit the canonical copy, then re-copy.*
+
+*A short pointer also lives in `~/.omp/agent/AGENTS.md` — omp's global instruction file, loaded
+in every session in every directory (empirically the only user-level path omp reads: `~/.agent`,
+`~/.agents`, `~/.codex`, `~/.config/opencode`, `~/.omp`, and `~/AGENTS.md` were all ignored).
+Keep it a **pointer**: the protocol lives here, and that file is charged to the context window of
+every omp session, including ones with nothing to do with agentdox.*

package/.mcp.json

@@ -4,7 +4,7 @@
       "type": "http",
       "url": "http://localhost:3003/mcp",
       "headers": {
-        "Authorization": "Bearer ${AGENTDOX_OMP_TOKEN}"
+        "Authorization": "Bearer ${AGENTDOX_TOKEN}"
       }
     }
   }

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

package/CLAUDE.md

@@ -13,17 +13,20 @@ It presents one keyless OpenAI-compatible provider and picks a concrete OpenRout
 
 agentdox is this repo's memory + docs + live-conversation system. The project slug is
 **`omp-router`** — ALWAYS scope agentdox writes to it. The HTTP MCP server in `.mcp.json`
-uses **`AGENTDOX_OMP_TOKEN`** (a bearer token with admin on the `omp-router` scope only).
+uses **`AGENTDOX_TOKEN`**, one **global** bearer token shared by every agentdox-wired repo.
+The scope comes from *this folder* (`AGENTDOX_SCOPE` in `.env.agentdox`), not from the token:
+the token grants every scope, so a wrong slug is **not** rejected — it silently writes into
+another project. Getting `omp-router` right is on you, not on RBAC.
 
 **Where the credentials live:**
 
 | What | Where |
 | --- | --- |
 | Token + URL + scope | `.env.agentdox` in this repo root (**gitignored** via `.env.*` — never commit) |
-| What `.mcp.json` reads | the `AGENTDOX_OMP_TOKEN` **environment variable**, not the file |
-| Persisted env value | Windows **User** environment (`[Environment]::GetEnvironmentVariable('AGENTDOX_OMP_TOKEN','User')`) |
+| What `.mcp.json` reads | the `AGENTDOX_TOKEN` **environment variable**, not the file |
+| Persisted env value | Windows **User** environment (`[Environment]::GetEnvironmentVariable('AGENTDOX_TOKEN','User')`) |
 | Server | `http://localhost:3003` — Docker container `agentdox-server` |
-| Admin token (to re-mint scoped PATs) | `E:/projects/agentdox/deploy/.env` |
+| Admin token (to re-mint the global PAT) | `E:/projects/agentdox/deploy/.env` |
 
 `.env.agentdox` is the durable record; the environment variable is what Claude Code actually
 substitutes into `.mcp.json` at MCP-server startup. If agentdox MCP returns **401**, the
@@ -60,7 +63,7 @@ served from this repo's `.mcp.json`.
 headers. It mounts them **prefixed**: `agentdox_memory_add`, `agentdox_context_assemble`, …
 (fully qualified `mcp__agentdox_*`). All 17 tools load.
 
-The one prerequisite is `AGENTDOX_OMP_TOKEN` being present in the **launching shell's**
+The one prerequisite is `AGENTDOX_TOKEN` being present in the **launching shell's**
 environment. It is persisted at Windows *User* scope, so only shells started afterwards
 inherit it — an already-open terminal will show no agentdox tools until restarted.
 
@@ -69,7 +72,7 @@ inherited) MUST use the REST API directly** — same live store, same RBAC. Don'
 just because the MCP tools are absent.
 
 REST basics: base `http://localhost:3003`, header `Authorization: Bearer <token>` where the token
-is `AGENTDOX_TOKEN` from `.env.agentdox` (admin on the `omp-router` scope). **memory uses
+is `AGENTDOX_TOKEN` from `.env.agentdox` (global; grants every scope). **memory uses
 `category`, everything else uses `scope`; both are always `"omp-router"`.** MCP-tool → REST map:
 
 | Duty / MCP tool | REST |
@@ -111,7 +114,7 @@ Turning the bridge on for the router itself (distinct from the MCP wiring above)
 
 ```bash
 export AGENTDOX_URL=http://localhost:3003
-export AGENTDOX_TOKEN=<same PAT as AGENTDOX_OMP_TOKEN>
+export AGENTDOX_TOKEN=<the global PAT, same value .mcp.json uses>
 export AGENTDOX_SCOPE=omp-router
 ```
 

package/package.json

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

package/src/config/defaults.ts

@@ -161,6 +161,15 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// faster than the server reassembles buys nothing but cache misses.
 		maxStalenessMs: 900_000,
 		maxBlockChars: 24_000,
+		// Bound what agentdox SELECTS, rather than letting the block grow and then
+		// slicing it at `maxBlockChars`. Byte truncation cuts an entry mid-sentence
+		// and is blind to relevance; a limit lets the server rank first. Left
+		// unbounded, this scope reached 15 memory entries = 23.5k chars (~5.9k
+		// tokens) injected into every turn, against a 24k cap it was about to hit.
+		memoryLimit: 8,
+		// Session messages are cheap today but grow once recordTurns is on, and
+		// they feed straight back into the next assembly.
+		sessionLimit: 6,
 		recordTurns: true,
 		maxQueue: 64,
 	},

package/src/config/schema.ts

@@ -138,6 +138,8 @@ const context = z.strictObject({
 	timeoutMs: z.number().int().positive().optional(),
 	maxStalenessMs: z.number().int().nonnegative().optional(),
 	maxBlockChars: z.number().int().positive().optional(),
+	memoryLimit: z.number().int().positive().optional(),
+	sessionLimit: z.number().int().nonnegative().optional(),
 	recordTurns: z.boolean().optional(),
 	maxQueue: z.number().int().positive().optional(),
 });

package/src/config/types.ts

@@ -372,6 +372,10 @@ export interface ContextConfig {
 	maxStalenessMs: number;
 	/** Hard cap on injected block size, characters. */
 	maxBlockChars: number;
+	/** Max memory entries agentdox may select for the block. */
+	memoryLimit: number;
+	/** Max recent session messages agentdox may select for the block. */
+	sessionLimit: number;
 	/** Write settled turns back to agentdox sessions, tagged with the served model. */
 	recordTurns: boolean;
 	/** Bound on queued write-backs; excess turns are dropped, never buffered unbounded. */

package/src/context/agentdox.ts

@@ -15,13 +15,19 @@ export interface AgentDoxClientOptions {
 	log: Logger;
 }
 
+/** Bounds on what agentdox may select for one block. */
+export interface AssembleLimits {
+	memoryLimit: number;
+	sessionLimit: number;
+}
+
 export interface AgentDoxClient {
 	/**
 	 * Assembles a context slice for `scope`, biased by `query`. Falls back to
 	 * the server's pre-assembled baseline when assembly is unavailable (older
 	 * server, or no query-relevant content).
 	 */
-	assemble(scope: string, query: string): Promise<string | null>;
+	assemble(scope: string, query: string, limits: AssembleLimits): Promise<string | null>;
 	createSession(scope: string, title: string): Promise<string | null>;
 	append(sessionId: string, role: "user" | "assistant", content: string, refs: string[]): Promise<boolean>;
 }
@@ -75,8 +81,15 @@ export function createAgentDoxClient(opts: AgentDoxClientOptions): AgentDoxClien
 	};
 
 	return {
-		async assemble(scope, query) {
-			const res = await request("POST", "/context/assemble", { scope, query });
+		async assemble(scope, query, limits) {
+			// camelCase: the REST endpoint ignores snake_case limit keys entirely,
+			// which silently reads as "unbounded".
+			const res = await request("POST", "/context/assemble", {
+				scope,
+				query,
+				memoryLimit: limits.memoryLimit,
+				sessionLimit: limits.sessionLimit,
+			});
 			if (res !== null && res.status === 200) {
 				const prompt = promptOf(res.json);
 				if (prompt !== null) return prompt;

package/src/context/bridge.ts

@@ -30,6 +30,13 @@ export interface BridgeOptions {
 	maxStalenessMs: number;
 	/** Hard cap on injected block size; a runaway context must not dominate the prompt. */
 	maxBlockChars: number;
+	/**
+	 * Bounds on what agentdox SELECTS. Preferred over `maxBlockChars`, which can
+	 * only slice bytes: the server ranks by relevance, so a limit drops the least
+	 * useful entry instead of severing whatever straddles the cap.
+	 */
+	memoryLimit: number;
+	sessionLimit: number;
 	/** Record settled turns back into agentdox sessions. */
 	recordTurns: boolean;
 	/** Bound on queued write-backs; excess is dropped rather than grown unbounded. */
@@ -73,7 +80,7 @@ function appendFragment(prior: string, next: string): string {
 }
 
 export function createContextBridge(opts: BridgeOptions): ContextBridge {
-	const { client, store, log, maxStalenessMs, maxBlockChars, recordTurns, maxQueue } = opts;
+	const { client, store, log, maxStalenessMs, maxBlockChars, memoryLimit, sessionLimit, recordTurns, maxQueue } = opts;
 
 	// Serialized write-back queue. Session appends for one conversation must
 	// stay ordered, and agentdox is a local service — one worker is plenty.
@@ -111,7 +118,7 @@ export function createContextBridge(opts: BridgeOptions): ContextBridge {
 				return { ...pinned, fetchedAtMs: input.pinnedFetchedAtMs };
 			}
 
-			const raw = await client.assemble(input.scope, input.query);
+			const raw = await client.assemble(input.scope, input.query, { memoryLimit, sessionLimit });
 			if (raw === null) {
 				// agentdox unreachable or empty. Keep serving the pinned block if we
 				// have one: stale shared context beats none, and re-using it also

package/src/context/index.ts

@@ -27,6 +27,8 @@ export function createBridgeFromConfig(cfg: RouterConfig, db: Database): Context
 		log,
 		maxStalenessMs: c.maxStalenessMs,
 		maxBlockChars: c.maxBlockChars,
+		memoryLimit: c.memoryLimit,
+		sessionLimit: c.sessionLimit,
 		recordTurns: c.recordTurns,
 		maxQueue: c.maxQueue,
 	});

package/src/router/classify.ts

@@ -49,19 +49,27 @@ const CAP_LOOP_DEPTH = -0.06;
 // the agent keeps grinding without human input. Unlike the mechanical-step
 // penalty above, this term ACCUMULATES with depth past the agentic threshold so
 // long loops climb out of trivial. The ramp slope is calibrated on recorded
-// coding turns; the cap governs the ceiling. `moderate` is NOT enough to break a
-// distinct-read loop: on the coding axis the cheapest model above the moderate
-// floor (deepseek-v4-flash, coding 69.1) also clears it after the latency
-// penalty, so escalating to moderate never swaps the weak model off — live
-// evidence (conv 888e5bddc1) is a loop grinding to depth 27+ on it. Only `hard`
-// (floor 72) excludes that model and forces a materially stronger, faster one.
-// So the cap lets a RUNAWAY loop (~depth 38 of pure continuations, no other
-// signal) reach `hard`; the calibrated mid-range still tops out in `moderate`,
-// and any corroborating stuck signal (circular call, tool failure, keywords)
-// reaches `hard` far sooner.
+// coding turns; the cap governs the ceiling.
+//
+// The cap was briefly 0.70, which let pure depth reach `hard`. That was aimed at
+// a real problem — a distinct-read loop grinding at depth 27+ on
+// deepseek-v4-flash (coding 69.1), which clears the moderate floor, so escalating
+// to moderate swapped nothing. But it overcorrected: on live data 152 of 155
+// `hard` dispatches were depth-driven and carried 63.5% of ALL spend, and those
+// same rows also carry the `-0.28 tool-result continuation (mechanical)` term —
+// the classifier already knew the work was mechanical and the depth bonus
+// overrode it. `hard` (floor 72, no price ceiling) forces gemini-3.7-flash at
+// roughly 8x the cost of the model moderate picks.
+//
+// The original grinding failure is now covered independently: windowed latency
+// scoring inflates a chronically slow model's effective cost, and it removed
+// deepseek-v4-flash from selection entirely. So depth alone tops out at
+// `moderate` again, and `hard` stays reachable via a CORROBORATING stuck signal
+// (circular call, tool failure, keywords) — which is what should buy a $2/Mtok
+// model, not depth by itself.
 const W_AUTONOMOUS_LOOP = 0.06; // base bonus at the threshold
 const W_AUTONOMOUS_LOOP_PER_DEPTH = 0.018; // added per loop step beyond the threshold
-const CAP_AUTONOMOUS_LOOP = 0.7; // pure depth ramps through moderate into hard for a runaway loop
+const CAP_AUTONOMOUS_LOOP = 0.45; // pure depth ramps into moderate, never alone into hard
 const W_IMAGES = 0.04;
 const W_TOOLS_OFFERED = 0.03;
 

package/test/classify.test.ts

@@ -213,16 +213,24 @@ describe("scoreHeuristic", () => {
 		}
 	});
 
-	test("pure loop depth ramps to moderate in the mid-range and hard only when runaway", () => {
+	test("pure loop depth never reaches hard on its own, however runaway", () => {
 		// A sustained-but-not-runaway loop tops out in moderate: the calibrated
 		// ramp ceiling for ordinary deep work.
 		const midRange = scoreHeuristic(contFeatures(30), BASE);
 		expect(midRange.tier).toBe("moderate");
-		// A runaway loop of pure continuations (no other signal) must reach hard.
-		// moderate never swaps the cheapest coding model off — it clears the 60
-		// floor even after the latency penalty — so only hard's 72 floor breaks it.
+		// And so does a runaway one. This reverses an earlier cap of 0.70 that let
+		// raw depth buy `hard`: on live data 152 of 155 hard dispatches were
+		// depth-driven and carried 63.5% of ALL spend, while those same rows also
+		// scored the mechanical tool-result-continuation penalty. `hard` has no
+		// price ceiling, so depth alone was buying a ~8x model for work the
+		// classifier already knew was mechanical. Depth is a weak signal of
+		// DIFFICULTY; hard must be bought by a corroborating stuck signal (see the
+		// circular-tool-call test below), which is the case that actually needs a
+		// stronger model.
 		const runaway = scoreHeuristic(contFeatures(90), BASE);
-		expect(runaway.tier).toBe("hard");
+		expect(runaway.tier).toBe("moderate");
+		// The ceiling must still be a real ceiling, not an accident of the ramp.
+		expect(scoreHeuristic(contFeatures(400), BASE).tier).toBe("moderate");
 	});
 
 	test("a circular tool call on a deep loop escalates to hard", () => {

package/test/context-bridge.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import type { AgentDoxClient } from "../src/context/agentdox.ts";
+import type { AgentDoxClient, AssembleLimits } from "../src/context/agentdox.ts";
 import { createContextBridge } from "../src/context/bridge.ts";
 import { createContextStore } from "../src/context/store.ts";
 import type { ContextResolveInput, TurnRecord } from "../src/context/types.ts";
@@ -15,16 +15,19 @@ interface FakeClient extends AgentDoxClient {
 	appended: { sessionId: string; role: string; content: string; refs: string[] }[];
 	sessionsCreated: number;
 	prompt: string;
+	lastLimits: AssembleLimits | null;
 }
 
 function mkClient(prompt = "MEMORY: player digs in 3/4 top-down"): FakeClient {
 	const c: FakeClient = {
 		assembleCalls: 0,
+		lastLimits: null,
 		appended: [],
 		sessionsCreated: 0,
 		prompt,
-		async assemble() {
+		async assemble(_scope, _query, limits) {
 			c.assembleCalls++;
+			c.lastLimits = limits;
 			return c.prompt;
 		},
 		async createSession() {
@@ -49,6 +52,8 @@ function mkBridge(client: AgentDoxClient, over: Partial<BridgeOpts> = {}) {
 		log,
 		maxStalenessMs: 900_000,
 		maxBlockChars: 24_000,
+		memoryLimit: 8,
+		sessionLimit: 6,
 		recordTurns: true,
 		maxQueue: 64,
 		...over,
@@ -89,6 +94,22 @@ describe("context bridge refresh policy", () => {
 		}
 	});
 
+	test("assembly is bounded, so the block cannot grow until bytes get severed", async () => {
+		// The block reached 23.5k chars (~5.9k tokens, 15 memory entries) against a
+		// 24k maxBlockChars cap, at which point renderBlock slices mid-entry. Byte
+		// truncation is blind to relevance, so the server must be told to rank and
+		// select instead. The REST endpoint ignores snake_case limit keys, which
+		// silently reads as unbounded — hence pinning that the limits are passed.
+		const client = mkClient();
+		const { bridge, db } = mkBridge(client, { memoryLimit: 5, sessionLimit: 2 });
+		try {
+			await bridge.resolve(input());
+			expect(client.lastLimits).toEqual({ memoryLimit: 5, sessionLimit: 2 });
+		} finally {
+			db.close();
+		}
+	});
+
 	test("refreshes when the model switches, because the cache is already forfeit", async () => {
 		const client = mkClient();
 		const { bridge, db } = mkBridge(client);
@@ -217,6 +238,8 @@ describe("context bridge refresh policy", () => {
 				log,
 				maxStalenessMs: 900_000,
 				maxBlockChars: 24_000,
+				memoryLimit: 8,
+				sessionLimit: 6,
 				recordTurns: true,
 				maxQueue: 64,
 			};

package/test/failover.test.ts

@@ -69,7 +69,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		hysteresis: { holdTurns: 2, holdTurnsAfterEscalation: 4, switchMargin: 1.5, cacheWarmTtlMs: 600_000, maxDowngradePerTurn: 1 },
 		exploration: { enabled: false, rates: {}, stickyPolicy: "never", holdTurns: { enabled: false, values: [2, 3, 4] } },
 		cache: { injectBreakpoints: true, maxBreakpoints: 4, minPromptTokens: 1024, milestoneTokens: 20_000 },
-		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, recordTurns: false, maxQueue: 64 },
+		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, memoryLimit: 8, sessionLimit: 6, recordTurns: false, maxQueue: 64 },
 		compaction: { enabled: false, budgetTokens: 40_000, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true },
 		budget: { onExceeded: "downgrade" },
 		profiles: [],

package/test/turn.test.ts

@@ -70,7 +70,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		hysteresis: { holdTurns: 2, holdTurnsAfterEscalation: 4, switchMargin: 1.5, cacheWarmTtlMs: 600_000, maxDowngradePerTurn: 1 },
 		exploration: { enabled: false, rates: {}, stickyPolicy: "never", holdTurns: { enabled: false, values: [2, 3, 4] } },
 		cache: { injectBreakpoints: true, maxBreakpoints: 4, minPromptTokens: 1024, milestoneTokens: 20_000 },
-		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, recordTurns: false, maxQueue: 64 },
+		context: { enabled: false, baseUrl: "", token: "", defaultScope: "", timeoutMs: 3_000, maxStalenessMs: 900_000, maxBlockChars: 24_000, memoryLimit: 8, sessionLimit: 6, recordTurns: false, maxQueue: 64 },
 		compaction: { enabled: false, budgetTokens: 40_000, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true },
 		budget: { onExceeded: "downgrade" },
 		profiles: [],