auto-model-router 0.1.2 → 0.1.4

package/README.md

@@ -6,13 +6,14 @@ OpenRouter model **per turn** based on measured price and estimated task
 complexity — including mid-conversation, when a session shifts from mechanical
 tool-loop churn to genuine reasoning work.
 
-All LLM inference is offloaded to OpenRouter. Nothing runs on-device except
-routing arithmetic.
-
 auto-model-router runs **embedded inside the omp process** (as an omp extension) — no
 separate server, no orphaned process. It binds a free OS-assigned port and
 lives and dies with the omp session.
 
+For non-omp harnesses (Hermes, Claude, any OpenAI-compatible client), run it as
+a standalone process with `auto-model-router serve --port <n>` — the same core,
+on a fixed port, owned by you. See [Hermes](#hermes) below.
+
 ## Why this exists when OpenRouter already ships routers
 
 OpenRouter has `openrouter/auto` (market-spend classifier) and
@@ -62,7 +63,7 @@ without touching routing.
 | `src/router/` | Feature extraction, complexity classification, candidate filtering and scoring, hysteresis, cache-breakpoint placement, budget guard, probe planning. |
 | `src/upstream/` | OpenRouter transport: streaming dispatch, `session_id` stickiness, error classification, fallback arrays. |
 | `src/config/` | Configuration loading, schema validation, and the built-in defaults. |
-| `src/cli/` | `stats`, `models`, `explain`, `config` commands. |
+| `src/cli/` | `serve`, `stats`, `models`, `explain`, `config` commands. |
 | `omp-extension/` | The omp extensions: `router-embed.ts`, `router-toast.ts`, `router-configure.ts`. |
 
 ### Two cost numbers, never conflated
@@ -73,13 +74,68 @@ without touching routing.
 - **Reported** — `usage.cost` from OpenRouter, authoritative after the fact.
   Drives the ledger, `stats`, and prediction-error calibration.
 
-## Requirements
-
-- **omp** (the Oh My Pi harness) — the router runs as an omp extension.
-- **Bun** `>= 1.2.0` — omp itself is a Bun process; the router code runs inside
+  it. No separate Bun install is needed for the embedded path. The standalone
+  `serve` binary (`npm install -g auto-model-router`) bundles Bun.
   it. No separate Bun install is needed for the embedded path.
 
-## Installation
+Two ways to get the router into omp. The **npm package** is the modern path —
+it installs the `auto-model-router` binary and wires the omp extensions; the
+**repo-local installer** is for developing against the source.
+
+### Via npm (installs the `auto-model-router` binary)
+
+```bash
+npm install -g auto-model-router
+```
+
+Then add the shipped extensions to omp's `~/.omp/agent/config.yml`
+(`$PI_CODING_AGENT_DIR/config.yml` when that env var relocates the agent dir):
+
+```yaml
+# ~/.omp/agent/config.yml
+extensions:
+  - auto-model-router/omp-extension/router-embed.ts
+  - auto-model-router/omp-extension/router-toast.ts      # optional: chosen-model toasts
+  - auto-model-router/omp-extension/router-configure.ts # optional: /router command
+```
+
+### From the repo (cross-platform installer)
+
+```bash
+bun tools/install.ts
+```
+
+It wires the auto-model-router extensions into omp's `~/.omp/agent/config.yml`
+(`$PI_CODING_AGENT_DIR/config.yml` when that env var relocates the agent dir),
+backing up the previous file first. It is idempotent — re-running is a no-op.
+
+Options:
+
+```bash
+bun tools/install.ts --no-toast --no-configure   # only the required embed extension
+```
+
+The installer adds:
+
+- `router-embed.ts` — **required**; runs the router in-process.
+- `router-toast.ts` — optional; chosen-model toasts.
+- `router-configure.ts` — optional; the `/router` command.
+
+Or add the paths by hand to omp's `~/.omp/agent/config.yml`:
+
+```yaml
+# ~/.omp/agent/config.yml
+extensions:
+  - /path/to/auto-model-router/omp-extension/router-embed.ts
+  - /path/to/auto-model-router/omp-extension/router-toast.ts      # optional: chosen-model toasts
+  - /path/to/auto-model-router/omp-extension/router-configure.ts # optional: /router command
+```
+
+Then restart the omp session (extensions load at session start).
+
+or install it from the marketplace (see below). The plugin declares all three
+extensions (`router-embed`, `router-toast`, `router-configure`), so installing
+it wires the router in without editing `config.yml` by hand.
 
 There is nothing to install system-wide. Run the cross-platform installer
 (Windows, macOS, Linux) from the repo:
@@ -162,37 +218,65 @@ npm publish
 
 ### Hermes
 
-Hermes speaks the OpenAI-compatible wire, so it connects to the router with no
-code change. Two ways to run the router for Hermes:
+Install the router globally (puts the `serve` binary on PATH) and
+install the native plugin, then point Hermes at it:
+
+**1. Install the router binary:**
+
+```bash
+npm install -g auto-model-router
+```
+
+**2. Install the Hermes plugin.** Copy `hermes-plugin/` to
+`$HERMES_HOME/plugins/model-providers/auto-model-router/` (where
+`HERMES_HOME` is `C:\Users\<you>\AppData\Local\hermes` on Windows,
+`~/.hermes` on macOS/Linux):
+
+```bash
+mkdir -p "$HERMES_HOME/plugins/model-providers"
+cp -r hermes-plugin/ "$HERMES_HOME/plugins/model-providers/auto-model-router/"
+```
+
+**3. Surface the provider in Hermes's picker.** Hermes only lists providers
+that have a credential. The router itself is keyless (it resolves its own
+OpenRouter key), but to make Hermes show it as selectable, add a marker value
+to `$HERMES_HOME/.env`:
+
+```bash
+echo "AUTO_MODEL_ROUTER_API_KEY=local" >> "$HERMES_HOME/.env"
+```
+
+**4. Restart Hermes.** On load, the plugin spawns the router (`auto-model-router
+serve`) as a subprocess on port 8788 and registers the provider profile. Select
+`auto-model-router/auto` as the model.
 
-**Standalone server (recommended for Hermes):** run the router as its own
-process on a fixed port, then point Hermes at it:
+The plugin runs the router against its **own** config home
+(`$HERMES_HOME/auto-model-router/`), separate from omp's
+`~/.auto-model-router/`, so the two harnesses never share a ledger or
+conversation state and don't leak routing toasts into each other's UIs.
+
+The router serves `GET /v1/models` (returning the `auto`, `auto-cheap`,
+`auto-max` profiles) and `POST /v1/chat/completions`, which Hermes's custom
+endpoint discovery verifies. The router's own OpenRouter key resolution
+(config → env → omp auth store) applies — Hermes does not need its own
+OpenRouter key.
+
+**Standalone alternative (no plugin):** run the router yourself, then add a
+custom provider:
 
 ```bash
 auto-model-router serve --port 8788
 ```
 
 ```yaml
-# ~/.hermes/config.yaml
+# $HERMES_HOME/config.yaml
 providers:
   auto-model-router:
     base_url: http://127.0.0.1:8788/v1
-    api_key: no-key-required
+    api_key: local
     default_model: auto
 ```
 
-**Hermes plugin (native):** copy `hermes-plugin/` to
-`$HERMES_HOME/plugins/model-providers/auto-model-router/` and restart Hermes.
-The plugin spawns the router as a subprocess on load and registers the provider
-profile, so Hermes routes each turn through the router automatically.
-
-The router serves `GET /v1/models` (returning the `auto`, `auto-cheap`,
-`auto-max` profiles) and `POST /v1/chat/completions`, which Hermes's custom
-endpoint discovery verifies. Select `auto-model-router/auto` as the model and
-the router routes each turn by price and complexity. The router's own OpenRouter
-key resolution (config → env → omp auth store) applies — Hermes does not need
-its own OpenRouter key.
-
 ### The OpenRouter key
 
 There should be exactly one OpenRouter key on the machine, and omp already owns
@@ -307,7 +391,8 @@ disk and back up the previous file to a timestamped `.bak`.
 | --- | --- | --- |
 | `OPENROUTER_API_KEY` | OpenRouter key (overrides the auth store). | — |
 | `AUTO_MODEL_ROUTER_HOME` | Config + database directory. | `~/.auto-model-router` |
-| `AUTO_MODEL_ROUTER_PORT` | Pin a specific bind port (rarely needed; the embedded router picks a free one otherwise). | OS-assigned |
+| `AUTO_MODEL_ROUTER_HOST` | Bind address override. | `127.0.0.1` |
+| `AUTO_MODEL_ROUTER_LOG` | Log level: `silent`/`error`/`warn`/`info`/`debug`. | `info` |
 | `AUTO_MODEL_ROUTER_LOG` | Log level: `silent`/`error`/`warn`/`info`/`debug`. | `info` |
 | `AUTO_MODEL_ROUTER_DB` | Override the ledger path. | `$AUTO_MODEL_ROUTER_HOME/router.db` |
 | `AUTO_MODEL_ROUTER_URL` | Toast/base URL override (the toast reads the shared port file first). | — |
@@ -472,8 +557,15 @@ on each other:
 - **Per-harness daily budget** — each harness sends an `X-Omp-Harness` header
   (from the provider block's `headers:`), and the router scopes the rolling
   24h `perDayUsd` ceiling to it. One harness can't exhaust the day for another.
-- **Per-harness toasts** — set `OMP_HARNESS_ID` to the same value so the
-  extension only toasts that harness's model choices.
+- **Per-session toasts** — the toast surfaces only the decisions made by *its
+  own* omp session. The embed extension tags every request with an
+  `X-Omp-Session` header (`ctx.sessionManager.getSessionId()`), the router
+  records it on each ledger row, and the toast filters on it. Two concurrent
+  interactive sessions — even of the same harness — never surface each other's
+  model choices. This needs no configuration.
+- **Per-harness toasts** — additionally set `OMP_HARNESS_ID` to the same value
+  so the extension only toasts that harness's model choices. Session scoping is
+  finer-grained; harness scoping still applies on top when set.
 
 Configure a harness by setting `server.harnessId`; set the same id in that
 harness's `OMP_HARNESS_ID` env var.
@@ -509,7 +601,8 @@ bound, even though it changes every session.
 The toast logic is a pure, unit-tested module
 (`omp-extension/toast-logic.ts`, covered by `test/toast-logic.test.ts`): it
 toasts only decisions newer than the last seen one, skips `wasted` escalation
-attempts, and prefers the actual serving slug over the requested one.
+attempts, prefers the actual serving slug over the requested one, and filters
+to the toast's own omp session id (and harness id, when set).
 
 ---
 

package/hermes-plugin/__init__.py

@@ -35,10 +35,23 @@ BASE_URL = f"http://127.0.0.1:{PORT}/v1"
 # The router binary, provided by `npm install -g auto-model-router`.
 BIN = "auto-model-router"
 
+# The router's config home. Must be SEPARATE from the default (~/.auto-model-router)
+# which omp's embedded router shares: both read the same ledger + config there,
+# so sharing it would leak omp's routing toasts into this harness (and vice versa)
+# and let the two routers fight over conversation state. Use a hermes-owned home.
+_ROUTER_HOME = os.environ.get(
+    "AUTO_MODEL_ROUTER_HOME",
+    os.path.join(
+        os.environ.get("HERMES_HOME", os.path.expanduser("~")), "auto-model-router"
+    ),
+)
+
 
 def _router_running() -> bool:
     try:
-        with urllib.request.urlopen(f"http://127.0.0.1:{PORT}/health", timeout=1) as resp:
+        with urllib.request.urlopen(
+            f"http://127.0.0.1:{PORT}/health", timeout=1
+        ) as resp:
             return resp.status == 200
     except Exception:
         return False
@@ -53,6 +66,7 @@ def _spawn_router() -> None:
             "auto-model-router is not installed or not on PATH. "
             "Run `npm install -g auto-model-router` first."
         )
+    env = {**os.environ, "AUTO_MODEL_ROUTER_HOME": _ROUTER_HOME}
     if sys.platform.startswith("win"):
         # npm installs a `.cmd` shim that cannot be exec'd as a bare argv
         # list; shell=True resolves it through the command shell.
@@ -62,6 +76,7 @@ def _spawn_router() -> None:
             stderr=subprocess.DEVNULL,
             shell=True,
             start_new_session=True,
+            env=env,
         )
     else:
         subprocess.Popen(
@@ -69,6 +84,7 @@ def _spawn_router() -> None:
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,
             start_new_session=True,
+            env=env,
         )
     # Wait for it to come up (bounded).
     for _ in range(50):

