svamp-cli 0.2.264 → 0.2.266

package/dist/{run-kkeXP2d_.mjs → run-CetRvMab.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 { exec, execSync, spawn, execFile as execFile$1, execFileSync } from 'node:child_process';
+import { randomUUID, randomBytes, createHash } from 'node:crypto';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, chmodSync, rmSync, cpSync, realpathSync, readdirSync, statSync, renameSync, appendFileSync, unlinkSync } from 'node:fs';
+import { exec, spawn, execSync, 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';
@@ -1170,52 +1170,862 @@ async function readProcessTable() {
     const command = parts.slice(5).join(" ");
     rows.push({ pid, ppid, etimeSec, cpu, rssKb, command });
   }
-  return rows;
+  return rows;
+}
+async function detectDescendants(rootPid, excludePids = /* @__PURE__ */ new Set()) {
+  if (!rootPid || rootPid < 1) return [];
+  const table = await readProcessTable();
+  if (table.length === 0) return [];
+  const byPpid = /* @__PURE__ */ new Map();
+  for (const row of table) {
+    const list = byPpid.get(row.ppid);
+    if (list) list.push(row);
+    else byPpid.set(row.ppid, [row]);
+  }
+  const descendants = [];
+  const visited = /* @__PURE__ */ new Set([rootPid]);
+  const queue = [rootPid];
+  const MAX_NODES = 5e3;
+  while (queue.length > 0 && descendants.length < MAX_NODES) {
+    const next = queue.shift();
+    const children = byPpid.get(next);
+    if (!children) continue;
+    for (const child of children) {
+      if (visited.has(child.pid)) continue;
+      visited.add(child.pid);
+      queue.push(child.pid);
+      if (!excludePids.has(child.pid)) {
+        descendants.push(child);
+      }
+    }
+  }
+  descendants.sort((a, b) => a.etimeSec - b.etimeSec);
+  return descendants;
+}
+async function killDescendant(rootPid, targetPid, signal = "SIGTERM") {
+  if (!rootPid || rootPid < 1) return { killed: false, reason: "no root pid" };
+  if (!targetPid || targetPid < 1) return { killed: false, reason: "invalid target pid" };
+  if (targetPid === rootPid) return { killed: false, reason: "cannot kill session root pid" };
+  const descendants = await detectDescendants(rootPid);
+  if (!descendants.some((d) => d.pid === targetPid)) {
+    return { killed: false, reason: "pid is not a descendant of this session" };
+  }
+  try {
+    process.kill(targetPid, signal);
+    return { killed: true };
+  } catch (err) {
+    return { killed: false, reason: err?.message ?? "kill failed" };
+  }
+}
+
+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-oauth", "anthropic-api-key", "claude-oauth-token", "hypha-proxy", "anthropic-gateway"],
+  openai: ["chatgpt-oauth", "openai-api-key", "openai-gateway"]
+};
+const OAUTH_METHODS = ["anthropic-oauth", "chatgpt-oauth"];
+function isOAuthMethod(method) {
+  return OAUTH_METHODS.includes(method);
+}
+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, accessToken, refreshToken, ...rest } = a;
+  const oauthConnected = isOAuthMethod(a.method) ? a.method === "anthropic-oauth" ? !!accessToken : true : void 0;
+  return {
+    ...rest,
+    secretPreview: previewSecret(secret) ?? (accessToken ? previewSecret(accessToken) : void 0),
+    oauthConnected
+  };
+}
+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" && !isOAuthMethod(method);
+  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,
+    // OAuth token bundle (anthropic-oauth) — carried through on refresh/update; kept if unset.
+    accessToken: input.accessToken ?? existing?.accessToken,
+    refreshToken: input.refreshToken ?? existing?.refreshToken,
+    expiresAt: input.expiresAt ?? existing?.expiresAt,
+    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 "anthropic-oauth":
+      return {
+        vendor: "anthropic",
+        claudeEnv: {
+          CLAUDE_CODE_OAUTH_TOKEN: account.accessToken,
+          ANTHROPIC_BASE_URL: void 0,
+          ANTHROPIC_API_KEY: void 0
+        },
+        describe: `claude subscription oauth (${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 });
+  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 "anthropic-oauth": {
+        const tok = account.accessToken;
+        if (!tok) return { ok: false, detail: "Not signed in \u2014 start the OAuth flow" };
+        const res = await withTimeout("https://api.anthropic.com/v1/messages", {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            "authorization": `Bearer ${tok}`,
+            "anthropic-version": "2023-06-01",
+            "anthropic-beta": "oauth-2025-04-20"
+          },
+          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: `Sign-in expired or rejected (HTTP ${res.status}) \u2014 reconnect` };
+        if (res.ok || res.status === 400 || res.status === 429) return { ok: true, detail: `Connected (HTTP ${res.status})` };
+        return { ok: true, detail: `Connected, 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.model || true, detail: "ChatGPT signed in via device auth \u2014 verified when a Codex session starts (per-account CODEX_HOME)" };
+      default:
+        return { ok: false, detail: "Unknown method" };
+    }
+  } catch (e) {
+    return { ok: false, detail: `Unreachable: ${e?.message || e}` };
+  }
+}
+async function refreshDueAnthropicAccounts(refresh, log, svampHome, skewMs = 10 * 60 * 1e3) {
+  const due = loadAccounts(svampHome).filter((a) => a.method === "anthropic-oauth" && a.refreshToken && Date.now() >= (a.expiresAt ?? 0) - skewMs);
+  for (const a of due) {
+    try {
+      const t = await refresh(a.refreshToken);
+      upsertAccount({
+        id: a.id,
+        label: a.label,
+        vendor: a.vendor,
+        method: a.method,
+        accessToken: t.accessToken,
+        refreshToken: t.refreshToken,
+        expiresAt: t.expiresAt
+      }, svampHome);
+      log(`[oauth] refreshed anthropic-oauth account ${a.label}`);
+    } catch (e) {
+      log(`[oauth] refresh failed for account ${a.label}: ${e?.message || e}`);
+    }
+  }
+}
+
+const ANTHROPIC_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+const ANTHROPIC_AUTH_ENDPOINT = "https://claude.ai/oauth/authorize";
+const ANTHROPIC_TOKEN_ENDPOINT = "https://platform.claude.com/v1/oauth/token";
+const ANTHROPIC_REDIRECT_URI = "https://console.anthropic.com/oauth/code/callback";
+const ANTHROPIC_SCOPES = "user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";
+function generatePkce() {
+  const verifier = randomBytes(32).toString("base64url");
+  const challenge = createHash("sha256").update(verifier).digest("base64url");
+  return { verifier, challenge };
+}
+function buildAnthropicAuthUrl(challenge, state) {
+  const params = new URLSearchParams({
+    response_type: "code",
+    client_id: ANTHROPIC_CLIENT_ID,
+    redirect_uri: ANTHROPIC_REDIRECT_URI,
+    code_challenge: challenge,
+    code_challenge_method: "S256",
+    state,
+    scope: ANTHROPIC_SCOPES,
+    oauth_beta: "oauth-2025-04-20"
+  });
+  return `${ANTHROPIC_AUTH_ENDPOINT}?${params.toString()}`;
+}
+function extractAuthCode(raw) {
+  let s = (raw || "").trim();
+  if (s.startsWith("http")) {
+    try {
+      const u = new URL(s);
+      const c = u.searchParams.get("code");
+      if (c) return c;
+    } catch {
+    }
+  }
+  if (s.includes("#")) s = s.split("#")[0];
+  return s.trim();
 }
