svamp-cli 0.2.264 → 0.2.265

package/dist/{run-kkeXP2d_.mjs → run-b-b_szy6.mjs}

@@ -5,13 +5,13 @@ import path__default, { join as join$1, resolve as resolve$1, dirname as dirname
 import { fileURLToPath } from 'url';
 import { execFile, spawn as spawn$1, execSync as execSync$1, exec as exec$1 } from 'child_process';
 import { randomUUID as randomUUID$1 } from 'crypto';
-import { randomBytes, createHash, randomUUID } from 'node:crypto';
-import { existsSync, readFileSync, realpathSync, readdirSync, statSync, mkdirSync, writeFileSync, renameSync, rmSync, appendFileSync, unlinkSync } from 'node:fs';
+import { randomUUID, randomBytes, createHash } from 'node:crypto';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, chmodSync, realpathSync, readdirSync, statSync, renameSync, rmSync, appendFileSync, unlinkSync } from 'node:fs';
 import { exec, execSync, spawn, execFile as execFile$1, execFileSync } from 'node:child_process';
 import { promisify } from 'util';
-import { extname, resolve, join, sep, basename, dirname } from 'node:path';
-import { EventEmitter } from 'node:events';
 import os, { homedir, platform } from 'node:os';
+import { join, extname, resolve, sep, basename, dirname } from 'node:path';
+import { EventEmitter } from 'node:events';
 import { ndJsonStream, ClientSideConnection } from '@agentclientprotocol/sdk';
 import { createInterface } from 'node:readline';
 import { mkdir, rm, chmod, access, mkdtemp, copyFile, writeFile, readdir, stat, readFile as readFile$1 } from 'node:fs/promises';
@@ -1218,6 +1218,547 @@ async function killDescendant(rootPid, targetPid, signal = "SIGTERM") {
   }
 }
 
