svamp-cli 0.2.263 → 0.2.265

package/dist/{run-DAOLRpvC.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';
@@ -253,6 +253,34 @@ function mergeSecurityContexts(base, override) {
   merged.allowedDirectories = mergeArrays(base.allowedDirectories, override.allowedDirectories);
   return merged;
 }
+function clampSecurityContextToCeiling(ceiling, requested) {
+  if (!ceiling) return void 0;
+  if (!requested) return ceiling;
+  const merged = {};
+  merged.role = ceiling.role;
+  merged.denyAllNetwork = (ceiling.denyAllNetwork ?? false) || (requested.denyAllNetwork ?? false);
+  const cf = ceiling.filesystem;
+  const rf = requested.filesystem;
+  if (cf || rf) {
+    merged.filesystem = {
+      // Grants: ceiling only (caller cannot widen writable paths).
+      allowWrite: cf?.allowWrite ? dedup(cf.allowWrite) : void 0,
+      // Denials: union (caller may add more).
+      denyRead: mergeArrays(cf?.denyRead, rf?.denyRead),
+      denyWrite: mergeArrays(cf?.denyWrite, rf?.denyWrite)
+    };
+  }
+  const cn = ceiling.network;
+  const rn = requested.network;
+  if (cn || rn) {
+    merged.network = {
+      allowedDomains: cn?.allowedDomains ? dedup(cn.allowedDomains) : void 0,
+      deniedDomains: mergeArrays(cn?.deniedDomains, rn?.deniedDomains)
+    };
+  }
+  merged.allowedDirectories = ceiling.allowedDirectories ? dedup(ceiling.allowedDirectories) : void 0;
+  return merged;
+}
 function resolveSecurityContext(config, userEmail) {
   if (!config) return void 0;
   const defaultCtx = config.default;
@@ -1190,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();
@@ -2356,7 +2925,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
           if (machineCtx) {
             options = {
               ...options,
-              securityContext: mergeSecurityContexts(machineCtx, options.securityContext)
+              securityContext: isSharedUser ? clampSecurityContextToCeiling(machineCtx, options.securityContext) : mergeSecurityContexts(machineCtx, options.securityContext)
             };
           }
         }
@@ -2572,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();
@@ -3013,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-YKxUZoMA.mjs');
+        const { FrpcTunnel } = await import('./frpc-Cwn_s0Fs.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -3480,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-DPLjT788.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);
         }
@@ -3579,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-Dni5WrqV.mjs');
+    const { queryCore } = await import('./commands-C_74tXoO.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -3927,290 +4533,95 @@ function classifyInbound(message, now = Date.now(), opts) {
     return { action: "wake", reason: self ? "always-wake (self)" : "always-wake (human)", breakerTripped: tripped2 };
   }
   if (openThreadReply) {
-    if (isBreakerOpenAt(now)) {
-      return { action: "queue", reason: "open-thread reply (breaker open)" };
-    }
-    const tripped2 = recordWake(now);
-    return { action: "wake", reason: "open-thread reply", breakerTripped: tripped2 };
-  }
-  if (message.urgency !== "urgent") {
-    return { action: "queue", reason: "non-urgent" };
-  }
-  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;
+    if (isBreakerOpenAt(now)) {
+      return { action: "queue", reason: "open-thread reply (breaker open)" };
     }
-    kept.push(line);
+    const tripped2 = recordWake(now);
+    return { action: "wake", reason: "open-thread reply", breakerTripped: tripped2 };
   }
-  for (const [key, v] of remainingUpdates) {
-    if (v === void 0) continue;
-    kept.push(`${key}=${v}`);
+  if (message.urgency !== "urgent") {
+    return { action: "queue", reason: "non-urgent" };
   }
-  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 (isBreakerOpenAt(now)) {
+    return { action: "queue", reason: "circuit-breaker-open" };
   }
-  if (mode === "custom") {
-    return {
-      mode,
-      baseUrl: process.env.ANTHROPIC_BASE_URL,
-      apiKeyPreview: redactKey(process.env.ANTHROPIC_API_KEY)
-    };
+  if (!takeUrgentToken(senderKey(message), now)) {
+    return { action: "queue", reason: "rate-limited" };
   }
-  return { mode: "login" };
+  const tripped = recordWake(now);
+  return { action: "wake", reason: "urgent", breakerTripped: tripped };
 }
-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 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 setClaudeAuthLogin() {
-  updateEnvFile({
-    [MODE_KEY]: void 0,
-    [HYPHA_PROXY_URL_KEY]: void 0,
-    ANTHROPIC_BASE_URL: void 0,
-    ANTHROPIC_API_KEY: void 0
-  });
+
+function inboxFilePath(projectDir, sessionId) {
+  return join(projectDir, ".svamp", sessionId, "inbox.json");
 }
-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"
-    );
+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 [];
   }