package/omp-extension/router-embed.ts

@@ -43,15 +43,20 @@ import {
  * Registers the auto-model-router provider (and its virtual models) into omp's model
  * registry at a specific bound port.
  */
-function registerRouterProvider(pi: ExtensionAPI, port: number, cfg: RouterConfig): void {
+function registerRouterProvider(pi: ExtensionAPI, port: number, cfg: RouterConfig, sessionId: string): void {
 	const providerConfig = buildProviderConfig(port, cfg);
+	const headers: Record<string, string> = {};
+	if (providerConfig.harnessId !== undefined && providerConfig.harnessId !== "") {
+		headers["X-Omp-Harness"] = providerConfig.harnessId;
+	}
+	// Per-session scoping: lets the toast surface only this session's decisions
+	// even when several omp sessions share one embedded router's ledger.
+	if (sessionId !== "") headers["X-Omp-Session"] = sessionId;
 	pi.registerProvider(EMBED_PROVIDER_ID, {
 		baseUrl: providerConfig.baseUrl,
 		api: "openai-completions",
 		apiKey: EMBED_DUMMY_API_KEY,
-		...(providerConfig.harnessId !== undefined && providerConfig.harnessId !== ""
-			? { headers: { "X-Omp-Harness": providerConfig.harnessId } }
-			: {}),
+		...(Object.keys(headers).length > 0 ? { headers } : {}),
 		models: providerConfig.models.map((m) => ({
 			id: m.id,
 			name: m.name,
@@ -90,9 +95,12 @@ export default function (pi: ExtensionAPI): void {
 		// Subagents and headless sessions do not bind their own router; they
 		// route to the main's router via the shared port file. The main writes
 		// the file before spawning subagents, so the port is available here.
+		// The omp UI session id tags every request so the toast can scope its
+		// notifications to that exact session (see router-toast.ts).
+		const sessionId = ctx.sessionManager.getSessionId();
 		if (!ctx.hasUI) {
 			const port = readEmbedPort(portFile);
-			if (port !== null) registerRouterProvider(pi, port, cfg);
+			if (port !== null) registerRouterProvider(pi, port, cfg, sessionId);
 			return;
 		}
 
@@ -108,7 +116,7 @@ export default function (pi: ExtensionAPI): void {
 
 		// Publish the shared port; subagents and the toast read it from here.
 		writeEmbedPort(portFile, actualPort);
-		registerRouterProvider(pi, actualPort, cfg);
+		registerRouterProvider(pi, actualPort, cfg, sessionId);
 
 		pi.on("session_shutdown", () => {
 			void app?.stop().catch(() => {});

package/omp-extension/router-toast.ts

@@ -73,6 +73,11 @@ export default function (pi: ExtensionAPI): void {
 		// poll loop entirely rather than waking every 2s to do nothing.
 		if (!ctx.hasUI) return;
 
+		// This session's omp id. The embed extension tags every request with it
+		// (X-Omp-Session), so filtering on it scopes toasts to this session even
+		// when several omp sessions share one embedded router's ledger.
+		const sessionId = ctx.sessionManager.getSessionId();
+
 		// The poll request's own deadline (3s) exceeds the poll period (2s), so
 		// a slow router could let a second tick start while the first is still in
 		// flight — both read the same lastSeenId and raise duplicate toasts. An
@@ -115,7 +120,7 @@ export default function (pi: ExtensionAPI): void {
 				const entries = body.entries;
 				if (!Array.isArray(entries) || entries.length === 0) return;
 
-				for (const t of selectToasts(entries, lastSeenId, HARNESS_ID)) {
+				for (const t of selectToasts(entries, lastSeenId, HARNESS_ID, sessionId)) {
 					ctx.ui.notify(t.text, "info");
 				}
 				lastSeenId = newestId(entries) ?? lastSeenId;

package/omp-extension/toast-logic.ts

@@ -83,6 +83,11 @@ export interface ToastDecision {
 	wasted: boolean;
 	/** Harness id from the request header; empty for the default harness. */
 	harnessId: string;
+	/**
+	 * omp UI session id from the `X-Omp-Session` header; empty for the no-header
+	 * default. Lets the toast scope to a single interactive session.
+	 */
+	ompSessionId?: string;
 }
 
 export interface ToastMessage {
@@ -111,6 +116,7 @@ export function selectToasts(
 	entries: ToastDecision[],
 	lastSeenId: string | null,
 	harnessId = "",
+	ompSessionId = "",
 ): ToastMessage[] {
 	if (lastSeenId === null) return [];
 	// `entries` is newest-first. Entries strictly newer than lastSeenId are the
@@ -124,6 +130,7 @@ export function selectToasts(
 		if (d === undefined) continue;
 		if (d.wasted) continue;
 		if (harnessId !== "" && d.harnessId !== harnessId) continue;
+		if (ompSessionId !== "" && d.ompSessionId !== ompSessionId) continue;
 		out.push({ model: d.servedSlug ?? d.slug, tier: d.tier, costUsd: d.reportedUsd, text: toToastText(d) });
 	}
 	return out;

package/package.json

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

package/src/cost/ledger.ts

@@ -32,6 +32,7 @@ interface LedgerRow {
 	turn: number;
 	requested_model: string;
 	harness_id: string;
+	omp_session_id: string;
 	slug: string;
 	served_slug: string | null;
 	tier: string;
@@ -128,6 +129,7 @@ function toEntry(row: LedgerRow): LedgerEntry {
 		turn: row.turn,
 		requestedModel: row.requested_model,
 		harnessId: row.harness_id,
+		ompSessionId: row.omp_session_id,
 		slug: row.slug,
 		servedSlug: row.served_slug,
 		tier: row.tier,
@@ -151,11 +153,11 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 	// Prepared once: record() runs on every turn.
 	const insertStmt = db.query(
 		`INSERT INTO ledger (
-			id, created_at_ms, conversation_key, session_id, turn, requested_model, harness_id, slug, served_slug,
+			id, created_at_ms, conversation_key, session_id, turn, requested_model, harness_id, omp_session_id, slug, served_slug,
 			tier, classification_source, reasons, predicted_usd, reported_usd, usage, cost_breakdown,
 			attempt, escalation_signal, latency_ms, ttft_ms, finish_reason, wasted, upstream_generation_id, error,
 			error_kind
-		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
 	);
 	const calibrationStmt = db.query(
 		`INSERT INTO token_calibration (tokenizer, est_bytes, actual_tokens, samples) VALUES (?, ?, ?, 1)
@@ -215,6 +217,7 @@ export function createLedger(db: Database, cfg: RouterConfig): Ledger {
 				entry.turn,
 				entry.requestedModel,
 				entry.harnessId,
+				entry.ompSessionId,
 				entry.slug,
 				entry.servedSlug,
 				entry.tier,

package/src/cost/types.ts

@@ -74,6 +74,12 @@ export interface LedgerEntry {
 	requestedModel: string;
 	/** Harness id from the request header; empty for the default harness. */
 	harnessId: string;
+	/**
+	 * omp UI session id from the `X-Omp-Session` request header; empty when the
+	 * client sends no header. Scopes toasts to a single interactive session so
+	 * concurrent sessions sharing one ledger don't surface each other's choices.
+	 */
+	ompSessionId: string;
 	/** Concrete slug we dispatched to. */
 	slug: string;
 	/** Slug that actually served it, per the response `model` field. */

package/src/index.ts

@@ -33,7 +33,6 @@ Global options:
 
   serve    --port <n>  --host <addr>  --log <level>
   stats    --days <n>  --json
-  stats    --days <n>  --json
   models   --tier <trivial|simple|moderate|hard>  --limit <n>  --json
   explain  --file <request.json>  --json          (reads stdin when --file is absent)
   config   --print  --write  --path <models.yml>  --config <router-config.yml>

package/src/server/turn.ts

@@ -141,6 +141,7 @@ export async function runTurn(
 				turn: turnNumber,
 				requestedModel: req.requestedModel,
 				harnessId: req.harnessId,
+				ompSessionId: req.ompSessionId,
 				slug: decision.slug,
 				servedSlug,
 				tier: decision.tier,

package/src/util/sqlite.ts

@@ -18,7 +18,7 @@ import { mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 
 /** Bump when a migration is added; guarded below so reopening never regresses it. */
-const USER_VERSION = 4;
+const USER_VERSION = 5;
 
 const MIGRATIONS = `
 CREATE TABLE IF NOT EXISTS catalog_cache (
@@ -37,6 +37,7 @@ CREATE TABLE IF NOT EXISTS ledger (
   turn INTEGER NOT NULL,
   requested_model TEXT NOT NULL,
   harness_id TEXT NOT NULL DEFAULT '',
+  omp_session_id TEXT NOT NULL DEFAULT '',
   slug TEXT NOT NULL,
   served_slug TEXT,
   tier TEXT NOT NULL,
@@ -118,6 +119,15 @@ END
 WHERE error IS NOT NULL;
 `;
 
+// v5: ledger gains omp_session_id, so the toast extension can scope decisions to
+// its own omp session. Before this, the only scoping was per-harness, so two
+// interactive omp sessions of the same harness (the default: empty) each
+// surfaced the other's routing toasts from the shared ledger. Existing rows
+// backfill to '' (unknown session), matching the no-header default.
+const MIGRATE_V5 = `
+ALTER TABLE ledger ADD COLUMN omp_session_id TEXT NOT NULL DEFAULT '';
+`;
+
 export function openDb(path: string): Database {
 	// ":memory:" has no parent directory to create.
 	if (path !== ":memory:") mkdirSync(dirname(path), { recursive: true });
@@ -134,6 +144,7 @@ export function openDb(path: string): Database {
 		const ledgerCols = db.query("PRAGMA table_info(ledger)").all() as { name: string }[];
 		if (!ledgerCols.some((c) => c.name === "harness_id")) db.exec(MIGRATE_V3);
 		if (!ledgerCols.some((c) => c.name === "error_kind")) db.exec(MIGRATE_V4);
+		if (!ledgerCols.some((c) => c.name === "omp_session_id")) db.exec(MIGRATE_V5);
 		db.exec(`PRAGMA user_version = ${USER_VERSION}`);
 	}
 	return db;

package/src/wire/openai/request.ts

@@ -204,6 +204,10 @@ export function parseChatRequest(body: unknown, headers: Headers): NormRequest {
 	// this via the provider block's `headers:` override; absent ⇒ single harness.
 	const harnessId = (headers.get("x-omp-harness") ?? "").trim();
 
+	// omp UI session id for per-session toast scoping. The embed extension sets
+	// this header to ctx.sessionManager.getSessionId(); absent ⇒ unknown session.
+	const ompSessionId = (headers.get("x-omp-session") ?? "").trim();
+
 	if (typeof b.model !== "string" || b.model.length === 0) {
 		throw invalidRequest("model must be a non-empty string");
 	}
@@ -262,6 +266,7 @@ export function parseChatRequest(body: unknown, headers: Headers): NormRequest {
 		protocol: "openai-chat",
 		conversationKey,
 		harnessId,
+		ompSessionId,
 		requestedModel,
 		messages,
 		tools,

package/src/wire/types.ts

@@ -68,6 +68,13 @@ export interface NormRequest {
 	 * client sends no header (single-harness default).
 	 */
 	harnessId: string;
+	/**
+	 * omp UI session id from the `X-Omp-Session` request header, when the client
+	 * sends one. Scopes toasts to a single interactive session so concurrent
+	 * sessions sharing one router don't surface each other's choices. Empty when
+	 * the client sends no header.
+	 */
+	ompSessionId: string;
 	/** Virtual model the client selected, e.g. `auto`, `auto-cheap`, `auto-max`. */
 	requestedModel: string;
 	messages: NormMessage[];

package/test/escalate.test.ts

@@ -22,6 +22,7 @@ function req(messages: NormMessage[] = [], over: Partial<NormRequest> = {}): Nor
 		protocol: "openai-chat",
 		conversationKey: "k",
 		harnessId: "",
+		ompSessionId: "",
 		requestedModel: "auto",
 		messages,
 		tools: [],

package/test/failover.test.ts

@@ -79,6 +79,7 @@ function mkReq(): NormRequest {
 		protocol: "openai-chat",
 		conversationKey: "conv-test",
 		harnessId: "",
+		ompSessionId: "",
 		requestedModel: "auto",
 		messages: [{ role: "user", text: "hi", images: 0, textBytes: 2, toolCalls: [] }],
 		tools: [],

package/test/toast-logic.test.ts

@@ -141,6 +141,38 @@ describe("selectToasts", () => {
 		];
 		expect(selectToasts(entries, "", "")).toHaveLength(2);
 	});
+
+	test("filters to the requesting omp session when one is set", () => {
+		// Two interactive omp sessions sharing one router's ledger: session-a's
+		// toast must not surface session-b's decisions.
+		const entries = [
+			dec({ id: "d3", slug: "mine", ompSessionId: "sess-a" }),
+			dec({ id: "d2", slug: "other", ompSessionId: "sess-b" }),
+			dec({ id: "d1", slug: "prior", ompSessionId: "sess-a" }),
+		];
+		const toasts = selectToasts(entries, "d1", "", "sess-a");
+		expect(toasts).toHaveLength(1);
+		expect(toasts[0]?.model).toBe("mine");
+	});
+
+	test("empty omp session id toasts every session", () => {
+		const entries = [
+			dec({ id: "d2", slug: "a", ompSessionId: "sess-a" }),
+			dec({ id: "d1", slug: "b", ompSessionId: "sess-b" }),
+		];
+		expect(selectToasts(entries, "", "", "")).toHaveLength(2);
+	});
+
+	test("harness and session filters compose", () => {
+		const entries = [
+			dec({ id: "d3", slug: "keep", harnessId: "h", ompSessionId: "sess-a" }),
+			dec({ id: "d2", slug: "wrong-session", harnessId: "h", ompSessionId: "sess-b" }),
+			dec({ id: "d1", slug: "wrong-harness", harnessId: "other", ompSessionId: "sess-a" }),
+		];
+		const toasts = selectToasts(entries, "", "h", "sess-a");
+		expect(toasts).toHaveLength(1);
+		expect(toasts[0]?.model).toBe("keep");
+	});
 });
 
 describe("toToastText", () => {

package/test/tokens.test.ts

@@ -18,6 +18,7 @@ function entry(over: Partial<LedgerEntry>): LedgerEntry {
 		turn: 1,
 		requestedModel: "auto",
 		harnessId: "",
+		ompSessionId: "",
 		slug: "openai/gpt-5-mini",
 		servedSlug: "openai/gpt-5-mini",
 		tier: "simple",

package/test/trust-attribution.test.ts

@@ -16,6 +16,7 @@ function entry(over: Partial<LedgerEntry>): LedgerEntry {
 		turn: 1,
 		requestedModel: "auto",
 		harnessId: "",
+		ompSessionId: "",
 		slug: "vendor/model",
 		servedSlug: "vendor/model",
 		tier: "simple",
@@ -163,11 +164,24 @@ describe("v4 migration", () => {
 		}
 	});
 
-	test("schema is at user_version 4", () => {
+	test("schema is at user_version 5", () => {
 		const db = openDb(":memory:");
 		try {
 			const row = db.query("PRAGMA user_version").get() as { user_version: number };
-			expect(row.user_version).toBe(4);
+			expect(row.user_version).toBe(5);
+		} finally {
+			db.close();
+		}
+	});
+
+	test("persists omp_session_id and returns it via recentEntries", () => {
+		const db = openDb(":memory:");
+		try {
+			const ledger = createLedger(db, cfg);
+			ledger.record(entry({ ompSessionId: "sess-a" }));
+			ledger.record(entry({ ompSessionId: "" }));
+			const got = ledger.recentEntries(10).map((e) => e.ompSessionId).sort();
+			expect(got).toEqual(["", "sess-a"]);
 		} finally {
 			db.close();
 		}

package/test/turn.test.ts

@@ -79,6 +79,7 @@ function mkReq(): NormRequest {
 		protocol: "openai-chat",
 		conversationKey: "conv-test",
 		harnessId: "",
+		ompSessionId: "",
 		requestedModel: "auto",
 		messages: [{ role: "user", text: "hi", images: 0, textBytes: 2, toolCalls: [] }],
 		tools: [],

package/test/wire-request.test.ts

@@ -58,6 +58,17 @@ describe("parseChatRequest normalization", () => {
 		expect(prefixed.requestedModel).toBe("auto");
 	});
 
+	test("reads harness and omp session ids from headers, trimmed", () => {
+		const headers = new Headers({ "x-omp-harness": " prod-a ", "x-omp-session": " sess-1 " });
+		const req = parseChatRequest(userBody("hi"), headers);
+		expect(req.harnessId).toBe("prod-a");
+		expect(req.ompSessionId).toBe("sess-1");
+	});
+
+	test("omp session id defaults to empty when the header is absent", () => {
+		expect(parseChatRequest(userBody("hi"), HEADERS).ompSessionId).toBe("");
+	});
+
 	test("tool schemas, names, and descriptions contribute to promptBytes", () => {
 		const parameters = { type: "object", properties: { path: { type: "string" } } };
 		const withTools = parseChatRequest(