@openma/cli 0.3.2 → 0.4.0

package/dist/index.js

@@ -47,30 +47,45 @@ function currentPlatform() {
   if (p === "darwin" || p === "linux" || p === "win32") return p;
   return "unknown";
 }
+function currentProfile() {
+  const raw = (process.env.OMA_PROFILE ?? "").trim();
+  if (raw === "") return "";
+  if (!PROFILE_SLUG_RE.test(raw)) {
+    throw new Error(
+      `OMA_PROFILE="${raw}" is not a valid profile slug. Expected: lowercase letters/digits/dashes, starting with letter or digit, max 32 chars.`
+    );
+  }
+  return raw;
+}
 function paths() {
   const home = homedir();
   const p = currentPlatform();
-  const configDir = join(home, ".oma/bridge");
+  const profile = currentProfile();
+  const dirSuffix = profile ? `-${profile}` : "";
+  const labelSuffix = profile ? `.${profile}` : "";
+  const configDir = join(home, `.oma/bridge${dirSuffix}`);
   const credsFile = join(configDir, "credentials.json");
   const machineIdFile = join(configDir, "machine-id");
   const sessionsDir = join(configDir, "sessions");
   const logFile = join(configDir, "logs", "bridge.log");
+  const serviceLabel = `${SERVICE_LABEL_BASE}${labelSuffix}`;
   let serviceFile = null;
   if (p === "darwin") {
-    serviceFile = join(home, "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`);
+    serviceFile = join(home, "Library", "LaunchAgents", `${serviceLabel}.plist`);
   } else if (p === "linux") {
-    serviceFile = join(home, ".config", "systemd", "user", `${SERVICE_LABEL}.service`);
+    serviceFile = join(home, ".config", "systemd", "user", `${serviceLabel}.service`);
   }
-  return { configDir, credsFile, machineIdFile, sessionsDir, logFile, serviceFile, serviceLabel: SERVICE_LABEL };
+  return { configDir, credsFile, machineIdFile, sessionsDir, logFile, serviceFile, serviceLabel };
 }
 function osTag() {
   return `${platform()}/${process.arch}`;
 }
-var SERVICE_LABEL;
+var PROFILE_SLUG_RE, SERVICE_LABEL_BASE;
 var init_platform = __esm({
   "src/bridge/lib/platform.ts"() {
     "use strict";
-    SERVICE_LABEL = "dev.openma.bridge";
+    PROFILE_SLUG_RE = /^[a-z0-9](?:[a-z0-9-]{0,30}[a-z0-9])?$/;
+    SERVICE_LABEL_BASE = "dev.openma.bridge";
   }
 });
 
@@ -94,9 +109,9 @@ async function writeCreds(creds) {
   await chmod(file2, 384);
 }
 async function deleteCreds() {
-  const { unlink: unlink2 } = await import("node:fs/promises");
+  const { unlink: unlink4 } = await import("node:fs/promises");
   try {
-    await unlink2(paths().credsFile);
+    await unlink4(paths().credsFile);
   } catch (e) {
     if (e.code !== "ENOENT") throw e;
   }
@@ -121,15 +136,40 @@ var init_config = __esm({
   }
 });
 
-// src/bridge/lib/launchd.ts
-import { mkdir as mkdir2, writeFile as writeFile2, unlink, readFile as readFile2 } from "node:fs/promises";
+// src/bridge/lib/service-templates.ts
 import { dirname as dirname2 } from "node:path";
-import { spawn } from "node:child_process";
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function dedupColon(p) {
+  const seen = /* @__PURE__ */ new Set();
+  return p.split(":").filter((part) => {
+    if (!part || seen.has(part)) return false;
+    seen.add(part);
+    return true;
+  }).join(":");
+}
+function dedupSemicolon(p) {
+  const seen = /* @__PURE__ */ new Set();
+  return p.split(";").filter((part) => {
+    if (!part || seen.has(part)) return false;
+    seen.add(part);
+    return true;
+  }).join(";");
+}
 function buildPlist(opts) {
   const p = paths();
   const nodeDir = dirname2(opts.nodePath);
   const setupPath = process.env.PATH ?? "";
-  const envPath = opts.envPath ?? dedupPath(setupPath ? `${nodeDir}:${setupPath}` : nodeDir);
+  const envPath = opts.envPath ?? dedupColon(setupPath ? `${nodeDir}:${setupPath}` : nodeDir);
+  const profile = currentProfile();
+  const envBlock = `<key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${escapeXml(envPath)}</string>
+` + (profile ? `    <key>OMA_PROFILE</key>
+    <string>${escapeXml(profile)}</string>
+` : "") + `  </dict>`;
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -153,26 +193,63 @@ function buildPlist(opts) {
   <string>${p.logFile}</string>
   <key>StandardErrorPath</key>
   <string>${p.logFile}</string>
-  <key>EnvironmentVariables</key>
-  <dict>
-    <key>PATH</key>
-    <string>${escapeXml(envPath)}</string>
-  </dict>
+  ${envBlock}
 </dict>
 </plist>
 `;
 }
-function escapeXml(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function dedupPath(p) {
-  const seen = /* @__PURE__ */ new Set();
-  return p.split(":").filter((part) => {
-    if (!part || seen.has(part)) return false;
-    seen.add(part);
-    return true;
-  }).join(":");
+function buildUnit(opts) {
+  const p = paths();
+  const nodeDir = dirname2(opts.nodePath);
+  const setupPath = process.env.PATH ?? "";
+  const envPath = opts.envPath ?? dedupColon(setupPath ? `${nodeDir}:${setupPath}` : nodeDir);
+  const profile = currentProfile();
+  const profileLine = profile ? `
+Environment=OMA_PROFILE=${profile}` : "";
+  return `[Unit]
+Description=OMA Bridge Daemon
+Documentation=https://github.com/open-ma/open-managed-agents
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${opts.nodePath} ${opts.cliEntry} bridge daemon
+Restart=always
+RestartSec=10
+Environment=PATH=${envPath}${profileLine}
+StandardOutput=append:${p.logFile}
+StandardError=append:${p.logFile}
+
+[Install]
+WantedBy=default.target
+`;
 }
+function buildShim(opts) {
+  const nodeDir = dirname2(opts.nodePath);
+  const setupPath = process.env.PATH ?? "";
+  const envPath = opts.envPath ?? dedupSemicolon(setupPath ? `${nodeDir};${setupPath}` : nodeDir);
+  const logFile = paths().logFile;
+  const profile = currentProfile();
+  const lines = [
+    "@echo off",
+    `set "PATH=${envPath}"`,
+    profile ? `set "OMA_PROFILE=${profile}"` : "",
+    `"${opts.nodePath}" "${opts.cliEntry}" bridge daemon >> "${logFile}" 2>&1`
+  ].filter(Boolean);
+  return lines.join("\r\n") + "\r\n";
+}
+var init_service_templates = __esm({
+  "src/bridge/lib/service-templates.ts"() {
+    "use strict";
+    init_platform();
+  }
+});
+
+// src/bridge/lib/launchd.ts
+import { mkdir as mkdir2, writeFile as writeFile2, unlink, readFile as readFile2 } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
+import { spawn } from "node:child_process";
 async function install(opts) {
   if (currentPlatform() !== "darwin") {
     throw new Error(
@@ -181,8 +258,8 @@ async function install(opts) {
   }
   const p = paths();
   if (!p.serviceFile) throw new Error("no service file path on this platform");
-  await mkdir2(dirname2(p.logFile), { recursive: true });
-  await mkdir2(dirname2(p.serviceFile), { recursive: true });
+  await mkdir2(dirname3(p.logFile), { recursive: true });
+  await mkdir2(dirname3(p.serviceFile), { recursive: true });
   await writeFile2(p.serviceFile, buildPlist(opts), "utf-8");
   await runLaunchctl(["unload", p.serviceFile]).catch(() => void 0);
   await runLaunchctl(["load", "-w", p.serviceFile]);
@@ -232,83 +309,628 @@ var init_launchd = __esm({
   "src/bridge/lib/launchd.ts"() {
     "use strict";
     init_platform();
+    init_service_templates();
   }
 });
 
-// ../acp-runtime/src/registry.ts
+// src/bridge/lib/systemd.ts
+import { mkdir as mkdir3, writeFile as writeFile3, unlink as unlink2, readFile as readFile3 } from "node:fs/promises";
+import { dirname as dirname4 } from "node:path";
 import { spawn as spawn2 } from "node:child_process";
-async function detect(id) {
-  const entry = KNOWN_ACP_AGENTS.find((e) => e.id === id);
-  if (!entry) return null;
-  return await isOnPath(entry.spec.command) ? entry : null;
+async function install2(opts) {
+  if (currentPlatform() !== "linux") {
+    throw new Error(
+      `systemd install only supported on Linux. Run \`oma bridge daemon\` in foreground or use the platform's service mechanism.`
+    );
+  }
+  const p = paths();
+  if (!p.serviceFile) throw new Error("no service file path on this platform");
+  await mkdir3(dirname4(p.logFile), { recursive: true });
+  await mkdir3(dirname4(p.serviceFile), { recursive: true });
+  await writeFile3(p.serviceFile, buildUnit(opts), "utf-8");
+  let warning;
+  let started = true;
+  try {
+    await runSystemctl(["--user", "daemon-reload"]);
+    await runSystemctl(["--user", "enable", "--now", `${p.serviceLabel}.service`]);
+  } catch (e) {
+    started = false;
+    warning = e.message;
+  }
+  const lingerEnabled = await isLingerEnabled().catch(() => false);
+  return { started, lingerEnabled, warning };
 }
