auto-model-router 0.13.1 → 0.15.0

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

package/README.md

@@ -710,8 +710,12 @@ escalation signal, error. Three views aggregate it, all from the same
   and model (dispatches, tokens, spend, escalations, errors) as CSV. Also
   `GET /v1/router/export?days=&harness=[&format=json]`; `GET /v1/router/spend?sinceMs=&harness=`
   gives spend over a harness set since an instant, and `GET /v1/router/feedback?days=&harness=`
-  lists verdicts by model and the recent ones with the harness that gave them. These are what
-  a front door such as the team edition reads instead of the ledger file.
+  lists verdicts by model and the recent ones with the harness that gave them, and
+  `GET /v1/router/decisions?harness=&days=|since=&slug=&tier=&limit=` is the decision trail
+  itself, newest first, each turn with its reasons, the classifier's view, forecast against
+  bill, escalation signal and verdicts (`?session=` narrows to one omp session, as `/router
+  why` does). These are what a front door such as the team edition reads instead of the
+  ledger file.
 - `GET /v1/router/report?days=7&harness=<id>` for dashboards (`harness` may be
   a comma-separated set of ids, for a group).
 - `GET /v1/router/summary?harness=<id>` — the daily summary as JSON (`auto=1`
@@ -1365,6 +1369,12 @@ skills: Claude Code's `~/.claude/skills/<name>/` and omp's `~/.omp/agent/skills/
 the bundle no longer carries, and a skill of the same name the member wrote themselves is
 left alone with a note. A remote without skills answers 404 and nothing happens.
 
+A remote whose `/setup/info` says `mcp: true` (a team edition serving shared context) also
+gets a `team-context` MCP server written for omp (`~/.omp/agent/mcp.json`) and Claude Code
+(`~/.claude.json`): `type: http`, the remote's `/mcp`, the member key in the Authorization
+header. Every refresh rewrites it with the current key, like models.yml; other servers in
+those files are untouched, and a remote that stops serving MCP has the entry removed.
+
 ## Direct upstreams: OpenAI, Azure OpenAI, Anthropic, vLLM
 
 OpenRouter and Ollama Cloud are the built-in upstreams. `upstreams:` adds named ones the

package/package.json

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

package/src/cli/connect.ts

@@ -68,6 +68,12 @@ export interface ConnectOptions {
 	exePath?: string;
 	/** The remote's skills bundle, installed into every configured harness that reads user-level skills. */
 	skills?: SkillsBundle;
+	/**
+	 * The remote's MCP endpoint (a team edition serving shared context): written as the
+	 * `team-context` server for omp and Claude Code with the member key, rewritten on every
+	 * refresh like models.yml. `null` removes an entry a previous connect wrote.
+	 */
+	mcp?: { url: string | null };
 	platform: string;
 	pathHas: (bin: string) => boolean;
 }
@@ -80,6 +86,39 @@ export interface ConnectReport {
 	notes: string[];
 	/** What the remote's skills bundle did, when there was one. */
 	skills?: SkillsInstallReport;
+	/** Files that gained (or lost) the team-context MCP server. */
+	mcp?: string[];
+}
+
+/** The name of the MCP server connect manages in a harness's config. */
+export const MCP_SERVER_NAME = "team-context";
+
+/**
+ * Merges the team-context server into an `mcpServers` JSON file (omp's mcp.json, Claude
+ * Code's ~/.claude.json), leaving every other key and server alone; `url` null removes it.
+ * Returns the new text, or null when nothing changes.
+ */
+export function mergeMcpServers(before: string, url: string | null, key: string): string | null {
+	let root: Record<string, unknown> = {};
+	if (before.trim() !== "") {
+		try {
+			const parsed = JSON.parse(before) as unknown;
+			if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+			root = parsed as Record<string, unknown>;
+		} catch {
+			return null; // a file we cannot parse is not ours to rewrite
+		}
+	}
+	const servers = { ...((root.mcpServers as Record<string, unknown> | undefined) ?? {}) };
+	if (url === null) {
+		if (!(MCP_SERVER_NAME in servers)) return null;
+		delete servers[MCP_SERVER_NAME];
+	} else {
+		const next = { type: "http", url, headers: { Authorization: `Bearer ${key}` } };
+		if (JSON.stringify(servers[MCP_SERVER_NAME]) === JSON.stringify(next)) return null;
+		servers[MCP_SERVER_NAME] = next;
+	}
+	return `${JSON.stringify({ ...root, mcpServers: servers }, null, 2)}\n`;
 }
 
 const expand = (raw: string, home: string): string => (raw === "~" || raw.startsWith("~/") || raw.startsWith("~\\") ? join(home, raw.slice(1)) : raw);
@@ -376,6 +415,24 @@ export function connectRemote(o: ConnectOptions): ConnectReport {
 		for (const s of report.skills.skipped) report.notes.push(`skill ${s}`);
 	}
 
+	// 6c. The remote's MCP endpoint (shared context tools), for the harnesses configured above
+	// that read a user-level mcpServers file; the member key travels in the header and is
+	// rewritten with every refresh, like models.yml.
+	if (o.mcp !== undefined) {
+		const files: string[] = [];
+		if (report.configured.some((c) => c.startsWith("omp ("))) files.push(join(agentDir, "mcp.json"));
+		if (report.configured.some((c) => c.startsWith("Claude Code ("))) files.push(join(o.home, ".claude.json"));
+		report.mcp = [];
+		for (const path of files) {
+			const before = existsSync(path) ? readFileSync(path, "utf8") : "";
+			const after = mergeMcpServers(before, o.mcp.url, o.key);
+			if (after === null) continue;
+			write(path, after);
+			report.mcp.push(path);
+		}
+		if (o.mcp.url !== null && files.length > 0) report.configured.push(`MCP (${MCP_SERVER_NAME} → ${o.mcp.url}: ${files.map((f) => f.replaceAll("\\", "/")).join(", ")})`);
+	}
+
 	// 7. Persist the environment.
 	if (o.profile && !o.dryRun) {
 		if (o.platform === "win32") {
@@ -433,6 +490,18 @@ export async function exchangeSetupToken(url: string, token: string, device: str
 	};
 }
 
+/** What a team edition says about itself at /setup/info; a plain router answers nothing. */
+export async function fetchSetupInfo(url: string, fetchImpl: typeof fetch = fetch): Promise<{ mcp: boolean }> {
+	try {
+		const res = await fetchImpl(`${url}/setup/info`, { signal: AbortSignal.timeout(10_000) });
+		if (!res.ok) return { mcp: false };
+		const body = (await res.json()) as { mcp?: unknown };
+		return { mcp: body.mcp === true };
+	} catch {
+		return { mcp: false };
+	}
+}
+
 /** Adds `dir` to the user's PATH on Windows, once, through the registry-backed API rather than setx. */
 function addToUserPathWindows(dir: string): void {
 	const quoted = `'${dir.replaceAll("'", "''")}'`;
@@ -495,6 +564,8 @@ export async function connectCommand(args: CliArgs): Promise<void> {
 	const scopeFlag = flagString(args, "scope");
 	// The remote's skills for the agents on this machine; a remote without any serves 404.
 	const skills = await fetchSkills(url, key, fetchImpl);
+	// Its shared-context MCP endpoint, when it is a team edition serving one.
+	const info = await fetchSetupInfo(url, fetchImpl);
 	const report = connectRemote({
 		url,
 		key,
@@ -515,6 +586,7 @@ export async function connectCommand(args: CliArgs): Promise<void> {
 		...(device === "" ? {} : { device }),
 		...(exePath === null ? {} : { exePath }),
 		...(skills.bundle === null ? {} : { skills: skills.bundle }),
+		mcp: { url: info.mcp ? `${url}/mcp` : null },
 	});
 	if (skills.note !== undefined) report.notes.push(skills.note);
 	if (exePath !== null) console.log(`executable ${exePath}; package files under ${packageDir}`);

package/src/cli/refresh.ts

@@ -14,6 +14,7 @@
  */
 
 import { executablePath, materializePackage, readEmbeddedPackage } from "./embedded.ts";
+import { fetchSetupInfo } from "./connect.ts";
 import { fetchSkills } from "./skills.ts";
 import { homedir } from "node:os";
 import { dirname, resolve } from "node:path";
@@ -99,6 +100,7 @@ export async function refreshAndRewrite(opts: { remote: RemoteRouter; fetchImpl?
 	const exePath = opts.remote.executable ?? executablePath() ?? undefined;
 	// A refresh is when the team's skills reach a machine that has not re-run connect.
 	const skills = await fetchSkills(opts.remote.url, fresh.key, opts.fetchImpl ?? fetch);
+	const info = await fetchSetupInfo(opts.remote.url, opts.fetchImpl ?? fetch);
 	connectRemote({
 		url: opts.remote.url,
 		key: fresh.key,
@@ -121,6 +123,7 @@ export async function refreshAndRewrite(opts: { remote: RemoteRouter; fetchImpl?
 		...(opts.storeDeps !== undefined ? { storeDeps: opts.storeDeps } : {}),
 		...(exePath !== undefined ? { exePath } : {}),
 		...(skills.bundle === null ? {} : { skills: skills.bundle }),
+		mcp: { url: info.mcp ? `${opts.remote.url}/mcp` : null },
 		// undefined keeps whatever scope the managed models.yml block already carries.
 	});
 	return fresh;

package/src/cost/ledger.ts

@@ -65,7 +65,7 @@ const CACHE_RELIABILITY_MEMO_MS = 60_000;
 const DAY_MS = 86_400_000;
 
 // Row shapes below are fixed by our own schema in util/sqlite.ts.
-interface LedgerRow {
+export interface LedgerRow {
 	id: string;
 	created_at_ms: number;
 	conversation_key: string;
@@ -240,7 +240,7 @@ function toLatency(slug: string, row: LatencyRow): ModelLatency | null {
 	return { slug, samples: row.samples, ttftMs: row.ttft_ms, tokensPerSec };
 }
 
-function toEntry(row: LedgerRow): LedgerEntry {
+export function toEntry(row: LedgerRow): LedgerEntry {
 	return {
 		id: row.id,
 		createdAtMs: row.created_at_ms,

package/src/cost/views.ts

@@ -10,7 +10,9 @@
 
 import { providerOfSlug } from "./report.ts";
 import type { Database } from "bun:sqlite";
+import { toEntry, type LedgerRow } from "./ledger.ts";
 import { harnessFilter } from "./report.ts";
+import type { LedgerEntry } from "./types.ts";
 
 /** `null` means every harness; an empty set matches nothing. */
 export type HarnessScope = readonly string[] | null;
@@ -61,6 +63,68 @@ function scope(harness: HarnessScope, column: string): { sql: string[]; bind: Re
 	return { sql: f.sql.map((s) => s.replace(/^harness_id/, column)), bind: f.bind };
 }
 
+/** A ledger entry as the decision explorer shows it: the entry itself plus the verdicts given on it. */
+export type DecisionEntry = LedgerEntry & { feedback: { verdict: "good" | "bad"; note: string; createdAtMs: number }[] };
+
+export interface DecisionFilter {
+	/** Entries at or after this instant; 0 for everything the ledger still holds. */
+	sinceMs: number;
+	/** The harness set; null for every harness, an empty list for none. */
+	harness: HarnessScope;
+	/** At most this many, newest first; 1..1000. */
+	limit?: number;
+	/** Only turns dispatched to (or served by) this slug. */
+	slug?: string;
+	/** Only turns classified at this tier. */
+	tier?: string;
+	/** Only one omp session (`/router why`). */
+	ompSessionId?: string;
+}
+
+/**
+ * Turns, newest first, over a harness set: what `GET /v1/router/decisions` serves and what a
+ * front door reads from the ledger file. Every field the decision trail needs is here — the
+ * reasons, the classifier's view, the cost forecast against the bill, the escalation signal —
+ * and the verdicts `/router good|bad` recorded against each turn ride along.
+ */
+export function decisionEntries(db: Database, filter: DecisionFilter): DecisionEntry[] {
+	const s = scope(filter.harness, "harness_id");
+	if (s === null) return [];
+	const where = ["created_at_ms >= $since", ...s.sql];
+	const bind: Record<string, string | number> = { $since: filter.sinceMs, ...s.bind };
+	if (filter.slug !== undefined && filter.slug !== "") {
+		where.push("(slug = $slug OR served_slug = $slug)");
+		bind.$slug = filter.slug;
+	}
+	if (filter.tier !== undefined && filter.tier !== "") {
+		where.push("tier = $tier");
+		bind.$tier = filter.tier;
+	}
+	if (filter.ompSessionId !== undefined && filter.ompSessionId !== "") {
+		where.push("omp_session_id = $session");
+		bind.$session = filter.ompSessionId;
+	}
+	const limit = Math.min(Math.max(filter.limit ?? 50, 1), 1_000);
+	const rows = db.query(`SELECT * FROM ledger WHERE ${where.join(" AND ")} ORDER BY created_at_ms DESC LIMIT ${limit}`).all(bind) as LedgerRow[];
+	const entries = rows.map(toEntry);
+	if (entries.length === 0) return [];
+	// Verdicts, when the feedback table exists (it does not on a ledger no one has judged).
+	const hasFeedback = (db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'feedback'").get() as { name: string } | null) !== null;
+	const verdicts = new Map<string, DecisionEntry["feedback"]>();
+	if (hasFeedback) {
+		const ids = entries.map((e) => e.id);
+		const marks = ids.map((_, i) => `$f${i}`).join(", ");
+		const fb: Record<string, string> = {};
+		ids.forEach((id, i) => (fb[`$f${i}`] = id));
+		for (const r of db.query(`SELECT ledger_id, verdict, note, created_at_ms FROM feedback WHERE ledger_id IN (${marks}) ORDER BY created_at_ms ASC`).all(fb) as { ledger_id: string; verdict: string; note: string; created_at_ms: number }[]) {
+			const list = verdicts.get(r.ledger_id) ?? [];
+			list.push({ verdict: r.verdict === "good" ? "good" : "bad", note: r.note, createdAtMs: r.created_at_ms });
+			verdicts.set(r.ledger_id, list);
+		}
+	}
+	return entries.map((e) => ({ ...e, feedback: verdicts.get(e.id) ?? [] }));
+}
+
 /** Spend (reported where present, predicted otherwise) since `sinceMs`, digest calls included as the ledger counts them. */
 export function spendUsdSince(db: Database, sinceMs: number, harness: HarnessScope): number {
 	const s = scope(harness, "harness_id");

package/src/index.ts

@@ -28,7 +28,7 @@ Usage: auto-model-router <command> [options]
   stats      Show routed spend, per-model share, and escalation rates
   report     Usage analytics: providers, models, tiers, cost, speed, cache hit rate
   export     One row per day, harness and model as CSV (--json for rows)
-  connect    Point this machine at a remote router (--url with --key[, --refresh-token] or --setup-token <one-time token from a team>; --scope pins one project for the whole machine (default: each workspace's own); --profile persists the environment and, from the compiled executable, PATH; the remote's skills are installed for Claude Code and omp)
+  connect    Point this machine at a remote router (--url with --key[, --refresh-token] or --setup-token <one-time token from a team>; --scope pins one project for the whole machine (default: each workspace's own); --profile persists the environment and, from the compiled executable, PATH; the remote's skills and its MCP endpoint are installed for Claude Code and omp)
   refresh    Trade the refresh token for a new access key and re-write every harness config (--force: even when not near expiry)
   token      Print an access key that is good right now, refreshing first if needed (for a harness key-helper)
   models     Show what each complexity tier would consider, and why

package/src/lib.ts

@@ -22,7 +22,7 @@ export type { DeepPartial } from "./config/load.ts";
 export { buildUsageReport, renderUsageReport, type UsageReport, type ReportTotals } from "./cost/report.ts";
 export { buildDailySummary, renderDailySummary, type DailySummary } from "./cost/summary.ts";
 export { openDb } from "./util/sqlite.ts";
-export { spendUsdSince, feedbackView, exportRows, exportCsv, harnessScopeParam, type HarnessScope, type ExportRow, type FeedbackRow, type FeedbackByModel, type FeedbackView } from "./cost/views.ts";
+export { spendUsdSince, feedbackView, exportRows, exportCsv, decisionEntries, harnessScopeParam, type HarnessScope, type ExportRow, type FeedbackRow, type FeedbackByModel, type FeedbackView, type DecisionEntry, type DecisionFilter } from "./cost/views.ts";
 export { createLedger } from "./cost/ledger.ts";
 export { createFeedbackStore, type FeedbackStore, type FeedbackRecord } from "./cost/feedback.ts";
 export { buildExecutable, collectPackageFiles, executableFileName, hostTarget, isExecutableTarget, EXECUTABLE_TARGETS, type ExecutableTarget, type BuildExecutableResult } from "./cli/build-executable.ts";

package/src/server/http.ts

@@ -10,7 +10,7 @@ import { createDigester } from "./digest.ts";
 import { advise } from "./advise.ts";
 import { TIER_ORDER, type Tier } from "../router/types.ts";
 import { baselinePrices, buildUsageReport, renderUsageReport } from "../cost/report.ts";
-import { exportCsv, exportRows, feedbackView, harnessScopeParam, spendUsdSince } from "../cost/views.ts";
+import { decisionEntries, exportCsv, exportRows, feedbackView, harnessScopeParam, spendUsdSince } from "../cost/views.ts";
 import { anthropicErrorResponse, countAnthropicTokens, createMessagesWire } from "../wire/anthropic/messages.ts";
 import { buildDailySummary, createKv, markSummaryShown, renderDailySummary, summaryDue, summaryHasNews, type SummaryOllama } from "../cost/summary.ts";
 import type { Ledger, ModelTrust } from "../cost/types.ts";
@@ -555,13 +555,24 @@ export function startServer(cfg: RouterConfig): StartedServer {
 					return json({ due: true, summary });
 				}
 				if (req.method === "GET" && url.pathname === "/v1/router/decisions") {
+					// The decision trail, newest first. ?session=<omp session id> narrows to one
+					// session (/router why); ?harness=a,b to a harness set (a team's user or group),
+					// ?since=<ms> or ?days=N to a window, ?slug= and ?tier= to a model or a tier.
 					const rawLimit = url.searchParams.get("limit");
 					const parsed = rawLimit === null ? 50 : Number.parseInt(rawLimit, 10);
 					const limit = Number.isInteger(parsed) ? Math.min(Math.max(parsed, 1), 1_000) : 50;
-					// ?session=<omp session id> narrows to one session (/router why).
-					const session = url.searchParams.get("session") ?? "";
-					const entries = session === "" ? ledger.recentEntries(limit) : (ledger.entriesForSession?.(session, limit) ?? []);
-					return json({ entries: entries.map((e) => ({ ...e, feedback: feedback.forLedgerId(e.id) })) });
+					const sinceRaw = Number.parseInt(url.searchParams.get("since") ?? "", 10);
+					const daysRaw = url.searchParams.get("days");
+					const sinceMs = Number.isFinite(sinceRaw) ? sinceRaw : daysRaw === null ? 0 : Date.now() - clampDays(daysRaw, 30) * 86_400_000;
+					const entries = decisionEntries(db, {
+						sinceMs,
+						harness: harnessScopeParam(url.searchParams.get("harness")),
+						limit,
+						slug: url.searchParams.get("slug") ?? "",
+						tier: url.searchParams.get("tier") ?? "",
+						ompSessionId: url.searchParams.get("session") ?? "",
+					});
+					return json({ entries });
 				}
 				if (url.pathname === "/v1/router/override") {
 					// Per-session pin / tier overrides from omp. GET shows, POST sets or clears.

package/test/mcp-entry.test.ts

@@ -0,0 +1,157 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { connectRemote, fetchSetupInfo, MCP_SERVER_NAME, mergeMcpServers } from "../src/cli/connect.ts";
+import { refreshAndRewrite } from "../src/cli/refresh.ts";
+import { parseRemoteRouter } from "../omp-extension/remote-logic.ts";
+
+const NL = "\n";
+const read = (p: string): Record<string, unknown> => JSON.parse(readFileSync(p, "utf8")) as Record<string, unknown>;
+const servers = (p: string): Record<string, unknown> => (read(p).mcpServers as Record<string, unknown>) ?? {};
+const auth = (p: string): string => (servers(p)[MCP_SERVER_NAME] as { headers: { Authorization: string } }).headers.Authorization;
+
+describe("mergeMcpServers", () => {
+	test("adds the team-context server next to the others and keeps every other key", () => {
+		const before = JSON.stringify({ $schema: "https://x/mcp-schema.json", mcpServers: { agentdox: { type: "http", url: "http://localhost:3003/mcp" } }, other: 1 });
+		const after = mergeMcpServers(before, "https://team.example/mcp", "amrt_k");
+		expect(after).not.toBeNull();
+		const doc = JSON.parse(after!) as Record<string, unknown>;
+		expect(doc.$schema).toBe("https://x/mcp-schema.json");
+		expect(doc.other).toBe(1);
+		expect(doc.mcpServers).toEqual({
+			agentdox: { type: "http", url: "http://localhost:3003/mcp" },
+			[MCP_SERVER_NAME]: { type: "http", url: "https://team.example/mcp", headers: { Authorization: "Bearer amrt_k" } },
+		});
+		expect(after!.endsWith("\n")).toBe(true);
+	});
+
+	test("an empty or missing file becomes a fresh mcpServers document", () => {
+		expect(JSON.parse(mergeMcpServers("", "https://t/mcp", "k")!)).toEqual({ mcpServers: { [MCP_SERVER_NAME]: { type: "http", url: "https://t/mcp", headers: { Authorization: "Bearer k" } } } });
+		expect(JSON.parse(mergeMcpServers("  \n", "https://t/mcp", "k")!)).toHaveProperty("mcpServers");
+	});
+
+	test("is idempotent, removes on null, and leaves a file it cannot parse alone", () => {
+		const one = mergeMcpServers("", "https://t/mcp", "k")!;
+		expect(mergeMcpServers(one, "https://t/mcp", "k")).toBeNull(); // unchanged
+		expect(mergeMcpServers(one, "https://t/mcp", "k2")).not.toBeNull(); // a new key rewrites
+		const removed = mergeMcpServers(one, null, "k")!;
+		expect(JSON.parse(removed)).toEqual({ mcpServers: {} });
+		expect(mergeMcpServers(removed, null, "k")).toBeNull(); // nothing to remove
+		expect(mergeMcpServers("{ not json", "https://t/mcp", "k")).toBeNull();
+		expect(mergeMcpServers("[1,2]", "https://t/mcp", "k")).toBeNull();
+	});
+});
+
+describe("connect writes the team MCP endpoint", () => {
+	function fixture(): { home: string; agent: string; env: Record<string, string> } {
+		const home = mkdtempSync(join(tmpdir(), "amr-mcp-connect-"));
+		mkdirSync(join(home, ".claude"), { recursive: true });
+		const agent = join(home, ".omp", "agent");
+		mkdirSync(agent, { recursive: true });
+		writeFileSync(join(agent, "config.yml"), `extensions: []${NL}`, "utf8");
+		const env = { HOME: home, PI_CODING_AGENT_DIR: agent, AUTO_MODEL_ROUTER_HOME: join(home, ".auto-model-router"), HERMES_HOME: join(home, "no-hermes") };
+		return { home, agent, env };
+	}
+
+	test("into omp mcp.json and Claude Code ~/.claude.json, only for the harnesses it configured", () => {
+		const { home, agent, env } = fixture();
+		try {
+			// Pre-existing servers and unrelated settings survive.
+			writeFileSync(join(agent, "mcp.json"), JSON.stringify({ $schema: "s", mcpServers: { agentdox: { type: "http", url: "http://localhost:3003/mcp" } } }, null, 2));
+			writeFileSync(join(home, ".claude.json"), JSON.stringify({ claudeAiMcpEverConnected: true, mcpServers: {} }));
+			const r = connectRemote({ url: "https://team.example", key: "amrt_k", userId: "u", name: "Ada", profile: false, dryRun: false, only: ["omp", "claude"], env, home, packageDir: "/pkg", mcp: { url: "https://team.example/mcp" }, platform: "linux", pathHas: () => false });
+			expect(r.mcp?.length).toBe(2);
+			expect(r.configured.some((c) => c.startsWith(`MCP (${MCP_SERVER_NAME} → https://team.example/mcp`))).toBe(true);
+			const omp = read(join(agent, "mcp.json"));
+			expect(omp.$schema).toBe("s");
+			expect(servers(join(agent, "mcp.json"))).toEqual({
+				agentdox: { type: "http", url: "http://localhost:3003/mcp" },
+				[MCP_SERVER_NAME]: { type: "http", url: "https://team.example/mcp", headers: { Authorization: "Bearer amrt_k" } },
+			});
+			const claude = read(join(home, ".claude.json"));
+			expect(claude.claudeAiMcpEverConnected).toBe(true);
+			expect(servers(join(home, ".claude.json"))[MCP_SERVER_NAME]).toEqual({ type: "http", url: "https://team.example/mcp", headers: { Authorization: "Bearer amrt_k" } });
+
+			// A second connect with the same key changes nothing.
+			const r2 = connectRemote({ url: "https://team.example", key: "amrt_k", userId: "u", name: "Ada", profile: false, dryRun: false, only: ["omp", "claude"], env, home, packageDir: "/pkg", mcp: { url: "https://team.example/mcp" }, platform: "linux", pathHas: () => false });
+			expect(r2.mcp).toEqual([]);
+
+			// Only Claude Code asked for: the omp file is not touched even though it exists.
+			rmSync(join(agent, "mcp.json"));
+			const r3 = connectRemote({ url: "https://team.example", key: "amrt_k3", userId: "u", name: "Ada", profile: false, dryRun: false, only: ["claude"], env, home, packageDir: "/pkg", mcp: { url: "https://team.example/mcp" }, platform: "linux", pathHas: () => false });
+			expect(r3.mcp).toEqual([join(home, ".claude.json")]);
+			expect(existsSync(join(agent, "mcp.json"))).toBe(false);
+			expect(auth(join(home, ".claude.json"))).toBe("Bearer amrt_k3");
+
+			// A remote that stops serving MCP has the entry removed; the neighbours stay.
+			const r4 = connectRemote({ url: "https://team.example", key: "amrt_k3", userId: "u", name: "Ada", profile: false, dryRun: false, only: ["claude"], env, home, packageDir: "/pkg", mcp: { url: null }, platform: "linux", pathHas: () => false });
+			expect(r4.mcp).toEqual([join(home, ".claude.json")]);
+			expect(servers(join(home, ".claude.json"))).toEqual({});
+			expect(read(join(home, ".claude.json")).claudeAiMcpEverConnected).toBe(true);
+			expect(r4.configured.some((c) => c.startsWith("MCP ("))).toBe(false);
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+	});
+
+	test("a dry run reports the files without writing them; no mcp option leaves them alone", () => {
+		const { home, agent, env } = fixture();
+		try {
+			const r = connectRemote({ url: "https://team.example", key: "amrt_k", userId: "u", name: "Ada", profile: false, dryRun: true, only: ["omp"], env, home, packageDir: "/pkg", mcp: { url: "https://team.example/mcp" }, platform: "linux", pathHas: () => false });
+			expect(r.mcp).toEqual([join(agent, "mcp.json")]);
+			expect(existsSync(join(agent, "mcp.json"))).toBe(false);
+			const r2 = connectRemote({ url: "https://team.example", key: "amrt_k", userId: "u", name: "Ada", profile: false, dryRun: false, only: ["omp"], env, home, packageDir: "/pkg", platform: "linux", pathHas: () => false });
+			expect(r2.mcp).toBeUndefined();
+			expect(existsSync(join(agent, "mcp.json"))).toBe(false);
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+	});
+
+	test("refresh rewrites the entry with the new key, asking the remote whether it still serves MCP", async () => {
+		const { home, agent, env } = fixture();
+		const routerHome = env.AUTO_MODEL_ROUTER_HOME!;
+		try {
+			connectRemote({ url: "https://team.example", key: "amrt_old", userId: "u_ada", name: "Ada", refreshToken: "amrr_r1", keyExpiresAtMs: 1, refreshExpiresAtMs: 2, profile: false, dryRun: false, only: ["omp"], env, home, packageDir: process.cwd(), mcp: { url: "https://team.example/mcp" }, platform: "linux", pathHas: () => false });
+			expect(auth(join(agent, "mcp.json"))).toBe("Bearer amrt_old");
+			const seen: string[] = [];
+			const fetchImpl = (async (input: string | URL | Request) => {
+				const url = String(input);
+				seen.push(url);
+				if (url.endsWith("/setup/info")) return Response.json({ version: "0.18.0", mcp: true });
+				if (url.endsWith("/setup/skills")) return new Response("", { status: 404 });
+				return Response.json({ key: "amrt_new", keyExpiresAtMs: 50, refreshToken: "amrr_r2", refreshExpiresAtMs: 90 });
+			}) as unknown as typeof fetch;
+			const remote = parseRemoteRouter(readFileSync(join(routerHome, "remote.json"), "utf8"))!;
+			await refreshAndRewrite({ remote, fetchImpl, home, packageDir: process.cwd(), env, platform: "linux", pathHas: () => false, routerHome });
+			expect(seen.some((u) => u === "https://team.example/setup/info")).toBe(true);
+			expect(servers(join(agent, "mcp.json"))[MCP_SERVER_NAME]).toEqual({ type: "http", url: "https://team.example/mcp", headers: { Authorization: "Bearer amrt_new" } });
+			// The remote no longer serves MCP (a plain router answers 404): the entry goes.
+			const plain = (async (input: string | URL | Request) => {
+				const url = String(input);
+				if (url.endsWith("/setup/info") || url.endsWith("/setup/skills")) return new Response("", { status: 404 });
+				return Response.json({ key: "amrt_new2", keyExpiresAtMs: 60, refreshToken: "amrr_r3", refreshExpiresAtMs: 99 });
+			}) as unknown as typeof fetch;
+			const remote2 = parseRemoteRouter(readFileSync(join(routerHome, "remote.json"), "utf8"))!;
+			await refreshAndRewrite({ remote: remote2, fetchImpl: plain, home, packageDir: process.cwd(), env, platform: "linux", pathHas: () => false, routerHome });
+			expect(servers(join(agent, "mcp.json"))).toEqual({});
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+	});
+});
+
+describe("fetchSetupInfo", () => {
+	test("reads mcp from a team, and answers false for a plain router, a bad body or a dead remote", async () => {
+		expect(await fetchSetupInfo("https://t", (async () => Response.json({ mcp: true })) as unknown as typeof fetch)).toEqual({ mcp: true });
+		expect(await fetchSetupInfo("https://t", (async () => Response.json({ mcp: "yes" })) as unknown as typeof fetch)).toEqual({ mcp: false });
+		expect(await fetchSetupInfo("https://t", (async () => new Response("", { status: 404 })) as unknown as typeof fetch)).toEqual({ mcp: false });
+		expect(await fetchSetupInfo("https://t", (async () => new Response("<html>", { status: 200 })) as unknown as typeof fetch)).toEqual({ mcp: false });
+		expect(
+			await fetchSetupInfo("https://t", (async () => {
+				throw new Error("down");
+			}) as unknown as typeof fetch),
+		).toEqual({ mcp: false });
+	});
+});

package/test/views.test.ts

@@ -148,6 +148,12 @@ describe("view routes", () => {
 		expect((await fetch(`http://127.0.0.1:${handle.server.port}/v1/router/spend?sinceMs=0`)).status).toBe(401);
 		expect((await get("/v1/router/spend")).status).toBe(400);
 		expect(((await (await get(`/v1/router/spend?sinceMs=${Date.now() - DAY}&harness=u_x`)).json()) as { usd: number }).usd).toBeCloseTo(0.25, 6);
+		// The decision trail over a harness set: a team asks with its user or group ids and sees only theirs.
+		const mine = (await (await get("/v1/router/decisions?harness=u_x&days=1")).json()) as { entries: { id: string; feedback: unknown[] }[] };
+		expect(mine.entries.map((e) => e.id)).toEqual(["r1"]);
+		expect(mine.entries[0]?.feedback).toEqual([]);
+		expect((((await (await get("/v1/router/decisions?harness=u_other&days=1")).json()) as { entries: unknown[] }).entries)).toEqual([]);
+		expect((((await (await get("/v1/router/decisions?limit=1")).json()) as { entries: { id: string }[] }).entries.map((e) => e.id))).toEqual(["r1"]); // no filter: everything, as before
 		expect(((await (await get(`/v1/router/spend?sinceMs=${Date.now() - DAY}&harness=u_other`)).json()) as { usd: number }).usd).toBe(0);
 		const fb = (await (await get("/v1/router/feedback?days=7")).json()) as { days: number; byModel: unknown[]; recent: unknown[] };
 		expect(fb).toEqual({ days: 7, byModel: [], recent: [] });
@@ -159,3 +165,28 @@ describe("view routes", () => {
 		expect(js.rows[0]?.harnessId).toBe("u_x");
 	});
 });
+
+describe("decision entries", () => {
+	const db = seeded();
+	const since = NOW - DAY;
+
+	test("newest first over a harness set, with the verdicts given on each turn", () => {
+		const { decisionEntries } = require("../src/cost/views.ts") as typeof import("../src/cost/views.ts");
+		const ada = decisionEntries(db, { sinceMs: since, harness: ["u_ada"] });
+		expect(ada.map((e) => e.id)).toEqual(["l1", "l2"]); // same instant in the fixture; insertion order within it is stable
+		expect(ada.find((e) => e.id === "l1")?.feedback).toEqual([{ verdict: "good", note: "", createdAtMs: NOW - 1000 }]);
+		expect(ada.find((e) => e.id === "l2")?.escalationSignal).toBe("circular");
+		// Everyone, within the window: the 40-day-old row stays out; the digest row is a turn like any other.
+		expect(decisionEntries(db, { sinceMs: since, harness: null }).map((e) => e.id).sort()).toEqual(["l1", "l2", "l3", "l4"]);
+		expect(decisionEntries(db, { sinceMs: 0, harness: null }).length).toBe(5);
+		// A model, a tier, nobody, and a cap.
+		expect(decisionEntries(db, { sinceMs: since, harness: null, slug: "ollama/glm-5.3-flash" }).map((e) => e.id).sort()).toEqual(["l3", "l4"]);
+		expect(decisionEntries(db, { sinceMs: since, harness: null, tier: "hard" })).toEqual([]);
+		expect(decisionEntries(db, { sinceMs: since, harness: [] })).toEqual([]);
+		expect(decisionEntries(db, { sinceMs: since, harness: null, limit: 1 }).length).toBe(1);
+		// The error on l3 and its note ride along, so an explorer can show why a turn went wrong.
+		const bob = decisionEntries(db, { sinceMs: since, harness: ["u_bob"], slug: "ollama/glm-5.3-flash" });
+		expect(bob.find((e) => e.id === "l3")?.error).toBe("boom");
+		expect(bob.find((e) => e.id === "l3")?.feedback[0]?.note).toBe("looped");
+	});
+});