-async function detectDescendants(rootPid, excludePids = /* @__PURE__ */ new Set()) {
-  if (!rootPid || rootPid < 1) return [];
-  const table = await readProcessTable();
-  if (table.length === 0) return [];
-  const byPpid = /* @__PURE__ */ new Map();
-  for (const row of table) {
-    const list = byPpid.get(row.ppid);
-    if (list) list.push(row);
-    else byPpid.set(row.ppid, [row]);
+function tokensFromResponse(j) {
+  const expiresInSec = typeof j.expires_in === "number" ? j.expires_in : 3600;
+  return {
+    accessToken: j.access_token || "",
+    refreshToken: j.refresh_token || "",
+    expiresAt: Date.now() + expiresInSec * 1e3
+  };
+}
+async function exchangeAnthropicCode(code, verifier, state) {
+  const res = await fetch(ANTHROPIC_TOKEN_ENDPOINT, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      grant_type: "authorization_code",
+      code: extractAuthCode(code),
+      redirect_uri: ANTHROPIC_REDIRECT_URI,
+      client_id: ANTHROPIC_CLIENT_ID,
+      code_verifier: verifier,
+      state
+      // Anthropic requires state echoed in the body
+    })
+  });
+  if (!res.ok) {
+    const t = await res.text().catch(() => "");
+    throw new Error(`Token exchange failed (${res.status}): ${t.slice(0, 300)}`);
+  }
+  return tokensFromResponse(await res.json());
+}
+async function refreshAnthropicToken(refreshToken) {
+  const res = await fetch(ANTHROPIC_TOKEN_ENDPOINT, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+      client_id: ANTHROPIC_CLIENT_ID
+    })
+  });
+  if (!res.ok) {
+    const t = await res.text().catch(() => "");
+    throw new Error(`Token refresh failed (${res.status}): ${t.slice(0, 300)}`);
   }
