auto-model-router 0.10.0 → 0.12.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.10.0",
+    "version": "0.12.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.10.0",
+      "version": "0.12.0",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -1340,6 +1340,31 @@ sends the name itself, which the router does not accept as a scope (a scope is a
 lowercase slug) and falls back to its default. `--scope <slug>` pins one project for the
 whole machine instead; a refresh keeps a pin, and `connect --scope ""` removes it.
 
+### One file to install
+
+A remote that serves members can hand them this package as a single executable: the CLI
+compiled by `bun build --compile` for their operating system (`buildExecutable` in the
+library, one of `linux-x64`, `linux-arm64`, `darwin-x64`, `darwin-arm64`,
+`windows-x64`), with the package's own source files embedded. Nothing else is installed —
+no bun, no npm. omp still loads the extensions from disk and Hermes still copies its
+plugin, so the first `connect` from the executable writes the embedded files out under
+`<router home>/package/<version>/` and points every harness there; the executable itself
+becomes Claude Code's key helper and, with `--profile`, goes on PATH. `connect
+--setup-token <token>` trades a one-time onboarding token at the remote's
+`/setup/exchange` for the credential, so the install command carries no key at all.
+`remote.json` records the executable, and a refresh from inside omp keeps the helper
+pointed at it.
+
+### The remote's skills come along
+
+A remote that serves a skills bundle (`GET <url>/setup/skills` with the member key: a
+version and a list of `{ name, files }`, each with a `SKILL.md`) has it installed by
+`connect`, and by every refresh, into the harnesses it configured that read user-level
+skills: Claude Code's `~/.claude/skills/<name>/` and omp's `~/.omp/agent/skills/<name>/`.
+`<router home>/skills-installed.json` records what was placed, so an update removes what
+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.
+
 ## Multiple coding harnesses, one router
 
 **One router process for everything.** omp's embed extension binds a private

package/omp-extension/remote-logic.ts

@@ -36,6 +36,12 @@ export interface RemoteRouter {
 	refreshExpiresAtMs?: number;
 	/** What the remote calls this machine. */
 	device?: string;
+	/**
+	 * The compiled executable that ran `connect`, when one did. A refresh from
+	 * inside omp re-writes every harness config and must point Claude Code's key
+	 * helper at it, not at a `bun run` of the extracted source.
+	 */
+	executable?: string;
 }
 
 export function remoteFilePath(routerHome: string): string {
@@ -59,6 +65,7 @@ export function parseRemoteRouter(text: string): RemoteRouter | null {
 			...(typeof raw.keyExpiresAtMs === "number" ? { keyExpiresAtMs: raw.keyExpiresAtMs } : {}),
 			...(typeof raw.refreshExpiresAtMs === "number" ? { refreshExpiresAtMs: raw.refreshExpiresAtMs } : {}),
 			...(typeof raw.device === "string" && raw.device !== "" ? { device: raw.device } : {}),
+			...(typeof raw.executable === "string" && raw.executable !== "" ? { executable: raw.executable } : {}),
 		};
 	} catch {
 		return null;

package/package.json

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

package/src/cli/build-executable.ts

@@ -0,0 +1,142 @@
+/**
+ * Builds the single-file member install: this package compiled by
+ * `bun build --compile` for one operating system, with the package's own source
+ * files embedded so `connect` can write out what omp and Hermes load from disk
+ * (see `embedded.ts`). A team server calls this once per router version and
+ * target and serves the result; nothing here runs on a member's machine.
+ *
+ * Cross-compiling needs bun's runtime for the target, which bun downloads on
+ * first use and caches; a host without network access to bun's releases can
+ * only build its own platform.
+ */
+
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { EMBEDDED_GLOBAL, type EmbeddedPackage } from "./embedded.ts";
+
+export const EXECUTABLE_TARGETS = ["linux-x64", "linux-arm64", "darwin-x64", "darwin-arm64", "windows-x64"] as const;
+export type ExecutableTarget = (typeof EXECUTABLE_TARGETS)[number];
+
+export function isExecutableTarget(value: string): value is ExecutableTarget {
+	return (EXECUTABLE_TARGETS as readonly string[]).includes(value);
+}
+
+/** The target of the machine this process runs on, or null when bun has no build for it. */
+export function hostTarget(platform = process.platform, arch = process.arch): ExecutableTarget | null {
+	const cpu = arch === "x64" ? "x64" : arch === "arm64" ? "arm64" : null;
+	if (cpu === null) return null;
+	if (platform === "linux") return `linux-${cpu}`;
+	if (platform === "darwin") return `darwin-${cpu}`;
+	if (platform === "win32" && cpu === "x64") return "windows-x64";
+	return null;
+}
+
+/** The file name a build for `target` is served under. */
+export function executableFileName(target: ExecutableTarget): string {
+	return `auto-model-router-${target}${target.startsWith("windows") ? ".exe" : ""}`;
+}
+
+/** The package entries the install needs: the CLI, the harness integrations, and the two runtime deps. */
+const PACKAGE_ENTRIES = ["package.json", "README.md", "src", "omp-extension", "hermes-plugin", "opencode-plugin"] as const;
+const RUNTIME_DEPS = ["yaml", "zod"] as const;
+
+function walk(root: string, rel: string, keep: (rel: string) => boolean, out: Record<string, string>): void {
+	const abs = join(root, ...rel.split("/").filter((s) => s !== ""));
+	const st = statSync(abs);
+	if (st.isDirectory()) {
+		for (const name of readdirSync(abs)) walk(root, rel === "" ? name : `${rel}/${name}`, keep, out);
+		return;
+	}
+	if (!keep(rel)) return;
+	// Everything the filters let through is text (ts, py, yaml, js, json, md). No byte-level
+	// sniffing: src/util/hash.ts holds a NUL inside a string literal and was silently dropped
+	// by one, which broke the extension on a member machine and nowhere else.
+	out[rel] = readFileSync(abs, "utf8");
+}
+
+const keepPackageFile = (rel: string): boolean => !rel.includes("__pycache__") && !rel.endsWith(".pyc") && !rel.endsWith(".test.ts");
+const keepDepFile = (rel: string): boolean => !/(^|\/)(tests?|__tests__)\//.test(rel) && !/\.(d\.[cm]?ts|map)$/.test(rel) && !/\.test\.[cm]?[jt]sx?$/.test(rel);
+
+/**
+ * Every file the executable embeds, keyed by path relative to the package
+ * root. The runtime dependencies are resolved from the package's own location,
+ * so a `bun link`ed package finds them too.
+ */
+export function collectPackageFiles(packageDir: string): EmbeddedPackage {
+	const files: Record<string, string> = {};
+	for (const entry of PACKAGE_ENTRIES) {
+		if (existsSync(join(packageDir, entry))) walk(packageDir, entry, keepPackageFile, files);
+	}
+	for (const dep of RUNTIME_DEPS) {
+		let depDir: string;
+		try {
+			depDir = dirname(Bun.resolveSync(`${dep}/package.json`, packageDir));
+		} catch {
+			continue;
+		}
+		const depFiles: Record<string, string> = {};
+		walk(depDir, "", keepDepFile, depFiles);
+		for (const [rel, content] of Object.entries(depFiles)) files[`node_modules/${dep}/${rel}`] = content;
+	}
+	const version = (JSON.parse(files["package.json"] ?? "{}") as { version?: string }).version ?? "0.0.0";
+	return { version, files };
+}
+
+export interface BuildExecutableOptions {
+	packageDir: string;
+	target: ExecutableTarget;
+	/** Where the executable goes; created or replaced. */
+	outFile: string;
+	/** The bun binary to build with; this process's own when it is bun. */
+	bun?: string;
+	/** A directory for the manifest and entry module; a temp dir when absent, removed afterwards. */
+	stageDir?: string;
+}
+
+export type BuildExecutableResult = { ok: true; path: string; bytes: number } | { ok: false; reason: string };
+
+function bunBinary(explicit: string | undefined): string | null {
+	if (explicit !== undefined) return explicit;
+	if (/(^|[\\/])bun(\.exe)?$/i.test(process.execPath)) return process.execPath;
+	return Bun.which("bun");
+}
+
+/**
+ * Compiles the package at `packageDir` into `outFile` for `target`. The entry
+ * module sets the global `embedded.ts` reads and then loads the CLI, so the CLI
+ * itself never knows at build time whether it will be compiled.
+ */
+export async function buildExecutable(opts: BuildExecutableOptions): Promise<BuildExecutableResult> {
+	const bun = bunBinary(opts.bun);
+	if (bun === null) return { ok: false, reason: "bun is not available to build with" };
+	const stage = opts.stageDir ?? mkdtempSync(join(tmpdir(), "amr-exe-"));
+	mkdirSync(stage, { recursive: true });
+	try {
+		const pkg = collectPackageFiles(opts.packageDir);
+		if (pkg.files["src/index.ts"] === undefined) return { ok: false, reason: `${opts.packageDir} does not hold the router package (no src/index.ts)` };
+		writeFileSync(join(stage, "manifest.json"), JSON.stringify(pkg), "utf8");
+		const entry = join(opts.packageDir, "src", "index.ts").replaceAll("\\", "/");
+		writeFileSync(
+			join(stage, "entry.ts"),
+			[
+				`import manifest from "./manifest.json" with { type: "file" };`,
+				`(globalThis as Record<string, unknown>)[${JSON.stringify(EMBEDDED_GLOBAL)}] = { manifestPath: manifest };`,
+				`await import(${JSON.stringify(entry)});`,
+				"",
+			].join("\n"),
+			"utf8",
+		);
+		mkdirSync(dirname(opts.outFile), { recursive: true });
+		const proc = Bun.spawn([bun, "build", "--compile", `--target=bun-${opts.target}`, join(stage, "entry.ts"), "--outfile", opts.outFile], { stdout: "pipe", stderr: "pipe", cwd: opts.packageDir });
+		const [stdout, stderr, exitCode] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited]);
+		if (exitCode !== 0 || !existsSync(opts.outFile)) {
+			const tail = `${stderr}\n${stdout}`.trim().split("\n").slice(-6).join("\n");
+			return { ok: false, reason: `bun build --compile for ${opts.target} failed (exit ${exitCode}): ${tail}` };
+		}
+		return { ok: true, path: opts.outFile, bytes: statSync(opts.outFile).size };
+	} finally {
+		if (opts.stageDir === undefined) rmSync(stage, { recursive: true, force: true });
+	}
+}
+

package/src/cli/connect.ts

@@ -25,11 +25,13 @@
  */
 
 import { appendFileSync, cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
+import { homedir, hostname } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { refreshAccountOf, remoteFilePath } from "../../omp-extension/remote-logic.ts";
 import { SCOPE_ENV } from "../context/scope.ts";
+import { executablePath, materializePackage, readEmbeddedPackage } from "./embedded.ts";
+import { fetchSkills, installSkills, type SkillsBundle, type SkillsInstallReport, type SkillsTarget } from "./skills.ts";
 import { pickStore, saveRefreshToken, type StoreDeps, type StoreKind } from "./credential-store.ts";
 import { flagString, type CliArgs } from "./args.ts";
 
@@ -58,6 +60,14 @@ export interface ConnectOptions {
 	keyExpiresAtMs?: number;
 	refreshExpiresAtMs?: number;
 	device?: string;
+	/**
+	 * The compiled executable running this, when one is (see embedded.ts). It
+	 * becomes Claude Code's key helper and goes on PATH with --profile, and
+	 * remote.json records it so a refresh from omp keeps pointing at it.
+	 */
+	exePath?: string;
+	/** The remote's skills bundle, installed into every configured harness that reads user-level skills. */
+	skills?: SkillsBundle;
 	platform: string;
 	pathHas: (bin: string) => boolean;
 }
@@ -68,6 +78,8 @@ export interface ConnectReport {
 	skipped: string[];
 	envLines: string[];
 	notes: string[];
+	/** What the remote's skills bundle did, when there was one. */
+	skills?: SkillsInstallReport;
 }
 
 const expand = (raw: string, home: string): string => (raw === "~" || raw.startsWith("~/") || raw.startsWith("~\\") ? join(home, raw.slice(1)) : raw);
@@ -257,6 +269,7 @@ export function connectRemote(o: ConnectOptions): ConnectReport {
 				...(o.keyExpiresAtMs !== undefined ? { keyExpiresAtMs: o.keyExpiresAtMs } : {}),
 				...(o.refreshExpiresAtMs !== undefined ? { refreshExpiresAtMs: o.refreshExpiresAtMs } : {}),
 				...(o.device !== undefined && o.device !== "" ? { device: o.device } : {}),
+				...(o.exePath !== undefined && o.exePath !== "" ? { executable: o.exePath } : {}),
 			},
 			null,
 			2,
@@ -339,8 +352,9 @@ export function connectRemote(o: ConnectOptions): ConnectReport {
 		const env: Record<string, unknown> = { ...((settings.env as Record<string, unknown> | undefined) ?? {}), ANTHROPIC_BASE_URL: o.url };
 		// Never leave a stale key beside the helper: the helper is the source now.
 		delete env.ANTHROPIC_API_KEY;
-		const entry = resolve(o.packageDir, "src", "index.ts").replaceAll("\\", "/");
-		const next = { ...settings, env, apiKeyHelper: `bun run "${entry}" token` };
+		// The executable is its own helper; under bun the source entry is.
+		const helper = o.exePath !== undefined && o.exePath !== "" ? `"${o.exePath.replaceAll("\\", "/")}" token` : `bun run "${resolve(o.packageDir, "src", "index.ts").replaceAll("\\", "/")}" token`;
+		const next = { ...settings, env, apiKeyHelper: helper };
 		const after = `${JSON.stringify(next, null, 2)}\n`;
 		if (after !== before) {
 			if (before !== "" && !o.dryRun) writeFileSync(`${settingsPath}.${new Date().toISOString().replaceAll(":", "-")}.bak`, before, "utf8");
@@ -351,6 +365,17 @@ export function connectRemote(o: ConnectOptions): ConnectReport {
 	report.envLines.unshift(`AUTO_MODEL_ROUTER_URL=${o.url}`, `AUTO_MODEL_ROUTER_API_KEY=${o.key}`);
 	report.envLines = [...new Set(report.envLines)];
 
+	// 6b. The remote's skills, into the harnesses configured above that read a
+	// user-level skills directory. Hermes, Codex and Aider have none we know of.
+	if (o.skills !== undefined) {
+		const targets: SkillsTarget[] = [];
+		if (report.configured.some((c) => c.startsWith("omp ("))) targets.push({ harness: "omp", dir: join(agentDir, "skills") });
+		if (report.configured.some((c) => c.startsWith("Claude Code ("))) targets.push({ harness: "Claude Code", dir: join(claudeDir, "skills") });
+		report.skills = installSkills(o.skills, targets, rh, o.dryRun);
+		if (report.skills.placed.length > 0) report.configured.push(`skills ${o.skills.version} (${report.skills.placed.join(", ")})`);
+		for (const s of report.skills.skipped) report.notes.push(`skill ${s}`);
+	}
+
 	// 7. Persist the environment.
 	if (o.profile && !o.dryRun) {
 		if (o.platform === "win32") {
@@ -358,11 +383,14 @@ export function connectRemote(o: ConnectOptions): ConnectReport {
 				const [k, ...v] = line.split("=");
 				Bun.spawnSync(["setx", k!, v.join("=")], { stdout: "ignore", stderr: "ignore" });
 			}
+			// Not setx for PATH: it truncates at 1024 characters and would eat the rest.
+			if (o.exePath !== undefined && o.exePath !== "") addToUserPathWindows(dirname(o.exePath));
 			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 remote (added by \`auto-model-router connect\`)\n${report.envLines.map((l) => `export ${l}`).join("\n")}\n`;
