auto-model-router 0.3.1 → 0.3.3

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

package/CLAUDE.md

@@ -11,108 +11,28 @@ It presents one keyless OpenAI-compatible provider and picks a concrete OpenRout
 
 ## 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_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.
+agentdox is this repo's memory + docs + live-conversation store. The project slug is
+**`omp-router`** — ALWAYS scope agentdox writes to it. The bearer token (`AGENTDOX_TOKEN`)
+is one global PAT that grants every scope, so a wrong slug is **not** rejected: it silently
+files this project's data under another project. Getting `omp-router` right is on you.
 
-**Where the credentials live:**
+**Full protocol: `.claude/skills/agentdox/SKILL.md`** (on connect, before asking the user,
+batching writes to the end of the session, the REST fallback with request shapes, search
+tips). Read it before using agentdox; do not improvise from this summary.
 
 | What | Where |
 | --- | --- |
-| Token + URL + scope | `.env.agentdox` in this repo root (**gitignored** via `.env.*` — never commit) |
-| 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 the global PAT) | `E:/projects/agentdox/deploy/.env` |
-
-**Searching agentdox.** Retrieval is hybrid — BM25 keyword matching fused with embeddings — and
-runs over *passages* of docs, not whole files. So ask in your own words; exact identifiers work
-too. Two habits worth having:
-
-- **Prefer `docs_passages` over `docs_search`.** It returns the section that answers the
-  question. `docs_search` returns whole documents, which then get truncated, and the truncation
-  is rarely the relevant part.
-- **If results look thin, run `index_stats {scope}` before concluding the store is empty.** It
-  reports how much of the scope is indexed and whether the embedding provider is reachable;
-  `embedded` far below `total`, or an unreachable provider, means you are getting keyword-only
-  results.
-
-`.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_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` (global; grants every 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).
+| Token, URL, scope | `.env.agentdox` in this repo root (gitignored — never commit) |
+| What `.mcp.json` reads | the `AGENTDOX_TOKEN` **environment variable** (Windows *User* scope; shells opened before it was set lack it) |
+| Server | `http://localhost:3003` — Docker container `agentdox-server`; endpoints in `E:/projects/agentdox/packages/server/src/index.ts` |
+| Admin token (re-mint) | `E:/projects/agentdox/deploy/.env` |
+
+Two rules that cause silent mistakes: **memory calls take `category`, everything else takes
+`scope`** (both always `"omp-router"`); and a **401 means the env var is missing** from the
+launching shell — re-set it from `.env.agentdox` and restart the harness. omp mounts the
+tools prefixed (`agentdox_memory_add`, …); a harness without them MUST use REST (the skill
+has the map) rather than skip recording. Cleanest REST call path is a throwaway `bun`
+script reading the token from `.env.agentdox`.
 
 ## This repo also *implements* an agentdox client
 

package/README.md