-  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})`;
+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 {
   }
-  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 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 PARTICIPANTS_CHANNEL_ID = "sys-participants";
 function channelPublicView(c) {
@@ -8692,46 +9103,6 @@ function mapDecisionToWire(d) {
   }
 }
 
-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,
-    hasCustomProvider: hasCustomProvider,
-    resolveCodexProvider: resolveCodexProvider
-});
-
 class CodexAppServerBackend {
   constructor(opts) {
     this.opts = opts;
@@ -8740,6 +9111,8 @@ class CodexAppServerBackend {
     const provider = opts.provider ?? resolveCodexProvider();
     const { configArgs, env: providerEnv, model: providerModel } = buildCodexProviderArgs(provider);
     this.model = opts.model ?? providerModel;
+    this.approvalPolicy = opts.approvalPolicy;
+    this.sandbox = opts.sandbox;
     this.client = new CodexAppServerClient({
       cwd: opts.cwd,
       env: { ...opts.env ?? {}, ...providerEnv },
@@ -8756,6 +9129,11 @@ class CodexAppServerBackend {
   sessionId = randomUUID();
   log;
   model;
+  // #0438: codex's own approval policy + sandbox, derived from the svamp permission mode. Mutable
+  // so a mid-session switchMode takes effect on the next turn. yolo → 'never' + 'danger-full-access'
+  // so codex NEVER prompts for writes (and never times out waiting on a prompt).
+  approvalPolicy;
+  sandbox;
   started = false;
   // Approval promises keyed by callId, resolved by respondToPermission().
   pendingApprovals = /* @__PURE__ */ new Map();
@@ -8779,9 +9157,9 @@ class CodexAppServerBackend {
     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`).");
     await this.client.start();
     if (this.opts.resumeThreadId) {
-      await this.client.resumeThread({ threadId: this.opts.resumeThreadId, model: this.model, approvalPolicy: this.opts.approvalPolicy, sandbox: this.opts.sandbox });
+      await this.client.resumeThread({ threadId: this.opts.resumeThreadId, model: this.model, approvalPolicy: this.approvalPolicy, sandbox: this.sandbox });
     } else {
-      const r = await this.client.startThread({ model: this.model, approvalPolicy: this.opts.approvalPolicy, sandbox: this.opts.sandbox });
+      const r = await this.client.startThread({ model: this.model, approvalPolicy: this.approvalPolicy, sandbox: this.sandbox });
       this.model = this.model ?? r.model;
     }
     this.started = true;