-  const descendants = [];
-  const visited = /* @__PURE__ */ new Set([rootPid]);
-  const queue = [rootPid];
-  const MAX_NODES = 5e3;
-  while (queue.length > 0 && descendants.length < MAX_NODES) {
-    const next = queue.shift();
-    const children = byPpid.get(next);
-    if (!children) continue;
-    for (const child of children) {
-      if (visited.has(child.pid)) continue;
-      visited.add(child.pid);
-      queue.push(child.pid);
-      if (!excludePids.has(child.pid)) {
-        descendants.push(child);
+  const tokens = tokensFromResponse(await res.json());
+  if (!tokens.refreshToken) tokens.refreshToken = refreshToken;
+  return tokens;
+}
+function parseDeviceAuthOutput(text) {
+  const out = {};
+  const urlMatch = text.match(/https?:\/\/[^\s"'<>)]+/i);
+  if (urlMatch) out.verificationUrl = urlMatch[0].replace(/[.,]$/, "");
+  const codeMatch = text.match(/\b([A-Z0-9]{3,5}(?:-[A-Z0-9]{3,5})+)\b/);
+  if (codeMatch) out.userCode = codeMatch[1];
+  return out;
+}
+const flows = /* @__PURE__ */ new Map();
+const FLOW_TTL_MS = 15 * 60 * 1e3;
+function oauthFlowDir(flowId, svampHome) {
+  const home = svampHome || process.env.SVAMP_HOME || join(homedir(), ".svamp");
+  return join(home, "oauth-flows", flowId);
+}
+function pruneFlows() {
+  const now = Date.now();
+  for (const [id, f] of flows) {
+    if (now - f.createdAt > FLOW_TTL_MS) {
+      try {
+        f.proc?.kill();
+      } catch {
       }
-    }
+      try {
+        if (f.codexHome) rmSync(join(f.codexHome, ".."), { recursive: true, force: true });
+      } catch {
+      }
+      flows.delete(id);
+    }
+  }
+}
+function startAnthropicFlow(label) {
+  pruneFlows();
+  const { verifier, challenge } = generatePkce();
+  const state = randomBytes(32).toString("base64url");
+  const flowId = randomUUID();
+  const authorizeUrl = buildAnthropicAuthUrl(challenge, state);
+  flows.set(flowId, { id: flowId, vendor: "anthropic", label, createdAt: Date.now(), status: "pending", state, verifier });
+  return { flowId, authorizeUrl };
+}
+function startOpenAiDeviceFlow(label, log, svampHome) {
+  pruneFlows();
+  const flowId = randomUUID();
+  const codexHome = join(oauthFlowDir(flowId, svampHome), "codex");
+  mkdirSync(codexHome, { recursive: true });
+  const flow = { id: flowId, vendor: "openai", label, createdAt: Date.now(), status: "pending", codexHome, outputBuffer: "" };
+  flows.set(flowId, flow);
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const proc = spawn("codex", ["login", "--device-auth"], {
+      env: { ...process.env, CODEX_HOME: codexHome },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    flow.proc = proc;
+    const onData = (buf) => {
+      const text = buf.toString();
+      flow.outputBuffer = (flow.outputBuffer || "") + text;
+      const parsed = parseDeviceAuthOutput(flow.outputBuffer);
+      if (parsed.verificationUrl) flow.verificationUrl = parsed.verificationUrl;
+      if (parsed.userCode) flow.userCode = parsed.userCode;
+      if (!settled && flow.verificationUrl && flow.userCode) {
+        settled = true;
+        resolve({ flowId, verificationUrl: flow.verificationUrl, userCode: flow.userCode });
+      }
+    };
+    proc.stdout?.on("data", onData);
+    proc.stderr?.on("data", onData);
+    proc.on("exit", (code) => {
+      if (code === 0 && flow.codexHome && existsSync(join(flow.codexHome, "auth.json"))) {
+        flow.status = "authorized";
+      } else {
+        flow.status = "error";
+        flow.error = flow.error || `codex login exited ${code}` + (/(device code|workspace admin|not.*enabled)/i.test(flow.outputBuffer || "") ? " \u2014 device-code login may be disabled for this ChatGPT workspace (ask an admin to enable it)." : "");
+        if (!settled) {
+          settled = true;
+          reject(new Error(flow.error));
+        }
+      }
+    });
+    proc.on("error", (err) => {
+      flow.status = "error";
+      flow.error = `Failed to run codex login: ${err.message}. Is the Codex CLI installed on this machine?`;
+      if (!settled) {
+        settled = true;
+        reject(new Error(flow.error));
+      }
+    });
+    setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        reject(new Error("Timed out waiting for the device code from codex login."));
+      }
+    }, 3e4);
+    log(`[oauth] started codex device-auth flow ${flowId}`);
+  });
+}
+function getFlow(flowId) {
+  return flows.get(flowId);
+}
+async function completeAnthropicFlow(flowId, code) {
+  const flow = flows.get(flowId);
+  if (!flow || flow.vendor !== "anthropic" || !flow.verifier || !flow.state) {
+    throw new Error("Invalid or expired OAuth flow");
   }
-  descendants.sort((a, b) => a.etimeSec - b.etimeSec);
-  return descendants;
+  const tokens = await exchangeAnthropicCode(code, flow.verifier, flow.state);
+  flows.delete(flowId);
+  return tokens;
 }
