@inetafrica/open-claudia 2.15.0 → 3.0.1

package/bot.js

@@ -10,7 +10,46 @@ const path = require("path");
 const fs = require("fs");
 const { execSync } = require("child_process");
 
-const { config, BOT_DIR, CONFIG_DIR, SOUL_FILE, VAULT_FILE, CHAT_ID } = require("./core/config");
+const {
+  config, BOT_DIR, CONFIG_DIR, SOUL_FILE, VAULT_FILE, CHAT_ID,
+  STATE_FILE, SESSIONS_FILE, JOBS_FILE, CRONS_FILE,
+  ensureRuntimeDirectories,
+} = require("./core/config");
+ensureRuntimeDirectories();
+
+// Refuse to double-boot: a second process on this CONFIG_DIR shares the same
+// channel tokens and 409-wars the running service (see core/single-instance).
+const { acquireSingleInstanceLock } = require("./core/single-instance");
+const instanceLock = acquireSingleInstanceLock({ configDir: CONFIG_DIR });
+if (!instanceLock.acquired) {
+  const h = instanceLock.holder;
+  console.error(
+    `Another Open Claudia instance already owns ${CONFIG_DIR} ` +
+    `(pid ${h.pid}, started ${h.startedAt || "?"}, ${h.entrypoint || "unknown entrypoint"}). Exiting. ` +
+    "Stop it first (launchctl stop com.claude-telegram-bot), or give a dev run its own OPEN_CLAUDIA_CONFIG_DIR."
+  );
+  process.exit(1);
+}
+
+const { defaultMigrationSources, ensureMigrationSnapshot } = require("./core/migration-backup");
+const migrationSources = defaultMigrationSources({
+  configDir: CONFIG_DIR,
+  stateFile: STATE_FILE,
+  sessionsFile: SESSIONS_FILE,
+  jobsFile: JOBS_FILE,
+  cronsFile: CRONS_FILE,
+});
+const migrationSnapshot = ensureMigrationSnapshot({
+  configDir: CONFIG_DIR,
+  sources: migrationSources,
+});
+require("./core/provider-migration").completeProviderMigration({
+  configDir: CONFIG_DIR,
+  sources: migrationSources,
+  snapshot: migrationSnapshot,
+});
+const { readRuntimeMode, sideChatCoordinator } = require("./core/side-chat");
+const runtimeMode = readRuntimeMode(CONFIG_DIR);
 const { vault } = require("./core/vault-store");
 const { isOnboarded } = require("./core/onboarding");
 const { initScheduler, stopAll: stopScheduler } = require("./core/scheduler");
@@ -58,14 +97,22 @@ function persist() {
 
 async function gracefulShutdown(signal) {
   console.log(`Received ${signal}, shutting down gracefully...`);
+  try { stopScheduler(); } catch (e) {}
+  try { loopback.stop(); } catch (e) {}
+  const sideCleanup = sideChatCoordinator.cancelAll().catch(() => 0);
+  const memoryCleanup = require("./core/pack-review")
+    .drainReviews({ timeoutMs: 5000, cancelOnTimeout: true })
+    .catch((error) => {
+      console.error("memory shutdown drain failed:", error?.message);
+      return { drained: false };
+    });
   for (const state of userStates.values()) {
     if (state.runningProcess) {
       try { killProcessTree(state.runningProcess.pid, "SIGTERM"); } catch (e) {}
     }
   }
+  await Promise.all([sideCleanup, memoryCleanup]);
   for (const a of adapters) { try { await a.stop(); } catch (e) {} }
-  try { stopScheduler(); } catch (e) {}
-  try { loopback.stop(); } catch (e) {}
   try {
     const mediaDir = path.join(CONFIG_DIR, "media");
     if (fs.existsSync(mediaDir)) {
@@ -234,6 +281,7 @@ setInterval(checkForUpdates, 5 * 60 * 1000);
   }
 
   console.log(`Open Claudia v${CURRENT_VERSION} running on: ${adapters.map((a) => a.id).join(", ")}`);
+  console.log(`Runtime mode: ${runtimeMode} (single modular runtime)`);
   console.log(`Workspace: ${require("./core/config").WORKSPACE}`);
   console.log(`Soul: ${SOUL_FILE}`);
   console.log(`Vault: ${VAULT_FILE} (${vault.exists() ? "exists" : "not created"})`);
@@ -251,6 +299,36 @@ setInterval(checkForUpdates, 5 * 60 * 1000);
       }
     } catch (e) {}
   }