-function isOnPath(cmd) {
+async function uninstall2() {
+  if (currentPlatform() !== "linux") return { removed: false };
+  const p = paths();
+  if (!p.serviceFile) return { removed: false };
+  let warning;
+  await runSystemctl(["--user", "disable", "--now", `${p.serviceLabel}.service`]).catch((e) => {
+    warning = e.message;
+  });
+  try {
+    await unlink2(p.serviceFile);
+    await runSystemctl(["--user", "daemon-reload"]).catch(() => void 0);
+    return { removed: true, warning };
+  } catch (e) {
+    if (e.code === "ENOENT") return { removed: false };
+    throw e;
+  }
+}
+function runSystemctl(args) {
+  return new Promise((resolve, reject) => {
+    const p = spawn2("systemctl", args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    p.stderr.on("data", (chunk) => stderr += chunk.toString());
+    p.once("error", (e) => reject(new Error(`systemctl spawn failed: ${e.message}`)));
+    p.once("exit", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`systemctl ${args.join(" ")} exited ${code}: ${stderr.trim()}`));
+    });
+  });
+}
+async function isLingerEnabled() {
+  const user = process.env.USER ?? process.env.LOGNAME ?? "";
+  if (!user) return false;
   return new Promise((resolve) => {
-    const probe = process.platform === "win32" ? "where" : "which";
-    const p = spawn2(probe, [cmd], { stdio: "ignore" });
+    const p = spawn2("loginctl", ["show-user", user, "--property=Linger", "--value"], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let out = "";
+    p.stdout.on("data", (c3) => out += c3.toString());
     p.once("error", () => resolve(false));
-    p.once("exit", (code) => resolve(code === 0));
+    p.once("exit", () => resolve(out.trim().toLowerCase() === "yes"));
   });
 }
-async function detectAll() {
-  const results = await Promise.all(KNOWN_ACP_AGENTS.map((e) => detect(e.id)));
-  return results.filter((e) => e !== null);
+function lingerHint() {
+  const user = process.env.USER ?? process.env.LOGNAME ?? "$USER";
+  return `sudo loginctl enable-linger ${user}   # so daemon survives logout`;
 }
-var KNOWN_ACP_AGENTS;
-var init_registry = __esm({
-  "../acp-runtime/src/registry.ts"() {
+async function readInstalledCliEntry2() {
+  const p = paths();
+  if (!p.serviceFile) return null;
+  let unit;
+  try {
+    unit = await readFile3(p.serviceFile, "utf-8");
+  } catch {
+    return null;
+  }
+  const m = unit.match(/^ExecStart=([^\s]+)\s+([^\s]+)\s+bridge\s+daemon\s*$/m);
+  return m?.[2] ?? null;
+}
+var init_systemd = __esm({
+  "src/bridge/lib/systemd.ts"() {
+    "use strict";
+    init_platform();
+    init_service_templates();
+  }
+});
+
+// src/bridge/lib/windows-task.ts
+import { mkdir as mkdir4, writeFile as writeFile4, unlink as unlink3, readFile as readFile4 } from "node:fs/promises";
+import { dirname as dirname5, join as join2 } from "node:path";
+import { spawn as spawn3 } from "node:child_process";
+function shimPath() {
+  return join2(paths().configDir, "daemon.cmd");
+}
+async function install3(opts) {
+  if (currentPlatform() !== "win32") {
+    throw new Error(`Windows Task Scheduler install only supported on Windows.`);
+  }
+  const p = paths();
+  await mkdir4(dirname5(p.logFile), { recursive: true });
+  await mkdir4(p.configDir, { recursive: true });
+  const shim = shimPath();
+  await writeFile4(shim, buildShim(opts), "utf-8");
+  const taskName = p.serviceLabel;
+  const args = [
+    "/create",
+    "/tn",
+    taskName,
+    "/tr",
+    `"${shim}"`,
+    "/sc",
+    "onlogon",
+    "/it",
+    "/rl",
+    "limited",
+    "/f"
+  ];
+  let warning;
+  try {
+    await runSchtasks(args);
+  } catch (e) {
+    return { registered: false, startedNow: false, shimPath: shim, warning: e.message };
+  }
+  let startedNow = true;
+  try {
+    await runSchtasks(["/run", "/tn", taskName]);
+  } catch (e) {
+    startedNow = false;
+    warning = e.message;
+  }
+  return { registered: true, startedNow, shimPath: shim, warning };
+}
+async function uninstall3() {
+  if (currentPlatform() !== "win32") return { removed: false };
+  const p = paths();
+  const taskName = p.serviceLabel;
+  let warning;
+  await runSchtasks(["/end", "/tn", taskName]).catch(() => void 0);
+  let removed = false;
+  try {
+    await runSchtasks(["/delete", "/tn", taskName, "/f"]);
+    removed = true;
+  } catch (e) {
+    warning = e.message;
+  }
+  try {
+    await unlink3(shimPath());
+  } catch {
+  }
+  return { removed, warning };
+}
+function runSchtasks(args) {
+  return new Promise((resolve, reject) => {
+    const p = spawn3("schtasks.exe", args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    let stdout = "";
+    p.stdout.on("data", (c3) => stdout += c3.toString());
+    p.stderr.on("data", (c3) => stderr += c3.toString());
+    p.once("error", (e) => reject(new Error(`schtasks spawn failed: ${e.message}`)));
+    p.once("exit", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`schtasks ${args.join(" ")} exited ${code}: ${(stderr || stdout).trim()}`));
+    });
+  });
+}
+async function readInstalledCliEntry3() {
+  let shim;
+  try {
+    shim = await readFile4(shimPath(), "utf-8");
+  } catch {
+    return null;
+  }
+  const m = shim.match(/^"([^"]+)"\s+"([^"]+)"\s+bridge\s+daemon/m);
+  return m?.[2] ?? null;
+}
+var init_windows_task = __esm({
+  "src/bridge/lib/windows-task.ts"() {
+    "use strict";
+    init_platform();
+    init_service_templates();
+  }
+});
+
+// src/bridge/lib/service-manager.ts
+function detectServiceKind() {
+  switch (currentPlatform()) {
+    case "darwin":
+      return "launchd";
+    case "linux":
+      return "systemd";
+    case "win32":
+      return "windows-task";
+    default:
+      return "unsupported";
+  }
+}
+async function install4(opts) {
+  const kind = detectServiceKind();
+  if (kind === "launchd") {
+    await install(opts);
+    return {
+      kind,
+      installedAt: paths().serviceFile,
+      started: true,
+      // launchctl load -w starts immediately
+      lingerEnabled: true
+      // n/a on macOS
+    };
+  }
+  if (kind === "systemd") {
+    const r = await install2(opts);
+    return {
+      kind,
+      installedAt: paths().serviceFile,
+      started: r.started,
+      warning: r.warning,
+      lingerEnabled: r.lingerEnabled
+    };
+  }
+  if (kind === "windows-task") {
+    const r = await install3(opts);
+    return {
+      kind,
+      installedAt: r.shimPath,
+      started: r.startedNow,
+      warning: r.warning,
+      lingerEnabled: true
+      // n/a on windows
+    };
+  }
+  return { kind, installedAt: null, started: false, lingerEnabled: true };
+}
+async function uninstall4() {
+  const kind = detectServiceKind();
+  if (kind === "launchd") {
+    const r = await uninstall();
+    return { kind, removed: r.removed };
+  }
+  if (kind === "systemd") {
+    const r = await uninstall2();
+    return { kind, removed: r.removed, warning: r.warning };
+  }
+  if (kind === "windows-task") {
+    const r = await uninstall3();
+    return { kind, removed: r.removed, warning: r.warning };
+  }
+  return { kind, removed: false };
+}
+async function readInstalledCliEntry4() {
+  const kind = detectServiceKind();
+  if (kind === "launchd") return readInstalledCliEntry();
+  if (kind === "systemd") return readInstalledCliEntry2();
+  if (kind === "windows-task") return readInstalledCliEntry3();
+  return null;
+}
+function lingerHint2() {
+  return detectServiceKind() === "systemd" ? lingerHint() : "";
+}
+var init_service_manager = __esm({
+  "src/bridge/lib/service-manager.ts"() {
+    "use strict";
+    init_platform();
+    init_launchd();
+    init_systemd();
+    init_windows_task();
+  }
+});
+
+// ../acp-runtime/src/known-agents.ts
+var OMA_OVERLAY_AGENTS;
+var init_known_agents = __esm({
+  "../acp-runtime/src/known-agents.ts"() {
     "use strict";
-    KNOWN_ACP_AGENTS = [
+    OMA_OVERLAY_AGENTS = [
+      // claude-acp: ACP wrapper around the user's `claude` binary. setup
+      // and `bridge agents refresh` offer y/N install via npm. spec uses
+      // the bare binary (faster spawn than `npx -y` per turn); install
+      // tells the audit how to get the binary onto PATH.
       {
-        id: "claude-agent-acp",
-        label: "Claude Code",
+        id: "claude-acp",
+        label: "Claude Agent",
         spec: { command: "claude-agent-acp" },
+        aliases: ["claude-agent-acp", "claude-code-acp"],
+        featured: true,
+        wraps: "claude",
+        install: { kind: "npm", package: "@agentclientprotocol/claude-agent-acp" },
         installHint: "npm install -g @agentclientprotocol/claude-agent-acp",
         homepage: "https://github.com/agentclientprotocol/claude-agent-acp"
       },
+      // codex-acp: ACP wrapper around the user's `codex` binary. Zed
+      // Industries' Rust binary; distributed as GitHub release tarballs +
+      // an npm mirror. We leave `install` unset here so mergeOverlay picks
+      // up the per-platform archives from the live registry — keeps overlay
+      // a single source of truth (no version-pinned URLs to bit-rot).
       {
-        id: "codex-cli",
+        id: "codex-acp",
         label: "Codex CLI",
-        spec: { command: "codex", args: ["--acp"] },
-        installHint: "npm install -g @openai/codex",
-        homepage: "https://github.com/openai/codex"
+        spec: { command: "codex-acp" },
+        aliases: ["codex-cli", "codex-acp-bridge"],
+        featured: true,
+        wraps: "codex",
+        installHint: "download from https://github.com/zed-industries/codex-acp/releases and place on PATH",
+        homepage: "https://github.com/zed-industries/codex-acp"
       },
+      // gemini: official id is `gemini`. Pre-registry OMA had `gemini-cli`.
       {
-        id: "gemini-cli",
+        id: "gemini",
         label: "Gemini CLI",
-        spec: { command: "gemini", args: ["--experimental-acp"] },
+        spec: { command: "gemini", args: ["--acp"] },
+        aliases: ["gemini-cli"],
         installHint: "npm install -g @google/gemini-cli",
         homepage: "https://github.com/google-gemini/gemini-cli"
       },
+      // opencode: official id matches ours, no alias needed. Listed here
+      // anyway so the Console (overlay-only) still sees it without needing
+      // a CDN fetch.
       {
         id: "opencode",
         label: "OpenCode",
         spec: { command: "opencode", args: ["acp"] },
-        installHint: "https://opencode.ai/docs/ \u2014 Go binary, install via the platform package or https://opencode.ai/install.sh",
+        installHint: "npm install -g opencode-ai@latest  # or curl -fsSL https://opencode.ai/install | bash",
         homepage: "https://opencode.ai/"
       },
+      // hermes: NOT in official registry. Python-packaged; the official
+      // installer downloads + sets up the global `hermes` binary. We ship a
+      // full entry so it appears in install hints even though the registry
+      // doesn't know about it.
       {
         id: "hermes",
         label: "Hermes (Nous Research)",
         spec: { command: "hermes", args: ["acp"] },
-        installHint: "see https://hermes-agent.nousresearch.com/docs/installation/",
+        featured: true,
+        installHint: "curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash",
         homepage: "https://github.com/NousResearch/hermes-agent"
       },
+      // openclaw: NOT in official registry. The `openclaw` cli's `acp`
+      // subcommand exposes an ACP bridge that forwards to the OpenClaw
+      // Gateway. Distinct from `acpx` (an ACP CLIENT, same GH org).
       {
-        // Meta-CLI from openclaw that can wrap many non-native-ACP agents
-        // (openclaw, cursor, pi, kiro, qwen). We ship one entry pointing at
-        // openclaw because that's the most-asked-for; users can always pass
-        // their own AgentSpec to wrap a different one.
         id: "openclaw",
-        label: "OpenClaw (via acpx)",
-        spec: { command: "acpx", args: ["openclaw"] },
-        installHint: "npm install -g acpx",
-        homepage: "https://github.com/openclaw/acpx"
+        label: "OpenClaw",
+        spec: { command: "openclaw", args: ["acp"] },
+        featured: true,
+        installHint: "npm install -g openclaw",
+        homepage: "https://github.com/openclaw/openclaw"
       }
     ];
   }
 });
 
+// ../acp-runtime/src/registry-fetch.ts
+import { readFile as readFile5, writeFile as writeFile5, mkdir as mkdir5 } from "node:fs/promises";
+import { dirname as dirname6 } from "node:path";
+async function fetchOfficialRegistry(opts) {
+  const ttl = opts?.ttlMs ?? DEFAULT_TTL_MS;
+  const cachePath = opts?.cachePath;
+  if (cachePath) {
+    const cached2 = await readCache(cachePath);
+    if (cached2 && Date.now() - cached2.fetchedAt < ttl) {
+      return cached2.data;
+    }
+    if (cached2 && opts?.cacheOnly) return cached2.data;
+  }
+  if (opts?.cacheOnly) {
+    throw new Error("registry cacheOnly=true but no cache exists");
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 5e3);
+  try {
+    const res = await fetch(REGISTRY_URL, { signal: controller.signal });
+    if (!res.ok) throw new Error(`registry fetch HTTP ${res.status}`);
+    const data = await res.json();
+    if (!Array.isArray(data?.agents)) {
+      throw new Error("registry JSON malformed (no .agents array)");
+    }
+    if (cachePath) {
+      await writeCache(cachePath, { fetchedAt: Date.now(), data }).catch(() => {
+      });
+    }
+    return data;
+  } catch (e) {
+    if (cachePath) {
+      const stale = await readCache(cachePath);
+      if (stale) return stale.data;
+    }
+    throw e;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function readCache(path2) {
+  try {
+    const text = await readFile5(path2, "utf-8");
+    const obj = JSON.parse(text);
+    if (typeof obj?.fetchedAt !== "number" || !Array.isArray(obj?.data?.agents)) return null;
+    return obj;
+  } catch {
+    return null;
+  }
+}
+async function writeCache(path2, c3) {
+  await mkdir5(dirname6(path2), { recursive: true });
+  await writeFile5(path2, JSON.stringify(c3, null, 2), "utf-8");
+}
+function mapOfficialAgent(o) {
+  const platformKey2 = `${process.platform === "win32" ? "windows" : process.platform}-${process.arch === "arm64" ? "aarch64" : process.arch === "x64" ? "x86_64" : process.arch}`;
+  let spec = null;
+  let installHint;
+  let install5;
+  if (o.distribution.binary?.[platformKey2]) {
+    const b = o.distribution.binary[platformKey2];
+    const command = b.cmd.replace(/^\.\//, "").replace(/\.exe$/, "");
+    spec = { command, args: b.args };
+    installHint = `download ${b.archive} and place \`${command}\` on PATH`;
+    const archives = {};
+    for (const [k, v] of Object.entries(o.distribution.binary)) {
+      archives[k] = { url: v.archive, cmd: v.cmd };
+    }
+    install5 = { kind: "binary", archives, downloadUrl: o.repository };
+  } else if (o.distribution.npx) {
+    const n = o.distribution.npx;
+    spec = { command: "npx", args: ["-y", n.package, ...n.args ?? []], env: n.env };
+    installHint = `npx -y ${n.package}` + (n.args ? " " + n.args.join(" ") : "");
+    const lastAt = n.package.lastIndexOf("@");
+    const pkgName = lastAt > 0 ? n.package.slice(0, lastAt) : n.package;
+    install5 = { kind: "npm", package: pkgName };
+  } else if (o.distribution.uvx) {
+    const u = o.distribution.uvx;
+    spec = { command: "uvx", args: [u.package, ...u.args ?? []], env: u.env };
+    installHint = `uvx ${u.package}` + (u.args ? " " + u.args.join(" ") : "");
+  }
+  if (!spec) return null;
+  return {
+    id: o.id,
+    label: o.name,
+    spec,
+    installHint,
+    install: install5,
+    homepage: o.website ?? o.repository
+  };
+}
+var REGISTRY_URL, DEFAULT_TTL_MS;
+var init_registry_fetch = __esm({
+  "../acp-runtime/src/registry-fetch.ts"() {
+    "use strict";
+    REGISTRY_URL = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
+    DEFAULT_TTL_MS = 60 * 60 * 1e3;
+  }
+});
+
+// ../acp-runtime/src/registry.ts
+import { spawn as spawn4, spawnSync } from "node:child_process";
+async function loadRegistry(opts) {
+  if (_mergedCache && !opts?.forceRefresh) return _mergedCache;
+  let officialMapped = [];
+  try {
+    const reg = await fetchOfficialRegistry({ cachePath: opts?.cachePath, ttlMs: opts?.ttlMs });
+    for (const o of reg.agents) {
+      const m = mapOfficialAgent(o);
+      if (m) officialMapped.push(m);
+    }
+  } catch (e) {
+    process.stderr.write(
+      `! ACP registry fetch failed (${e.message}); using OMA overlay only
+`
+    );
+    officialMapped = [];
+  }
+  _mergedCache = mergeOverlay(officialMapped, OMA_OVERLAY_AGENTS);
+  _npmGlobalCache = snapshotNpmGlobal();
+  _uvToolCache = snapshotUvTool();
+  return _mergedCache;
+}
+function getKnownAgents() {
+  return _mergedCache ?? OMA_OVERLAY_AGENTS;
+}
+function resolveKnownAgent(id) {
+  const list = getKnownAgents();
+  for (const e of list) {
+    if (e.id === id) return e;
+    if (e.aliases?.includes(id)) return e;
+  }
+  return null;
+}
+function mergeOverlay(official, overlay) {
+  const overlayById = new Map(overlay.map((e) => [e.id, e]));
+  const seenOverlay = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const o of official) {
+    const ov = overlayById.get(o.id);
+    if (ov) {
+      seenOverlay.add(o.id);
+      merged.push({
+        id: o.id,
+        label: ov.label || o.label,
+        spec: ov.spec,
+        // overlay wins — usually carries our preferred binary
+        installHint: ov.installHint || o.installHint,
+        homepage: ov.homepage || o.homepage,
+        aliases: ov.aliases,
+        featured: ov.featured,
+        wraps: ov.wraps,
+        // Overlay's install wins when set (lets us pin a specific
+        // package). When unset, fall back to whatever mapOfficialAgent
+        // derived from the live registry — that's how codex-acp picks
+        // up its per-platform archives without overlay duplicating
+        // version-pinned URLs that bit-rot.
+        install: ov.install ?? o.install
+      });
+    } else {
+      merged.push(o);
+    }
+  }
+  for (const ov of overlay) {
+    if (!seenOverlay.has(ov.id)) merged.push(ov);
+  }
+  return merged;
+}
+async function detect(id) {
+  const entry = resolveKnownAgent(id);
+  if (!entry) return null;
+  if (!await isOnPath(entry.spec.command)) return null;
+  if (entry.spec.command === "npx" && !isNpxPackageInstalled(entry)) return null;
+  if (entry.spec.command === "uvx" && !isUvxPackageInstalled(entry)) return null;
+  return entry;
+}
+function isNpxPackageInstalled(entry) {
+  const pkgSpec = entry.spec.args?.[1];
+  if (!pkgSpec) return false;
+  const lastAt = pkgSpec.lastIndexOf("@");
+  const pkgName = lastAt > 0 ? pkgSpec.slice(0, lastAt) : pkgSpec;
+  const cache = _npmGlobalCache ?? (_npmGlobalCache = snapshotNpmGlobal());
+  return cache.has(pkgName);
+}
+function isUvxPackageInstalled(entry) {
+  const pkgSpec = entry.spec.args?.[0];
+  if (!pkgSpec) return false;
+  let pkgName = pkgSpec;
+  for (const sep of ["==", "@"]) {
+    const idx = pkgName.indexOf(sep, 1);
+    if (idx > 0) {
+      pkgName = pkgName.slice(0, idx);
+      break;
+    }
+  }
+  const cache = _uvToolCache ?? (_uvToolCache = snapshotUvTool());
+  return cache.has(pkgName);
+}
+function snapshotNpmGlobal() {
+  try {
+    const r = spawnSync("npm", ["ls", "-g", "--depth=0", "--parseable"], {
+      encoding: "utf-8",
+      timeout: 1e4
+    });
+    if (r.status !== 0 && !r.stdout) return /* @__PURE__ */ new Set();
+    const out = /* @__PURE__ */ new Set();
+    for (const line of (r.stdout ?? "").split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const idx = trimmed.lastIndexOf("/node_modules/");
+      if (idx < 0) continue;
+      const tail = trimmed.slice(idx + "/node_modules/".length);
+      if (!tail) continue;
+      out.add(tail);
+    }
+    return out;
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function snapshotUvTool() {
+  try {
+    const r = spawnSync("uv", ["tool", "list"], { encoding: "utf-8", timeout: 1e4 });
+    if (r.status !== 0 && !r.stdout) return /* @__PURE__ */ new Set();
+    const out = /* @__PURE__ */ new Set();
+    for (const line of (r.stdout ?? "").split("\n")) {
+      if (!line || line.startsWith(" ") || line.startsWith("warning:")) continue;
+      const m = line.match(/^([a-zA-Z0-9._-]+)\s+v?\d/);
+      if (m) out.add(m[1]);
+    }
+    return out;
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function isOnPath(cmd) {
+  return new Promise((resolve) => {
+    const probe = process.platform === "win32" ? "where" : "which";
+    const p = spawn4(probe, [cmd], { stdio: "ignore" });
+    p.once("error", () => resolve(false));
+    p.once("exit", (code) => resolve(code === 0));
+  });
+}
+async function detectAll() {
+  const list = getKnownAgents();
+  const results = await Promise.all(list.map((e) => detect(e.id)));
+  return results.filter((e) => e !== null);
+}
+var _mergedCache, _npmGlobalCache, _uvToolCache;
+var init_registry = __esm({
+  "../acp-runtime/src/registry.ts"() {
+    "use strict";
+    init_known_agents();
+    init_registry_fetch();
+    init_known_agents();
+    init_known_agents();
+    _mergedCache = null;
+    _npmGlobalCache = null;
+    _uvToolCache = null;
+  }
+});
+
 // src/bridge/lib/style.ts
 function wrap(open, close) {
   return (s) => isTty ? `\x1B[${open}m${s}\x1B[${close}m` : s;
@@ -387,9 +1009,9 @@ var init_version = __esm({
     "use strict";
     req = createRequire(import.meta.url);
     PKG_VERSION = (() => {
-      for (const path of ["../package.json", "../../package.json"]) {
+      for (const path2 of ["../package.json", "../../package.json"]) {
         try {
-          return req(path).version;
+          return req(path2).version;
         } catch {
         }
       }
@@ -2693,8 +3315,8 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes3, createHash: createHash2 } = __require("crypto");
-    var { Duplex, Readable: Readable2 } = __require("stream");
+    var { randomBytes: randomBytes4, createHash: createHash2 } = __require("crypto");
+    var { Duplex, Readable: Readable3 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate = require_permessage_deflate();
     var Receiver2 = require_receiver();
@@ -3220,7 +3842,7 @@ var require_websocket = __commonJS({
         }
       }
       const defaultPort = isSecure ? 443 : 80;
-      const key = randomBytes3(16).toString("base64");
+      const key = randomBytes4(16).toString("base64");
       const request = isSecure ? https.request : http.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
@@ -4056,22 +4678,2410 @@ async function probeRuntimeToken(serverUrl, token, timeoutMs = 8e3) {
       if (status === 401 || status === 403 || status === 404) {
         settle({ ok: false, reason: "invalid", detail: `HTTP ${status}` });
       } else {
-        settle({ ok: true });
+        settle({ ok: true });
+      }
+    });
+    ws.once("error", (e) => {
+      clearTimeout(timer);
+      settle({
+        ok: false,
+        reason: "unreachable",
+        detail: e instanceof Error ? e.message : String(e)
+      });
+    });
+  });
+}
+var init_probe = __esm({
+  "src/bridge/lib/probe.ts"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/key.js
+var isUpKey, isDownKey, isSpaceKey, isNumberKey, isEnterKey;
+var init_key = __esm({
+  "../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/key.js"() {
+    isUpKey = (key, keybindings = []) => (
+      // The up key
+      key.name === "up" || // Vim keybinding: hjkl keys map to left/down/up/right
+      keybindings.includes("vim") && key.name === "k" || // Emacs keybinding: Ctrl+P means "previous" in Emacs navigation conventions
+      keybindings.includes("emacs") && key.ctrl && key.name === "p"
+    );
+    isDownKey = (key, keybindings = []) => (
+      // The down key
+      key.name === "down" || // Vim keybinding: hjkl keys map to left/down/up/right
+      keybindings.includes("vim") && key.name === "j" || // Emacs keybinding: Ctrl+N means "next" in Emacs navigation conventions
+      keybindings.includes("emacs") && key.ctrl && key.name === "n"
+    );
+    isSpaceKey = (key) => key.name === "space";
+    isNumberKey = (key) => "1234567890".includes(key.name);
+    isEnterKey = (key) => key.name === "enter" || key.name === "return";
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/errors.js
+var AbortPromptError, CancelPromptError, ExitPromptError, HookError, ValidationError;
+var init_errors = __esm({
+  "../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/errors.js"() {
+    AbortPromptError = class extends Error {
+      name = "AbortPromptError";
+      message = "Prompt was aborted";
+      constructor(options) {
+        super();
+        this.cause = options?.cause;
+      }
+    };
+    CancelPromptError = class extends Error {
+      name = "CancelPromptError";
+      message = "Prompt was canceled";
+    };
+    ExitPromptError = class extends Error {
+      name = "ExitPromptError";
+    };
+    HookError = class extends Error {
+      name = "HookError";
+    };
+    ValidationError = class extends Error {
+      name = "ValidationError";
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/hook-engine.js
+import { AsyncLocalStorage, AsyncResource } from "node:async_hooks";
+function createStore(rl) {
+  const store = {
+    rl,
+    hooks: [],
+    hooksCleanup: [],
+    hooksEffect: [],
+    index: 0,
+    handleChange() {
+    }
+  };
+  return store;
+}
+function withHooks(rl, cb) {
+  const store = createStore(rl);
+  return hookStorage.run(store, () => {
+    function cycle(render) {
+      store.handleChange = () => {
+        store.index = 0;
+        render();
+      };
+      store.handleChange();
+    }
+    return cb(cycle);
+  });
+}
+function getStore() {
+  const store = hookStorage.getStore();
+  if (!store) {
+    throw new HookError("[Inquirer] Hook functions can only be called from within a prompt");
+  }
+  return store;
+}
+function readline() {
+  return getStore().rl;
+}
+function withUpdates(fn) {
+  const wrapped = (...args) => {
+    const store = getStore();
+    let shouldUpdate = false;
+    const oldHandleChange = store.handleChange;
+    store.handleChange = () => {
+      shouldUpdate = true;
+    };
+    const returnValue = fn(...args);
+    if (shouldUpdate) {
+      oldHandleChange();
+    }
+    store.handleChange = oldHandleChange;
+    return returnValue;
+  };
+  return AsyncResource.bind(wrapped);
+}
+function withPointer(cb) {
+  const store = getStore();
+  const { index } = store;
+  const pointer = {
+    get() {
+      return store.hooks[index];
+    },
+    set(value) {
+      store.hooks[index] = value;
+    },
+    initialized: index in store.hooks
+  };
+  const returnValue = cb(pointer);
+  store.index++;
+  return returnValue;
+}
+function handleChange() {
+  getStore().handleChange();
+}
+var hookStorage, effectScheduler;
+var init_hook_engine = __esm({
+  "../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/hook-engine.js"() {
+    init_errors();
+    hookStorage = new AsyncLocalStorage();
+    effectScheduler = {
+      queue(cb) {
+        const store = getStore();
+        const { index } = store;
+        store.hooksEffect.push(() => {
+          store.hooksCleanup[index]?.();
+          const cleanFn = cb(readline());
+          if (cleanFn != null && typeof cleanFn !== "function") {
+            throw new ValidationError("useEffect return value must be a cleanup function or nothing.");
+          }
+          store.hooksCleanup[index] = cleanFn;
+        });
+      },
+      run() {
+        const store = getStore();
+        withUpdates(() => {
+          store.hooksEffect.forEach((effect) => {
+            effect();
+          });
+          store.hooksEffect.length = 0;
+        })();
+      },
+      clearAll() {
+        const store = getStore();
+        store.hooksCleanup.forEach((cleanFn) => {
+          cleanFn?.();
+        });
+        store.hooksEffect.length = 0;
+        store.hooksCleanup.length = 0;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/use-state.js
+import { AsyncResource as AsyncResource2 } from "node:async_hooks";
+function isFactory(value) {
+  return typeof value === "function";
+}
+function useState(defaultValue) {
+  return withPointer((pointer) => {
+    const setState = AsyncResource2.bind(function setState2(newValue) {
+      if (pointer.get() !== newValue) {
+        pointer.set(newValue);
+        handleChange();
+      }
+    });
+    if (pointer.initialized) {
+      return [pointer.get(), setState];
+    }
+    const value = isFactory(defaultValue) ? defaultValue() : defaultValue;
+    pointer.set(value);
+    return [value, setState];
+  });
+}
+var init_use_state = __esm({
+  "../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/use-state.js"() {
+    init_hook_engine();
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/use-effect.js
+function useEffect(cb, depArray) {
+  withPointer((pointer) => {
+    const oldDeps = pointer.get();
+    const hasChanged = !Array.isArray(oldDeps) || depArray.some((dep, i) => !Object.is(dep, oldDeps[i]));
+    if (hasChanged) {
+      effectScheduler.queue(cb);
+    }
+    pointer.set(depArray);
+  });
+}
+var init_use_effect = __esm({
+  "../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/use-effect.js"() {
+    init_hook_engine();
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+figures@2.0.5/node_modules/@inquirer/figures/dist/index.js
+import process2 from "node:process";
+function isUnicodeSupported() {
+  if (!process2.platform.startsWith("win")) {
+    return process2.env["TERM"] !== "linux";
+  }
+  return Boolean(process2.env["CI"]) || // CI environments generally support unicode
+  Boolean(process2.env["WT_SESSION"]) || // Windows Terminal
+  Boolean(process2.env["TERMINUS_SUBLIME"]) || // Terminus (<0.2.27)
+  process2.env["ConEmuTask"] === "{cmd::Cmder}" || // ConEmu and cmder
+  process2.env["TERM_PROGRAM"] === "Terminus-Sublime" || process2.env["TERM_PROGRAM"] === "vscode" || process2.env["TERM"] === "xterm-256color" || process2.env["TERM"] === "alacritty" || process2.env["TERMINAL_EMULATOR"] === "JetBrains-JediTerm";
+}
+var common, specialMainSymbols, specialFallbackSymbols, mainSymbols, fallbackSymbols, shouldUseMain, figures, dist_default, replacements;
+var init_dist = __esm({
+  "../../node_modules/.pnpm/@inquirer+figures@2.0.5/node_modules/@inquirer/figures/dist/index.js"() {
+    common = {
+      circleQuestionMark: "(?)",
+      questionMarkPrefix: "(?)",
+      square: "\u2588",
+      squareDarkShade: "\u2593",
+      squareMediumShade: "\u2592",
+      squareLightShade: "\u2591",
+      squareTop: "\u2580",
+      squareBottom: "\u2584",
+      squareLeft: "\u258C",
+      squareRight: "\u2590",
+      squareCenter: "\u25A0",
+      bullet: "\u25CF",
+      dot: "\u2024",
+      ellipsis: "\u2026",
+      pointerSmall: "\u203A",
+      triangleUp: "\u25B2",
+      triangleUpSmall: "\u25B4",
+      triangleDown: "\u25BC",
+      triangleDownSmall: "\u25BE",
+      triangleLeftSmall: "\u25C2",
+      triangleRightSmall: "\u25B8",
+      home: "\u2302",
+      heart: "\u2665",
+      musicNote: "\u266A",
+      musicNoteBeamed: "\u266B",
+      arrowUp: "\u2191",
+      arrowDown: "\u2193",
+      arrowLeft: "\u2190",
+      arrowRight: "\u2192",
+      arrowLeftRight: "\u2194",
+      arrowUpDown: "\u2195",
+      almostEqual: "\u2248",
+      notEqual: "\u2260",
+      lessOrEqual: "\u2264",
+      greaterOrEqual: "\u2265",
+      identical: "\u2261",
+      infinity: "\u221E",
+      subscriptZero: "\u2080",
+      subscriptOne: "\u2081",
+      subscriptTwo: "\u2082",
+      subscriptThree: "\u2083",
+      subscriptFour: "\u2084",
+      subscriptFive: "\u2085",
+      subscriptSix: "\u2086",
+      subscriptSeven: "\u2087",
+      subscriptEight: "\u2088",
+      subscriptNine: "\u2089",
+      oneHalf: "\xBD",
+      oneThird: "\u2153",
+      oneQuarter: "\xBC",
+      oneFifth: "\u2155",
+      oneSixth: "\u2159",
+      oneEighth: "\u215B",
+      twoThirds: "\u2154",
+      twoFifths: "\u2156",
+      threeQuarters: "\xBE",
+      threeFifths: "\u2157",
+      threeEighths: "\u215C",
+      fourFifths: "\u2158",
+      fiveSixths: "\u215A",
+      fiveEighths: "\u215D",
+      sevenEighths: "\u215E",
+      line: "\u2500",
+      lineBold: "\u2501",
+      lineDouble: "\u2550",
+      lineDashed0: "\u2504",
+      lineDashed1: "\u2505",
+      lineDashed2: "\u2508",
+      lineDashed3: "\u2509",
+      lineDashed4: "\u254C",
+      lineDashed5: "\u254D",
+      lineDashed6: "\u2574",
+      lineDashed7: "\u2576",
+      lineDashed8: "\u2578",
+      lineDashed9: "\u257A",
+      lineDashed10: "\u257C",
+      lineDashed11: "\u257E",
+      lineDashed12: "\u2212",
+      lineDashed13: "\u2013",
+      lineDashed14: "\u2010",
+      lineDashed15: "\u2043",
+      lineVertical: "\u2502",
+      lineVerticalBold: "\u2503",
+      lineVerticalDouble: "\u2551",
+      lineVerticalDashed0: "\u2506",
+      lineVerticalDashed1: "\u2507",
+      lineVerticalDashed2: "\u250A",
+      lineVerticalDashed3: "\u250B",
+      lineVerticalDashed4: "\u254E",
+      lineVerticalDashed5: "\u254F",
+      lineVerticalDashed6: "\u2575",
+      lineVerticalDashed7: "\u2577",
+      lineVerticalDashed8: "\u2579",
+      lineVerticalDashed9: "\u257B",
+      lineVerticalDashed10: "\u257D",
+      lineVerticalDashed11: "\u257F",
+      lineDownLeft: "\u2510",
+      lineDownLeftArc: "\u256E",
+      lineDownBoldLeftBold: "\u2513",
+      lineDownBoldLeft: "\u2512",
+      lineDownLeftBold: "\u2511",
+      lineDownDoubleLeftDouble: "\u2557",
+      lineDownDoubleLeft: "\u2556",
+      lineDownLeftDouble: "\u2555",
+      lineDownRight: "\u250C",
+      lineDownRightArc: "\u256D",
+      lineDownBoldRightBold: "\u250F",
+      lineDownBoldRight: "\u250E",
+      lineDownRightBold: "\u250D",
+      lineDownDoubleRightDouble: "\u2554",
+      lineDownDoubleRight: "\u2553",
+      lineDownRightDouble: "\u2552",
+      lineUpLeft: "\u2518",
+      lineUpLeftArc: "\u256F",
+      lineUpBoldLeftBold: "\u251B",
+      lineUpBoldLeft: "\u251A",
+      lineUpLeftBold: "\u2519",
+      lineUpDoubleLeftDouble: "\u255D",
+      lineUpDoubleLeft: "\u255C",
+      lineUpLeftDouble: "\u255B",
+      lineUpRight: "\u2514",
+      lineUpRightArc: "\u2570",
+      lineUpBoldRightBold: "\u2517",
+      lineUpBoldRight: "\u2516",
+      lineUpRightBold: "\u2515",
+      lineUpDoubleRightDouble: "\u255A",
+      lineUpDoubleRight: "\u2559",
+      lineUpRightDouble: "\u2558",
+      lineUpDownLeft: "\u2524",
+      lineUpBoldDownBoldLeftBold: "\u252B",
+      lineUpBoldDownBoldLeft: "\u2528",
+      lineUpDownLeftBold: "\u2525",
+      lineUpBoldDownLeftBold: "\u2529",
+      lineUpDownBoldLeftBold: "\u252A",
+      lineUpDownBoldLeft: "\u2527",
+      lineUpBoldDownLeft: "\u2526",
+      lineUpDoubleDownDoubleLeftDouble: "\u2563",
+      lineUpDoubleDownDoubleLeft: "\u2562",
+      lineUpDownLeftDouble: "\u2561",
+      lineUpDownRight: "\u251C",
+      lineUpBoldDownBoldRightBold: "\u2523",
+      lineUpBoldDownBoldRight: "\u2520",
+      lineUpDownRightBold: "\u251D",
+      lineUpBoldDownRightBold: "\u2521",
+      lineUpDownBoldRightBold: "\u2522",
+      lineUpDownBoldRight: "\u251F",
+      lineUpBoldDownRight: "\u251E",
+      lineUpDoubleDownDoubleRightDouble: "\u2560",
+      lineUpDoubleDownDoubleRight: "\u255F",
+      lineUpDownRightDouble: "\u255E",
+      lineDownLeftRight: "\u252C",
+      lineDownBoldLeftBoldRightBold: "\u2533",
+      lineDownLeftBoldRightBold: "\u252F",
+      lineDownBoldLeftRight: "\u2530",
+      lineDownBoldLeftBoldRight: "\u2531",
+      lineDownBoldLeftRightBold: "\u2532",
+      lineDownLeftRightBold: "\u252E",
+      lineDownLeftBoldRight: "\u252D",
+      lineDownDoubleLeftDoubleRightDouble: "\u2566",
+      lineDownDoubleLeftRight: "\u2565",
+      lineDownLeftDoubleRightDouble: "\u2564",
+      lineUpLeftRight: "\u2534",
+      lineUpBoldLeftBoldRightBold: "\u253B",
+      lineUpLeftBoldRightBold: "\u2537",
+      lineUpBoldLeftRight: "\u2538",
+      lineUpBoldLeftBoldRight: "\u2539",
+      lineUpBoldLeftRightBold: "\u253A",
+      lineUpLeftRightBold: "\u2536",
+      lineUpLeftBoldRight: "\u2535",
+      lineUpDoubleLeftDoubleRightDouble: "\u2569",
+      lineUpDoubleLeftRight: "\u2568",
+      lineUpLeftDoubleRightDouble: "\u2567",
+      lineUpDownLeftRight: "\u253C",
+      lineUpBoldDownBoldLeftBoldRightBold: "\u254B",
+      lineUpDownBoldLeftBoldRightBold: "\u2548",
+      lineUpBoldDownLeftBoldRightBold: "\u2547",
+      lineUpBoldDownBoldLeftRightBold: "\u254A",
+      lineUpBoldDownBoldLeftBoldRight: "\u2549",
+      lineUpBoldDownLeftRight: "\u2540",
+      lineUpDownBoldLeftRight: "\u2541",
+      lineUpDownLeftBoldRight: "\u253D",
+      lineUpDownLeftRightBold: "\u253E",
+      lineUpBoldDownBoldLeftRight: "\u2542",
+      lineUpDownLeftBoldRightBold: "\u253F",
+      lineUpBoldDownLeftBoldRight: "\u2543",
+      lineUpBoldDownLeftRightBold: "\u2544",
+      lineUpDownBoldLeftBoldRight: "\u2545",
+      lineUpDownBoldLeftRightBold: "\u2546",
+      lineUpDoubleDownDoubleLeftDoubleRightDouble: "\u256C",
+      lineUpDoubleDownDoubleLeftRight: "\u256B",
+      lineUpDownLeftDoubleRightDouble: "\u256A",
+      lineCross: "\u2573",
+      lineBackslash: "\u2572",
+      lineSlash: "\u2571"
+    };
+    specialMainSymbols = {
+      tick: "\u2714",
+      info: "\u2139",
+      warning: "\u26A0",
+      cross: "\u2718",
+      squareSmall: "\u25FB",
+      squareSmallFilled: "\u25FC",
+      circle: "\u25EF",
+      circleFilled: "\u25C9",
+      circleDotted: "\u25CC",
+      circleDouble: "\u25CE",
+      circleCircle: "\u24DE",
+      circleCross: "\u24E7",
+      circlePipe: "\u24BE",
+      radioOn: "\u25C9",
+      radioOff: "\u25EF",
+      checkboxOn: "\u2612",
+      checkboxOff: "\u2610",
+      checkboxCircleOn: "\u24E7",
+      checkboxCircleOff: "\u24BE",
+      pointer: "\u276F",
+      triangleUpOutline: "\u25B3",
+      triangleLeft: "\u25C0",
+      triangleRight: "\u25B6",
+      lozenge: "\u25C6",
+      lozengeOutline: "\u25C7",
+      hamburger: "\u2630",
+      smiley: "\u32E1",
+      mustache: "\u0DF4",
+      star: "\u2605",
+      play: "\u25B6",
+      nodejs: "\u2B22",
+      oneSeventh: "\u2150",
+      oneNinth: "\u2151",
+      oneTenth: "\u2152"
+    };
+    specialFallbackSymbols = {
+      tick: "\u221A",
+      info: "i",
+      warning: "\u203C",
+      cross: "\xD7",
+      squareSmall: "\u25A1",
+      squareSmallFilled: "\u25A0",
+      circle: "( )",
+      circleFilled: "(*)",
+      circleDotted: "( )",
+      circleDouble: "( )",
+      circleCircle: "(\u25CB)",
+      circleCross: "(\xD7)",
+      circlePipe: "(\u2502)",
+      radioOn: "(*)",
+      radioOff: "( )",
+      checkboxOn: "[\xD7]",
+      checkboxOff: "[ ]",
+      checkboxCircleOn: "(\xD7)",
+      checkboxCircleOff: "( )",
+      pointer: ">",
+      triangleUpOutline: "\u2206",
+      triangleLeft: "\u25C4",
+      triangleRight: "\u25BA",
+      lozenge: "\u2666",
+      lozengeOutline: "\u25CA",
+      hamburger: "\u2261",
+      smiley: "\u263A",
+      mustache: "\u250C\u2500\u2510",
+      star: "\u2736",
+      play: "\u25BA",
+      nodejs: "\u2666",
+      oneSeventh: "1/7",
+      oneNinth: "1/9",
+      oneTenth: "1/10"
+    };
+    mainSymbols = {
+      ...common,
+      ...specialMainSymbols
+    };
+    fallbackSymbols = {
+      ...common,
+      ...specialFallbackSymbols
+    };
+    shouldUseMain = isUnicodeSupported();
+    figures = shouldUseMain ? mainSymbols : fallbackSymbols;
+    dist_default = figures;
+    replacements = Object.entries(specialMainSymbols);
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/theme.js
+import { styleText } from "node:util";
+var defaultTheme;
+var init_theme = __esm({
+  "../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/theme.js"() {
+    init_dist();
+    defaultTheme = {
+      prefix: {
+        idle: styleText("blue", "?"),
+        done: styleText("green", dist_default.tick)
+      },
+      spinner: {
+        interval: 80,
+        frames: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"].map((frame) => styleText("yellow", frame))
+      },
+      style: {
+        answer: (text) => styleText("cyan", text),
+        message: (text) => styleText("bold", text),
+        error: (text) => styleText("red", `> ${text}`),
+        defaultAnswer: (text) => styleText("dim", `(${text})`),
+        help: (text) => styleText("dim", text),
+        highlight: (text) => styleText("cyan", text),
+        key: (text) => styleText("cyan", styleText("bold", `<${text}>`))
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/make-theme.js
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  let proto = value;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(value) === proto;
+}
+function deepMerge(...objects) {
+  const output = {};
+  for (const obj of objects) {
+    for (const [key, value] of Object.entries(obj)) {
+      const prevValue = output[key];
+      output[key] = isPlainObject(prevValue) && isPlainObject(value) ? deepMerge(prevValue, value) : value;
+    }
+  }
+  return output;
+}
+function makeTheme(...themes) {
+  const themesToMerge = [
+    defaultTheme,
+    ...themes.filter((theme) => theme != null)
+  ];
+  return deepMerge(...themesToMerge);
+}
+var init_make_theme = __esm({
+  "../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/make-theme.js"() {
+    init_theme();
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/use-prefix.js
+function usePrefix({ status = "idle", theme }) {
+  const [showLoader, setShowLoader] = useState(false);
+  const [tick, setTick] = useState(0);
+  const { prefix, spinner } = makeTheme(theme);
+  useEffect(() => {
+    if (status === "loading") {
+      let tickInterval;
+      let inc = -1;
+      const delayTimeout = setTimeout(() => {
+        setShowLoader(true);
+        tickInterval = setInterval(() => {
+          inc = inc + 1;
+          setTick(inc % spinner.frames.length);
+        }, spinner.interval);
+      }, 300);
+      return () => {
+        clearTimeout(delayTimeout);
+        clearInterval(tickInterval);
+      };
+    } else {
+      setShowLoader(false);
+    }
+  }, [status]);
+  if (showLoader) {
+    return spinner.frames[tick];
+  }
+  const iconName = status === "loading" ? "idle" : status;
+  return typeof prefix === "string" ? prefix : prefix[iconName] ?? prefix["idle"];
+}
+var init_use_prefix = __esm({
+  "../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/use-prefix.js"() {
+    init_use_state();
+    init_use_effect();
+    init_make_theme();
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/use-memo.js
+function useMemo(fn, dependencies) {
+  return withPointer((pointer) => {
+    const prev = pointer.get();
+    if (!prev || prev.dependencies.length !== dependencies.length || prev.dependencies.some((dep, i) => dep !== dependencies[i])) {
+      const value = fn();
+      pointer.set({ value, dependencies });
+      return value;
+    }
+    return prev.value;
+  });
+}
+var init_use_memo = __esm({
+  "../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/use-memo.js"() {
+    init_hook_engine();
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/use-ref.js
+function useRef(val) {
+  return useState({ current: val })[0];
+}
+var init_use_ref = __esm({
+  "../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/use-ref.js"() {
+    init_use_state();
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/use-keypress.js
+function useKeypress(userHandler) {
+  const signal = useRef(userHandler);
+  signal.current = userHandler;
+  useEffect((rl) => {
+    let ignore = false;
+    const handler = withUpdates((_input, event) => {
+      if (ignore)
+        return;
+      void signal.current(event, rl);
+    });
+    rl.input.on("keypress", handler);
+    return () => {
+      ignore = true;
+      rl.input.removeListener("keypress", handler);
+    };
+  }, []);
+}
+var init_use_keypress = __esm({
+  "../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/use-keypress.js"() {
+    init_use_ref();
+    init_use_effect();
+    init_hook_engine();
+  }
+});
+
+// ../../node_modules/.pnpm/cli-width@4.1.0/node_modules/cli-width/index.js
+var require_cli_width = __commonJS({
+  "../../node_modules/.pnpm/cli-width@4.1.0/node_modules/cli-width/index.js"(exports, module) {
+    "use strict";
+    module.exports = cliWidth2;
+    function normalizeOpts(options) {
+      const defaultOpts = {
+        defaultWidth: 0,
+        output: process.stdout,
+        tty: __require("tty")
+      };
+      if (!options) {
+        return defaultOpts;
+      }
+      Object.keys(defaultOpts).forEach(function(key) {
+        if (!options[key]) {
+          options[key] = defaultOpts[key];
+        }
+      });
+      return options;
+    }
+    function cliWidth2(options) {
+      const opts = normalizeOpts(options);
+      if (opts.output.getWindowSize) {
+        return opts.output.getWindowSize()[0] || opts.defaultWidth;
+      }
+      if (opts.tty.getWindowSize) {
+        return opts.tty.getWindowSize()[1] || opts.defaultWidth;
+      }
+      if (opts.output.columns) {
+        return opts.output.columns;
+      }
+      if (process.env.CLI_WIDTH) {
+        const width = parseInt(process.env.CLI_WIDTH, 10);
+        if (!isNaN(width) && width !== 0) {
+          return width;
+        }
+      }
+      return opts.defaultWidth;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength, isFullWidth, isWideNotCJKTNotEmoji;
+var init_utils = __esm({
+  "../../node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/utils.js"() {
+    getCodePointsLength = /* @__PURE__ */ (() => {
+      const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+      return (input) => {
+        let surrogatePairsNr = 0;
+        SURROGATE_PAIR_RE.lastIndex = 0;
+        while (SURROGATE_PAIR_RE.test(input)) {
+          surrogatePairsNr += 1;
+        }
+        return input.length - surrogatePairsNr;
+      };
+    })();
+    isFullWidth = (x) => {
+      return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+    };
+    isWideNotCJKTNotEmoji = (x) => {
+      return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE, CONTROL_RE, CJKT_WIDE_RE, TAB_RE, EMOJI_RE, LATIN_RE, MODIFIER_RE, NO_TRUNCATION, getStringTruncatedWidth, dist_default2;
+var init_dist2 = __esm({
+  "../../node_modules/.pnpm/fast-string-truncated-width@3.0.3/node_modules/fast-string-truncated-width/dist/index.js"() {
+    init_utils();
+    ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+    CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+    CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+    TAB_RE = /\t{1,1000}/y;
+    EMOJI_RE = /[\u{1F1E6}-\u{1F1FF}]{2}|\u{1F3F4}[\u{E0061}-\u{E007A}]{2}[\u{E0030}-\u{E0039}\u{E0061}-\u{E007A}]{1,3}\u{E007F}|(?:\p{Emoji}\uFE0F\u20E3?|\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation})(?:\u200D(?:\p{Emoji_Modifier_Base}\p{Emoji_Modifier}?|\p{Emoji_Presentation}|\p{Emoji}\uFE0F\u20E3?))*/yu;
+    LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+    MODIFIER_RE = /\p{M}+/gu;
+    NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
+    getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+      const LIMIT = truncationOptions.limit ?? Infinity;
+      const ELLIPSIS = truncationOptions.ellipsis ?? "";
+      const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+      const ANSI_WIDTH = 0;
+      const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+      const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+      const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+      const FULL_WIDTH_WIDTH = 2;
+      const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+      const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+      const PARSE_BLOCKS = [
+        [LATIN_RE, REGULAR_WIDTH],
+        [ANSI_RE, ANSI_WIDTH],
+        [CONTROL_RE, CONTROL_WIDTH],
+        [TAB_RE, TAB_WIDTH],
+        [EMOJI_RE, EMOJI_WIDTH],
+        [CJKT_WIDE_RE, WIDE_WIDTH]
+      ];
+      let indexPrev = 0;
+      let index = 0;
+      let length = input.length;
+      let lengthExtra = 0;
+      let truncationEnabled = false;
+      let truncationIndex = length;
+      let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+      let unmatchedStart = 0;
+      let unmatchedEnd = 0;
+      let width = 0;
+      let widthExtra = 0;
+      outer: while (true) {
+        if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+          const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+          lengthExtra = 0;
+          for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+            const codePoint = char.codePointAt(0) || 0;
+            if (isFullWidth(codePoint)) {
+              widthExtra = FULL_WIDTH_WIDTH;
+            } else if (isWideNotCJKTNotEmoji(codePoint)) {
+              widthExtra = WIDE_WIDTH;
+            } else {
+              widthExtra = REGULAR_WIDTH;
+            }
+            if (width + widthExtra > truncationLimit) {
+              truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+            }
+            if (width + widthExtra > LIMIT) {
+              truncationEnabled = true;
+              break outer;
+            }
+            lengthExtra += char.length;
+            width += widthExtra;
+          }
+          unmatchedStart = unmatchedEnd = 0;
+        }
+        if (index >= length) {
+          break outer;
+        }
+        for (let i = 0, l = PARSE_BLOCKS.length; i < l; i++) {
+          const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
+          BLOCK_RE.lastIndex = index;
+          if (BLOCK_RE.test(input)) {
+            lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+            widthExtra = lengthExtra * BLOCK_WIDTH;
+            if (width + widthExtra > truncationLimit) {
+              truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+            }
+            if (width + widthExtra > LIMIT) {
+              truncationEnabled = true;
+              break outer;
+            }
+            width += widthExtra;
+            unmatchedStart = indexPrev;
+            unmatchedEnd = index;
+            index = indexPrev = BLOCK_RE.lastIndex;
+            continue outer;
+          }
+        }
+        index += 1;
+      }
+      return {
+        width: truncationEnabled ? truncationLimit : width,
+        index: truncationEnabled ? truncationIndex : length,
+        truncated: truncationEnabled,
+        ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+      };
+    };
+    dist_default2 = getStringTruncatedWidth;
+  }
+});
+
+// ../../node_modules/.pnpm/fast-string-width@3.0.2/node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2, fastStringWidth, dist_default3;
+var init_dist3 = __esm({
+  "../../node_modules/.pnpm/fast-string-width@3.0.2/node_modules/fast-string-width/dist/index.js"() {
+    init_dist2();
+    NO_TRUNCATION2 = {
+      limit: Infinity,
+      ellipsis: "",
+      ellipsisWidth: 0
+    };
+    fastStringWidth = (input, options = {}) => {
+      return dist_default2(input, NO_TRUNCATION2, options).width;
+    };
+    dist_default3 = fastStringWidth;
+  }
+});
+
+// ../../node_modules/.pnpm/fast-wrap-ansi@0.2.0/node_modules/fast-wrap-ansi/lib/main.js
+function wrapAnsi(string4, columns, options) {
+  return String(string4).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join("\n");
+}
+var ESC, CSI, END_CODE, ANSI_ESCAPE_BELL, ANSI_CSI, ANSI_OSC, ANSI_SGR_TERMINATOR, ANSI_ESCAPE_LINK, GROUP_REGEX, getClosingCode, wrapAnsiCode, wrapAnsiHyperlink, wrapWord, stringVisibleTrimSpacesRight, exec, CRLF_OR_LF;
+var init_main = __esm({
+  "../../node_modules/.pnpm/fast-wrap-ansi@0.2.0/node_modules/fast-wrap-ansi/lib/main.js"() {
+    init_dist3();
+    ESC = "\x1B";
+    CSI = "\x9B";
+    END_CODE = 39;
+    ANSI_ESCAPE_BELL = "\x07";
+    ANSI_CSI = "[";
+    ANSI_OSC = "]";
+    ANSI_SGR_TERMINATOR = "m";
+    ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+    GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+    getClosingCode = (openingCode) => {
+      if (openingCode >= 30 && openingCode <= 37)
+        return 39;
+      if (openingCode >= 90 && openingCode <= 97)
+        return 39;
+      if (openingCode >= 40 && openingCode <= 47)
+        return 49;
+      if (openingCode >= 100 && openingCode <= 107)
+        return 49;
+      if (openingCode === 1 || openingCode === 2)
+        return 22;
+      if (openingCode === 3)
+        return 23;
+      if (openingCode === 4)
+        return 24;
+      if (openingCode === 7)
+        return 27;
+      if (openingCode === 8)
+        return 28;
+      if (openingCode === 9)
+        return 29;
+      if (openingCode === 0)
+        return 0;
+      return void 0;
+    };
+    wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+    wrapAnsiHyperlink = (url2) => `${ESC}${ANSI_ESCAPE_LINK}${url2}${ANSI_ESCAPE_BELL}`;
+    wrapWord = (rows, word, columns) => {
+      const characters = word[Symbol.iterator]();
+      let isInsideEscape = false;
+      let isInsideLinkEscape = false;
+      let lastRow = rows.at(-1);
+      let visible = lastRow === void 0 ? 0 : dist_default3(lastRow);
+      let currentCharacter = characters.next();
+      let nextCharacter = characters.next();
+      let rawCharacterIndex = 0;
+      while (!currentCharacter.done) {
+        const character = currentCharacter.value;
+        const characterLength = dist_default3(character);
+        if (visible + characterLength <= columns) {
+          rows[rows.length - 1] += character;
+        } else {
+          rows.push(character);
+          visible = 0;
+        }
+        if (character === ESC || character === CSI) {
+          isInsideEscape = true;
+          isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+        }
+        if (isInsideEscape) {
+          if (isInsideLinkEscape) {
+            if (character === ANSI_ESCAPE_BELL) {
+              isInsideEscape = false;
+              isInsideLinkEscape = false;
+            }
+          } else if (character === ANSI_SGR_TERMINATOR) {
+            isInsideEscape = false;
+          }
+        } else {
+          visible += characterLength;
+          if (visible === columns && !nextCharacter.done) {
+            rows.push("");
+            visible = 0;
+          }
+        }
+        currentCharacter = nextCharacter;
+        nextCharacter = characters.next();
+        rawCharacterIndex += character.length;
+      }
+      lastRow = rows.at(-1);
+      if (!visible && lastRow !== void 0 && lastRow.length && rows.length > 1) {
+        rows[rows.length - 2] += rows.pop();
+      }
+    };
+    stringVisibleTrimSpacesRight = (string4) => {
+      const words = string4.split(" ");
+      let last = words.length;
+      while (last) {
+        if (dist_default3(words[last - 1])) {
+          break;
+        }
+        last--;
+      }
+      if (last === words.length) {
+        return string4;
+      }
+      return words.slice(0, last).join(" ") + words.slice(last).join("");
+    };
+    exec = (string4, columns, options = {}) => {
+      if (options.trim !== false && string4.trim() === "") {
+        return "";
+      }
+      let returnValue = "";
+      let escapeCode;
+      let escapeUrl;
+      const words = string4.split(" ");
+      let rows = [""];
+      let rowLength = 0;
+      for (let index = 0; index < words.length; index++) {
+        const word = words[index];
+        if (options.trim !== false) {
+          const row = rows.at(-1) ?? "";
+          const trimmed = row.trimStart();
+          if (row.length !== trimmed.length) {
+            rows[rows.length - 1] = trimmed;
+            rowLength = dist_default3(trimmed);
+          }
+        }
+        if (index !== 0) {
+          if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+            rows.push("");
+            rowLength = 0;
+          }
+          if (rowLength || options.trim === false) {
+            rows[rows.length - 1] += " ";
+            rowLength++;
+          }
+        }
+        const wordLength = dist_default3(word);
+        if (options.hard && wordLength > columns) {
+          const remainingColumns = columns - rowLength;
+          const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+          const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+          if (breaksStartingNextLine < breaksStartingThisLine) {
+            rows.push("");
+          }
+          wrapWord(rows, word, columns);
+          rowLength = dist_default3(rows.at(-1) ?? "");
+          continue;
+        }
+        if (rowLength + wordLength > columns && rowLength && wordLength) {
+          if (options.wordWrap === false && rowLength < columns) {
+            wrapWord(rows, word, columns);
+            rowLength = dist_default3(rows.at(-1) ?? "");
+            continue;
+          }
+          rows.push("");
+          rowLength = 0;
+        }
+        if (rowLength + wordLength > columns && options.wordWrap === false) {
+          wrapWord(rows, word, columns);
+          rowLength = dist_default3(rows.at(-1) ?? "");
+          continue;
+        }
+        rows[rows.length - 1] += word;
+        rowLength += wordLength;
+      }
+      if (options.trim !== false) {
+        rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+      }
+      const preString = rows.join("\n");
+      let inSurrogate = false;
+      for (let i = 0; i < preString.length; i++) {
+        const character = preString[i];
+        returnValue += character;
+        if (!inSurrogate) {
+          inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+          if (inSurrogate) {
+            continue;
+          }
+        } else {
+          inSurrogate = false;
+        }
+        if (character === ESC || character === CSI) {
+          GROUP_REGEX.lastIndex = i + 1;
+          const groupsResult = GROUP_REGEX.exec(preString);
+          const groups = groupsResult?.groups;
+          if (groups?.code !== void 0) {
+            const code = Number.parseFloat(groups.code);
+            escapeCode = code === END_CODE ? void 0 : code;
+          } else if (groups?.uri !== void 0) {
+            escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+          }
+        }
+        if (preString[i + 1] === "\n") {
+          if (escapeUrl) {
+            returnValue += wrapAnsiHyperlink("");
+          }
+          const closingCode = escapeCode ? getClosingCode(escapeCode) : void 0;
+          if (escapeCode && closingCode) {
+            returnValue += wrapAnsiCode(closingCode);
+          }
+        } else if (character === "\n") {
+          if (escapeCode && getClosingCode(escapeCode)) {
+            returnValue += wrapAnsiCode(escapeCode);
+          }
+          if (escapeUrl) {
+            returnValue += wrapAnsiHyperlink(escapeUrl);
+          }
+        }
+      }
+      return returnValue;
+    };
+    CRLF_OR_LF = /\r?\n/;
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/utils.js
+function breakLines(content, width) {
+  return content.split("\n").flatMap((line) => wrapAnsi(line, width, { trim: false, hard: true }).split("\n").map((str) => str.trimEnd())).join("\n");
+}
+function readlineWidth() {
+  return (0, import_cli_width.default)({ defaultWidth: 80, output: readline().output });
+}
+var import_cli_width;
+var init_utils2 = __esm({
+  "../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/utils.js"() {
+    import_cli_width = __toESM(require_cli_width(), 1);
+    init_main();
+    init_hook_engine();
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/pagination/use-pagination.js
+function usePointerPosition({ active, renderedItems, pageSize, loop }) {
+  const state = useRef({
+    lastPointer: active,
+    lastActive: void 0
+  });
+  const { lastPointer, lastActive } = state.current;
+  const middle = Math.floor(pageSize / 2);
+  const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+  const defaultPointerPosition = renderedItems.slice(0, active).reduce((acc, item) => acc + item.length, 0);
+  let pointer = defaultPointerPosition;
+  if (renderedLength > pageSize) {
+    if (loop) {
+      pointer = lastPointer;
+      if (
+        // First render, skip this logic.
+        lastActive != null && // Only move the pointer down when the user moves down.
+        lastActive < active && // Check user didn't move up across page boundary.
+        active - lastActive < pageSize
+      ) {
+        pointer = Math.min(
+          // Furthest allowed position for the pointer is the middle of the list
+          middle,
+          Math.abs(active - lastActive) === 1 ? Math.min(
+            // Move the pointer at most the height of the last active item.
+            lastPointer + (renderedItems[lastActive]?.length ?? 0),
+            // If the user moved by one item, move the pointer to the natural position of the active item as
+            // long as it doesn't move the cursor up.
+            Math.max(defaultPointerPosition, lastPointer)
+          ) : (
+            // Otherwise, move the pointer down by the difference between the active and last active item.
+            lastPointer + active - lastActive
+          )
+        );
+      }
+    } else {
+      const spaceUnderActive = renderedItems.slice(active).reduce((acc, item) => acc + item.length, 0);
+      pointer = spaceUnderActive < pageSize - middle ? (
+        // If the active item is near the end of the list, progressively move the cursor towards the end.
+        pageSize - spaceUnderActive
+      ) : (
+        // Otherwise, progressively move the pointer to the middle of the list.
+        Math.min(defaultPointerPosition, middle)
+      );
+    }
+  }
+  state.current.lastPointer = pointer;
+  state.current.lastActive = active;
+  return pointer;
+}
+function usePagination({ items, active, renderItem, pageSize, loop = true }) {
+  const width = readlineWidth();
+  const bound = (num) => (num % items.length + items.length) % items.length;
+  const renderedItems = items.map((item, index) => {
+    if (item == null)
+      return [];
+    return breakLines(renderItem({ item, index, isActive: index === active }), width).split("\n");
+  });
+  const renderedLength = renderedItems.reduce((acc, item) => acc + item.length, 0);
+  const renderItemAtIndex = (index) => renderedItems[index] ?? [];
+  const pointer = usePointerPosition({ active, renderedItems, pageSize, loop });
+  const activeItem = renderItemAtIndex(active).slice(0, pageSize);
+  const activeItemPosition = pointer + activeItem.length <= pageSize ? pointer : pageSize - activeItem.length;
+  const pageBuffer = Array.from({ length: pageSize });
+  pageBuffer.splice(activeItemPosition, activeItem.length, ...activeItem);
+  const itemVisited = /* @__PURE__ */ new Set([active]);
+  let bufferPointer = activeItemPosition + activeItem.length;
+  let itemPointer = bound(active + 1);
+  while (bufferPointer < pageSize && !itemVisited.has(itemPointer) && (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer > active)) {
+    const lines = renderItemAtIndex(itemPointer);
+    const linesToAdd = lines.slice(0, pageSize - bufferPointer);
+    pageBuffer.splice(bufferPointer, linesToAdd.length, ...linesToAdd);
+    itemVisited.add(itemPointer);
+    bufferPointer += linesToAdd.length;
+    itemPointer = bound(itemPointer + 1);
+  }
+  bufferPointer = activeItemPosition - 1;
+  itemPointer = bound(active - 1);
+  while (bufferPointer >= 0 && !itemVisited.has(itemPointer) && (loop && renderedLength > pageSize ? itemPointer !== active : itemPointer < active)) {
+    const lines = renderItemAtIndex(itemPointer);
+    const linesToAdd = lines.slice(Math.max(0, lines.length - bufferPointer - 1));
+    pageBuffer.splice(bufferPointer - linesToAdd.length + 1, linesToAdd.length, ...linesToAdd);
+    itemVisited.add(itemPointer);
+    bufferPointer -= linesToAdd.length;
+    itemPointer = bound(itemPointer - 1);
+  }
+  return pageBuffer.filter((line) => typeof line === "string").join("\n");
+}
+var init_use_pagination = __esm({
+  "../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/pagination/use-pagination.js"() {
+    init_use_ref();
+    init_utils2();
+  }
+});
+
+// ../../node_modules/.pnpm/mute-stream@3.0.0/node_modules/mute-stream/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/.pnpm/mute-stream@3.0.0/node_modules/mute-stream/lib/index.js"(exports, module) {
+    var Stream = __require("stream");
+    var MuteStream2 = class extends Stream {
+      #isTTY = null;
+      constructor(opts = {}) {
+        super(opts);
+        this.writable = this.readable = true;
+        this.muted = false;
+        this.on("pipe", this._onpipe);
+        this.replace = opts.replace;
+        this._prompt = opts.prompt || null;
+        this._hadControl = false;
+      }
+      #destSrc(key, def) {
+        if (this._dest) {
+          return this._dest[key];
+        }
+        if (this._src) {
+          return this._src[key];
+        }
+        return def;
+      }
+      #proxy(method, ...args) {
+        if (typeof this._dest?.[method] === "function") {
+          this._dest[method](...args);
+        }
+        if (typeof this._src?.[method] === "function") {
+          this._src[method](...args);
+        }
+      }
+      get isTTY() {
+        if (this.#isTTY !== null) {
+          return this.#isTTY;
+        }
+        return this.#destSrc("isTTY", false);
+      }
+      // basically just get replace the getter/setter with a regular value
+      set isTTY(val) {
+        this.#isTTY = val;
+      }
+      get rows() {
+        return this.#destSrc("rows");
+      }
+      get columns() {
+        return this.#destSrc("columns");
+      }
+      mute() {
+        this.muted = true;
+      }
+      unmute() {
+        this.muted = false;
+      }
+      _onpipe(src) {
+        this._src = src;
+      }
+      pipe(dest, options) {
+        this._dest = dest;
+        return super.pipe(dest, options);
+      }
+      pause() {
+        if (this._src) {
+          return this._src.pause();
+        }
+      }
+      resume() {
+        if (this._src) {
+          return this._src.resume();
+        }
+      }
+      write(c3) {
+        if (this.muted) {
+          if (!this.replace) {
+            return true;
+          }
+          if (c3.match(/^\u001b/)) {
+            if (c3.indexOf(this._prompt) === 0) {
+              c3 = c3.slice(this._prompt.length);
+              c3 = c3.replace(/./g, this.replace);
+              c3 = this._prompt + c3;
+            }
+            this._hadControl = true;
+            return this.emit("data", c3);
+          } else {
+            if (this._prompt && this._hadControl && c3.indexOf(this._prompt) === 0) {
+              this._hadControl = false;
+              this.emit("data", this._prompt);
+              c3 = c3.slice(this._prompt.length);
+            }
+            c3 = c3.toString().replace(/./g, this.replace);
+          }
+        }
+        this.emit("data", c3);
+      }
+      end(c3) {
+        if (this.muted) {
+          if (c3 && this.replace) {
+            c3 = c3.toString().replace(/./g, this.replace);
+          } else {
+            c3 = null;
+          }
+        }
+        if (c3) {
+          this.emit("data", c3);
+        }
+        this.emit("end");
+      }
+      destroy(...args) {
+        return this.#proxy("destroy", ...args);
+      }
+      destroySoon(...args) {
+        return this.#proxy("destroySoon", ...args);
+      }
+      close(...args) {
+        return this.#proxy("close", ...args);
+      }
+    };
+    module.exports = MuteStream2;
+  }
+});
+
+// ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js
+var signals;
+var init_signals = __esm({
+  "../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js"() {
+    signals = [];
+    signals.push("SIGHUP", "SIGINT", "SIGTERM");
+    if (process.platform !== "win32") {
+      signals.push(
+        "SIGALRM",
+        "SIGABRT",
+        "SIGVTALRM",
+        "SIGXCPU",
+        "SIGXFSZ",
+        "SIGUSR2",
+        "SIGTRAP",
+        "SIGSYS",
+        "SIGQUIT",
+        "SIGIOT"
+        // should detect profiler and enable/disable accordingly.
+        // see #21
+        // 'SIGPROF'
+      );
+    }
+    if (process.platform === "linux") {
+      signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js
+var processOk, kExitEmitter, global, ObjectDefineProperty, Emitter, SignalExitBase, signalExitWrap, SignalExitFallback, SignalExit, process3, onExit, load, unload;
+var init_mjs = __esm({
+  "../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js"() {
+    init_signals();
+    processOk = (process4) => !!process4 && typeof process4 === "object" && typeof process4.removeListener === "function" && typeof process4.emit === "function" && typeof process4.reallyExit === "function" && typeof process4.listeners === "function" && typeof process4.kill === "function" && typeof process4.pid === "number" && typeof process4.on === "function";
+    kExitEmitter = Symbol.for("signal-exit emitter");
+    global = globalThis;
+    ObjectDefineProperty = Object.defineProperty.bind(Object);
+    Emitter = class {
+      emitted = {
+        afterExit: false,
+        exit: false
+      };
+      listeners = {
+        afterExit: [],
+        exit: []
+      };
+      count = 0;
+      id = Math.random();
+      constructor() {
+        if (global[kExitEmitter]) {
+          return global[kExitEmitter];
+        }
+        ObjectDefineProperty(global, kExitEmitter, {
+          value: this,
+          writable: false,
+          enumerable: false,
+          configurable: false
+        });
+      }
+      on(ev, fn) {
+        this.listeners[ev].push(fn);
+      }
+      removeListener(ev, fn) {
+        const list = this.listeners[ev];
+        const i = list.indexOf(fn);
+        if (i === -1) {
+          return;
+        }
+        if (i === 0 && list.length === 1) {
+          list.length = 0;
+        } else {
+          list.splice(i, 1);
+        }
+      }
+      emit(ev, code, signal) {
+        if (this.emitted[ev]) {
+          return false;
+        }
+        this.emitted[ev] = true;
+        let ret = false;
+        for (const fn of this.listeners[ev]) {
+          ret = fn(code, signal) === true || ret;
+        }
+        if (ev === "exit") {
+          ret = this.emit("afterExit", code, signal) || ret;
+        }
+        return ret;
+      }
+    };
+    SignalExitBase = class {
+    };
+    signalExitWrap = (handler) => {
+      return {
+        onExit(cb, opts) {
+          return handler.onExit(cb, opts);
+        },
+        load() {
+          return handler.load();
+        },
+        unload() {
+          return handler.unload();
+        }
+      };
+    };
+    SignalExitFallback = class extends SignalExitBase {
+      onExit() {
+        return () => {
+        };
+      }
+      load() {
+      }
+      unload() {
+      }
+    };
+    SignalExit = class extends SignalExitBase {
+      // "SIGHUP" throws an `ENOSYS` error on Windows,
+      // so use a supported signal instead
+      /* c8 ignore start */
+      #hupSig = process3.platform === "win32" ? "SIGINT" : "SIGHUP";
+      /* c8 ignore stop */
+      #emitter = new Emitter();
+      #process;
+      #originalProcessEmit;
+      #originalProcessReallyExit;
+      #sigListeners = {};
+      #loaded = false;
+      constructor(process4) {
+        super();
+        this.#process = process4;
+        this.#sigListeners = {};
+        for (const sig of signals) {
+          this.#sigListeners[sig] = () => {
+            const listeners = this.#process.listeners(sig);
+            let { count } = this.#emitter;
+            const p = process4;
+            if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
+              count += p.__signal_exit_emitter__.count;
+            }
+            if (listeners.length === count) {
+              this.unload();
+              const ret = this.#emitter.emit("exit", null, sig);
+              const s = sig === "SIGHUP" ? this.#hupSig : sig;
+              if (!ret)
+                process4.kill(process4.pid, s);
+            }
+          };
+        }
+        this.#originalProcessReallyExit = process4.reallyExit;
+        this.#originalProcessEmit = process4.emit;
+      }
+      onExit(cb, opts) {
+        if (!processOk(this.#process)) {
+          return () => {
+          };
+        }
+        if (this.#loaded === false) {
+          this.load();
+        }
+        const ev = opts?.alwaysLast ? "afterExit" : "exit";
+        this.#emitter.on(ev, cb);
+        return () => {
+          this.#emitter.removeListener(ev, cb);
+          if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
+            this.unload();
+          }
+        };
+      }
+      load() {
+        if (this.#loaded) {
+          return;
+        }
+        this.#loaded = true;
+        this.#emitter.count += 1;
+        for (const sig of signals) {
+          try {
+            const fn = this.#sigListeners[sig];
+            if (fn)
+              this.#process.on(sig, fn);
+          } catch (_) {
+          }
+        }
+        this.#process.emit = (ev, ...a) => {
+          return this.#processEmit(ev, ...a);
+        };
+        this.#process.reallyExit = (code) => {
+          return this.#processReallyExit(code);
+        };
+      }
+      unload() {
+        if (!this.#loaded) {
+          return;
+        }
+        this.#loaded = false;
+        signals.forEach((sig) => {
+          const listener = this.#sigListeners[sig];
+          if (!listener) {
+            throw new Error("Listener not defined for signal: " + sig);
+          }
+          try {
+            this.#process.removeListener(sig, listener);
+          } catch (_) {
+          }
+        });
+        this.#process.emit = this.#originalProcessEmit;
+        this.#process.reallyExit = this.#originalProcessReallyExit;
+        this.#emitter.count -= 1;
+      }
+      #processReallyExit(code) {
+        if (!processOk(this.#process)) {
+          return 0;
+        }
+        this.#process.exitCode = code || 0;
+        this.#emitter.emit("exit", this.#process.exitCode, null);
+        return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+      }
+      #processEmit(ev, ...args) {
+        const og = this.#originalProcessEmit;
+        if (ev === "exit" && processOk(this.#process)) {
+          if (typeof args[0] === "number") {
+            this.#process.exitCode = args[0];
+          }
+          const ret = og.call(this.#process, ev, ...args);
+          this.#emitter.emit("exit", this.#process.exitCode, null);
+          return ret;
+        } else {
+          return og.call(this.#process, ev, ...args);
+        }
+      }
+    };
+    process3 = globalThis.process;
+    ({
+      onExit: (
+        /**
+         * Called when the process is exiting, whether via signal, explicit
+         * exit, or running out of stuff to do.
+         *
+         * If the global process object is not suitable for instrumentation,
+         * then this will be a no-op.
+         *
+         * Returns a function that may be used to unload signal-exit.
+         */
+        onExit
+      ),
+      load: (
+        /**
+         * Load the listeners.  Likely you never need to call this, unless
+         * doing a rather deep integration with signal-exit functionality.
+         * Mostly exposed for the benefit of testing.
+         *
+         * @internal
+         */
+        load
+      ),
+      unload: (
+        /**
+         * Unload the listeners.  Likely you never need to call this, unless
+         * doing a rather deep integration with signal-exit functionality.
+         * Mostly exposed for the benefit of testing.
+         *
+         * @internal
+         */
+        unload
+      )
+    } = signalExitWrap(processOk(process3) ? new SignalExit(process3) : new SignalExitFallback()));
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+ansi@2.0.5/node_modules/@inquirer/ansi/dist/index.js
+var ESC2, cursorLeft, cursorHide, cursorShow, cursorUp, cursorDown, cursorTo, eraseLine, eraseLines;
+var init_dist4 = __esm({
+  "../../node_modules/.pnpm/@inquirer+ansi@2.0.5/node_modules/@inquirer/ansi/dist/index.js"() {
+    ESC2 = "\x1B[";
+    cursorLeft = ESC2 + "G";
+    cursorHide = ESC2 + "?25l";
+    cursorShow = ESC2 + "?25h";
+    cursorUp = (rows = 1) => rows > 0 ? `${ESC2}${rows}A` : "";
+    cursorDown = (rows = 1) => rows > 0 ? `${ESC2}${rows}B` : "";
+    cursorTo = (x, y) => {
+      if (typeof y === "number" && !Number.isNaN(y)) {
+        return `${ESC2}${y + 1};${x + 1}H`;
+      }
+      return `${ESC2}${x + 1}G`;
+    };
+    eraseLine = ESC2 + "2K";
+    eraseLines = (lines) => lines > 0 ? (eraseLine + cursorUp(1)).repeat(lines - 1) + eraseLine + cursorLeft : "";
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/screen-manager.js
+import { stripVTControlCharacters } from "node:util";
+var height, lastLine, ScreenManager;
+var init_screen_manager = __esm({
+  "../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/screen-manager.js"() {
+    init_utils2();
+    init_dist4();
+    height = (content) => content.split("\n").length;
+    lastLine = (content) => content.split("\n").pop() ?? "";
+    ScreenManager = class {
+      // These variables are keeping information to allow correct prompt re-rendering
+      height = 0;
+      extraLinesUnderPrompt = 0;
+      cursorPos;
+      rl;
+      constructor(rl) {
+        this.rl = rl;
+        this.cursorPos = rl.getCursorPos();
+      }
+      write(content) {
+        this.rl.output.unmute();
+        this.rl.output.write(content);
+        this.rl.output.mute();
+      }
+      render(content, bottomContent = "") {
+        const promptLine = lastLine(content);
+        const rawPromptLine = stripVTControlCharacters(promptLine);
+        let prompt = rawPromptLine;
+        if (this.rl.line.length > 0) {
+          prompt = prompt.slice(0, -this.rl.line.length);
+        }
+        this.rl.setPrompt(prompt);
+        this.cursorPos = this.rl.getCursorPos();
+        const width = readlineWidth();
+        content = breakLines(content, width);
+        bottomContent = breakLines(bottomContent, width);
+        if (rawPromptLine.length % width === 0) {
+          content += "\n";
+        }
+        let output = content + (bottomContent ? "\n" + bottomContent : "");
+        const promptLineUpDiff = Math.floor(rawPromptLine.length / width) - this.cursorPos.rows;
+        const bottomContentHeight = promptLineUpDiff + (bottomContent ? height(bottomContent) : 0);
+        if (bottomContentHeight > 0)
+          output += cursorUp(bottomContentHeight);
+        output += cursorTo(this.cursorPos.cols);
+        this.write(cursorDown(this.extraLinesUnderPrompt) + eraseLines(this.height) + output);
+        this.extraLinesUnderPrompt = bottomContentHeight;
+        this.height = height(output);
+      }
+      checkCursorPos() {
+        const cursorPos = this.rl.getCursorPos();
+        if (cursorPos.cols !== this.cursorPos.cols) {
+          this.write(cursorTo(cursorPos.cols));
+          this.cursorPos = cursorPos;
+        }
+      }
+      done({ clearContent }) {
+        this.rl.setPrompt("");
+        let output = cursorDown(this.extraLinesUnderPrompt);
+        output += clearContent ? eraseLines(this.height) : "\n";
+        output += cursorShow;
+        this.write(output);
+        this.rl.close();
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/promise-polyfill.js
+var PromisePolyfill;
+var init_promise_polyfill = __esm({
+  "../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/promise-polyfill.js"() {
+    PromisePolyfill = class extends Promise {
+      // Available starting from Node 22
+      // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers
+      static withResolver() {
+        let resolve;
+        let reject;
+        const promise2 = new Promise((res, rej) => {
+          resolve = res;
+          reject = rej;
+        });
+        return { promise: promise2, resolve, reject };
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/create-prompt.js
+import * as readline2 from "node:readline";
+import { AsyncResource as AsyncResource3 } from "node:async_hooks";
+import path from "node:path";
+function getCallSites() {
+  const _prepareStackTrace = Error.prepareStackTrace;
+  let result = [];
+  try {
+    Error.prepareStackTrace = (_, callSites) => {
+      const callSitesWithoutCurrent = callSites.slice(1);
+      result = callSitesWithoutCurrent;
+      return callSitesWithoutCurrent;
+    };
+    new Error().stack;
+  } catch {
+    return result;
+  }
+  Error.prepareStackTrace = _prepareStackTrace;
+  return result;
+}
+function createPrompt(view) {
+  const callSites = getCallSites();
+  const prompt = (config2, context = {}) => {
+    const { input = process.stdin, signal } = context;
+    const cleanups = /* @__PURE__ */ new Set();
+    const output = new import_mute_stream.default();
+    output.pipe(context.output ?? process.stdout);
+    const rl = readline2.createInterface({
+      terminal: true,
+      input,
+      output
+    });
+    output.mute();
+    const screen = new ScreenManager(rl);
+    const { promise: promise2, resolve, reject } = PromisePolyfill.withResolver();
+    const cancel = () => reject(new CancelPromptError());
+    if (signal) {
+      const abort = () => reject(new AbortPromptError({ cause: signal.reason }));
+      if (signal.aborted) {
+        abort();
+        return Object.assign(promise2, { cancel });
+      }
+      signal.addEventListener("abort", abort);
+      cleanups.add(() => signal.removeEventListener("abort", abort));
+    }
+    cleanups.add(onExit((code, signal2) => {
+      reject(new ExitPromptError(`User force closed the prompt with ${code} ${signal2}`));
+    }));
+    const sigint = () => reject(new ExitPromptError(`User force closed the prompt with SIGINT`));
+    rl.on("SIGINT", sigint);
+    cleanups.add(() => rl.removeListener("SIGINT", sigint));
+    return withHooks(rl, (cycle) => {
+      const hooksCleanup = AsyncResource3.bind(() => effectScheduler.clearAll());
+      rl.on("close", hooksCleanup);
+      cleanups.add(() => rl.removeListener("close", hooksCleanup));
+      const startCycle = () => {
+        const checkCursorPos = () => screen.checkCursorPos();
+        rl.input.on("keypress", checkCursorPos);
+        cleanups.add(() => rl.input.removeListener("keypress", checkCursorPos));
+        let pendingDone = null;
+        cycle(() => {
+          let effectsSettled = false;
+          try {
+            const nextView = view(config2, (value) => {
+              if (effectsSettled) {
+                resolve(value);
+              } else {
+                pendingDone = { value };
+              }
+            });
+            if (nextView === void 0) {
+              let callerFilename = callSites[1]?.getFileName();
+              if (callerFilename && !callerFilename.startsWith("file://")) {
+                callerFilename = path.resolve(callerFilename);
+              }
+              throw new Error(`Prompt functions must return a string.
+    at ${callerFilename}`);
+            }
+            const [content, bottomContent] = typeof nextView === "string" ? [nextView] : nextView;
+            screen.render(content, bottomContent);
+            effectScheduler.run();
+          } catch (error40) {
+            reject(error40);
+          }
+          effectsSettled = true;
+          if (pendingDone !== null) {
+            const { value } = pendingDone;
+            pendingDone = null;
+            resolve(value);
+          }
+        });
+      };
+      if ("readableFlowing" in input) {
+        nativeSetImmediate(startCycle);
+      } else {
+        startCycle();
+      }
+      return Object.assign(promise2.then((answer) => {
+        effectScheduler.clearAll();
+        return answer;
+      }, (error40) => {
+        effectScheduler.clearAll();
+        throw error40;
+      }).finally(() => {
+        cleanups.forEach((cleanup) => cleanup());
+        screen.done({ clearContent: Boolean(context.clearPromptOnDone) });
+        output.end();
+      }).then(() => promise2), { cancel });
+    });
+  };
+  return prompt;
+}
+var import_mute_stream, nativeSetImmediate;
+var init_create_prompt = __esm({
+  "../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/create-prompt.js"() {
+    import_mute_stream = __toESM(require_lib(), 1);
+    init_mjs();
+    init_screen_manager();
+    init_promise_polyfill();
+    init_hook_engine();
+    init_errors();
+    nativeSetImmediate = globalThis.setImmediate;
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/Separator.js
+import { styleText as styleText2 } from "node:util";
+var Separator;
+var init_Separator = __esm({
+  "../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/lib/Separator.js"() {
+    init_dist();
+    Separator = class {
+      separator = styleText2("dim", Array.from({ length: 15 }).join(dist_default.line));
+      type = "separator";
+      constructor(separator) {
+        if (separator) {
+          this.separator = separator;
+        }
+      }
+      static isSeparator(choice) {
+        return Boolean(choice && typeof choice === "object" && "type" in choice && choice.type === "separator");
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/index.js
+var init_dist5 = __esm({
+  "../../node_modules/.pnpm/@inquirer+core@11.1.9_@types+node@22.19.17/node_modules/@inquirer/core/dist/index.js"() {
+    init_key();
+    init_errors();
+    init_use_prefix();
+    init_use_state();
+    init_use_memo();
+    init_use_keypress();
+    init_make_theme();
+    init_use_pagination();
+    init_create_prompt();
+    init_Separator();
+  }
+});
+
+// ../../node_modules/.pnpm/@inquirer+checkbox@5.1.4_@types+node@22.19.17/node_modules/@inquirer/checkbox/dist/index.js
+import { styleText as styleText3 } from "node:util";
+function isSelectable(item) {
+  return !Separator.isSeparator(item) && !item.disabled;
+}
+function isNavigable(item) {
+  return !Separator.isSeparator(item);
+}
+function isChecked(item) {
+  return !Separator.isSeparator(item) && item.checked;
+}
+function toggle(item) {
+  return isSelectable(item) ? { ...item, checked: !item.checked } : item;
+}
+function check(checked) {
+  return function(item) {
+    return isSelectable(item) ? { ...item, checked } : item;
+  };
+}
+function normalizeChoices(choices) {
+  return choices.map((choice) => {
+    if (Separator.isSeparator(choice))
+      return choice;
+    if (typeof choice !== "object" || choice === null || !("value" in choice)) {
+      const name2 = String(choice);
+      return {
+        value: choice,
+        name: name2,
+        short: name2,
+        checkedName: name2,
+        disabled: false,
+        checked: false
+      };
+    }
+    const name = choice.name ?? String(choice.value);
+    const normalizedChoice = {
+      value: choice.value,
+      name,
+      short: choice.short ?? name,
+      checkedName: choice.checkedName ?? name,
+      disabled: choice.disabled ?? false,
+      checked: choice.checked ?? false
+    };
+    if (choice.description) {
+      normalizedChoice.description = choice.description;
+    }
+    return normalizedChoice;
+  });
+}
+var checkboxTheme, dist_default4;
+var init_dist6 = __esm({
+  "../../node_modules/.pnpm/@inquirer+checkbox@5.1.4_@types+node@22.19.17/node_modules/@inquirer/checkbox/dist/index.js"() {
+    init_dist5();
+    init_dist4();
+    init_dist();
+    init_dist5();
+    checkboxTheme = {
+      icon: {
+        checked: styleText3("green", dist_default.circleFilled),
+        unchecked: dist_default.circle,
+        cursor: dist_default.pointer,
+        disabledChecked: styleText3("green", dist_default.circleDouble),
+        disabledUnchecked: "-"
+      },
+      style: {
+        disabled: (text) => styleText3("dim", text),
+        renderSelectedChoices: (selectedChoices) => selectedChoices.map((choice) => choice.short).join(", "),
+        description: (text) => styleText3("cyan", text),
+        keysHelpTip: (keys) => keys.map(([key, action]) => `${styleText3("bold", key)} ${styleText3("dim", action)}`).join(styleText3("dim", " \u2022 "))
+      },
+      i18n: { disabledError: "This option is disabled and cannot be toggled." },
+      keybindings: []
+    };
+    dist_default4 = createPrompt((config2, done) => {
+      const { pageSize = 7, loop = true, required: required2, validate = () => true } = config2;
+      const shortcuts = { all: "a", invert: "i", ...config2.shortcuts };
+      const theme = makeTheme(checkboxTheme, config2.theme);
+      const { keybindings } = theme;
+      const [status, setStatus] = useState("idle");
+      const prefix = usePrefix({ status, theme });
+      const [items, setItems] = useState(normalizeChoices(config2.choices));
+      const bounds = useMemo(() => {
+        const first = items.findIndex(isNavigable);
+        const last = items.findLastIndex(isNavigable);
+        if (first === -1) {
+          throw new ValidationError("[checkbox prompt] No selectable choices. All choices are disabled.");
+        }
+        return { first, last };
+      }, [items]);
+      const [active, setActive] = useState(bounds.first);
+      const [errorMsg, setError] = useState();
+      useKeypress(async (key) => {
+        if (isEnterKey(key)) {
+          const selection = items.filter(isChecked);
+          const isValid = await validate([...selection]);
+          if (required2 && !selection.length) {
+            setError("At least one choice must be selected");
+          } else if (isValid === true) {
+            setStatus("done");
+            done(selection.map((choice) => choice.value));
+          } else {
+            setError(isValid || "You must select a valid value");
+          }
+        } else if (isUpKey(key, keybindings) || isDownKey(key, keybindings)) {
+          if (errorMsg) {
+            setError(void 0);
+          }
+          if (loop || isUpKey(key, keybindings) && active !== bounds.first || isDownKey(key, keybindings) && active !== bounds.last) {
+            const offset = isUpKey(key, keybindings) ? -1 : 1;
+            let next = active;
+            do {
+              next = (next + offset + items.length) % items.length;
+            } while (!isNavigable(items[next]));
+            setActive(next);
+          }
+        } else if (isSpaceKey(key)) {
+          const activeItem = items[active];
+          if (activeItem && !Separator.isSeparator(activeItem)) {
+            if (activeItem.disabled) {
+              setError(theme.i18n.disabledError);
+            } else {
+              setError(void 0);
+              setItems(items.map((choice, i) => i === active ? toggle(choice) : choice));
+            }
+          }
+        } else if (key.name === shortcuts.all) {
+          const selectAll = items.some((choice) => isSelectable(choice) && !choice.checked);
+          setItems(items.map(check(selectAll)));
+        } else if (key.name === shortcuts.invert) {
+          setItems(items.map(toggle));
+        } else if (isNumberKey(key)) {
+          const selectedIndex = Number(key.name) - 1;
+          let selectableIndex = -1;
+          const position = items.findIndex((item) => {
+            if (Separator.isSeparator(item))
+              return false;
+            selectableIndex++;
+            return selectableIndex === selectedIndex;
+          });
+          const selectedItem = items[position];
+          if (selectedItem && isSelectable(selectedItem)) {
+            setActive(position);
+            setItems(items.map((choice, i) => i === position ? toggle(choice) : choice));
+          }
+        }
+      });
+      const message = theme.style.message(config2.message, status);
+      let description;
+      const page = usePagination({
+        items,
+        active,
+        renderItem({ item, isActive }) {
+          if (Separator.isSeparator(item)) {
+            return ` ${item.separator}`;
+          }
+          const cursor = isActive ? theme.icon.cursor : " ";
+          if (item.disabled) {
+            const disabledLabel = typeof item.disabled === "string" ? item.disabled : "(disabled)";
+            const checkbox2 = item.checked ? theme.icon.disabledChecked : theme.icon.disabledUnchecked;
+            return theme.style.disabled(`${cursor}${checkbox2} ${item.name} ${disabledLabel}`);
+          }
+          if (isActive) {
+            description = item.description;
+          }
+          const checkbox = item.checked ? theme.icon.checked : theme.icon.unchecked;
+          const name = item.checked ? item.checkedName : item.name;
+          const color = isActive ? theme.style.highlight : (x) => x;
+          return color(`${cursor}${checkbox} ${name}`);
+        },
+        pageSize,
+        loop
+      });
+      if (status === "done") {
+        const selection = items.filter(isChecked);
+        const answer = theme.style.answer(theme.style.renderSelectedChoices(selection, items));
+        return [prefix, message, answer].filter(Boolean).join(" ");
+      }
+      const keys = [
+        ["\u2191\u2193", "navigate"],
+        ["space", "select"]
+      ];
+      if (shortcuts.all)
+        keys.push([shortcuts.all, "all"]);
+      if (shortcuts.invert)
+        keys.push([shortcuts.invert, "invert"]);
+      keys.push(["\u23CE", "submit"]);
+      const helpLine = theme.style.keysHelpTip(keys);
+      const lines = [
+        [prefix, message].filter(Boolean).join(" "),
+        page,
+        " ",
+        description ? theme.style.description(description) : "",
+        errorMsg ? theme.style.error(errorMsg) : "",
+        helpLine
+      ].filter(Boolean).join("\n").trimEnd();
+      return `${lines}${cursorHide}`;
+    });
+  }
+});
+
+// src/bridge/lib/binary-installer.ts
+import { spawn as spawn5 } from "node:child_process";
+import { homedir as homedir2, tmpdir } from "node:os";
+import { join as join3, basename } from "node:path";
+import { mkdirSync, rmSync, chmodSync, existsSync, symlinkSync, unlinkSync, createWriteStream } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+function platformKey() {
+  const os = process.platform === "win32" ? "windows" : process.platform;
+  const arch = process.arch === "arm64" ? "aarch64" : process.arch === "x64" ? "x86_64" : process.arch;
+  return `${os}-${arch}`;
+}
+async function installBinaryWrapper(opts) {
+  const archive = opts.install.archives[platformKey()];
+  if (!archive) {
+    return {
+      ok: false,
+      error: `no archive for ${platformKey()}`,
+      hint: opts.install.downloadUrl ? `manual install: ${opts.install.downloadUrl}` : void 0
+    };
+  }
+  const cmdRel = archive.cmd.replace(/^\.\//, "");
+  const binName = basename(cmdRel).replace(/\.exe$/, "");
+  const wrapperDir = join3(WRAPPERS_DIR, opts.id);
+  const cmdAbs = join3(wrapperDir, cmdRel);
+  const linkPath = join3(BIN_DIR, binName);
+  try {
+    rmSync(wrapperDir, { recursive: true, force: true });
+  } catch (e) {
+    return { ok: false, error: `wipe stale wrapper dir failed: ${e.message}` };
+  }
+  mkdirSync(wrapperDir, { recursive: true });
+  mkdirSync(BIN_DIR, { recursive: true });
+  const ext = guessExtension(archive.url);
+  const tmpFile = join3(tmpdir(), `oma-${opts.id}-${randomBytes(4).toString("hex")}${ext}`);
+  try {
+    opts.onProgress?.(`downloading ${archive.url}`);
+    await downloadToFile(archive.url, tmpFile, opts.onProgress);
+    opts.onProgress?.(`extracting to ${wrapperDir}`);
+    await extractArchive(tmpFile, wrapperDir, ext);
+    if (!existsSync(cmdAbs)) {
+      return {
+        ok: false,
+        error: `extracted archive missing expected cmd: ${cmdRel}`
+      };
+    }
+    chmodSync(cmdAbs, 493);
+    try {
+      unlinkSync(linkPath);
+    } catch {
+    }
+    symlinkSync(cmdAbs, linkPath);
+    const result = { ok: true, binPath: linkPath, installedAt: wrapperDir };
+    if (!isOnPath2(BIN_DIR)) {
+      result.hint = `add \`${BIN_DIR}\` to your PATH (it's where OMA installs wrappers)`;
+    }
+    return result;
+  } catch (e) {
+    return { ok: false, error: e.message };
+  } finally {
+    try {
+      unlinkSync(tmpFile);
+    } catch {
+    }
+  }
+}
+function guessExtension(url2) {
+  const path2 = (() => {
+    try {
+      return new URL(url2).pathname;
+    } catch {
+      return url2;
+    }
+  })();
+  for (const ext of [".tar.gz", ".tgz", ".tar.bz2", ".tbz2", ".tar.xz", ".txz", ".zip"]) {
+    if (path2.toLowerCase().endsWith(ext)) return ext;
+  }
+  return "";
+}
+async function downloadToFile(url2, dest, onProgress) {
+  const res = await fetch(url2, { redirect: "follow" });
+  if (!res.ok) throw new Error(`download HTTP ${res.status}`);
+  const total = Number(res.headers.get("content-length") ?? "0");
+  if (!res.body) throw new Error("download returned empty body");
+  let last = Date.now();
+  let read = 0;
+  const stream = res.body;
+  const node = Readable.fromWeb(stream);
+  node.on("data", (chunk) => {
+    read += chunk.byteLength;
+    if (Date.now() - last > 1e3 && onProgress) {
+      last = Date.now();
+      const pct = total ? `${Math.floor(read / total * 100)}%` : "";
+      onProgress(`  \u2026${formatBytes(read)}${total ? `/${formatBytes(total)} ${pct}` : ""}`);
+    }
+  });
+  await pipeline(node, createWriteStream(dest));
+}
+function formatBytes(n) {
+  if (n < 1024) return `${n}B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)}KB`;
+  return `${(n / 1024 / 1024).toFixed(1)}MB`;
+}
+function extractArchive(archive, dest, ext) {
+  const isWin = process.platform === "win32";
+  let cmd;
+  let args;
+  if (ext === ".zip") {
+    if (isWin) {
+      cmd = "tar";
+      args = ["-xf", archive, "-C", dest];
+    } else {
+      cmd = "unzip";
+      args = ["-q", "-o", archive, "-d", dest];
+    }
+  } else if (ext === ".tar.gz" || ext === ".tgz") {
+    cmd = "tar";
+    args = ["-xzf", archive, "-C", dest];
+  } else if (ext === ".tar.bz2" || ext === ".tbz2") {
+    cmd = "tar";
+    args = ["-xjf", archive, "-C", dest];
+  } else if (ext === ".tar.xz" || ext === ".txz") {
+    cmd = "tar";
+    args = ["-xJf", archive, "-C", dest];
+  } else {
+    return Promise.reject(new Error(`unsupported archive extension '${ext || "?"}'`));
+  }
+  return new Promise((resolve, reject) => {
+    const p = spawn5(cmd, args, { stdio: ["ignore", "ignore", "pipe"] });
+    let err = "";
+    p.stderr?.on("data", (d) => {
+      err += d.toString();
+    });
+    p.once("error", (e) => reject(new Error(`${cmd} spawn failed: ${e.message}`)));
+    p.once("exit", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${cmd} exited ${code}: ${err.trim().slice(0, 400)}`));
+    });
+  });
+}
+function isOnPath2(dir) {
+  const sep = process.platform === "win32" ? ";" : ":";
+  return (process.env.PATH ?? "").split(sep).includes(dir);
+}
+var WRAPPERS_DIR, BIN_DIR, binDir;
+var init_binary_installer = __esm({
+  "src/bridge/lib/binary-installer.ts"() {
+    "use strict";
+    WRAPPERS_DIR = join3(homedir2(), ".local", "share", "oma", "wrappers");
+    BIN_DIR = join3(homedir2(), ".local", "bin");
+    binDir = BIN_DIR;
+  }
+});
+
+// src/bridge/lib/wrapper-audit.ts
+import { spawn as spawn6 } from "node:child_process";
+async function auditAndOfferWrappers(initialAgents, opts = {}) {
+  let agents = initialAgents.map((a) => ({ id: a.id }));
+  const detectedIds = new Set(agents.map((a) => a.id));
+  const rows = [];
+  for (const e of getKnownAgents()) {
+    if (detectedIds.has(e.id)) {
+      if (e.wraps) {
+        rows.push({ id: e.id, label: e.label, status: { kind: "wrapper-detected", wraps: e.wraps } });
+      } else {
+        rows.push({ id: e.id, label: e.label, status: { kind: "builtin-detected" } });
+      }
+      continue;
+    }
+    if (e.wraps && e.install && await isOnPath3(e.wraps)) {
+      rows.push({
+        id: e.id,
+        label: e.label,
+        status: { kind: "wrapper-needs-install", wraps: e.wraps, install: e.install }
+      });
+    }
+  }
+  if (rows.length === 0) return agents;
+  const tty2 = Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY);
+  if (opts.dryRun) {
+    printAuditPlain(rows);
+    return agents;
+  }
+  if (!tty2 && !opts.yes) {
+    printAuditPlain(rows);
+    log.hint("non-interactive context \u2014 skipping prompts. Re-run from a terminal to install.");
+    return agents;
+  }
+  let toInstall;
+  if (opts.yes) {
+    toInstall = rows.filter((r) => {
+      if (r.status.kind !== "wrapper-needs-install") return false;
+      const inst = r.status.install;
+      if (inst.kind === "npm") return true;
+      if (inst.kind === "binary") return Boolean(inst.archives[platformKey()]);
+      return false;
+    });
+  } else {
+    const choices = buildChoices(rows);
+    if (!choices.some((c3) => "value" in c3 && !("disabled" in c3 && c3.disabled))) {
+      printAuditPlain(rows);
+      log.hint("nothing to install \u2014 your ACP agents are already in sync");
+      return agents;
+    }
+    const selected = await dist_default4({
+      message: "Install ACP wrappers? (space to toggle, enter to confirm)",
+      choices,
+      pageSize: Math.min(20, choices.length + 2),
+      loop: false
+    }).catch(() => []);
+    toInstall = rows.filter((r) => {
+      if (r.status.kind !== "wrapper-needs-install") return false;
+      if (!selected.includes(r.id)) return false;
+      const inst = r.status.install;
+      if (inst.kind === "npm") return true;
+      if (inst.kind === "binary") return Boolean(inst.archives[platformKey()]);
+      return false;
+    });
+  }
+  if (toInstall.length === 0) {
+    log.hint("nothing to install");
+    return agents;
+  }
+  let installed = 0;
+  for (const r of toInstall) {
+    if (r.status.kind !== "wrapper-needs-install") continue;
+    const inst = r.status.install;
+    if (inst.kind === "npm") {
+      log.step(`installing ${inst.package}`);
+      const ok = await npmInstallGlobal(inst.package);
+      if (ok) {
+        log.ok(`${r.id} installed`);
+        installed += 1;
+      } else {
+        log.warn(`install failed \u2014 try manually: npm i -g ${inst.package}`);
+      }
+    } else if (inst.kind === "binary") {
+      log.step(`downloading ${r.id} (binary, ${platformKey()})`);
+      const result = await installBinaryWrapper({
+        id: r.id,
+        install: inst,
+        onProgress: (m) => process.stderr.write(`  ${c.dim(m)}
+`)
+      });
+      if (result.ok) {
+        log.ok(`${r.id} installed \u2192 ${c.dim(result.binPath ?? "")}`);
+        if (result.hint) log.hint(result.hint);
+        installed += 1;
+      } else {
+        log.warn(`${r.id} install failed: ${result.error ?? "unknown"}`);
+        if (result.hint) log.hint(result.hint);
+        if (inst.downloadUrl) log.hint(`manual: ${inst.downloadUrl}`);
       }
-    });
-    ws.once("error", (e) => {
-      clearTimeout(timer);
-      settle({
-        ok: false,
-        reason: "unreachable",
-        detail: e instanceof Error ? e.message : String(e)
+    }
+  }
+  if (installed > 0) {
+    agents = (await detectAll()).map((a) => ({ id: a.id, binary: a.spec.command }));
+  }
+  return agents;
+}
+function buildChoices(rows) {
+  const detected = rows.filter((r) => r.status.kind !== "wrapper-needs-install");
+  const missing = rows.filter((r) => r.status.kind === "wrapper-needs-install");
+  const out = [];
+  if (detected.length) {
+    out.push(new Separator(c.dim("\u2500\u2500\u2500 already detected on this machine \u2500\u2500\u2500")));
+    for (const r of detected) {
+      const tag = r.status.kind === "wrapper-detected" ? `wrapper for \`${r.status.wraps}\`` : "built-in ACP";
+      out.push({
+        name: `${r.id.padEnd(18)}${c.dim(tag)}`,
+        value: r.id,
+        disabled: " (already installed)"
       });
-    });
+    }
+  }
+  if (missing.length) {
+    out.push(new Separator(c.dim("\u2500\u2500\u2500 ACP wrappers available to install \u2500\u2500\u2500")));
+    const pk = platformKey();
+    for (const r of missing) {
+      if (r.status.kind !== "wrapper-needs-install") continue;
+      const wrapsLabel = c.dim(`wraps \`${r.status.wraps}\``);
+      const inst = r.status.install;
+      if (inst.kind === "npm") {
+        out.push({
+          name: `${r.id.padEnd(18)}${wrapsLabel} ${c.dim(`\u2014 npm i -g ${inst.package}`)}`,
+          value: r.id,
+          checked: false
+        });
+      } else {
+        const archive = inst.archives[pk];
+        if (archive) {
+          out.push({
+            name: `${r.id.padEnd(18)}${wrapsLabel} ${c.dim(`\u2014 binary release (${pk}) \u2192 ~/.local/bin/`)}`,
+            value: r.id,
+            checked: false
+          });
+        } else {
+          out.push({
+            name: `${r.id.padEnd(18)}${wrapsLabel} ${c.dim(`\u2014 no ${pk} build` + (inst.downloadUrl ? `; see ${inst.downloadUrl}` : ""))}`,
+            value: r.id,
+            disabled: " (manual download required)"
+          });
+        }
+      }
+    }
+  }
+  return out;
+}
+function printAuditPlain(rows) {
+  process.stderr.write("\n");
+  log.step(`ACP audit (${rows.length} relevant on this machine):`);
+  const pk = platformKey();
+  for (const r of rows) {
+    let line;
+    if (r.status.kind === "builtin-detected") {
+      line = `  ${c.green("\u2713")} ${r.id.padEnd(18)} ${c.dim("built-in ACP")}`;
+    } else if (r.status.kind === "wrapper-detected") {
+      line = `  ${c.green("\u2713")} ${r.id.padEnd(18)} ${c.dim(`wrapper for \`${r.status.wraps}\``)}`;
+    } else {
+      const inst = r.status.install;
+      if (inst.kind === "npm") {
+        line = `  ${c.yellow("\u25CB")} ${r.id.padEnd(18)} ${c.dim(`wraps \`${r.status.wraps}\` \u2014 npm i -g ${inst.package}`)}`;
+      } else if (inst.archives[pk]) {
+        line = `  ${c.yellow("\u25CB")} ${r.id.padEnd(18)} ${c.dim(`wraps \`${r.status.wraps}\` \u2014 binary release (${pk}) \u2192 ${binDir}`)}`;
+      } else {
+        line = `  ${c.yellow("\u25CB")} ${r.id.padEnd(18)} ${c.dim(`wraps \`${r.status.wraps}\` \u2014 no ${pk} build` + (inst.downloadUrl ? `, see ${inst.downloadUrl}` : ""))}`;
+      }
+    }
+    process.stderr.write(line + "\n");
+  }
+}
+function isOnPath3(cmd) {
+  return new Promise((resolve) => {
+    const probe = process.platform === "win32" ? "where" : "which";
+    const p = spawn6(probe, [cmd], { stdio: "ignore" });
+    p.once("error", () => resolve(false));
+    p.once("exit", (code) => resolve(code === 0));
   });
 }
-var init_probe = __esm({
-  "src/bridge/lib/probe.ts"() {
+function npmInstallGlobal(pkg) {
+  return new Promise((resolve) => {
+    const p = spawn6("npm", ["install", "-g", pkg], { stdio: "inherit" });
+    p.once("error", () => resolve(false));
+    p.once("exit", (code) => resolve(code === 0));
+  });
+}
+var init_wrapper_audit = __esm({
+  "src/bridge/lib/wrapper-audit.ts"() {
     "use strict";
+    init_dist6();
+    init_registry();
+    init_style();
+    init_binary_installer();
   }
 });
 
@@ -4081,18 +7091,22 @@ __export(setup_exports, {
   runSetup: () => runSetup
 });
 import { createServer } from "node:http";
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 import { hostname } from "node:os";
-import { randomBytes } from "node:crypto";
+import { randomBytes as randomBytes2 } from "node:crypto";
 import { realpathSync } from "node:fs";
-function launchdInstallOpts() {
+import { join as join4 } from "node:path";
+function serviceInstallOpts() {
   return {
     nodePath: process.execPath,
     cliEntry: realpathSync(process.argv[1])
   };
 }
 async function runSetup(opts) {
-  printBanner(`setup \u2014 register this machine with ${opts.serverUrl}`, PKG_VERSION);
+  const profile = currentProfile();
+  const profileTag = profile ? `  [profile=${profile}]` : "";
+  printBanner(`setup \u2014 register this machine with ${opts.serverUrl}${profileTag}`, PKG_VERSION);
+  await loadRegistry({ cachePath: join4(paths().configDir, "registry-cache.json") });
   if (!opts.force) {
     const existing = await readCreds();
     if (existing) {
@@ -4109,30 +7123,19 @@ async function runSetup(opts) {
         } else {
           log.hint(`runtime ${existing.runtimeId.slice(0, 8)}\u2026 (use --force to re-register)`);
         }
-        if (!opts.noService && currentPlatform() === "darwin") {
-          const installedEntry = await readInstalledCliEntry();
-          const currentEntry = launchdInstallOpts().cliEntry;
-          if (installedEntry && installedEntry !== currentEntry) {
-            log.warn(`plist was pointing at a different binary; updating`);
-            log.hint(`old: ${c.dim(installedEntry)}`);
-            log.hint(`new: ${c.dim(currentEntry)}`);
-          }
-          await install(launchdInstallOpts());
-          log.ok(`launchd plist refreshed  ${c.dim(paths().serviceFile ?? "")}`);
-          log.ok(`daemon restarted  ${c.dim("logs: " + paths().logFile)}`);
-        } else {
-          log.hint("run `oma bridge daemon` to start the bridge");
-        }
+        const fastPathAgents = (await detectAll()).map((a) => ({ id: a.id, binary: a.spec.command }));
+        await auditAndOfferWrappers(fastPathAgents, { yes: opts.yes });
         process.stderr.write(`
 ${c.bold("Up to date.")}
 
 `);
+        await refreshServiceOrFallback(opts);
         return;
       }
     }
   }
   log.step("waiting for browser to authorize");
-  const state = randomBytes(16).toString("hex");
+  const state = randomBytes2(16).toString("hex");
   const code = await waitForCallback(state, opts.browserOrigin);
   log.ok("received code from browser");
   const machineId = await getOrCreateMachineId();
@@ -4154,38 +7157,105 @@ ${c.bold("Up to date.")}
     createdAt: Math.floor(Date.now() / 1e3)
   });
   log.ok(`credentials written  ${c.dim(paths().credsFile)}`);
-  let agents = await detectAll();
-  const hasClaudeAcp = agents.some((a) => a.id === "claude-agent-acp");
-  if (!hasClaudeAcp && await isOnPath2("claude")) {
-    log.step("found `claude` on PATH \u2014 installing ACP wrapper @agentclientprotocol/claude-agent-acp");
-    const ok = await npmInstallGlobal("@agentclientprotocol/claude-agent-acp");
-    if (ok) {
-      log.ok("claude-agent-acp installed");
-      agents = await detectAll();
-    } else {
-      log.warn("auto-install failed \u2014 install manually: npm i -g @agentclientprotocol/claude-agent-acp");
-    }
-  }
+  let agents = (await detectAll()).map((a) => ({ id: a.id, binary: a.spec.command }));
+  agents = await auditAndOfferWrappers(agents, { yes: opts.yes });
   if (agents.length > 0) {
     log.ok(`agents detected  ${c.dim(agents.map((a) => a.id).join(", "))}`);
   } else {
     log.warn("no ACP agents on PATH yet");
     log.hint("install one, e.g. `npm i -g @agentclientprotocol/claude-agent-acp`");
   }
-  if (opts.noService || currentPlatform() !== "darwin") {
+  await installServiceOrFallback(opts);
+}
+async function installServiceOrFallback(opts) {
+  const kind = detectServiceKind();
+  if (opts.noService || kind === "unsupported") {
+    process.stderr.write("\n");
+    if (kind === "unsupported") {
+      log.warn(`platform service install not supported on ${process.platform}; running daemon in foreground`);
+    } else {
+      log.step("--no-service: starting daemon in foreground");
+    }
+    log.hint("Ctrl-C to stop. To run as a system service, re-run setup without --no-service.");
+    process.stderr.write("\n");
+    execIntoDaemon();
+    return;
+  }
+  await installAndReport(opts);
+}
+async function refreshServiceOrFallback(opts) {
+  const kind = detectServiceKind();
+  if (opts.noService || kind === "unsupported") {
     process.stderr.write("\n");
-    log.step("service install skipped");
-    log.hint("run `oma bridge daemon` to start the bridge in the foreground");
+    log.step(opts.noService ? "--no-service: starting daemon in foreground" : `service install not supported on ${process.platform}; running daemon in foreground`);
+    log.hint("Ctrl-C to stop. To run as a system service, re-run setup without --no-service.");
+    process.stderr.write("\n");
+    execIntoDaemon();
     return;
   }
-  await install(launchdInstallOpts());
-  log.ok(`launchd plist installed  ${c.dim(paths().serviceFile ?? "")}`);
-  log.ok(`daemon started  ${c.dim("logs: " + paths().logFile)}`);
+  const installedEntry = await readInstalledCliEntry4();
+  const currentEntry = serviceInstallOpts().cliEntry;
+  if (installedEntry && installedEntry !== currentEntry) {
+    log.warn(`service was pointing at a different binary; updating`);
+    log.hint(`old: ${c.dim(installedEntry)}`);
+    log.hint(`new: ${c.dim(currentEntry)}`);
+  }
+  await installAndReport(opts);
+}
+async function installAndReport(opts) {
+  void opts;
+  const result = await install4(serviceInstallOpts());
+  const where = result.installedAt ? c.dim(result.installedAt) : c.dim("(no install path)");
+  switch (result.kind) {
+    case "launchd":
+      log.ok(`launchd plist installed  ${where}`);
+      log.ok(`daemon started  ${c.dim("logs: " + paths().logFile)}`);
+      break;
+    case "systemd":
+      log.ok(`systemd unit installed  ${where}`);
+      if (result.started) {
+        log.ok(`daemon started  ${c.dim("logs: " + paths().logFile)}`);
+      } else {
+        log.warn(`unit installed but failed to start: ${result.warning ?? "unknown"}`);
+        log.hint(`try: systemctl --user status ${paths().serviceLabel}`);
+      }
+      if (!result.lingerEnabled) {
+        log.hint(lingerHint2());
+      }
+      break;
+    case "windows-task":
+      log.ok(`Task Scheduler task registered  ${where}`);
+      if (result.started) {
+        log.ok(`daemon started  ${c.dim("logs: " + paths().logFile)}`);
+      } else {
+        log.warn(`task registered but failed to start now: ${result.warning ?? "unknown"}`);
+        log.hint(`it will run at next logon. To start manually: schtasks /run /tn ${paths().serviceLabel}`);
+      }
+      break;
+    case "unsupported":
+      log.err(`platform unsupported`);
+      return;
+  }
   process.stderr.write("\n");
   process.stderr.write(`${c.bold("Done.")} the runtime should appear online at ${c.cyan(opts.browserOrigin)}
 
 `);
 }
+function execIntoDaemon() {
+  const profile = currentProfile();
+  const child = spawn7(process.execPath, [process.argv[1], "bridge", "daemon"], {
+    stdio: "inherit",
+    env: { ...process.env, ...profile ? { OMA_PROFILE: profile } : {} }
+  });
+  child.once("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code ?? 0);
+  });
+  return new Promise(() => void 0);
+}
 function waitForCallback(state, browserOrigin) {
   return new Promise((resolve, reject) => {
     const timeoutMs = 5 * 60 * 1e3;
@@ -4269,37 +7339,23 @@ function openBrowser(url2) {
   return new Promise((resolve, reject) => {
     const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
     const args = process.platform === "win32" ? ["", url2] : [url2];
-    const p = spawn3(cmd, args, { stdio: "ignore", detached: true, shell: process.platform === "win32" });
+    const p = spawn7(cmd, args, { stdio: "ignore", detached: true, shell: process.platform === "win32" });
     p.once("error", reject);
     p.unref();
     setTimeout(() => resolve(), 100);
   });
 }
-function isOnPath2(cmd) {
-  return new Promise((resolve) => {
-    const probe = process.platform === "win32" ? "where" : "which";
-    const p = spawn3(probe, [cmd], { stdio: "ignore" });
-    p.once("error", () => resolve(false));
-    p.once("exit", (code) => resolve(code === 0));
-  });
-}
-function npmInstallGlobal(pkg) {
-  return new Promise((resolve) => {
-    const p = spawn3("npm", ["install", "-g", pkg], { stdio: "inherit" });
-    p.once("error", () => resolve(false));
-    p.once("exit", (code) => resolve(code === 0));
-  });
-}
 var init_setup = __esm({
   "src/bridge/commands/setup.ts"() {
     "use strict";
     init_config();
     init_platform();
-    init_launchd();
+    init_service_manager();
     init_registry();
     init_style();
     init_version();
     init_probe();
+    init_wrapper_audit();
   }
 });
 
@@ -4400,7 +7456,7 @@ __export(util_exports, {
   getParsedType: () => getParsedType,
   getSizableOrigin: () => getSizableOrigin,
   isObject: () => isObject,
-  isPlainObject: () => isPlainObject,
+  isPlainObject: () => isPlainObject2,
   issue: () => issue,
   joinValues: () => joinValues,
   jsonStringifyReplacer: () => jsonStringifyReplacer,
@@ -4504,10 +7560,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path) {
-  if (!path)
+function getElementAtPath(obj, path2) {
+  if (!path2)
     return obj;
-  return path.reduce((acc, key) => acc?.[key], obj);
+  return path2.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -4534,7 +7590,7 @@ function esc(str) {
 function isObject(data) {
   return typeof data === "object" && data !== null && !Array.isArray(data);
 }
-function isPlainObject(o) {
+function isPlainObject2(o) {
   if (isObject(o) === false)
     return false;
   const ctor = o.constructor;
@@ -4662,7 +7718,7 @@ function omit(schema, mask) {
   });
 }
 function extend(schema, shape) {
-  if (!isPlainObject(shape)) {
+  if (!isPlainObject2(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
   const def = {
@@ -4756,11 +7812,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path, issues) {
+function prefixIssues(path2, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path);
+    iss.path.unshift(path2);
     return iss;
   });
 }
@@ -4949,7 +8005,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path = []) => {
+  const processError = (error41, path2 = []) => {
     var _a, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -4959,7 +8015,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path, ...issue2.path];
+        const fullpath = [...path2, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -4989,9 +8045,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path) {
+function toDotPath(path2) {
   const segs = [];
-  for (const seg of path) {
+  for (const seg of path2) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -5017,7 +8073,7 @@ function prettifyError(error40) {
   return lines.join("\n");
 }
 var initializer, $ZodError, $ZodRealError;
-var init_errors = __esm({
+var init_errors2 = __esm({
   "../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/core/errors.js"() {
     init_core();
     init_util();
@@ -5053,7 +8109,7 @@ var _parse, parse, _parseAsync, parseAsync, _safeParse, safeParse, _safeParseAsy
 var init_parse = __esm({
   "../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/core/parse.js"() {
     init_core();
-    init_errors();
+    init_errors2();
     init_util();
     _parse = (_Err) => (schema, value, _ctx, _params) => {
       const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
@@ -5841,7 +8897,7 @@ function isValidBase64(data) {
 function isValidBase64URL(data) {
   if (!base64url.test(data))
     return false;
-  const base643 = data.replace(/[-_]/g, (c2) => c2 === "-" ? "+" : "/");
+  const base643 = data.replace(/[-_]/g, (c3) => c3 === "-" ? "+" : "/");
   const padded = base643.padEnd(Math.ceil(base643.length / 4) * 4, "=");
   return isValidBase64(padded);
 }
@@ -5917,7 +8973,7 @@ function mergeValues(a, b) {
   if (a instanceof Date && b instanceof Date && +a === +b) {
     return { valid: true, data: a };
   }
-  if (isPlainObject(a) && isPlainObject(b)) {
+  if (isPlainObject2(a) && isPlainObject2(b)) {
     const bKeys = Object.keys(b);
     const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
     const newObj = { ...a, ...b };
@@ -6994,7 +10050,7 @@ var init_schemas = __esm({
       $ZodType.init(inst, def);
       inst._zod.parse = (payload, ctx) => {
         const input = payload.value;
-        if (!isPlainObject(input)) {
+        if (!isPlainObject2(input)) {
           payload.issues.push({
             expected: "record",
             code: "invalid_type",
@@ -14535,7 +17591,7 @@ var init_core2 = __esm({
   "../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/core/index.js"() {
     init_core();
     init_parse();
-    init_errors();
+    init_errors2();
     init_schemas();
     init_checks();
     init_versions();
@@ -14608,7 +17664,7 @@ var init_iso = __esm({
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/classic/errors.js
 var initializer2, ZodError, ZodRealError;
-var init_errors2 = __esm({
+var init_errors3 = __esm({
   "../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/classic/errors.js"() {
     init_core2();
     init_core2();
@@ -14652,7 +17708,7 @@ var parse2, parseAsync2, safeParse2, safeParseAsync2;
 var init_parse2 = __esm({
   "../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v4/classic/parse.js"() {
     init_core2();
-    init_errors2();
+    init_errors3();
     parse2 = /* @__PURE__ */ _parse(ZodRealError);
     parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
     safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
@@ -15011,7 +18067,7 @@ function promise(innerType) {
     innerType
   });
 }
-function check(fn) {
+function check2(fn) {
   const ch = new $ZodCheck({
     check: "custom"
     // ...util.normalizeParams(params),
@@ -15026,7 +18082,7 @@ function refine(fn, _params = {}) {
   return _refine(ZodCustom, fn, _params);
 }
 function superRefine(fn) {
-  const ch = check((payload) => {
+  const ch = check2((payload) => {
     payload.addIssue = (issue2) => {
       if (typeof issue2 === "string") {
         payload.issues.push(util_exports.issue(issue2, payload.value, ch._zod.def));
@@ -15102,7 +18158,7 @@ var init_schemas2 = __esm({
       inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
       inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
       inst.spa = inst.safeParseAsync;
-      inst.refine = (check2, params) => inst.check(refine(check2, params));
+      inst.refine = (check3, params) => inst.check(refine(check3, params));
       inst.superRefine = (refinement) => inst.check(superRefine(refinement));
       inst.overwrite = (fn) => inst.check(_overwrite(fn));
       inst.optional = () => optional(inst);
@@ -15369,9 +18425,9 @@ var init_schemas2 = __esm({
       ZodType.init(inst, def);
       inst.min = (value, params) => inst.check(_gte(value, params));
       inst.max = (value, params) => inst.check(_lte(value, params));
-      const c2 = inst._zod.bag;
-      inst.minDate = c2.minimum ? new Date(c2.minimum) : null;
-      inst.maxDate = c2.maximum ? new Date(c2.maximum) : null;
+      const c3 = inst._zod.bag;
+      inst.minDate = c3.minimum ? new Date(c3.minimum) : null;
+      inst.maxDate = c3.maximum ? new Date(c3.maximum) : null;
     });
     ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
       $ZodArray.init(inst, def);
@@ -15754,7 +18810,7 @@ __export(external_exports, {
   bigint: () => bigint2,
   boolean: () => boolean2,
   catch: () => _catch2,
-  check: () => check,
+  check: () => check2,
   cidrv4: () => cidrv42,
   cidrv6: () => cidrv62,
   clone: () => clone,
@@ -15883,7 +18939,7 @@ var init_external = __esm({
     init_core2();
     init_schemas2();
     init_checks2();
-    init_errors2();
+    init_errors3();
     init_parse2();
     init_compat();
     init_core2();
@@ -18415,7 +21471,7 @@ var init_src = __esm({
 
 // ../acp-runtime/src/spawners/node.ts
 import { spawn as nodeSpawn } from "node:child_process";
-import { Readable, Writable } from "node:stream";
+import { Readable as Readable2, Writable } from "node:stream";
 var NodeSpawner;
 var init_node = __esm({
   "../acp-runtime/src/spawners/node.ts"() {
@@ -18436,8 +21492,8 @@ var init_node = __esm({
           stdio: ["pipe", "pipe", "pipe"]
         });
         const stdin = Writable.toWeb(child.stdin);
-        const stdout = Readable.toWeb(child.stdout);
-        const stderr = Readable.toWeb(child.stderr);
+        const stdout = Readable2.toWeb(child.stdout);
+        const stderr = Readable2.toWeb(child.stderr);
         const exited = new Promise((resolve) => {
           let settled = false;
           const settle = (code, signal) => {
@@ -18461,28 +21517,28 @@ var init_node = __esm({
 });
 
 // src/bridge/lib/session-cwd.ts
-import { mkdir as mkdir3, rm, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir6, rm, writeFile as writeFile6 } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { dirname as dirname3, join as join2 } from "node:path";
+import { dirname as dirname8, join as join5 } from "node:path";
 function dirNameFor(sessionId) {
   if (/^[a-f0-9]{1,12}$/i.test(sessionId)) return sessionId.toLowerCase();
   return createHash("sha256").update(sessionId).digest("hex").slice(0, DIR_NAME_LEN);
 }
 async function ensureSessionCwd(sessionId) {
-  const cwd = join2(paths().sessionsDir, dirNameFor(sessionId));
-  await mkdir3(cwd, { recursive: true });
+  const cwd = join5(paths().sessionsDir, dirNameFor(sessionId));
+  await mkdir6(cwd, { recursive: true });
   return cwd;
 }
 async function writeBundle(cwd, files) {
   for (const f of files) {
     if (f.path.startsWith("/") || f.path.includes("..")) continue;
-    const dst = join2(cwd, f.path);
-    await mkdir3(dirname3(dst), { recursive: true });
-    await writeFile3(dst, f.content);
+    const dst = join5(cwd, f.path);
+    await mkdir6(dirname8(dst), { recursive: true });
+    await writeFile6(dst, f.content);
   }
 }
 async function removeSessionCwd(sessionId) {
-  const cwd = join2(paths().sessionsDir, dirNameFor(sessionId));
+  const cwd = join5(paths().sessionsDir, dirNameFor(sessionId));
   try {
     await rm(cwd, { recursive: true, force: true });
   } catch {
@@ -18498,12 +21554,12 @@ var init_session_cwd = __esm({
 });
 
 // src/bridge/lib/claude-config-dir.ts
-import { mkdir as mkdir4, readdir, rm as rm2, symlink } from "node:fs/promises";
-import { join as join3 } from "node:path";
-import { homedir as homedir2 } from "node:os";
+import { mkdir as mkdir7, readdir, rm as rm2, symlink } from "node:fs/promises";
+import { join as join6 } from "node:path";
+import { homedir as homedir3 } from "node:os";
 async function setupClaudeConfigDir(cwd, blocklist) {
-  const cfgDir = join3(cwd, ".claude-config");
-  await mkdir4(cfgDir, { recursive: true });
+  const cfgDir = join6(cwd, ".claude-config");
+  await mkdir7(cfgDir, { recursive: true });
   await mirrorClaudeHome(cfgDir);
   await rebuildSkills(cfgDir, blocklist);
   return cfgDir;
@@ -18517,11 +21573,11 @@ async function mirrorClaudeHome(cfgDir) {
   }
   for (const entry of entries) {
     if (entry === "skills") continue;
-    const dst = join3(cfgDir, entry);
+    const dst = join6(cfgDir, entry);
     await rm2(dst, { recursive: true, force: true }).catch(() => {
     });
     try {
-      await symlink(join3(CLAUDE_HOME, entry), dst);
+      await symlink(join6(CLAUDE_HOME, entry), dst);
     } catch (e) {
       process.stderr.write(
         `  ! claude-config symlink ${entry} failed (non-fatal): ${e.message}
@@ -18531,11 +21587,11 @@ async function mirrorClaudeHome(cfgDir) {
   }
 }
 async function rebuildSkills(cfgDir, blocklist) {
-  const dst = join3(cfgDir, "skills");
+  const dst = join6(cfgDir, "skills");
   await rm2(dst, { recursive: true, force: true }).catch(() => {
   });
-  await mkdir4(dst, { recursive: true });
-  const src = join3(CLAUDE_HOME, "skills");
+  await mkdir7(dst, { recursive: true });
+  const src = join6(CLAUDE_HOME, "skills");
   let ids = [];
   try {
     ids = await readdir(src);
@@ -18545,7 +21601,7 @@ async function rebuildSkills(cfgDir, blocklist) {
   for (const id of ids) {
     if (id.startsWith(".")) continue;
     if (blocklist.has(id)) continue;
-    await symlink(join3(src, id), join3(dst, id)).catch((e) => {
+    await symlink(join6(src, id), join6(dst, id)).catch((e) => {
       process.stderr.write(
         `  ! claude-config skill symlink ${id} failed (non-fatal): ${e.message}
 `
@@ -18557,11 +21613,12 @@ var CLAUDE_HOME;
 var init_claude_config_dir = __esm({
   "src/bridge/lib/claude-config-dir.ts"() {
     "use strict";
-    CLAUDE_HOME = join3(homedir2(), ".claude");
+    CLAUDE_HOME = join6(homedir3(), ".claude");
   }
 });
 
 // src/bridge/lib/session-manager.ts
+import { spawn as childSpawn } from "node:child_process";
 function scrubAcpSpawnEnv(base) {
   return {
     ...base,
@@ -18585,6 +21642,11 @@ var init_session_manager = __esm({
       #runtime = new AcpRuntimeImpl(this.#spawner);
       #sessions = /* @__PURE__ */ new Map();
       #env = { apiKey: "", apiUrl: "", runtimeToken: "" };
+      /** Set by `drain()` to refuse new session.start while in-flight turns
+       *  finish. Existing sessions keep accepting prompts so a user mid-turn
+       *  doesn't hit "session not ready" mid-stream just because the daemon
+       *  is on its way out. */
+      #draining = false;
       constructor(send) {
         this.#send = send;
       }
@@ -18597,6 +21659,18 @@ var init_session_manager = __esm({
       has(session_id) {
         return this.#sessions.has(session_id);
       }
+      /** Sum of in-flight turns across all sessions. A turn registers itself
+       *  in `sess.turns` when `prompt()` starts and removes itself in the
+       *  finally block when the ACP child finishes streaming. drain() polls
+       *  this to know when it's safe to exit. */
+      activeTurnCount() {
+        let n = 0;
+        for (const s of this.#sessions.values()) n += s.turns.size;
+        return n;
+      }
+      sessionCount() {
+        return this.#sessions.size;
+      }
       /** Re-announce alive sessions to the server (used after WS reconnect). */
       announceAll() {
         for (const [session_id, sess] of this.#sessions) {
@@ -18604,6 +21678,15 @@ var init_session_manager = __esm({
         }
       }
       async start(p) {
+        if (this.#draining) {
+          this.#send({
+            type: "session.error",
+            session_id: p.session_id,
+            turn_id: "",
+            message: "daemon draining for restart \u2014 retry in a few seconds"
+          });
+          return;
+        }
         const existing = this.#sessions.get(p.session_id);
         if (existing) {
           this.#send({
@@ -18613,7 +21696,7 @@ var init_session_manager = __esm({
           });
           return;
         }
-        const agent = KNOWN_ACP_AGENTS.find((a) => a.id === p.agent_id);
+        const agent = resolveKnownAgent(p.agent_id);
         if (!agent) {
           this.#send({
             type: "session.error",
@@ -18622,12 +21705,32 @@ var init_session_manager = __esm({
           });
           return;
         }
+        if (agent.id !== p.agent_id) {
+          process.stderr.write(
+            `  \u21AA canonicalized acp_agent_id ${p.agent_id} \u2192 ${agent.id} (legacy alias)
+`
+          );
+        }
+        const onPath = await new Promise((resolve) => {
+          const probe = process.platform === "win32" ? "where" : "which";
+          const p2 = childSpawn(probe, [agent.spec.command], { stdio: "ignore" });
+          p2.once("error", () => resolve(false));
+          p2.once("exit", (code) => resolve(code === 0));
+        });
+        if (!onPath) {
+          this.#send({
+            type: "session.error",
+            session_id: p.session_id,
+            message: `binary not on PATH for ${agent.id}: \`${agent.spec.command}\`` + (agent.installHint ? `. Install: ${agent.installHint}` : "")
+          });
+          return;
+        }
         const sessionCwd = await ensureSessionCwd(p.session_id);
         let blocklist = [];
         let bundleMcpServers = [];
         let bundleEnv = [];
         try {
-          const bundle = await this.#fetchBundle(p.session_id, p.agent_id);
+          const bundle = await this.#fetchBundle(p.session_id, agent.id);
           if (bundle) {
             await writeBundle(sessionCwd, bundle.files);
             blocklist = bundle.local_skill_blocklist ?? [];
@@ -18639,7 +21742,7 @@ var init_session_manager = __esm({
 `);
         }
         const extraEnv = {};
-        if (p.agent_id === "claude-agent-acp") {
+        if (agent.id === "claude-acp") {
           try {
             const cfgDir = await setupClaudeConfigDir(sessionCwd, new Set(blocklist));
             extraEnv.CLAUDE_CONFIG_DIR = cfgDir;
@@ -18760,6 +21863,66 @@ var init_session_manager = __esm({
         const ids = [...this.#sessions.keys()];
         await Promise.all(ids.map((id) => this.#killChild(id)));
       }
+      /**
+       * Graceful drain for upgrade/restart. Caller (daemon SIGTERM handler)
+       * awaits this before exiting so in-flight ACP turns get to finish
+       * naturally instead of being SIGTERM'd mid-stream.
+       *
+       * Recovery model — mirrors the cloud agent's DO-eviction recovery
+       * (apps/agent/src/runtime/turn-runtime.ts:268 recoverAgentTurn):
+       *
+       *   1. Set #draining → start() rejects new sessions; server retries.
+       *   2. Poll activeTurnCount every 200ms until either:
+       *        - all turns drained naturally (clean session.complete) → break
+       *        - deadline elapsed → abort remaining turns. Their prompt()
+       *          loops unwind, emit session.error, and the ACP children
+       *          checkpoint their conversation state to disk (each ACP
+       *          implementation owns its own persistence; e.g. claude-acp
+       *          stores into ~/.claude/projects/...).
+       *   3. disposeAll() — KEEPS spawn cwds. Same shape as a clean
+       *      shutdown.
+       *
+       * The next time the server sends session.start for any of these ids
+       * it includes `resume.acp_session_id`. The new daemon respawns a
+       * fresh ACP child in the preserved cwd and calls session/load to
+       * restore conversation history (session-manager.ts:311 →
+       * session.ts:108). Worst case the user re-prompts the cut-off turn;
+       * partial response on their screen is the only artifact.
+       *
+       * Idempotent: a second call while one is in progress no-ops past the
+       * existing drain.
+       */
+      async drain(deadlineMs, opts) {
+        if (this.#draining) {
+          const t02 = Date.now();
+          while (this.#sessions.size > 0 && Date.now() - t02 < deadlineMs) {
+            await new Promise((r) => setTimeout(r, 200));
+          }
+          return { initialTurns: 0, abortedTurns: 0, sessions: 0 };
+        }
+        this.#draining = true;
+        const initialTurns = this.activeTurnCount();
+        const initialSessions = this.#sessions.size;
+        const t0 = Date.now();
+        while (this.activeTurnCount() > 0) {
+          const elapsed = Date.now() - t0;
+          if (elapsed >= deadlineMs) break;
+          opts?.onProgress?.(this.activeTurnCount(), deadlineMs - elapsed);
+          await new Promise((r) => setTimeout(r, 200));
+        }
+        let aborted2 = 0;
+        for (const sess of this.#sessions.values()) {
+          for (const ctrl of sess.turns.values()) {
+            ctrl.abort();
+            aborted2 += 1;
+          }
+        }
+        if (aborted2 > 0) {
+          await new Promise((r) => setTimeout(r, 2e3));
+        }
+        await this.disposeAll();
+        return { initialTurns, abortedTurns: aborted2, sessions: initialSessions };
+      }
       /** Kill the ACP child + drop in-memory state. Does NOT touch the spawn
        *  cwd — caller decides whether the cwd should outlive this. */
       async #killChild(session_id) {
@@ -18788,27 +21951,34 @@ var init_session_manager = __esm({
 });
 
 // src/bridge/lib/local-skills.ts
-import { readdir as readdir2, readFile as readFile3, stat } from "node:fs/promises";
-import { join as join4 } from "node:path";
-import { homedir as homedir3 } from "node:os";
+import { readdir as readdir2, readFile as readFile6, stat } from "node:fs/promises";
+import { join as join7 } from "node:path";
+import { homedir as homedir4 } from "node:os";
 async function detectLocalSkills() {
-  return {
-    "claude-agent-acp": await detectClaudeCodeSkills()
-  };
+  const [claude, gemini, opencode] = await Promise.all([
+    detectClaudeCodeSkills(),
+    detectGeminiExtensions(),
+    detectOpencodeAgents()
+  ]);
+  const out = {};
+  if (claude.length) out["claude-acp"] = claude;
+  if (gemini.length) out["gemini"] = gemini;
+  if (opencode.length) out["opencode"] = opencode;
+  return out;
 }
 async function detectClaudeCodeSkills() {
   const seen = /* @__PURE__ */ new Map();
-  for (const skill of await scanSkillsDir(join4(HOME, ".claude", "skills"), "global")) {
+  for (const skill of await scanSkillsDir(join7(HOME, ".claude", "skills"), "global")) {
     seen.set(skill.id, skill);
   }
-  const pluginsRoot = join4(HOME, ".claude", "plugins");
+  const pluginsRoot = join7(HOME, ".claude", "plugins");
   let plugins = [];
   try {
     plugins = await readdir2(pluginsRoot);
   } catch {
   }
   for (const plugin of plugins) {
-    const pluginSkillsDir = join4(pluginsRoot, plugin, "skills");
+    const pluginSkillsDir = join7(pluginsRoot, plugin, "skills");
     for (const skill of await scanSkillsDir(pluginSkillsDir, "plugin", plugin)) {
       const key = `${plugin}/${skill.id}`;
       seen.set(key, skill);
@@ -18826,7 +21996,7 @@ async function scanSkillsDir(dir, source, source_label) {
   const out = [];
   for (const id of entries) {
     if (id.startsWith(".")) continue;
-    const skillDir = join4(dir, id);
+    const skillDir = join7(dir, id);
     let st;
     try {
       st = await stat(skillDir);
@@ -18834,7 +22004,7 @@ async function scanSkillsDir(dir, source, source_label) {
       continue;
     }
     if (!st.isDirectory()) continue;
-    const meta = await readSkillMeta(join4(skillDir, "SKILL.md"));
+    const meta = await readSkillMeta(join7(skillDir, "SKILL.md"));
     out.push({
       id,
       name: meta.name ?? id,
@@ -18849,7 +22019,7 @@ async function scanSkillsDir(dir, source, source_label) {
 async function readSkillMeta(file2) {
   let text;
   try {
-    text = await readFile3(file2, "utf-8");
+    text = await readFile6(file2, "utf-8");
   } catch {
     return {};
   }
@@ -18873,11 +22043,89 @@ async function readSkillMeta(file2) {
   }
   return { name, description };
 }
+async function detectGeminiExtensions() {
+  const root = join7(HOME, ".gemini", "extensions");
+  let entries;
+  try {
+    entries = await readdir2(root);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const id of entries) {
+    if (id.startsWith(".")) continue;
+    const extDir = join7(root, id);
+    let st;
+    try {
+      st = await stat(extDir);
+    } catch {
+      continue;
+    }
+    if (!st.isDirectory()) continue;
+    let manifest = {};
+    try {
+      const raw = await readFile6(join7(extDir, "gemini-extension.json"), "utf-8");
+      manifest = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    let description = manifest.description;
+    if (!description) {
+      const ctxName = manifest.contextFileName ?? "GEMINI.md";
+      const meta = await readSkillMeta(join7(extDir, ctxName));
+      description = meta.description;
+    }
+    out.push({
+      id,
+      name: manifest.name ?? id,
+      description,
+      source: "global",
+      path: extDir
+    });
+  }
+  return out;
+}
+async function detectOpencodeAgents() {
+  const seen = /* @__PURE__ */ new Map();
+  const dirs = [
+    join7(HOME, ".opencode", "agents"),
+    join7(HOME, ".config", "opencode", "agents")
+  ];
+  for (const dir of dirs) {
+    let entries;
+    try {
+      entries = await readdir2(dir);
+    } catch {
+      continue;
+    }
+    for (const file2 of entries) {
+      if (!file2.endsWith(".md") || file2.startsWith(".")) continue;
+      const id = file2.slice(0, -3);
+      const path2 = join7(dir, file2);
+      let st;
+      try {
+        st = await stat(path2);
+      } catch {
+        continue;
+      }
+      if (!st.isFile()) continue;
+      const meta = await readSkillMeta(path2);
+      seen.set(id, {
+        id,
+        name: meta.name ?? id,
+        description: meta.description,
+        source: "global",
+        path: path2
+      });
+    }
+  }
+  return [...seen.values()];
+}
 var HOME;
 var init_local_skills = __esm({
   "src/bridge/lib/local-skills.ts"() {
     "use strict";
-    HOME = homedir3();
+    HOME = homedir4();
   }
 });
 
@@ -18887,6 +22135,8 @@ __export(daemon_exports, {
   runDaemon: () => runDaemon
 });
 import { hostname as hostname3 } from "node:os";
+import { join as join8 } from "node:path";
+import { mkdirSync as mkdirSync2, writeFileSync, unlinkSync as unlinkSync2 } from "node:fs";
 async function runDaemon() {
   const creds = await readCreds();
   if (!creds) {
@@ -18895,25 +22145,108 @@ async function runDaemon() {
     );
     process.exit(2);
   }
-  printBanner(`daemon \u2014 runtime ${creds.runtimeId.slice(0, 8)}\u2026 \u2192 ${creds.serverUrl}`, PKG_VERSION);
+  const profile = currentProfile();
+  const profileTag = profile ? `  [profile=${profile}]` : "";
+  printBanner(`daemon \u2014 runtime ${creds.runtimeId.slice(0, 8)}\u2026 \u2192 ${creds.serverUrl}${profileTag}`, PKG_VERSION);
+  const cachePath = join8(paths().configDir, "registry-cache.json");
+  await loadRegistry({ cachePath });
   const wsBase = creds.serverUrl.replace(/^http(s?):\/\//, "ws$1://").replace(/\/$/, "");
   const wsUrl = `${wsBase}/agents/runtime/_attach`;
   let backoffMs = RECONNECT_BACKOFF_MIN_MS;
+  const DRAIN_DEADLINE_MS = 1e4;
+  let draining = false;
   let stopping = false;
-  const stop = (sig) => {
+  const stop = (sig, force = false) => {
     if (stopping) return;
-    stopping = true;
-    log.step(`${sig} received, shutting down`);
-    void sessions.disposeAll();
-    if (currentWs) {
+    if (draining && !force) {
+      log.warn(`${sig} again \u2014 abandoning drain, exiting now`);
+      stopping = true;
       try {
-        currentWs.close(1e3, "shutdown");
+        unlinkSync2(join8(paths().configDir, "daemon.pid"));
       } catch {
       }
+      void sessions.disposeAll();
+      if (currentWs) {
+        try {
+          currentWs.close(1e3, "shutdown");
+        } catch {
+        }
+      }
+      return;
+    }
+    draining = true;
+    log.step(`${sig} received, draining (${DRAIN_DEADLINE_MS / 1e3}s deadline; sessions recover via session/load on reconnect)`);
+    try {
+      unlinkSync2(join8(paths().configDir, "daemon.pid"));
+    } catch {
     }
+    void (async () => {
+      const r = await sessions.drain(DRAIN_DEADLINE_MS, {
+        onProgress: (active, msLeft) => {
+          log.hint(`${active} turns active, ${Math.ceil(msLeft / 1e3)}s left`);
+        }
+      }).catch((e) => {
+        log.err(`drain failed: ${e.message}`);
+        return { initialTurns: 0, abortedTurns: 0, sessions: 0 };
+      });
+      const naturallyCompleted = r.initialTurns - r.abortedTurns;
+      if (r.abortedTurns > 0) {
+        log.warn(
+          `deadline reached \u2014 aborted ${r.abortedTurns} in-flight turn(s); they'll resume via ACP session/load when the server reconnects`
+        );
+      }
+      log.ok(
+        `drained ${r.sessions} session(s) (${naturallyCompleted}/${r.initialTurns} turns completed cleanly)`
+      );
+      stopping = true;
+      if (currentWs) {
+        try {
+          currentWs.close(1e3, "shutdown");
+        } catch {
+        }
+      }
+    })();
   };
   process.on("SIGTERM", () => stop("SIGTERM"));
   process.on("SIGINT", () => stop("SIGINT"));
+  try {
+    mkdirSync2(paths().configDir, { recursive: true });
+    writeFileSync(join8(paths().configDir, "daemon.pid"), String(process.pid), "utf-8");
+  } catch (e) {
+    process.stderr.write(`! pid file write failed (non-fatal): ${e.message}
+`);
+  }
+  process.on("SIGHUP", () => {
+    void (async () => {
+      log.step("SIGHUP \u2014 refreshing agent detection");
+      try {
+        await loadRegistry({ cachePath, forceRefresh: true });
+        const agents = (await detectAll()).map((a) => ({ id: a.id, binary: a.spec.command }));
+        const localSkillsDetailed = await detectLocalSkills();
+        const localSkills = {};
+        for (const [agentId, skills] of Object.entries(localSkillsDetailed)) {
+          if (!skills) continue;
+          localSkills[agentId] = skills.map(({ path: _path, ...rest }) => rest);
+        }
+        if (currentWs && currentWs.readyState === wrapper_default.OPEN) {
+          currentWs.send(JSON.stringify({
+            type: "hello",
+            machine_id: creds.machineId,
+            hostname: hostname3(),
+            os: osTag(),
+            version: PKG_VERSION,
+            agents,
+            local_skills: localSkills
+          }));
+          log.ok(`re-published manifest  (${agents.length} agents)`);
+        } else {
+          log.warn("WS not attached \u2014 manifest will be re-sent on next connect");
+        }
+      } catch (e) {
+        log.warn(`refresh failed: ${e.message}`);
+      }
+    })();
+  });
   let currentWs = null;
   const sessions = new SessionManager(() => {
   });
@@ -19060,7 +22393,9 @@ __export(status_exports, {
   runStatus: () => runStatus
 });
 async function runStatus() {
-  printBanner("status", PKG_VERSION);
+  const profile = currentProfile();
+  const profileTag = profile ? `  [profile=${profile}]` : "";
+  printBanner(`status${profileTag}`, PKG_VERSION);
   const p = paths();
   const creds = await readCreds();
   if (!creds) {
@@ -19068,6 +22403,7 @@ async function runStatus() {
     log.hint(`looked for ${p.credsFile}`);
     process.exit(1);
   }
+  const kind = detectServiceKind();
   const row = (k, v) => process.stderr.write(`  ${c.dim(k.padEnd(11))} ${v}
 `);
   row("server", creds.serverUrl);
@@ -19076,7 +22412,7 @@ async function runStatus() {
   row("registered", new Date(creds.createdAt * 1e3).toISOString());
   row("creds file", c.dim(p.credsFile));
   row("log file", c.dim(p.logFile));
-  if (p.serviceFile) row("service", c.dim(p.serviceFile));
+  row("service", c.dim(`${kind}${p.serviceFile ? ` \u2192 ${p.serviceFile}` : ""}`));
   process.stderr.write("\n");
   log.step("probing server");
   const probe = await probeRuntimeToken(creds.serverUrl, creds.token);
@@ -19101,6 +22437,7 @@ var init_status = __esm({
     "use strict";
     init_config();
     init_platform();
+    init_service_manager();
     init_style();
     init_version();
     init_probe();
@@ -19114,15 +22451,15 @@ __export(uninstall_exports, {
 });
 async function runUninstall() {
   printBanner("uninstall \u2014 remove daemon + local credentials", PKG_VERSION);
-  if (currentPlatform() === "darwin") {
-    try {
-      const r = await uninstall();
-      if (r.removed) log.ok(`launchd plist removed  ${c.dim(paths().serviceFile ?? "")}`);
-      else process.stderr.write(`${sym.dot()} ${c.dim("launchd plist not present")}
+  try {
+    const r = await uninstall4();
+    const tag = r.kind === "launchd" ? "launchd plist" : r.kind === "systemd" ? "systemd unit" : r.kind === "windows-task" ? "Task Scheduler task" : "service";
+    if (r.removed) log.ok(`${tag} removed  ${c.dim(paths().serviceFile ?? paths().configDir)}`);
+    else process.stderr.write(`${sym.dot()} ${c.dim(`${tag} not present`)}
 `);
-    } catch (e) {
-      log.warn(`launchd uninstall failed: ${e instanceof Error ? e.message : String(e)}`);
-    }
+    if (r.warning) log.hint(c.dim(r.warning));
+  } catch (e) {
+    log.warn(`service uninstall failed: ${e instanceof Error ? e.message : String(e)}`);
   }
   const creds = await readCreds();
   if (creds) {
@@ -19157,7 +22494,7 @@ ${c.bold("Done.")}
 var init_uninstall = __esm({
   "src/bridge/commands/uninstall.ts"() {
     "use strict";
-    init_launchd();
+    init_service_manager();
     init_config();
     init_platform();
     init_style();
@@ -19165,17 +22502,87 @@ var init_uninstall = __esm({
   }
 });
 
+// src/bridge/commands/agents.ts
+var agents_exports = {};
+__export(agents_exports, {
+  runAgents: () => runAgents
+});
+import { readFileSync, statSync } from "node:fs";
+import { join as join9 } from "node:path";
+async function runAgents(args) {
+  const sub = args[0] ?? "";
+  switch (sub) {
+    case "refresh":
+      await refresh(args.slice(1));
+      return;
+    default:
+      process.stderr.write(
+        "oma bridge agents \u2014 manage local agent detection\n\n  oma bridge agents refresh [--yes]   re-scan + offer-install missing ACP wrappers + signal daemon\n"
+      );
+      process.exit(sub ? 1 : 0);
+  }
+}
+async function refresh(args) {
+  const profile = currentProfile();
+  const profileTag = profile ? ` [profile=${profile}]` : "";
+  const yes = args.includes("--yes") || args.includes("-y");
+  const cachePath = join9(paths().configDir, "registry-cache.json");
+  await loadRegistry({ cachePath, forceRefresh: true });
+  const detected = (await detectAll()).map((a) => ({ id: a.id, binary: a.spec.command }));
+  await auditAndOfferWrappers(detected, { yes });
+  const pidFile = join9(paths().configDir, "daemon.pid");
+  let pid = 0;
+  try {
+    pid = parseInt(readFileSync(pidFile, "utf-8").trim(), 10);
+    if (!Number.isFinite(pid) || pid <= 0) pid = 0;
+    if (pid) process.kill(pid, 0);
+  } catch {
+    pid = 0;
+  }
+  if (pid === 0) {
+    log.hint(`no running daemon${profileTag}; manifest will reflect on next \`oma bridge daemon\``);
+    return;
+  }
+  try {
+    const ageMs = Date.now() - statSync(pidFile).mtimeMs;
+    if (ageMs > 7 * 24 * 3600 * 1e3) {
+      log.hint(`pid file is ${Math.floor(ageMs / 864e5)} days old`);
+    }
+  } catch {
+  }
+  try {
+    process.kill(pid, "SIGHUP");
+    log.ok(`daemon${profileTag} re-detecting (pid ${pid})`);
+    log.hint("Console dropdown will reflect the new state in 1\u20132s");
+  } catch (e) {
+    log.warn(`signal failed: ${e.message}`);
+    process.exit(2);
+  }
+}
+var init_agents = __esm({
+  "src/bridge/commands/agents.ts"() {
+    "use strict";
+    init_platform();
+    init_registry();
+    init_wrapper_audit();
+    init_style();
+  }
+});
+
 // src/index.ts
+init_platform();
 import { createServer as createServer2 } from "node:http";
 import { execSync } from "node:child_process";
-import { homedir as homedir4, hostname as hostname4 } from "node:os";
-import { join as join5, dirname as dirname4 } from "node:path";
-import { mkdirSync, readFileSync, writeFileSync, unlinkSync, existsSync, chmodSync } from "node:fs";
-import { randomBytes as randomBytes2 } from "node:crypto";
+import { homedir as homedir5, hostname as hostname4 } from "node:os";
+import { join as join10, dirname as dirname9 } from "node:path";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync as unlinkSync3, existsSync as existsSync2, chmodSync as chmodSync2 } from "node:fs";
+import { randomBytes as randomBytes3 } from "node:crypto";
 function credentialsPath() {
   const xdg = process.env.XDG_CONFIG_HOME;
-  const base = xdg && xdg.length > 0 ? xdg : join5(homedir4(), ".config");
-  return join5(base, "oma", "credentials.json");
+  const base = xdg && xdg.length > 0 ? xdg : join10(homedir5(), ".config");
+  const profile = currentProfile();
+  const file2 = profile ? `credentials.${profile}.json` : "credentials.json";
+  return join10(base, "oma", file2);
 }
 function migrateV1ToV2(v1) {
   return {
@@ -19195,10 +22602,10 @@ function migrateV1ToV2(v1) {
   };
 }
 function readCredentials() {
-  const path = credentialsPath();
+  const path2 = credentialsPath();
   try {
-    if (!existsSync(path)) return null;
-    const raw = readFileSync(path, "utf8");
+    if (!existsSync2(path2)) return null;
+    const raw = readFileSync2(path2, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version === 2) return parsed;
     if (parsed.version === 1) {
@@ -19215,18 +22622,18 @@ function readCredentials() {
   }
 }
 function writeCredentials(creds) {
-  const path = credentialsPath();
-  mkdirSync(dirname4(path), { recursive: true, mode: 448 });
-  writeFileSync(path, JSON.stringify(creds, null, 2), { mode: 384 });
+  const path2 = credentialsPath();
+  mkdirSync3(dirname9(path2), { recursive: true, mode: 448 });
+  writeFileSync2(path2, JSON.stringify(creds, null, 2), { mode: 384 });
   try {
-    chmodSync(path, 384);
+    chmodSync2(path2, 384);
   } catch {
   }
 }
 function clearCredentials() {
-  const path = credentialsPath();
-  if (!existsSync(path)) return false;
-  unlinkSync(path);
+  const path2 = credentialsPath();
+  if (!existsSync2(path2)) return false;
+  unlinkSync3(path2);
   return true;
 }
 function loadConfig() {
@@ -19291,8 +22698,8 @@ async function fetchWithRetry(url2, init, maxRetries = 3) {
     attempt += 1;
   }
 }
-async function apiFetch(config2, path, init) {
-  const url2 = `${config2.baseUrl}${path}`;
+async function apiFetch(config2, path2, init) {
+  const url2 = `${config2.baseUrl}${path2}`;
   const res = await fetchWithRetry(url2, {
     ...init,
     headers: {
@@ -19312,8 +22719,8 @@ async function apiFetch(config2, path, init) {
   }
   return res.json();
 }
-async function rawStream(config2, path, init) {
-  const res = await fetchWithRetry(`${config2.baseUrl}${path}`, {
+async function rawStream(config2, path2, init) {
+  const res = await fetchWithRetry(`${config2.baseUrl}${path2}`, {
     ...init,
     headers: {
       "x-api-key": config2.apiKey,
@@ -19456,7 +22863,7 @@ function table(rows) {
   if (!rows.length) return;
   const widths = rows[0].map((_, i) => Math.max(...rows.map((r) => (r[i] || "").length)));
   for (const row of rows) {
-    console.log(row.map((c2, i) => (c2 || "").padEnd(widths[i])).join("  "));
+    console.log(row.map((c3, i) => (c3 || "").padEnd(widths[i])).join("  "));
   }
 }
 function capsPreview(caps) {
@@ -19476,7 +22883,7 @@ function isPubliclyReachable(url2) {
   }
 }
 async function authLogin(baseUrl, requestedTenant) {
-  const state = randomBytes2(16).toString("hex");
+  const state = randomBytes3(16).toString("hex");
   const port = 19500 + Math.floor(Math.random() * 500);
   const callback = `http://127.0.0.1:${port}/callback`;
   const params = new URLSearchParams({
@@ -20000,7 +23407,7 @@ Version: v${a.version}`);
         console.log("No model cards. Create one with: oma models create");
         return;
       }
-      table([["NAME", "PROVIDER", "MODEL", "KEY", "DEFAULT"], ...data.map((c2) => [c2.name, c2.provider, c2.model_id, `****${c2.api_key_preview || ""}`, c2.is_default ? "yes" : ""])]);
+      table([["NAME", "PROVIDER", "MODEL", "KEY", "DEFAULT"], ...data.map((c3) => [c3.name, c3.provider, c3.model_id, `****${c3.api_key_preview || ""}`, c3.is_default ? "yes" : ""])]);
     }
   },
   {
@@ -20107,7 +23514,7 @@ Save this key \u2014 it won't be shown again.`);
         console.log("No credentials in this vault.");
         return;
       }
-      table([["NAME", "TYPE", "DETAIL"], ...data.map((c2) => [c2.display_name, c2.auth.type, c2.auth.mcp_server_url || c2.auth.command_prefixes?.join(", ") || ""])]);
+      table([["NAME", "TYPE", "DETAIL"], ...data.map((c3) => [c3.display_name, c3.auth.type, c3.auth.mcp_server_url || c3.auth.command_prefixes?.join(", ") || ""])]);
     }
   },
   {
@@ -21257,14 +24664,14 @@ Expires in ${r.expiresInDays} days.`);
     http: "POST   /v1/memory_stores/:id/memories {path, content, precondition?}",
     async run(config2, args) {
       const storeId = args[0];
-      const path = args[1];
+      const path2 = args[1];
       const content = readContentArg(args);
       const sha = flag(args, "--precondition-sha256");
-      if (!storeId || !path || content === void 0) {
+      if (!storeId || !path2 || content === void 0) {
         console.error("Usage: oma memory write <store-id> <path> (--content <c> | --from-file <f>) [--precondition-sha256 <h>]");
         process.exit(1);
       }
-      const body = { path, content };
+      const body = { path: path2, content };
       if (sha) body.precondition = { type: "content_sha256", content_sha256: sha };
       const mem = await apiFetch(
         config2,
@@ -21345,19 +24752,19 @@ Expires in ${r.expiresInDays} days.`);
     async run(config2, args) {
       const storeId = args[0];
       const memId = args[1];
-      const path = flag(args, "--path");
+      const path2 = flag(args, "--path");
       const content = readContentArg(args);
       const sha = flag(args, "--precondition-sha256");
       if (!storeId || !memId) {
         console.error("Usage: oma memory update <store-id> <memory-id> [--path <p>] [--content <c> | --from-file <f>] [--precondition-sha256 <h>]");
         process.exit(1);
       }
-      if (path === void 0 && content === void 0) {
+      if (path2 === void 0 && content === void 0) {
         console.error("Pass at least --path or --content/--from-file.");
         process.exit(1);
       }
       const body = {};
-      if (path !== void 0) body.path = path;
+      if (path2 !== void 0) body.path = path2;
       if (content !== void 0) body.content = content;
       if (sha) body.precondition = { type: "content_sha256", content_sha256: sha };
       const mem = await apiFetch(
@@ -21571,10 +24978,10 @@ async function connectMcp(config2, mcpServerUrl, vaultId) {
 }
 function apiRef(resource) {
   const groups = /* @__PURE__ */ new Map();
-  for (const c2 of commands) {
-    const list = groups.get(c2.group) || [];
-    list.push(`  ${c2.http}`);
-    groups.set(c2.group, list);
+  for (const c3 of commands) {
+    const list = groups.get(c3.group) || [];
+    list.push(`  ${c3.http}`);
+    groups.set(c3.group, list);
   }
   for (const e of extraEndpoints) {
     const list = groups.get(e.group) || [];
@@ -21631,20 +25038,21 @@ oma \u2014 Open Managed Agents CLI
 
 Usage:`);
   let lastGroup = "";
-  for (const c2 of commands) {
-    if (c2.group !== lastGroup) {
+  for (const c3 of commands) {
+    if (c3.group !== lastGroup) {
       console.log(`
-  ${c2.group}:`);
-      lastGroup = c2.group;
+  ${c3.group}:`);
+      lastGroup = c3.group;
     }
-    console.log(`    ${c2.usage.padEnd(42)} ${c2.desc}`);
+    console.log(`    ${c3.usage.padEnd(42)} ${c3.desc}`);
   }
   console.log(`
   Bridge (local runtime):
-    oma bridge setup [--force] [--no-service]    Pair this machine with OMA (one-time OAuth)
-    oma bridge daemon                            Run the bridge in foreground
+    oma bridge setup [--force] [--no-service]    Pair this machine with OMA + start daemon
     oma bridge status                            Show creds + probe server reachability
-    oma bridge uninstall                         Remove launchd service + creds
+    oma bridge agents refresh                    Re-detect agents + offer wrapper installs
+    oma bridge uninstall                         Stop service + remove creds
+    (oma bridge daemon                           Internal: launched by service mgr / debugging)
 
   API Reference:
     oma api                                    Show all HTTP endpoints
@@ -21669,17 +25077,42 @@ async function main() {
     apiRef(args[1]);
     return;
   }
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--profile" && i + 1 < args.length) {
+      process.env.OMA_PROFILE = args[i + 1];
+      args.splice(i, 2);
+      const argvIdx = process.argv.indexOf("--profile");
+      if (argvIdx !== -1) process.argv.splice(argvIdx, 2);
+      break;
+    }
+    const eq = args[i].match(/^--profile=(.+)$/);
+    if (eq) {
+      process.env.OMA_PROFILE = eq[1];
+      args.splice(i, 1);
+      const argvIdx = process.argv.findIndex((a) => a.startsWith("--profile="));
+      if (argvIdx !== -1) process.argv.splice(argvIdx, 1);
+      break;
+    }
+  }
+  try {
+    currentProfile();
+  } catch (e) {
+    console.error(`Error: ${e.message}`);
+    process.exit(2);
+  }
   if (args[0] === "bridge") {
     const sub = args[1] ?? "";
     process.argv.splice(2, 2);
     switch (sub) {
       case "setup": {
+        const serverUrl = flag(args, "--server-url") ?? "https://openma.dev";
         const { runSetup: runSetup2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
         await runSetup2({
-          serverUrl: flag(args, "--server-url") ?? "https://openma.dev",
-          browserOrigin: flag(args, "--browser-origin") ?? "https://openma.dev",
+          serverUrl,
+          browserOrigin: flag(args, "--browser-origin") ?? serverUrl,
           noService: args.includes("--no-service"),
-          force: args.includes("--force")
+          force: args.includes("--force"),
+          yes: args.includes("--yes") || args.includes("-y")
         });
         return;
       }
@@ -21698,9 +25131,14 @@ async function main() {
         await runUninstall2();
         return;
       }
+      case "agents": {
+        const { runAgents: runAgents2 } = await Promise.resolve().then(() => (init_agents(), agents_exports));
+        await runAgents2(args.slice(2));
+        return;
+      }
       default:
         console.error(
-          "oma bridge \u2014 pair a local ACP agent with OMA\n\n  oma bridge setup [--server-url=\u2026] [--no-service] [--force]\n  oma bridge daemon\n  oma bridge status\n  oma bridge uninstall\n"
+          "oma bridge \u2014 pair a local ACP agent with OMA\n\n  oma bridge setup [--server-url=\u2026] [--no-service] [--force] [--yes]\n                                       Pair + install service + start daemon\n  oma bridge status                    Creds + service kind + probe server\n  oma bridge agents refresh [--yes]    Re-scan + offer-install wrappers + reload\n  oma bridge uninstall                 Stop service + remove creds\n  oma bridge daemon                    (internal \u2014 launched by service mgr / for debug)\n\n  Use --profile <name> (or OMA_PROFILE=<name>) to run multiple\n  daemons side-by-side (e.g. prod in launchd + staging foreground).\n"
         );
         process.exit(sub ? 1 : 0);
     }
@@ -21711,15 +25149,15 @@ async function main() {
   const config2 = isPreAuth ? loadConfigOptional() : loadConfig();
   config2.json = wantJson;
   let needsArgMatch = null;
-  for (const c2 of commands) {
-    const verbMatch = c2.match.every((tok, i) => args[i] === tok);
+  for (const c3 of commands) {
+    const verbMatch = c3.match.every((tok, i) => args[i] === tok);
     if (!verbMatch) continue;
-    if (c2.needsArg && !args[c2.match.length]) {
-      needsArgMatch = c2;
+    if (c3.needsArg && !args[c3.match.length]) {
+      needsArgMatch = c3;
       continue;
     }
-    const rest = args.slice(c2.match.length);
-    return c2.run(config2, rest);
+    const rest = args.slice(c3.match.length);
+    return c3.run(config2, rest);
   }
   if (needsArgMatch) {
     console.error(`${needsArgMatch.usage}