+const EXAMPLE_HYPHA_PROXY_URL = "https://proxy.hypha.aicell.io";
+const MODE_KEY = "SVAMP_CLAUDE_PROXY";
+const HYPHA_PROXY_URL_KEY = "SVAMP_HYPHA_PROXY_URL";
+const MANAGED_KEYS = /* @__PURE__ */ new Set([
+  MODE_KEY,
+  HYPHA_PROXY_URL_KEY,
+  "ANTHROPIC_BASE_URL",
+  "ANTHROPIC_API_KEY"
+]);
+function normalizeProxyUrl(raw) {
+  const trimmed = raw.trim().replace(/\/+$/, "");
+  if (trimmed.endsWith("/v1")) {
+    throw new Error(
+      "Hypha proxy URL must not end in /v1 \u2014 the SDK appends it, producing double /v1/v1/messages"
+    );
+  }
+  return trimmed;
+}
+function resolveHyphaProxyUrl() {
+  const configured = (process.env[HYPHA_PROXY_URL_KEY] || "").trim();
+  if (!configured) return void 0;
+  try {
+    return normalizeProxyUrl(configured);
+  } catch {
+    return void 0;
+  }
+}
+function envFilePath() {
+  const svampHome = process.env.SVAMP_HOME || join(homedir(), ".svamp");
+  return join(svampHome, ".env");
+}
+function readEnvLines() {
+  const file = envFilePath();
+  if (!existsSync(file)) return [];
+  return readFileSync(file, "utf-8").split("\n");
+}
+function writeEnvLines(lines) {
+  const file = envFilePath();
+  const dir = join(file, "..");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+    lines.pop();
+  }
+  writeFileSync(file, lines.join("\n") + "\n", "utf-8");
+}
+function updateEnvFile(updates) {
+  const lines = readEnvLines();
+  const kept = [];
+  const remainingUpdates = new Map(Object.entries(updates));
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      kept.push(line);
+      continue;
+    }
+    const eq = trimmed.indexOf("=");
+    const key = eq === -1 ? trimmed : trimmed.slice(0, eq);
+    if (remainingUpdates.has(key)) {
+      const v = remainingUpdates.get(key);
+      remainingUpdates.delete(key);
+      if (v === void 0) continue;
+      kept.push(`${key}=${v}`);
+      continue;
+    }
+    kept.push(line);
+  }
+  for (const [key, v] of remainingUpdates) {
+    if (v === void 0) continue;
+    kept.push(`${key}=${v}`);
+  }
+  writeEnvLines(kept);
+}
+function currentMode() {
+  const raw = (process.env[MODE_KEY] || "").trim().toLowerCase();
+  if (raw === "hypha" || raw === "hypha-proxy") return "hypha";
+  if (raw === "custom") return "custom";
+  return "login";
+}
+function redactKey(key) {
+  if (!key) return void 0;
+  if (key.length <= 12) return "***";
+  return `${key.slice(0, 8)}\u2026${key.slice(-4)}`;
+}
+function getClaudeAuthStatus() {
+  const mode = currentMode();
+  if (mode === "hypha") {
+    const token = process.env.HYPHA_TOKEN;
+    const proxyUrl = resolveHyphaProxyUrl();
+    return {
+      mode,
+      baseUrl: proxyUrl,
+      apiKeyPreview: redactKey(token),
+      hyphaTokenMissing: !token,
+      hyphaProxyUrlMissing: !proxyUrl
+    };
+  }
+  if (mode === "custom") {
+    return {
+      mode,
+      baseUrl: process.env.ANTHROPIC_BASE_URL,
+      apiKeyPreview: redactKey(process.env.ANTHROPIC_API_KEY)
+    };
+  }
+  return { mode: "login" };
+}
+function setClaudeAuthHyphaProxy(url) {
+  if (!url || !url.trim()) {
+    throw new Error(
+      `A Hypha proxy URL is required (no default). Example: svamp daemon auth use-hypha-proxy ${EXAMPLE_HYPHA_PROXY_URL}`
+    );
+  }
+  updateEnvFile({
+    [MODE_KEY]: "hypha",
+    [HYPHA_PROXY_URL_KEY]: normalizeProxyUrl(url),
+    // Hypha mode resolves token live at spawn — no stored copy.
+    ANTHROPIC_BASE_URL: void 0,
+    ANTHROPIC_API_KEY: void 0
+  });
+}
+function setClaudeAuthLogin() {
+  updateEnvFile({
+    [MODE_KEY]: void 0,
+    [HYPHA_PROXY_URL_KEY]: void 0,
+    ANTHROPIC_BASE_URL: void 0,
+    ANTHROPIC_API_KEY: void 0
+  });
+}
+function setClaudeAuthCustom(baseUrl, apiKey) {
+  if (!baseUrl) throw new Error("ANTHROPIC_BASE_URL is required for custom mode");
+  if (!apiKey) throw new Error("ANTHROPIC_API_KEY is required for custom mode");
+  const trimmed = baseUrl.replace(/\/+$/, "");
+  if (trimmed.endsWith("/v1")) {
+    throw new Error(
+      "ANTHROPIC_BASE_URL must not end in /v1 \u2014 the SDK appends it, producing double /v1/v1/messages"
+    );
+  }
+  updateEnvFile({
+    [MODE_KEY]: "custom",
+    [HYPHA_PROXY_URL_KEY]: void 0,
+    ANTHROPIC_BASE_URL: trimmed,
+    ANTHROPIC_API_KEY: apiKey
+  });
+}
+function applyClaudeProxyEnv(spawnEnv) {
+  const mode = currentMode();
+  if (mode === "hypha") {
+    const proxyUrl = resolveHyphaProxyUrl();
+    if (!proxyUrl) {
+      delete spawnEnv.ANTHROPIC_BASE_URL;
+      delete spawnEnv.ANTHROPIC_API_KEY;
+      return `hypha mode but ${HYPHA_PROXY_URL_KEY} not configured \u2014 run \`svamp daemon auth use-hypha-proxy <URL>\`; falling back to login`;
+    }
+    const token = process.env.HYPHA_TOKEN;
+    if (!token) {
+      delete spawnEnv.ANTHROPIC_BASE_URL;
+      delete spawnEnv.ANTHROPIC_API_KEY;
+      return "hypha mode but HYPHA_TOKEN missing \u2014 falling back to login";
+    }
+    spawnEnv.ANTHROPIC_BASE_URL = proxyUrl;
+    spawnEnv.ANTHROPIC_API_KEY = token;
+    const cacheOverride = spawnEnv.ENABLE_PROMPT_CACHING_1H ?? process.env.ENABLE_PROMPT_CACHING_1H ?? spawnEnv.FORCE_PROMPT_CACHING_5M ?? process.env.FORCE_PROMPT_CACHING_5M;
+    if (cacheOverride === void 0) spawnEnv.ENABLE_PROMPT_CACHING_1H = "1";
+    return `hypha proxy (${proxyUrl}, 1h cache TTL)`;
+  }
+  if (mode === "custom") {
+    const url = process.env.ANTHROPIC_BASE_URL;
+    const key = process.env.ANTHROPIC_API_KEY;
+    if (!url || !key) {
+      delete spawnEnv.ANTHROPIC_BASE_URL;
+      delete spawnEnv.ANTHROPIC_API_KEY;
+      return "custom mode but ANTHROPIC_BASE_URL/API_KEY missing \u2014 falling back to login";
+    }
+    spawnEnv.ANTHROPIC_BASE_URL = url;
+    spawnEnv.ANTHROPIC_API_KEY = key;
+    return `custom proxy (${url})`;
+  }
+  delete spawnEnv.ANTHROPIC_BASE_URL;
+  delete spawnEnv.ANTHROPIC_API_KEY;
+  return null;
+}
+const MANAGED_ENV_KEYS = Array.from(MANAGED_KEYS);
+
+var claudeAuth = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    EXAMPLE_HYPHA_PROXY_URL: EXAMPLE_HYPHA_PROXY_URL,
+    MANAGED_ENV_KEYS: MANAGED_ENV_KEYS,
+    applyClaudeProxyEnv: applyClaudeProxyEnv,
+    getClaudeAuthStatus: getClaudeAuthStatus,
+    resolveHyphaProxyUrl: resolveHyphaProxyUrl,
+    setClaudeAuthCustom: setClaudeAuthCustom,
+    setClaudeAuthHyphaProxy: setClaudeAuthHyphaProxy,
+    setClaudeAuthLogin: setClaudeAuthLogin,
+    updateEnvFile: updateEnvFile
+});
+
+function codexPermissionSettings(mode) {
+  switch (mode) {
+    case "yolo":
+    case "bypassPermissions":
+    case "danger-full-access":
+      return { approvalPolicy: "never", sandbox: "danger-full-access" };
+    case "safe-yolo":
+    case "acceptEdits":
+      return { approvalPolicy: "on-failure", sandbox: "workspace-write" };
+    case "read-only":
+    case "plan":
+      return { approvalPolicy: "on-request", sandbox: "read-only" };
+    case "default":
+    default:
+      return { approvalPolicy: "on-request", sandbox: "workspace-write" };
+  }
+}
+const CODEX_PROVIDER_KEY_ENV = "SVAMP_CODEX_API_KEY";
+const PROVIDER_NAME = "svamp";
+function resolveCodexProvider(env = process.env) {
+  return {
+    apiBase: env.SVAMP_CODEX_API_BASE || env.LLM_API_BASE || void 0,
+    apiKey: env.SVAMP_CODEX_API_KEY || env.LLM_API_KEY || void 0,
+    model: env.SVAMP_CODEX_MODEL || env.LLM_MODEL || void 0
+  };
+}
+function hasCustomProvider(cfg) {
+  return !!(cfg.apiBase && cfg.apiKey);
+}
+function buildCodexProviderArgs(cfg) {
+  if (!hasCustomProvider(cfg)) {
+    return { configArgs: cfg.model ? ["-c", `model=${JSON.stringify(cfg.model)}`] : [], env: {}, model: cfg.model };
+  }
+  const configArgs = [
+    "-c",
+    `model_provider=${JSON.stringify(PROVIDER_NAME)}`,
+    "-c",
+    `model_providers.${PROVIDER_NAME}.name=${JSON.stringify(PROVIDER_NAME)}`,
+    "-c",
+    `model_providers.${PROVIDER_NAME}.base_url=${JSON.stringify(cfg.apiBase)}`,
+    "-c",
+    `model_providers.${PROVIDER_NAME}.env_key=${JSON.stringify(CODEX_PROVIDER_KEY_ENV)}`,
+    "-c",
+    `model_providers.${PROVIDER_NAME}.wire_api=${JSON.stringify("responses")}`
+  ];
+  if (cfg.model) configArgs.push("-c", `model=${JSON.stringify(cfg.model)}`);
+  return { configArgs, env: { [CODEX_PROVIDER_KEY_ENV]: cfg.apiKey }, model: cfg.model };
+}
+
+var codexProvider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    CODEX_PROVIDER_KEY_ENV: CODEX_PROVIDER_KEY_ENV,
+    buildCodexProviderArgs: buildCodexProviderArgs,
+    codexPermissionSettings: codexPermissionSettings,
+    hasCustomProvider: hasCustomProvider,
+    resolveCodexProvider: resolveCodexProvider
+});
+
+const METHODS_BY_VENDOR = {
+  anthropic: ["anthropic-api-key", "claude-oauth-token", "hypha-proxy", "anthropic-gateway"],
+  openai: ["openai-api-key", "chatgpt-oauth", "openai-gateway"]
+};
+function accountsFilePath(svampHome) {
+  const home = svampHome || process.env.SVAMP_HOME || join(homedir(), ".svamp");
+  return join(home, "accounts.json");
+}
+function accountCodexHomeDir(accountId, svampHome) {
+  const home = svampHome || process.env.SVAMP_HOME || join(homedir(), ".svamp");
+  return join(home, "codex-accounts", accountId);
+}
+function loadAccounts(svampHome) {
+  const file = accountsFilePath(svampHome);
+  if (!existsSync(file)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf-8"));
+    if (!parsed || !Array.isArray(parsed.accounts)) return [];
+    return parsed.accounts;
+  } catch {
+    return [];
+  }
+}
+function saveAccounts(accounts, svampHome) {
+  const file = accountsFilePath(svampHome);
+  const dir = join(file, "..");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const payload = { version: 1, accounts };
+  writeFileSync(file, JSON.stringify(payload, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  try {
+    chmodSync(file, 384);
+  } catch {
+  }
+}
+function previewSecret(secret) {
+  if (!secret) return void 0;
+  if (secret.length <= 8) return "\u2022\u2022\u2022\u2022";
+  return `${secret.slice(0, 4)}\u2026${secret.slice(-4)}`;
+}
+function redactAccount(a) {
+  const { secret, ...rest } = a;
+  return { ...rest, secretPreview: previewSecret(secret) };
+}
+function redactAccounts(accounts) {
+  return accounts.map(redactAccount);
+}
+function defaultAccountIds(accounts) {
+  const out = { anthropic: null, openai: null };
+  for (const a of accounts) {
+    if (a.isDefault) out[a.vendor] = a.id;
+  }
+  return out;
+}
+function validateAccountInput(input) {
+  const vendor = input.vendor;
+  const method = input.method;
+  if (vendor !== "anthropic" && vendor !== "openai") {
+    throw new Error(`Invalid account vendor: ${String(vendor)}`);
+  }
+  if (!method || !METHODS_BY_VENDOR[vendor].includes(method)) {
+    throw new Error(`Invalid method "${String(method)}" for vendor "${vendor}"`);
+  }
+  if (!input.label || !input.label.trim()) {
+    throw new Error("Account label is required");
+  }
+  const needsSecret = method !== "hypha-proxy";
+  if (needsSecret && !input.secret && !input.id) {
+    throw new Error(`A credential is required for method "${method}"`);
+  }
+  if ((method === "anthropic-gateway" || method === "openai-gateway") && !input.baseUrl) {
+    throw new Error(`A base URL is required for a custom gateway`);
+  }
+  return { vendor, method };
+}
+function upsertAccount(input, svampHome) {
+  const { vendor, method } = validateAccountInput(input);
+  const accounts = loadAccounts(svampHome);
+  const now = Date.now();
+  const existing = input.id ? accounts.find((a) => a.id === input.id) : void 0;
+  const account = {
+    id: existing?.id || input.id || randomUUID(),
+    label: input.label.trim(),
+    vendor,
+    method,
+    // Keep the old secret if the update left it blank (edit label/model without re-entry).
+    secret: input.secret && input.secret.length > 0 ? input.secret : existing?.secret,
+    baseUrl: input.baseUrl?.trim() || void 0,
+    model: input.model?.trim() || void 0,
+    isDefault: input.isDefault ?? existing?.isDefault ?? false,
+    createdBy: existing?.createdBy || input.createdBy,
+    createdAt: existing?.createdAt || now,
+    updatedAt: now
+  };
+  let next = accounts.filter((a) => a.id !== account.id);
+  if (account.isDefault) {
+    next = next.map((a) => a.vendor === vendor ? { ...a, isDefault: false } : a);
+  }
+  if (!next.some((a) => a.vendor === vendor && a.isDefault) && !account.isDefault) {
+    account.isDefault = true;
+  }
+  next.push(account);
+  saveAccounts(next, svampHome);
+  return account;
+}
+function deleteAccount(id, svampHome) {
+  const accounts = loadAccounts(svampHome);
+  const removed = accounts.find((a) => a.id === id);
+  let next = accounts.filter((a) => a.id !== id);
+  if (removed?.isDefault) {
+    const idx = next.findIndex((a) => a.vendor === removed.vendor);
+    if (idx >= 0) next[idx] = { ...next[idx], isDefault: true };
+  }
+  saveAccounts(next, svampHome);
+}
+function setDefaultAccount(vendor, id, svampHome) {
+  const accounts = loadAccounts(svampHome);
+  if (!accounts.some((a) => a.id === id && a.vendor === vendor)) {
+    throw new Error(`No ${vendor} account with id ${id}`);
+  }
+  const next = accounts.map(
+    (a) => a.vendor === vendor ? { ...a, isDefault: a.id === id, updatedAt: Date.now() } : a
+  );
+  saveAccounts(next, svampHome);
+}
+function getAccount(id, svampHome) {
+  return loadAccounts(svampHome).find((a) => a.id === id);
+}
+function stripV1(url) {
+  const trimmed = url.trim().replace(/\/+$/, "");
+  if (trimmed.endsWith("/v1")) {
+    throw new Error("Base URL must not end in /v1 \u2014 the SDK appends it (double /v1/v1)");
+  }
+  return trimmed;
+}
+function resolveAccountEnv(account, env = process.env, svampHome) {
+  switch (account.method) {
+    case "anthropic-api-key":
+      return {
+        vendor: "anthropic",
+        claudeEnv: {
+          ANTHROPIC_API_KEY: account.secret,
+          ANTHROPIC_BASE_URL: account.baseUrl ? stripV1(account.baseUrl) : void 0,
+          CLAUDE_CODE_OAUTH_TOKEN: void 0
+        },
+        describe: `anthropic API key (${account.label})`
+      };
+    case "anthropic-gateway": {
+      const url = stripV1(account.baseUrl || "");
+      return {
+        vendor: "anthropic",
+        claudeEnv: {
+          ANTHROPIC_BASE_URL: url,
+          ANTHROPIC_API_KEY: account.secret,
+          CLAUDE_CODE_OAUTH_TOKEN: void 0
+        },
+        describe: `anthropic gateway ${url} (${account.label})`
+      };
+    }
+    case "hypha-proxy": {
+      const url = account.baseUrl ? stripV1(account.baseUrl) : resolveHyphaProxyUrl();
+      const token = env.HYPHA_TOKEN;
+      if (!url) throw new Error("hypha-proxy account has no URL (set SVAMP_HYPHA_PROXY_URL or an account base URL)");
+      if (!token) throw new Error("hypha-proxy account requires HYPHA_TOKEN on the machine");
+      return {
+        vendor: "anthropic",
+        claudeEnv: {
+          ANTHROPIC_BASE_URL: url,
+          ANTHROPIC_API_KEY: token,
+          CLAUDE_CODE_OAUTH_TOKEN: void 0,
+          // #0203: subscription backend qualifies for the free 1h prompt-cache TTL.
+          ENABLE_PROMPT_CACHING_1H: env.FORCE_PROMPT_CACHING_5M ? void 0 : "1"
+        },
+        describe: `hypha proxy ${url} (${account.label})`
+      };
+    }
+    case "claude-oauth-token":
+      return {
+        vendor: "anthropic",
+        claudeEnv: {
+          CLAUDE_CODE_OAUTH_TOKEN: account.secret,
+          ANTHROPIC_BASE_URL: void 0,
+          ANTHROPIC_API_KEY: void 0
+        },
+        describe: `claude subscription token (${account.label})`
+      };
+    case "openai-api-key":
+      return {
+        vendor: "openai",
+        codexProvider: { model: account.model },
+        extraEnv: { OPENAI_API_KEY: account.secret || "" },
+        describe: `openai API key (${account.label})`
+      };
+    case "openai-gateway": {
+      const url = stripV1(account.baseUrl || "");
+      const provider = { apiBase: url, apiKey: account.secret, model: account.model };
+      return {
+        vendor: "openai",
+        codexProvider: provider,
+        extraEnv: { [CODEX_PROVIDER_KEY_ENV]: account.secret || "" },
+        describe: `openai gateway ${url} (${account.label})`
+      };
+    }
+    case "chatgpt-oauth": {
+      const codexHome = accountCodexHomeDir(account.id, svampHome);
+      return {
+        vendor: "openai",
+        codexProvider: { model: account.model },
+        codexHome,
+        extraEnv: { CODEX_HOME: codexHome },
+        describe: `chatgpt subscription (${account.label})`
+      };
+    }
+    default:
+      throw new Error(`Unknown account method: ${account.method}`);
+  }
+}
+function ensureCodexHome(account, svampHome) {
+  const dir = accountCodexHomeDir(account.id, svampHome);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const authPath = join(dir, "auth.json");
+  const body = JSON.stringify({ OPENAI_API_KEY: null, tokens: { access_token: account.secret || "" } }, null, 2);
+  writeFileSync(authPath, body + "\n", { encoding: "utf-8", mode: 384 });
+  try {
+    chmodSync(authPath, 384);
+  } catch {
+  }
+  return dir;
+}
+async function probeAccount(account, env = process.env) {
+  let resolved;
+  try {
+    resolved = resolveAccountEnv(account, env);
+  } catch (e) {
+    return { ok: false, detail: `Misconfigured: ${e?.message || e}` };
+  }
+  const withTimeout = async (url, init) => {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), 8e3);
+    try {
+      return await fetch(url, { ...init, signal: ctrl.signal });
+    } finally {
+      clearTimeout(t);
+    }
+  };
+  try {
+    switch (account.method) {
+      case "anthropic-api-key":
+      case "anthropic-gateway":
+      case "hypha-proxy": {
+        const base = resolved.claudeEnv?.ANTHROPIC_BASE_URL || "https://api.anthropic.com";
+        const key = resolved.claudeEnv?.ANTHROPIC_API_KEY;
+        if (!key) return { ok: false, detail: "No credential resolved" };
+        const res = await withTimeout(`${base}/v1/messages`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            "x-api-key": key,
+            "authorization": `Bearer ${key}`,
+            "anthropic-version": "2023-06-01"
+          },
+          body: JSON.stringify({ model: "claude-3-5-haiku-20241022", max_tokens: 1, messages: [{ role: "user", content: "hi" }] })
+        });
+        if (res.status === 401 || res.status === 403) return { ok: false, detail: `Auth rejected (HTTP ${res.status})` };
+        if (res.ok || res.status === 400 || res.status === 429) return { ok: true, detail: `Reachable (HTTP ${res.status})` };
+        return { ok: true, detail: `Reachable, unexpected HTTP ${res.status}` };
+      }
+      case "openai-api-key":
+      case "openai-gateway": {
+        const base = account.method === "openai-gateway" ? stripV1(account.baseUrl || "") : "https://api.openai.com/v1";
+        const key = account.secret || "";
+        if (!key) return { ok: false, detail: "No credential resolved" };
+        const res = await withTimeout(`${base}/models`, { headers: { authorization: `Bearer ${key}` } });
+        if (res.status === 401 || res.status === 403) return { ok: false, detail: `Auth rejected (HTTP ${res.status})` };
+        if (res.ok || res.status === 400 || res.status === 429) return { ok: true, detail: `Reachable (HTTP ${res.status})` };
+        return { ok: true, detail: `Reachable, unexpected HTTP ${res.status}` };
+      }
+      case "claude-oauth-token":
+        return { ok: !!account.secret, detail: account.secret ? "Token stored \u2014 verified when a session starts (Claude CLI uses CLAUDE_CODE_OAUTH_TOKEN)" : "No token stored" };
+      case "chatgpt-oauth":
+        return { ok: !!account.secret, detail: account.secret ? "Token stored \u2014 verified when a Codex session starts (per-account CODEX_HOME)" : "No token stored" };
+      default:
+        return { ok: false, detail: "Unknown method" };
+    }
+  } catch (e) {
+    return { ok: false, detail: `Unreachable: ${e?.message || e}` };
+  }
+}
+
 const FIELD_RANGES = [[0, 59], [0, 23], [1, 31], [1, 12], [0, 6]];
 function parseField(token, [min, max]) {
   const set = /* @__PURE__ */ new Set();
@@ -2600,6 +3141,43 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         });
         return { success: true };
       },