-async function killDescendant(rootPid, targetPid, signal = "SIGTERM") {
-  if (!rootPid || rootPid < 1) return { killed: false, reason: "no root pid" };
-  if (!targetPid || targetPid < 1) return { killed: false, reason: "invalid target pid" };
-  if (targetPid === rootPid) return { killed: false, reason: "cannot kill session root pid" };
-  const descendants = await detectDescendants(rootPid);
-  if (!descendants.some((d) => d.pid === targetPid)) {
-    return { killed: false, reason: "pid is not a descendant of this session" };
+function finalizeOpenAiFlow(flowId, accountCodexHome) {
+  const flow = flows.get(flowId);
+  if (!flow || flow.vendor !== "openai") throw new Error("Invalid or expired OAuth flow");
+  if (flow.status !== "authorized" || !flow.codexHome) throw new Error("Device authorization not complete yet");
+  mkdirSync(accountCodexHome, { recursive: true });
+  cpSync(flow.codexHome, accountCodexHome, { recursive: true });
+  try {
+    rmSync(join(flow.codexHome, ".."), { recursive: true, force: true });
+  } catch {
+  }
+  flows.delete(flowId);
+}
+function cancelFlow(flowId) {
+  const flow = flows.get(flowId);
+  if (!flow) return;
+  flow.status = "cancelled";
+  try {
+    flow.proc?.kill();
+  } catch {
   }
   try {
-    process.kill(targetPid, signal);
-    return { killed: true };
-  } catch (err) {
-    return { killed: false, reason: err?.message ?? "kill failed" };
+    if (flow.codexHome) rmSync(join(flow.codexHome, ".."), { recursive: true, force: true });
+  } catch {
   }
+  flows.delete(flowId);
 }
 
 const FIELD_RANGES = [[0, 59], [0, 23], [1, 31], [1, 12], [0, 6]];
@@ -2600,6 +3410,110 @@ 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);
+      },
+      // ── Guided OAuth login (both vendors; admin-gated) ──
+      // Anthropic: PKCE authorize URL → user pastes the shown code back.
+      // OpenAI: device-auth → we show a verification URL + user code, then poll to completion.
+      startBackendOAuth: async (vendor, label, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "admin");
+        const lbl = (label || "").trim() || (vendor === "anthropic" ? "Claude subscription" : "ChatGPT subscription");
+        if (vendor === "anthropic") {
+          const { flowId, authorizeUrl } = startAnthropicFlow(lbl);
+          return { vendor, flowId, mode: "paste-code", authorizeUrl };
+        }
+        if (vendor === "openai") {
+          const { flowId, verificationUrl, userCode } = await startOpenAiDeviceFlow(
+            lbl,
+            (m) => console.log(m),
+            metadata.svampHomeDir
+          );
+          return { vendor, flowId, mode: "device-code", verificationUrl, userCode };
+        }
+        throw new Error(`Unsupported OAuth vendor: ${String(vendor)}`);
+      },
+      completeBackendOAuth: async (flowId, code, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "admin");
+        const flow = getFlow(flowId);
+        if (!flow) throw new Error("OAuth flow expired \u2014 start again");
+        const createdBy = context?.user?.email;
+        if (flow.vendor === "anthropic") {
+          if (!code || !code.trim()) throw new Error("Paste the authorization code");
+          const tokens = await completeAnthropicFlow(flowId, code);
+          const account = upsertAccount({
+            label: flow.label,
+            vendor: "anthropic",
+            method: "anthropic-oauth",
+            accessToken: tokens.accessToken,
+            refreshToken: tokens.refreshToken,
+            expiresAt: tokens.expiresAt,
+            createdBy
+          }, metadata.svampHomeDir);
+          notifyListeners({ type: "update-machine", machineId, backendAccountsChanged: true });
+          return { done: true, account: redactAccount(account) };
+        }
+        if (flow.status === "pending") {
+          return { done: false, status: "pending", verificationUrl: flow.verificationUrl, userCode: flow.userCode };
+        }
+        if (flow.status === "error") throw new Error(flow.error || "Device authorization failed");
+        if (flow.status === "authorized") {
+          const account = upsertAccount({
+            label: flow.label,
+            vendor: "openai",
+            method: "chatgpt-oauth",
+            createdBy
+          }, metadata.svampHomeDir);
+          try {
+            finalizeOpenAiFlow(flowId, accountCodexHomeDir(account.id, metadata.svampHomeDir));
+          } catch (e) {
+            deleteAccount(account.id, metadata.svampHomeDir);
+            throw e;
+          }
+          notifyListeners({ type: "update-machine", machineId, backendAccountsChanged: true });
+          return { done: true, account: redactAccount(account) };
+        }
+        throw new Error("Device authorization was cancelled");
+      },
+      cancelBackendOAuth: async (flowId, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "admin");
+        cancelFlow(flowId);
+        return { success: true };
+      },
       // Register a listener for real-time updates (app calls this with _rintf callback)
       registerListener: async (callback, context) => {
         trackInbound();
@@ -3041,7 +3955,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-CxqX4sQ7.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -3508,7 +4422,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-CWu6yjFl.mjs');
           const r2 = await runWiseAgent({ message: params.message, sender, config: { tools: toolsForRole(role2) }, deps, transport, model: resolved.model });
           return fmt(r2);
         }
