cc-claw 0.15.2 → 0.16.1

package/dist/cli.js

@@ -33,7 +33,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.15.2" : (() => {
+    VERSION = true ? "0.16.1" : (() => {
       try {
         return JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8")).version ?? "unknown";
       } catch {
@@ -1729,6 +1729,30 @@ function initSchema(db3) {
       mode TEXT NOT NULL DEFAULT 'auto'
     );
   `);
+  db3.exec(`
+    CREATE TABLE IF NOT EXISTS backend_credentials (
+      id                 INTEGER PRIMARY KEY AUTOINCREMENT,
+      backend            TEXT NOT NULL,
+      slot_type          TEXT NOT NULL DEFAULT 'api_key',
+      label              TEXT,
+      api_key            TEXT,
+      config_home        TEXT,
+      priority           INTEGER NOT NULL DEFAULT 0,
+      enabled            INTEGER NOT NULL DEFAULT 1,
+      cooldown_until     TEXT,
+      last_used          TEXT,
+      consecutive_errors INTEGER NOT NULL DEFAULT 0,
+      created_at         TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+  db3.exec(`
+    CREATE TABLE IF NOT EXISTS chat_backend_slot (
+      chat_id  TEXT NOT NULL,
+      backend  TEXT NOT NULL,
+      slot_id  INTEGER,
+      PRIMARY KEY (chat_id, backend)
+    );
+  `);
   try {
     const deleted = db3.prepare(
       "DELETE FROM usage_log WHERE created_at < datetime('now', '-90 days')"
@@ -3311,10 +3335,108 @@ var init_gemini_slots = __esm({
   }
 });
 
+// src/memory/backend-slots.ts
+function getBackendSlots(backend2) {
+  return getDb().prepare(`
+    SELECT ${SLOT_COLUMNS}
+    FROM backend_credentials WHERE backend = ? ORDER BY priority ASC, id ASC
+  `).all(backend2);
+}
+function getEligibleBackendSlots(backend2) {
+  return getDb().prepare(`
+    SELECT ${SLOT_COLUMNS}
+    FROM backend_credentials
+    WHERE backend = ? AND enabled = 1
+      AND (cooldown_until IS NULL OR cooldown_until <= datetime('now'))
+    ORDER BY priority ASC, last_used ASC NULLS FIRST
+  `).all(backend2);
+}
+function getChatBackendSlotId(chatId, backend2) {
+  const row = getDb().prepare(
+    "SELECT slot_id FROM chat_backend_slot WHERE chat_id = ? AND backend = ?"
+  ).get(chatId, backend2);
+  return row?.slot_id ?? null;
+}
+function getNextBackendSlot(chatId, backend2) {
+  const pinned = getDb().prepare(`
+    SELECT ${SLOT_COLUMNS}
+    FROM backend_credentials bc
+    JOIN chat_backend_slot cbs ON cbs.slot_id = bc.id
+    WHERE cbs.chat_id = ? AND cbs.backend = ? AND bc.enabled = 1
+      AND (bc.cooldown_until IS NULL OR bc.cooldown_until <= datetime('now'))
+  `).get(chatId, backend2);
+  if (pinned) return pinned;
+  const eligible = getEligibleBackendSlots(backend2);
+  return eligible.length > 0 ? eligible[0] : null;
+}
+function markBackendSlotSuccess(slotId) {
+  getDb().prepare(`
+    UPDATE backend_credentials
+    SET last_used = datetime('now'), consecutive_errors = 0,
+        cooldown_until = CASE WHEN cooldown_until < datetime('now') THEN NULL ELSE cooldown_until END
+    WHERE id = ?
+  `).run(slotId);
+}
+function markBackendSlotExhausted(slotId, cooldownHours = 6) {
+  getDb().prepare(`
+    UPDATE backend_credentials
+    SET cooldown_until = datetime('now', '+' || ? || ' hours'),
+        consecutive_errors = consecutive_errors + 1,
+        enabled = CASE WHEN consecutive_errors + 1 >= 10 THEN 0 ELSE enabled END
+    WHERE id = ?
+  `).run(cooldownHours, slotId);
+}
+function pinChatBackendSlot(chatId, backend2, slotId) {
+  getDb().prepare(`
+    INSERT INTO chat_backend_slot (chat_id, backend, slot_id) VALUES (?, ?, ?)
+    ON CONFLICT(chat_id, backend) DO UPDATE SET slot_id = excluded.slot_id
+  `).run(chatId, backend2, slotId);
+}
+function clearChatBackendSlot(chatId, backend2) {
+  getDb().prepare("DELETE FROM chat_backend_slot WHERE chat_id = ? AND backend = ?").run(chatId, backend2);
+}
+function addBackendSlot(opts) {
+  const result = getDb().prepare(`
+    INSERT INTO backend_credentials (backend, slot_type, label, api_key, config_home, priority)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(opts.backend, opts.slotType, opts.label ?? null, opts.apiKey ?? null, opts.configHome ?? null, opts.priority ?? 0);
+  return Number(result.lastInsertRowid);
+}
+function removeBackendSlot(id) {
+  getDb().prepare("DELETE FROM chat_backend_slot WHERE slot_id = ?").run(id);
+  return getDb().prepare("DELETE FROM backend_credentials WHERE id = ?").run(id).changes > 0;
+}
+function setBackendSlotEnabled(id, enabled) {
+  getDb().prepare("UPDATE backend_credentials SET enabled = ? WHERE id = ?").run(enabled ? 1 : 0, id);
+}
+function reorderBackendSlot(id, priority) {
+  getDb().prepare("UPDATE backend_credentials SET priority = ? WHERE id = ?").run(priority, id);
+}
+function reenableBackendSlot(slotId) {
+  getDb().prepare(`
+    UPDATE backend_credentials
+    SET enabled = 1, consecutive_errors = 0, cooldown_until = NULL
+    WHERE id = ?
+  `).run(slotId);
+}
+var SLOT_COLUMNS;
+var init_backend_slots = __esm({
+  "src/memory/backend-slots.ts"() {
+    "use strict";
+    init_store5();
+    SLOT_COLUMNS = `
+  id, backend, slot_type AS slotType, label, api_key AS apiKey, config_home AS configHome,
+  priority, enabled, cooldown_until AS cooldownUntil, last_used AS lastUsed,
+  consecutive_errors AS consecutiveErrors, created_at AS createdAt
+`;
+  }
+});
+
 // src/memory/store.ts
 var store_exports5 = {};
 __export(store_exports5, {
   ALL_TOOLS: () => ALL_TOOLS,
+  addBackendSlot: () => addBackendSlot,
   addGeminiSlot: () => addGeminiSlot,
   addHeartbeatWatch: () => addHeartbeatWatch,
   addUsage: () => addUsage,
@@ -3325,6 +3447,7 @@ __export(store_exports5, {
   clearAgentMode: () => clearAgentMode,
   clearAllSessions: () => clearAllSessions,
   clearBackendLimit: () => clearBackendLimit,
+  clearChatBackendSlot: () => clearChatBackendSlot,
   clearChatGeminiSlot: () => clearChatGeminiSlot,
   clearCwd: () => clearCwd,
   clearMessageLog: () => clearMessageLog,
@@ -3352,13 +3475,16 @@ __export(store_exports5, {
   getAllTimeUsage: () => getAllTimeUsage,
   getBackend: () => getBackend,
   getBackendLimit: () => getBackendLimit,
+  getBackendSlots: () => getBackendSlots,
   getBackendUsageInWindow: () => getBackendUsageInWindow,
   getBookmark: () => getBookmark,
+  getChatBackendSlotId: () => getChatBackendSlotId,
   getChatGeminiSlotId: () => getChatGeminiSlotId,
   getChatIdByAlias: () => getChatIdByAlias,
   getChatUsageByModel: () => getChatUsageByModel,
   getCwd: () => getCwd,
   getDb: () => getDb,
+  getEligibleBackendSlots: () => getEligibleBackendSlots,
   getEligibleGeminiSlots: () => getEligibleGeminiSlots,
   getEnabledTools: () => getEnabledTools,
   getGeminiRotationMode: () => getGeminiRotationMode,
@@ -3371,6 +3497,7 @@ __export(store_exports5, {
   getMode: () => getMode,
   getModel: () => getModel,
   getModelSignature: () => getModelSignature,
+  getNextBackendSlot: () => getNextBackendSlot,
   getNextGeminiSlot: () => getNextGeminiSlot,
   getPendingEscalation: () => getPendingEscalation,
   getRecentBookmarks: () => getRecentBookmarks,
@@ -3394,18 +3521,24 @@ __export(store_exports5, {
   insertJobRun: () => insertJobRun,
   listMemories: () => listMemories,
   listSessionSummaries: () => listSessionSummaries,
+  markBackendSlotExhausted: () => markBackendSlotExhausted,
+  markBackendSlotSuccess: () => markBackendSlotSuccess,
   markMessageLogSummarized: () => markMessageLogSummarized,
   markSlotExhausted: () => markSlotExhausted,
   markSlotSuccess: () => markSlotSuccess,
   openDatabaseReadOnly: () => openDatabaseReadOnly,
+  pinChatBackendSlot: () => pinChatBackendSlot,
   pinChatGeminiSlot: () => pinChatGeminiSlot,
   pruneJobRuns: () => pruneJobRuns,
   pruneMessageLog: () => pruneMessageLog,
+  reenableBackendSlot: () => reenableBackendSlot,
   reenableSlot: () => reenableSlot,
+  removeBackendSlot: () => removeBackendSlot,
   removeChatAlias: () => removeChatAlias,
   removeGeminiSlot: () => removeGeminiSlot,
   removeHeartbeatWatch: () => removeHeartbeatWatch,
   removePendingEscalation: () => removePendingEscalation,
+  reorderBackendSlot: () => reorderBackendSlot,
   reorderGeminiSlot: () => reorderGeminiSlot,
   resetJobFailures: () => resetJobFailures,
   resetTools: () => resetTools,
@@ -3420,6 +3553,7 @@ __export(store_exports5, {
   setAgentMode: () => setAgentMode,
   setBackend: () => setBackend,
   setBackendLimit: () => setBackendLimit,
+  setBackendSlotEnabled: () => setBackendSlotEnabled,
   setBootTime: () => setBootTime,
   setChatAlias: () => setChatAlias,
   setCwd: () => setCwd,
@@ -3480,6 +3614,7 @@ var init_store5 = __esm({
     init_aliases();
     init_message_log();
     init_gemini_slots();
+    init_backend_slots();
   }
 });
 
@@ -3672,6 +3807,16 @@ var init_claude = __esm({
         env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1";
         return env;
       }
+      getEnvForSlot(slot) {
+        const env = this.getEnv();
+        if (slot.slotType === "api_key" && slot.apiKey) {
+          env.ANTHROPIC_API_KEY = slot.apiKey;
+        } else if (slot.slotType === "oauth" && slot.configHome) {
+          env.HOME = slot.configHome;
+          delete env.ANTHROPIC_API_KEY;
+        }
+        return env;
+      }
       applyThinkingConfig(level, model2) {
         if (level === "auto") return {};
         if (level === "off") return { envOverrides: { MAX_THINKING_TOKENS: "0" } };
@@ -3961,7 +4106,7 @@ var init_gemini = __esm({
        * OAuth slots set GEMINI_CLI_HOME for isolated config and unset GEMINI_API_KEY so
        * the CLI uses OAuth instead. Returns the slot used (or null for default behavior).
        */
-      getEnvForSlot(chatId, thinkingOverrides, mode) {
+      resolveSlotEnv(chatId, thinkingOverrides, mode) {
         const slot = getNextGeminiSlot(chatId, mode);
         const env = this.getEnv(thinkingOverrides);
         if (!slot) return { env, slot: null };
@@ -4072,6 +4217,15 @@ var init_codex = __esm({
       getEnv(thinkingOverrides) {
         return buildBaseEnv(thinkingOverrides);
       }
+      getEnvForSlot(slot) {
+        const env = this.getEnv();
+        if (slot.slotType === "api_key" && slot.apiKey) {
+          env.OPENAI_API_KEY = slot.apiKey;
+        } else if (slot.slotType === "oauth" && slot.configHome) {
+          env.CODEX_HOME = slot.configHome;
+        }
+        return env;
+      }
       applyThinkingConfig(level, _model) {
         if (level === "auto") return {};
         const mapped = level === "off" ? "low" : level === "extra_high" ? "xhigh" : level;
@@ -9778,11 +9932,11 @@ var init_evolve = __esm({
         const body = JSON.parse(await readBody(req));
         const { setReflectionStatus: setReflectionStatus2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
         const { existsSync: fileExists, readFileSync: fileRead } = await import("fs");
-        const { join: join28 } = await import("path");
+        const { join: join29 } = await import("path");
         const { CC_CLAW_HOME: home } = await Promise.resolve().then(() => (init_paths(), paths_exports));
         const chatId = body.chatId || (process.env.ALLOWED_CHAT_ID ?? "").split(",")[0]?.trim() || "default";
-        const soulPath = join28(home, "identity/SOUL.md");
-        const userPath = join28(home, "identity/USER.md");
+        const soulPath = join29(home, "identity/SOUL.md");
+        const userPath = join29(home, "identity/USER.md");
         const soul = fileExists(soulPath) ? fileRead(soulPath, "utf-8") : "";
         const user = fileExists(userPath) ? fileRead(userPath, "utf-8") : "";
         setReflectionStatus2(getDb(), chatId, "active", soul, user);
@@ -10572,6 +10726,53 @@ Partial output: ${accumulatedText.slice(-500)}`;
     });
   });
 }
+async function spawnWithSlotRotation(chatId, adapter, baseConfig, configWithSession, model2, cancelState, thinkingLevel, timeoutMs, maxTurns, opts, onSlotRotation) {
+  const slots = getEligibleBackendSlots(adapter.id);
+  if (slots.length === 0) {
+    return spawnQuery(adapter, configWithSession, model2, cancelState, thinkingLevel, timeoutMs, maxTurns, opts);
+  }
+  const maxAttempts = slots.length;
+  let lastError;
+  for (let i = 0; i < maxAttempts; i++) {
+    const slot = getNextBackendSlot(chatId, adapter.id);
+    if (!slot) break;
+    const slotLabel = slot.label || `slot-${slot.id}`;
+    log(`[agent:${adapter.id}-rotation] Trying ${slotLabel} (${slot.slotType}, attempt ${i + 1}/${maxAttempts})`);
+    if (i === 0) pinChatBackendSlot(chatId, adapter.id, slot.id);
+    const slotEnv = adapter.getEnvForSlot?.(slot) ?? adapter.getEnv();
+    const effectiveConfig = i === 0 ? configWithSession : baseConfig;
+    try {
+      const result = await spawnQuery(adapter, effectiveConfig, model2, cancelState, thinkingLevel, timeoutMs, maxTurns, { ...opts, envOverride: slotEnv });
+      markBackendSlotSuccess(slot.id);
+      return result;
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      if (/rate.?limit|too many requests|429|503|timeout/i.test(errMsg)) {
+        throw err;
+      }
+      const isExhausted = /quota|exhausted|exceeded|insufficient|credit|billing|unauthorized|forbidden|401|403/i.test(errMsg);
+      if (isExhausted) {
+        warn(`[agent:${adapter.id}-rotation] Slot ${slotLabel} exhausted: ${errMsg.slice(0, 200)}`);
+        markBackendSlotExhausted(slot.id, 6);
+        lastError = err instanceof Error ? err : new Error(errMsg);
+        try {
+          await summarizeWithFallbackChain(chatId, void 0, adapter.id);
+          clearSession(chatId);
+        } catch {
+        }
+        const nextSlot = getEligibleBackendSlots(adapter.id)[0];
+        if (nextSlot && onSlotRotation) {
+          const nextLabel = nextSlot.label || `slot-${nextSlot.id}`;
+          onSlotRotation(slotLabel, nextLabel);
+          pinChatBackendSlot(chatId, adapter.id, nextSlot.id);
+        }
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw lastError ?? new Error(`All ${adapter.id} credential slots exhausted`);
+}
 async function spawnGeminiWithRotation(chatId, adapter, baseConfig, configWithSession, model2, cancelState, thinkingLevel, timeoutMs, maxTurns, rotationMode, opts, onSlotRotation, parentChatId, onModelDowngrade) {
   const geminiAdapter = adapter;
   const slots = getEligibleGeminiSlots(rotationMode);
@@ -10579,14 +10780,14 @@ async function spawnGeminiWithRotation(chatId, adapter, baseConfig, configWithSe
     return spawnQuery(adapter, configWithSession, model2, cancelState, thinkingLevel, timeoutMs, maxTurns, opts);
   }
   if (parentChatId) {
-    const { env } = geminiAdapter.getEnvForSlot(parentChatId, void 0, rotationMode);
+    const { env } = geminiAdapter.resolveSlotEnv(parentChatId, void 0, rotationMode);
     return await spawnQuery(adapter, configWithSession, model2, cancelState, thinkingLevel, timeoutMs, maxTurns, { ...opts, envOverride: env });
   }
   const maxAttempts = slots.length;
   let lastError;
   let unknownRetried = false;
   for (let i = 0; i < maxAttempts; i++) {
-    const { env, slot } = geminiAdapter.getEnvForSlot(chatId, void 0, rotationMode);
+    const { env, slot } = geminiAdapter.resolveSlotEnv(chatId, void 0, rotationMode);
     if (!slot) break;
     const slotLabel = slot.label || `slot-${slot.id}`;
     log(`[agent:gemini-rotation] Trying ${slotLabel} (${slot.slotType}, attempt ${i + 1}/${maxAttempts})`);
@@ -10739,16 +10940,20 @@ async function askAgentImpl(chatId, userMessage, opts) {
   let result = { resultText: "", sessionId: void 0, input: 0, output: 0, cacheRead: 0, sawToolEvents: false, sawResultEvent: false };
   const rotationMode = adapter.id === "gemini" ? getGeminiRotationMode() : "off";
   const useGeminiRotation = rotationMode !== "off" && getEligibleGeminiSlots(rotationMode).length > 0;
+  const useBackendRotation = adapter.id !== "gemini" && getEligibleBackendSlots(adapter.id).length > 0;
   try {
     if (useGeminiRotation) {
       const rotationCb = onSlotRotation ? (from, to) => onSlotRotation(chatId, from, to) : void 0;
       const downgradeCb = onModelDowngrade ? (from, to, reason) => onModelDowngrade(chatId, from, to, reason) : void 0;
       result = await spawnGeminiWithRotation(chatId, adapter, baseConfig, configWithSession, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, rotationMode, spawnOpts, rotationCb, settingsSourceChatId, downgradeCb);
+    } else if (useBackendRotation) {
+      const rotationCb = onSlotRotation ? (from, to) => onSlotRotation(chatId, from, to) : void 0;
+      result = await spawnWithSlotRotation(chatId, adapter, baseConfig, configWithSession, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, spawnOpts, rotationCb);
     } else {
       const slotSpawnOpts = (() => {
         if (adapter.id !== "gemini") return spawnOpts;
         const geminiAdapter = adapter;
-        const { env, slot } = geminiAdapter.getEnvForSlot(chatId);
+        const { env, slot } = geminiAdapter.resolveSlotEnv(chatId);
         if (slot) {
           log(`[agent] rotation=off, using pinned slot: ${slot.label || `slot-${slot.id}`} (${slot.slotType})`);
           return { ...spawnOpts, envOverride: env };
@@ -10795,11 +11000,14 @@ async function askAgentImpl(chatId, userMessage, opts) {
         const rotationCb = onSlotRotation ? (from, to) => onSlotRotation(chatId, from, to) : void 0;
         const downgradeCb = onModelDowngrade ? (from, to, reason) => onModelDowngrade(chatId, from, to, reason) : void 0;
         result = await spawnGeminiWithRotation(chatId, adapter, baseConfig, baseConfig, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, rotationMode, spawnOpts, rotationCb, settingsSourceChatId, downgradeCb);
+      } else if (useBackendRotation) {
+        const rotationCb = onSlotRotation ? (from, to) => onSlotRotation(chatId, from, to) : void 0;
+        result = await spawnWithSlotRotation(chatId, adapter, baseConfig, baseConfig, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, spawnOpts, rotationCb);
       } else {
         const retryOpts = (() => {
           if (adapter.id !== "gemini") return spawnOpts;
           const geminiAdapter = adapter;
-          const { env, slot } = geminiAdapter.getEnvForSlot(chatId);
+          const { env, slot } = geminiAdapter.resolveSlotEnv(chatId);
           if (slot) return { ...spawnOpts, envOverride: env };
           return spawnOpts;
         })();
@@ -10815,11 +11023,14 @@ async function askAgentImpl(chatId, userMessage, opts) {
         const rotationCb = onSlotRotation ? (from, to) => onSlotRotation(chatId, from, to) : void 0;
         const downgradeCb = onModelDowngrade ? (from, to, reason) => onModelDowngrade(chatId, from, to, reason) : void 0;
         result = await spawnGeminiWithRotation(chatId, adapter, baseConfig, baseConfig, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, rotationMode, spawnOpts, rotationCb, settingsSourceChatId, downgradeCb);
+      } else if (useBackendRotation) {
+        const rotationCb = onSlotRotation ? (from, to) => onSlotRotation(chatId, from, to) : void 0;
+        result = await spawnWithSlotRotation(chatId, adapter, baseConfig, baseConfig, resolvedModel, cancelState, thinkingLevel, timeoutMs, maxTurns, spawnOpts, rotationCb);
       } else {
         const retryOpts = (() => {
           if (adapter.id !== "gemini") return spawnOpts;
           const geminiAdapter = adapter;
-          const { env, slot } = geminiAdapter.getEnvForSlot(chatId);
+          const { env, slot } = geminiAdapter.resolveSlotEnv(chatId);
           if (slot) return { ...spawnOpts, envOverride: env };
           return spawnOpts;
         })();
@@ -10944,6 +11155,7 @@ var init_agent = __esm({
     init_summarize();
     init_quota();
     init_store5();
+    init_store5();
     init_server();
     init_mcp_config();
     init_store5();
@@ -12812,7 +13024,10 @@ var init_helpers = __esm({
         { cmd: "/thinking", desc: "Adjust thinking level" },
         { cmd: "/permissions", desc: "Set permission mode" },
         { cmd: "/response_style", desc: "Set response verbosity" },
-        { cmd: "/model_signature", desc: "Toggle model signature" }
+        { cmd: "/model_signature", desc: "Toggle model signature" },
+        { cmd: "/gemini_accounts", desc: "Gemini credential slots" },
+        { cmd: "/claude_accounts", desc: "Claude credential slots" },
+        { cmd: "/codex_accounts", desc: "Codex credential slots" }
       ],
       Memory: [
         { cmd: "/memory", desc: "Browse stored memories" },
@@ -15687,13 +15902,13 @@ async function handleEvolveCallback(chatId, data, channel) {
       const { getReflectionStatus: getReflectionStatus2, setReflectionStatus: setReflectionStatus2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
       const current = getReflectionStatus2(getDb(), chatId);
       if (current === "frozen") {
-        const { readFileSync: readFileSync21, existsSync: existsSync48 } = await import("fs");
-        const { join: join28 } = await import("path");
+        const { readFileSync: readFileSync22, existsSync: existsSync49 } = await import("fs");
+        const { join: join29 } = await import("path");
         const { CC_CLAW_HOME: CC_CLAW_HOME3 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
-        const soulPath = join28(CC_CLAW_HOME3, "identity/SOUL.md");
-        const userPath = join28(CC_CLAW_HOME3, "identity/USER.md");
-        const soul = existsSync48(soulPath) ? readFileSync21(soulPath, "utf-8") : "";
-        const user = existsSync48(userPath) ? readFileSync21(userPath, "utf-8") : "";
+        const soulPath = join29(CC_CLAW_HOME3, "identity/SOUL.md");
+        const userPath = join29(CC_CLAW_HOME3, "identity/USER.md");
+        const soul = existsSync49(soulPath) ? readFileSync22(soulPath, "utf-8") : "";
+        const user = existsSync49(userPath) ? readFileSync22(userPath, "utf-8") : "";
         setReflectionStatus2(getDb(), chatId, "active", soul, user);
         const { logActivity: logActivity2 } = await Promise.resolve().then(() => (init_store3(), store_exports3));
         logActivity2(getDb(), { chatId, source: "telegram", eventType: "reflection_unfrozen", summary: "Reflection enabled" });
@@ -16036,14 +16251,28 @@ Tap to toggle:`,
       }
       const iStats = getIntentStats();
       const iTotal = iStats.chat + iStats.agentic;
-      let geminiSlotInfo = "";
+      let slotInfo = "";
       if ((backendId ?? "claude") === "gemini") {
         try {
           const active = getNextGeminiSlot(chatId);
           const totalSlots = getEligibleGeminiSlots().length;
           if (active) {
             const label2 = active.label || `slot-${active.id}`;
-            geminiSlotInfo = ` \xB7 \u{1F511} ${label2} (${totalSlots} slots)`;
+            slotInfo = ` \xB7 \u{1F511} ${label2} (${totalSlots} slots)`;
+          }
+        } catch {
+        }
+      } else if (backendId === "claude" || backendId === "codex") {
+        try {
+          const slots = getBackendSlots(backendId);
+          const enabledSlots = slots.filter((s) => s.enabled);
+          if (enabledSlots.length > 0) {
+            const pinnedId = getChatBackendSlotId(chatId, backendId);
+            const active = pinnedId ? slots.find((s) => s.id === pinnedId) : enabledSlots[0];
+            if (active) {
+              const label2 = active.label || `slot-${active.id}`;
+              slotInfo = ` \xB7 \u{1F511} ${label2} (${enabledSlots.length} slots)`;
+            }
           }
         } catch {
         }
@@ -16057,7 +16286,7 @@ Tap to toggle:`,
         `\u23F1 Uptime: ${uptimeStr}`,
         ``,
         buildSectionHeader("Engine"),
-        `\u{1F9E0} ${adapter?.displayName ?? backendId ?? "not set"} \xB7 ${formatModelShort(model2)}${geminiSlotInfo}`,
+        `\u{1F9E0} ${adapter?.displayName ?? backendId ?? "not set"} \xB7 ${formatModelShort(model2)}${slotInfo}`,
         `\u{1F4AD} Think: ${thinking2} \xB7 Mode: ${mode}`,
         `\u{1F916} Agents: ${getAgentMode(chatId)}`,
         `\u{1F507} Voice: ${voice2 ? "on" : "off"} \xB7 Sig: ${modelSig}`,
@@ -16176,6 +16405,42 @@ Use: /gemini_accounts <name> to pin`, { parseMode: "plain" });
       }
       break;
     }
+    case "claude_accounts":
+    case "codex_accounts": {
+      const slotBackend = command === "claude_accounts" ? "claude" : "codex";
+      const slotDisplayName = command === "claude_accounts" ? "Claude" : "Codex";
+      const slots = getBackendSlots(slotBackend);
+      if (slots.length === 0) {
+        await channel.sendText(chatId, `No ${slotDisplayName} credentials configured.
+Add with: <code>cc-claw ${slotBackend} add-key</code>`, { parseMode: "html" });
+        break;
+      }
+      if (typeof channel.sendKeyboard === "function") {
+        const pinnedSlotId = getChatBackendSlotId(chatId, slotBackend);
+        const slotButtons = slots.filter((s) => s.enabled).map((s) => {
+          const label2 = s.label || `slot-${s.id}`;
+          const icon = s.slotType === "oauth" ? "\u{1F468}\u{1F3FD}\u200D\u{1F4BB}" : "\u{1F511}";
+          const marker = pinnedSlotId === s.id ? " \u2713" : "";
+          return { label: `${icon} ${label2}${marker}`, data: `bslot:${slotBackend}:${s.id}` };
+        });
+        const rows = [];
+        for (let i = 0; i < slotButtons.length; i += 2) {
+          rows.push(slotButtons.slice(i, i + 2));
+        }
+        rows.push([{ label: "\u{1F504} Auto (rotation)", data: `bslot:${slotBackend}:auto` }]);
+        await channel.sendKeyboard(chatId, `${slotDisplayName} Accounts:`, rows);
+      } else {
+        const list = slots.filter((s) => s.enabled).map((s) => {
+          const icon = s.slotType === "oauth" ? "\u{1F468}\u{1F3FD}\u200D\u{1F4BB}" : "\u{1F511}";
+          return `${icon} ${s.label || `slot-${s.id}`} (#${s.id})`;
+        }).join("\n");
+        await channel.sendText(chatId, `${slotDisplayName} Slots:
+${list}
+
+Use: /${command} <name> to pin`, { parseMode: "plain" });
+      }
+      break;
+    }
     case "model": {
       let adapter;
       try {
@@ -17791,6 +18056,28 @@ ${rotationNote}`, { parseMode: "html" });
       await channel.sendKeyboard(chatId, "Gemini Accounts & Rotation:", rows);
     }
     return;
+  } else if (data.startsWith("bslot:")) {
+    const parts = data.split(":");
+    const backend2 = parts[1];
+    const val = parts[2];
+    const displayName = backend2 === "claude" ? "Claude" : "Codex";
+    if (val === "auto") {
+      clearChatBackendSlot(chatId, backend2);
+      clearSession(chatId);
+      await channel.sendText(chatId, `${displayName} slot set to <b>\u{1F504} auto rotation</b>.`, { parseMode: "html" });
+    } else {
+      const slotId = parseInt(val, 10);
+      const slots = getBackendSlots(backend2);
+      const slot = slots.find((s) => s.id === slotId);
+      if (slot) {
+        pinChatBackendSlot(chatId, backend2, slotId);
+        clearSession(chatId);
+        const label2 = slot.label || `slot-${slot.id}`;
+        const icon = slot.slotType === "oauth" ? "\u{1F468}\u{1F3FD}\u200D\u{1F4BB}" : "\u{1F511}";
+        await channel.sendText(chatId, `${icon} ${displayName} account set to <b>${label2}</b>`, { parseMode: "html" });
+      }
+    }
+    return;
   } else if (data.startsWith("shell:")) {
     const parts = data.split(":");
     const action = parts[1];
@@ -18549,6 +18836,12 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
           const slot = getGeminiSlots().find((s) => s.id === slotId);
           if (slot) slotTag = ` \xB7 ${slot.label || `slot-${slot.id}`}`;
         }
+      } else if (adapter.id === "claude" || adapter.id === "codex") {
+        const slotId = getChatBackendSlotId(chatId, adapter.id);
+        if (slotId) {
+          const slot = getBackendSlots(adapter.id).find((s) => s.id === slotId);
+          if (slot) slotTag = ` \xB7 ${slot.label || `slot-${slot.id}`}`;
+        }
       }
       responseText += `
 
@@ -19748,6 +20041,8 @@ var init_telegram2 = __esm({
           { command: "claude", description: "Switch to Claude backend" },
           { command: "gemini", description: "Switch to Gemini backend" },
           { command: "gemini_accounts", description: "Manage Gemini credentials & rotation" },
+          { command: "claude_accounts", description: "Manage Claude credentials & rotation" },
+          { command: "codex_accounts", description: "Manage Codex credentials & rotation" },
           { command: "codex", description: "Switch to Codex backend" },
           { command: "cursor", description: "Switch to Cursor backend" },
           { command: "model", description: "Switch model for active backend" },
@@ -21102,11 +21397,11 @@ async function main() {
   bootstrapSkills().catch((err) => error("[cc-claw] Skill bootstrap failed:", err));
   try {
     const { generateAiSkill: generateAiSkill2 } = await Promise.resolve().then(() => (init_ai_skill(), ai_skill_exports));
-    const { writeFileSync: writeFileSync12, mkdirSync: mkdirSync16 } = await import("fs");
-    const { join: join28 } = await import("path");
-    const skillDir = join28(SKILLS_PATH, "cc-claw-cli");
-    mkdirSync16(skillDir, { recursive: true });
-    writeFileSync12(join28(skillDir, "SKILL.md"), generateAiSkill2(), "utf-8");
+    const { writeFileSync: writeFileSync12, mkdirSync: mkdirSync17 } = await import("fs");
+    const { join: join29 } = await import("path");
+    const skillDir = join29(SKILLS_PATH, "cc-claw-cli");
+    mkdirSync17(skillDir, { recursive: true });
+    writeFileSync12(join29(skillDir, "SKILL.md"), generateAiSkill2(), "utf-8");
     log("[cc-claw] AI skill updated");
   } catch {
   }
@@ -21991,8 +22286,8 @@ async function doctorCommand(globalOpts, localOpts) {
   }
   if (existsSync25(ERROR_LOG_PATH)) {
     try {
-      const { readFileSync: readFileSync21 } = await import("fs");
-      const logContent = readFileSync21(ERROR_LOG_PATH, "utf-8");
+      const { readFileSync: readFileSync22 } = await import("fs");
+      const logContent = readFileSync22(ERROR_LOG_PATH, "utf-8");
       const recentLines = logContent.split("\n").filter(Boolean).slice(-100);
       const last24h = Date.now() - 864e5;
       const recentErrors = recentLines.filter((line) => {
@@ -22415,6 +22710,347 @@ var init_gemini2 = __esm({
   }
 });
 
+// src/cli/commands/backend-cmd-factory.ts
+var backend_cmd_factory_exports = {};
+__export(backend_cmd_factory_exports, {
+  makeAddAccount: () => makeAddAccount,
+  makeAddKey: () => makeAddKey,
+  makeDisable: () => makeDisable,
+  makeEnable: () => makeEnable,
+  makeList: () => makeList,
+  makeRefresh: () => makeRefresh,
+  makeRemove: () => makeRemove,
+  makeReorder: () => makeReorder,
+  registerBackendSlotCommands: () => registerBackendSlotCommands
+});
+import { existsSync as existsSync28, mkdirSync as mkdirSync13, readFileSync as readFileSync18 } from "fs";
+import { join as join26 } from "path";
+import { createInterface as createInterface6 } from "readline";
+function requireDb2() {
+  if (!existsSync28(DB_PATH)) {
+    outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
+    process.exit(1);
+  }
+}
+async function requireWriteDb2() {
+  requireDb2();
+  if (!dbInitialized2) {
+    const { initDatabase: initDatabase2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+    initDatabase2();
+    dbInitialized2 = true;
+  }
+}
+async function resolveSlotId2(backend2, idOrLabel) {
+  const numeric = parseInt(idOrLabel, 10);
+  if (!isNaN(numeric)) return numeric;
+  const { getBackendSlots: getBackendSlots2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+  const match = getBackendSlots2(backend2).find(
+    (s) => s.label?.toLowerCase() === idOrLabel.toLowerCase()
+  );
+  return match?.id ?? null;
+}
+function makeList(backend2, displayName) {
+  return async function list(_globalOpts) {
+    requireDb2();
+    const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+    const readDb = openDatabaseReadOnly2();
+    const slots = readDb.prepare(`
+      SELECT id, slot_type, label, config_home, priority, enabled, cooldown_until, last_used, consecutive_errors, created_at
+      FROM backend_credentials WHERE backend = ? ORDER BY priority ASC, id ASC
+    `).all(backend2);
+    readDb.close();
+    if (slots.length === 0) {
+      output({ slots: [] }, () => `No ${displayName} credential slots configured.
+Add one with: cc-claw ${backend2} add-account  or  cc-claw ${backend2} add-key`);
+      return;
+    }
+    output(slots, (data) => {
+      const list2 = data;
+      const lines = ["", divider(`${displayName} Credential Slots`), ""];
+      for (const s of list2) {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const inCooldown = s.cooldown_until && s.cooldown_until > now;
+        const icon = !s.enabled ? error2("\u25CB disabled") : inCooldown ? warning("\u25D1 cooldown") : success("\u25CF active");
+        const label2 = s.label || `slot-${s.id}`;
+        const type = s.slot_type === "oauth" ? "\u{1F468}\u{1F3FD}\u200D\u{1F4BB}" : "\u{1F511}";
+        lines.push(`  ${icon}  ${label2} ${muted(`(${type}, #${s.id}, priority ${s.priority})`)}`);
+        if (inCooldown) lines.push(`         Cooldown until: ${warning(s.cooldown_until)}`);
+        if (s.consecutive_errors > 0) lines.push(`         Consecutive errors: ${warning(String(s.consecutive_errors))}`);
+        if (s.last_used) lines.push(`         Last used: ${muted(s.last_used)}`);
+      }
+      lines.push("");
+      return lines.join("\n");
+    });
+  };
+}
+function makeAddKey(backend2, displayName) {
+  return async function addKey(_globalOpts, opts) {
+    await requireWriteDb2();
+    const rl2 = createInterface6({ input: process.stdin, output: process.stdout });
+    const ask2 = (q) => new Promise((r) => rl2.question(q, r));
+    const key = await ask2(`Paste your ${displayName} API key: `);
+    rl2.close();
+    if (!key.trim()) {
+      outputError("EMPTY_KEY", "No key provided.");
+      process.exit(1);
+    }
+    const { addBackendSlot: addBackendSlot2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+    const id = addBackendSlot2({
+      backend: backend2,
+      slotType: "api_key",
+      label: opts.label,
+      apiKey: key.trim(),
+      priority: opts.priority ? parseInt(opts.priority, 10) : 0
+    });
+    output(
+      { id, type: "api_key", backend: backend2, label: opts.label ?? null },
+      () => success(`Added ${displayName} API key slot #${id}${opts.label ? ` (${opts.label})` : ""}`)
+    );
+  };
+}
+function makeAddAccount(backend2, displayName) {
+  return async function addAccount(_globalOpts, opts) {
+    const config2 = ADD_ACCOUNT_CONFIGS[backend2];
+    if (!config2) {
+      outputError("UNSUPPORTED", `add-account is not supported for ${displayName}. Use add-key instead.`);
+      process.exit(1);
+    }
+    await requireWriteDb2();
+    const slotsDir = join26(CC_CLAW_HOME, config2.slotsSubdir);
+    if (!existsSync28(slotsDir)) mkdirSync13(slotsDir, { recursive: true });
+    const tempId = Date.now();
+    const slotDir = join26(slotsDir, `slot-${tempId}`);
+    mkdirSync13(slotDir, { recursive: true, mode: 448 });
+    if (config2.preSetup) config2.preSetup(slotDir);
+    console.log("");
+    console.log(`  Opening ${displayName} CLI for sign-in...`);
+    console.log(`  Sign in with the account you want for this slot.`);
+    console.log(`  After sign-in completes, return here.`);
+    console.log("");
+    const { execSync: execSync8 } = await import("child_process");
+    const loginEnv = {
+      ...process.env,
+      [config2.envKey]: config2.envValue(slotDir),
+      ...config2.envOverrides
+    };
+    try {
+      execSync8(config2.loginCommand.join(" "), {
+        stdio: "inherit",
+        env: loginEnv,
+        cwd: slotDir
+      });
+    } catch {
+    }
+    if (!config2.verifyCredentials(slotDir)) {
+      console.log(error2(`
+  No credentials found. Sign-in may have failed.`));
+      console.log(`  The slot directory is preserved at: ${slotDir}`);
+      console.log(`  Re-run: cc-claw ${backend2} add-account
+`);
+      process.exit(1);
+    }
+    const accountLabel = opts.label || config2.extractLabel(slotDir);
+    const { addBackendSlot: addBackendSlot2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+    const id = addBackendSlot2({
+      backend: backend2,
+      slotType: "oauth",
+      label: accountLabel,
+      configHome: slotDir,
+      priority: opts.priority ? parseInt(opts.priority, 10) : 0
+    });
+    output(
+      { id, type: "oauth", backend: backend2, label: accountLabel, configHome: slotDir },
+      () => success(`Added ${displayName} subscription slot #${id} (${accountLabel})`)
+    );
+  };
+}
+function makeRemove(backend2, displayName) {
+  return async function remove(_globalOpts, idOrLabel) {
+    await requireWriteDb2();
+    const slotId = await resolveSlotId2(backend2, idOrLabel);
+    if (!slotId) {
+      outputError("NOT_FOUND", `Slot "${idOrLabel}" not found.`);
+      return;
+    }
+    const { removeBackendSlot: removeBackendSlot2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+    const removed = removeBackendSlot2(slotId);
+    if (removed) {
+      output({ removed: true, id: slotId }, () => success(`Removed slot "${idOrLabel}" (#${slotId})`));
+    } else {
+      outputError("NOT_FOUND", `Slot "${idOrLabel}" not found.`);
+    }
+  };
+}
+function makeEnable(backend2, _displayName) {
+  return async function enable(_globalOpts, idOrLabel) {
+    await requireWriteDb2();
+    const slotId = await resolveSlotId2(backend2, idOrLabel);
+    if (!slotId) {
+      outputError("NOT_FOUND", `Slot "${idOrLabel}" not found.`);
+      return;
+    }
+    const { setBackendSlotEnabled: setBackendSlotEnabled2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+    setBackendSlotEnabled2(slotId, true);
+    output({ id: slotId, enabled: true }, () => success(`Enabled slot "${idOrLabel}" (#${slotId})`));
+  };
+}
+function makeDisable(backend2, _displayName) {
+  return async function disable(_globalOpts, idOrLabel) {
+    await requireWriteDb2();
+    const slotId = await resolveSlotId2(backend2, idOrLabel);
+    if (!slotId) {
+      outputError("NOT_FOUND", `Slot "${idOrLabel}" not found.`);
+      return;
+    }
+    const { setBackendSlotEnabled: setBackendSlotEnabled2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+    setBackendSlotEnabled2(slotId, false);
+    output({ id: slotId, enabled: false }, () => warning(`Disabled slot "${idOrLabel}" (#${slotId})`));
+  };
+}
+function makeReorder(backend2, _displayName) {
+  return async function reorder(_globalOpts, idOrLabel, priority) {
+    await requireWriteDb2();
+    const slotId = await resolveSlotId2(backend2, idOrLabel);
+    if (!slotId) {
+      outputError("NOT_FOUND", `Slot "${idOrLabel}" not found.`);
+      return;
+    }
+    const { reorderBackendSlot: reorderBackendSlot2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+    reorderBackendSlot2(slotId, parseInt(priority, 10));
+    output(
+      { id: slotId, priority: parseInt(priority, 10) },
+      () => success(`Slot "${idOrLabel}" (#${slotId}) priority set to ${priority}`)
+    );
+  };
+}
+function makeRefresh(backend2, displayName) {
+  return async function refresh(_globalOpts) {
+    await requireWriteDb2();
+    const { getBackendSlots: getBackendSlots2, reenableBackendSlot: reenableBackendSlot2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+    const slots = getBackendSlots2(backend2);
+    let count = 0;
+    for (const s of slots) {
+      if (!s.enabled || s.cooldownUntil || s.consecutiveErrors > 0) {
+        reenableBackendSlot2(s.id);
+        count++;
+      }
+    }
+    output(
+      { refreshed: count },
+      () => count > 0 ? success(`Refreshed ${count} ${displayName} slot(s) \u2014 cooldowns cleared, errors reset`) : `All ${displayName} slots are already healthy.`
+    );
+  };
+}
+function registerBackendSlotCommands(parentCommand, backend2, displayName, globalOpts) {
+  const cmd = parentCommand.command(backend2).description(`Manage ${displayName} credential slots`);
+  cmd.command("list").description(`Show all configured ${displayName} credential slots`).action(async () => {
+    await makeList(backend2, displayName)(globalOpts());
+  });
+  cmd.command("add-key").description("Add an API key slot (prompts for key in terminal)").option("--label <name>", "Friendly label for this slot").option("--priority <n>", "Priority (lower = preferred)", "0").action(async (opts) => {
+    await makeAddKey(backend2, displayName)(globalOpts(), opts);
+  });
+  cmd.command("remove <id-or-label>").description("Remove a credential slot (by ID or label)").action(async (id) => {
+    await makeRemove(backend2, displayName)(globalOpts(), id);
+  });
+  cmd.command("enable <id-or-label>").description("Re-enable a disabled slot").action(async (id) => {
+    await makeEnable(backend2, displayName)(globalOpts(), id);
+  });
+  cmd.command("disable <id-or-label>").description("Disable a slot").action(async (id) => {
+    await makeDisable(backend2, displayName)(globalOpts(), id);
+  });
+  cmd.command("reorder <id-or-label> <priority>").description("Set slot priority (lower = preferred)").action(async (id, priority) => {
+    await makeReorder(backend2, displayName)(globalOpts(), id, priority);
+  });
+  cmd.command("refresh").description("Re-enable all slots, clear cooldowns and errors").action(async () => {
+    await makeRefresh(backend2, displayName)(globalOpts());
+  });
+  return cmd;
+}
+var dbInitialized2, ADD_ACCOUNT_CONFIGS;
+var init_backend_cmd_factory = __esm({
+  "src/cli/commands/backend-cmd-factory.ts"() {
+    "use strict";
+    init_format2();
+    init_paths();
+    dbInitialized2 = false;
+    ADD_ACCOUNT_CONFIGS = {
+      claude: {
+        slotsSubdir: "claude-slots",
+        loginCommand: ["claude", "auth", "login", "--claudeai"],
+        envKey: "HOME",
+        envValue: (slotDir) => slotDir,
+        envOverrides: { ANTHROPIC_API_KEY: void 0 },
+        preSetup: (slotDir) => {
+          mkdirSync13(join26(slotDir, ".claude"), { recursive: true });
+        },
+        verifyCredentials: (slotDir) => {
+          const claudeJson = join26(slotDir, ".claude.json");
+          const claudeJsonNested = join26(slotDir, ".claude", ".claude.json");
+          if (existsSync28(claudeJson)) {
+            try {
+              const data = JSON.parse(readFileSync18(claudeJson, "utf-8"));
+              return Boolean(data.oauthAccount);
+            } catch {
+              return false;
+            }
+          }
+          if (existsSync28(claudeJsonNested)) {
+            try {
+              const data = JSON.parse(readFileSync18(claudeJsonNested, "utf-8"));
+              return Boolean(data.oauthAccount);
+            } catch {
+              return false;
+            }
+          }
+          return false;
+        },
+        extractLabel: (slotDir) => {
+          try {
+            const { execSync: execSync8 } = __require("child_process");
+            const out = execSync8("claude auth status", {
+              encoding: "utf-8",
+              env: { ...process.env, HOME: slotDir, ANTHROPIC_API_KEY: void 0 },
+              timeout: 1e4
+            });
+            const parsed = JSON.parse(out);
+            if (parsed.email) return parsed.email;
+          } catch {
+          }
+          try {
+            const claudeJson = join26(slotDir, ".claude.json");
+            if (existsSync28(claudeJson)) {
+              const data = JSON.parse(readFileSync18(claudeJson, "utf-8"));
+              if (data.oauthAccount?.emailAddress) return data.oauthAccount.emailAddress;
+            }
+          } catch {
+          }
+          return "subscription";
+        }
+      },
+      codex: {
+        slotsSubdir: "codex-slots",
+        loginCommand: ["codex", "login"],
+        envKey: "CODEX_HOME",
+        envValue: (slotDir) => slotDir,
+        envOverrides: { OPENAI_API_KEY: void 0 },
+        verifyCredentials: (slotDir) => {
+          return existsSync28(join26(slotDir, "auth.json"));
+        },
+        extractLabel: (slotDir) => {
+          try {
+            const authData = JSON.parse(readFileSync18(join26(slotDir, "auth.json"), "utf-8"));
+            if (authData.email) return authData.email;
+            if (authData.account_name) return authData.account_name;
+            if (authData.user?.email) return authData.user.email;
+          } catch {
+          }
+          return "subscription";
+        }
+      }
+    };
+  }
+});
+
 // src/cli/commands/backend.ts
 var backend_exports = {};
 __export(backend_exports, {
@@ -22422,12 +23058,12 @@ __export(backend_exports, {
   backendList: () => backendList,
   backendSet: () => backendSet
 });
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 async function backendList(globalOpts) {
   const { getAvailableAdapters: getAvailableAdapters3 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
   const chatId = resolveChatId(globalOpts);
   let activeBackend = null;
-  if (existsSync28(DB_PATH)) {
+  if (existsSync29(DB_PATH)) {
     const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
     const readDb = openDatabaseReadOnly2();
     try {
@@ -22458,7 +23094,7 @@ async function backendList(globalOpts) {
 }
 async function backendGet(globalOpts) {
   const chatId = resolveChatId(globalOpts);
-  if (!existsSync28(DB_PATH)) {
+  if (!existsSync29(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -22502,13 +23138,13 @@ __export(model_exports, {
   modelList: () => modelList,
   modelSet: () => modelSet
 });
-import { existsSync as existsSync29 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 async function modelList(globalOpts) {
   const chatId = resolveChatId(globalOpts);
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const { getAdapter: getAdapter4, getAllAdapters: getAllAdapters5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
   let backendId = "claude";
-  if (existsSync29(DB_PATH)) {
+  if (existsSync30(DB_PATH)) {
     const readDb = openDatabaseReadOnly2();
     try {
       const row = readDb.prepare("SELECT backend FROM chat_backend WHERE chat_id = ?").get(chatId);
@@ -22541,7 +23177,7 @@ async function modelList(globalOpts) {
 }
 async function modelGet(globalOpts) {
   const chatId = resolveChatId(globalOpts);
-  if (!existsSync29(DB_PATH)) {
+  if (!existsSync30(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -22585,9 +23221,9 @@ __export(memory_exports2, {
   memoryList: () => memoryList,
   memorySearch: () => memorySearch
 });
-import { existsSync as existsSync30 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 async function memoryList(globalOpts) {
-  if (!existsSync30(DB_PATH)) {
+  if (!existsSync31(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -22611,7 +23247,7 @@ async function memoryList(globalOpts) {
   });
 }
 async function memorySearch(globalOpts, query) {
-  if (!existsSync30(DB_PATH)) {
+  if (!existsSync31(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -22633,7 +23269,7 @@ async function memorySearch(globalOpts, query) {
   });
 }
 async function memoryHistory(globalOpts, opts) {
-  if (!existsSync30(DB_PATH)) {
+  if (!existsSync31(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -22681,7 +23317,7 @@ __export(cron_exports2, {
   cronList: () => cronList,
   cronRuns: () => cronRuns
 });
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync32 } from "fs";
 function parseFallbacks(raw) {
   return raw.slice(0, 3).map((f) => {
     const [backend2, ...rest] = f.split(":");
@@ -22702,7 +23338,7 @@ function parseAndValidateTimeout(raw) {
   return val;
 }
 async function cronList(globalOpts) {
-  if (!existsSync31(DB_PATH)) {
+  if (!existsSync32(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -22740,7 +23376,7 @@ async function cronList(globalOpts) {
   });
 }
 async function cronHealth(globalOpts) {
-  if (!existsSync31(DB_PATH)) {
+  if (!existsSync32(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -22899,7 +23535,7 @@ async function cronEdit(globalOpts, id, opts) {
   }
 }
 async function cronRuns(globalOpts, jobId, opts) {
-  if (!existsSync31(DB_PATH)) {
+  if (!existsSync32(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -22946,9 +23582,9 @@ __export(agents_exports, {
   runnersList: () => runnersList,
   tasksList: () => tasksList
 });
-import { existsSync as existsSync32 } from "fs";
+import { existsSync as existsSync33 } from "fs";
 async function agentsList(globalOpts) {
-  if (!existsSync32(DB_PATH)) {
+  if (!existsSync33(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -22979,7 +23615,7 @@ async function agentsList(globalOpts) {
   });
 }
 async function tasksList(globalOpts) {
-  if (!existsSync32(DB_PATH)) {
+  if (!existsSync33(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -23107,10 +23743,10 @@ __export(db_exports, {
   dbPath: () => dbPath,
   dbStats: () => dbStats
 });
-import { existsSync as existsSync33, statSync as statSync8, copyFileSync as copyFileSync2, mkdirSync as mkdirSync13 } from "fs";
+import { existsSync as existsSync34, statSync as statSync8, copyFileSync as copyFileSync2, mkdirSync as mkdirSync14 } from "fs";
 import { dirname as dirname5 } from "path";
 async function dbStats(globalOpts) {
-  if (!existsSync33(DB_PATH)) {
+  if (!existsSync34(DB_PATH)) {
     outputError("DB_NOT_FOUND", `Database not found at ${DB_PATH}`);
     process.exit(1);
   }
@@ -23118,7 +23754,7 @@ async function dbStats(globalOpts) {
   const readDb = openDatabaseReadOnly2();
   const mainSize = statSync8(DB_PATH).size;
   const walPath = DB_PATH + "-wal";
-  const walSize = existsSync33(walPath) ? statSync8(walPath).size : 0;
+  const walSize = existsSync34(walPath) ? statSync8(walPath).size : 0;
   const tableNames = readDb.prepare(
     "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '%_fts%' ORDER BY name"
   ).all();
@@ -23152,16 +23788,16 @@ async function dbPath(globalOpts) {
   output({ path: DB_PATH }, (d) => d.path);
 }
 async function dbBackup(globalOpts, destPath) {
-  if (!existsSync33(DB_PATH)) {
+  if (!existsSync34(DB_PATH)) {
     outputError("DB_NOT_FOUND", `Database not found at ${DB_PATH}`);
     process.exit(1);
   }
   const dest = destPath ?? `${DB_PATH}.backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
   try {
-    mkdirSync13(dirname5(dest), { recursive: true });
+    mkdirSync14(dirname5(dest), { recursive: true });
     copyFileSync2(DB_PATH, dest);
     const walPath = DB_PATH + "-wal";
-    if (existsSync33(walPath)) copyFileSync2(walPath, dest + "-wal");
+    if (existsSync34(walPath)) copyFileSync2(walPath, dest + "-wal");
     output({ path: dest, sizeBytes: statSync8(dest).size }, (d) => {
       const b = d;
       return `
@@ -23190,9 +23826,9 @@ __export(usage_exports, {
   usageCost: () => usageCost,
   usageTokens: () => usageTokens
 });
-import { existsSync as existsSync34 } from "fs";
+import { existsSync as existsSync35 } from "fs";
 function ensureDb() {
-  if (!existsSync34(DB_PATH)) {
+  if (!existsSync35(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -23382,9 +24018,9 @@ __export(config_exports2, {
   configList: () => configList,
   configSet: () => configSet
 });
-import { existsSync as existsSync35, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync36, readFileSync as readFileSync19 } from "fs";
 async function configList(globalOpts) {
-  if (!existsSync35(DB_PATH)) {
+  if (!existsSync36(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -23418,7 +24054,7 @@ async function configGet(globalOpts, key) {
     outputError("INVALID_KEY", `Unknown config key "${key}". Valid keys: ${RUNTIME_KEYS.join(", ")}`);
     process.exit(1);
   }
-  if (!existsSync35(DB_PATH)) {
+  if (!existsSync36(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -23464,11 +24100,11 @@ async function configSet(globalOpts, key, value) {
   }
 }
 async function configEnv(_globalOpts) {
-  if (!existsSync35(ENV_PATH)) {
+  if (!existsSync36(ENV_PATH)) {
     outputError("ENV_NOT_FOUND", `No .env file at ${ENV_PATH}. Run cc-claw setup.`);
     process.exit(1);
   }
-  const content = readFileSync18(ENV_PATH, "utf-8");
+  const content = readFileSync19(ENV_PATH, "utf-8");
   const entries = {};
   const secretPatterns = /TOKEN|KEY|SECRET|PASSWORD|CREDENTIALS/i;
   for (const line of content.split("\n")) {
@@ -23518,9 +24154,9 @@ __export(session_exports, {
   sessionGet: () => sessionGet,
   sessionNew: () => sessionNew
 });
-import { existsSync as existsSync36 } from "fs";
+import { existsSync as existsSync37 } from "fs";
 async function sessionGet(globalOpts) {
-  if (!existsSync36(DB_PATH)) {
+  if (!existsSync37(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -23581,9 +24217,9 @@ __export(permissions_exports, {
   verboseGet: () => verboseGet,
   verboseSet: () => verboseSet
 });
-import { existsSync as existsSync37 } from "fs";
+import { existsSync as existsSync38 } from "fs";
 function ensureDb2() {
-  if (!existsSync37(DB_PATH)) {
+  if (!existsSync38(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -23730,9 +24366,9 @@ __export(cwd_exports, {
   cwdGet: () => cwdGet,
   cwdSet: () => cwdSet
 });
-import { existsSync as existsSync38 } from "fs";
+import { existsSync as existsSync39 } from "fs";
 async function cwdGet(globalOpts) {
-  if (!existsSync38(DB_PATH)) {
+  if (!existsSync39(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -23794,9 +24430,9 @@ __export(voice_exports, {
   voiceGet: () => voiceGet,
   voiceSet: () => voiceSet
 });
-import { existsSync as existsSync39 } from "fs";
+import { existsSync as existsSync40 } from "fs";
 async function voiceGet(globalOpts) {
-  if (!existsSync39(DB_PATH)) {
+  if (!existsSync40(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -23845,9 +24481,9 @@ __export(heartbeat_exports, {
   heartbeatGet: () => heartbeatGet,
   heartbeatSet: () => heartbeatSet
 });
-import { existsSync as existsSync40 } from "fs";
+import { existsSync as existsSync41 } from "fs";
 async function heartbeatGet(globalOpts) {
-  if (!existsSync40(DB_PATH)) {
+  if (!existsSync41(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -23956,9 +24592,9 @@ __export(summarizer_exports, {
   summarizerGet: () => summarizerGet,
   summarizerSet: () => summarizerSet
 });
-import { existsSync as existsSync41 } from "fs";
+import { existsSync as existsSync42 } from "fs";
 async function summarizerGet(globalOpts) {
-  if (!existsSync41(DB_PATH)) {
+  if (!existsSync42(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -24002,9 +24638,9 @@ __export(thinking_exports, {
   thinkingGet: () => thinkingGet,
   thinkingSet: () => thinkingSet
 });
-import { existsSync as existsSync42 } from "fs";
+import { existsSync as existsSync43 } from "fs";
 async function thinkingGet(globalOpts) {
-  if (!existsSync42(DB_PATH)) {
+  if (!existsSync43(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -24048,9 +24684,9 @@ __export(chats_exports, {
   chatsList: () => chatsList,
   chatsRemoveAlias: () => chatsRemoveAlias
 });
-import { existsSync as existsSync43 } from "fs";
+import { existsSync as existsSync44 } from "fs";
 async function chatsList(_globalOpts) {
-  if (!existsSync43(DB_PATH)) {
+  if (!existsSync44(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -24178,9 +24814,9 @@ var mcps_exports2 = {};
 __export(mcps_exports2, {
   mcpsList: () => mcpsList
 });
-import { existsSync as existsSync44 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 async function mcpsList(_globalOpts) {
-  if (!existsSync44(DB_PATH)) {
+  if (!existsSync45(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -24217,11 +24853,11 @@ __export(chat_exports2, {
   chatSend: () => chatSend
 });
 import { request as httpRequest2 } from "http";
-import { readFileSync as readFileSync19, existsSync as existsSync45 } from "fs";
+import { readFileSync as readFileSync20, existsSync as existsSync46 } from "fs";
 function getToken2() {
   if (process.env.CC_CLAW_API_TOKEN) return process.env.CC_CLAW_API_TOKEN;
   try {
-    if (existsSync45(TOKEN_PATH2)) return readFileSync19(TOKEN_PATH2, "utf-8").trim();
+    if (existsSync46(TOKEN_PATH2)) return readFileSync20(TOKEN_PATH2, "utf-8").trim();
   } catch {
   }
   return null;
@@ -24358,7 +24994,7 @@ var tui_exports = {};
 __export(tui_exports, {
   tuiCommand: () => tuiCommand
 });
-import { createInterface as createInterface6 } from "readline";
+import { createInterface as createInterface7 } from "readline";
 import pc2 from "picocolors";
 async function tuiCommand(globalOpts, cmdOpts) {
   const { isDaemonRunning: isDaemonRunning2, apiPost: apiPost2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
@@ -24368,7 +25004,7 @@ async function tuiCommand(globalOpts, cmdOpts) {
   }
   const chatId = resolveChatId(globalOpts);
   const { chatSend: chatSend2 } = await Promise.resolve().then(() => (init_chat2(), chat_exports2));
-  const rl2 = createInterface6({
+  const rl2 = createInterface7({
     input: process.stdin,
     output: process.stdout,
     prompt: pc2.cyan("you > "),
@@ -24500,8 +25136,8 @@ var completion_exports = {};
 __export(completion_exports, {
   completionCommand: () => completionCommand
 });
-import { writeFileSync as writeFileSync10, mkdirSync as mkdirSync14 } from "fs";
-import { join as join26 } from "path";
+import { writeFileSync as writeFileSync10, mkdirSync as mkdirSync15 } from "fs";
+import { join as join27 } from "path";
 import { homedir as homedir9 } from "os";
 async function completionCommand(opts) {
   const shell = opts.shell ?? detectShell();
@@ -24517,10 +25153,10 @@ async function completionCommand(opts) {
     process.exit(1);
   }
   if (opts.install) {
-    const dir = join26(homedir9(), ".config", "cc-claw", "completions");
-    mkdirSync14(dir, { recursive: true });
+    const dir = join27(homedir9(), ".config", "cc-claw", "completions");
+    mkdirSync15(dir, { recursive: true });
     const filename = shell === "zsh" ? "_cc-claw" : shell === "fish" ? "cc-claw.fish" : "cc-claw.bash";
-    const filepath = join26(dir, filename);
+    const filepath = join27(dir, filename);
     writeFileSync10(filepath, script, "utf-8");
     console.log(`\u2713 Completion script written to ${filepath}
 `);
@@ -24691,9 +25327,9 @@ __export(evolve_exports2, {
   evolveStatus: () => evolveStatus,
   evolveUndo: () => evolveUndo
 });
-import { existsSync as existsSync46 } from "fs";
+import { existsSync as existsSync47 } from "fs";
 function ensureDb3() {
-  if (!existsSync46(DB_PATH)) {
+  if (!existsSync47(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -25109,10 +25745,10 @@ var init_evolve3 = __esm({
 
 // src/setup.ts
 var setup_exports = {};
-import { existsSync as existsSync47, writeFileSync as writeFileSync11, readFileSync as readFileSync20, copyFileSync as copyFileSync3, mkdirSync as mkdirSync15, statSync as statSync9 } from "fs";
+import { existsSync as existsSync48, writeFileSync as writeFileSync11, readFileSync as readFileSync21, copyFileSync as copyFileSync3, mkdirSync as mkdirSync16, statSync as statSync9 } from "fs";
 import { execFileSync as execFileSync5 } from "child_process";
-import { createInterface as createInterface7 } from "readline";
-import { join as join27 } from "path";
+import { createInterface as createInterface8 } from "readline";
+import { join as join28 } from "path";
 function divider2() {
   console.log(dim("\u2500".repeat(55)));
 }
@@ -25187,21 +25823,21 @@ async function setup() {
   }
   console.log("");
   for (const dir of [CC_CLAW_HOME, DATA_PATH, LOGS_PATH, SKILLS_PATH, RUNNERS_PATH, AGENTS_PATH]) {
-    if (!existsSync47(dir)) mkdirSync15(dir, { recursive: true });
+    if (!existsSync48(dir)) mkdirSync16(dir, { recursive: true });
   }
   const env = {};
-  const envSource = existsSync47(ENV_PATH) ? ENV_PATH : existsSync47(".env") ? ".env" : null;
+  const envSource = existsSync48(ENV_PATH) ? ENV_PATH : existsSync48(".env") ? ".env" : null;
   if (envSource) {
     console.log(yellow(`  Found existing config at ${envSource} \u2014 your values will be preserved`));
     console.log(yellow("  unless you enter new ones. Just press Enter to keep existing values.\n"));
-    const existing = readFileSync20(envSource, "utf-8");
+    const existing = readFileSync21(envSource, "utf-8");
     for (const line of existing.split("\n")) {
       const match = line.match(/^([^#=]+)=(.*)$/);
       if (match) env[match[1].trim()] = match[2].trim();
     }
   }
-  const cwdDb = join27(process.cwd(), "cc-claw.db");
-  if (existsSync47(cwdDb) && !existsSync47(DB_PATH)) {
+  const cwdDb = join28(process.cwd(), "cc-claw.db");
+  if (existsSync48(cwdDb) && !existsSync48(DB_PATH)) {
     const { size } = statSync9(cwdDb);
     console.log(yellow(`  Found existing database at ${cwdDb} (${(size / 1024).toFixed(0)}KB)`));
     const migrate = await confirm("Copy database to ~/.cc-claw/? (preserves memories & history)", true);
@@ -25474,7 +26110,7 @@ var init_setup = __esm({
   "src/setup.ts"() {
     "use strict";
     init_paths();
-    rl = createInterface7({ input: process.stdin, output: process.stdout });
+    rl = createInterface8({ input: process.stdin, output: process.stdout });
     ask = (q) => new Promise((resolve) => rl.question(q, resolve));
     bold = (s) => `\x1B[1m${s}\x1B[0m`;
     green = (s) => `\x1B[32m${s}\x1B[0m`;
@@ -25576,6 +26212,43 @@ gemini.command("rotation [mode]").description("Get or set rotation mode (off, al
   const { geminiRotation: geminiRotation2 } = await Promise.resolve().then(() => (init_gemini2(), gemini_exports));
   await geminiRotation2(program.opts(), mode);
 });
+function registerUnifiedSlotCommands(parentCmd, backendId, displayName) {
+  const cmd = parentCmd.command(backendId).description(`Manage ${displayName} credential slots`);
+  cmd.command("list").description(`Show all configured ${displayName} credential slots`).action(async () => {
+    const { makeList: makeList2 } = await Promise.resolve().then(() => (init_backend_cmd_factory(), backend_cmd_factory_exports));
+    await makeList2(backendId, displayName)(program.opts());
+  });
+  cmd.command("add-key").description("Add an API key slot (prompts for key in terminal)").option("--label <name>", "Friendly label for this slot").option("--priority <n>", "Priority (lower = preferred)", "0").action(async (opts) => {
+    const { makeAddKey: makeAddKey2 } = await Promise.resolve().then(() => (init_backend_cmd_factory(), backend_cmd_factory_exports));
+    await makeAddKey2(backendId, displayName)(program.opts(), opts);
+  });
+  cmd.command("add-account").description("Add a subscription/OAuth slot (opens browser for sign-in)").option("--label <name>", "Friendly label for this slot").option("--priority <n>", "Priority (lower = preferred)", "0").action(async (opts) => {
+    const { makeAddAccount: makeAddAccount2 } = await Promise.resolve().then(() => (init_backend_cmd_factory(), backend_cmd_factory_exports));
+    await makeAddAccount2(backendId, displayName)(program.opts(), opts);
+  });
+  cmd.command("remove <id-or-label>").description("Remove a credential slot (by ID or label)").action(async (id) => {
+    const { makeRemove: makeRemove2 } = await Promise.resolve().then(() => (init_backend_cmd_factory(), backend_cmd_factory_exports));
+    await makeRemove2(backendId, displayName)(program.opts(), id);
+  });
+  cmd.command("enable <id-or-label>").description("Re-enable a disabled slot").action(async (id) => {
+    const { makeEnable: makeEnable2 } = await Promise.resolve().then(() => (init_backend_cmd_factory(), backend_cmd_factory_exports));
+    await makeEnable2(backendId, displayName)(program.opts(), id);
+  });
+  cmd.command("disable <id-or-label>").description("Disable a slot").action(async (id) => {
+    const { makeDisable: makeDisable2 } = await Promise.resolve().then(() => (init_backend_cmd_factory(), backend_cmd_factory_exports));
+    await makeDisable2(backendId, displayName)(program.opts(), id);
+  });
+  cmd.command("reorder <id-or-label> <priority>").description("Set slot priority (lower = preferred)").action(async (id, priority) => {
+    const { makeReorder: makeReorder2 } = await Promise.resolve().then(() => (init_backend_cmd_factory(), backend_cmd_factory_exports));
+    await makeReorder2(backendId, displayName)(program.opts(), id, priority);
+  });
+  cmd.command("refresh").description("Re-enable all slots, clear cooldowns and errors").action(async () => {
+    const { makeRefresh: makeRefresh2 } = await Promise.resolve().then(() => (init_backend_cmd_factory(), backend_cmd_factory_exports));
+    await makeRefresh2(backendId, displayName)(program.opts());
+  });
+}
+registerUnifiedSlotCommands(program, "claude", "Claude");
+registerUnifiedSlotCommands(program, "codex", "Codex");
 var backend = program.command("backend").description("Manage AI backend");
 backend.command("list").description("Available backends with status").action(async () => {
   const { backendList: backendList2 } = await Promise.resolve().then(() => (init_backend(), backend_exports));