+      // ── Backend Accounts (per-machine credentials; admin-gated) ──
+      // Secrets live on the machine (~/.svamp/accounts.json, 0600) and are NEVER returned —
+      // only redacted previews. The composer sends an opaque accountId; the daemon resolves it
+      // to concrete auth at spawn (daemon/backendAccounts.ts). See docs/sharing-and-security.md.
+      listBackendAccounts: async (context) => {
+        authorizeRequest(context, currentMetadata.sharing, "admin");
+        const accounts = loadAccounts(metadata.svampHomeDir);
+        return {
+          accounts: redactAccounts(accounts),
+          defaults: defaultAccountIds(accounts)
+        };
+      },
+      setBackendAccount: async (account, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "admin");
+        const createdBy = context?.user?.email;
+        const saved = upsertAccount({ ...account, createdBy: account.createdBy || createdBy }, metadata.svampHomeDir);
+        notifyListeners({ type: "update-machine", machineId, backendAccountsChanged: true });
+        return { success: true, account: redactAccount(saved) };
+      },
+      deleteBackendAccount: async (id, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "admin");
+        deleteAccount(id, metadata.svampHomeDir);
+        notifyListeners({ type: "update-machine", machineId, backendAccountsChanged: true });
+        return { success: true };
+      },
+      setDefaultBackendAccount: async (vendor, id, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "admin");
+        setDefaultAccount(vendor, id, metadata.svampHomeDir);
+        notifyListeners({ type: "update-machine", machineId, backendAccountsChanged: true });
+        return { success: true };
+      },
+      testBackendAccount: async (id, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "admin");
+        const acct = getAccount(id, metadata.svampHomeDir);
+        if (!acct) return { ok: false, detail: "Account not found" };
+        return await probeAccount(acct);
+      },
       // Register a listener for real-time updates (app calls this with _rintf callback)
       registerListener: async (callback, context) => {
         trackInbound();
@@ -3041,7 +3619,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         const tunnels = handlers.tunnels;
         if (!tunnels) throw new Error("Tunnel management not available");
         if (tunnels.has(params.name)) throw new Error(`Tunnel '${params.name}' already running`);
-        const { FrpcTunnel } = await import('./frpc-DmaWRu0M.mjs');
+        const { FrpcTunnel } = await import('./frpc-Cwn_s0Fs.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -3508,7 +4086,7 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
           }
           const deps = buildSessionDeps(rpc, { cwd, ownerEmail: owner });
           const sender = { name: context?.user?.email || context?.user?.id || "user", kind: "user", verified: true };
-          const { toolsForRole } = await import('./sideband-CIJUNKUA.mjs');
+          const { toolsForRole } = await import('./sideband-DywLL2xs.mjs');
           const r2 = await runWiseAgent({ message: params.message, sender, config: { tools: toolsForRole(role2) }, deps, transport, model: resolved.model });
           return fmt(r2);
         }