@@ -8798,7 +9176,7 @@ class CodexAppServerBackend {
       resolveTurn = res;
     });
     try {
-      await this.client.sendTurnAndWait(prompt, { model: this.model, approvalPolicy: this.opts.approvalPolicy, sandbox: this.opts.sandbox });
+      await this.client.sendTurnAndWait(prompt, { model: this.model, approvalPolicy: this.approvalPolicy, sandbox: this.sandbox });
     } catch (err) {
       this.emit({ type: "status", status: "error", detail: err instanceof Error ? err.message : String(err) });
     } finally {
@@ -8849,6 +9227,12 @@ class CodexAppServerBackend {
   setModel(model) {
     this.model = model;
   }
+  /** #0438: update codex's approval policy + sandbox (from a svamp permission-mode switch). Takes
+   *  effect on the next turn (and next thread start). yolo → 'never' + 'danger-full-access'. */
+  setPermission(approvalPolicy, sandbox) {
+    this.approvalPolicy = approvalPolicy;
+    this.sandbox = sandbox;
+  }
   /** The model label for assistant-message parity with Claude (frontend schema requires a non-empty `model`). */
   getModel() {
     return this.model || "codex";
@@ -11985,17 +12369,31 @@ function resolveEvaluatorModel(envValue) {
 function parseEvaluatorVerdict(text) {
   if (!text) return null;
   const candidates = [];
-  let depth = 0, start = -1;
+  let depth = 0, start = -1, inStr = false, esc = false;
   for (let i = 0; i < text.length; i++) {
     const c = text[i];
-    if (c === "{") {
+    if (inStr) {
+      if (esc) {
+        esc = false;
+      } else if (c === "\\") {
+        esc = true;
+      } else if (c === '"') {
+        inStr = false;
+      }
+      continue;
+    }
+    if (c === '"') {
+      inStr = true;
+    } else if (c === "{") {
       if (depth === 0) start = i;
       depth++;
     } else if (c === "}") {
-      depth--;
-      if (depth === 0 && start >= 0) {
-        candidates.push(text.slice(start, i + 1));
-        start = -1;
+      if (depth > 0) {
+        depth--;
+        if (depth === 0 && start >= 0) {
+          candidates.push(text.slice(start, i + 1));
+          start = -1;
+        }
       }
     }
   }
@@ -13867,7 +14265,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-DWshkZ3Z.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-CKd1jXfX.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const entries = Array.from(urls.entries());
@@ -13885,7 +14283,7 @@ async function startDaemon(options) {
     }
   }
   async function createExposedTunnel(spec) {
-    const { FrpcTunnel } = await import('./frpc-YKxUZoMA.mjs');
+    const { FrpcTunnel } = await import('./frpc-Cwn_s0Fs.mjs');
     const tunnel = new FrpcTunnel({
       name: spec.name,
       ports: spec.ports,
@@ -13906,7 +14304,7 @@ async function startDaemon(options) {
   }
   const tunnelRecreateState = /* @__PURE__ */ new Map();
   const tunnelRecreateInFlight = /* @__PURE__ */ new Set();
-  const { ServeManager } = await import('./serveManager-DVDWrx2q.mjs');
+  const { ServeManager } = await import('./serveManager-Dy1ZZNaY.mjs');
   const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   ensureAutoInstalledSkills(logger).catch(() => {
   });
@@ -14343,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();
@@ -14843,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 = {};
@@ -16028,11 +16451,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-DrA4F31T.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-B4zSdme1.mjs');
+              const { workflowRpc } = await import('./rpc-DwlZTOtK.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -16323,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();
@@ -16426,6 +16851,8 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               if (currentPermissionMode === mode) return;
               logger.log(`[${agentName} Session ${sessionId}] Switch mode: ${mode}`);
               currentPermissionMode = mode;
+              const cp = codexPermissionSettings(mode);
+              agentBackend.setPermission?.(cp.approvalPolicy, cp.sandbox);
             },
             onRestartClaude: async () => {
               logger.log(`[${agentName} Session ${sessionId}] Restart agent requested`);
@@ -16588,11 +17015,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-DrA4F31T.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-B4zSdme1.mjs');
+              const { workflowRpc } = await import('./rpc-DwlZTOtK.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -16743,17 +17170,45 @@ ${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;
-          logger.log(`[Agent Session ${sessionId}] Codex backend: app-server (model=${codexModel ?? "default"}${provider.apiBase ? `, provider=${provider.apiBase}` : ""})`);
+          const codexPerm = codexPermissionSettings(currentPermissionMode);
+          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,
+            sandbox: codexPerm.sandbox,
             // #0412 P2: resume the persisted thread across a daemon restart (context intact).
             resumeThreadId: acpResumeThreadId
           });
@@ -17600,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-DfbBMHWm.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-BxijQDI8.mjs');
     const workflowScheduler = new WorkflowScheduler({
       projectRoots: () => {
         const dirs = /* @__PURE__ */ new Set();
@@ -18211,4 +18666,4 @@ var run = /*#__PURE__*/Object.freeze({
     writeStopMarker: writeStopMarker
 });
 
-export { downloadSkillFile as $, listRuns as A, getWorkflow as B, runWorkflow as C, setWorkflowEnabled as D, removeWorkflow as E, saveWorkflow as F, rawWorkflow as G, listWorkflows as H, isWorkflowEnabled as I, workflowCrons as J, cronMatches as K, summarize as L, workflowSteps as M, loadMachineContext as N, buildMachineInstructions as O, machineToolsForRole as P, buildMachineTools as Q, READ_ONLY_TOOLS as R, ServeAuth as S, parseFrontmatter as T, getSkillsServer as U, getSkillsWorkspaceName as V, getSkillsCollectionName as W, fetchWithTimeout as X, searchSkills as Y, SKILLS_DIR as Z, getSkillInfo as _, createSessionStore as a, listSkillFiles as a0, resolveModel 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, clearStopMarker as e, stopMarkerExists as f, getHyphaServerUrl$1 as g, getFrpsSubdomainHost as h, getFrpsServerPort as i, getFrpsServerAddr as j, shortId as k, getHyphaServerUrl as l, hasCookieToken as m, resolveProjectRoot as n, getIssue as o, resumeIssue as p, pauseIssue as q, registerMachineService as r, startDaemon as s, addComment as t, updateIssue as u, addIssue as v, listIssues as w, searchIssues as x, isVisibleTo as y, getRun 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 };