@@ -3607,7 +4521,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-BX6_mFbE.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -3968,277 +4882,82 @@ function classifyInbound(message, now = Date.now(), opts) {
     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}`);
+    return { action: "queue", reason: "rate-limited" };
   }
-  writeEnvLines(kept);
+  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 +9439,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 +14601,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-aCeb0xu5.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const entries = Array.from(urls.entries());
@@ -13958,7 +14619,7 @@ async function startDaemon(options) {
     }
   }
   async function createExposedTunnel(spec) {
-    const { FrpcTunnel } = await import('./frpc-DmaWRu0M.mjs');
+    const { FrpcTunnel } = await import('./frpc-CxqX4sQ7.mjs');
     const tunnel = new FrpcTunnel({
       name: spec.name,
       ports: spec.ports,
@@ -13979,7 +14640,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-Bk6Fkoha.mjs');
   const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   ensureAutoInstalledSkills(logger).catch(() => {
   });
@@ -14416,7 +15077,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 +15580,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 +16787,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-DswYjrCh.mjs');
+              const { issueRpc } = await import('./rpc-BB9tE2dR.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-BXmmzMmw.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -16396,7 +17082,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 +17351,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-DswYjrCh.mjs');
+              const { issueRpc } = await import('./rpc-BB9tE2dR.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-BXmmzMmw.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -16818,16 +17506,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 +18391,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-Xhs6PCCU.mjs');
     const workflowScheduler = new WorkflowScheduler({
       projectRoots: () => {
         const dirs = /* @__PURE__ */ new Set();
@@ -17696,6 +18409,18 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
         logger.log(`[workflow] scheduler tick error: ${e?.message || e}`);
       }
     }, 2e4);
+    const runOAuthAccountRefresh = () => {
+      refreshDueAnthropicAccounts(
+        async (rt) => {
+          const t = await refreshAnthropicToken(rt);
+          return t;
+        },
+        (m) => logger.log(m),
+        SVAMP_HOME
+      ).catch((e) => logger.log(`[oauth] account refresh error: ${e?.message || e}`));
+    };
+    runOAuthAccountRefresh();
+    const backendAccountRefreshInterval = setInterval(runOAuthAccountRefresh, 5 * 6e4);
     let heartbeatRunning = false;
     let lastReconnectAt = 0;
     let heartbeatCycle = 0;
@@ -18289,4 +19014,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 };