@@ -3607,7 +4185,7 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
     if (r.error || !r.sender) return { error: r.error || "unauthorized" };
     const callId = "call_" + Math.random().toString(16).slice(2, 12);
     const rendered = renderMessage(c, { sender: r.sender, body: { message: kwargs.message }, callId });
-    const { queryCore } = await import('./commands-DuPRCS2G.mjs');
+    const { queryCore } = await import('./commands-C_74tXoO.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -3967,278 +4545,83 @@ function classifyInbound(message, now = Date.now(), opts) {
   if (isBreakerOpenAt(now)) {
     return { action: "queue", reason: "circuit-breaker-open" };
   }
-  if (!takeUrgentToken(senderKey(message), now)) {
-    return { action: "queue", reason: "rate-limited" };
-  }
-  const tripped = recordWake(now);
-  return { action: "wake", reason: "urgent", breakerTripped: tripped };
-}
-function applyInboxClear(inbox, opts) {
-  let kept;
-  if (opts?.messageId) kept = inbox.filter((m) => m.messageId !== opts.messageId);
-  else if (opts?.all) kept = [];
-  else kept = inbox.filter((m) => !m.read);
-  return { kept, removed: inbox.length - kept.length };
-}
-
-function inboxFilePath(projectDir, sessionId) {
-  return join(projectDir, ".svamp", sessionId, "inbox.json");
-}
-function loadInbox(projectDir, sessionId) {
-  try {
-    const p = inboxFilePath(projectDir, sessionId);
-    if (!existsSync(p)) return [];
-    const data = JSON.parse(readFileSync(p, "utf8"));
-    if (Array.isArray(data)) return data;
-    if (data && Array.isArray(data.messages)) return data.messages;
-    return [];
-  } catch {
-    return [];
-  }
-}
-function saveInbox(projectDir, sessionId, inbox) {
-  try {
-    const p = inboxFilePath(projectDir, sessionId);
-    mkdirSync(dirname(p), { recursive: true });
-    const tmp = `${p}.tmp-${process.pid}`;
-    writeFileSync(tmp, JSON.stringify(inbox));
-    renameSync(tmp, p);
-  } catch {
-  }
-}
-
-function envInt(name, fallback) {
-  const raw = process.env[name];
-  if (raw === void 0 || raw === "") return fallback;
-  const n = parseInt(raw, 10);
-  return Number.isFinite(n) && n >= 0 ? n : fallback;
-}
-function getRateLimitRetryConfig() {
-  return {
-    maxRetries: envInt("SVAMP_RATELIMIT_MAX_RETRIES", 200),
-    baseMs: envInt("SVAMP_RATELIMIT_BASE_MS", 5e3),
-    capMs: envInt("SVAMP_RATELIMIT_CAP_MS", 12e4)
-  };
-}
-function computeRetryDelayMs(attempt, cfg = getRateLimitRetryConfig(), rng = Math.random) {
-  const a = Math.max(0, Math.floor(attempt));
-  const expo = Math.min(a, 30);
-  const nominal = Math.min(cfg.capMs, cfg.baseMs * Math.pow(2, expo));
-  const half = nominal / 2;
-  return Math.round(half + rng() * half);
-}
-function isRetryableRateLimit(text, apiErrorStatus) {
-  const t = (text || "").toLowerCase();
-  const hardLimit = t.includes("quota") || // The Hypha LLM proxy emits a 429 "Daily spending limit reached … Resets
-  // at 00:00 UTC. Contact the admin to raise your limit." That is a hard cap
-  // that resets at a fixed time / needs human action — NOT a transient
-  // upstream throttle. Retrying it 10× just delays surfacing the real error.
-  t.includes("spending limit") || t.includes("credit") || t.includes("balance") || t.includes("billing") || t.includes("payment") || t.includes("subscription") || t.includes("1m-context") || t.includes("1m context") || t.includes("insufficient") || t.includes("usage limit") && !t.includes("not your usage limit");
-  if (hardLimit) return false;
-  const authIssue = apiErrorStatus === 401 || apiErrorStatus === 403 || t.includes("unauthorized") || t.includes("invalid api key") || t.includes("authentication") || t.includes("forbidden");
-  if (authIssue) return false;
-  const clientError = apiErrorStatus === 400 || apiErrorStatus === 404 || apiErrorStatus === 422 || t.includes("invalid_request") || t.includes("invalid request") || t.includes("bad request");
-  if (clientError) return false;
-  const serverTransient = typeof apiErrorStatus === "number" && apiErrorStatus >= 500 && apiErrorStatus <= 599 || apiErrorStatus === 429 || /\b(429|500|502|503|504|520|521|522|523|524|529)\b/.test(t) || t.includes("temporarily limiting") || t.includes("not your usage limit") || t.includes("overloaded") || t.includes("overload") || t.includes("too many requests") || t.includes("server is busy") || t.includes("internal server error") || t.includes("bad gateway") || t.includes("service unavailable") || t.includes("gateway timeout") || t.includes("rate limit") || t.includes("rate-limit") || t.includes("rate limited");
-  if (serverTransient) return true;
-  const networkTransient = t.includes("socket hang up") || t.includes("closed unexpectedly") || t.includes("connection closed") || t.includes("connection reset") || t.includes("connection error") || t.includes("econnreset") || t.includes("etimedout") || t.includes("econnaborted") || t.includes("epipe") || t.includes("enetunreach") || t.includes("enetreset") || t.includes("ehostunreach") || t.includes("eai_again") || t.includes("network error") || t.includes("fetch failed") || t.includes("request timed out") || t.includes("timed out");
-  return networkTransient;
-}
-
-const EXAMPLE_HYPHA_PROXY_URL = "https://proxy.hypha.aicell.io";
-const MODE_KEY = "SVAMP_CLAUDE_PROXY";
-const HYPHA_PROXY_URL_KEY = "SVAMP_HYPHA_PROXY_URL";
-const MANAGED_KEYS = /* @__PURE__ */ new Set([
-  MODE_KEY,
-  HYPHA_PROXY_URL_KEY,
-  "ANTHROPIC_BASE_URL",
-  "ANTHROPIC_API_KEY"
-]);
-function normalizeProxyUrl(raw) {
-  const trimmed = raw.trim().replace(/\/+$/, "");
-  if (trimmed.endsWith("/v1")) {
-    throw new Error(
-      "Hypha proxy URL must not end in /v1 \u2014 the SDK appends it, producing double /v1/v1/messages"
-    );
-  }
-  return trimmed;
-}
-function resolveHyphaProxyUrl() {
-  const configured = (process.env[HYPHA_PROXY_URL_KEY] || "").trim();
-  if (!configured) return void 0;
-  try {
-    return normalizeProxyUrl(configured);
-  } catch {
-    return void 0;
-  }
-}
-function envFilePath() {
-  const svampHome = process.env.SVAMP_HOME || join(homedir(), ".svamp");
-  return join(svampHome, ".env");
-}
-function readEnvLines() {
-  const file = envFilePath();
-  if (!existsSync(file)) return [];
-  return readFileSync(file, "utf-8").split("\n");
-}
-function writeEnvLines(lines) {
-  const file = envFilePath();
-  const dir = join(file, "..");
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
-    lines.pop();
-  }
-  writeFileSync(file, lines.join("\n") + "\n", "utf-8");
-}
-function updateEnvFile(updates) {
-  const lines = readEnvLines();
-  const kept = [];
-  const remainingUpdates = new Map(Object.entries(updates));
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) {
-      kept.push(line);
-      continue;
-    }
-    const eq = trimmed.indexOf("=");
-    const key = eq === -1 ? trimmed : trimmed.slice(0, eq);
-    if (remainingUpdates.has(key)) {
-      const v = remainingUpdates.get(key);
-      remainingUpdates.delete(key);
-      if (v === void 0) continue;
-      kept.push(`${key}=${v}`);
-      continue;
-    }
-    kept.push(line);
-  }
-  for (const [key, v] of remainingUpdates) {
-    if (v === void 0) continue;
-    kept.push(`${key}=${v}`);
-  }
-  writeEnvLines(kept);
+  if (!takeUrgentToken(senderKey(message), now)) {
+    return { action: "queue", reason: "rate-limited" };
+  }
+  const tripped = recordWake(now);
+  return { action: "wake", reason: "urgent", breakerTripped: tripped };
 }