+			const pathLine = o.exePath !== undefined && o.exePath !== "" ? [`export PATH="${dirname(o.exePath)}:$PATH"`] : [];
+			const block = `\n# auto-model-router remote (added by \`auto-model-router connect\`)\n${[...report.envLines.map((l) => `export ${l}`), ...pathLine].join("\n")}\n`;
 			const before = existsSync(rc) ? readFileSync(rc, "utf8") : "";
 			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));
@@ -374,16 +402,85 @@ export function connectRemote(o: ConnectOptions): ConnectReport {
 	return report;
 }
 
+/** What a team's one-time setup token is traded for. */
+export interface IssuedCredential {
+	key: string;
+	refreshToken: string;
+	keyExpiresAtMs?: number;
+	refreshExpiresAtMs?: number;
+	userId: string;
+	name: string;
+}
+
+/**
+ * Trades a one-time setup token for this machine's credential at the team's
+ * exchange route, so the install needs nothing on the machine but this
+ * program: the token is the only secret in the install command and dies on use.
+ */
+export async function exchangeSetupToken(url: string, token: string, device: string, fetchImpl: typeof fetch = fetch): Promise<IssuedCredential> {
+	const res = await fetchImpl(`${url}/setup/exchange`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ token, device }), signal: AbortSignal.timeout(15_000) });
+	if (res.status === 401) throw new Error("the setup token was refused (expired or already used); get a new one from the team's portal");
+	if (!res.ok) throw new Error(`the team's setup exchange answered ${res.status}`);
+	const body = (await res.json()) as Record<string, unknown>;
+	if (typeof body.key !== "string" || body.key === "") throw new Error("the team's setup exchange returned no key");
+	return {
+		key: body.key,
+		refreshToken: typeof body.refreshToken === "string" ? body.refreshToken : "",
+		...(typeof body.keyExpiresAtMs === "number" ? { keyExpiresAtMs: body.keyExpiresAtMs } : {}),
+		...(typeof body.refreshExpiresAtMs === "number" ? { refreshExpiresAtMs: body.refreshExpiresAtMs } : {}),
+		userId: typeof body.userId === "string" ? body.userId : "",
+		name: typeof body.name === "string" ? body.name : "",
+	};
+}
+
+/** 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("'", "''")}'`;
+	const script = `$d=${quoted}; $p=[Environment]::GetEnvironmentVariable('Path','User'); if ($null -eq $p) { $p='' }; if (($p -split ';') -notcontains $d) { [Environment]::SetEnvironmentVariable('Path', (($p.TrimEnd(';') + ';' + $d).TrimStart(';')), 'User') }`;
+	Bun.spawnSync(["powershell", "-NoProfile", "-NonInteractive", "-Command", script], { stdout: "ignore", stderr: "ignore" });
+}
+
+/**
+ * Where the harness integrations are read from. Under bun that is this
+ * package; in the compiled executable it is the copy written out from the
+ * executable's own embedded files.
+ */
+async function resolvePackageDir(): Promise<string> {
+	const embedded = await readEmbeddedPackage();
+	if (embedded === null) return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+	const raw = process.env.AUTO_MODEL_ROUTER_HOME ?? join(homedir(), ".auto-model-router");
+	return materializePackage(expand(raw, homedir()), embedded);
+}
+
 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("connect needs --url <remote router> and --key <its key>");
