auto-model-router 0.4.14 → 0.6.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.4.14",
+    "version": "0.6.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.4.14",
+      "version": "0.6.0",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -1184,6 +1184,51 @@ text, not the conversation, so a hard task that only becomes hard three tool
 calls in stays on the router (the router's own escalation still applies
 there); and the switch happens at prompt boundaries, never mid-turn.
 
+## Claude Code (Anthropic Messages API)
+
+The router also speaks the Anthropic Messages API, which is the only wire Claude Code
+uses. Point Claude Code at the router and every turn is routed like any other harness's,
+to OpenRouter, Ollama Cloud, or whatever upstream is configured:
+
+```bash
+export ANTHROPIC_BASE_URL=http://127.0.0.1:8788
+export ANTHROPIC_API_KEY=<server.apiKey, or any string when the router has no key>
+claude
+```
+
+`POST /v1/messages` (streaming and not) and `POST /v1/messages/count_tokens` are served;
+the key may arrive as `x-api-key` or as a bearer. Claude Code asks for `claude-*` model
+names, which `anthropic.models` maps to profiles (first matching glob wins):
+
+```yaml
+anthropic:
+  models:
+    "*haiku*": auto-cheap     # Claude Code's background chores
+    "claude-*": auto          # real turns; try auto-max for an opus-only feel
+```
+
+Profile ids pass through, so `ANTHROPIC_MODEL=auto-max` works too. The harness id defaults
+to `claude-code` (from the user agent) and the session id is taken from the `metadata`
+Claude Code sends, so reports, budgets and the team edition see it like any other harness.
+
+What is translated: system prompts (string or blocks), text, image, `tool_use` and
+`tool_result` blocks, custom tools and `tool_choice` (including
+`disable_parallel_tool_use`), `stop_sequences`, `thinking` budgets and `output_config.effort`
+(as reasoning effort), and back: text, `tool_use` and `thinking` blocks, the four stop
+reasons, and usage with cache read and cache creation counts. The routing summary rides on
+`message_delta` as `x_auto_model_router`.
+
+Not available through the router: Anthropic server-side tools (web search, web fetch, code
+execution) and Anthropic-schema client tools (`bash_*`, `text_editor_*`) are dropped from
+the tool list, since no upstream serves them; thinking blocks come back unsigned and are
+dropped again on replay; `count_tokens` is the router's own estimate. Client `cache_control`
+markers are replaced by the router's own breakpoint plan.
+
+Claude Code prices its own cost line from the Claude model name it asked for, so the
+figure it shows is not what was spent; the router's ledger (`/router report`, the team
+edition) is. Verified with Claude Code 2.1.263 headless (`claude -p` with the Read tool)
+routed to a DeepSeek model; the captured request is `test/fixtures/harness/claude-code.json`.
+
 ## Per-request routing policy
 
 A front door in front of the router (the team edition, or any proxy that
@@ -1202,6 +1247,19 @@ 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.
+
 ## Multiple coding harnesses, one router
 
 **One router process for everything.** omp's embed extension binds a private
@@ -1229,6 +1287,7 @@ plus a harness header; the rest needs the harness's own hook API.
 | Harness | Wire | Harness id | Session id | Subagent flag | Toast | `/router` | Digest | Daily summary | Model switch |
 | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
 | omp | native provider | yes | yes | yes | yes | full hub | yes | yes | experimental |
+| Claude Code | Anthropic Messages (`/v1/messages`) | derived (`claude-code`) | from `metadata` | no | no | no | no | no | no |
 | Hermes | provider plugin | yes | yes (native plugin) | yes (native plugin) | no | text | yes (native plugin) | on demand | no |
 | Codex CLI | Responses API wire | yes | yes (from body) | yes (from body) | no | no | compaction only | no | no |
 | Aider | config only | via model settings | no | no | no | no | no tools | no | no |

package/hermes-plugin/__init__.py

@@ -30,7 +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"))
-BASE_URL = f"http://127.0.0.1:{PORT}/v1"
+# 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
+# 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"
 
 # The router binary, provided by `npm install -g auto-model-router`.
 BIN = "auto-model-router"
@@ -94,8 +98,8 @@ def _spawn_router() -> None:
     raise RuntimeError(f"auto-model-router did not come up on port {PORT}")
 
 
-_spawn_router()
-
+if not TEAM_URL:
+    _spawn_router()
 profile = ProviderProfile(
     name="auto-model-router",
     api_mode="chat_completions",

package/omp-extension/router-embed.ts

@@ -26,6 +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 type { StartedServer } from "../src/server/http.ts";
 import type { RouterConfig } from "../src/config/types.ts";
 
@@ -167,6 +168,17 @@ 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}`);
+			return;
+		}
+
 		// This module is cached per PROCESS, so `app` and `boundPort` are
 		// process-global even when omp loads the extension into more than one
 		// host. A router already bound in this process is therefore reusable:

package/omp-extension/router-toast.ts

@@ -23,40 +23,17 @@
  * the poll authenticates.
  */
 
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
 
-import { parse as parseYaml } from "yaml";
 
 import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
 
-import { embedPortPath, readEmbedPort } from "./embed-logic.ts";
-import { newestId, resolveRouterUrl, selectToasts, type ToastDecision } from "./toast-logic.ts";
+import { routerAuthHeaders, routerBaseUrl } from "./router-url.ts";
+import { newestId, selectToasts, type ToastDecision } from "./toast-logic.ts";
 
 /** Raw router config.yml, or null when there is none to read. */
-function readRouterConfig(): string | null {
-	const raw = process.env.AUTO_MODEL_ROUTER_HOME ?? join(homedir(), ".auto-model-router");
-	const home =
-		raw === "~" || raw.startsWith("~/") || raw.startsWith("~\\") ? join(homedir(), raw.slice(1)) : raw;
-	const path = join(home, "config.yml");
-	if (!existsSync(path)) return null;
-	try {
-		return readFileSync(path, "utf8");
-	} catch {
-		return null;
-	}
-}
 
 /** Absolute path of the shared embed port file (main session writes it). */
-function embedPortFile(): string {
-	const raw = process.env.AUTO_MODEL_ROUTER_HOME ?? join(homedir(), ".auto-model-router");
-	const home =
-		raw === "~" || raw.startsWith("~/") || raw.startsWith("~\\") ? join(homedir(), raw.slice(1)) : raw;
-	return embedPortPath(home);
-}
 
-const ROUTER_API_KEY = process.env.AUTO_MODEL_ROUTER_API_KEY;
 // This harness's id, matching the X-Omp-Harness header the router records.
 // Empty ⇒ toast every harness (single-harness default).
 const HARNESS_ID = process.env.OMP_HARNESS_ID ?? "";
@@ -91,19 +68,13 @@ 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.
-				const embedPort = readEmbedPort(embedPortFile());
-				const routerUrl = resolveRouterUrl(
-					process.env.AUTO_MODEL_ROUTER_URL,
-					readRouterConfig(),
-					parseYaml,
-					process.env.AUTO_MODEL_ROUTER_PORT,
-					embedPort,
-				);
+				// Team-client mode resolves to the team endpoint with the member key.
+				const routerUrl = routerBaseUrl();
 
 				let res: Response;
 				try {
 					res = await fetch(`${routerUrl}/v1/router/decisions?limit=20`, {
-						headers: ROUTER_API_KEY === undefined ? {} : { authorization: `Bearer ${ROUTER_API_KEY}` },
+						headers: routerAuthHeaders(),
 						signal: AbortSignal.timeout(3_000),
 					});
 				} catch {

package/omp-extension/router-url.ts

@@ -15,6 +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 { resolveRouterUrl } from "./toast-logic.ts";
 
 /** `$AUTO_MODEL_ROUTER_HOME` with `~` expanded, default `~/.auto-model-router`. */
@@ -36,6 +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;
 	return resolveRouterUrl(
 		process.env.AUTO_MODEL_ROUTER_URL,
 		readRouterConfigText(),
@@ -47,6 +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 key = process.env.AUTO_MODEL_ROUTER_API_KEY;
 	return key === undefined || key === "" ? {} : { authorization: `Bearer ${key}` };
 }

package/omp-extension/team-logic.ts

@@ -0,0 +1,88 @@
+/**
+ * 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) },
+		})),
+	};
+}

package/package.json

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

package/src/cli/args.ts

@@ -20,6 +20,8 @@ export interface CliArgs {
  */
 const BOOLEAN_FLAGS: Record<string, true> = {
 	json: true,
+	profile: true,
+	"dry-run": true,
 	write: true,
 	print: true,
 	help: true,
@@ -31,6 +33,7 @@ const COMMANDS: Record<string, true> = {
 	stats: true,
 	report: true,
 	export: true,
+	join: true,
 	models: true,
 	explain: true,
 	config: true,

package/src/cli/config-wizard.ts

@@ -335,6 +335,13 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "report.dailySummary", label: "Daily summary at session start", kind: "boolean" },
 		],
 	},
+	{
+		title: "Claude Code (Anthropic Messages wire)",
+		fields: [
+			{ path: "anthropic.models.*haiku*", label: "Model names matching *haiku* route to profile", kind: "string", optional: true, hint: "e.g. auto-cheap" },
+			{ path: "anthropic.models.claude-*", label: "Model names matching claude-* route to profile", kind: "string", optional: true, hint: "e.g. auto or auto-max" },
+		],
+	},
 	{
 		title: "Harness switch",
 		fields: [

package/src/cli/join.ts

@@ -0,0 +1,218 @@
+/**
+ * `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:
+ *
+ *   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
+ *   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)
+ *
+ * Every write is idempotent and announced. `--profile` persists the
+ * environment lines (shell rc on POSIX, user environment on Windows).
+ * `--dry-run` prints what would change. Honours PI_CODING_AGENT_DIR,
+ * HERMES_HOME and AUTO_MODEL_ROUTER_HOME, so a test can point it anywhere.
+ */
+
+import { appendFileSync, cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+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 { flagString, type CliArgs } from "./args.ts";
+
+export interface JoinOptions {
+	url: string;
+	key: string;
+	userId: string;
+	name: string;
+	profile: boolean;
+	dryRun: boolean;
+	/** Restrict to these harnesses (omp, hermes, codex, aider, claude); empty ⇒ every one detected. */
+	only: string[];
+	env: Record<string, string | undefined>;
+	home: string;
+	/** Where this package lives (the extensions are referenced from here). */
+	packageDir: string;
+	platform: string;
+	pathHas: (bin: string) => boolean;
+}
+
+export interface JoinReport {
+	teamFile: string;
+	configured: string[];
+	skipped: string[];
+	envLines: string[];
+	notes: string[];
+}
+
+const expand = (raw: string, home: string): string => (raw === "~" || raw.startsWith("~/") || raw.startsWith("~\\") ? join(home, raw.slice(1)) : raw);
+
+function routerHomeOf(o: JoinOptions): string {
+	return expand(o.env.AUTO_MODEL_ROUTER_HOME ?? join(o.home, ".auto-model-router"), o.home);
+}
+
+function ompAgentDir(o: JoinOptions): 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 {
+	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);
+
+/** Adds lines to a YAML `extensions:` list by text, keeping everything else byte-identical. */
+export function addExtensions(text: string, paths: readonly string[]): string {
+	const eol = text.includes("\r\n") ? "\r\n" : "\n";
+	const missing = paths.filter((p) => !text.includes(p));
+	if (missing.length === 0) return text;
+	const lines = missing.map((p) => `  - ${p}`);
+	const m = /^extensions:[ \t]*\r?\n/m.exec(text);
+	if (m === null) return `${text}${text.endsWith("\n") || text === "" ? "" : eol}extensions:${eol}${lines.join(eol)}${eol}`;
+	const at = m.index + m[0].length;
+	return `${text.slice(0, at)}${lines.join(eol)}${eol}${text.slice(at)}`;
+}
+
+/** Sets `KEY=value` lines in a dotenv-style file, replacing existing keys. */
+export function setDotenv(text: string, values: Record<string, string>): string {
+	const eol = text.includes("\r\n") ? "\r\n" : "\n";
+	let out = text;
+	for (const [k, v] of Object.entries(values)) {
+		const re = new RegExp(`^${k}=.*$`, "m");
+		if (re.test(out)) out = out.replace(re, `${k}=${v}`);
+		else out = `${out}${out === "" || out.endsWith("\n") ? "" : eol}${k}=${v}${eol}`;
+	}
+	return out;
+}
+
+export function codexBlock(url: string): string {
+	return `
+[model_providers.auto-model-router]
+name = "auto-model-router (team)"
+base_url = "${url}/v1"
+env_key = "AUTO_MODEL_ROUTER_API_KEY"
+wire_api = "responses"
+http_headers = { "X-Omp-Harness" = "codex" }
+`;
+}
+
+export function joinTeam(o: JoinOptions): JoinReport {
+	const report: JoinReport = { teamFile: "", 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.
+	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`);
+
+	// 2. omp
+	const agentDir = ompAgentDir(o);
+	if (wants(o, "omp") && existsSync(agentDir)) {
+		const cfgPath = join(agentDir, "config.yml");
+		const ext = ["router-toast", "router-embed", "router-configure", "router-digest"].map((n) => resolve(o.packageDir, "omp-extension", `${n}.ts`).replaceAll("\\", "/"));
+		const before = existsSync(cfgPath) ? readFileSync(cfgPath, "utf8") : "";
+		const after = addExtensions(before, ext);
+		if (after !== before) write(cfgPath, after);
+		report.configured.push(`omp (${cfgPath}; pick auto-model-router/auto as the model)`);
+	} else report.skipped.push("omp (no ~/.omp/agent)");
+
+	// 3. Hermes
+	const hh = hermesHome(o);
+	if (wants(o, "hermes") && existsSync(hh)) {
+		if (!o.dryRun) {
+			cpSync(join(o.packageDir, "hermes-plugin"), join(hh, "plugins", "model-providers", "auto-model-router"), { recursive: true });
+			cpSync(join(o.packageDir, "hermes-plugin", "native"), join(hh, "plugins", "auto-model-router"), { recursive: true });
+		}
+		const envPath = join(hh, ".env");
+		write(envPath, setDotenv(existsSync(envPath) ? readFileSync(envPath, "utf8") : "", { AUTO_MODEL_ROUTER_URL: o.url, AUTO_MODEL_ROUTER_API_KEY: o.key }));
+		report.configured.push(`Hermes (${hh}/plugins; restart Hermes and select auto-model-router/auto)`);
+	} else report.skipped.push("Hermes (no HERMES_HOME)");
+
+	// 4. Codex
+	const codexDir = join(o.home, ".codex");
+	if (wants(o, "codex") && existsSync(codexDir)) {
+		const p = join(codexDir, "config.toml");
+		const before = existsSync(p) ? readFileSync(p, "utf8") : "";
+		if (!before.includes("[model_providers.auto-model-router]")) write(p, before + codexBlock(o.url));
+		report.configured.push(`Codex (${p}; set model = "auto" and model_provider = "auto-model-router")`);
+		report.envLines.push(`AUTO_MODEL_ROUTER_API_KEY=${o.key}`);
+	} else report.skipped.push("Codex (no ~/.codex)");
+
+	// 5. Aider
+	const aiderConf = join(o.home, ".aider.conf.yml");
+	if (wants(o, "aider") && (existsSync(aiderConf) || o.pathHas("aider"))) {
+		const before = existsSync(aiderConf) ? readFileSync(aiderConf, "utf8") : "";
+		if (!before.includes("openai-api-base:")) write(aiderConf, `${before}${before === "" || before.endsWith("\n") ? "" : "\n"}openai-api-base: ${o.url}/v1\nopenai-api-key: ${o.key}\nmodel: openai/auto\n`);
+		report.configured.push(`Aider (${aiderConf})`);
+	} else report.skipped.push("Aider (not found)");
+
+	// 6. Claude Code: environment only.
+	if (wants(o, "claude") && o.pathHas("claude")) {
+		report.envLines.push(`ANTHROPIC_BASE_URL=${o.url}`, `ANTHROPIC_API_KEY=${o.key}`);
+		report.configured.push("Claude Code (environment)");
+	} else report.skipped.push("Claude Code (not on PATH)");
+	report.envLines.unshift(`AUTO_MODEL_ROUTER_URL=${o.url}`, `AUTO_MODEL_ROUTER_API_KEY=${o.key}`);
+	report.envLines = [...new Set(report.envLines)];
+
+	// 7. Persist the environment.
+	if (o.profile && !o.dryRun) {
+		if (o.platform === "win32") {
+			for (const line of report.envLines) {
+				const [k, ...v] = line.split("=");
+				Bun.spawnSync(["setx", k!, v.join("=")], { stdout: "ignore", stderr: "ignore" });
+			}
+			report.notes.push("user environment variables set with setx; open a new terminal");
+		} 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 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));
+			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> {
+	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>");
+	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.
+	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;
+		}
+	} 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}`}`);
+	for (const c of report.configured) console.log(`  configured ${c}`);
+	for (const s of report.skipped) console.log(`  skipped    ${s}`);
+	console.log("environment:");
+	for (const l of report.envLines) console.log(`  ${process.platform === "win32" ? "$env:" : "export "}${process.platform === "win32" ? l.replace("=", '="') + '"' : l}`);
+	for (const n of report.notes) console.log(`note: ${n}`);
+}

package/src/config/defaults.ts

@@ -335,6 +335,10 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// One transcript message per day, at the first interactive session start.
 		dailySummary: true,
 	},
+	anthropic: {
+		// haiku is what Claude Code uses for background chores; everything else is a real turn.
+		models: { "*haiku*": "auto-cheap", "claude-*": "auto" },
+	},
 	harnessSwitch: {
 		// Off: moving the harness's own model is a visible change the operator opts into.
 		enabled: false,

package/src/config/schema.ts

@@ -277,6 +277,7 @@ export const configInputSchema = z.strictObject({
 	budget: budget.optional(),
 	profiles: z.array(profile).optional(),
 	report: z.strictObject({ baselines: z.array(z.string()).optional(), dailySummary: z.boolean().optional() }).optional(),
+	anthropic: z.object({ models: z.record(z.string(), z.string()).optional() }).strict().optional(),
 	harnessSwitch: z
 		.strictObject({
 			enabled: z.boolean().optional(),

package/src/config/types.ts

@@ -620,6 +620,16 @@ export interface ReportConfig {
  * each user prompt and the harness moves its own active model to a
  * harness-native one for the mapped tiers. See omp-extension/router-switch.ts.
  */
+/** The Anthropic Messages wire (`POST /v1/messages`, Claude Code). */
+export interface AnthropicConfig {
+	/**
+	 * Which router profile a Messages `model` name means, first matching glob
+	 * wins. Claude Code asks for `claude-*` names; unmatched names pass through
+	 * so profile ids (`auto`, `auto-max`) still work.
+	 */
+	models: Record<string, string>;
+}
+
 export interface HarnessSwitchConfig {
 	enabled: boolean;
 	/**
@@ -830,6 +840,7 @@ export interface RouterConfig {
 	report: ReportConfig;
 	digest: DigestConfig;
 	harnessSwitch: HarnessSwitchConfig;
+	anthropic: AnthropicConfig;
 	profiles: ProfileConfig[];
 	ledger: LedgerConfig;
 	/**

package/src/index.ts

@@ -12,6 +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 { modelsCommand } from "./cli/models.ts";
 import { reportCommand } from "./cli/report.ts";
 import { serveCommand } from "./cli/serve.ts";
@@ -25,6 +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)
   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
@@ -78,6 +80,9 @@ async function main(): Promise<number> {
 		case "export":
 			await exportCommand(args);
 			return 0;
+		case "join":
+			await joinCommand(args);
+			return 0;
 		case "models":
 			await modelsCommand(args);
 			return 0;