-function currentMode() {
-  const raw = (process.env[MODE_KEY] || "").trim().toLowerCase();
-  if (raw === "hypha" || raw === "hypha-proxy") return "hypha";
-  if (raw === "custom") return "custom";
-  return "login";
+function applyInboxClear(inbox, opts) {
+  let kept;
+  if (opts?.messageId) kept = inbox.filter((m) => m.messageId !== opts.messageId);
+  else if (opts?.all) kept = [];
+  else kept = inbox.filter((m) => !m.read);
+  return { kept, removed: inbox.length - kept.length };
 }
-function redactKey(key) {
-  if (!key) return void 0;
-  if (key.length <= 12) return "***";
-  return `${key.slice(0, 8)}\u2026${key.slice(-4)}`;
+
+function inboxFilePath(projectDir, sessionId) {
+  return join(projectDir, ".svamp", sessionId, "inbox.json");
 }
-function getClaudeAuthStatus() {
-  const mode = currentMode();
-  if (mode === "hypha") {
-    const token = process.env.HYPHA_TOKEN;
-    const proxyUrl = resolveHyphaProxyUrl();
-    return {
-      mode,
-      baseUrl: proxyUrl,
-      apiKeyPreview: redactKey(token),
-      hyphaTokenMissing: !token,
-      hyphaProxyUrlMissing: !proxyUrl
-    };
-  }
-  if (mode === "custom") {
-    return {
-      mode,
-      baseUrl: process.env.ANTHROPIC_BASE_URL,
-      apiKeyPreview: redactKey(process.env.ANTHROPIC_API_KEY)
-    };
+function loadInbox(projectDir, sessionId) {
+  try {
+    const p = inboxFilePath(projectDir, sessionId);
+    if (!existsSync(p)) return [];
+    const data = JSON.parse(readFileSync(p, "utf8"));
+    if (Array.isArray(data)) return data;
+    if (data && Array.isArray(data.messages)) return data.messages;
+    return [];
+  } catch {
+    return [];
   }
-  return { mode: "login" };
 }
-function setClaudeAuthHyphaProxy(url) {
-  if (!url || !url.trim()) {
-    throw new Error(
-      `A Hypha proxy URL is required (no default). Example: svamp daemon auth use-hypha-proxy ${EXAMPLE_HYPHA_PROXY_URL}`
-    );
+function saveInbox(projectDir, sessionId, inbox) {
+  try {
+    const p = inboxFilePath(projectDir, sessionId);
+    mkdirSync(dirname(p), { recursive: true });
+    const tmp = `${p}.tmp-${process.pid}`;
+    writeFileSync(tmp, JSON.stringify(inbox));
+    renameSync(tmp, p);
+  } catch {
   }
-  updateEnvFile({
-    [MODE_KEY]: "hypha",
-    [HYPHA_PROXY_URL_KEY]: normalizeProxyUrl(url),
-    // Hypha mode resolves token live at spawn — no stored copy.
-    ANTHROPIC_BASE_URL: void 0,
-    ANTHROPIC_API_KEY: void 0
-  });
 }
-function setClaudeAuthLogin() {
-  updateEnvFile({
-    [MODE_KEY]: void 0,
-    [HYPHA_PROXY_URL_KEY]: void 0,
-    ANTHROPIC_BASE_URL: void 0,
-    ANTHROPIC_API_KEY: void 0
-  });
+
+function envInt(name, fallback) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw === "") return fallback;
+  const n = parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 0 ? n : fallback;
 }
-function setClaudeAuthCustom(baseUrl, apiKey) {
-  if (!baseUrl) throw new Error("ANTHROPIC_BASE_URL is required for custom mode");
-  if (!apiKey) throw new Error("ANTHROPIC_API_KEY is required for custom mode");
-  const trimmed = baseUrl.replace(/\/+$/, "");
-  if (trimmed.endsWith("/v1")) {
-    throw new Error(
-      "ANTHROPIC_BASE_URL must not end in /v1 \u2014 the SDK appends it, producing double /v1/v1/messages"
-    );
-  }
-  updateEnvFile({
-    [MODE_KEY]: "custom",
-    [HYPHA_PROXY_URL_KEY]: void 0,
-    ANTHROPIC_BASE_URL: trimmed,
-    ANTHROPIC_API_KEY: apiKey
-  });
+function getRateLimitRetryConfig() {
+  return {
+    maxRetries: envInt("SVAMP_RATELIMIT_MAX_RETRIES", 200),
+    baseMs: envInt("SVAMP_RATELIMIT_BASE_MS", 5e3),
+    capMs: envInt("SVAMP_RATELIMIT_CAP_MS", 12e4)
+  };
 }
-function applyClaudeProxyEnv(spawnEnv) {
-  const mode = currentMode();
-  if (mode === "hypha") {
-    const proxyUrl = resolveHyphaProxyUrl();
-    if (!proxyUrl) {
-      delete spawnEnv.ANTHROPIC_BASE_URL;
-      delete spawnEnv.ANTHROPIC_API_KEY;
-      return `hypha mode but ${HYPHA_PROXY_URL_KEY} not configured \u2014 run \`svamp daemon auth use-hypha-proxy <URL>\`; falling back to login`;
-    }
-    const token = process.env.HYPHA_TOKEN;
-    if (!token) {
-      delete spawnEnv.ANTHROPIC_BASE_URL;
-      delete spawnEnv.ANTHROPIC_API_KEY;
-      return "hypha mode but HYPHA_TOKEN missing \u2014 falling back to login";
-    }
-    spawnEnv.ANTHROPIC_BASE_URL = proxyUrl;
-    spawnEnv.ANTHROPIC_API_KEY = token;
-    const cacheOverride = spawnEnv.ENABLE_PROMPT_CACHING_1H ?? process.env.ENABLE_PROMPT_CACHING_1H ?? spawnEnv.FORCE_PROMPT_CACHING_5M ?? process.env.FORCE_PROMPT_CACHING_5M;
-    if (cacheOverride === void 0) spawnEnv.ENABLE_PROMPT_CACHING_1H = "1";
-    return `hypha proxy (${proxyUrl}, 1h cache TTL)`;
-  }
-  if (mode === "custom") {
-    const url = process.env.ANTHROPIC_BASE_URL;
-    const key = process.env.ANTHROPIC_API_KEY;
-    if (!url || !key) {
-      delete spawnEnv.ANTHROPIC_BASE_URL;
-      delete spawnEnv.ANTHROPIC_API_KEY;
-      return "custom mode but ANTHROPIC_BASE_URL/API_KEY missing \u2014 falling back to login";
-    }
-    spawnEnv.ANTHROPIC_BASE_URL = url;
-    spawnEnv.ANTHROPIC_API_KEY = key;
-    return `custom proxy (${url})`;
-  }
-  delete spawnEnv.ANTHROPIC_BASE_URL;
-  delete spawnEnv.ANTHROPIC_API_KEY;
-  return null;
+function computeRetryDelayMs(attempt, cfg = getRateLimitRetryConfig(), rng = Math.random) {
+  const a = Math.max(0, Math.floor(attempt));
+  const expo = Math.min(a, 30);
+  const nominal = Math.min(cfg.capMs, cfg.baseMs * Math.pow(2, expo));
+  const half = nominal / 2;
+  return Math.round(half + rng() * half);
+}
+function isRetryableRateLimit(text, apiErrorStatus) {
+  const t = (text || "").toLowerCase();
+  const hardLimit = t.includes("quota") || // The Hypha LLM proxy emits a 429 "Daily spending limit reached … Resets
+  // at 00:00 UTC. Contact the admin to raise your limit." That is a hard cap
+  // that resets at a fixed time / needs human action — NOT a transient
+  // upstream throttle. Retrying it 10× just delays surfacing the real error.
+  t.includes("spending limit") || t.includes("credit") || t.includes("balance") || t.includes("billing") || t.includes("payment") || t.includes("subscription") || t.includes("1m-context") || t.includes("1m context") || t.includes("insufficient") || t.includes("usage limit") && !t.includes("not your usage limit");
+  if (hardLimit) return false;
+  const authIssue = apiErrorStatus === 401 || apiErrorStatus === 403 || t.includes("unauthorized") || t.includes("invalid api key") || t.includes("authentication") || t.includes("forbidden");
+  if (authIssue) return false;
+  const clientError = apiErrorStatus === 400 || apiErrorStatus === 404 || apiErrorStatus === 422 || t.includes("invalid_request") || t.includes("invalid request") || t.includes("bad request");
+  if (clientError) return false;
+  const serverTransient = typeof apiErrorStatus === "number" && apiErrorStatus >= 500 && apiErrorStatus <= 599 || apiErrorStatus === 429 || /\b(429|500|502|503|504|520|521|522|523|524|529)\b/.test(t) || t.includes("temporarily limiting") || t.includes("not your usage limit") || t.includes("overloaded") || t.includes("overload") || t.includes("too many requests") || t.includes("server is busy") || t.includes("internal server error") || t.includes("bad gateway") || t.includes("service unavailable") || t.includes("gateway timeout") || t.includes("rate limit") || t.includes("rate-limit") || t.includes("rate limited");
+  if (serverTransient) return true;
+  const networkTransient = t.includes("socket hang up") || t.includes("closed unexpectedly") || t.includes("connection closed") || t.includes("connection reset") || t.includes("connection error") || t.includes("econnreset") || t.includes("etimedout") || t.includes("econnaborted") || t.includes("epipe") || t.includes("enetunreach") || t.includes("enetreset") || t.includes("ehostunreach") || t.includes("eai_again") || t.includes("network error") || t.includes("fetch failed") || t.includes("request timed out") || t.includes("timed out");
+  return networkTransient;
 }
-const MANAGED_ENV_KEYS = Array.from(MANAGED_KEYS);
-
-var claudeAuth = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    EXAMPLE_HYPHA_PROXY_URL: EXAMPLE_HYPHA_PROXY_URL,
-    MANAGED_ENV_KEYS: MANAGED_ENV_KEYS,
-    applyClaudeProxyEnv: applyClaudeProxyEnv,
-    getClaudeAuthStatus: getClaudeAuthStatus,
-    resolveHyphaProxyUrl: resolveHyphaProxyUrl,
-    setClaudeAuthCustom: setClaudeAuthCustom,
-    setClaudeAuthHyphaProxy: setClaudeAuthHyphaProxy,
-    setClaudeAuthLogin: setClaudeAuthLogin,
-    updateEnvFile: updateEnvFile
-});
 
 const PARTICIPANTS_CHANNEL_ID = "sys-participants";
 function channelPublicView(c) {
@@ -8720,64 +9103,6 @@ function mapDecisionToWire(d) {
   }
 }
 
-function codexPermissionSettings(mode) {
-  switch (mode) {
-    case "yolo":
-    case "bypassPermissions":
-    case "danger-full-access":
-      return { approvalPolicy: "never", sandbox: "danger-full-access" };
-    case "safe-yolo":
-    case "acceptEdits":
-      return { approvalPolicy: "on-failure", sandbox: "workspace-write" };
-    case "read-only":
-    case "plan":
-      return { approvalPolicy: "on-request", sandbox: "read-only" };
-    case "default":
-    default:
-      return { approvalPolicy: "on-request", sandbox: "workspace-write" };
-  }
-}
-const CODEX_PROVIDER_KEY_ENV = "SVAMP_CODEX_API_KEY";
-const PROVIDER_NAME = "svamp";
-function resolveCodexProvider(env = process.env) {
-  return {
-    apiBase: env.SVAMP_CODEX_API_BASE || env.LLM_API_BASE || void 0,
-    apiKey: env.SVAMP_CODEX_API_KEY || env.LLM_API_KEY || void 0,
-    model: env.SVAMP_CODEX_MODEL || env.LLM_MODEL || void 0
-  };
-}
-function hasCustomProvider(cfg) {
-  return !!(cfg.apiBase && cfg.apiKey);
-}
-function buildCodexProviderArgs(cfg) {
-  if (!hasCustomProvider(cfg)) {
-    return { configArgs: cfg.model ? ["-c", `model=${JSON.stringify(cfg.model)}`] : [], env: {}, model: cfg.model };
-  }
-  const configArgs = [
-    "-c",
-    `model_provider=${JSON.stringify(PROVIDER_NAME)}`,
-    "-c",
-    `model_providers.${PROVIDER_NAME}.name=${JSON.stringify(PROVIDER_NAME)}`,
-    "-c",
-    `model_providers.${PROVIDER_NAME}.base_url=${JSON.stringify(cfg.apiBase)}`,
-    "-c",
-    `model_providers.${PROVIDER_NAME}.env_key=${JSON.stringify(CODEX_PROVIDER_KEY_ENV)}`,
-    "-c",
-    `model_providers.${PROVIDER_NAME}.wire_api=${JSON.stringify("responses")}`
-  ];
-  if (cfg.model) configArgs.push("-c", `model=${JSON.stringify(cfg.model)}`);
-  return { configArgs, env: { [CODEX_PROVIDER_KEY_ENV]: cfg.apiKey }, model: cfg.model };
-}
-
-var codexProvider = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    CODEX_PROVIDER_KEY_ENV: CODEX_PROVIDER_KEY_ENV,
-    buildCodexProviderArgs: buildCodexProviderArgs,
-    codexPermissionSettings: codexPermissionSettings,
-    hasCustomProvider: hasCustomProvider,
-    resolveCodexProvider: resolveCodexProvider
-});
-
 class CodexAppServerBackend {
   constructor(opts) {
     this.opts = opts;
@@ -13940,7 +14265,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-BZPDL-1B.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-CKd1jXfX.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const entries = Array.from(urls.entries());
@@ -13958,7 +14283,7 @@ async function startDaemon(options) {
     }
   }
   async function createExposedTunnel(spec) {
-    const { FrpcTunnel } = await import('./frpc-DmaWRu0M.mjs');
+    const { FrpcTunnel } = await import('./frpc-Cwn_s0Fs.mjs');
     const tunnel = new FrpcTunnel({
       name: spec.name,
       ports: spec.ports,
@@ -13979,7 +14304,7 @@ async function startDaemon(options) {
   }
   const tunnelRecreateState = /* @__PURE__ */ new Map();
   const tunnelRecreateInFlight = /* @__PURE__ */ new Set();
-  const { ServeManager } = await import('./serveManager-a_dIQuK4.mjs');
+  const { ServeManager } = await import('./serveManager-Dy1ZZNaY.mjs');
   const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   ensureAutoInstalledSkills(logger).catch(() => {
   });
@@ -14416,7 +14741,10 @@ ${v.guidance ? v.guidance + "\n" : ""}Criteria: ${v.criteria || "(none)"}
           ...sessionMetadata,
           // Derive the handle name from the id (new-format ids embed it) so the two
           // never diverge; fall back to persisted name (legacy ids) then a fresh one.
-          friendlyName: persisted?.metadata?.friendlyName || friendlyNameFromId(sessionId) || generateFriendlyName(collectKnownFriendlyNames())
+          friendlyName: persisted?.metadata?.friendlyName || friendlyNameFromId(sessionId) || generateFriendlyName(collectKnownFriendlyNames()),
+          // Selected backend account (composer). Sticky across respawns + restart via the
+          // persisted metadata; the daemon resolves it to concrete auth at each Claude spawn.
+          accountId: options2.accountId ?? persisted?.metadata?.accountId ?? void 0
         };
         let currentPermissionMode = options2.permissionMode || persisted?.permissionMode || "bypassPermissions";
         const sessionCreatedAt = persisted?.createdAt || Date.now();
@@ -14916,6 +15244,28 @@ ${parts.join("\n")}`);
           if (proxyDesc) {
             logger.log(`[Session ${sessionId}] Claude auth: ${proxyDesc}`);
           }
+          {
+            const acctId = sessionMetadata.accountId;
+            if (acctId) {
+              try {
+                const acct = getAccount(acctId, SVAMP_HOME);
+                if (!acct) {
+                  logger.log(`[Session ${sessionId}] account ${acctId} not found \u2014 using machine default`);
+                } else if (acct.vendor !== "anthropic") {
+                  logger.log(`[Session ${sessionId}] account ${acctId} is a ${acct.vendor} account, not usable for Claude \u2014 using machine default`);
+                } else {
+                  const resolved = resolveAccountEnv(acct, process.env, SVAMP_HOME);
+                  for (const [k, v] of Object.entries(resolved.claudeEnv || {})) {
+                    if (v === void 0) delete spawnEnv[k];
+                    else spawnEnv[k] = v;
+                  }
+                  logger.log(`[Session ${sessionId}] Claude auth (account): ${resolved.describe}`);
+                }
+              } catch (e) {
+                logger.log(`[Session ${sessionId}] account ${acctId} resolve failed (${e?.message || e}) \u2014 using machine default`);
+              }
+            }
+          }
           if (isoConfig && stagedCredentials) {
             Object.assign(spawnEnv, stagedCredentials.env);
             const filtered = {};
@@ -16101,11 +16451,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-DswYjrCh.mjs');
+              const { issueRpc } = await import('./rpc-BnHMvDxQ.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-Db3BR76v.mjs');
+              const { workflowRpc } = await import('./rpc-DwlZTOtK.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -16396,7 +16746,9 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
           sharing: options2.sharing,
           securityContext: options2.securityContext,
           tags: options2.tags,
-          parentSessionId: options2.parentSessionId
+          parentSessionId: options2.parentSessionId,
+          // Selected backend account — sticky across restart via persisted metadata.
+          accountId: options2.accountId ?? acpPersisted?.metadata?.accountId ?? void 0
         };
         let currentPermissionMode = options2.permissionMode || "bypassPermissions";
         const allowedTools = /* @__PURE__ */ new Set();
@@ -16663,11 +17015,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-DswYjrCh.mjs');
+              const { issueRpc } = await import('./rpc-BnHMvDxQ.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-Db3BR76v.mjs');
+              const { workflowRpc } = await import('./rpc-DwlZTOtK.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -16818,16 +17170,41 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
           const avail = codexAppServerAvailable();
           if (avail === null) throw new Error("Codex CLI not found \u2014 install it (`npm i -g @openai/codex`) and authenticate (`svamp daemon codex-auth`).");
           if (avail === false) throw new Error("Installed Codex is too old for app-server \u2014 upgrade to >= 0.100 (`npm i -g @openai/codex@latest`).");
-          const provider = resolveCodexProvider();
+          let provider = resolveCodexProvider();
+          let accountCodexEnv;
+          let accountDesc;
+          {
+            const acctId = sessionMetadata.accountId;
+            if (acctId) {
+              try {
+                const acct = getAccount(acctId, SVAMP_HOME);
+                if (!acct) {
+                  logger.log(`[Agent Session ${sessionId}] account ${acctId} not found \u2014 using machine default`);
+                } else if (acct.vendor !== "openai") {
+                  logger.log(`[Agent Session ${sessionId}] account ${acctId} is a ${acct.vendor} account, not usable for Codex \u2014 using machine default`);
+                } else {
+                  const resolved = resolveAccountEnv(acct, process.env, SVAMP_HOME);
+                  if (resolved.codexHome) ensureCodexHome(acct, SVAMP_HOME);
+                  provider = resolved.codexProvider || {};
+                  accountCodexEnv = resolved.extraEnv;
+                  accountDesc = resolved.describe;
+                }
+              } catch (e) {
+                logger.log(`[Agent Session ${sessionId}] account ${acctId} resolve failed (${e?.message || e}) \u2014 using machine default`);
+              }
+            }
+          }
           const codexModel = options2.model || agentConfig?.default_model || provider.model || void 0;
           const codexPerm = codexPermissionSettings(currentPermissionMode);
-          logger.log(`[Agent Session ${sessionId}] Codex backend: app-server (model=${codexModel ?? "default"}${provider.apiBase ? `, provider=${provider.apiBase}` : ""}, mode=${currentPermissionMode} \u2192 approval=${codexPerm.approvalPolicy}/sandbox=${codexPerm.sandbox})`);
+          logger.log(`[Agent Session ${sessionId}] Codex backend: app-server (model=${codexModel ?? "default"}${provider.apiBase ? `, provider=${provider.apiBase}` : ""}${accountDesc ? `, account=${accountDesc}` : ""}, mode=${currentPermissionMode} \u2192 approval=${codexPerm.approvalPolicy}/sandbox=${codexPerm.sandbox})`);
           if (acpResumeThreadId) logger.log(`[Agent Session ${sessionId}] Resuming Codex thread ${acpResumeThreadId} (restart recovery)`);
           agentBackend = new CodexAppServerBackend({
             cwd: directory,
             model: codexModel,
             provider,
-            env: options2.environmentVariables,
+            // Account extra env (OPENAI_API_KEY / SVAMP_CODEX_API_KEY / CODEX_HOME) layered
+            // over any per-session environmentVariables from the composer.
+            env: { ...options2.environmentVariables || {}, ...accountCodexEnv || {} },
             log: logger.log,
             isolationConfig: agentIsoConfig,
             approvalPolicy: codexPerm.approvalPolicy,
@@ -17678,7 +18055,7 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
     const PING_TIMEOUT_MS = 15e3;
     const POST_RECONNECT_GRACE_MS = 2e4;
     const RECONNECT_JITTER_MS = 2500;
-    const { WorkflowScheduler } = await import('./scheduler-DhKDP3hC.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-BxijQDI8.mjs');
     const workflowScheduler = new WorkflowScheduler({
       projectRoots: () => {
         const dirs = /* @__PURE__ */ new Set();
@@ -18289,4 +18666,4 @@ var run = /*#__PURE__*/Object.freeze({
     writeStopMarker: writeStopMarker
 });
 
-export { resolveModel as $, runWorkflow as A, setWorkflowEnabled as B, removeWorkflow as C, saveWorkflow as D, rawWorkflow as E, listWorkflows as F, isWorkflowEnabled as G, workflowCrons as H, cronMatches as I, summarize as J, workflowSteps as K, loadMachineContext as L, buildMachineInstructions as M, machineToolsForRole as N, buildMachineTools as O, parseFrontmatter as P, getSkillsServer as Q, READ_ONLY_TOOLS as R, ServeAuth as S, getSkillsWorkspaceName as T, getSkillsCollectionName as U, fetchWithTimeout as V, searchSkills as W, SKILLS_DIR as X, getSkillInfo as Y, downloadSkillFile as Z, listSkillFiles as _, createSessionStore as a, clearStopMarker as a0, stopMarkerExists as a1, formatHandle as a2, normalizeAllowedUser as a3, loadSecurityContextConfig as a4, resolveSecurityContext as a5, buildSecurityContextFromFlags as a6, mergeSecurityContexts as a7, buildSessionShareUrl as a8, computeOutboundHop as a9, registerAwaitingReply as aa, buildMachineShareUrl as ab, parseHandle as ac, handleMatchesMetadata as ad, describeMisconfiguration as ae, buildMachineDeps as af, applyClaudeProxyEnv as ag, composeSessionId as ah, generateFriendlyName as ai, generateHookSettings as aj, claudeAuth as ak, projectInfo as al, DefaultTransport$1 as am, acpBackend as an, acpAgentConfig as ao, codexProvider as ap, codexAppServerBackend as aq, GeminiTransport$1 as ar, instanceConfig as as, api as at, run as au, stopDaemon as b, connectToHypha as c, daemonStatus as d, getFrpsSubdomainHost as e, getFrpsServerPort as f, getHyphaServerUrl$1 as g, getFrpsServerAddr as h, shortId as i, getHyphaServerUrl as j, hasCookieToken as k, resolveProjectRoot as l, getIssue as m, resumeIssue as n, addComment as o, pauseIssue as p, addIssue as q, registerMachineService as r, startDaemon as s, listIssues as t, updateIssue as u, searchIssues as v, isVisibleTo as w, getRun as x, listRuns as y, getWorkflow as z };
+export { resolveModel as $, runWorkflow as A, setWorkflowEnabled as B, removeWorkflow as C, saveWorkflow as D, rawWorkflow as E, listWorkflows as F, isWorkflowEnabled as G, workflowCrons as H, cronMatches as I, summarize as J, workflowSteps as K, loadMachineContext as L, buildMachineInstructions as M, machineToolsForRole as N, buildMachineTools as O, parseFrontmatter as P, getSkillsServer as Q, READ_ONLY_TOOLS as R, ServeAuth as S, getSkillsWorkspaceName as T, getSkillsCollectionName as U, fetchWithTimeout as V, searchSkills as W, SKILLS_DIR as X, getSkillInfo as Y, downloadSkillFile as Z, listSkillFiles as _, createSessionStore as a, clearStopMarker as a0, stopMarkerExists as a1, formatHandle as a2, normalizeAllowedUser as a3, loadSecurityContextConfig as a4, resolveSecurityContext as a5, buildSecurityContextFromFlags as a6, mergeSecurityContexts as a7, buildSessionShareUrl as a8, computeOutboundHop as a9, registerAwaitingReply as aa, buildMachineShareUrl as ab, parseHandle as ac, handleMatchesMetadata as ad, describeMisconfiguration as ae, buildMachineDeps as af, applyClaudeProxyEnv as ag, composeSessionId as ah, generateFriendlyName as ai, generateHookSettings as aj, claudeAuth as ak, codexProvider as al, projectInfo as am, DefaultTransport$1 as an, acpBackend as ao, acpAgentConfig as ap, codexAppServerBackend as aq, GeminiTransport$1 as ar, instanceConfig as as, api as at, run as au, stopDaemon as b, connectToHypha as c, daemonStatus as d, getFrpsSubdomainHost as e, getFrpsServerPort as f, getHyphaServerUrl$1 as g, getFrpsServerAddr as h, shortId as i, getHyphaServerUrl as j, hasCookieToken as k, resolveProjectRoot as l, getIssue as m, resumeIssue as n, addComment as o, pauseIssue as p, addIssue as q, registerMachineService as r, startDaemon as s, listIssues as t, updateIssue as u, searchIssues as v, isVisibleTo as w, getRun as x, listRuns as y, getWorkflow as z };