+	let key = flagString(args, "key") ?? process.env.AUTO_MODEL_ROUTER_API_KEY ?? "";
+	const setupToken = flagString(args, "setup-token") ?? "";
+	if (url === "" || (key === "" && setupToken === "")) throw new Error("connect needs --url <remote router> and either --key <its key> or --setup-token <one-time token from the team>");
 	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 against the route every router serves before touching anything.
+	const packageDir = await resolvePackageDir();
+	const exePath = executablePath();
+	const fetchImpl = fetch;
 	let name = flagString(args, "name") ?? "";
 	let userId = flagString(args, "user-id") ?? "";
+	let device = flagString(args, "device") ?? "";
+	// A remote that issues short-lived keys hands these over beside the key.
+	let refreshToken = flagString(args, "refresh-token") ?? "";
+	let keyExpires = Number.parseInt(flagString(args, "key-expires") ?? "", 10);
+	let refreshExpires = Number.parseInt(flagString(args, "refresh-expires") ?? "", 10);
+	if (setupToken !== "") {
+		if (device === "") device = hostname();
+		const issued = await exchangeSetupToken(url, setupToken, device);
+		key = issued.key;
+		refreshToken = issued.refreshToken;
+		keyExpires = issued.keyExpiresAtMs ?? Number.NaN;
+		refreshExpires = issued.refreshExpiresAtMs ?? Number.NaN;
+		if (issued.userId !== "") userId = issued.userId;
+		if (issued.name !== "") name = issued.name;
+		console.log(`credential issued for ${name === "" ? userId : name} (device ${device})`);
+	}
+	// Verify the key against the route every router serves before touching anything.
 	try {
 		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");
@@ -396,11 +493,8 @@ export async function connectCommand(args: CliArgs): Promise<void> {
 	// A single-project machine can label every request; a machine with several
 	// repos should leave it off and let the extensions send the workspace's own.
 	const scopeFlag = flagString(args, "scope");
-	// A remote that issues short-lived keys hands these over beside the key.
-	const refreshToken = flagString(args, "refresh-token") ?? "";
-	const keyExpires = Number.parseInt(flagString(args, "key-expires") ?? "", 10);
-	const refreshExpires = Number.parseInt(flagString(args, "refresh-expires") ?? "", 10);
-	const device = flagString(args, "device") ?? "";
+	// The remote's skills for the agents on this machine; a remote without any serves 404.
+	const skills = await fetchSkills(url, key, fetchImpl);
 	const report = connectRemote({
 		url,
 		key,
@@ -419,7 +513,11 @@ export async function connectCommand(args: CliArgs): Promise<void> {
 		...(Number.isFinite(keyExpires) ? { keyExpiresAtMs: keyExpires } : {}),
 		...(Number.isFinite(refreshExpires) ? { refreshExpiresAtMs: refreshExpires } : {}),
 		...(device === "" ? {} : { device }),
+		...(exePath === null ? {} : { exePath }),
+		...(skills.bundle === null ? {} : { skills: skills.bundle }),
 	});
+	if (skills.note !== undefined) report.notes.push(skills.note);
+	if (exePath !== null) console.log(`executable ${exePath}; package files under ${packageDir}`);
 	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}`);

package/src/cli/embedded.ts

@@ -0,0 +1,78 @@
+/**
+ * The router package carried inside a compiled executable.
+ *
+ * `bun build --compile` turns this CLI into one file per operating system, and
+ * that is what a team member downloads: no bun, no npm, nothing else. But the
+ * harness integrations are not the CLI — omp loads `omp-extension/*.ts` with
+ * its own runtime and Hermes copies `hermes-plugin/` — so the executable also
+ * carries the package's source files and writes them out under the router home
+ * the first time `connect` runs. The build side (`build-executable.ts`) puts a
+ * JSON manifest of those files into the executable and sets a global that names
+ * it; this side reads it.
+ */
+
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+export interface EmbeddedPackage {
+	/** The router package's version, which also names the extracted directory. */
+	version: string;
+	/** Relative path (forward slashes) → file content. Text only: the package has no binaries. */
+	files: Record<string, string>;
+}
+
+/** What the build's entry module sets before the CLI loads. */
+export interface EmbeddedHandle {
+	/** Path of the manifest inside the executable's embedded filesystem. */
+	manifestPath: string;
+}
+
+export const EMBEDDED_GLOBAL = "AUTO_MODEL_ROUTER_EMBEDDED";
+
+export function embeddedHandle(): EmbeddedHandle | null {
+	const h = (globalThis as Record<string, unknown>)[EMBEDDED_GLOBAL];
+	return typeof h === "object" && h !== null && typeof (h as EmbeddedHandle).manifestPath === "string" ? (h as EmbeddedHandle) : null;
+}
+
+/** True when this process is the compiled executable rather than `bun run src/index.ts`. */
+export function isCompiled(): boolean {
+	return embeddedHandle() !== null;
+}
+
+/** The executable's own path when compiled, for key helpers and PATH; null under bun. */
+export function executablePath(): string | null {
+	return isCompiled() ? process.execPath : null;
+}
+
+export async function readEmbeddedPackage(): Promise<EmbeddedPackage | null> {
+	const h = embeddedHandle();
+	if (h === null) return null;
+	const parsed = JSON.parse(await Bun.file(h.manifestPath).text()) as EmbeddedPackage;
+	return typeof parsed.version === "string" && typeof parsed.files === "object" && parsed.files !== null ? parsed : null;
+}
+
+const MARKER = ".materialized";
+
+/**
+ * Writes the embedded package under `<routerHome>/package/<version>/` and
+ * returns that directory, the `packageDir` every harness config then points
+ * at. Idempotent: a marker records the manifest's hash, so an unchanged
+ * executable writes nothing on later runs and a rebuilt one of the same
+ * version refreshes the files.
+ */
+export function materializePackage(routerHome: string, pkg: EmbeddedPackage): string {
+	const dir = join(routerHome, "package", pkg.version);
+	const digest = Bun.hash(JSON.stringify(pkg.files)).toString(16);
+	try {
+		if (readFileSync(join(dir, MARKER), "utf8").trim() === digest) return dir;
+	} catch {
+		/* not written yet */
+	}
+	for (const [rel, content] of Object.entries(pkg.files)) {
+		const target = join(dir, ...rel.split("/"));
+		mkdirSync(dirname(target), { recursive: true });
+		writeFileSync(target, content, "utf8");
+	}
+	writeFileSync(join(dir, MARKER), `${digest}\n`, "utf8");
+	return dir;
+}

package/src/cli/refresh.ts

@@ -13,6 +13,8 @@
  * its own expiry, so a session still holding it is never cut.
  */
 
+import { executablePath, materializePackage, readEmbeddedPackage } from "./embedded.ts";
+import { fetchSkills } from "./skills.ts";
 import { homedir } from "node:os";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -89,7 +91,14 @@ export async function refreshAndRewrite(opts: { remote: RemoteRouter; fetchImpl?
 	const rh = opts.routerHome ?? routerHome();
 	const fresh = await refreshCredential(opts.remote, opts.fetchImpl ?? fetch, rh, opts.storeDeps ?? {});
 	const home = opts.home ?? (process.env.HOME !== undefined && process.env.HOME !== "" ? process.env.HOME : homedir());
-	const packageDir = opts.packageDir ?? resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+	// The compiled executable rewrites from its own extracted package and keeps
+	// itself as the key helper; the omp extension, running from that extracted
+	// package, learns the executable from remote.json.
+	const embedded = opts.packageDir === undefined ? await readEmbeddedPackage() : null;
+	const packageDir = opts.packageDir ?? (embedded === null ? resolve(dirname(fileURLToPath(import.meta.url)), "..", "..") : materializePackage(rh, embedded));
+	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);
 	connectRemote({
 		url: opts.remote.url,
 		key: fresh.key,
@@ -110,6 +119,8 @@ export async function refreshAndRewrite(opts: { remote: RemoteRouter; fetchImpl?
 		// The store that already holds it keeps it; a machine never silently changes store.
 		...(opts.remote.refreshTokenStore !== undefined ? { store: opts.remote.refreshTokenStore } : {}),
 		...(opts.storeDeps !== undefined ? { storeDeps: opts.storeDeps } : {}),
+		...(exePath !== undefined ? { exePath } : {}),
+		...(skills.bundle === null ? {} : { skills: skills.bundle }),
 		// undefined keeps whatever scope the managed models.yml block already carries.
 	});
 	return fresh;

package/src/cli/skills.ts

@@ -0,0 +1,145 @@
+/**
+ * Skills served by a remote router, installed by `connect`.
+ *
+ * A coding agent is only as good as the instructions it carries, and a team
+ * has instructions it wants every member's agent to have: how its shared
+ * context works, how to use the router well. The remote serves them as one
+ * versioned bundle (`GET <url>/setup/skills`, with the member key), and
+ * `connect` writes them into every harness it configures that reads a
+ * user-level skills directory — Claude Code's `~/.claude/skills`, omp's
+ * `~/.omp/agent/skills`. A manifest under the router home records what was
+ * placed, so an update removes what the bundle no longer carries and a skill
+ * the member wrote themselves under the same name is never touched.
+ */
+
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+export interface SkillsBundle {
+	/** Changes whenever any file changes; what `connect` reports and remembers. */
+	version: string;
+	skills: { name: string; files: Record<string, string> }[];
+}
+
+const NAME = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+const REL = /^(?!\.)(?!.*\/\.)[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*$/;
+
+/** Parses a bundle defensively: a malformed one installs nothing rather than something odd. */
+export function parseSkillsBundle(value: unknown): SkillsBundle | null {
+	if (typeof value !== "object" || value === null) return null;
+	const raw = value as Record<string, unknown>;
+	if (typeof raw.version !== "string" || raw.version === "" || !Array.isArray(raw.skills)) return null;
+	const skills: SkillsBundle["skills"] = [];
+	for (const s of raw.skills) {
+		if (typeof s !== "object" || s === null) return null;
+		const r = s as Record<string, unknown>;
+		if (typeof r.name !== "string" || !NAME.test(r.name) || typeof r.files !== "object" || r.files === null) return null;
+		const files: Record<string, string> = {};
+		for (const [rel, content] of Object.entries(r.files as Record<string, unknown>)) {
+			if (!REL.test(rel) || typeof content !== "string") return null;
+			files[rel] = content;
+		}
+		if (files["SKILL.md"] === undefined) return null;
+		skills.push({ name: r.name, files });
+	}
+	return { version: raw.version, skills };
+}
+
+/** The remote's bundle, or null when it serves none (404) or cannot be reached; never throws. */
+export async function fetchSkills(url: string, key: string, fetchImpl: typeof fetch = fetch): Promise<{ bundle: SkillsBundle | null; note?: string }> {
+	try {
+		const res = await fetchImpl(`${url}/setup/skills`, { headers: { authorization: `Bearer ${key}` }, signal: AbortSignal.timeout(15_000) });
+		if (res.status === 404) return { bundle: null };
+		if (!res.ok) return { bundle: null, note: `skills: ${url}/setup/skills answered ${res.status}; nothing installed` };
+		const bundle = parseSkillsBundle(await res.json());
+		return bundle === null ? { bundle: null, note: "skills: the remote's bundle was not understood; nothing installed" } : { bundle };
+	} catch (err) {
+		return { bundle: null, note: `skills: could not fetch ${url}/setup/skills (${err instanceof Error ? err.message : String(err)}); nothing installed` };
+	}
+}
+
+export interface SkillsTarget {
+	/** Shown in the report: "Claude Code", "omp". */
+	harness: string;
+	/** The harness's user-level skills directory; each skill goes in `<dir>/<name>/`. */
+	dir: string;
+}
+
+export interface SkillsInstallReport {
+	version: string;
+	/** "<harness>: <name>" per skill written. */
+	placed: string[];
+	/** Files from an earlier install the bundle no longer carries. */
+	removed: string[];
+	/** Skills left alone because the member has their own of that name there. */
+	skipped: string[];
+}
+
+interface Manifest {
+	version: string;
+	files: string[];
+}
+
+export function skillsManifestPath(routerHome: string): string {
+	return join(routerHome, "skills-installed.json");
+}
+
+export function readSkillsManifest(routerHome: string): Manifest | null {
+	try {
+		const raw = JSON.parse(readFileSync(skillsManifestPath(routerHome), "utf8")) as Record<string, unknown>;
+		return typeof raw.version === "string" && Array.isArray(raw.files) ? { version: raw.version, files: raw.files.filter((f): f is string => typeof f === "string") } : null;
+	} catch {
+		return null;
+	}
+}
+
+const norm = (p: string): string => p.replaceAll("\\", "/");
+
+/**
+ * Writes the bundle into each target, records what it placed, removes what a
+ * previous install placed that is gone now, and skips a skill directory it did
+ * not create. Pure over the file system: no network, so a test can drive it.
+ */
+export function installSkills(bundle: SkillsBundle, targets: readonly SkillsTarget[], routerHome: string, dryRun = false): SkillsInstallReport {
+	const previous = readSkillsManifest(routerHome);
+	const ours = new Set((previous?.files ?? []).map(norm));
+	const report: SkillsInstallReport = { version: bundle.version, placed: [], removed: [], skipped: [] };
+	const placedFiles: string[] = [];
+	for (const t of targets) {
+		for (const skill of bundle.skills) {
+			const dir = join(t.dir, skill.name);
+			const foreign = existsSync(dir) && !readdirSync(dir).some((f) => ours.has(norm(join(dir, f))));
+			if (foreign) {
+				report.skipped.push(`${t.harness}: ${skill.name} (a skill of that name is already there and was not placed by connect; left alone)`);
+				continue;
+			}
+			for (const [rel, content] of Object.entries(skill.files)) {
+				const path = join(dir, ...rel.split("/"));
+				placedFiles.push(norm(path));
+				if (dryRun) continue;
+				mkdirSync(dirname(path), { recursive: true });
+				writeFileSync(path, content, "utf8");
+			}
+			report.placed.push(`${t.harness}: ${skill.name}`);
+		}
+	}
+	const keep = new Set(placedFiles);
+	for (const old of ours) {
+		if (keep.has(old)) continue;
+		report.removed.push(old);
+		if (dryRun) continue;
+		rmSync(old, { force: true });
+		// An emptied skill directory goes too, so the harness does not list a hollow skill.
+		const parent = dirname(old);
+		try {
+			if (readdirSync(parent).length === 0) rmSync(parent, { recursive: true, force: true });
+		} catch {
+			/* already gone */
+		}
+	}
+	if (!dryRun) {
+		mkdirSync(routerHome, { recursive: true });
+		writeFileSync(skillsManifestPath(routerHome), `${JSON.stringify({ version: bundle.version, files: placedFiles } satisfies Manifest, null, 2)}\n`, "utf8");
+	}
+	return report;
+}

package/src/index.ts

@@ -13,6 +13,7 @@ import { configCommand } from "./cli/config-cmd.ts";
 import { explainCommand } from "./cli/explain.ts";
 import { exportCommand } from "./cli/export.ts";
 import { connectCommand } from "./cli/connect.ts";
+import { isCompiled, readEmbeddedPackage } from "./cli/embedded.ts";
 import { refreshCommand, tokenCommand } from "./cli/refresh.ts";
 import { modelsCommand } from "./cli/models.ts";
 import { reportCommand } from "./cli/report.ts";
@@ -27,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, --key[, --refresh-token]; --scope pins one project for the whole machine (default: each workspace's own); --profile persists the environment)
+  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)
   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
@@ -56,7 +57,9 @@ async function main(): Promise<number> {
 	const args = parseArgv(process.argv.slice(2));
 
 	if (args.flags.has("version")) {
-		const pkg: unknown = await Bun.file(join(import.meta.dir, "..", "package.json")).json();
+		// The compiled executable has no package.json beside it; its embedded copy answers.
+		const embedded = await readEmbeddedPackage();
+		const pkg: unknown = embedded ?? (await Bun.file(join(import.meta.dir, "..", "package.json")).json());
 		const value =
 			typeof pkg === "object" && pkg !== null && "version" in pkg && typeof pkg.version === "string"
 				? pkg.version
@@ -108,7 +111,8 @@ async function main(): Promise<number> {
 	}
 }
 
-if (import.meta.main) {
+// The compiled executable loads this module from its entry, so it is never import.meta.main there.
+if (import.meta.main || isCompiled()) {
 	try {
 		const code = await main();
 		if (code !== 0) process.exit(code);

package/src/lib.ts

@@ -23,5 +23,7 @@ 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 { 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";
+export { parseSkillsBundle, type SkillsBundle } from "./cli/skills.ts";
 export type { RequestPolicy } from "./wire/types.ts";
 export type { Ledger, LedgerEntry } from "./cost/types.ts";

package/test/executable.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { buildExecutable, collectPackageFiles, executableFileName, hostTarget, isExecutableTarget } from "../src/cli/build-executable.ts";
+import { connectRemote, exchangeSetupToken } from "../src/cli/connect.ts";
+import { EMBEDDED_GLOBAL, embeddedHandle, isCompiled, materializePackage, readEmbeddedPackage } from "../src/cli/embedded.ts";
+import { parseRemoteRouter } from "../omp-extension/remote-logic.ts";
+
+const NL = String.fromCharCode(10);
+
+describe("the single-file member install", () => {
+	test("the embedded package is the install: CLI, harness integrations, runtime deps; no tests, no caches", () => {
+		const pkg = collectPackageFiles(process.cwd());
+		expect(pkg.version).toBe((JSON.parse(readFileSync("package.json", "utf8")) as { version: string }).version);
+		expect(pkg.files["src/index.ts"]).toContain("connect");
+		expect(pkg.files["omp-extension/router-embed.ts"]).toBeDefined();
+		expect(pkg.files["hermes-plugin/native/__init__.py"] ?? pkg.files[Object.keys(pkg.files).find((k) => k.startsWith("hermes-plugin/")) ?? ""]).toBeDefined();
+		expect(pkg.files["node_modules/zod/package.json"]).toBeDefined();
+		expect(pkg.files["node_modules/yaml/package.json"]).toBeDefined();
+		const names = Object.keys(pkg.files);
+		// Every non-test source file, none missing: a dropped one only fails on a member machine, when the extension imports it.
+		const onDisk = readdirSync("src", { recursive: true }).map(String).filter((f) => /\.(ts|py|yaml)$/.test(f) && !f.endsWith(".test.ts")).map((f) => `src/${f.replaceAll("\\", "/")}`);
+		expect(onDisk.length).toBeGreaterThan(50);
+		for (const f of onDisk) expect(names).toContain(f);
+		expect(names.some((n) => n.endsWith(".test.ts"))).toBe(false);
+		expect(names.some((n) => n.includes("__pycache__") || n.endsWith(".pyc"))).toBe(false);
+		expect(names.some((n) => /\.d\.ts$/.test(n) && n.startsWith("node_modules/"))).toBe(false);
+	});
+
+	test("targets and file names", () => {
+		expect(isExecutableTarget("linux-x64")).toBe(true);
+		expect(isExecutableTarget("linux-x86")).toBe(false);
+		expect(executableFileName("windows-x64")).toBe("auto-model-router-windows-x64.exe");
+		expect(executableFileName("darwin-arm64")).toBe("auto-model-router-darwin-arm64");
+		expect(hostTarget("win32", "x64")).toBe("windows-x64");
+		expect(hostTarget("darwin", "arm64")).toBe("darwin-arm64");
+		expect(hostTarget("win32", "arm64")).toBeNull();
+	});
+
+	test("under bun there is no embedded package", async () => {
+		expect(isCompiled()).toBe(false);
+		expect(embeddedHandle()).toBeNull();
+		expect(await readEmbeddedPackage()).toBeNull();
+	});
+
+	test("materializing writes the files once, keyed by content, under the router home", () => {
+		const home = mkdtempSync(join(tmpdir(), "amr-mat-"));
+		try {
+			const pkg = { version: "9.9.9", files: { "package.json": `{"version":"9.9.9"}${NL}`, "src/index.ts": `console.log(1)${NL}`, "omp-extension/x.ts": "export {}" } };
+			const dir = materializePackage(home, pkg);
+			expect(dir).toBe(join(home, "package", "9.9.9"));
+			expect(readFileSync(join(dir, "src", "index.ts"), "utf8")).toBe(`console.log(1)${NL}`);
+			// Unchanged: a second call leaves a hand-edited file alone (nothing is rewritten).
+			writeFileSync(join(dir, "src", "index.ts"), "edited", "utf8");
+			expect(materializePackage(home, pkg)).toBe(dir);
+			expect(readFileSync(join(dir, "src", "index.ts"), "utf8")).toBe("edited");
+			// A rebuilt executable of the same version with different content refreshes it.
+			expect(materializePackage(home, { ...pkg, files: { ...pkg.files, "src/index.ts": "v2" } })).toBe(dir);
+			expect(readFileSync(join(dir, "src", "index.ts"), "utf8")).toBe("v2");
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+	});
+
+	test("connect from the executable: it is Claude Code's key helper, goes on PATH, and remote.json names it", () => {
+		const home = mkdtempSync(join(tmpdir(), "amr-exe-connect-"));
+		const claude = join(home, ".claude");
+		mkdirSync(claude, { recursive: true });
+		const rh = join(home, ".auto-model-router");
+		const env = { HOME: home, PI_CODING_AGENT_DIR: join(home, "no-omp"), AUTO_MODEL_ROUTER_HOME: rh, HERMES_HOME: join(home, "no-hermes"), SHELL: "/bin/zsh" };
+		const exe = join(rh, "bin", "auto-model-router");
+		try {
+			const r = connectRemote({ url: "https://team.example", key: "amrt_k", userId: "u_ada", name: "Ada", profile: true, dryRun: false, only: ["claude"], env, home, packageDir: join(rh, "package", "1.0.0"), exePath: exe, platform: "linux", pathHas: () => false });
+			expect(r.configured.some((c) => c.startsWith("Claude Code ("))).toBe(true);
+			const s = JSON.parse(readFileSync(join(claude, "settings.json"), "utf8")) as { apiKeyHelper: string };
+			expect(s.apiKeyHelper).toBe(`"${exe.replaceAll("\\", "/")}" token`);
+			expect(parseRemoteRouter(readFileSync(join(rh, "remote.json"), "utf8"))?.executable).toBe(exe);
+			const rc = readFileSync(join(home, ".zshrc"), "utf8");
+			expect(rc).toContain(`export PATH="${join(rh, "bin")}:$PATH"`);
+			expect(rc).toContain("export AUTO_MODEL_ROUTER_URL=https://team.example");
+			// Re-running keeps one block.
+			connectRemote({ url: "https://team.example", key: "amrt_k2", userId: "u_ada", name: "Ada", profile: true, dryRun: false, only: ["claude"], env, home, packageDir: join(rh, "package", "1.0.0"), exePath: exe, platform: "linux", pathHas: () => false });
+			expect(readFileSync(join(home, ".zshrc"), "utf8").split("# auto-model-router remote").length).toBe(2);
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+	});
+
+	test("a setup token is traded for the credential; a refused token says so", async () => {
+		const seen: { url: string; body: string }[] = [];
+		const ok = (async (url: string | URL | Request, init?: RequestInit) => {
+			seen.push({ url: String(url), body: String(init?.body) });
+			return Response.json({ key: "amrt_new", refreshToken: "amrr_new", keyExpiresAtMs: 10, refreshExpiresAtMs: 20, userId: "u_ada", name: "Ada", teamUrl: "https://team.example" });
+		}) as unknown as typeof fetch;
+		const issued = await exchangeSetupToken("https://team.example", "amrs_t", "laptop", ok);
+		expect(issued).toEqual({ key: "amrt_new", refreshToken: "amrr_new", keyExpiresAtMs: 10, refreshExpiresAtMs: 20, userId: "u_ada", name: "Ada" });
+		expect(seen[0]?.url).toBe("https://team.example/setup/exchange");
+		expect(JSON.parse(seen[0]?.body ?? "{}")).toEqual({ token: "amrs_t", device: "laptop" });
+		const refused = (async () => Response.json({ error: "invalid_token" }, { status: 401 })) as unknown as typeof fetch;
+		await expect(exchangeSetupToken("https://team.example", "amrs_old", "laptop", refused)).rejects.toThrow("refused");
+	});
+
+	test("the executable builds for this host and knows its version from the embedded package", async () => {
+		const target = hostTarget();
+		if (target === null) return;
+		const dir = mkdtempSync(join(tmpdir(), "amr-build-"));
+		try {
+			const out = join(dir, executableFileName(target));
+			const r = await buildExecutable({ packageDir: process.cwd(), target, outFile: out });
+			if (!r.ok) throw new Error(r.reason);
+			expect(existsSync(out)).toBe(true);
+			expect(r.bytes).toBeGreaterThan(10_000_000);
+			const version = Bun.spawnSync([out, "--version"], { stdout: "pipe", stderr: "pipe" }).stdout.toString().trim();
+			expect(version).toBe((JSON.parse(readFileSync("package.json", "utf8")) as { version: string }).version);
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	}, 120_000);
+
+	test("the global handle is what marks a compiled process", () => {
+		const g = globalThis as Record<string, unknown>;
+		g[EMBEDDED_GLOBAL] = { manifestPath: "/$bunfs/root/manifest.json" };
+		try {
+			expect(isCompiled()).toBe(true);
+			expect(embeddedHandle()?.manifestPath).toBe("/$bunfs/root/manifest.json");
+		} finally {
+			delete g[EMBEDDED_GLOBAL];
+		}
+		expect(isCompiled()).toBe(false);
+	});
+});

package/test/skills.test.ts

@@ -0,0 +1,110 @@
+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 } from "../src/cli/connect.ts";
+import { fetchSkills, installSkills, parseSkillsBundle, readSkillsManifest, type SkillsBundle } from "../src/cli/skills.ts";
+
+const NL = String.fromCharCode(10);
+const bundle = (version: string, skills: Record<string, Record<string, string>>): SkillsBundle => ({ version, skills: Object.entries(skills).map(([name, files]) => ({ name, files })) });
+
+describe("skills served by the remote, installed by connect", () => {
+	test("a bundle is parsed defensively", () => {
+		expect(parseSkillsBundle({ version: "v1", skills: [{ name: "team-context", files: { "SKILL.md": "# x" } }] })?.skills[0]?.name).toBe("team-context");
+		expect(parseSkillsBundle({ version: "v1", skills: [{ name: "Bad Name", files: { "SKILL.md": "# x" } }] })).toBeNull();
+		expect(parseSkillsBundle({ version: "v1", skills: [{ name: "ok", files: { "notes.md": "x" } }] })).toBeNull(); // no SKILL.md
+		expect(parseSkillsBundle({ version: "v1", skills: [{ name: "ok", files: { "../escape.md": "x", "SKILL.md": "y" } }] })).toBeNull();
+		expect(parseSkillsBundle({ version: "", skills: [] })).toBeNull();
+		expect(parseSkillsBundle("nope")).toBeNull();
+	});
+
+	test("install writes each skill into each target, updates in place, removes what is gone, and leaves a member's own skill alone", () => {
+		const home = mkdtempSync(join(tmpdir(), "amr-skills-"));
+		const rh = join(home, ".auto-model-router");
+		const claude = join(home, ".claude", "skills");
+		const omp = join(home, ".omp", "agent", "skills");
+		try {
+			const targets = [
+				{ harness: "Claude Code", dir: claude },
+				{ harness: "omp", dir: omp },
+			];
+			// The member already has their own "router" skill in Claude Code.
+			mkdirSync(join(claude, "router"), { recursive: true });
+			writeFileSync(join(claude, "router", "SKILL.md"), "mine", "utf8");
+			const v1 = bundle("v1", { "team-context": { "SKILL.md": `# ctx v1${NL}`, "notes/extra.md": "extra" }, router: { "SKILL.md": "# router v1" } });
+			const r1 = installSkills(v1, targets, rh);
+			expect(r1.placed).toEqual(["Claude Code: team-context", "omp: team-context", "omp: router"]);
+			expect(r1.skipped).toHaveLength(1);
+			expect(r1.skipped[0]).toContain("Claude Code: router");
+			expect(readFileSync(join(claude, "router", "SKILL.md"), "utf8")).toBe("mine");
+			expect(readFileSync(join(omp, "router", "SKILL.md"), "utf8")).toBe("# router v1");
+			expect(readFileSync(join(claude, "team-context", "notes", "extra.md"), "utf8")).toBe("extra");
+			expect(readSkillsManifest(rh)?.version).toBe("v1");
+			expect(readSkillsManifest(rh)?.files).toHaveLength(5);
+
+			// v2 drops the extra file and the router skill; team-context changes.
+			const v2 = bundle("v2", { "team-context": { "SKILL.md": `# ctx v2${NL}` } });
+			const r2 = installSkills(v2, targets, rh);
+			expect(r2.placed).toEqual(["Claude Code: team-context", "omp: team-context"]);
+			expect(readFileSync(join(omp, "team-context", "SKILL.md"), "utf8")).toBe(`# ctx v2${NL}`);
+			expect(existsSync(join(claude, "team-context", "notes", "extra.md"))).toBe(false);
+			expect(existsSync(join(omp, "router"))).toBe(false); // ours, now gone, directory and all
+			expect(readFileSync(join(claude, "router", "SKILL.md"), "utf8")).toBe("mine"); // theirs, untouched
+			expect(r2.removed).toHaveLength(3);
+			expect(readSkillsManifest(rh)?.files).toHaveLength(2);
+
+			// Dry run touches nothing.
+			const r3 = installSkills(bundle("v3", { fresh: { "SKILL.md": "x" } }), targets, rh, true);
+			expect(r3.placed).toHaveLength(2);
+			expect(existsSync(join(omp, "fresh"))).toBe(false);
+			expect(readSkillsManifest(rh)?.version).toBe("v2");
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+	});
+
+	test("fetchSkills: a remote without skills is silent, an unreachable one is a note, never an error", async () => {
+		const gone = (async () => new Response("", { status: 404 })) as unknown as typeof fetch;
+		expect(await fetchSkills("https://t", "k", gone)).toEqual({ bundle: null });
+		const seen: string[] = [];
+		const ok = (async (url: string | URL | Request, init?: RequestInit) => {
+			seen.push(`${String(url)} ${(init?.headers as Record<string, string>).authorization}`);
+			return Response.json({ version: "v9", skills: [{ name: "team-context", files: { "SKILL.md": "# hi" } }] });
+		}) as unknown as typeof fetch;
+		expect((await fetchSkills("https://t", "amrt_k", ok)).bundle?.version).toBe("v9");
+		expect(seen[0]).toBe("https://t/setup/skills Bearer amrt_k");
+		const down = (async () => {
+			throw new Error("connect ECONNREFUSED");
+		}) as unknown as typeof fetch;
+		const r = await fetchSkills("https://t", "k", down);
+		expect(r.bundle).toBeNull();
+		expect(r.note).toContain("ECONNREFUSED");
+		const odd = (async () => Response.json({ version: "v1", skills: "?" })) as unknown as typeof fetch;
+		expect((await fetchSkills("https://t", "k", odd)).note).toContain("not understood");
+	});
+
+	test("connect installs the bundle only into the harnesses it configured", () => {
+		const home = mkdtempSync(join(tmpdir(), "amr-skills-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 rh = join(home, ".auto-model-router");
+		const env = { HOME: home, PI_CODING_AGENT_DIR: agent, AUTO_MODEL_ROUTER_HOME: rh, HERMES_HOME: join(home, "no-hermes") };
+		try {
+			const skills = bundle("s1", { "team-context": { "SKILL.md": "# team" } });
+			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", skills, platform: "linux", pathHas: () => false });
+			expect(r.skills?.placed).toEqual(["omp: team-context", "Claude Code: team-context"]);
+			expect(readFileSync(join(agent, "skills", "team-context", "SKILL.md"), "utf8")).toBe("# team");
+			expect(readFileSync(join(home, ".claude", "skills", "team-context", "SKILL.md"), "utf8")).toBe("# team");
+			expect(r.configured.some((c) => c.startsWith("skills s1 ("))).toBe(true);
+			// Only Claude Code asked for: omp's directory is not created.
+			rmSync(join(agent, "skills"), { recursive: true, force: true });
+			const r2 = connectRemote({ url: "https://team.example", key: "amrt_k", userId: "u", name: "Ada", profile: false, dryRun: false, only: ["claude"], env, home, packageDir: "/pkg", skills, platform: "linux", pathHas: () => false });
+			expect(r2.skills?.placed).toEqual(["Claude Code: team-context"]);
+			expect(existsSync(join(agent, "skills"))).toBe(false);
+		} finally {
+			rmSync(home, { recursive: true, force: true });
+		}
+	});
+});