auto-model-router 0.6.0 → 0.6.2

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

package/README.md

@@ -1149,6 +1149,13 @@ What happens once it is on:
   cooldown.
 - **Ollama reports no cost per response**, so the ledger records the
   predicted figure at list price for those rows.
+- **Ollama Cloud alone works.** With `ollama.enabled` and no OpenRouter key,
+  the router routes over Ollama's models only. OpenRouter's catalog is public,
+  so it is still read (the twins' benchmarks and capabilities come from it),
+  but its models are never candidates; `/health` lists what can serve under
+  `serving` (`["ollama"]`, `["openrouter","ollama"]`, …). Tier coverage is
+  whatever Ollama's catalog spans; a tier with nothing in it relaxes to the
+  best available band, as it does under any other narrowing.
 
 Ollama's compatibility layer differs from OpenRouter's in a few ways the
 router handles for you: no `models[]` fallback cascade, no `tool_choice`,
@@ -1247,18 +1254,18 @@ override already pinned one. Every field is optional; a malformed header is
 ignored rather than failing the turn. The decision trail records what the
 policy changed (`policy: …`).
 
-## Joining a team router
-
-The team edition's install script runs `auto-model-router join --url <team> --key <key>`
-on a member's machine. It writes `<router home>/team.json`, after which the omp
-extensions run in **team-client mode**: the embed extension registers the team endpoint as
-omp's provider with the member's key instead of binding a local router, and the toast,
-`/router` hub and digest extensions talk to the team. Nothing is classified or selected
-locally; the team router is the router. The same command adds the extensions to omp's
-config, installs the Hermes plugins and points them at the team, adds the Codex provider
-and the Aider settings, and prints (or with `--profile` persists) the environment lines
-for Claude Code. `--harness omp,hermes` restricts it; `--dry-run` shows the changes.
-Delete `team.json` to leave team mode.
+## Using a remote router
+
+`auto-model-router connect --url <router> --key <key>` points this machine at a router
+running elsewhere: a shared instance on a LAN, or a team edition front door. It writes
+`<router home>/remote.json`, after which the omp extensions run in **remote mode**: the
+embed extension registers the remote router as omp's provider with that key instead of
+binding a local one, and the toast, `/router` hub and digest extensions talk to it. Nothing
+is classified or selected locally; the remote router is the router. The same command adds
+the extensions to omp's config, installs the Hermes plugins and points them at the remote,
+adds the Codex provider and the Aider settings, and prints (or with `--profile` persists)
+the environment lines for Claude Code. `--harness omp,hermes` restricts it; `--dry-run`
+shows the changes. Delete `remote.json` to go back to a local router. (`join` is an alias.)
 
 ## Multiple coding harnesses, one router
 

package/hermes-plugin/__init__.py

@@ -30,11 +30,11 @@ from providers.base import ProviderProfile
 
 # Fixed port the standalone router binds. Hermes points at this URL.
 PORT = int(os.environ.get("AUTO_MODEL_ROUTER_PORT", "8788"))
-# Team mode: `auto-model-router join` sets AUTO_MODEL_ROUTER_URL (and the key) in
-# $HERMES_HOME/.env; the plugin then points Hermes at the team endpoint and
+# Remote mode: `auto-model-router connect` sets AUTO_MODEL_ROUTER_URL (and the
+# key) in $HERMES_HOME/.env; the plugin then points Hermes at that router and
 # spawns nothing locally.
-TEAM_URL = os.environ.get("AUTO_MODEL_ROUTER_URL", "").rstrip("/")
-BASE_URL = f"{TEAM_URL}/v1" if TEAM_URL else f"http://127.0.0.1:{PORT}/v1"
+REMOTE_URL = os.environ.get("AUTO_MODEL_ROUTER_URL", "").rstrip("/")
+BASE_URL = f"{REMOTE_URL}/v1" if REMOTE_URL else f"http://127.0.0.1:{PORT}/v1"
 
 # The router binary, provided by `npm install -g auto-model-router`.
 BIN = "auto-model-router"
@@ -98,7 +98,7 @@ def _spawn_router() -> None:
     raise RuntimeError(f"auto-model-router did not come up on port {PORT}")
 
 
-if not TEAM_URL:
+if not REMOTE_URL:
     _spawn_router()
 profile = ProviderProfile(
     name="auto-model-router",

package/omp-extension/remote-logic.ts

@@ -0,0 +1,93 @@
+/**
+ * Remote-router mode for the omp extensions. `auto-model-router connect`
+ * writes `<router home>/remote.json`; when it exists the embed extension
+ * registers the REMOTE router as omp's provider instead of binding a local
+ * one, and the toast, hub and digest extensions talk to it with the key.
+ * Nothing is classified or selected locally: the remote router is the router.
+ * A shared router on a LAN and the team edition are both remotes.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+export const REMOTE_FILE = "remote.json";
+/** The name the first release used; still read so nothing breaks on upgrade. */
+const LEGACY_FILE = "team.json";
+
+export interface RemoteRouter {
+	/** The remote router, no trailing slash, e.g. https://router.example.com */
+	url: string;
+	/** The key that router expects (`server.apiKey`, or a team user key). */
+	key: string;
+	userId: string;
+	name: string;
+	joinedAtMs: number;
+}
+
+export function remoteFilePath(routerHome: string): string {
+	return join(routerHome, REMOTE_FILE);
+}
+
+/** Parses remote.json defensively; anything malformed ⇒ not in remote mode. */
+export function parseRemoteRouter(text: string): RemoteRouter | null {
+	try {
+		const raw = JSON.parse(text) as Record<string, unknown>;
+		if (typeof raw.url !== "string" || typeof raw.key !== "string" || raw.url === "" || raw.key === "") return null;
+		return { url: raw.url.replace(/\/+$/, ""), key: raw.key, userId: typeof raw.userId === "string" ? raw.userId : "", name: typeof raw.name === "string" ? raw.name : "", joinedAtMs: typeof raw.joinedAtMs === "number" ? raw.joinedAtMs : 0 };
+	} catch {
+		return null;
+	}
+}
+
+export function readRemoteRouter(routerHome: string): RemoteRouter | null {
+	for (const path of [remoteFilePath(routerHome), join(routerHome, LEGACY_FILE)]) {
+		if (!existsSync(path)) continue;
+		try {
+			return parseRemoteRouter(readFileSync(path, "utf8"));
+		} catch {
+			return null;
+		}
+	}
+	return null;
+}
+
+/** The virtual models a remote router serves; costs are the fallback blend so omp can show estimates. */
+export const REMOTE_MODELS: readonly { id: string; name: string }[] = [
+	{ id: "auto", name: "auto (remote)" },
+	{ id: "auto-cheap", name: "auto-cheap (remote)" },
+	{ id: "auto-max", name: "auto-max (remote)" },
+];
+
+/**
+ * omp's provider registration for remote mode: the remote's /v1 with the key,
+ * the session and subagent tags, and the virtual models. Costs are USD per
+ * million tokens, like the embedded config.
+ */
+export function remoteProviderRegistration(remote: RemoteRouter, sessionId: string, subagent: boolean, blend: { inputPerMtok: number; outputPerMtok: number }): {
+	baseUrl: string;
+	api: string;
+	apiKey: string;
+	headers: Record<string, string>;
+	models: { id: string; name: string; api: string; reasoning: boolean; input: string[]; contextWindow: number; maxTokens: number; cost: { input: number; output: number; cacheRead: number; cacheWrite: number } }[];
+} {
+	const headers: Record<string, string> = {};
+	if (sessionId !== "") headers["X-Omp-Session"] = sessionId;
+	if (subagent) headers["X-Omp-Subagent"] = "1";
+	const round = (v: number): number => Math.round(v * 1e4) / 1e4;
+	return {
+		baseUrl: `${remote.url}/v1`,
+		api: "openai-completions",
+		apiKey: remote.key,
+		headers,
+		models: REMOTE_MODELS.map((m) => ({
+			id: m.id,
+			name: m.name,
+			api: "openai-completions",
+			reasoning: false,
+			input: ["text", "image"],
+			contextWindow: 200_000,
+			maxTokens: 32_000,
+			cost: { input: round(blend.inputPerMtok), output: round(blend.outputPerMtok), cacheRead: round(blend.inputPerMtok * 0.1), cacheWrite: round(blend.inputPerMtok * 1.25) },
+		})),
+	};
+}

package/omp-extension/report-logic.ts

@@ -104,6 +104,8 @@ export function renderSoftFailureSpikes(spikes: readonly SoftFailureSpikeView[]
 export interface HealthSnapshot {
 	status?: string;
 	apiKeyConfigured?: boolean;
+	/** Upstreams that can serve a turn right now (`openrouter` needs its key; `ollama` needs to be on and out of cooldown). */
+	serving?: string[];
 	apiKeySource?: string;
 	agentdox?: { url?: string; defaultScope?: string; recordTurns?: boolean } | null;
 	ollama?: {
@@ -133,7 +135,9 @@ const mins = (ms: number): string => (ms >= 3_600_000 ? `${(ms / 3_600_000).toFi
 /** Renders `/health` as a few plain lines for the transcript. */
 export function renderStatus(baseUrl: string, h: HealthSnapshot, nowMs = Date.now()): string {
 	const out: string[] = [`auto-model-router at ${baseUrl}: ${h.status ?? "unknown"}`];
-	out.push(`openrouter: key ${h.apiKeyConfigured === true ? `configured (${h.apiKeySource ?? "?"})` : "MISSING"}`);
+	const orKey = h.apiKeyConfigured === true ? `configured (${h.apiKeySource ?? "?"})` : h.serving?.includes("ollama") === true ? "missing · routing over ollama cloud only" : "MISSING";
+	out.push(`openrouter: key ${orKey}`);
+	if (h.serving !== undefined && h.serving.length === 0) out.push("serving: NOTHING (no OpenRouter key and Ollama off or cooling down)");
 	const c = h.catalog;
 	if (c !== undefined && c !== null) {
 		const shrink = c.shrink !== undefined && c.shrink !== null ? ` · SHRANK ${c.shrink.fromModels ?? "?"} -> ${c.shrink.toModels ?? "?"}` : "";

package/omp-extension/router-embed.ts

@@ -26,7 +26,7 @@ import { join } from "node:path";
 import { ompModelsPath } from "../src/cli/config-cmd.ts";
 import { loadConfig } from "../src/config/load.ts";
 import { startServer } from "../src/server/http.ts";
-import { readTeamClient, teamProviderRegistration } from "./team-logic.ts";
+import { readRemoteRouter, remoteProviderRegistration } from "./remote-logic.ts";
 import type { StartedServer } from "../src/server/http.ts";
 import type { RouterConfig } from "../src/config/types.ts";
 
@@ -168,14 +168,14 @@ export default function (pi: ExtensionAPI): void {
 		// notifications to that exact session (see router-toast.ts).
 		const sessionId = ctx.sessionManager.getSessionId();
 
-		// Team-client mode (`auto-model-router join`): the team endpoint is the
-		// router. Register it as the provider with the member's key and bind
-		// nothing locally; the other extensions find the team through team.json.
-		const team = readTeamClient(routerHome());
-		if (team !== null) {
-			pi.registerProvider(EMBED_PROVIDER_ID, teamProviderRegistration(team, sessionId, !ctx.hasUI, cfg.ledger.fallbackBlend));
-			pi.setLabel(`auto-model-router team (${team.url.replace(/^https?:\/\//, "")})`);
-			writeEmbedLog(`team mode url=${team.url} user=${team.userId} session=${sessionId}`);
+		// Remote mode (`auto-model-router connect`): a router elsewhere is the
+		// router. Register it as the provider with its key and bind nothing
+		// locally; the other extensions find it through remote.json.
+		const remote = readRemoteRouter(routerHome());
+		if (remote !== null) {
+			pi.registerProvider(EMBED_PROVIDER_ID, remoteProviderRegistration(remote, sessionId, !ctx.hasUI, cfg.ledger.fallbackBlend));
+			pi.setLabel(`auto-model-router remote (${remote.url.replace(/^https?:\/\//, "")})`);
+			writeEmbedLog(`remote mode url=${remote.url} user=${remote.userId} session=${sessionId}`);
 			return;
 		}
 

package/omp-extension/router-toast.ts

@@ -68,7 +68,7 @@ export default function (pi: ExtensionAPI): void {
 				// The embedded router binds a free OS-assigned port, so the URL
 				// is resolved fresh each tick from the port file the embed
 				// extension writes at session_start.
-				// Team-client mode resolves to the team endpoint with the member key.
+				// Remote mode resolves to the remote router with its key.
 				const routerUrl = routerBaseUrl();
 
 				let res: Response;

package/omp-extension/router-url.ts

@@ -15,7 +15,7 @@ import { join } from "node:path";
 import { parse as parseYaml } from "yaml";
 
 import { embedPortPath, readEmbedPort } from "./embed-logic.ts";
-import { readTeamClient } from "./team-logic.ts";
+import { readRemoteRouter } from "./remote-logic.ts";
 import { resolveRouterUrl } from "./toast-logic.ts";
 
 /** `$AUTO_MODEL_ROUTER_HOME` with `~` expanded, default `~/.auto-model-router`. */
@@ -37,9 +37,9 @@ export function readRouterConfigText(): string | null {
 
 /** Base URL of the router this omp process should talk to. */
 export function routerBaseUrl(): string {
-	// Team-client mode: the team endpoint is the router.
-	const team = readTeamClient(routerHome());
-	if (team !== null) return team.url;
+	// Remote mode: the router elsewhere is the router.
+	const remote = readRemoteRouter(routerHome());
+	if (remote !== null) return remote.url;
 	return resolveRouterUrl(
 		process.env.AUTO_MODEL_ROUTER_URL,
 		readRouterConfigText(),
@@ -51,8 +51,8 @@ export function routerBaseUrl(): string {
 
 /** Authorization header for a router configured with `server.apiKey`. */
 export function routerAuthHeaders(): Record<string, string> {
-	const team = readTeamClient(routerHome());
-	if (team !== null) return { authorization: `Bearer ${team.key}` };
+	const remote = readRemoteRouter(routerHome());
+	if (remote !== null) return { authorization: `Bearer ${remote.key}` };
 	const key = process.env.AUTO_MODEL_ROUTER_API_KEY;
 	return key === undefined || key === "" ? {} : { authorization: `Bearer ${key}` };
 }

package/package.json

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

package/src/catalog/composite.ts

@@ -10,6 +10,13 @@
  * Ollama models are left out entirely: a candidate that will 402 or 429 is
  * not a candidate, and hiding it here means the turn routes straight to an
  * OpenRouter model instead of paying a doomed dispatch first.
+ *
+ * The same rule covers OpenRouter: without a key its models cannot be
+ * dispatched (its catalog is public, so they would still be listed), and
+ * `serveOpenRouter` leaves them out so an Ollama-only deployment routes over
+ * Ollama Cloud alone instead of picking models that 401 at dispatch time. The
+ * OpenRouter catalog is still fetched: Ollama's models borrow their twins'
+ * benchmarks and capabilities from it.
  */
 
 import type { OllamaAvailability } from "../upstream/ollama.ts";
@@ -25,6 +32,8 @@ export interface CompositeBias {
 	usage: OllamaUsageSource;
 	/** When given, read on every use instead of the static pair, so a config hot reload applies. */
 	live?: () => { costBias: number; biasUntilUsage: number };
+	/** False when OpenRouter cannot dispatch (no key): its models are listed for metadata only, never served. Default true. */
+	serveOpenRouter?: () => boolean;
 }
 
 export function createCompositeCatalog(
@@ -36,6 +45,7 @@ export function createCompositeCatalog(
 	let lastBase: CatalogSnapshot | null = null;
 	let lastOllama: readonly CatalogModel[] = [];
 	let lastAvailable = true;
+	let lastServeBase = true;
 	let lastBias = 1;
 	let merged: CatalogSnapshot | null = null;
 
@@ -47,13 +57,15 @@ export function createCompositeCatalog(
 
 	function combine(base: CatalogSnapshot, models: readonly CatalogModel[]): CatalogSnapshot {
 		const available = availability.available();
+		const serveBase = bias.serveOpenRouter?.() ?? true;
 		const providerBias = currentBias();
-		if (merged !== null && base === lastBase && models === lastOllama && available === lastAvailable && providerBias === lastBias) return merged;
+		if (merged !== null && base === lastBase && models === lastOllama && available === lastAvailable && serveBase === lastServeBase && providerBias === lastBias) return merged;
 		lastBase = base;
 		lastOllama = models;
 		lastAvailable = available;
+		lastServeBase = serveBase;
 		lastBias = providerBias;
-		merged = mergeSnapshots(base, available ? models : []);
+		merged = serveBase ? mergeSnapshots(base, available ? models : []) : { ...base, models: available ? [...models] : [] };
 		// A fresh object either way once anything changed; stamp the live bias so
 		// candidate scoring reads it off the snapshot it is ranking.
 		merged = { ...merged, providerBias: { ollama: providerBias } };

package/src/cli/args.ts

@@ -33,6 +33,7 @@ const COMMANDS: Record<string, true> = {
 	stats: true,
 	report: true,
 	export: true,
+	connect: true,
 	join: true,
 	models: true,
 	explain: true,

package/src/cli/{join.ts → connect.ts}

@@ -1,12 +1,12 @@
 /**
- * `auto-model-router join --url <team> --key <key>`: make this machine a
- * member of a team router. Writes `<router home>/team.json` (the omp
- * extensions then run in team-client mode and never bind a local router),
- * and configures every harness it finds:
+ * `auto-model-router connect --url <router> --key <key>`: point this machine
+ * at a remote router (a shared one on a LAN, or the team edition). Writes
+ * `<router home>/remote.json` (the omp extensions then run in remote mode and
+ * never bind a local router), and configures every harness it finds:
  *
  *   omp         the four extensions are added to ~/.omp/agent/config.yml
  *   Hermes      the provider plugin and the native plugin are copied into
- *               $HERMES_HOME/plugins and .env points them at the team
+ *               $HERMES_HOME/plugins and .env points them at the remote
  *   Codex       ~/.codex/config.toml gains the auto-model-router provider
  *   Aider       ~/.aider.conf.yml gains the base URL, key and model
  *   Claude Code ANTHROPIC_BASE_URL / ANTHROPIC_API_KEY (printed; --profile persists)
@@ -21,10 +21,10 @@ import { appendFileSync, cpSync, existsSync, mkdirSync, readFileSync, writeFileS
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { teamFilePath } from "../../omp-extension/team-logic.ts";
+import { remoteFilePath } from "../../omp-extension/remote-logic.ts";
 import { flagString, type CliArgs } from "./args.ts";
 
-export interface JoinOptions {
+export interface ConnectOptions {
 	url: string;
 	key: string;
 	userId: string;
@@ -41,8 +41,8 @@ export interface JoinOptions {
 	pathHas: (bin: string) => boolean;
 }
 
-export interface JoinReport {
-	teamFile: string;
+export interface ConnectReport {
+	remoteFile: string;
 	configured: string[];
 	skipped: string[];
 	envLines: string[];
@@ -51,22 +51,22 @@ export interface JoinReport {
 
 const expand = (raw: string, home: string): string => (raw === "~" || raw.startsWith("~/") || raw.startsWith("~\\") ? join(home, raw.slice(1)) : raw);
 
-function routerHomeOf(o: JoinOptions): string {
+function routerHomeOf(o: ConnectOptions): string {
 	return expand(o.env.AUTO_MODEL_ROUTER_HOME ?? join(o.home, ".auto-model-router"), o.home);
 }
 
-function ompAgentDir(o: JoinOptions): string {
+function ompAgentDir(o: ConnectOptions): string {
 	const d = o.env.PI_CODING_AGENT_DIR;
 	return d !== undefined && d !== "" ? expand(d, o.home) : join(o.home, ".omp", "agent");
 }
 
-function hermesHome(o: JoinOptions): string {
+function hermesHome(o: ConnectOptions): string {
 	const d = o.env.HERMES_HOME;
 	if (d !== undefined && d !== "") return expand(d, o.home);
 	return o.platform === "win32" ? join(o.env.LOCALAPPDATA ?? join(o.home, "AppData", "Local"), "hermes") : join(o.home, ".hermes");
 }
 
-const wants = (o: JoinOptions, h: string): boolean => o.only.length === 0 || o.only.includes(h);
+const wants = (o: ConnectOptions, h: string): boolean => o.only.length === 0 || o.only.includes(h);
 
 /** Adds lines to a YAML `extensions:` list by text, keeping everything else byte-identical. */
 export function addExtensions(text: string, paths: readonly string[]): string {
@@ -95,7 +95,7 @@ export function setDotenv(text: string, values: Record<string, string>): string
 export function codexBlock(url: string): string {
 	return `
 [model_providers.auto-model-router]
-name = "auto-model-router (team)"
+name = "auto-model-router (remote)"
 base_url = "${url}/v1"
 env_key = "AUTO_MODEL_ROUTER_API_KEY"
 wire_api = "responses"
@@ -103,18 +103,18 @@ http_headers = { "X-Omp-Harness" = "codex" }
 `;
 }
 
-export function joinTeam(o: JoinOptions): JoinReport {
-	const report: JoinReport = { teamFile: "", configured: [], skipped: [], envLines: [], notes: [] };
+export function connectRemote(o: ConnectOptions): ConnectReport {
+	const report: ConnectReport = { remoteFile: "", configured: [], skipped: [], envLines: [], notes: [] };
 	const write = (path: string, content: string): void => {
 		if (o.dryRun) return;
 		mkdirSync(dirname(path), { recursive: true });
 		writeFileSync(path, content, "utf8");
 	};
 
-	// 1. team.json: what puts the omp extensions into team-client mode.
+	// 1. remote.json: what puts the omp extensions into remote mode.
 	const rh = routerHomeOf(o);
-	report.teamFile = teamFilePath(rh);
-	write(report.teamFile, `${JSON.stringify({ url: o.url, key: o.key, userId: o.userId, name: o.name, joinedAtMs: Date.now() }, null, 2)}\n`);
+	report.remoteFile = remoteFilePath(rh);
+	write(report.remoteFile, `${JSON.stringify({ url: o.url, key: o.key, userId: o.userId, name: o.name, joinedAtMs: Date.now() }, null, 2)}\n`);
 
 	// 2. omp
 	const agentDir = ompAgentDir(o);
@@ -176,40 +176,37 @@ export function joinTeam(o: JoinOptions): JoinReport {
 		} else {
 			const shell = o.env.SHELL ?? "";
 			const rc = shell.includes("zsh") ? join(o.home, ".zshrc") : join(o.home, ".bashrc");
-			const block = `\n# auto-model-router team (added by \`auto-model-router join\`)\n${report.envLines.map((l) => `export ${l}`).join("\n")}\n`;
+			const block = `\n# auto-model-router remote (added by \`auto-model-router connect\`)\n${report.envLines.map((l) => `export ${l}`).join("\n")}\n`;
 			const before = existsSync(rc) ? readFileSync(rc, "utf8") : "";
-			if (!before.includes("# auto-model-router team")) appendFileSync(rc, block, "utf8");
-			else write(rc, before.replace(/\n# auto-model-router team[^\n]*\n(?:export [^\n]*\n)*/, block));
+			if (!before.includes("# auto-model-router remote") && !before.includes("# auto-model-router team")) appendFileSync(rc, block, "utf8");
+			else write(rc, before.replace(/\n# auto-model-router (?:remote|team)[^\n]*\n(?:export [^\n]*\n)*/, block));
 			report.notes.push(`environment appended to ${rc}; open a new shell or source it`);
 		}
 	} else report.notes.push("add the environment lines to your shell profile, or re-run with --profile");
 	return report;
 }
 
-export async function joinCommand(args: CliArgs): Promise<void> {
+export async function connectCommand(args: CliArgs): Promise<void> {
 	const url = (flagString(args, "url") ?? process.env.AUTO_MODEL_ROUTER_URL ?? "").replace(/\/+$/, "");
 	const key = flagString(args, "key") ?? process.env.AUTO_MODEL_ROUTER_API_KEY ?? "";
-	if (url === "" || key === "") throw new Error("join needs --url <team endpoint> and --key <your team key>");
+	if (url === "" || key === "") throw new Error("connect needs --url <remote router> and --key <its key>");
 	const only = (flagString(args, "harness") ?? "").split(",").map((s) => s.trim().toLowerCase()).filter((s) => s !== "");
 	const pathHas = (bin: string): boolean => Bun.which(bin) !== null;
 	const packageDir = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
-	// Verify the key before touching anything.
+	// Verify the key against the route every router serves before touching anything.
 	let name = flagString(args, "name") ?? "";
 	let userId = flagString(args, "user-id") ?? "";
 	try {
-		const res = await fetch(`${url}/me`, { headers: { authorization: `Bearer ${key}` }, signal: AbortSignal.timeout(10_000) });
-		if (res.status === 401) throw new Error("the team rejected this key");
-		if (res.ok) {
-			const me = (await res.json()) as { user?: { id?: string; name?: string } };
-			userId = me.user?.id ?? userId;
-			name = me.user?.name ?? name;
-		}
+		const res = await fetch(`${url}/v1/models`, { headers: { authorization: `Bearer ${key}` }, signal: AbortSignal.timeout(10_000) });
+		if (res.status === 401) throw new Error("the remote router rejected this key");
 	} catch (err) {
 		if (err instanceof Error && err.message.includes("rejected")) throw err;
 		console.log(`warning: could not reach ${url} to verify the key (${err instanceof Error ? err.message : String(err)}); configuring anyway`);
 	}
-	const report = joinTeam({ url, key, userId, name, profile: args.flags.has("profile"), dryRun: args.flags.has("dry-run"), only, env: process.env, home: homedir(), packageDir, platform: process.platform, pathHas });
-	console.log(`${args.flags.has("dry-run") ? "would write" : "wrote"} ${report.teamFile}${name === "" ? "" : ` for ${name}`}`);
+	// HOME wins when set (Git Bash, WSL, CI) so a caller can redirect every write; the OS profile otherwise.
+	const home = process.env.HOME !== undefined && process.env.HOME !== "" ? process.env.HOME : homedir();
+	const report = connectRemote({ url, key, userId, name, profile: args.flags.has("profile"), dryRun: args.flags.has("dry-run"), only, env: process.env, home, packageDir, platform: process.platform, pathHas });
+	console.log(`${args.flags.has("dry-run") ? "would write" : "wrote"} ${report.remoteFile}${name === "" ? "" : ` for ${name}`}`);
 	for (const c of report.configured) console.log(`  configured ${c}`);
 	for (const s of report.skipped) console.log(`  skipped    ${s}`);
 	console.log("environment:");

package/src/index.ts

@@ -12,7 +12,7 @@ import { parseArgv } from "./cli/args.ts";
 import { configCommand } from "./cli/config-cmd.ts";
 import { explainCommand } from "./cli/explain.ts";
 import { exportCommand } from "./cli/export.ts";
-import { joinCommand } from "./cli/join.ts";
+import { connectCommand } from "./cli/connect.ts";
 import { modelsCommand } from "./cli/models.ts";
 import { reportCommand } from "./cli/report.ts";
 import { serveCommand } from "./cli/serve.ts";
@@ -26,7 +26,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)
-  join       Make this machine a member of a team router (--url, --key; --profile persists the environment)
+  connect    Point this machine at a remote router (--url, --key; --profile persists the environment)
   models     Show what each complexity tier would consider, and why
   explain    Route a saved request without dispatching it, and explain the decision
   config     Interactive wizard over the router's own config.yml
@@ -80,8 +80,9 @@ async function main(): Promise<number> {
 		case "export":
 			await exportCommand(args);
 			return 0;
-		case "join":
-			await joinCommand(args);
+		case "connect":
+		case "join": // the first release's name
+			await connectCommand(args);
 			return 0;
 		case "models":
 			await modelsCommand(args);

package/src/server/http.ts

@@ -241,7 +241,8 @@ export function startServer(cfg: RouterConfig): StartedServer {
 	}
 
 	if (cfg.openrouter.apiKey === "") {
-		log.warn("OPENROUTER_API_KEY is not set; /v1/chat/completions will fail at dispatch time");
+		if (ollama !== null) log.warn("no OpenRouter key: routing over Ollama Cloud models only (OpenRouter's catalog is read for metadata, never served)");
+		else log.warn("OPENROUTER_API_KEY is not set and Ollama is off; /v1/chat/completions will fail at dispatch time");
 	}
 	if (ollama !== null) {
 		log.info("ollama cloud upstream enabled", {
@@ -608,6 +609,9 @@ export function startServer(cfg: RouterConfig): StartedServer {
 					return json({
 						status: "ok",
 						apiKeyConfigured: cfg.openrouter.apiKey !== "",
+						// Which upstreams turns can actually be served from: OpenRouter needs
+						// its key; Ollama needs to be on and out of cooldown.
+						serving: [...(cfg.openrouter.apiKey !== "" ? ["openrouter"] : []), ...(ollama !== null && ollama.available() ? ["ollama"] : [])],
 						// Provenance only; never the key itself.
 						apiKeySource: apiKeySource(cfg).source,
 						// Provenance only; never the agentdox token itself.

package/src/server/providers.ts

@@ -55,6 +55,7 @@ export function createProviders(cfg: RouterConfig, db: Database, log: Logger = c
 			biasUntilUsage: cfg.ollama.biasUntilUsage,
 			usage: ollamaUsage,
 			live: () => ({ costBias: cfg.ollama.costBias, biasUntilUsage: cfg.ollama.biasUntilUsage }),
+			serveOpenRouter: () => cfg.openrouter.apiKey !== "",
 		}),
 		ollama,
 		ollamaUsage,

package/test/ollama.test.ts

@@ -398,6 +398,32 @@ describe("multi upstream + composite catalog", () => {
 		expect(catalog.ollamaModels()).toHaveLength(3); // still known, just hidden
 		expect(mergeSnapshots(base, []).models).toBe(base.models);
 	});
+
+	test("without an OpenRouter key only the Ollama models are served; the OpenRouter catalog still feeds metadata and lookups", async () => {
+		const base: CatalogSnapshot = { models: OR_MODELS, fetchedAtMs: 1, keyScoped: false };
+		const openrouter: CatalogSource = { get: async () => base, refresh: async () => base, peek: () => base, find: (s) => OR_MODELS.find((m) => m.slug === s) };
+		const ollamaModels = buildOllamaModels({ listings: listings(), openrouter: OR_MODELS, cfg: OLLAMA, log });
+		let available = true;
+		let keyed = false;
+		const source = { get: async () => ollamaModels, peek: () => ollamaModels, invalidate: () => {} };
+		const breaker = { available: () => available, cooldownUntilMs: () => null, lastTrip: () => null };
+		const catalog = createCompositeCatalog(openrouter, source, breaker, { costBias: 1, biasUntilUsage: 1, usage: NO_USAGE, serveOpenRouter: () => keyed });
+
+		const a = await catalog.get();
+		expect(a.models.map((m) => m.provider)).toEqual(["ollama", "ollama", "ollama"]);
+		expect(a.fetchedAtMs).toBe(1);
+		expect(await catalog.get()).toBe(a); // memoised while nothing changes
+		expect(catalog.find("z-ai/glm-5.3-flash")?.provider).toBe("openrouter"); // lookups (served-model attribution) still resolve
+		expect(a.models[0]?.quality).toEqual(OR_MODELS.find((m) => m.slug === "z-ai/glm-5.3-flash")?.quality); // twin metadata borrowed
+
+		available = false;
+		expect((await catalog.get()).models).toEqual([]); // nothing can serve: breaker open, no key
+		available = true;
+		keyed = true; // a hot-reloaded key brings OpenRouter back without a restart
+		const c = await catalog.get();
+		expect(c.models.length).toBe(OR_MODELS.length + 3);
+		expect(c).not.toBe(a);
+	});
 });
 
 describe("selection over a mixed catalog", () => {

package/test/{team-client.test.ts → remote.test.ts}

@@ -3,29 +3,32 @@ import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { addExtensions, codexBlock, joinTeam, setDotenv, type JoinOptions } from "../src/cli/join.ts";
-import { parseTeamClient, readTeamClient, teamProviderRegistration } from "../omp-extension/team-logic.ts";
+import { addExtensions, codexBlock, connectRemote, setDotenv, type ConnectOptions } from "../src/cli/connect.ts";
+import { parseRemoteRouter, readRemoteRouter, remoteProviderRegistration } from "../omp-extension/remote-logic.ts";
 
 /**
- * Team-client mode: team.json puts the omp extensions on the team endpoint,
- * and `join` configures every harness it finds without touching anything it
- * does not recognise.
+ * Remote mode: remote.json puts the omp extensions on a router elsewhere,
+ * and `connect` configures every harness it finds without touching anything
+ * it does not recognise.
  */
 
-describe("team-logic", () => {
-	test("team.json is parsed defensively and turned into omp's provider registration", () => {
-		expect(parseTeamClient("nope")).toBeNull();
-		expect(parseTeamClient(JSON.stringify({ url: "https://t/", key: "" }))).toBeNull();
-		const t = parseTeamClient(JSON.stringify({ url: "https://team.example/", key: "amrt_k", userId: "u_1", name: "Ada" }))!;
+describe("remote-logic", () => {
+	test("remote.json is parsed defensively and turned into omp's provider registration", () => {
+		expect(parseRemoteRouter("nope")).toBeNull();
+		expect(parseRemoteRouter(JSON.stringify({ url: "https://t/", key: "" }))).toBeNull();
+		const t = parseRemoteRouter(JSON.stringify({ url: "https://team.example/", key: "amrt_k", userId: "u_1", name: "Ada" }))!;
 		expect(t.url).toBe("https://team.example");
-		const reg = teamProviderRegistration(t, "sess-1", true, { inputPerMtok: 1, outputPerMtok: 4 });
+		const reg = remoteProviderRegistration(t, "sess-1", true, { inputPerMtok: 1, outputPerMtok: 4 });
 		expect(reg).toMatchObject({ baseUrl: "https://team.example/v1", api: "openai-completions", apiKey: "amrt_k", headers: { "X-Omp-Session": "sess-1", "X-Omp-Subagent": "1" } });
 		expect(reg.models.map((m) => m.id)).toEqual(["auto", "auto-cheap", "auto-max"]);
 		expect(reg.models[0]!.cost).toEqual({ input: 1, output: 4, cacheRead: 0.1, cacheWrite: 1.25 });
-		const dir = mkdtempSync(join(tmpdir(), "amr-team-client-"));
-		expect(readTeamClient(dir)).toBeNull();
-		writeFileSync(join(dir, "team.json"), JSON.stringify({ url: "https://t", key: "k" }));
-		expect(readTeamClient(dir)?.key).toBe("k");
+		const dir = mkdtempSync(join(tmpdir(), "amr-remote-"));
+		expect(readRemoteRouter(dir)).toBeNull();
+		writeFileSync(join(dir, "remote.json"), JSON.stringify({ url: "https://t", key: "k" }));
+		expect(readRemoteRouter(dir)?.key).toBe("k");
+		rmSync(join(dir, "remote.json"));
+		writeFileSync(join(dir, "team.json"), JSON.stringify({ url: "https://legacy", key: "k2" })); // the first release's name still works
+		expect(readRemoteRouter(dir)?.url).toBe("https://legacy");
 		rmSync(dir, { recursive: true, force: true });
 	});
 
@@ -39,9 +42,9 @@ describe("team-logic", () => {
 	});
 });
 
-describe("join", () => {
-	function scenario(extra: Partial<JoinOptions> = {}): { home: string; o: JoinOptions } {
-		const home = mkdtempSync(join(tmpdir(), "amr-join-"));
+describe("connect", () => {
+	function scenario(extra: Partial<ConnectOptions> = {}): { home: string; o: ConnectOptions } {
+		const home = mkdtempSync(join(tmpdir(), "amr-connect-"));
 		const agent = join(home, ".omp", "agent");
 		mkdirSync(agent, { recursive: true });
 		writeFileSync(join(agent, "config.yml"), "extensions:\n  - E:/other/ext.ts\nsetupVersion: 2\n");
@@ -49,15 +52,15 @@ describe("join", () => {
 		writeFileSync(join(home, ".hermes", ".env"), "OPENAI_API_KEY=x\n");
 		mkdirSync(join(home, ".codex"), { recursive: true });
 		writeFileSync(join(home, ".codex", "config.toml"), 'model = "gpt-5"\n');
-		const o: JoinOptions = { url: "https://team.example", key: "amrt_key", userId: "u_ada", name: "Ada", profile: false, dryRun: false, only: [], env: { HOME: home, HERMES_HOME: join(home, ".hermes"), PI_CODING_AGENT_DIR: agent, AUTO_MODEL_ROUTER_HOME: join(home, ".auto-model-router") }, home, packageDir: process.cwd(), platform: "linux", pathHas: (b) => b === "claude" || b === "aider", ...extra };
+		const o: ConnectOptions = { url: "https://team.example", key: "amrt_key", userId: "u_ada", name: "Ada", profile: false, dryRun: false, only: [], env: { HOME: home, HERMES_HOME: join(home, ".hermes"), PI_CODING_AGENT_DIR: agent, AUTO_MODEL_ROUTER_HOME: join(home, ".auto-model-router") }, home, packageDir: process.cwd(), platform: "linux", pathHas: (b) => b === "claude" || b === "aider", ...extra };
 		return { home, o };
 	}
 
-	test("writes team.json and configures omp, Hermes, Codex, Aider and Claude Code idempotently", () => {
+	test("writes remote.json and configures omp, Hermes, Codex, Aider and Claude Code idempotently", () => {
 		const { home, o } = scenario();
-		const r1 = joinTeam(o);
-		expect(existsSync(r1.teamFile)).toBe(true);
-		expect(JSON.parse(readFileSync(r1.teamFile, "utf8"))).toMatchObject({ url: "https://team.example", key: "amrt_key", userId: "u_ada", name: "Ada" });
+		const r1 = connectRemote(o);
+		expect(existsSync(r1.remoteFile)).toBe(true);
+		expect(JSON.parse(readFileSync(r1.remoteFile, "utf8"))).toMatchObject({ url: "https://team.example", key: "amrt_key", userId: "u_ada", name: "Ada" });
 		const ompCfg = readFileSync(join(home, ".omp", "agent", "config.yml"), "utf8");
 		expect(ompCfg).toContain("extensions:\n  - ");
 		expect(ompCfg).toContain("omp-extension/router-embed.ts");
@@ -72,24 +75,24 @@ describe("join", () => {
 		expect(r1.envLines).toEqual(["AUTO_MODEL_ROUTER_URL=https://team.example", "AUTO_MODEL_ROUTER_API_KEY=amrt_key", "ANTHROPIC_BASE_URL=https://team.example", "ANTHROPIC_API_KEY=amrt_key"]);
 		// Running again changes nothing.
 		const snapshot = [ompCfg, readFileSync(join(home, ".codex", "config.toml"), "utf8"), readFileSync(join(home, ".aider.conf.yml"), "utf8")];
-		joinTeam(o);
+		connectRemote(o);
 		expect([readFileSync(join(home, ".omp", "agent", "config.yml"), "utf8"), readFileSync(join(home, ".codex", "config.toml"), "utf8"), readFileSync(join(home, ".aider.conf.yml"), "utf8")]).toEqual(snapshot);
 		rmSync(home, { recursive: true, force: true });
 	});
 
 	test("--harness restricts, --dry-run writes nothing, --profile appends once to the shell rc", () => {
 		const { home, o } = scenario({ only: ["omp"], dryRun: true });
-		const r = joinTeam(o);
-		expect(existsSync(r.teamFile)).toBe(false);
+		const r = connectRemote(o);
+		expect(existsSync(r.remoteFile)).toBe(false);
 		expect(r.configured.some((c) => c.startsWith("omp"))).toBe(true);
 		expect(r.skipped.some((s) => s.startsWith("Hermes"))).toBe(true);
 		expect(existsSync(join(home, ".hermes", "plugins"))).toBe(false);
 		const { home: h2, o: o2 } = scenario({ profile: true, env: { SHELL: "/bin/zsh" } });
 		o2.env = { ...o.env, HOME: h2, HERMES_HOME: join(h2, ".hermes"), PI_CODING_AGENT_DIR: join(h2, ".omp", "agent"), AUTO_MODEL_ROUTER_HOME: join(h2, ".auto-model-router"), SHELL: "/bin/zsh" };
-		joinTeam(o2);
-		joinTeam(o2);
+		connectRemote(o2);
+		connectRemote(o2);
 		const rc = readFileSync(join(h2, ".zshrc"), "utf8");
-		expect(rc.split("# auto-model-router team").length).toBe(2);
+		expect(rc.split("# auto-model-router remote").length).toBe(2);
 		expect(rc).toContain("export ANTHROPIC_BASE_URL=https://team.example");
 		rmSync(home, { recursive: true, force: true });
 		rmSync(h2, { recursive: true, force: true });

package/test/report-logic.test.ts

@@ -99,6 +99,8 @@ describe("renderStatus", () => {
 	test("degrades cleanly when sections are absent", () => {
 		const text = renderStatus("http://h", { status: "ok", apiKeyConfigured: false });
 		expect(text).toContain("key MISSING");
+		expect(renderStatus("http://h", { status: "ok", apiKeyConfigured: false, serving: ["ollama"] })).toContain("routing over ollama cloud only");
+		expect(renderStatus("http://h", { status: "ok", apiKeyConfigured: false, serving: [] })).toContain("serving: NOTHING");
 		expect(text).toContain("catalog: not fetched yet");
 		expect(text).toContain("ollama cloud: disabled");
 		expect(text).toContain("agentdox: off");

package/omp-extension/team-logic.ts

@@ -1,88 +0,0 @@
-/**
- * Team client mode for the omp extensions. `auto-model-router join` writes
- * `<router home>/team.json`; when it exists the embed extension registers the
- * TEAM endpoint as omp's provider instead of binding a local router, and the
- * toast, hub and digest extensions talk to the team with the member's key.
- * Nothing is classified or selected locally: the team router is the router.
- */
-
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-
-export const TEAM_FILE = "team.json";
-
-export interface TeamClient {
-	/** The team endpoint, no trailing slash, e.g. https://team.example.com */
-	url: string;
-	/** The member's user key (`amrt_…`). */
-	key: string;
-	userId: string;
-	name: string;
-	joinedAtMs: number;
-}
-
-export function teamFilePath(routerHome: string): string {
-	return join(routerHome, TEAM_FILE);
-}
-
-/** Parses team.json defensively; anything malformed ⇒ not in team mode. */
-export function parseTeamClient(text: string): TeamClient | null {
-	try {
-		const raw = JSON.parse(text) as Record<string, unknown>;
-		if (typeof raw.url !== "string" || typeof raw.key !== "string" || raw.url === "" || raw.key === "") return null;
-		return { url: raw.url.replace(/\/+$/, ""), key: raw.key, userId: typeof raw.userId === "string" ? raw.userId : "", name: typeof raw.name === "string" ? raw.name : "", joinedAtMs: typeof raw.joinedAtMs === "number" ? raw.joinedAtMs : 0 };
-	} catch {
-		return null;
-	}
-}
-
-export function readTeamClient(routerHome: string): TeamClient | null {
-	const path = teamFilePath(routerHome);
-	if (!existsSync(path)) return null;
-	try {
-		return parseTeamClient(readFileSync(path, "utf8"));
-	} catch {
-		return null;
-	}
-}
-
-/** The virtual models the team serves; costs are the router's fallback blend so omp can show estimates. */
-export const TEAM_MODELS: readonly { id: string; name: string }[] = [
-	{ id: "auto", name: "auto (team)" },
-	{ id: "auto-cheap", name: "auto-cheap (team)" },
-	{ id: "auto-max", name: "auto-max (team)" },
-];
-
-/**
- * omp's provider registration for team mode: the team's /v1 with the member
- * key, the session and subagent tags the team forwards to the router, and the
- * virtual models. Costs are USD per million tokens, like the embedded config.
- */
-export function teamProviderRegistration(team: TeamClient, sessionId: string, subagent: boolean, blend: { inputPerMtok: number; outputPerMtok: number }): {
-	baseUrl: string;
-	api: string;
-	apiKey: string;
-	headers: Record<string, string>;
-	models: { id: string; name: string; api: string; reasoning: boolean; input: string[]; contextWindow: number; maxTokens: number; cost: { input: number; output: number; cacheRead: number; cacheWrite: number } }[];
-} {
-	const headers: Record<string, string> = {};
-	if (sessionId !== "") headers["X-Omp-Session"] = sessionId;
-	if (subagent) headers["X-Omp-Subagent"] = "1";
-	const round = (v: number): number => Math.round(v * 1e4) / 1e4;
-	return {
-		baseUrl: `${team.url}/v1`,
-		api: "openai-completions",
-		apiKey: team.key,
-		headers,
-		models: TEAM_MODELS.map((m) => ({
-			id: m.id,
-			name: m.name,
-			api: "openai-completions",
-			reasoning: false,
-			input: ["text", "image"],
-			contextWindow: 200_000,
-			maxTokens: 32_000,
-			cost: { input: round(blend.inputPerMtok), output: round(blend.outputPerMtok), cacheRead: round(blend.inputPerMtok * 0.1), cacheWrite: round(blend.inputPerMtok * 1.25) },
-		})),
-	};
-}