auto-model-router 0.2.2 → 0.2.7

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

@@ -0,0 +1,143 @@
+---
+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."
+---
+
+# agentdox — the standard interaction protocol
+
+agentdox is a shared memory + docs + conversation store at `http://localhost:3003`. It is what
+stops you rediscovering the same project facts every session.
+
+**Follow this protocol identically every time.** Consistency is the point: the value of the
+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:
+
+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
+
+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.
+
+## 1. Pick your transport — MCP or REST
+
+Both hit the same live store with the same RBAC. **Check which you have, then use it:**
+
+- **MCP tools present** — use them. Claude Code and Cursor mount them as `memory_add`,
+  `context_assemble`, …; **omp mounts them prefixed**, e.g. `agentdox_memory_add`,
+  `agentdox_context_assemble`. omp reads `.mcp.json` (repo root), `.omp/mcp.json`,
+  `.claude/mcp.json`, and `~/.omp/agent/mcp.json`, and it **does** expand `${VAR}` in headers.
+- **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
+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`.
+
+Cleanest REST call path — a throwaway `bun` script, which avoids PowerShell mangling `$` in
+inline JSON and avoids quoting pain in `curl`:
+
+```ts
+const tok = /AGENTDOX_TOKEN=(.+)/.exec(await Bun.file(".env.agentdox").text())?.[1]?.trim() ?? "";
+const H = { Authorization: `Bearer ${tok}`, "content-type": "application/json" };
+await fetch("http://localhost:3003/memory", { method: "POST", headers: H,
+  body: JSON.stringify({ content: "…", category: "<scope>", importance: 0.9 }) });
+```
+
+## 2. On connect (every session, before other work)
+
+| Step | MCP | REST |
+| --- | --- | --- |
+| Ensure the project | `project_ensure {slug, name}` | `POST /projects {slug,name}` (idempotent) |
+| Read the brief | `context_brief {scope}` | `GET /context/brief?scope=<scope>` |
+
+The brief is the cumulative on-ramp: overview, repo layout, code style, build/test,
+conventions, gotchas, decision log. **Read it before exploring the repo** — it exists so you
+don't rediscover what a previous session already established.
+
+`404 no_brief` means none exists yet: seed it once with `context_brief_seed {scope}` /
+`POST /context/brief/seed {scope}`.
+
+## 3. Before asking the user anything
+
+| MCP | REST |
+| --- | --- |
+| `context_assemble {scope, query}` | `POST /context/assemble {scope, query}` |
+
+Returns relevant memory + docs + recent conversation as one block. **Consult it before
+re-asking the user about anything that might already be recorded.** Re-asking a question the
+store already answers is the specific failure this system exists to prevent.
+
+## 4. During work — append the session in real time
+
+| MCP | REST |
+| --- | --- |
+| `session_start {scope, title}` | `POST /sessions {scope, title}` → returns `id` |
+| `session_append {session_id, role, content}` | `POST /sessions/:id/messages {role, content, refs?}` |
+| — | `POST /sessions/:id/end` when the topic closes |
+
+Append **as the conversation happens**, not as one summary at the end. Live history is what
+context assembly draws on for the next session.
+
+## 5. Before finishing any task (mandatory)
+
+Updating agentdox is part of completing a task, not an optional extra. Do not close out a task
+while memory, docs, or the brief for the area you touched is stale.
+
+| What changed | MCP | REST |
+| --- | --- | --- |
+| A fact you already stored | `memory_update {id, …}` | `PATCH /memory/:id {content?, importance?}` |
+| A new durable fact | `memory_add {content, category, importance}` | `POST /memory {content, category, importance}` |
+| Find what exists first | `memory_search {query, category}` | `GET /memory/search?q=…&category=<scope>` · `GET /memory?category=<scope>` |
+| Architecture / conventions | `docs_update {id, content}` | `PATCH /docs/:id {title?, content?, tags?}` |
+| A genuinely new doc | `docs_write {slug, title, content, scope}` | `POST /docs {slug, title, content, scope}` |
+| List / read docs | `docs_read` · `docs_search` | `GET /docs?scope=<scope>` · `GET /docs/search?q=…` · `GET /docs/slug/:slug` |
+| A decision you made | `context_brief_record {scope, title, decision, rationale}` | `POST /context/brief/decision {scope, title, decision, rationale}` |
+| Edit brief sections | — | `PUT /context/brief {scope, overview?, repoLayout?, codeStyle?, buildTest?, assetConventions?, gotchas?}` |
+
+**Search before you add.** Update the existing entry rather than leaving two contradictory
+facts. Record the *why* of a decision, not just the *what*.
+
+## Two inconsistencies that cause silent mistakes
+
+1. **Memory uses `category`; everything else uses `scope`.** `memory_add` / `memory_search` /
+   `memory_update` (and `POST /memory`, `GET /memory`) take `category`. Passing `scope` to a
+   memory call leaves the entry unscoped, where nothing will ever find it again. `category`
+   **is** the scope — set it every time.
+2. **`session_append` uses `session_id`** (snake_case), and `context_assemble` uses
+   `memory_limit` / `docs_limit` / `session_limit`. Everything else uses plain names.
+
+## Writing good entries
+
+- **Memory is high-signal and compact.** One fact per entry. Prefer editing an existing entry
+  over piling on near-duplicates. Set `importance` deliberately: 0.9+ for things that change
+  how work is done, 0.5 for ordinary context.
+- **Do not store what the repo already records.** Code structure, file listings, and git
+  history are discoverable. Store what is *not* in the code: why a decision was made, a user
+  preference, a constraint, a gotcha that cost time.
+- **Docs are versioned** (`GET /docs/:id/history`), so update freely rather than hedging.
+
+## 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.
+- **Connection refused** → the `agentdox-server` Docker container is not running.
+
+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.*

package/.mcp.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "agentdox": {
+      "type": "http",
+      "url": "http://localhost:3003/mcp",
+      "headers": {
+        "Authorization": "Bearer ${AGENTDOX_OMP_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.2",
+    "version": "0.2.7",
     "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.2",
+      "version": "0.2.7",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/CLAUDE.md

@@ -0,0 +1,129 @@
+# auto-model-router — project memory & conventions
+
+`auto-model-router` is a local, cost/complexity-aware model router for [Oh My Pi](https://github.com/oh-my-pi).
+It presents one keyless OpenAI-compatible provider and picks a concrete OpenRouter model
+**per turn**. This file is loaded by coding agents (Claude Code, Cursor) as project memory.
+
+> **Repo identity:** this directory (`E:/projects/omp-router`) is the **main** repo.
+> `E:/projects/auto-model-router-research` is a *separate divergent checkout* kept for other
+> feature work — do not edit it expecting changes here. omp's `~/.omp/agent/config.yml`
+> `extensions:` list points at **this** repo.
+
+## agentdox — shared context/memory (**MANDATORY to keep updated**)
+
+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).
+
+**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')`) |
+| Server | `http://localhost:3003` — Docker container `agentdox-server` |
+| Admin token (to re-mint scoped PATs) | `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
+variable is missing from the environment — re-set it from `.env.agentdox` and restart Claude
+Code (substitution happens once, at startup). Re-mint instructions are in `.env.agentdox`.
+
+**Requirement: keeping agentdox current is part of completing any task, not optional.**
+Do NOT close out a task while memory, docs, or conversation history for the area you touched
+is stale or incomplete.
+
+Concrete duties (all scoped to `omp-router`):
+
+- **On connect:** run `project_ensure` with `slug: "omp-router"` before any memory/docs work.
+- **On startup:** read `context_brief` to onboard on decisions, conventions, and gotchas
+  before rediscovering them.
+- **Memory** (`memory_add` / `memory_update` / `memory_search`): record user-stated
+  preferences and corrections. When a fact changes, UPDATE the existing entry — never leave
+  contradictory facts. Keep entries compact and high-signal.
+- **Docs** (`docs_write` / `docs_update`): keep architecture and decisions current as reality
+  changes; writing once is not enough.
+- **Sessions** (`session_start` / `session_append`): append messages in real time, not as an
+  end-of-task summary.
+- **Context** (`context_assemble`): consult it (with a query) before re-asking the user about
+  anything already captured.
+- **Decisions** (`context_brief_record`): record decisions and conventions as they are made.
+
+### How to actually call it (MCP tools vs REST)
+
+The duties above name the **MCP tools** (`memory_add`, `docs_write`, `context_brief_record`, …),
+served from this repo's `.mcp.json`.
+
+**omp gets these tools too** — verified 2026-08-28. omp reads `.mcp.json` (repo root),
+`.omp/mcp.json`, `.claude/mcp.json`, and `~/.omp/agent/mcp.json`, and it expands `${VAR}` in
+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**
+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.
+
+**A harness genuinely without those tools (e.g. Hermes, or omp before the env var is
+inherited) MUST use the REST API directly** — same live store, same RBAC. Don't skip recording
+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
+`category`, everything else uses `scope`; both are always `"omp-router"`.** MCP-tool → REST map:
+
+| Duty / MCP tool | REST |
+| --- | --- |
+| `project_ensure` | `POST /projects` `{slug,name}` (idempotent; re-ensure returns the project) |
+| `memory_search` | `GET /memory?category=omp-router&limit=N` · `GET /memory/search?q=…&category=omp-router` |
+| `memory_add` | `POST /memory` `{content, category:"omp-router", importance:0..1}` |
+| `memory_update` | `PATCH /memory/:id` `{content?, importance?, …}` (edit in place — never pile on dupes) |
+| `docs_write` | `POST /docs` `{slug, title, content, scope:"omp-router", tags?}` |
+| `docs_update` | `PATCH /docs/:id` `{title?, content?, tags?}` · list `GET /docs?scope=omp-router` |
+| read `context_brief` | `GET /context/brief?scope=omp-router` (404 `no_brief` until seeded) |
+| seed the brief | `PUT /context/brief` `{scope, overview?, repoLayout?, codeStyle?, buildTest?, assetConventions?, gotchas?}` |
+| `context_brief_record` | `POST /context/brief/decision` `{scope, title, decision, rationale}` |
+| `context_assemble` | `POST /context/assemble` `{scope, query}` · baseline `GET /context/snapshot?scope=` · `POST /context/refresh` `{scope}` |
+| `session_start` / `session_append` | `POST /sessions` `{scope, title}` → `POST /sessions/:id/messages` `{role, content, refs?}` → `POST /sessions/:id/end` |
+
+Cleanest call path (avoids Windows PowerShell mangling `$` in inline JSON): a throwaway
+`bun` script that reads the token and `fetch`es —
+
+```ts
+const tok = /AGENTDOX_TOKEN=(.+)/.exec(await Bun.file(".env.agentdox").text())?.[1]?.trim() ?? "";
+const H = { Authorization: `Bearer ${tok}`, "content-type": "application/json" };
+await fetch("http://localhost:3003/memory", { method: "POST", headers: H,
+  body: JSON.stringify({ content: "…", category: "omp-router", importance: 0.9 }) });
+```
+
+Endpoints are defined in `E:/projects/agentdox/packages/server/src/index.ts`; the router's own
+read/write client is `src/context/agentdox.ts` (assemble / createSession / append only).
+
+## This repo also *implements* an agentdox client
+
+Beyond consuming agentdox as an agent, `src/context/` is the **router↔agentdox bridge**: it
+injects shared project context into every routed turn and records turns back, attributed to
+the model that served them. See `docs/AGENTDOX-BRIDGE.md` for the current state, how to run
+it, and the open issue. Design rationale lives in
+`E:/projects/agentdox/docs/architecture/router-context-bridge.md`.
+
+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_SCOPE=omp-router
+```
+
+A URL + token is enough to enable it; `GET /health` on the router confirms.
+
+## Conventions
+
+- **Bun + TypeScript**, `exactOptionalPropertyTypes: true`. Use `...(x === undefined ? {} : { x })`
+  rather than assigning `undefined` to an optional property.
+- **`src/util/sqlite.ts` is the ONLY migration path.** New tables go in the idempotent
+  `MIGRATIONS` block; column additions get a `MIGRATE_Vn` const plus a `PRAGMA table_info`
+  guard, and `USER_VERSION` is bumped. `test/trust-attribution.test.ts` asserts the version.
+- **bun:sqlite named params must be written `$name`** in the bind object. Bare keys bind
+  nothing and every column silently lands NULL.
+- Verify with `bunx tsc --noEmit` and `bun test` (406+ tests) before declaring done.