@@ -623,7 +623,7 @@ an OpenRouter sibling). See [Ollama Cloud](#ollama-cloud) below.
 | `usagePollMs` | `600000` (10 min) | How often plan usage is re-read. `0` disables it (static bias). Needs the API key; the daemon path without one keeps a static bias. |
 | `quotaCooldownMs` | `900000` | Route around Ollama this long after a 402 (credits exhausted). |
 | `rateLimitCooldownMs` | `60000` | Route around Ollama this long after a 429 (concurrency cap). |
-| `planCreditsUsd` | `0` | Dollar value of the plan's included monthly credits (Pro 60, Max 300). Lets `/health` and `/router status` show ollama.com's plan reading as dollars next to the ledger's figure. `0` shows the share only. |
+| `planCreditsUsd` | `0` | Override for the plan's included monthly credits. `0` detects the plan from ollama.com (`POST /api/me`) and applies its published allowance (Pro $60, Max $300), so `/health` and `/router status` show ollama.com's reading as dollars next to the ledger's figure. Set it for a plan the router does not know. |
 
 ### `tiers` — per-tier economic envelope
 
@@ -824,8 +824,9 @@ What happens once it is on:
   previous prompt is taken as the cached prefix and priced at the cached
   rate; a first turn, a switch, or a longer gap is priced cold. The ledger
   flags these rows (`usage.cachedEstimated`) and reports show their cache
-  rate as `~N%`. Set `planCreditsUsd` (Pro 60, Max 300) to see ollama.com's
-  own dollar reading in `/router status` as the cross-check.
+  rate as `~N%`. `/router status` shows ollama.com's own dollar reading as
+  the cross-check: the plan is read from `POST /api/me` and its published
+  allowance applied (`planCreditsUsd` overrides it).
 - **Same economics, same failover.** Candidates from both providers are ranked
   together; `costBias` tilts the comparison while a plan's included credits
   would otherwise go unused. **Credit-aware by default:** the router reads the

package/docs/AGENTDOX-BRIDGE.md

@@ -175,8 +175,14 @@ would fix that, at the cost of one credential reaching every project.
   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.
+  more every run. **Done 2026-09-07:** recent sessions ride only on a conversation's FIRST
+  block (`ContextResolveInput.firstFetch`); refreshes ask for `sessionLimit: 0`, since by then
+  the section was this conversation's own turns (1.4-1.9k chars per block, changing every
+  refresh). In the same change the relevance query became `context/query.ts`
+  `relevanceQuery`: the last user message with real content after omp's wrapper elements
+  (`<system-reminder>`, `<recap>`, `<chat>`, image stubs) are stripped, capped at 400 chars —
+  live blocks had been queried with those wrappers verbatim, one header running to 2k chars.
+  Recorded user turns use the same cleaner.
 - **`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,

package/omp-extension/report-logic.ts

@@ -74,8 +74,8 @@ export interface HealthSnapshot {
 		available?: boolean;
 		cooldownUntilMs?: number | null;
 		lastTrip?: { kind?: string; atMs?: number; message?: string } | null;
-		usage?: { monthlyUsedFraction?: number | null; activityCostUsd?: number | null; fetchedAtMs?: number | null } | null;
-		meter?: { usedUsd?: number; creditsUsd?: number } | null;
+		usage?: { monthlyUsedFraction?: number | null; activityCostUsd?: number | null; plan?: string | null; fetchedAtMs?: number | null } | null;
+		meter?: { usedUsd?: number; creditsUsd?: number; plan?: string | null } | null;
 		costBias?: { configured?: number; effective?: number; biasUntilUsage?: number };
 	} | null;
 	catalog?: {
@@ -106,7 +106,8 @@ export function renderStatus(baseUrl: string, h: HealthSnapshot, nowMs = Date.no
 		const avail = o.available === true ? "available" : `COOLING DOWN${o.cooldownUntilMs ? ` until ${new Date(o.cooldownUntilMs).toLocaleTimeString()}` : ""}`;
 		const frac = o.usage?.monthlyUsedFraction;
 		const meter = o.meter !== undefined && o.meter !== null && o.meter.usedUsd !== undefined ? ` ($${o.meter.usedUsd.toFixed(2)} of $${o.meter.creditsUsd ?? "?"})` : "";
-		const usage = frac === undefined || frac === null ? "plan usage unknown" : `plan usage ${(frac * 100).toFixed(1)}%${meter}`;
+		const planName = o.meter?.plan ?? o.usage?.plan ?? null;
+		const usage = frac === undefined || frac === null ? "plan usage unknown" : `${planName === null ? "plan" : `${planName} plan`} usage ${(frac * 100).toFixed(1)}%${meter}`;
 		const bias = o.costBias === undefined ? "" : ` · cost bias ×${o.costBias.effective ?? o.costBias.configured ?? 1} (until ${((o.costBias.biasUntilUsage ?? 1) * 100).toFixed(0)}%)`;
 		const trip = o.lastTrip !== undefined && o.lastTrip !== null ? ` · last trip ${o.lastTrip.kind ?? "?"}${o.lastTrip.atMs ? ` ${mins(nowMs - o.lastTrip.atMs)} ago` : ""}` : "";
 		out.push(`ollama cloud: ${o.models ?? 0} models · ${avail} · key ${o.apiKeySource ?? "?"} · ${usage}${bias}${trip}`);

package/package.json

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

package/src/cli/config-wizard.ts

@@ -143,7 +143,7 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "ollama.usagePollMs", label: "Plan usage poll", kind: "number", min: 0, hint: "ms, 0=off" },
 			{ path: "ollama.quotaCooldownMs", label: "Quota (402) cooldown", kind: "number", min: 0, hint: "ms" },
 			{ path: "ollama.rateLimitCooldownMs", label: "Rate-limit (429) cooldown", kind: "number", min: 0, hint: "ms" },
-			{ path: "ollama.planCreditsUsd", label: "Plan credits per month $", kind: "number", min: 0, hint: "Pro 60, Max 300; 0=unknown" },
+			{ path: "ollama.planCreditsUsd", label: "Plan credits per month $", kind: "number", min: 0, hint: "0=detect plan (Pro 60, Max 300)" },
 		],
 	},
 	{

package/src/config/types.ts

@@ -115,9 +115,9 @@ export interface OllamaConfig {
 	/** How long to route around Ollama after a 429 (concurrency cap), ms. */
 	rateLimitCooldownMs: number;
 	/**
-	 * Dollar value of the plan's included monthly credits (Pro 60, Max 300), so
-	 * the plan-relative usage reading can be shown as dollars beside the
-	 * ledger's own Ollama figure. 0 ⇒ unknown: usage is shown as a share only.
+	 * Override for the plan's included monthly credits, USD. 0 (default) reads
+	 * the plan from ollama.com (`POST /api/me`) and applies its published
+	 * allowance (Pro 60, Max 300); set this for a plan the router does not know.
 	 */
 	planCreditsUsd: number;
 }

package/src/context/bridge.ts

@@ -121,7 +121,15 @@ export function createContextBridge(opts: BridgeOptions): ContextBridge {
 				return { ...pinned, fetchedAtMs: input.pinnedFetchedAtMs };
 			}
 
-			const raw = await client.assemble(input.scope, input.query, { memoryLimit, docsLimit, sessionLimit, briefChars });
+			// Recent sessions only on a conversation's first block: after that they
+			// are this conversation's own recorded turns, duplicating the prompt
+			// and changing on every refresh (measured 1.4-1.9k chars per block).
+			const raw = await client.assemble(input.scope, input.query, {
+				memoryLimit,
+				docsLimit,
+				sessionLimit: input.firstFetch ? sessionLimit : 0,
+				briefChars,
+			});
 			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/query.ts

@@ -0,0 +1,58 @@
+/**
+ * What to tell agentdox this turn is about.
+ *
+ * The relevance query biases which memories and docs the assembled block
+ * carries, and agentdox echoes it verbatim into the block's header. Taking
+ * the last user-role message literally sent omp's own machinery instead of
+ * the user's ask: `<system-reminder>` nudges, `<system-notice>` job results,
+ * `<recap>` prompts, "Attached image(s) from tool result:" continuations.
+ * Measured on the live ledger: the three most recent blocks for one scope
+ * were queried with `<chat>`, `<system-reminder>` and an image notice, one
+ * header alone ran to 2k chars, and every refresh re-ranked memory against
+ * noise — different bytes each time, at the head of the cached prefix.
+ *
+ * The query is the last user message with real content once wrapper blocks
+ * are stripped, falling back to the conversation's opening ask, capped so the
+ * header stays a line rather than a message.
+ */
+
+import type { NormRequest } from "../wire/types.ts";
+
+/** Longest query worth sending: enough to rank on, short enough to stay stable. */
+export const MAX_QUERY_CHARS = 400;
+
+/**
+ * Harness wrapper tags whose whole element is machinery, not the user's ask.
+ * Stripped before judging whether a message has content.
+ */
+const WRAPPER_TAGS = ["system-reminder", "system-notice", "system-directive", "recap", "chat", "checkpoint-active-reminder", "interrupted-thinking"];
+
+const WRAPPER_RE = new RegExp(`<(${WRAPPER_TAGS.join("|")})(\\s[^>]*)?>[\\s\\S]*?</\\1>`, "gi");
+/** An unclosed wrapper at the start swallows the rest: treat the message as machinery. */
+const OPEN_WRAPPER_RE = new RegExp(`^\\s*<(${WRAPPER_TAGS.join("|")})(\\s[^>]*)?>`, "i");
+/** omp's tool-result image continuation and similar auto-generated stubs. */
+const STUB_RE = /^(attached image\(s\)(\s.*)?|\[image\]|\(no output\)|continue[.!]?)$/i;
+
+/** The user's own words in a message, or "" when it is all harness machinery. */
+export function userContent(text: string): string {
+	let t = text.replace(WRAPPER_RE, " ");
+	if (OPEN_WRAPPER_RE.test(t)) return "";
+	t = t.replace(/\s+/g, " ").trim();
+	if (t === "" || STUB_RE.test(t)) return "";
+	return t;
+}
+
+function cap(text: string): string {
+	return text.length > MAX_QUERY_CHARS ? `${text.slice(0, MAX_QUERY_CHARS - 1)}…` : text;
+}
+
+/** The relevance query for this turn: last real user message, else the opening ask, else "". */
+export function relevanceQuery(req: Pick<NormRequest, "messages">): string {
+	for (let i = req.messages.length - 1; i >= 0; i--) {
+		const m = req.messages[i];
+		if (m === undefined || m.role !== "user") continue;
+		const content = userContent(m.text);
+		if (content !== "") return cap(content);
+	}
+	return "";
+}

package/src/context/types.ts

@@ -38,8 +38,15 @@ export interface ContextResolveInput {
 	modelSwitching: boolean;
 	/** An escalation or failover retry — the prefix is cold either way. */
 	retrying: boolean;
-	/** Latest user text, used to bias agentdox relevance ranking. */
+	/** The user's ask this turn (see `context/query.ts`), used to bias agentdox relevance ranking. */
 	query: string;
+	/**
+	 * This conversation has not been given a block before. Recent sessions
+	 * are included only then: they carry a previous conversation forward, but
+	 * on a refresh they would mostly be this conversation's own turns, which
+	 * the prompt already holds.
+	 */
+	firstFetch: boolean;
 }
 
 /** One settled turn, recorded to agentdox with the model that served it. */

package/src/server/turn.ts

@@ -9,6 +9,7 @@
  */
 
 import type { CatalogSource } from "../catalog/types.ts";
+import { relevanceQuery, userContent } from "../context/query.ts";
 import type { ContextBridge } from "../context/types.ts";
 import type { RouterConfig } from "../config/types.ts";
 import { estimateUnreportedCache } from "../cost/cache-estimate.ts";
@@ -159,7 +160,8 @@ export async function runTurn(
 				pinnedFetchedAtMs: state.contextFetchedAtMs,
 				modelSwitching: state.currentSlug !== null && state.currentSlug !== decision.slug,
 				retrying: attempt > 0,
-				query: lastUserText(req),
+				query: relevanceQuery(req),
+				firstFetch: state.contextVersion === null,
 			});
 			if (pin !== null) {
 				contextBlock = pin.block;
@@ -589,7 +591,8 @@ export async function runTurn(
 		// 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);
+			// Record the user's words, not omp's wrappers (recap prompts, reminders).
+			const userText = userContent(lastUserText(req));
 			const turnEnded = finishReason !== "tool_calls";
 			log.debug("agentdox record turn", {
 				conversationKey: req.conversationKey.slice(0, 8),

package/src/upstream/ollama-usage.ts

@@ -35,9 +35,26 @@ export interface OllamaUsage {
 	activityCostUsd: number | null;
 	/** Requests this billing month, summed over models. */
 	requestsThisMonth: number;
+	/** Subscription name from `POST /api/me` (`pro`, `max`, …), or null when unknown. */
+	plan: string | null;
 	fetchedAtMs: number;
 }
 
+/**
+ * Included monthly credits per plan, USD, from ollama.com/pricing (2026-09-07):
+ * Pro $20/mo carries $60 of usage, Max $100/mo carries $300. The dashboard's
+ * dollar figure is `limits.monthly.usage` × this. A plan not listed here
+ * (free, team, an unseen tier) yields no dollar reading rather than a guess.
+ */
+export const PLAN_CREDITS_USD: Readonly<Record<string, number>> = { pro: 60, max: 300 };
+
+/** The plan named by an `/api/me` payload, lower-cased, or null. */
+export function parseOllamaPlan(json: unknown): string | null {
+	const root = asRec(json);
+	const plan = root?.Plan ?? root?.plan;
+	return typeof plan === "string" && plan.trim() !== "" ? plan.trim().toLowerCase() : null;
+}
+
 function asRec(v: unknown): Record<string, unknown> | null {
 	return typeof v === "object" && v !== null && !Array.isArray(v) ? (v as Record<string, unknown>) : null;
 }
@@ -72,6 +89,7 @@ export function parseOllamaUsage(json: unknown, nowMs = Date.now()): OllamaUsage
 		monthlyUsageRaw: usageRaw,
 		activityCostUsd: Number.isFinite(cost) ? cost : null,
 		requestsThisMonth: requests,
+		plan: null,
 		fetchedAtMs: nowMs,
 	};
 }
@@ -98,8 +116,35 @@ export function createOllamaUsageSource(
 	let checkedAtMs = 0;
 	let inflight: Promise<OllamaUsage | null> | null = null;
 	let warned = false;
+	let plan: string | null = null;
+	let planWarned = false;
+
+	/** Best-effort: a missing plan only costs the dollar reading, never the bias. */
+	async function refreshPlan(): Promise<void> {
+		try {
+			const res = await fetchImpl(`${root}/api/me`, {
+				method: "POST",
+				headers: { authorization: `Bearer ${opts.apiKey}` },
+				signal: AbortSignal.timeout(opts.timeoutMs),
+			});
+			if (res.ok) {
+				const parsed = parseOllamaPlan(await res.json());
+				if (parsed !== null) plan = parsed;
+			} else if (!planWarned) {
+				planWarned = true;
+				opts.log.warn("ollama account endpoint unavailable; plan stays unknown", { status: res.status });
+			}
+		} catch (err) {
+			if (!planWarned) {
+				planWarned = true;
+				opts.log.warn("ollama account fetch failed; plan stays unknown", { error: err instanceof Error ? err.message : String(err) });
+			}
+		}
+	}
 
 	async function refresh(): Promise<OllamaUsage | null> {
+		// The plan changes rarely, but the call is one small request per poll.
+		await refreshPlan();
 		try {
 			const res = await fetchImpl(`${root}/api/usage`, {
 				headers: { authorization: `Bearer ${opts.apiKey}` },
@@ -108,7 +153,7 @@ export function createOllamaUsageSource(
 			if (res.ok) {
 				const parsed = parseOllamaUsage(await res.json());
 				if (parsed !== null) {
-					current = parsed;
+					current = { ...parsed, plan };
 					warned = false;
 				} else if (!warned) {
 					warned = true;
@@ -156,8 +201,21 @@ export function effectiveOllamaBias(costBias: number, biasUntilUsage: number, us
 	return used >= biasUntilUsage ? 1 : costBias;
 }
 
+/**
+ * Included credits for this account: the configured override when set, else
+ * the detected plan's published allowance, else null.
+ */
+export function ollamaPlanCredits(usage: OllamaUsage | null, overrideUsd: number): number | null {
+	if (overrideUsd > 0) return overrideUsd;
+	const plan = usage?.plan ?? null;
+	if (plan === null) return null;
+	return PLAN_CREDITS_USD[plan] ?? null;
+}
+
 /** The dashboard's dollar reading: plan share × included credits, when both are known. */
-export function ollamaMeter(usage: OllamaUsage | null, planCreditsUsd: number): { usedUsd: number; creditsUsd: number } | null {
-	if (usage === null || usage.monthlyUsedFraction === null || !(planCreditsUsd > 0)) return null;
-	return { usedUsd: Math.round(usage.monthlyUsedFraction * planCreditsUsd * 100) / 100, creditsUsd: planCreditsUsd };
+export function ollamaMeter(usage: OllamaUsage | null, overrideUsd: number): { usedUsd: number; creditsUsd: number; plan: string | null } | null {
+	if (usage === null || usage.monthlyUsedFraction === null) return null;
+	const credits = ollamaPlanCredits(usage, overrideUsd);
+	if (credits === null) return null;
+	return { usedUsd: Math.round(usage.monthlyUsedFraction * credits * 100) / 100, creditsUsd: credits, plan: usage.plan };
 }

package/test/context-bridge.test.ts

@@ -72,11 +72,23 @@ function input(over: Partial<ContextResolveInput> = {}): ContextResolveInput {
 		modelSwitching: false,
 		retrying: false,
 		query: "movement rules",
+		firstFetch: true,
 		...over,
 	};
 }
 
 describe("context bridge refresh policy", () => {
+	test("recent sessions ride only on a conversation's first block; refreshes ask for none", async () => {
+		const client = mkClient();
+		const { bridge } = mkBridge(client, { sessionLimit: 6 });
+		await bridge.resolve(input({ firstFetch: true }));
+		expect(client.lastLimits?.sessionLimit).toBe(6);
+		// A refresh (model switch) on a conversation that already had a block.
+		await bridge.resolve(input({ firstFetch: false, modelSwitching: true, pinnedVersion: "stale", pinnedFetchedAtMs: 1 }));
+		expect(client.lastLimits?.sessionLimit).toBe(0);
+		expect(client.assembleCalls).toBe(2);
+	});
+
 	test("fetches on the first turn, then pins without re-fetching", async () => {
 		const client = mkClient();
 		const { bridge, db } = mkBridge(client);

package/test/context-query.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, test } from "bun:test";
+
+import { MAX_QUERY_CHARS, relevanceQuery, userContent } from "../src/context/query.ts";
+
+/**
+ * The agentdox relevance query must be the user's ask, not omp's wrappers:
+ * live blocks were queried with `<chat>`, `<system-reminder>` and an image
+ * notice, re-ranking memory against noise on every refresh.
+ */
+
+const msg = (role: "user" | "assistant" | "system" | "tool", text: string) => ({ role, text }) as never;
+
+describe("userContent", () => {
+	test("strips wrapper elements and keeps the user's words", () => {
+		expect(userContent("<system-reminder>\n5 todo items still open.\n</system-reminder>\nplease fix the water tests")).toBe("please fix the water tests");
+		expect(userContent("<recap>User stepped away; returning.</recap>")).toBe("");
+		expect(userContent("<system-notice>Background job bg_43 completed.</system-notice>")).toBe("");
+	});
+
+	test("an unclosed wrapper at the start is all machinery", () => {
+		expect(userContent("<chat>\nassistant said things\nuser said things")).toBe("");
+		expect(userContent("<system-reminder>Today: 2026-09-07")).toBe("");
+	});
+
+	test("auto-generated stubs are not content", () => {
+		expect(userContent("Attached image(s) from tool result:")).toBe("");
+		expect(userContent("(no output)")).toBe("");
+		expect(userContent("continue")).toBe("");
+	});
+
+	test("ordinary text passes through with whitespace collapsed", () => {
+		expect(userContent("  why does   the\n\nrouter pick glm?  ")).toBe("why does the router pick glm?");
+	});
+});
+
+describe("relevanceQuery", () => {
+	test("takes the last user message with real content, skipping wrapper-only turns", () => {
+		const req = {
+			messages: [
+				msg("system", "You are omp."),
+				msg("user", "add a /router command with reports"),
+				msg("assistant", "done"),
+				msg("user", "<system-reminder>5 todo items still open.</system-reminder>"),
+				msg("tool", "Attached image(s) from tool result:"),
+				msg("user", "Attached image(s) from tool result:"),
+			],
+		};
+		expect(relevanceQuery(req)).toBe("add a /router command with reports");
+	});
+
+	test("prefers the newest real ask over the opening one", () => {
+		const req = { messages: [msg("user", "first ask"), msg("assistant", "ok"), msg("user", "<recap>x</recap> now fix the report window")] };
+		expect(relevanceQuery(req)).toBe("now fix the report window");
+	});
+
+	test("caps long asks so the block header stays a line", () => {
+		const long = "x".repeat(5_000);
+		const q = relevanceQuery({ messages: [msg("user", long)] });
+		expect(q.length).toBe(MAX_QUERY_CHARS);
+		expect(q.endsWith("…")).toBe(true);
+	});
+
+	test("nothing usable yields an empty query", () => {
+		expect(relevanceQuery({ messages: [msg("user", "<chat>\nlog"), msg("assistant", "hi")] })).toBe("");
+		expect(relevanceQuery({ messages: [] })).toBe("");
+	});
+});

package/test/ollama.test.ts

@@ -22,7 +22,7 @@ import { buildCandidates } from "../src/router/candidates.ts";
 import { extractFeatures } from "../src/router/features.ts";
 import { createMultiUpstream } from "../src/upstream/multi.ts";
 import { classifyOllamaStatus, createOllamaClient, toOllamaBody } from "../src/upstream/ollama.ts";
-import { createOllamaUsageSource, effectiveOllamaBias, NO_USAGE, ollamaMeter, parseOllamaUsage, usageFraction } from "../src/upstream/ollama-usage.ts";
+import { createOllamaUsageSource, effectiveOllamaBias, NO_USAGE, ollamaMeter, parseOllamaPlan, parseOllamaUsage, usageFraction } from "../src/upstream/ollama-usage.ts";
 import type { Dispatch, DispatchOptions, UpstreamClient } from "../src/upstream/types.ts";
 import { createLogger } from "../src/util/log.ts";
 import { parseChatRequest } from "../src/wire/openai/request.ts";
@@ -444,7 +444,7 @@ describe("ollama plan usage (credit-aware bias)", () => {
 	});
 
 	test("the bias holds under the threshold, switches to list price above it, and stays on when usage is unknown", () => {
-		const at = (f: number | null) => (f === null ? null : { monthlyUsedFraction: f, monthlyUsageRaw: f, activityCostUsd: null, requestsThisMonth: 0, fetchedAtMs: 0 });
+		const at = (f: number | null) => (f === null ? null : { monthlyUsedFraction: f, monthlyUsageRaw: f, activityCostUsd: null, requestsThisMonth: 0, plan: null, fetchedAtMs: 0 });
 		expect(effectiveOllamaBias(0.1, 0.9, at(0.5))).toBe(0.1);
 		expect(effectiveOllamaBias(0.1, 0.9, at(0.9))).toBe(1);
 		expect(effectiveOllamaBias(0.1, 0.9, at(1))).toBe(1);
@@ -457,15 +457,21 @@ describe("ollama plan usage (credit-aware bias)", () => {
 		let calls = 0;
 		let fail = false;
 		const fetchImpl = async (url: string, init?: RequestInit): Promise<Response> => {
+			expect((init?.headers as Record<string, string>).authorization).toBe("Bearer k");
+			// The plan rides along on every poll: POST /api/me (GET answers 405).
+			if (url === "https://ollama.com/api/me") {
+				expect(init?.method).toBe("POST");
+				return Response.json({ ID: "x", Email: "e", Plan: "Pro" });
+			}
 			calls++;
 			expect(url).toBe("https://ollama.com/api/usage");
-			expect((init?.headers as Record<string, string>).authorization).toBe("Bearer k");
 			if (fail) return new Response("down", { status: 503 });
 			return Response.json({ ...PAYLOAD, limits: { monthly: { usage: 42, models: [] } } });
 		};
 		const src = createOllamaUsageSource({ apiKey: "k", pollMs: 20, timeoutMs: 1000, log, fetchImpl });
 		expect(src.peek()).toBeNull();
 		expect((await src.get())?.monthlyUsedFraction).toBeCloseTo(0.42, 6);
+		expect(src.peek()?.plan).toBe("pro");
 		await src.get();
 		expect(calls).toBe(1); // within the interval
 		fail = true;
@@ -482,7 +488,7 @@ describe("ollama plan usage (credit-aware bias)", () => {
 		const source = { get: async () => ollamaModels, peek: () => ollamaModels, invalidate: () => {} };
 		const breaker = { available: () => true, cooldownUntilMs: () => null, lastTrip: () => null };
 		let used = 0.2;
-		const usage = { get: async () => ({ monthlyUsedFraction: used, monthlyUsageRaw: used * 100, activityCostUsd: null, requestsThisMonth: 0, fetchedAtMs: 0 }), peek: () => ({ monthlyUsedFraction: used, monthlyUsageRaw: used * 100, activityCostUsd: null, requestsThisMonth: 0, fetchedAtMs: 0 }) };
+		const usage = { get: async () => ({ monthlyUsedFraction: used, monthlyUsageRaw: used * 100, activityCostUsd: null, requestsThisMonth: 0, plan: null, fetchedAtMs: 0 }), peek: () => ({ monthlyUsedFraction: used, monthlyUsageRaw: used * 100, activityCostUsd: null, requestsThisMonth: 0, plan: null, fetchedAtMs: 0 }) };
 		const catalog = createCompositeCatalog(openrouter, source, breaker, { costBias: 0.1, biasUntilUsage: 0.9, usage });
 
 		const a = await catalog.get();
@@ -506,16 +512,29 @@ describe("ollama plan usage (credit-aware bias)", () => {
 
 
 describe("ollamaMeter", () => {
-	test("plan share times credits is the dashboard's dollar figure", () => {
-		const usage = { monthlyUsedFraction: 0.104, monthlyUsageRaw: 0.104, activityCostUsd: 0, requestsThisMonth: 1250, fetchedAtMs: 1 };
-		// 10.4% of Pro's $60 is the $6.24 ollama.com shows.
-		expect(ollamaMeter(usage, 60)).toEqual({ usedUsd: 6.24, creditsUsd: 60 });
+	const usage = (plan: string | null, frac: number | null = 0.104) => ({ monthlyUsedFraction: frac, monthlyUsageRaw: frac, activityCostUsd: 0, requestsThisMonth: 1250, plan, fetchedAtMs: 1 });
+
+	test("a detected plan applies its published allowance: 10.4% of Pro's $60 is the $6.24 ollama.com shows", () => {
+		expect(ollamaMeter(usage("pro"), 0)).toEqual({ usedUsd: 6.24, creditsUsd: 60, plan: "pro" });
+		expect(ollamaMeter(usage("max"), 0)).toEqual({ usedUsd: 31.2, creditsUsd: 300, plan: "max" });
 	});
 
-	test("unknown credits or usage yields no meter", () => {
-		const usage = { monthlyUsedFraction: 0.5, monthlyUsageRaw: 0.5, activityCostUsd: 0, requestsThisMonth: 1, fetchedAtMs: 1 };
-		expect(ollamaMeter(usage, 0)).toBeNull();
+	test("a configured override wins over the detected plan; an unknown plan without one yields no meter", () => {
+		expect(ollamaMeter(usage("pro"), 100)).toEqual({ usedUsd: 10.4, creditsUsd: 100, plan: "pro" });
+		expect(ollamaMeter(usage("team"), 0)).toBeNull();
+		expect(ollamaMeter(usage("team"), 500)?.creditsUsd).toBe(500);
+		expect(ollamaMeter(usage(null), 0)).toBeNull();
+	});
+
+	test("no usage reading yields no meter", () => {
 		expect(ollamaMeter(null, 60)).toBeNull();
-		expect(ollamaMeter({ ...usage, monthlyUsedFraction: null }, 60)).toBeNull();
+		expect(ollamaMeter(usage("pro", null), 60)).toBeNull();
+	});
+
+	test("parseOllamaPlan reads the account payload case-insensitively", () => {
+		expect(parseOllamaPlan({ ID: "x", Plan: "Pro" })).toBe("pro");
+		expect(parseOllamaPlan({ plan: "max" })).toBe("max");
+		expect(parseOllamaPlan({ Plan: "" })).toBeNull();
+		expect(parseOllamaPlan("nope")).toBeNull();
 	});
 });

package/test/report-logic.test.ts

@@ -65,7 +65,7 @@ describe("renderStatus", () => {
 				apiKeySource: "omp",
 				lastTrip: { kind: "quota", atMs: now - 120_000, message: "402" },
 				usage: { monthlyUsedFraction: 0.42, activityCostUsd: 3.1, fetchedAtMs: now },
-				meter: { usedUsd: 25.2, creditsUsd: 60 },
+				meter: { usedUsd: 25.2, creditsUsd: 60, plan: "pro" },
 				costBias: { configured: 0.1, effective: 0.1, biasUntilUsage: 0.9 },
 			},
 			catalog: { models: 240, ageMs: 5 * 60_000, keyScoped: true, shrink: { fromModels: 300, toModels: 120, atMs: now } },
@@ -76,7 +76,7 @@ describe("renderStatus", () => {
 		expect(text).toContain("refreshed 5m ago");
 		expect(text).toContain("SHRANK 300 -> 120");
 		expect(text).toContain("COOLING DOWN");
-		expect(text).toContain("plan usage 42.0% ($25.20 of $60)");
+		expect(text).toContain("pro plan usage 42.0% ($25.20 of $60)");
 		expect(text).toContain("cost bias ×0.1 (until 90%)");
 		expect(text).toContain("last trip quota 2m ago");
 		expect(text).toContain("scope omp-router");

package/tools/agentdox-e2e.ts

@@ -58,6 +58,7 @@ function input(over: Partial<ContextResolveInput> = {}): ContextResolveInput {
 		modelSwitching: false,
 		retrying: false,
 		query: "cache prompt context injection",
+		firstFetch: true,
 		...over,
 	};
 }