+
+  // Surface jobs the provider migration disabled. Announce once per job:
+  // marked only after a successful send, so a down adapter retries next boot.
+  try {
+    const jobsStore = require("./core/jobs");
+    const unannounced = jobsStore.listArchived().filter((job) => !job.announcedAt);
+    if (unannounced.length) {
+      const lines = unannounced.slice(0, 15).map((job) => {
+        const label = job.label || (job.prompt ? String(job.prompt).slice(0, 50) : job.id);
+        return `• [${job.kind || "job"}] ${label}\n   ↳ ${job.archiveReason}`;
+      });
+      const message = [
+        `⚠️ ${unannounced.length} scheduled job(s) were disabled during the provider migration and will NOT fire:`,
+        "",
+        ...lines,
+        unannounced.length > 15 ? `…and ${unannounced.length - 15} more.` : "",
+        "",
+        "Full list: open-claudia cron-list. Re-create the ones you still need with /cron add or schedule-wakeup.",
+      ].filter(Boolean).join("\n");
+      const tg = adapters.find((a) => a.type === "telegram");
+      if (tg && CHAT_ID) {
+        await tg.send(CHAT_ID, message);
+        jobsStore.markArchivedAnnounced(unannounced.map((job) => job.id));
+      } else {
+        console.warn(message);
+      }
+    }
+  } catch (e) {
+    console.error("archived-jobs notice failed:", e.message);
+  }
 })().catch((e) => {
   console.error("Boot failure:", e);
   process.exit(1);

package/channels/telegram/adapter.js

@@ -36,6 +36,11 @@ class TelegramAdapter {
     this._wedgedSince = 0;       // start of the current unrecovered error streak
     this._lastHiccupLog = 0;     // throttle the transient-error log (1/min)
     this._healBackoff = 0;       // grows per consecutive heal, capped
+    this._pollWatchdogTimer = null; // detects a silent first/active getUpdates stall
+    this._pollStartedAt = 0;
+    this._conflictSince = 0;         // start of the current 409 streak
+    this._conflictTimer = null;      // pending paused retry after a 409
+    this._conflictClearTimer = null; // quiet after a retry ⇒ streak over
     this._wireInbound();
   }
 
@@ -53,12 +58,33 @@ class TelegramAdapter {
   }
 
   async start() {
-    await this.bot.startPolling();
+    // node-telegram-bot-api resolves startPolling() only after the current
+    // getUpdates request settles. Awaiting it can therefore pin the entire bot
+    // boot sequence behind a half-open first poll. Start the loop, return so the
+    // remaining adapters can boot, and let the independent watchdog recover a
+    // poll that never completes and emits no polling_error.
+    this._pollStartedAt = Date.now();
+    Promise.resolve(this.bot.startPolling()).catch((error) => {
+      this._onPollingHiccup(error?.message || "Telegram polling failed to start");
+    });
+    if (!this._pollWatchdogTimer) {
+      this._pollWatchdogTimer = setInterval(() => this._checkPollingHealth(), 15000);
+    }
+  }
+
+  _checkPollingHealth() {
+    if (this._conflictTimer || this._conflictSince) return; // 409 backoff owns recovery
+    const lastCompletedPoll = this.bot?._polling?._lastUpdate || this._pollStartedAt;
+    if (!lastCompletedPoll || Date.now() - lastCompletedPoll <= 75000) return;
+    this._onPollingHiccup("poll watchdog: no completed getUpdates request in 75s");
   }
 
   async stop() {
+    if (this._pollWatchdogTimer) { clearInterval(this._pollWatchdogTimer); this._pollWatchdogTimer = null; }
     if (this._healTimer) { clearTimeout(this._healTimer); this._healTimer = null; }
     if (this._healthyTimer) { clearTimeout(this._healthyTimer); this._healthyTimer = null; }
+    if (this._conflictTimer) { clearTimeout(this._conflictTimer); this._conflictTimer = null; }
+    if (this._conflictClearTimer) { clearTimeout(this._conflictClearTimer); this._conflictClearTimer = null; }
     try { await this.bot.stopPolling(); } catch (e) {}
   }
 
@@ -94,7 +120,12 @@ class TelegramAdapter {
       process.exit(1);
     }
     try {
-      try { await this.bot.stopPolling(); } catch (e) {}
+      try {
+        // `stopPolling()` without cancellation waits for the active getUpdates
+        // request to settle. A half-open socket may never settle, which wedges
+        // this recovery routine itself. Abort the request before restarting.
+        await this.bot.stopPolling({ cancel: true, reason: "stale Telegram long-poll recovery" });
+      } catch (e) {}
       try { this._agent.destroy(); } catch (e) {} // drop any lingering pooled socket
       await new Promise((r) => setTimeout(r, 500));
       await this.bot.startPolling();
@@ -111,13 +142,42 @@ class TelegramAdapter {
     }, 30000);
   }
 
+  // Telegram 409s a getUpdates call while ANOTHER one holds the token. Two
+  // causes: a ghost long-poll left by an uncleanly-killed predecessor (clears
+  // within its ≤30s poll timeout), or a genuinely running second instance.
+  // Exiting on the first 409 turned the ghost case into a KeepAlive respawn
+  // storm (7 boot→409→die cycles on 2026-07-12). So: pause, retry inside a
+  // grace window, and exit only if the conflict outlives it — that really is
+  // a second instance, and the supervisor's throttled respawns pace the rest.
+  _on409Conflict() {
+    const now = Date.now();
+    if (!this._conflictSince) this._conflictSince = now;
+    if (this._conflictClearTimer) { clearTimeout(this._conflictClearTimer); this._conflictClearTimer = null; }
+    if (now - this._conflictSince > 120000) {
+      console.error("Another instance is polling (409 persisted >2min). Exiting.");
+      process.exit(1);
+    }
+    if (this._conflictTimer) return; // a paused retry is already queued
+    console.error("409 Conflict: another poller holds this token — pausing 15s (ghost polls clear in <1min; exiting only if this persists >2min).");
+    // Stop hammering now; the timer below dials back in.
+    Promise.resolve(this.bot.stopPolling({ cancel: true, reason: "409 conflict backoff" })).catch(() => {});
+    this._conflictTimer = setTimeout(async () => {
+      this._conflictTimer = null;
+      try { await this.bot.startPolling(); } catch (e) {}
+      // No further 409 for 45s ⇒ the other poller is gone; end the streak.
+      this._conflictClearTimer = setTimeout(() => {
+        this._conflictClearTimer = null;
+        this._conflictSince = 0;
+      }, 45000);
+    }, 15000);
+  }
+
   _wireInbound() {
     this.bot.on("polling_error", (err) => {
       const msg = err.message || "";
       if (msg.includes("409 Conflict")) {
-        // Two pollers can't share one token — this one must bow out.
-        console.error("Another instance is polling. Exiting.");
-        process.exit(1);
+        this._on409Conflict();
+        return;
       }
       if (/ETIMEDOUT|ECONNRESET|ENOTFOUND|ENETUNREACH|EAI_AGAIN|EFATAL|socket hang up/i.test(msg)) {
         this._onPollingHiccup(msg); // transient — heal quietly, never exit

package/channels/voice/adapter.js

@@ -132,6 +132,7 @@ class VoiceAdapter {
     // frontend, not just a voice channel.
     if (pathname.startsWith("/v1/manage/")) {
       return require("./manage").handle(req, res, url, {
+        canonicalUserId: canonicalForChannel("voice", this.channelId),
         json: (code, payload) => this._json(res, code, payload),
         readBody: (cb) => this._readBody(req, res, cb),
       });

package/channels/voice/manage.js

@@ -24,7 +24,9 @@ const entities = require("../../core/entities");
 const people = require("../../core/people");
 const lessons = require("../../core/lessons");
 const ideas = require("../../core/ideas");
-const { TASKS_DIR, DEFAULT_CLAUDE_MODEL } = require("../../core/config");
+const { TASKS_DIR, DEFAULT_PROVIDER } = require("../../core/config");
+const { registry: providerRegistry } = require("../../core/providers");
+const { getActiveProvider, getUserState } = require("../../core/state");
 
 let PKG_VERSION = "unknown";
 try { PKG_VERSION = require("../../package.json").version || "unknown"; } catch (e) {}
@@ -56,7 +58,25 @@ function isOpen(t) { return t.status === "pending" || t.status === "in_progress"
 
 // ── responses ──────────────────────────────────────────────────────
 
-function overview() {
+function providerMetadata(providerId, source, reason = null) {
+  if (!providerId) return { providerId: null, label: null, model: null, defaultModel: null, source, reason };
+  try {
+    const provider = providerRegistry.getProvider(providerId);
+    const defaultModel = provider.defaultModel() || null;
+    return {
+      providerId: provider.id,
+      label: provider.label,
+      model: defaultModel,
+      defaultModel,
+      source,
+      reason,
+    };
+  } catch (error) {
+    return { providerId, label: providerId, model: null, defaultModel: null, source, reason: error.message };
+  }
+}
+
+function overview(canonicalUserId = null) {
   const keys = taskFileKeys();
   let openTasks = 0, inProgress = 0;
   for (const key of keys) {
@@ -67,9 +87,27 @@ function overview() {
     }
   }
   const allJobs = jobs.listAll();
+  const selectedDefault = providerRegistry.selectDefaultProvider(DEFAULT_PROVIDER);
+  const defaultProvider = providerMetadata(
+    selectedDefault.providerId,
+    selectedDefault.source,
+    selectedDefault.reason,
+  );
+  const activeState = canonicalUserId ? getUserState(canonicalUserId) : null;
+  const activeProviderId = getActiveProvider(activeState) || defaultProvider.providerId;
+  const activeProvider = providerMetadata(
+    activeProviderId,
+    getActiveProvider(activeState) ? "active" : defaultProvider.source,
+    activeProviderId ? null : defaultProvider.reason,
+  );
+  const activeModel = activeState?.providerSettings?.[activeProviderId]?.model || activeProvider.defaultModel;
+  activeProvider.model = activeModel || null;
   return {
     version: PKG_VERSION,
-    model: DEFAULT_CLAUDE_MODEL,
+    activeProvider,
+    defaultProvider,
+    // Compatibility for companion clients predating provider metadata.
+    model: activeProvider.model,
     counts: {
       tasksOpen: openTasks,
       tasksInProgress: inProgress,
@@ -184,7 +222,7 @@ function ideasView() {
 // we don't reach into its privates.
 
 function handle(req, res, url, helpers) {
-  const { json, readBody } = helpers;
+  const { canonicalUserId, json, readBody } = helpers;
   const method = req.method;
   const sub = url.pathname.slice("/v1/manage/".length).replace(/\/+$/, "");
   const parts = sub.split("/").filter(Boolean);
@@ -192,7 +230,7 @@ function handle(req, res, url, helpers) {
   try {
     // GET reads
     if (method === "GET") {
-      if (sub === "overview") return json(200, { ok: true, ...overview() });
+      if (sub === "overview") return json(200, { ok: true, ...overview(canonicalUserId) });
       if (sub === "tasks") return json(200, { ok: true, ...allTasks() });
       if (sub === "jobs") return json(200, { ok: true, ...allJobsView() });
       if (sub === "packs") return json(200, { ok: true, ...packSummaries() });

package/config-dir.js

@@ -1,11 +1,3 @@
-const path = require("path");
-const fs = require("fs");
-
-const CONFIG_DIR = path.join(process.env.HOME || require("os").homedir(), ".open-claudia");
-
-// Ensure directory exists
-if (!fs.existsSync(CONFIG_DIR)) {
-  fs.mkdirSync(CONFIG_DIR, { recursive: true });
-}
-
-module.exports = CONFIG_DIR;
+// Compatibility export for modules that need only the path. Resolving a path
+// is intentionally pure: setup/runtime entrypoints create it explicitly.
+module.exports = require("./core/config-dir").resolveConfigDir();

package/core/actions.js

@@ -4,11 +4,15 @@
 
 const fs = require("fs");
 const path = require("path");
-const { CONFIG_DIR, WORKSPACE, CHAT_ID, resolvedCursorPath, resolvedCodexPath } = require("./config");
+const { CONFIG_DIR, WORKSPACE, CHAT_ID } = require("./config");
 const { send } = require("./io");
-const { currentState, resetSettings, resetSessionUsage, saveState } = require("./state");
-const { runClaude, getActiveSessionId } = require("./runner");
-const { listProjects, projectKeyboard, workspacePath } = require("./projects");
+const {
+  currentState, saveState,
+  getActiveProvider, getProjectKey, consumeSessionCallbackToken,
+  userOwnsProviderSession,
+} = require("./state");
+const { admitRunContext, runAgent } = require("./runner");
+const { listProjects, projectKeyboard } = require("./projects");
 const { isChatOwner, approveAuthRequest, denyAuthRequest, authRequestLabel } = require("./access");
 const accessStore = require("./access");
 const peopleStore = require("./people");
@@ -16,13 +20,47 @@ const { vault } = require("./vault-store");
 const intros = require("./intros");
 const introFlow = require("./intro-flow");
 const { finishOnboarding } = require("./onboarding");
-const { startSession } = require("./handlers");
+const {
+  startSession, switchProviderState, startNewConversation,
+  endCurrentSession, activeContinueOptions, applyProviderSetting,
+} = require("./handlers");
+const providerRegistry = require("./providers");
 const jobs = require("./jobs");
 const scheduler = require("./scheduler");
+const { sideChatCoordinator } = require("./side-chat");
 const {
   getClaudeOAuthToken, runClaudeAuthCommand, runCodexLoginStatus, runCodexDeviceLogin,
 } = require("./auth-flow");
 
+const REMOVED_PROVIDER_CALLBACK_MESSAGE = "This button is from an older Open Claudia release. Cursor Agent support has been removed. Open /backend to choose Claude Code or OpenAI Codex.";
+
+function isRemovedProviderCallback(payload) {
+  const value = String(payload || "");
+  return value === "be:cursor" || value === "mb:cursor" || value.startsWith("mb:cursor:");
+}
+
+async function handleRemovedProviderCallback(payload, deliver = send) {
+  if (!isRemovedProviderCallback(payload)) return false;
+  await deliver(REMOVED_PROVIDER_CALLBACK_MESSAGE);
+  return true;
+}
+
+function resolveSessionCallbackAction(token, state, now = Date.now()) {
+  const expected = {
+    userId: state?.userId,
+    project: getProjectKey(state),
+    provider: getActiveProvider(state),
+    now,
+  };
+  const consumed = consumeSessionCallbackToken(token, expected);
+  if (consumed.status !== "ok") return consumed;
+  const value = consumed.value;
+  if (!userOwnsProviderSession(value.userId, value.project, value.provider, value.sessionId)) {
+    return { status: "stale", value: null };
+  }
+  return { status: "ok", value };
+}
+
 // Append an owner "always-allow" grant to a person's persona-pack Mandate so
 // the guardrail won't escalate the same thing again. Wholesale-writes the
 // combined mandate (upsert replaces the section); relationship is preserved.
@@ -46,11 +84,24 @@ function appendMandate(rec, line) {
 async function handleAction(envelope) {
   const adapter = envelope.adapter;
   const d = envelope.action?.payload || envelope.action?.buttonId || "";
+  const state = currentState();
+  const continuePrompt = "continue";
+  const continuation = d === "a:continue" && state.currentSession ? activeContinueOptions(state) : null;
+  const continueRunContext = continuation
+    ? admitRunContext(continuePrompt, state.currentSession.dir, null, continuation)
+    : null;
   // Telegram needs us to ack the callback so the client stops spinning.
   if (adapter && adapter.type === "telegram" && envelope.action?.callbackId) {
     try { await adapter.bot.answerCallbackQuery(envelope.action.callbackId); } catch (e) {}
   }
-  const state = currentState();
+
+  if (d.startsWith("sc:q:")) {
+    const outcome = await sideChatCoordinator.enqueue(d.slice("sc:q:".length), state.userId);
+    if (outcome.status === "queued") return send("Added to the main task queue.");
+    if (outcome.status === "forbidden") return send("That side-chat action belongs to another user.");
+    if (outcome.status === "expired") return send("That side-chat action expired. Send the message again if it still matters.");
+    return send(`Could not add that message to the main task: ${outcome.error?.message || "unknown error"}`);
+  }
 
   if (d.startsWith("auth:")) {
     if (!isChatOwner(envelope.channelId)) return send("Owner only — auth controls are restricted.");
@@ -233,47 +284,60 @@ async function handleAction(envelope) {
 
   if (d === "show:projects") { await send("Pick:", { keyboard: projectKeyboard() }); return; }
   if (d.startsWith("s:")) { startSession(d.slice(2)); return; }
-  if (d.startsWith("ss:")) { if (state.currentSession) startSession(state.currentSession.name, d.slice(3)); return; }
+  if (d.startsWith("ss:")) {
+    const resolved = resolveSessionCallbackAction(d.slice(3), state);
+    if (resolved.status !== "ok") {
+      const message = resolved.status === "forbidden"
+        ? "That conversation button belongs to another user, project, or provider."
+        : "That conversation button is stale or expired. Open /sessions again.";
+      return send(message);
+    }
+    return startSession(resolved.value.project, resolved.value.sessionId, { provider: resolved.value.provider });
+  }
   if (d.startsWith("new:")) {
     const proj = d.slice(4);
-    state.currentSession = { name: proj === "__workspace__" ? "Workspace" : proj, dir: workspacePath(proj) };
-    state.lastSessionId = null;
-    state.isFirstMessage = true;
-    state.messageQueue = [];
-    resetSettings(state);
-    resetSessionUsage(state);
-    saveState();
+    const expected = proj === "__workspace__" ? "Workspace" : proj;
+    const result = startNewConversation({ state, projectName: expected });
+    if (!result.ok) return send("That new-conversation button is stale. Open /sessions again.");
     await send(`Session: ${state.currentSession.name}\nNew conversation\n\nSend text, voice, or images.\n\n/sessions — switch conversation\n/session — switch project`);
     return;
   }
-  if (d === "a:continue") { if (state.currentSession && getActiveSessionId()) await runClaude("continue", state.currentSession.dir); else send("No session to continue."); return; }
+  if (d === "a:continue") {
+    if (!continueRunContext) return send("No session to continue.");
+    return runAgent(continuePrompt, continueRunContext.cwd, null, {
+      runContext: continueRunContext,
+      ...continuation,
+    });
+  }
   if (d === "a:end") {
     if (state.currentSession) {
-      const n = state.currentSession.name;
-      state.currentSession = null;
-      state.lastSessionId = null;
-      state.messageQueue = [];
-      resetSettings(state);
-      resetSessionUsage(state);
-      saveState();
-      await send(`Ended: ${n}`, { keyboard: { inline_keyboard: [[{ text: "New", callback_data: "show:projects" }]] } });
+      const result = endCurrentSession({ state });
+      if (!result.ok) return send(`Could not end session: ${result.error.message}`);
+      await send(`Ended: ${result.project}`, { keyboard: { inline_keyboard: [[{ text: "New", callback_data: "show:projects" }]] } });
     }
     return;
   }
   if (d === "noop") return;
+  if (await handleRemovedProviderCallback(d)) return;
   if (d.startsWith("mb:")) {
     const rest = d.slice(3);
     const colon = rest.indexOf(":");
     if (colon < 0) return;
     const be = rest.slice(0, colon);
     const model = rest.slice(colon + 1);
-    if (be === "cursor" && !resolvedCursorPath) { await send("Cursor Agent CLI not found."); return; }
-    if (be === "codex" && !resolvedCodexPath) { await send("Codex CLI not found. Install: npm install -g @openai/codex"); return; }
+    let provider;
+    try { provider = providerRegistry.getProvider(be); }
+    catch (_) { return send("That provider is no longer available. Open /model again."); }
+    let available = false;
+    try { available = provider.isAvailable() === true; } catch (_) {}
+    if (!available) return send(`${provider.label} is unavailable. Run /doctor for recovery steps.`);
+    if (model !== "default" && !provider.modelChoices().includes(model)) {
+      return send("That model button is stale. Open /model again.");
+    }
     const switched = state.settings.backend !== be;
-    state.settings.backend = be;
-    state.settings.model = model;
-    saveState();
-    const beLabel = be === "cursor" ? "Cursor Agent" : be === "codex" ? "Codex" : "Claude Code";
+    const changed = switchProviderState(be, { state, model: model === "default" ? null : model });
+    if (!changed.ok) return send(`Could not switch provider: ${changed.error.message}`);
+    const beLabel = provider.label;
     // Auth-aware: if the chosen provider isn't connected, start its login flow
     // now. The model is already set, so once auth completes the user is on it.
     if (be === "claude" && !getClaudeOAuthToken().value) {
@@ -291,9 +355,27 @@ async function handleAction(envelope) {
     await send(switched ? `Switched to ${beLabel}.\nModel: ${model}` : `Model: ${model}`);
     return;
   }
-  if (d.startsWith("m:")) { state.settings.model = d.slice(2) === "default" ? null : d.slice(2); await send(`Model: ${state.settings.model || "default"}`); return; }
-  if (d.startsWith("e:")) { const e = d.slice(2); state.settings.effort = e === "default" ? null : e; await send(`Effort: ${state.settings.effort || "default"}`); return; }
-  if (d.startsWith("b:")) { const b = d.slice(2); state.settings.budget = b === "none" ? null : parseFloat(b); await send(`Budget: ${state.settings.budget ? "$" + state.settings.budget : "none"}`); return; }
+  if (d.startsWith("m:")) {
+    state.settings.model = d.slice(2) === "default" ? null : d.slice(2);
+    await send(`Model: ${state.settings.model || "default"}`);
+    return;
+  }
+  if (d.startsWith("e:")) {
+    const parts = d.split(":");
+    const providerId = parts.length >= 3 ? parts[1] : getActiveProvider(state);
+    const effort = parts.length >= 3 ? parts.slice(2).join(":") : parts[1];
+    const result = applyProviderSetting(state, providerId, "effort", effort, { requireActive: true, persist: true });
+    await send(result.ok ? `${result.providerLabel} effort: ${result.value || "default"}` : result.message);
+    return;
+  }
+  if (d.startsWith("b:")) {
+    const parts = d.split(":");
+    const providerId = parts.length >= 3 ? parts[1] : getActiveProvider(state);
+    const budget = parts.length >= 3 ? parts.slice(2).join(":") : parts[1];
+    const result = applyProviderSetting(state, providerId, "budget", budget, { requireActive: true, persist: true });
+    await send(result.ok ? `${result.providerLabel} budget: ${result.value ? "$" + result.value : "none"}` : result.message);
+    return;
+  }
   if (d.startsWith("eng:")) {
     const v = d.slice(4);
     const recall = require("./recall");
@@ -386,6 +468,9 @@ async function handleAction(envelope) {
         : `[Tool approval ${rec.id}] The owner DENIED the held run${isExternalAction ? ` requested by ${rec.personName || "an external contact"}` : ""}:\n${rec.command}\n` +
           `Do NOT run it. ${isExternalAction ? "Let them know you can't do that one and move on." : "Acknowledge the denial to the user and adjust course."}`;
       try {
+        if (!rec.provider || !rec.project || !rec.canonicalUserId) {
+          throw new Error("the original provider/project context predates safe scheduled-run pinning");
+        }
         scheduler.addJob({
           kind: "wakeup",
           // External escalations carry the origin as an adapter TYPE string
@@ -393,6 +478,20 @@ async function handleAction(envelope) {
           adapter: isExternalAction ? "" : (rec.adapter || (adapter && adapter.id) || ""),
           adapterType: isExternalAction ? (rec.adapter || (adapter && adapter.type)) : (adapter && adapter.type),
           channelId: String(rec.channelId || envelope.channelId),
+          canonicalUserId: rec.canonicalUserId,
+          userId: rec.userId || null,
+          provider: rec.provider,
+          providerSettings: rec.providerSettings || {},
+          project: rec.project,
+          projectDir: rec.projectDir || null,
+          sessionId: rec.sessionId || null,
+          previousSessionId: rec.previousSessionId || null,
+          originRunId: rec.originRunId || null,
+          sessionLineage: {
+            originRunId: rec.originRunId || null,
+            originSessionId: rec.sessionId || null,
+            previousSessionId: rec.previousSessionId || null,
+          },
           prompt,
           label: `Tool approval ${rec.status}: ${label}`.slice(0, 60),
           source: "approval",
@@ -417,6 +516,12 @@ async function handleAction(envelope) {
     await send(`Tool trace: ${state.settings.showToolTrace ? "on" : "off"}`);
     return;
   }
+  if (d.startsWith("vb:")) {
+    state.settings.showThinking = d.slice(3) === "on";
+    saveState();
+    await send(`Verbose thinking: ${state.settings.showThinking ? "on" : "off"}`);
+    return;
+  }
   if (d.startsWith("cw:")) {
     const v = d.slice(3);
     if (v === "default") state.settings.compactWindow = null;
@@ -432,22 +537,26 @@ async function handleAction(envelope) {
   }
   if (d.startsWith("be:")) {
     const be = d.slice(3);
-    if (be === "cursor" && !resolvedCursorPath) { await send("Cursor Agent CLI not found."); return; }
-    if (be === "codex" && !resolvedCodexPath) { await send("Codex CLI not found. Install: npm install -g @openai/codex"); return; }
-    state.settings.backend = be;
-    state.settings.model = null;
-    saveState();
-    const label = be === "cursor" ? "Cursor Agent" : be === "codex" ? "Codex" : "Claude Code";
-    await send(`Switched to ${label}.`);
+    let provider;
+    try { provider = providerRegistry.getProvider(be); }
+    catch (_) { return send("That provider is no longer available. Open /backend again."); }
+    let available = false;
+    try { available = provider.isAvailable() === true; } catch (_) {}
+    if (!available) return send(`${provider.label} is unavailable. Run /doctor for recovery steps.`);
+    const switched = switchProviderState(be, { state });
+    if (!switched.ok) return send(`Could not switch provider: ${switched.error.message}`);
+    await send(`Switched to ${provider.label}.`);
     return;
   }
 
   if (d.startsWith("mode:")) {
     if (!isChatOwner(envelope.channelId)) { await send("Owner only — mode switch restarts the bot."); return; }
     const newMode = d.slice(5);
+    if (!new Set(["direct", "agent"]).has(newMode)) return send("Unknown runtime mode.");
     const modeFile = path.join(CONFIG_DIR, ".bot-mode");
     fs.writeFileSync(modeFile, newMode);
     await send(`Switching to ${newMode} mode... restarting.`);
+    await sideChatCoordinator.cancelAll();
     setTimeout(() => process.exit(0), 500);
     return;
   }
@@ -499,4 +608,10 @@ async function handleAction(envelope) {
   }
 }
 
-module.exports = { handleAction };
+module.exports = {
+  REMOVED_PROVIDER_CALLBACK_MESSAGE,
+  handleAction,
+  handleRemovedProviderCallback,
+  isRemovedProviderCallback,
+  resolveSessionCallbackAction,
+};