package/README.md

@@ -566,6 +566,70 @@ harness's reliability from only its own ledger rows.
 
 ---
 
+## Shared project context across model switches (agentdox)
+
+Switching models mid-conversation loses more than a prompt cache: the new model
+has none of the project knowledge the last one built up. Because every harness
+routes through this one provider, the router is the single place that can fix
+that for all of them at once.
+
+Point it at an [agentdox](https://github.com/…/agentdox) server and every turn —
+whatever model wins the routing decision — carries the same project memory, docs,
+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
+```
+
+Setting a URL and a token is enough to turn it on.
+
+### 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
+would invalidate the cached prefix every turn — costing far more than routing
+saves. Instead a block is **pinned per conversation** and refreshed only when the
+prefix is already cold:
+
+| Trigger | Cache cost |
+| --- | --- |
+| First turn of a conversation | none — nothing is warm yet |
+| The router switches model | none — already forfeited by the switch |
+| Escalation or failover retry | none — a new dispatch is cold anyway |
+| Staleness TTL (`context.maxStalenessMs`, default 900s) | paid once |
+
+Between those moments the identical bytes are re-injected and the cache holds.
+The refresh rides on a cache miss that was happening regardless — which is why
+"context follows the model switch" is nearly free.
+
+A block is versioned by **content hash**, not by agentdox's `assembledAt`.
+agentdox re-assembles on a timer, so a timestamp would change on every tick and
+break a warm cache for nothing; an unchanged re-assembly hashes identically and
+costs nothing.
+
+The block is appended to the **last system message** rather than inserted as a
+new one, so the cache-breakpoint indices the core computed stay valid and the
+block lands inside the prefix `planCacheBreakpoints` already marks.
+
+### Turns are recorded back, attributed to the model that served them
+
+With `context.recordTurns` (default on), each settled turn is written to an
+agentdox session tagged `model:<slug>` and `tier:<tier>` — a transcript that
+shows which model produced which turn. Those messages feed back into the next
+`context_assemble`, so the model you switch *to* inherits what the model you
+switched *from* actually did.
+
+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.
+
+`GET /health` reports the bridge's URL, default scope, and `recordTurns` — never
+the token. Design notes: `docs/architecture/router-context-bridge.md` in the
+agentdox repo. Live check: `bun tools/agentdox-e2e.ts`.
+
+---
+
 ## Toast notifications for the chosen model
 
 auto-model-router is headless and cannot draw into omp's TUI, so chosen-model toasts

package/docs/AGENTDOX-BRIDGE.md

@@ -0,0 +1,132 @@
+# agentdox bridge — handoff
+
+**Status:** implemented, typechecks clean, 409 tests pass, injection verified end-to-end
+through omp. **One open bug** in the write-back path (§5). Pick up there.
+
+Design rationale (why it is built this way):
+`E:/projects/agentdox/docs/architecture/router-context-bridge.md`.
+
+---
+
+## 1. What it does
+
+The router is the only choke point that sees every model in every harness. The bridge
+injects an agentdox project-context block into every routed turn, so switching models never
+loses project memory/docs/brief — and records each settled turn back to agentdox, attributed
+to the model that served it.
+
+The load-bearing constraint is the prompt cache: a block that changes per turn sits at the
+front of the prefix and would make every turn a full cache miss. So a block is **pinned per
+conversation** and refreshed only when the prefix is already cold (first turn, model switch,
+retry, or staleness TTL). Version is a **content hash**, not agentdox's `assembledAt`, so an
+unchanged re-assembly keeps the same bytes and the cache survives.
+
+## 2. Where the code is
+
+| Path | Role |
+| --- | --- |
+| `src/context/types.ts` | Contracts (`ContextBridge`, `ContextPin`, `TurnRecord`) |
+| `src/context/agentdox.ts` | REST client. Total: every method returns a value or null, never throws |
+| `src/context/bridge.ts` | **The refresh policy.** `shouldRefresh` is the heart of it |
+| `src/context/store.ts` | `context_blocks` (content-addressed) + `agentdox_sessions` |
+| `src/context/index.ts` | `createBridgeFromConfig` — returns an inert bridge when unconfigured |
+| `src/server/turn.ts` | Resolve → inject → pin → record. Two `log.debug("agentdox …")` lines |
+| `src/wire/openai/request.ts` | `injectContextBlock` + `x-agentdox-scope` header parsing |
+| `src/util/sqlite.ts` | `USER_VERSION` 11, `MIGRATE_V11` |
+| `test/context-bridge.test.ts` | 14 tests: every refresh trigger, restart survival, degradation |
+| `tools/agentdox-e2e.ts` | Live check against a running agentdox server |
+
+Injection appends to the **last system message** rather than inserting one — inserting would
+shift every `cacheBreakpointMessageIndices` entry the core computed, and appending lands the
+block inside the prefix `planCacheBreakpoints` already marks.
+
+## 3. Running it
+
+```bash
+export AGENTDOX_URL=http://localhost:3003
+export AGENTDOX_TOKEN=<PAT with write on the scope>   # see .env.agentdox
+export AGENTDOX_SCOPE=omp-router
+bun src/index.ts serve --port 8799        # standalone
+curl -s http://127.0.0.1:8799/health      # confirms the bridge block
+bun tools/agentdox-e2e.ts                 # live end-to-end
+```
+
+`AUTO_MODEL_ROUTER_LOG=debug` surfaces two lines per turn:
+
+```
+DEBUG agentdox context active=true scope=omp-router injected=true chars=1683
+DEBUG agentdox record turn userChars=109 assistantChars=4 messages=2 roles=system,user
+```
+
+Use `AUTO_MODEL_ROUTER_DB=<scratch>.db` to avoid touching the live `~/.auto-model-router/router.db`.
+
+## 4. Testing through omp — the gotcha that cost an hour
+
+`omp -p` (headless) **never binds its own router**. Per `omp-extension/router-embed.ts`, only
+a session with `ctx.hasUI` binds; headless sessions read `$AUTO_MODEL_ROUTER_HOME/embed.port`
+and register the provider against whatever port is in that file. So a headless run silently
+routes to whatever router is already running — including a stale one with old code.
+
+To test *your* build through omp:
+
+```bash
+cp ~/.auto-model-router/embed.port ~/.auto-model-router/embed.port.bak
+printf '8799' > ~/.auto-model-router/embed.port     # point at your standalone router
+AGENTDOX_URL=… AGENTDOX_TOKEN=… AGENTDOX_SCOPE=omp-router \
+  omp -p --no-tools --no-session "…"
+cp ~/.auto-model-router/embed.port.bak ~/.auto-model-router/embed.port   # restore
+```
+
+Two more traps hit during this work:
+
+- `pkill -f "src/index.ts serve"` does **not** work in Git Bash on Windows. The old process
+  keeps the port, the new one prints `Failed to start server. Is port 8799 in use?` to its
+  log, and you spend a while testing stale code. Kill via
+  `Get-NetTCPConnection -LocalPort 8799 -State Listen` → `Stop-Process -Force`.
+- Long-running interactive omp sessions hold their own embedded routers from whenever they
+  started. Check `Get-Process omp` before trusting a result.
+
+## 5. OPEN BUG — assistant text is under-captured on the omp path
+
+**Verified working:** injection reaches the model through omp. The dispatched system message
+was confirmed to contain the block (`containsBlock=true`), and on a direct
+`/v1/chat/completions` dispatch the model answered *from* the injected memory, verbatim:
+
+> "The router pins one agentdox context block per conversation, refreshing it only on model
+> switches, retries, or TTL."
+
+**Broken:** through omp, the recorded assistant turn is near-empty — `assistantChars=4`
+(literally `" high"`) while omp displayed several paragraphs. The session and the model
+attribution (`refs: ["model:…", "tier:…"]`) are written correctly; only the assistant
+*content* is wrong.
+
+`assistantText` is accumulated in `src/server/turn.ts` from `ev.type === "text"` deltas
+inside the chunk loop. Leads, roughly in order of suspicion:
+
+1. **omp issues more than one upstream request per visible turn** (e.g. a title/summary call
+   on the `smol` role, which also resolves to `auto` → the router). The 4-char record may be
+   an auxiliary request, with the real answer on a different conversation key. Check by
+   logging `conversationKey` alongside the record line and counting turns per omp invocation.
+2. **Content arrives as `reasoning` deltas, not `text`**, for reasoning-capable models — the
+   accumulator deliberately ignores `reasoning`. If so, decide whether the transcript should
+   capture reasoning (probably not) or whether `text` is arriving under a chunk shape the
+   interpreter is not mapping to a `text` event.
+3. **Escalation resets the buffer.** `assistantText` is declared per attempt; if a turn
+   commits on a later attempt the earlier text is correctly dropped, but verify the committed
+   attempt is the one being recorded.
+
+Start by adding `conversationKey` and `attempt` to the `agentdox record turn` debug line and
+running one omp invocation — that distinguishes lead 1 from the others immediately.
+
+## 6. Also worth doing
+
+- **Context pollution.** `context_assemble` includes recent session messages, so recorded
+  test turns feed back into the next block (already observed: the block contained
+  `assistant:: high` from a prior run). Real usage is fine, but noisy test turns compound.
+  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`.
+- **Four copies of this project exist** on this machine: this repo, the research checkout,
+  `~/.omp/plugins/cache/marketplaces/auto-model-router` (v0.2.1, marketplace cache — not
+  installed, `installed_plugins.json` is empty), and a global npm `auto-model-router@0.2.4`.
+  Confirm which one a given run is exercising before trusting an e2e result.