@inetafrica/open-claudia 2.15.0 → 3.0.1

package/bot-agent.js

@@ -1,2351 +1,6 @@
-const TelegramBot = require("node-telegram-bot-api");
-const { spawn, execSync } = require("child_process");
-const fs = require("fs");
-const path = require("path");
-const https = require("https");
-const cron = require("node-cron");
-const Vault = require("./vault");
-const CONFIG_DIR = require("./config-dir");
-const { telegramHtml } = require("./channels/telegram/format");
+#!/usr/bin/env node
+"use strict";
 
-// ── Graceful shutdown & error handling ─────────────────────────────
-process.on("SIGINT", () => process.exit(0));
-process.on("SIGTERM", () => process.exit(0));
-
-// Notify user of crashes via Telegram before exiting
-function notifyError(label, err) {
-  const msg = `${label}: ${err?.message || err}`.slice(0, 1000);
-  console.error(msg, err?.stack || "");
-  try {
-    // Synchronous-style notification using the Telegram API directly
-    const token = process.env.TELEGRAM_BOT_TOKEN;
-    const chatId = process.env.TELEGRAM_CHAT_ID?.split(",")[0];
-    if (token && chatId) {
-      const data = JSON.stringify({ chat_id: chatId, text: msg });
-      const req = require("https").request({
-        hostname: "api.telegram.org", path: `/bot${token}/sendMessage`,
-        method: "POST", headers: { "Content-Type": "application/json", "Content-Length": data.length },
-      });
-      req.write(data);
-      req.end();
-    }
-  } catch (e) { /* last resort — ignore */ }
-}
-
-process.on("uncaughtException", (err) => {
-  notifyError("Uncaught exception", err);
-  // Give the notification a moment to send before exiting
-  setTimeout(() => process.exit(1), 2000);
-});
-
-process.on("unhandledRejection", (reason) => {
-  notifyError("Unhandled rejection", reason);
-});
-
-// ── Load Config from .env ───────────────────────────────────────────
-function loadEnv() {
-  const envPath = path.join(CONFIG_DIR, ".env");
-  if (!fs.existsSync(envPath)) {
-    console.error("No .env file found. Run: node setup.js");
-    process.exit(1);
-  }
-  const lines = fs.readFileSync(envPath, "utf-8").split("\n");
-  const env = {};
-  for (const line of lines) {
-    const idx = line.indexOf("=");
-    if (idx > 0) env[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
-  }
-  return env;
-}
-
-function saveEnvKey(key, value) {
-  const envPath = path.join(CONFIG_DIR, ".env");
-  const content = fs.readFileSync(envPath, "utf-8");
-  const lines = content.split("\n");
-  let found = false;
-  const updated = lines.map((line) => {
-    if (line.startsWith(key + "=")) { found = true; return `${key}=${value}`; }
-    return line;
-  });
-  if (!found) updated.push(`${key}=${value}`);
-  fs.writeFileSync(envPath, updated.join("\n"));
-}
-
-const config = loadEnv();
-const TOKEN = config.TELEGRAM_BOT_TOKEN;
-const CHAT_IDS = (config.TELEGRAM_CHAT_ID || "").split(",").map((s) => s.trim()).filter(Boolean);
-const CHAT_ID = CHAT_IDS[0]; // Primary owner chat for crons/notifications
-const WORKSPACE = config.WORKSPACE;
-const CLAUDE_PATH = config.CLAUDE_PATH;
-const CURSOR_PATH = config.CURSOR_PATH || null;
-const DEFAULT_CLAUDE_MODEL = config.CLAUDE_MODEL || process.env.CLAUDE_MODEL || "claude-fable-5";
-
-// Resolve Cursor Agent CLI (optional)
-let resolvedCursorPath = CURSOR_PATH;
-if (!resolvedCursorPath) {
-  try {
-    resolvedCursorPath = execSync("which agent 2>/dev/null", { encoding: "utf-8" }).trim() || null;
-  } catch (e) { resolvedCursorPath = null; }
-}
-if (resolvedCursorPath) console.log(`Cursor Agent CLI: ${resolvedCursorPath}`);
-
-const WHISPER_CLI = config.WHISPER_CLI || "";
-const WHISPER_MODEL = config.WHISPER_MODEL || "";
-const FFMPEG = config.FFMPEG || "";
-const SOUL_FILE = config.SOUL_FILE || path.join(CONFIG_DIR, "soul.md");
-const CRONS_FILE = config.CRONS_FILE || path.join(CONFIG_DIR, "crons.json");
-const VAULT_FILE = config.VAULT_FILE || path.join(CONFIG_DIR, "vault.enc");
-const AUTH_FILE = config.AUTH_FILE || path.join(CONFIG_DIR, "auth.json");
-const BOT_DIR = __dirname;
-
-// Detect PATH for subprocess
-const FULL_PATH = [
-  path.dirname(CLAUDE_PATH),
-  resolvedCursorPath ? path.dirname(resolvedCursorPath) : null,
-  path.dirname(process.execPath),
-  FFMPEG ? path.dirname(FFMPEG) : null,
-  WHISPER_CLI ? path.dirname(WHISPER_CLI) : null,
-  ...(process.platform === "win32"
-    ? [process.env.APPDATA, process.env.LOCALAPPDATA].filter(Boolean).map((p) => path.join(p, "npm"))
-    : ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"]
-  ),
-].filter(Boolean).join(path.delimiter);
-
-const bot = new TelegramBot(TOKEN, {
-  polling: {
-    autoStart: true,
-    params: { timeout: 30 },
-  },
-});
-const vault = new Vault(VAULT_FILE);
-
-// ── Auto-reconnect on polling errors ───────────────────────────────
-let reconnectTimer = null;
-bot.on("polling_error", (err) => {
-  const msg = err.message || "";
-  console.error("Polling error:", msg);
-  // Another instance is already running — exit immediately
-  if (msg.includes("409 Conflict")) {
-    console.error("Another instance is polling. Exiting.");
-    process.exit(1);
-  }
-  if (msg.includes("ETIMEDOUT") || msg.includes("ECONNRESET") || msg.includes("ENOTFOUND") || msg.includes("EFATAL")) {
-    if (reconnectTimer) return; // Already scheduled
-    console.log("Network lost. Reconnecting in 10s...");
-    reconnectTimer = setTimeout(async () => {
-      reconnectTimer = null;
-      try {
-        await bot.stopPolling();
-        await new Promise((r) => setTimeout(r, 2000));
-        await bot.startPolling();
-        console.log("Reconnected.");
-      } catch (e) {
-        console.error("Reconnect failed:", e.message);
-        // launchd will restart us if we exit
-        process.exit(1);
-      }
-    }, 10000);
-  }
-});
-
-// ── Update checker (every 5 mins) ──────────────────────────────────
-const CURRENT_VERSION = require(path.join(__dirname, "package.json")).version;
-const { isNewerVersion } = require("./core/version");
-let lastNotifiedVersion = null;
-
-function checkForUpdates() {
-  https.get("https://registry.npmjs.org/@inetafrica/open-claudia/latest", (res) => {
-    let data = "";
-    res.on("data", (d) => { data += d; });
-    res.on("end", () => {
-      try {
-        const latest = JSON.parse(data).version;
-        if (isNewerVersion(latest, CURRENT_VERSION) && latest !== lastNotifiedVersion) {
-          lastNotifiedVersion = latest;
-          bot.sendMessage(CHAT_ID, `Hey! A new version is available (v${latest}). You're on v${CURRENT_VERSION}.\n\nSend /upgrade to update — I'll be back in a few seconds.`);
-        }
-      } catch (e) {}
-    });
-  }).on("error", () => {});
-}
-
-// Check on startup (after 30s) and every 5 minutes
-setTimeout(checkForUpdates, 30000);
-setInterval(checkForUpdates, 5 * 60 * 1000);
-
-// ── Commands Menu ───────────────────────────────────────────────────
-bot.setMyCommands([
-  { command: "session", description: "Pick a project to work on" },
-  { command: "projects", description: "Browse all workspace projects" },
-  { command: "model", description: "Switch model (opus/sonnet/haiku)" },
-  { command: "effort", description: "Set effort level" },
-  { command: "budget", description: "Set max spend for next task" },
-  { command: "plan", description: "Toggle plan mode" },
-  { command: "ask", description: "Toggle ask mode (Cursor only)" },
-  { command: "sessions", description: "List conversations for this project" },
-  { command: "compact", description: "Summarize conversation context" },
-  { command: "continue", description: "Resume last conversation" },
-  { command: "worktree", description: "Toggle isolated git branch" },
-  { command: "cron", description: "Manage scheduled tasks" },
-  { command: "vault", description: "Manage credentials (password required)" },
-  { command: "soul", description: "View/edit assistant identity" },
-  { command: "status", description: "Session & settings info" },
-  { command: "cursor", description: "Switch to Cursor Agent backend" },
-  { command: "claude", description: "Switch to Claude Code backend" },
-  { command: "backend", description: "Show/switch active backend" },
-  { command: "auth", description: "Request access to this bot" },
-  { command: "auth_status", description: "Check Claude Code auth" },
-  { command: "login", description: "Start Claude Code login" },
-  { command: "setup_token", description: "Create Claude OAuth token" },
-  { command: "stop", description: "Cancel running task" },
-  { command: "end", description: "End current session" },
-  { command: "version", description: "Show current version" },
-  { command: "restart", description: "Restart the bot" },
-  { command: "upgrade", description: "Upgrade and restart" },
-  { command: "help", description: "Show all commands" },
-]);
-
-// Temp dir for media
-const TEMP_DIR = path.join(CONFIG_DIR, "media");
-const FILES_DIR = path.join(CONFIG_DIR, "files");
-if (!fs.existsSync(TEMP_DIR)) fs.mkdirSync(TEMP_DIR, { recursive: true });
-if (!fs.existsSync(FILES_DIR)) fs.mkdirSync(FILES_DIR, { recursive: true });
-
-// ── Persistent state ───────────────────────────────────────────────
-const STATE_FILE = path.join(CONFIG_DIR, "state.json");
-const SESSIONS_FILE = path.join(CONFIG_DIR, "sessions.json");
-
-function loadState() {
-  try {
-    return JSON.parse(fs.readFileSync(STATE_FILE, "utf-8"));
-  } catch (e) {
-    return {};
-  }
-}
-
-function saveState() {
-  const data = {
-    currentSession,
-    lastSessionId,
-    cursorSessionId,
-    settings,
-  };
-  try { fs.writeFileSync(STATE_FILE, JSON.stringify(data)); } catch (e) {}
-}
-
-// ── Message deduplication ──────────────────────────────────────────
-const processedMessages = new Set();
-function isDuplicate(msgId) {
-  if (processedMessages.has(msgId)) return true;
-  processedMessages.add(msgId);
-  // Keep set from growing unbounded
-  if (processedMessages.size > 200) {
-    const arr = [...processedMessages];
-    processedMessages.clear();
-    arr.slice(-100).forEach((id) => processedMessages.add(id));
-  }
-  return false;
-}
-
-// ── Per-project session history ────────────────────────────────────
-
-function loadSessions() {
-  try { return JSON.parse(fs.readFileSync(SESSIONS_FILE, "utf-8")); } catch (e) { return {}; }
-}
-
-function saveSessions(sessions) {
-  try { fs.writeFileSync(SESSIONS_FILE, JSON.stringify(sessions, null, 2)); } catch (e) {}
-}
-
-function recordSession(projectName, sessionId, title) {
-  const sessions = loadSessions();
-  if (!sessions[projectName]) sessions[projectName] = [];
-  const existing = sessions[projectName].find((s) => s.id === sessionId);
-  if (existing) {
-    if (title) existing.title = title;
-    existing.lastUsed = new Date().toISOString();
-  } else {
-    sessions[projectName].push({
-      id: sessionId,
-      title: title || "Untitled",
-      created: new Date().toISOString(),
-      lastUsed: new Date().toISOString(),
-    });
-  }
-  // Keep last 20 sessions per project
-  sessions[projectName] = sessions[projectName].slice(-20);
-  saveSessions(sessions);
-}
-
-function getProjectSessions(projectName) {
-  const sessions = loadSessions();
-  return (sessions[projectName] || []).slice().reverse();
-}
-
-function getLastProjectSession(projectName) {
-  const sessions = getProjectSessions(projectName);
-  return sessions.length > 0 ? sessions[0] : null;
-}
-
-const savedState = loadState();
-
-// ── State ───────────────────────────────────────────────────────────
-// Agent mode: heavy tasks run as "background" processes while
-// new messages get handled by short-lived "chat" processes.
-let currentSession = savedState.currentSession || null;
-let runningProcess = null;        // The main/heavy task process
-let runningProcessPrompt = null;  // What the main task is doing (for context)
-let chatProcesses = new Map();    // msgId -> proc (lightweight chat processes)
-let statusMessageId = null;
-let streamBuffer = "";
-let streamInterval = null;
-let lastSessionId = savedState.lastSessionId || null;
-let cursorSessionId = savedState.cursorSessionId || null;
-let messageQueue = [];            // Fallback queue (only used if chat process also fails)
-let activeCrons = new Map();
-let pendingVaultUnlock = false;
-let pendingVaultAction = null;
-let pendingClaudeAuthProcess = null;
-let pendingClaudeAuthLabel = null;
-let isFirstMessage = !lastSessionId;
-let lastInputWasVoice = false;
-
-let settings = savedState.settings || {
-  model: null, effort: null, budget: null, permissionMode: null, worktree: false, backend: "claude",
-};
-if (!settings.backend) settings.backend = "claude";
-
-function resetSettings() {
-  settings = { model: null, effort: null, budget: null, permissionMode: null, worktree: false, backend: "claude" };
-}
-
-function isAuthorized(msg) {
-  const chatId = String(msg.chat.id);
-  if (CHAT_IDS.includes(chatId)) return true;
-  // Also check auth.json for dynamically added chats
-  try {
-    const auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf-8"));
-    return Array.isArray(auth.authorized) && auth.authorized.some((a) => String(a.chatId) === chatId);
-  } catch (e) {}
-  return false;
-}
-
-function isOwner(msg) {
-  const chatId = String(msg.chat.id);
-  if (chatId === CHAT_ID) return true;
-  try {
-    const auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf-8"));
-    const authorized = Array.isArray(auth.authorized) ? auth.authorized : [];
-    if (authorized.some((a) => String(a.chatId) === chatId && a.isOwner === true)) return true;
-    if (!authorized.some((a) => a.isOwner === true) && CHAT_IDS.includes(chatId)) return true;
-  } catch (e) {}
-  return false;
-}
-
-function loadAuth() {
-  try {
-    const auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf-8"));
-    return {
-      authorized: Array.isArray(auth.authorized) ? auth.authorized : [],
-      pending: Array.isArray(auth.pending) ? auth.pending : [],
-    };
-  } catch (e) {
-    return { authorized: [], pending: [] };
-  }
-}
-
-function saveAuth(auth) {
-  fs.writeFileSync(AUTH_FILE, JSON.stringify(auth, null, 2));
-}
-
-function authRequestLabel(request) {
-  return request.username ? `@${request.username}` : request.name || request.chatId;
-}
-
-function updateAuthorizedChatEnv(auth) {
-  const ids = new Set(CHAT_IDS);
-  for (const user of auth.authorized) {
-    if (user.chatId) ids.add(String(user.chatId));
-  }
-  saveEnvKey("TELEGRAM_CHAT_ID", [...ids].join(","));
-}
-
-async function approveAuthRequest(chatId) {
-  const auth = loadAuth();
-  if (auth.authorized.some((a) => String(a.chatId) === chatId)) {
-    auth.pending = auth.pending.filter((p) => String(p.chatId) !== chatId);
-    saveAuth(auth);
-    updateAuthorizedChatEnv(auth);
-    return { status: "already_authorized" };
-  }
-
-  const idx = auth.pending.findIndex((p) => String(p.chatId) === chatId);
-  if (idx < 0) return { status: "not_found" };
-
-  const approved = auth.pending.splice(idx, 1)[0];
-  auth.authorized.push({
-    chatId: approved.chatId,
-    name: approved.name,
-    username: approved.username,
-    isOwner: false,
-    authorizedAt: new Date().toISOString(),
-  });
-  saveAuth(auth);
-  updateAuthorizedChatEnv(auth);
-  return { status: "approved", request: approved };
-}
-
-async function denyAuthRequest(chatId) {
-  const auth = loadAuth();
-  const idx = auth.pending.findIndex((p) => String(p.chatId) === chatId);
-  if (idx < 0) return { status: "not_found" };
-
-  const denied = auth.pending.splice(idx, 1)[0];
-  saveAuth(auth);
-  return { status: "denied", request: denied };
-}
-
-// ── Auth request handler (for unauthorized users) ──────────────────
-bot.onText(/\/auth$/, async (msg) => {
-  if (isAuthorized(msg)) {
-    bot.sendMessage(msg.chat.id, "You're already authorized.");
-    return;
-  }
-  const chatId = String(msg.chat.id);
-  const name = [msg.from?.first_name, msg.from?.last_name].filter(Boolean).join(" ");
-  const username = msg.from?.username || "";
-
-  // Add to pending in auth.json
-  const auth = loadAuth();
-
-  // Check if already pending
-  if (auth.pending.some((p) => String(p.chatId) === chatId)) {
-    bot.sendMessage(msg.chat.id, "Your request is already pending. The bot owner will review it.");
-    return;
-  }
-
-  auth.pending.push({
-    chatId,
-    name,
-    username,
-    requestedAt: new Date().toISOString(),
-  });
-  saveAuth(auth);
-
-  bot.sendMessage(msg.chat.id, "Access requested! The bot owner will review your request.");
-
-  // Notify owner
-  const label = authRequestLabel({ chatId, name, username });
-  bot.sendMessage(CHAT_ID, `New auth request from ${label} (${chatId}).`, {
-    reply_markup: {
-      inline_keyboard: [[
-        { text: "Approve", callback_data: `auth:approve:${chatId}` },
-        { text: "Deny", callback_data: `auth:deny:${chatId}` },
-      ]],
-    },
-  });
-});
-
-// ── Onboarding ──────────────────────────────────────────────────────
-let onboardingStep = null; // null | "name" | "role" | "style" | "done"
-let onboardingData = {};
-
-function isOnboarded() {
-  return config.ONBOARDED === "true";
-}
-
-async function startOnboarding() {
-  onboardingStep = "name";
-  onboardingData = {};
-  await send(
-    "Welcome! Let's set me up.\n\nWhat should I call you?"
-  );
-}
-
-async function handleOnboarding(msg) {
-  const text = msg.text;
-
-  if (onboardingStep === "name") {
-    onboardingData.name = text;
-    onboardingStep = "role";
-    await send(`Nice to meet you, ${text}!\n\nWhat's your role? (e.g., "full-stack developer", "startup founder", "student")`);
-    return true;
-  }
-
-  if (onboardingStep === "role") {
-    onboardingData.role = text;
-    onboardingStep = "style";
-    await send("How should I communicate?\n\nPick a style:", {
-      keyboard: {
-        inline_keyboard: [
-          [
-            { text: "Concise & technical", callback_data: "ob:concise" },
-            { text: "Detailed & educational", callback_data: "ob:detailed" },
-          ],
-          [
-            { text: "Casual & friendly", callback_data: "ob:casual" },
-            { text: "Minimal (just code)", callback_data: "ob:minimal" },
-          ],
-        ],
-      },
-    });
-    return true;
-  }
-
-  return false;
-}
-
-function finishOnboarding(style) {
-  onboardingData.style = style;
-  onboardingStep = null;
-
-  // Generate soul.md
-  const styleDescriptions = {
-    concise: "Direct, concise, technical. No fluff. Lead with the answer.",
-    detailed: "Thorough and educational. Explain the why, not just the what.",
-    casual: "Casual and friendly. Like chatting with a smart friend who codes.",
-    minimal: "Minimal output. Just code and brief explanations. No chatter.",
-  };
-
-  const soul = `# Soul
-
-You are ${onboardingData.name}'s personal AI coding assistant, running 24/7 via Telegram.
-
-## Identity
-- Tone: ${styleDescriptions[style]}
-- Platform: Telegram (mobile-first, keep messages short)
-
-## About ${onboardingData.name}
-- Role: ${onboardingData.role}
-
-## Working Style
-- Prefer action over discussion. Do the thing, then explain.
-- Send files for long output instead of text walls.
-- Proactively flag issues and suggest improvements.
-
-## Capabilities
-- Write, edit, and refactor code across all projects
-- Run commands, tests, builds
-- Send files, images, code snippets directly via Telegram
-- Run scheduled checks (cron jobs) and report results
-- Store and use credentials from the encrypted vault
-`;
-
-  fs.writeFileSync(SOUL_FILE, soul);
-  saveEnvKey("ONBOARDED", "true");
-  config.ONBOARDED = "true";
-
-  send(`All set, ${onboardingData.name}! I'm configured and ready.\n\nTap /session to pick a project and start working.`, {
-    keyboard: { inline_keyboard: [[{ text: "Pick a project", callback_data: "show:projects" }]] },
-  });
-}
-
-// ── Soul / System Prompt ────────────────────────────────────────────
-
-function loadSoul() {
-  try { return fs.readFileSync(SOUL_FILE, "utf-8"); } catch (e) { return "You are a helpful AI coding assistant."; }
-}
-
-function loadCrons() {
-  try { return JSON.parse(fs.readFileSync(CRONS_FILE, "utf-8")); } catch (e) { return []; }
-}
-
-function saveCrons(list) {
-  fs.writeFileSync(CRONS_FILE, JSON.stringify(list, null, 2));
-}
-
-function buildSystemPrompt() {
-  const soul = loadSoul();
-  const cronList = loadCrons();
-  const vaultKeys = vault.isUnlocked() ? vault.keys() : [];
-  const now = new Date().toISOString();
-  const hasVoice = WHISPER_CLI && FFMPEG;
-
-  return `
-${soul}
-
-## Current Context
-- Date/time: ${now}
-- Platform: Telegram (mobile app)
-- Active project: ${currentSession ? currentSession.name + " (" + currentSession.dir + ")" : "none"}
-- Voice notes: ${hasVoice ? "enabled" : "disabled"}
-- Vault: ${vault.isUnlocked() ? "unlocked (" + vaultKeys.length + " keys)" : "locked"}
-
-## Your Configuration Files
-These are YOUR files — read and modify them when the user asks:
-
-### ${SOUL_FILE}
-Your identity and personality. Edit to change behavior or update knowledge about the user.
-
-### ${CRONS_FILE}
-Scheduled tasks. JSON array of { id, schedule, project, prompt, label }.
-Active: ${cronList.length > 0 ? cronList.map(c => c.label).join(", ") : "none"}.
-
-### ${VAULT_FILE}
-Encrypted credential vault. ${vault.isUnlocked() ? "UNLOCKED. Keys: " + vaultKeys.join(", ") : "LOCKED — user must send /vault to unlock."}.
-${vault.isUnlocked() ? "To read a credential: require('./vault') or read from the vault object." : ""}
-
-### ${path.join(BOT_DIR, "bot.js")}
-The bot code. Read to understand capabilities. Only modify if explicitly asked.
-
-### ${path.join(BOT_DIR, ".env")}
-Configuration (Telegram token, paths, etc). Sensitive — don't expose values.
-
-## Received Files
-Files sent by the user are saved in: ${FILES_DIR}
-${fs.existsSync(FILES_DIR) ? (() => { try { const f = fs.readdirSync(FILES_DIR); return f.length > 0 ? "Current files: " + f.slice(-10).join(", ") : "No files yet."; } catch(e) { return ""; } })() : ""}
-
-## Telegram API
-Send things directly to the user:
-
-Text: curl -s -X POST "https://api.telegram.org/bot${TOKEN}/sendMessage" -d chat_id=${CHAT_ID} -d text="message"
-File: curl -s -X POST "https://api.telegram.org/bot${TOKEN}/sendDocument" -F chat_id=${CHAT_ID} -F document=@/path/to/file
-Image: curl -s -X POST "https://api.telegram.org/bot${TOKEN}/sendPhoto" -F chat_id=${CHAT_ID} -F photo=@/path/to/image.png
-
-## Session
-${lastSessionId ? "Resuming conversation — you have prior context." : "New conversation."}
-
-## Guidelines
-- Keep responses concise — this is a mobile screen.
-- Use Telegram-compatible markdown: *bold*, _italic_, \`code\`, \`\`\`code blocks\`\`\`. No headers (#), no links [text](url).
-- For long output (logs, diffs, large code), save to a file and send via the Telegram API curl above — don't paste walls of text.
-- Act on screenshots (fix bugs, implement designs) — don't just describe what you see.
-- When the user sends a file, it's saved in ${FILES_DIR}. Read it with the Read tool.
-- When the user sends a credential, token, or API key, store it in the vault immediately using the vault CLI or bot commands. Tell them it's stored and that you've deleted their message for security. Don't tell them to use /vault manually — handle it for them.
-- When asked to change your personality, edit ${SOUL_FILE}.
-- When asked about yourself, you are Open Claudia — an AI coding assistant running Claude Code via Telegram.
-- If a task will take a while, let the user know upfront.
-- Don't ask for confirmation on simple tasks — just do them.
-- NEVER start long-running processes (dev servers, watchers, tails) in the foreground. They block all further messages. Instead, run them in the background: \`nohup command &\` or \`command &disown\`. Then report the PID so the user can stop it later.
-- If asked to "start" or "run" a dev server, ALWAYS background it.
-`.trim();
-}
-
-// ── Helpers ─────────────────────────────────────────────────────────
-
-function listProjects() {
-  try {
-    return fs.readdirSync(WORKSPACE, { withFileTypes: true })
-      .filter((d) => d.isDirectory())
-      .map((d) => d.name)
-      .filter((n) => !n.startsWith("."));
-  } catch (e) { return []; }
-}
-
-function findProject(query) {
-  const projects = listProjects();
-  const q = query.toLowerCase();
-  const exact = projects.find((p) => p.toLowerCase() === q);
-  if (exact) return exact;
-  const startsWith = projects.filter((p) => p.toLowerCase().startsWith(q));
-  if (startsWith.length === 1) return startsWith[0];
-  const contains = projects.filter((p) => p.toLowerCase().includes(q));
-  if (contains.length === 1) return contains[0];
-  return contains.length > 0 ? contains : null;
-}
-
-function projectKeyboard() {
-  const projects = listProjects();
-  const rows = [[{ text: "\u{1F4C1} Workspace (root)", callback_data: "s:__workspace__" }]];
-  for (let i = 0; i < projects.length; i += 2) {
-    const row = [{ text: projects[i], callback_data: `s:${projects[i]}` }];
-    if (projects[i + 1]) row.push({ text: projects[i + 1], callback_data: `s:${projects[i + 1]}` });
-    rows.push(row);
-  }
-  return { inline_keyboard: rows };
-}
-
-async function send(text, opts = {}) {
-  const parseMode = opts.parseMode || "HTML";
-  const body = parseMode === "HTML" ? telegramHtml(text) : text;
-  const fallbackBody = String(text ?? "");
-  const o = {};
-  if (parseMode) o.parse_mode = parseMode;
-  if (opts.keyboard) o.reply_markup = opts.keyboard;
-  if (opts.replyTo) o.reply_to_message_id = opts.replyTo;
-
-  for (let attempt = 0; attempt < 3; attempt++) {
-    try {
-      const msg = await bot.sendMessage(CHAT_ID, body, o);
-      return msg.message_id;
-    } catch (e) {
-      const errMsg = e.message || "";
-
-      // replyTo message was deleted or not found — retry without it
-      if (o.reply_to_message_id && errMsg.includes("message to be replied not found")) {
-        delete o.reply_to_message_id;
-        continue;
-      }
-
-      // Rate limited — wait and retry
-      const retryMatch = errMsg.match(/retry after (\d+)/i);
-      if (retryMatch) {
-        const waitSec = Math.min(parseInt(retryMatch[1], 10), 30);
-        console.error(`Send: rate limited, waiting ${waitSec}s`);
-        await new Promise((r) => setTimeout(r, waitSec * 1000));
-        continue;
-      }
-
-      // Parse mode failed — retry once as plain text, but do not leak raw HTML tags.
-      if (parseMode && o.parse_mode) {
-        console.error("Send parse-mode failed, retrying plain text:", errMsg);
-        delete o.parse_mode;
-        try {
-          const msg = await bot.sendMessage(CHAT_ID, fallbackBody, o);
-          return msg.message_id;
-        } catch (plainErr) {
-          console.error("Send plain-text fallback error:", plainErr.message || plainErr);
-          return null;
-        }
-      }
-
-      console.error("Send error:", errMsg);
-      return null;
-    }
-  }
-  console.error("Send: exhausted retries");
-  return null;
-}
-
-async function editMessage(messageId, text, opts = {}) {
-  const parseMode = opts.parseMode || "HTML";
-  const body = parseMode === "HTML" ? telegramHtml(text) : text;
-  const fallbackBody = String(text ?? "");
-  try {
-    const o = { chat_id: CHAT_ID, message_id: messageId };
-    if (parseMode) o.parse_mode = parseMode;
-    if (opts.keyboard) o.reply_markup = opts.keyboard;
-    await bot.editMessageText(body, o);
-  } catch (e) {
-    const errMsg = e.message || "";
-    // Rate limited — skip this update (next interval will catch up)
-    if (errMsg.includes("retry after")) return;
-    // Message unchanged — ignore
-    if (errMsg.includes("message is not modified")) return;
-    if (parseMode) {
-      try {
-        const fallback = { chat_id: CHAT_ID, message_id: messageId };
-        if (opts.keyboard) fallback.reply_markup = opts.keyboard;
-        await bot.editMessageText(fallbackBody, fallback);
-        return;
-      } catch (e2) {}
-    }
-    // Log anything unexpected
-    if (!errMsg.includes("message to edit not found")) {
-      console.error("Edit error:", errMsg);
-    }
-  }
-}
-
-function splitMessage(text, maxLen = 4000) {
-  if (text.length <= maxLen) return [text];
-  const chunks = [];
-  while (text.length > 0) { chunks.push(text.slice(0, maxLen)); text = text.slice(maxLen); }
-  return chunks;
-}
-
-async function downloadFile(fileId, ext) {
-  const file = await bot.getFile(fileId);
-  const fileUrl = `https://api.telegram.org/file/bot${TOKEN}/${file.file_path}`;
-  const localPath = path.join(TEMP_DIR, `tg-${Date.now()}${ext}`);
-  await new Promise((resolve, reject) => {
-    const out = fs.createWriteStream(localPath);
-    https.get(fileUrl, (res) => { res.pipe(out); out.on("finish", () => { out.close(); resolve(); }); }).on("error", reject);
-  });
-  return localPath;
-}
-
-function transcribeAudio(oggPath) {
-  if (!WHISPER_CLI || !FFMPEG) return null;
-  const wavPath = oggPath.replace(/\.[^.]+$/, ".wav");
-  execSync(`"${FFMPEG}" -i "${oggPath}" -ar 16000 -ac 1 -y "${wavPath}" 2>/dev/null`);
-  const output = execSync(`"${WHISPER_CLI}" -m "${WHISPER_MODEL}" --no-timestamps -f "${wavPath}" 2>/dev/null`, { encoding: "utf-8" });
-  try { fs.unlinkSync(wavPath); } catch (e) { /* ignore */ }
-  return output.split("\n")
-    .filter((l) => l.trim() && !l.startsWith("whisper_") && !l.startsWith("ggml_") && !l.startsWith("load_"))
-    .join(" ").trim();
-}
-
-// ── Text-to-Speech ────────────────────────────────────────────────
-// Shared with direct mode: ElevenLabs natural voice, falling back to `say`.
-
-const { textToVoice } = require("./core/media");
-
-async function sendVoice(oggPath) {
-  try {
-    await bot.sendVoice(CHAT_ID, oggPath);
-    try { fs.unlinkSync(oggPath); } catch (e) {}
-    return true;
-  } catch (e) {
-    console.error("Send voice error:", e.message);
-    try { fs.unlinkSync(oggPath); } catch (e2) {}
-    return false;
-  }
-}
-
-// Delete a message (used for vault password cleanup)
-async function deleteMessage(msgId) {
-  try { await bot.deleteMessage(CHAT_ID, msgId); } catch (e) { /* ignore */ }
-}
-
-
-// ── Claude Auth Helpers ─────────────────────────────────────────────
-
-const CLAUDE_OAUTH_TOKEN_KEY = "CLAUDE_CODE_OAUTH_TOKEN";
-const CLAUDE_OAUTH_VAULT_KEY = "claude_oauth_token";
-
-function redactSensitive(value) {
-  return String(value || "")
-    .replace(/sk-ant-[A-Za-z0-9._-]+/g, "[REDACTED_TOKEN]")
-    .replace(/(Bearer\s+)[A-Za-z0-9._=-]+/gi, "$1[REDACTED_TOKEN]")
-    .replace(/(CLAUDE_CODE_OAUTH_TOKEN\s*=\s*)\S+/gi, "$1[REDACTED_TOKEN]")
-    .replace(/([?&](?:token|access_token|refresh_token)=)[^\s&]+/gi, "$1[REDACTED]");
-}
-
-
-function stripTerminalControls(value) {
-  return String(value || "")
-    // OSC 8 hyperlinks and other OSC sequences
-    .replace(/\x1b\][\s\S]*?(?:\x07|\x1b\\)/g, "")
-    // CSI ANSI sequences
-    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
-    // remaining non-printing controls except newline/tab
-    .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
-}
-
-function isClaudeAuthUrl(url) {
-  try {
-    const u = new URL(url);
-    const host = u.hostname.toLowerCase();
-    return host === "claude.com" || host.endsWith(".claude.com") ||
-      host === "anthropic.com" || host.endsWith(".anthropic.com") ||
-      host === "localhost" || host === "127.0.0.1";
-  } catch (e) {
-    return false;
-  }
-}
-
-function looksLikeClaudeToken(value) {
-  const text = String(value || "").trim();
-  return /^sk-ant-[A-Za-z0-9._-]+$/.test(text) || text.length >= 80 && /^[A-Za-z0-9._=-]+$/.test(text);
-}
-
-
-function looksLikeClaudeAuthReply(value) {
-  const text = String(value || "").trim();
-  if (!text) return false;
-  if (looksLikeClaudeToken(text)) return true;
-  if (/^https?:\/\//i.test(text) && /claude|anthropic/i.test(text)) return true;
-  // OAuth callback/login codes are usually long, dense strings. Do not consume normal chat.
-  if (text.length >= 24 && !/\s/.test(text) && /^[A-Za-z0-9._~:/?#[\]@!$&'()*+,;=%-]+$/.test(text)) return true;
-  return false;
-}
-
-function clearPendingClaudeAuth() {
-  if (pendingClaudeAuthProcess && pendingClaudeAuthProcess.kill) {
-    try { pendingClaudeAuthProcess.kill("SIGTERM"); } catch (e) {}
-  }
-  pendingClaudeAuthProcess = null;
-  pendingClaudeAuthLabel = null;
-}
-
-function getClaudeOAuthToken() {
-  if (config[CLAUDE_OAUTH_TOKEN_KEY]) return { value: config[CLAUDE_OAUTH_TOKEN_KEY], source: ".env" };
-  if (process.env.CLAUDE_CODE_OAUTH_TOKEN) return { value: process.env.CLAUDE_CODE_OAUTH_TOKEN, source: "process env" };
-  if (vault.isUnlocked()) {
-    const value = vault.get(CLAUDE_OAUTH_VAULT_KEY) || vault.get(CLAUDE_OAUTH_TOKEN_KEY);
-    if (value) return { value, source: "vault" };
-  }
-  return { value: null, source: null };
-}
-
-function claudeSubprocessEnv() {
-  const env = { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME };
-  const token = getClaudeOAuthToken().value;
-  if (token) env.CLAUDE_CODE_OAUTH_TOKEN = token;
-  return env;
-}
-
-function saveClaudeOAuthToken(token) {
-  const clean = String(token || "").trim();
-  if (!clean) return false;
-  saveEnvKey(CLAUDE_OAUTH_TOKEN_KEY, clean);
-  config[CLAUDE_OAUTH_TOKEN_KEY] = clean;
-  process.env.CLAUDE_CODE_OAUTH_TOKEN = clean;
-  if (vault.isUnlocked()) vault.set(CLAUDE_OAUTH_VAULT_KEY, clean);
-  return true;
-}
-
-function clearClaudeOAuthToken() {
-  saveEnvKey(CLAUDE_OAUTH_TOKEN_KEY, "");
-  config[CLAUDE_OAUTH_TOKEN_KEY] = "";
-  delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
-  if (vault.isUnlocked()) {
-    vault.remove(CLAUDE_OAUTH_VAULT_KEY);
-    vault.remove(CLAUDE_OAUTH_TOKEN_KEY);
-  }
-}
-
-function extractClaudeToken(text) {
-  const match = String(text || "").match(/sk-ant-[A-Za-z0-9._-]+/);
-  return match ? match[0] : null;
-}
-
-function extractUrls(text) {
-  return [...stripTerminalControls(text).matchAll(/https?:\/\/[^\s)]+/g)].map((m) => m[0]);
-}
-
-
-function isClaudeAuthErrorText(text) {
-  const lower = String(text || "").toLowerCase();
-  return lower.includes("unauthorized") ||
-    lower.includes("not logged in") ||
-    lower.includes("login required") ||
-    lower.includes("reauthenticate") ||
-    lower.includes("re-authenticate") ||
-    lower.includes("authentication failed") ||
-    lower.includes("auth failed") ||
-    lower.includes("invalid api key") ||
-    lower.includes("api key") && lower.includes("invalid") ||
-    lower.includes("keychain") && (lower.includes("unlock") || lower.includes("could not") || lower.includes("failed")) ||
-    lower.includes("security unlock-keychain");
-}
-
-function claudeAuthRecoveryMessage(reason = "Claude Code authentication failed") {
-  const tokenInfo = getClaudeOAuthToken();
-  const tokenLine = tokenInfo.value
-    ? `Stored OAuth token: yes (${tokenInfo.source})`
-    : "Stored OAuth token: no";
-  return [
-    `Claude auth needs attention: ${redactSensitive(reason)}`,
-    "",
-    tokenLine,
-    "",
-    "Try one of these from Telegram:",
-    "1. /auth_status — check what Claude sees",
-    "2. /setup_token — create a long-lived Claude Code token, then store it",
-    "3. /use_oauth_token — paste the token securely if you already generated one",
-    "4. /login — interactive Claude.ai browser login fallback",
-    "",
-    "If this is a macOS Keychain problem after SSH/reboot, run on the Mac:",
-    "security unlock-keychain",
-    "",
-    "Recommended for this bot: /setup_token + /use_oauth_token so launchd does not depend on Keychain."
-  ].join("\n");
-}
-
-function preflightClaudeAuthMessage() {
-  if (settings.backend === "cursor") return null;
-  if (getClaudeOAuthToken().value) return null;
-  try {
-    const output = execSync(`"${CLAUDE_PATH}" auth status`, {
-      cwd: process.env.HOME || require("os").homedir(),
-      env: claudeSubprocessEnv(),
-      encoding: "utf8",
-      timeout: 10000,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-    if (isClaudeAuthErrorText(output)) return claudeAuthRecoveryMessage(output.trim().slice(-500));
-    return null;
-  } catch (e) {
-    const output = `${e.stdout || ""}\n${e.stderr || ""}\n${e.message || ""}`;
-    if (isClaudeAuthErrorText(output)) return claudeAuthRecoveryMessage(output.trim().slice(-500));
-    return null;
-  }
-}
-
-
-function isClaudeUsageLimitText(text) {
-  const lower = String(text || "").toLowerCase();
-  return lower.includes("usage limit") ||
-    lower.includes("you've hit your usage limit") ||
-    lower.includes("you have hit your usage limit") ||
-    lower.includes("spend limit") ||
-    lower.includes("monthly cycle") ||
-    lower.includes("rate limit") && lower.includes("model");
-}
-
-function claudeUsageLimitMessage(details = "") {
-  return [
-    "Claude ran, but the selected model is unavailable/limited right now.",
-    details ? `\nDetails:\n${redactSensitive(details)}` : "",
-    "",
-    "Try from Telegram:",
-    "1. /model sonnet",
-    "2. Then send your message again",
-    "",
-    "If you specifically need Opus, wait for the usage window to reset or increase the spend/usage limit."
-  ].filter(Boolean).join("\n");
-}
-
-function runClaudeAuthStatusDiagnostic() {
-  try {
-    const output = execSync(`"${CLAUDE_PATH}" auth status`, {
-      cwd: process.env.HOME || require("os").homedir(),
-      env: claudeSubprocessEnv(),
-      encoding: "utf8",
-      timeout: 10000,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-    return output.trim();
-  } catch (e) {
-    return `${e.stdout || ""}\n${e.stderr || ""}\n${e.message || ""}`.trim();
-  }
-}
-
-
-async function sendClaudeAuthStatusSummary(prefix = "Claude auth status") {
-  const output = runClaudeAuthStatusDiagnostic();
-  const tokenInfo = getClaudeOAuthToken();
-  const lines = summarizeClaudeAuthStatus(output, isClaudeAuthErrorText(output) ? 1 : 0, tokenInfo);
-  await send([
-    prefix,
-    "",
-    ...lines,
-    `Bot OAuth token: ${tokenInfo.value ? "configured via " + tokenInfo.source : "not configured"}`,
-  ].join("\n"));
-}
-
-function claudeEmptyFailureMessage(code, stderrText = "") {
-  const stderr = redactSensitive(String(stderrText || "").trim());
-  if (isClaudeUsageLimitText(stderr)) return claudeUsageLimitMessage(stderr.slice(-1200));
-  if (isClaudeAuthErrorText(stderr)) return claudeAuthRecoveryMessage(stderr.slice(-1200));
-
-  const authStatus = runClaudeAuthStatusDiagnostic();
-  if (isClaudeAuthErrorText(authStatus)) return claudeAuthRecoveryMessage(authStatus.slice(-1200));
-  if (isClaudeUsageLimitText(authStatus)) return claudeUsageLimitMessage(authStatus.slice(-1200));
-
-  return [
-    `Claude exited with code ${code} but produced no assistant output.`,
-    stderr ? `\nStderr:\n${stderr.slice(-1200)}` : "\nStderr: (empty)",
-    authStatus ? `\nAuth status:\n${redactSensitive(authStatus).slice(-1200)}` : "",
-    "",
-    "Useful next steps:",
-    "• /auth_status — verify Claude auth",
-    "• /model sonnet — switch away from Opus if usage-limited",
-    "• /setup_token — create a launchd-safe OAuth token if Keychain is the issue"
-  ].filter(Boolean).join("\n");
-}
-
-
-function summarizeClaudeAuthStatus(output, exitCode, tokenInfo) {
-  const text = String(output || "");
-  const lower = text.toLowerCase();
-  const loggedOut = /not (logged in|authenticated)|unauthenticated|no auth|login required/.test(lower);
-  const loggedIn = !loggedOut && (exitCode === 0 || /logged in|authenticated|claude\.ai|anthropic/.test(lower));
-  const email = (text.match(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i) || [null])[0];
-  const provider = /claude\.ai|claudeai/.test(lower) ? "Claude.ai" : (/anthropic/.test(lower) ? "Anthropic" : "unknown");
-  let method = tokenInfo.value ? `OAuth token (${tokenInfo.source})` : "unknown";
-  if (/api key|apikey/.test(lower)) method = "API key";
-  else if (/oauth|claude\.ai|claudeai/.test(lower)) method = tokenInfo.value ? `OAuth token (${tokenInfo.source})` : "OAuth/Claude.ai";
-  return [
-    `Logged in: ${loggedIn ? "yes" : (loggedOut ? "no" : "unknown")}`,
-    `Auth method: ${method}`,
-    `Email: ${email || "unknown"}`,
-    `Provider: ${provider}`,
-  ];
-}
-
-async function runClaudeAuthCommand(args, label, opts = {}) {
-  if (pendingClaudeAuthProcess) {
-    await send(`Another Claude auth flow is already running (${pendingClaudeAuthLabel}). Send the requested code/token or wait for it to finish.`);
-    return;
-  }
-  await send(`${label} started...`);
-  const proc = spawn(CLAUDE_PATH, args, {
-    cwd: process.env.HOME || require("os").homedir(),
-    env: claudeSubprocessEnv(),
-    stdio: ["pipe", "pipe", "pipe"],
-  });
-  pendingClaudeAuthProcess = proc;
-  pendingClaudeAuthLabel = label;
-  let output = "";
-  let sentUrls = new Set();
-  let tokenStored = false;
-  let lastSnippetAt = 0;
-
-  const handleChunk = async (chunk) => {
-    output += chunk;
-    const token = opts.captureToken ? extractClaudeToken(chunk) || extractClaudeToken(output) : null;
-    if (token && !tokenStored) {
-      tokenStored = saveClaudeOAuthToken(token);
-      await send(tokenStored ? "Claude OAuth token captured and stored. I did not print it." : "Claude OAuth token appeared, but I could not store it.");
-    }
-    for (const url of extractUrls(chunk)) {
-      if (!isClaudeAuthUrl(url)) continue;
-      if (!sentUrls.has(url)) {
-        sentUrls.add(url);
-        await send(`${label} URL:\n${redactSensitive(url)}\n\nOpen it, complete the flow, then paste any code Claude asks for here.`);
-      }
-    }
-    const redacted = redactSensitive(stripTerminalControls(chunk)).trim();
-    const now = Date.now();
-    const usefulAuthLine = /opening browser|paste code|enter code|login|auth|token|error|failed/i.test(redacted);
-    if (redacted && usefulAuthLine && now - lastSnippetAt > 3000 && !looksLikeClaudeToken(redacted) && !/github\.com\/vadimdemedes\/ink/i.test(redacted)) {
-      lastSnippetAt = now;
-      await send(redacted.length > 1200 ? redacted.slice(-1200) : redacted);
-    }
-  };
-
-  proc.stdout.on("data", (d) => handleChunk(d.toString()).catch((e) => console.error("Auth output error:", e.message)));
-  proc.stderr.on("data", (d) => handleChunk(d.toString()).catch((e) => console.error("Auth stderr error:", e.message)));
-  proc.on("close", async (code) => {
-    pendingClaudeAuthProcess = null;
-    pendingClaudeAuthLabel = null;
-    const token = opts.captureToken ? extractClaudeToken(output) : null;
-    if (token && !tokenStored) tokenStored = saveClaudeOAuthToken(token);
-    const cleaned = redactSensitive(stripTerminalControls(output))
-      .replace(/https?:\/\/github\.com\/vadimdemedes\/ink\S*/gi, "")
-      .trim();
-    const isTtyError = /raw mode is not supported|process\.stdin/i.test(output);
-    if (tokenStored) {
-      await send(`${label} finished. OAuth token stored for launchd/non-interactive Claude runs.`);
-      await sendClaudeAuthStatusSummary("Post-auth check:");
-    } else if (isTtyError && opts.captureToken) {
-      await send(`${label} cannot complete from this bot — the Claude CLI needs an interactive terminal for setup-token.\n\nRun this in your Mac terminal:\n  claude setup-token\n\nThen paste the token here with:\n  /use_oauth_token <token>`);
-    } else if (cleaned) {
-      await send(`${label} finished (exit ${code}).\n\n${cleaned.slice(-2500)}`);
-      await sendClaudeAuthStatusSummary("Post-auth check:");
-    } else {
-      await send(`${label} finished (exit ${code}).`);
-      await sendClaudeAuthStatusSummary("Post-auth check:");
-    }
-  });
-  proc.on("error", async (err) => {
-    pendingClaudeAuthProcess = null;
-    pendingClaudeAuthLabel = null;
-    await send(`${label} failed: ${redactSensitive(err.message)}`);
-  });
-}
-
-// ── Claude Runner ───────────────────────────────────────────────────
-
-function parseStreamEvents(data) {
-  const events = [];
-  for (const line of data.split("\n").filter((l) => l.trim())) {
-    try { events.push(JSON.parse(line)); } catch (e) { /* partial */ }
-  }
-  return events;
-}
-
-function buildClaudeArgs(prompt, opts = {}) {
-  if (settings.backend === "cursor") return buildCursorArgs(prompt, opts);
-  const args = ["-p", "--verbose", "--output-format", "stream-json",
-    "--append-system-prompt", buildSystemPrompt()];
-  if (opts.continueSession) args.push("--continue");
-  else if (lastSessionId && !opts.fresh) args.push("--resume", lastSessionId);
-  args.push("--model", settings.model || DEFAULT_CLAUDE_MODEL);
-  if (settings.effort) args.push("--effort", settings.effort);
-  if (settings.budget) args.push("--max-budget-usd", String(settings.budget));
-  if (settings.permissionMode) args.push("--permission-mode", settings.permissionMode);
-  else args.push("--dangerously-skip-permissions");
-  if (settings.worktree) args.push("--worktree");
-  args.push(prompt);
-  return args;
-}
-
-function buildCursorArgs(prompt, opts = {}) {
-  const args = ["--print", "--trust", "--output-format", "stream-json"];
-  if (opts.continueSession) args.push("--continue");
-  else if (cursorSessionId && !opts.fresh) args.push("--resume", cursorSessionId);
-  if (settings.model) args.push("--model", settings.model);
-  if (settings.permissionMode === "plan") args.push("--mode", "plan");
-  else if (settings.permissionMode === "ask") args.push("--mode", "ask");
-  if (settings.worktree) args.push("--worktree");
-  args.push(prompt);
-  return args;
-}
-
-function getActiveBinary() {
-  if (settings.backend === "cursor") return resolvedCursorPath;
-  return CLAUDE_PATH;
-}
-
-function getActiveSessionId() {
-  return settings.backend === "cursor" ? cursorSessionId : lastSessionId;
-}
-
-/**
- * Quick chat process — handles messages while a heavy task is running.
- * Uses a fresh session (no --resume) with context about what's running.
- */
-async function runClaudeChat(prompt, cwd, replyToMsgId) {
-  bot.sendChatAction(CHAT_ID, "typing").catch(() => {});
-
-  const contextPrompt = `A background task is currently running: "${runningProcessPrompt || "unknown task"}"\n` +
-    `The user sent a new message while that task is in progress. Answer their question or help them.\n` +
-    `If they're asking about the running task, let them know it's still working.\n` +
-    `Keep your response brief — this is a side conversation.\n\n` +
-    `User message: ${prompt}`;
-
-  const args = ["-p", "--verbose", "--output-format", "stream-json",
-    "--append-system-prompt", buildSystemPrompt(),
-    "--dangerously-skip-permissions"];
-  args.push("--model", settings.model || DEFAULT_CLAUDE_MODEL);
-  args.push(contextPrompt);
-
-  const proc = spawn(CLAUDE_PATH, args, {
-    cwd,
-    env: claudeSubprocessEnv(),
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-
-  chatProcesses.set(replyToMsgId, proc);
-  let chatText = "";
-  let chatBuf = "";
-
-  proc.stdout.on("data", (data) => {
-    chatBuf += data.toString();
-    const events = parseStreamEvents(chatBuf);
-    const lastNewline = chatBuf.lastIndexOf("\n");
-    chatBuf = lastNewline >= 0 ? chatBuf.slice(lastNewline + 1) : chatBuf;
-    for (const evt of events) {
-      if (evt.type === "assistant" && evt.message?.content) {
-        for (const block of evt.message.content) {
-          if (block.type === "text") chatText += block.text;
-        }
-      }
-      if (evt.type === "result" && evt.result) chatText = evt.result;
-    }
-  });
-
-  proc.on("close", async () => {
-    chatProcesses.delete(replyToMsgId);
-    const text = chatText || "(no response)";
-    const chunks = splitMessage(text);
-    const sent = await send(chunks[0], { replyTo: replyToMsgId });
-    if (!sent) await send(chunks[0]);
-    for (let i = 1; i < chunks.length; i++) await send(chunks[i]);
-  });
-
-  proc.on("error", async (err) => {
-    chatProcesses.delete(replyToMsgId);
-    await send(`Chat error: ${err.message}`, { replyTo: replyToMsgId });
-  });
-}
-
-async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
-  if (runningProcess) {
-    // Instead of queueing, spawn a lightweight chat process
-    await runClaudeChat(prompt, cwd, replyToMsgId);
-    return;
-  }
-
-  const authPreflight = preflightClaudeAuthMessage();
-  if (authPreflight) {
-    await send(authPreflight, { replyTo: replyToMsgId });
-    return;
-  }
-
-  bot.sendChatAction(CHAT_ID, "typing");
-  statusMessageId = null;
-  streamBuffer = "";
-  let assistantText = "";
-  let toolUses = [];
-  let currentTool = null;
-  let currentToolDetail = "";
-
-  const args = buildClaudeArgs(prompt, opts);
-  const binaryPath = getActiveBinary();
-  const proc = spawn(binaryPath, args, {
-    cwd,
-    env: claudeSubprocessEnv(),
-    stdio: ["ignore", "pipe", "pipe"],
-    detached: process.platform !== "win32", // Create process group so /stop kills children too
-  });
-
-  runningProcess = proc;
-  runningProcessPrompt = prompt.length > 100 ? prompt.slice(0, 97) + "..." : prompt;
-  const startTime = Date.now();
-  let longRunningNotified = false;
-
-  // Inactivity watchdog. The single-flight `runningProcess` flag is only
-  // cleared by this child's close/error events, so a child that hangs
-  // (e.g. a wedged tool call) pins the flag forever and demotes every later
-  // message to a side-chat. Track the last time the child produced output;
-  // if it goes silent past the idle limit, kill it so the flag clears and
-  // the bot responds again. Tune with OC_TURN_IDLE_MS (default 10min).
-  const idleLimitMs = Math.max(60000, parseInt(process.env.OC_TURN_IDLE_MS, 10) || 10 * 60 * 1000);
-  let lastActivity = Date.now();
-  let watchdogTripped = false;
-
-  let lastUpdate = "";
-  // Adaptive update interval: 2s for first 2min, then 5s to avoid rate limits
-  const scheduleUpdate = () => {
-    const elapsed = Math.floor((Date.now() - startTime) / 1000);
-    const interval = elapsed > 120 ? 5000 : 2000;
-    streamInterval = setTimeout(updateProgress, interval);
-  };
-  const updateProgress = async () => {
-    const elapsed = Math.floor((Date.now() - startTime) / 1000);
-    // Inactivity watchdog: kill a child that has gone silent past the idle limit.
-    if (!watchdogTripped && runningProcess === proc && Date.now() - lastActivity > idleLimitMs) {
-      watchdogTripped = true;
-      const idleMin = Math.floor((Date.now() - lastActivity) / 60000);
-      const pid = proc.pid;
-      console.error(`[watchdog] child pid ${pid} idle ${idleMin}min (limit ${Math.floor(idleLimitMs / 60000)}min) — killing`);
-      try { process.kill(-pid, "SIGTERM"); } catch (e) {
-        try { proc.kill("SIGTERM"); } catch (e2) {}
-      }
-      setTimeout(() => { try { process.kill(-pid, "SIGKILL"); } catch (e) {} }, 3000);
-      // Failsafe: if close never fires, force-clear so the bot recovers anyway.
-      setTimeout(() => {
-        if (runningProcess === proc) {
-          runningProcess = null; runningProcessPrompt = null;
-          clearTimeout(streamInterval); streamInterval = null;
-        }
-      }, 10000);
-      try {
-        await send(`Task stalled — no activity for ${idleMin}min, so I stopped it and I'm responsive again. Send /continue to resume, or just re-ask.`);
-      } catch (e) {}
-      statusMessageId = null;
-      return; // stop the progress loop; close (or failsafe) clears state
-    }
-    try {
-      bot.sendChatAction(CHAT_ID, "typing").catch(() => {});
-      const display = formatProgress(assistantText, toolUses, currentTool, elapsed, currentToolDetail);
-      if (display && display !== lastUpdate) {
-        if (!statusMessageId && assistantText) {
-          statusMessageId = await send(display.length > 4000 ? display.slice(-4000) : display, { replyTo: replyToMsgId });
-        } else if (statusMessageId) {
-          await editMessage(statusMessageId, display.length > 4000 ? display.slice(-4000) : display);
-        }
-        lastUpdate = display;
-      }
-      // Notify after 5 minutes that it's still running
-      if (elapsed > 300 && !longRunningNotified) {
-        longRunningNotified = true;
-        await send(`Still working (${Math.floor(elapsed / 60)}min)... Send /stop to cancel.`);
-      }
-    } catch (e) {
-      console.error("Progress update error:", e.message);
-    }
-    if (runningProcess) scheduleUpdate();
-  };
-  scheduleUpdate();
-
-  proc.stdout.on("data", (data) => {
-    lastActivity = Date.now();
-    streamBuffer += data.toString();
-    const events = parseStreamEvents(streamBuffer);
-    const lastNewline = streamBuffer.lastIndexOf("\n");
-    streamBuffer = lastNewline >= 0 ? streamBuffer.slice(lastNewline + 1) : streamBuffer;
-    for (const evt of events) {
-      if (evt.type === "assistant" && evt.message?.content) {
-        for (const block of evt.message.content) {
-          if (block.type === "text") assistantText += block.text;
-          else if (block.type === "tool_use") {
-            currentTool = block.name;
-            toolUses.push(block.name);
-            const input = block.input || {};
-            if (block.name === "Bash" && input.command) currentToolDetail = input.command.slice(0, 80);
-            else if (block.name === "Read" && input.file_path) currentToolDetail = input.file_path.split("/").slice(-2).join("/");
-            else if (block.name === "Edit" && input.file_path) currentToolDetail = input.file_path.split("/").slice(-2).join("/");
-            else if (block.name === "Write" && input.file_path) currentToolDetail = input.file_path.split("/").slice(-2).join("/");
-            else if (block.name === "Grep" && input.pattern) currentToolDetail = input.pattern.slice(0, 40);
-            else if (block.name === "Glob" && input.pattern) currentToolDetail = input.pattern;
-            else currentToolDetail = "";
-          }
-        }
-      }
-      // Cursor Agent tool_call events (different format from Claude's tool_use blocks)
-      if (evt.type === "tool_call" && evt.subtype === "started" && evt.tool_call) {
-        const tc = evt.tool_call;
-        if (tc.shellToolCall) {
-          const a = tc.shellToolCall.args || {};
-          currentTool = "Shell"; toolUses.push("Shell");
-          currentToolDetail = (a.description || a.command || "").slice(0, 80);
-        } else if (tc.readToolCall) {
-          currentTool = "Read"; toolUses.push("Read");
-          currentToolDetail = (tc.readToolCall.args?.path || "").split("/").slice(-2).join("/");
-        } else if (tc.editToolCall) {
-          currentTool = "Edit"; toolUses.push("Edit");
-          currentToolDetail = (tc.editToolCall.args?.filePath || "").split("/").slice(-2).join("/");
-        } else if (tc.writeToolCall) {
-          currentTool = "Write"; toolUses.push("Write");
-          currentToolDetail = (tc.writeToolCall.args?.filePath || "").split("/").slice(-2).join("/");
-        } else if (tc.grepToolCall) {
-          currentTool = "Grep"; toolUses.push("Grep");
-          currentToolDetail = (tc.grepToolCall.args?.pattern || "").slice(0, 40);
-        } else if (tc.globToolCall) {
-          currentTool = "Glob"; toolUses.push("Glob");
-          currentToolDetail = (tc.globToolCall.args?.globPattern || "").slice(0, 40);
-        } else if (tc.createPlanToolCall) {
-          currentTool = "Plan"; toolUses.push("Plan");
-          const plan = tc.createPlanToolCall.args || {};
-          let planText = "";
-          if (plan.name) planText += `**${plan.name}**\n\n`;
-          if (plan.plan) planText += plan.plan + "\n";
-          if (plan.todos && plan.todos.length) {
-            planText += "\n**Tasks:**\n";
-            for (const todo of plan.todos) {
-              planText += `• ${todo.content || todo.id}\n`;
-            }
-          }
-          if (planText) assistantText = planText;
-          currentToolDetail = plan.name || "creating plan";
-        } else {
-          const toolKey = Object.keys(tc)[0] || "unknown";
-          currentTool = toolKey.replace("ToolCall", ""); toolUses.push(currentTool);
-          currentToolDetail = "";
-        }
-      }
-      if (evt.type === "result" && evt.session_id) {
-        if (settings.backend === "cursor") { cursorSessionId = evt.session_id; }
-        else { lastSessionId = evt.session_id; }
-        saveState();
-      }
-      if (evt.type === "result" && evt.result) assistantText = evt.result;
-    }
-  });
-
-  let stderrBuffer = "";
-  proc.stderr.on("data", (d) => {
-    lastActivity = Date.now();
-    const chunk = d.toString();
-    stderrBuffer += chunk;
-    console.error("STDERR:", redactSensitive(chunk));
-  });
-
-  proc.on("close", async (code) => {
-    runningProcess = null; runningProcessPrompt = null;
-    clearTimeout(streamInterval); streamInterval = null;
-    if (watchdogTripped) {
-      // The inactivity watchdog already notified the user and killed the
-      // child; don't also deliver partial / "(no output)" text.
-      statusMessageId = null;
-      if (settings.budget) settings.budget = null;
-      return;
-    }
-    if (settings.backend !== "cursor" && isClaudeAuthErrorText(stderrBuffer)) {
-      await send(claudeAuthRecoveryMessage(stderrBuffer.trim().slice(-800)), { replyTo: replyToMsgId });
-      return;
-    }
-    if (settings.backend === "cursor" && isClaudeAuthErrorText(stderrBuffer)) {
-      await send("Cursor authentication error. Run `agent login` on this machine, then retry.", { replyTo: replyToMsgId });
-      return;
-    }
-    try {
-      if (code !== 0 && code !== null && !assistantText.trim()) {
-        await send(claudeEmptyFailureMessage(code, stderrBuffer), { replyTo: replyToMsgId });
-        return;
-      }
-
-      const finalText = redactSensitive(assistantText || "(no output)");
-      const chunks = splitMessage(finalText);
-      const firstChunk = chunks[0];
-
-      if (statusMessageId && chunks.length === 1) {
-        await editMessage(statusMessageId, firstChunk);
-      } else {
-        const sent = await send(firstChunk, { replyTo: replyToMsgId });
-        if (!sent) await send(firstChunk);
-        for (let i = 1; i < chunks.length; i++) {
-          await send(chunks[i]);
-        }
-      }
-      if (code !== 0 && code !== null) await send(`Exit code: ${code}`);
-
-      // Spoken auto-replies on voice input are off by default on chat
-      // transports (they were unwanted noise on Telegram). Opt in with
-      // VOICE_REPLY_ON_VOICE=1. The hands-free voice channel speaks back
-      // regardless via its own path.
-      if (lastInputWasVoice) {
-        lastInputWasVoice = false;
-        if (process.env.VOICE_REPLY_ON_VOICE === "1") {
-          const voicePath = await textToVoice(finalText);
-          if (voicePath) await sendVoice(voicePath);
-        }
-      }
-    } catch (e) {
-      console.error("Final message delivery failed:", e.message);
-      await send("Task completed but failed to deliver the response. Send /continue to see the result.");
-    }
-    if (settings.budget) settings.budget = null;
-    statusMessageId = null;
-
-    // Record session with auto-title from first message
-    if (lastSessionId && currentSession) {
-      const title = isFirstMessage ? (prompt.length > 60 ? prompt.slice(0, 57) + "..." : prompt) : null;
-      recordSession(currentSession.name, lastSessionId, title);
-      isFirstMessage = false;
-    }
-    if (messageQueue.length > 0 && currentSession) {
-      const next = messageQueue.shift();
-      await runClaude(next.prompt, currentSession.dir, next.replyToMsgId, next.opts);
-    }
-  });
-
-  proc.on("error", async (err) => {
-    runningProcess = null; runningProcessPrompt = null; clearTimeout(streamInterval);
-    await send(`Error: ${err.message}`); statusMessageId = null;
-  });
-}
-
-async function runClaudeSilent(prompt, cwd, label) {
-  return new Promise((resolve) => {
-    const args = ["-p", "--output-format", "text", "--verbose",
-      "--append-system-prompt", buildSystemPrompt(),
-      "--dangerously-skip-permissions", prompt];
-    const proc = spawn(CLAUDE_PATH, args, {
-      cwd, env: claudeSubprocessEnv(),
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-    let output = "";
-    proc.stdout.on("data", (d) => { output += d.toString(); });
-    proc.on("close", async () => {
-      const chunks = splitMessage(`Cron: ${label}\n\n${redactSensitive(output.trim() || "(no output)")}`);
-      for (const c of chunks) await send(c);
-      resolve();
-    });
-    proc.on("error", async (err) => { await send(`Cron "${label}" failed: ${err.message}`); resolve(); });
-  });
-}
-
-function formatProgress(text, tools, currentTool, elapsed, toolDetail) {
-  const mins = Math.floor(elapsed / 60);
-  const secs = elapsed % 60;
-  const time = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
-
-  const parts = [];
-  let status = currentTool ? `Working: ${currentTool}` : (tools.length > 0 ? "Processing..." : "Thinking...");
-  if (currentTool && toolDetail) status += ` — ${toolDetail}`;
-  parts.push(`${status} (${time})`);
-  if (tools.length > 1) parts.push(`Steps: ${[...new Set(tools)].join(" > ")}`);
-  if (text) parts.push(text.length > 800 ? "..." + text.slice(-800) : text);
-  return parts.join("\n\n");
-}
-
-// ── Cron System ─────────────────────────────────────────────────────
-
-function scheduleCron(c) {
-  const cwd = path.join(WORKSPACE, c.project);
-  if (activeCrons.has(c.id)) activeCrons.get(c.id).task.stop();
-  const task = cron.schedule(c.schedule, () => runClaudeSilent(c.prompt, cwd, c.label));
-  activeCrons.set(c.id, { task, config: c });
-}
-
-function initCrons() {
-  for (const c of loadCrons()) { try { scheduleCron(c); } catch (e) { console.error("Cron error:", e.message); } }
-  console.log(`Loaded ${loadCrons().length} cron(s)`);
-}
-
-// ── Session ─────────────────────────────────────────────────────────
-
-function startSession(name, resumeSessionId) {
-  let projectName, projectDir;
-  if (name === "__workspace__") {
-    projectName = "Workspace";
-    projectDir = WORKSPACE;
-  } else {
-    const result = findProject(name);
-    if (!result) return send(`No match for "${name}".`, { keyboard: projectKeyboard() });
-    if (Array.isArray(result)) return send("Multiple matches:", { keyboard: { inline_keyboard: result.map((p) => [{ text: p, callback_data: `s:${p}` }]) } });
-    projectName = result;
-    projectDir = path.join(WORKSPACE, result);
-  }
-
-  currentSession = { name: projectName, dir: projectDir };
-  messageQueue = []; resetSettings();
-
-  // Resume a specific session or the last one for this project
-  if (resumeSessionId) {
-    lastSessionId = resumeSessionId;
-    const sessions = getProjectSessions(projectName);
-    const s = sessions.find((x) => x.id === resumeSessionId);
-    const title = s ? s.title : "";
-    isFirstMessage = false;
-    saveState();
-    send(`Session: ${projectName}\nResumed: ${title || resumeSessionId.slice(0, 8)}\n\nSend text, voice, or images.\n\n/sessions — switch conversation\n/session — switch project`);
-  } else {
-    const last = getLastProjectSession(projectName);
-    if (last) {
-      lastSessionId = last.id;
-      isFirstMessage = false;
-      saveState();
-      send(`Session: ${projectName}\nResumed: ${last.title}\n\nSend text, voice, or images.\n\n/sessions — switch conversation\n/session — switch project`, {
-        keyboard: { inline_keyboard: [[{ text: "New conversation", callback_data: `new:${projectName}` }]] },
-      });
-    } else {
-      lastSessionId = null;
-      isFirstMessage = true;
-      saveState();
-      send(`Session: ${projectName}\n\nSend text, voice, or images.\n\n/sessions — switch conversation\n/session — switch project`);
-    }
-  }
-}
-
-function requireSession(msg) {
-  if (!currentSession) { send("Pick a project first:", { keyboard: projectKeyboard() }); return false; }
-  return true;
-}
-
-// ── Commands ────────────────────────────────────────────────────────
-
-bot.onText(/\/start/, (msg) => {
-  if (!isAuthorized(msg)) return;
-  if (!isOnboarded()) return startOnboarding();
-  send("Pick a project to start:", { keyboard: { inline_keyboard: [[{ text: "Pick a project", callback_data: "show:projects" }]] } });
-});
-
-bot.onText(/\/help/, (msg) => {
-  if (!isAuthorized(msg)) return;
-  send([
-    "Session: /session /sessions /projects /continue /status /stop /end",
-    "Settings: /model /effort /budget /plan /compact /worktree /mode",
-    "Automation: /cron /vault /soul",
-    "Claude auth: /auth_status /login /setup_token /use_oauth_token /clear_oauth_token",
-    "System: /restart /upgrade",
-    "",
-    "Send text, voice, photos, or files.",
-    "Reply to any message for context.",
-  ].join("\n"));
-});
-
-bot.onText(/\/version$/, (msg) => {
-  if (!isAuthorized(msg)) return;
-  send(`Open Claudia v${CURRENT_VERSION}`);
-});
-
-bot.onText(/\/restart$/, async (msg) => {
-  if (!isOwner(msg)) return;
-  await send("Going offline for a quick restart — back in a moment.");
-  setTimeout(() => process.exit(0), 1000);
-});
-
-bot.onText(/\/upgrade$/, async (msg) => {
-  if (!isOwner(msg)) return;
-  try { process.chdir(process.env.HOME || require("os").homedir()); } catch (e) { /* already gone */ }
-  // Check if there's actually a newer version
-  let latest = null;
-  try {
-    latest = execSync("npm view @inetafrica/open-claudia version", {
-      encoding: "utf-8", timeout: 15000,
-      env: { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME || require("os").homedir() },
-    }).trim();
-    if (!isNewerVersion(latest, CURRENT_VERSION)) {
-      await send(`Already on the latest version (v${CURRENT_VERSION}).`);
-      return;
-    }
-    await send(`Upgrading v${CURRENT_VERSION} → v${latest}...`);
-  } catch (e) {
-    await send("Upgrading...");
-  }
-  try {
-    execSync(`npm install -g @inetafrica/open-claudia@${latest} 2>&1`, {
-      encoding: "utf-8", timeout: 120000,
-      cwd: process.env.HOME || require("os").homedir(),
-      env: { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME || require("os").homedir() },
-    });
-    // Read version and changelog from newly installed package
-    const root = execSync("npm root -g", { encoding: "utf-8", cwd: process.env.HOME || require("os").homedir(), env: { ...process.env, PATH: FULL_PATH } }).trim();
-    const newPkg = JSON.parse(fs.readFileSync(path.join(root, "@inetafrica", "open-claudia", "package.json"), "utf-8"));
-    let whatsNew = "";
-    try {
-      const changelog = fs.readFileSync(path.join(root, "@inetafrica", "open-claudia", "CHANGELOG.md"), "utf-8");
-      let versionHeader = `## v${newPkg.version}`;
-      let start = changelog.indexOf(versionHeader);
-      if (start < 0) { versionHeader = `## ${newPkg.version}`; start = changelog.indexOf(versionHeader); }
-      if (start >= 0) {
-        const afterHeader = changelog.slice(start + versionHeader.length);
-        const nextVersion = afterHeader.indexOf("\n## ");
-        const section = nextVersion >= 0 ? afterHeader.slice(0, nextVersion) : afterHeader;
-        whatsNew = section.trim();
-      }
-    } catch (e) { /* no changelog */ }
-    const msg = `Installed v${newPkg.version}.${whatsNew ? `\n\nWhat's new:\n${whatsNew}` : ""}\n\nGoing offline to restart...`;
-    await send(msg);
-  } catch (e) {
-    const errOutput = (e.stdout || e.stderr || e.message || "").slice(-500);
-    await send(`Upgrade failed:\n${errOutput}`);
-    return;
-  }
-  // Give Telegram time to deliver the message, then exit for launchd to restart
-  setTimeout(() => process.exit(0), 2000);
-});
-
-bot.onText(/\/projects$/, (msg) => { if (isAuthorized(msg)) send("Pick:", { keyboard: projectKeyboard() }); });
-bot.onText(/\/session$/, (msg) => {
-  if (!isAuthorized(msg)) return;
-  if (currentSession) send(`Active: ${currentSession.name}\n\nSwitch?`, { keyboard: projectKeyboard() });
-  else send("Pick:", { keyboard: projectKeyboard() });
-});
-bot.onText(/\/session (.+)/, (msg, match) => { if (isAuthorized(msg)) startSession(match[1].trim()); });
-
-bot.onText(/\/sessions$/, (msg) => {
-  if (!isAuthorized(msg)) return;
-  if (!requireSession(msg)) return;
-  const sessions = getProjectSessions(currentSession.name);
-  if (sessions.length === 0) return send("No past conversations for this project.");
-  const rows = sessions.slice(0, 10).map((s) => {
-    const date = new Date(s.lastUsed).toLocaleDateString();
-    const active = lastSessionId === s.id ? " (active)" : "";
-    return [{ text: `${s.title}${active} — ${date}`, callback_data: `ss:${s.id}` }];
-  });
-  rows.push([{ text: "New conversation", callback_data: `new:${currentSession.name}` }]);
-  send(`Conversations in ${currentSession.name}:`, { keyboard: { inline_keyboard: rows } });
-});
-
-bot.onText(/\/model$/, (msg) => {
-  if (!isAuthorized(msg)) return;
-  const keyboard = settings.backend === "cursor" ? [
-    [{ text: "Composer 2", callback_data: "m:composer-2" }, { text: "Composer 2 Fast", callback_data: "m:composer-2-fast" }],
-    [{ text: "Opus 4.6 Thinking", callback_data: "m:claude-4.6-opus-high-thinking" }, { text: "Sonnet 4.6", callback_data: "m:claude-4.6-sonnet-medium" }],
-    [{ text: "GPT-5.4", callback_data: "m:gpt-5.4-medium" }, { text: "GPT-5.4 High", callback_data: "m:gpt-5.4-high" }],
-    [{ text: "Auto", callback_data: "m:auto" }, { text: "Default", callback_data: "m:default" }],
-  ] : [
-    [{ text: "Fable 5", callback_data: "m:claude-fable-5" }, { text: "Opus 4.8", callback_data: "m:claude-opus-4-8" }],
-    [{ text: "Opus 4.7", callback_data: "m:claude-opus-4-7" }, { text: "Sonnet", callback_data: "m:sonnet" }],
-    [{ text: "Haiku", callback_data: "m:haiku" }, { text: "Default", callback_data: "m:default" }],
-  ];
-  const label = settings.backend === "cursor" ? "Cursor Agent" : "Claude Code";
-  send(`${label} model: ${settings.model || "default"}\n\nOr type /model <name> for any model.`, { keyboard: { inline_keyboard: keyboard } });
-});
-bot.onText(/\/model (.+)/, (msg, match) => { if (!isAuthorized(msg)) return; settings.model = match[1].trim().toLowerCase(); if (settings.model === "default") settings.model = null; send(`Model: ${settings.model || "default"}`); });
-
-bot.onText(/\/effort$/, (msg) => {
-  if (!isAuthorized(msg)) return;
-  if (settings.backend === "cursor") return send("Effort levels are not supported on Cursor Agent.\nSwitch to Claude with /claude to use this.");
-  send(`Effort: ${settings.effort || "default"}`, { keyboard: { inline_keyboard: [
-    [{ text: "Low", callback_data: "e:low" }, { text: "Med", callback_data: "e:medium" }, { text: "High", callback_data: "e:high" }, { text: "Max", callback_data: "e:max" }],
-    [{ text: "Default", callback_data: "e:default" }],
-  ] } });
-});
-bot.onText(/\/effort (.+)/, (msg, match) => {
-  if (!isAuthorized(msg)) return;
-  if (settings.backend === "cursor") return send("Effort levels are not supported on Cursor Agent.");
-  const e = match[1].trim().toLowerCase(); settings.effort = ["low","medium","high","max"].includes(e) ? e : null; send(`Effort: ${settings.effort || "default"}`);
-});
-
-bot.onText(/\/budget$/, (msg) => {
-  if (!isAuthorized(msg)) return;
-  if (settings.backend === "cursor") return send("Budget limits are not supported on Cursor Agent.\nSwitch to Claude with /claude to use this.");
-  send(`Budget: ${settings.budget ? "$" + settings.budget : "none"}`, { keyboard: { inline_keyboard: [
-    [{ text: "$1", callback_data: "b:1" }, { text: "$5", callback_data: "b:5" }, { text: "$10", callback_data: "b:10" }, { text: "$25", callback_data: "b:25" }],
-    [{ text: "No limit", callback_data: "b:none" }],
-  ] } });
-});
-bot.onText(/\/budget (.+)/, (msg, match) => {
-  if (!isAuthorized(msg)) return;
-  if (settings.backend === "cursor") return send("Budget limits are not supported on Cursor Agent.");
-  const v = parseFloat(match[1].replace("$","")); settings.budget = v > 0 ? v : null; send(`Budget: ${settings.budget ? "$"+settings.budget : "none"}`);
-});
-
-bot.onText(/\/plan$/, (msg) => {
-  if (!isAuthorized(msg)) return;
-  const p = settings.permissionMode === "plan";
-  settings.permissionMode = p ? null : "plan";
-  const label = settings.backend === "cursor" ? "read-only planning, no edits" : "plan permission mode";
-  send(p ? "Plan mode off." : `Plan mode on (${label}).`);
-});
-bot.onText(/\/ask$/, (msg) => {
-  if (!isAuthorized(msg)) return;
-  if (settings.backend !== "cursor") return send("Ask mode is only available on Cursor Agent.\nUse /cursor to switch.");
-  const a = settings.permissionMode === "ask";
-  settings.permissionMode = a ? null : "ask";
-  send(a ? "Ask mode off." : "Ask mode on (read-only Q&A, no edits).");
-});
-bot.onText(/\/compact/, async (msg) => { if (!isAuthorized(msg)) return; if (!requireSession(msg)) return; if (!getActiveSessionId()) return send("No conversation."); await runClaude("Summarize: key decisions, code state, next steps.", currentSession.dir, msg.message_id); });
-bot.onText(/\/continue$/, async (msg) => { if (!isAuthorized(msg)) return; if (!requireSession(msg)) return; await runClaude("continue where we left off", currentSession.dir, msg.message_id, { continueSession: true }); });
-bot.onText(/\/worktree$/, (msg) => { if (!isAuthorized(msg)) return; settings.worktree = !settings.worktree; send(settings.worktree ? "Worktree on." : "Worktree off."); });
-
-bot.onText(/\/cursor$/, async (msg) => {
-  if (!isAuthorized(msg)) return;
-  if (!resolvedCursorPath) return send("Cursor Agent CLI not found.\nSet CURSOR_PATH in .env or install: https://docs.cursor.com/agent");
-  settings.backend = "cursor";
-  settings.model = null;
-  saveState();
-  const sid = cursorSessionId ? `\nSession: ${cursorSessionId.slice(0, 8)}...` : "\nNew session.";
-  send(`Switched to Cursor Agent.${sid}\n\n/claude — switch back`);
-});
-
-bot.onText(/\/claude$/, async (msg) => {
-  if (!isAuthorized(msg)) return;
-  settings.backend = "claude";
-  settings.model = null;
-  saveState();
-  const sid = lastSessionId ? `\nSession: ${lastSessionId.slice(0, 8)}...` : "\nNew session.";
-  send(`Switched to Claude Code.${sid}\n\n/cursor — switch to Cursor`);
-});
-
-bot.onText(/\/backend$/, async (msg) => {
-  if (!isAuthorized(msg)) return;
-  const label = settings.backend === "cursor" ? "Cursor Agent" : "Claude Code";
-  const cursorAvail = resolvedCursorPath ? "available" : "not found";
-  send(`Backend: ${label}\n\nClaude Code: available\nCursor Agent: ${cursorAvail}`, { keyboard: { inline_keyboard: [
-    [{ text: "Claude Code", callback_data: "be:claude" }, { text: "Cursor Agent", callback_data: "be:cursor" }],
-  ] } });
-});
-
-bot.onText(/\/mode$/, async (msg) => {
-  if (!isAuthorized(msg)) return;
-  await send("Bot mode: *agent* (non-blocking)\n\nHeavy tasks run in the background. You can keep chatting while they work.\nSwitch to direct mode for serial execution with shared session context.", {
-    parseMode: "Markdown",
-    keyboard: { inline_keyboard: [
-      [{ text: "Switch to Direct Mode", callback_data: "mode:direct" }],
-    ] },
-  });
-});
-
-bot.onText(/\/stop/, async (msg) => {
-  if (!isAuthorized(msg)) return;
-  let stopped = false;
-  if (runningProcess) {
-    const pid = runningProcess.pid;
-    try { process.kill(-pid, "SIGTERM"); } catch (e) {
-      try { runningProcess.kill("SIGTERM"); } catch (e2) {}
-    }
-    setTimeout(() => { try { process.kill(-pid, "SIGKILL"); } catch (e) {} }, 3000);
-    runningProcess = null; runningProcessPrompt = null;
-    if (streamInterval) clearTimeout(streamInterval);
-    stopped = true;
-  }
-  // Also kill any chat processes
-  for (const [id, proc] of chatProcesses) {
-    try { proc.kill("SIGTERM"); } catch (e) {}
-  }
-  if (chatProcesses.size > 0) { chatProcesses.clear(); stopped = true; }
-  messageQueue = [];
-  await send(stopped ? "Cancelled." : "Nothing running.");
-});
-
-bot.onText(/\/status/, (msg) => {
-  if (!isAuthorized(msg)) return;
-  if (!currentSession) return send("No session.", { keyboard: { inline_keyboard: [[{ text: "Pick", callback_data: "show:projects" }]] } });
-  const backendLabel = settings.backend === "cursor" ? "Cursor Agent" : "Claude Code";
-  const lines = [
-    `Project: ${currentSession.name} (agent mode)`,
-    `Backend: ${backendLabel}`,
-    `Model: ${settings.model || "default"} | Effort: ${settings.effort || "default"}`,
-    `Vault: ${vault.isUnlocked() ? "unlocked" : "locked"} | Crons: ${activeCrons.size}`,
-  ];
-  if (runningProcess) {
-    lines.push(`Background task: ${runningProcessPrompt || "working..."}`);
-    if (chatProcesses.size > 0) lines.push(`Chat processes: ${chatProcesses.size}`);
-    lines.push("Send messages — I'll respond via a side channel while the task runs.");
-  } else {
-    lines.push("Ready.");
-  }
-  send(lines.join("\n"));
-});
-
-bot.onText(/\/end/, (msg) => {
-  if (!isAuthorized(msg)) return;
-  if (currentSession) {
-    const n = currentSession.name; currentSession = null; lastSessionId = null; messageQueue = []; resetSettings();
-    saveState();
-    send(`Ended: ${n}`, { keyboard: { inline_keyboard: [[{ text: "New session", callback_data: "show:projects" }]] } });
-  } else send("No session.");
-});
-
-bot.onText(/\/soul$/, async (msg) => {
-  if (!isAuthorized(msg)) return;
-  const soul = loadSoul();
-  const preview = soul.length > 3000 ? soul.slice(0, 3000) + "\n..." : soul;
-  await send(preview);
-  await send(`Edit: ${SOUL_FILE}\nOr tell me what to change and I'll update it.`);
-});
-
-// ── Claude Auth Commands ────────────────────────────────────────────
-
-bot.onText(/\/(?:auth_status|auth status)$/, async (msg) => {
-  if (!isAuthorized(msg)) return;
-  const tokenInfo = getClaudeOAuthToken();
-  const proc = spawn(CLAUDE_PATH, ["auth", "status"], {
-    cwd: process.env.HOME || require("os").homedir(),
-    env: claudeSubprocessEnv(),
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-  let output = "";
-  proc.stdout.on("data", (d) => { output += d.toString(); });
-  proc.stderr.on("data", (d) => { output += d.toString(); });
-  proc.on("close", async (code) => {
-    const clean = redactSensitive(output.trim()) || "(no output)";
-    await send([
-      `Claude auth status: exit ${code}`,
-      ...summarizeClaudeAuthStatus(output, code, tokenInfo),
-      `Bot OAuth token: ${tokenInfo.value ? "configured via " + tokenInfo.source : "not configured"}`,
-      `Vault: ${vault.isUnlocked() ? "unlocked" : "locked"}`,
-      "",
-      clean.slice(-2500),
-    ].join("\n"));
-  });
-  proc.on("error", async (err) => send(`Claude auth status failed: ${redactSensitive(err.message)}`));
-});
-
-bot.onText(/\/cancel_auth$/, async (msg) => {
-  if (!isAuthorized(msg)) return;
-  if (!pendingClaudeAuthProcess) return send("No Claude auth flow is pending.");
-  clearPendingClaudeAuth();
-  await send("Claude auth flow cancelled. Normal messages will go to the assistant again.");
-});
-
-bot.onText(/\/auth_code(?:\s+(.+))?$/, async (msg, match) => {
-  if (!isAuthorized(msg)) return;
-  const code = (match[1] || "").trim();
-  await deleteMessage(msg.message_id);
-  if (!pendingClaudeAuthProcess || pendingClaudeAuthLabel === "manual OAuth token save") {
-    return send("No Claude login flow is waiting for an auth code. Start with /login, or use /use_oauth_token for tokens.");
-  }
-  if (!code || !looksLikeClaudeAuthReply(code)) {
-    return send("That does not look like a Claude auth code/callback. Use /cancel_auth to cancel the login flow.");
-  }
-  try {
-    pendingClaudeAuthProcess.stdin.write(code + "\n");
-    await send("Auth code sent to Claude. I’ll confirm with auth status when Claude finishes.");
-  } catch (e) {
-    clearPendingClaudeAuth();
-    await send(`Could not send auth code to Claude: ${redactSensitive(e.message)}`);
-  }
-});
-
-bot.onText(/\/login$/, async (msg) => {
-  if (!isAuthorized(msg)) return;
-  await runClaudeAuthCommand(["auth", "login", "--claudeai", "--email", "sumeet@inet.africa"], "Claude login");
-});
-
-bot.onText(/\/setup_token$/, async (msg) => {
-  if (!isAuthorized(msg)) return;
-  await runClaudeAuthCommand(["setup-token"], "Claude setup-token", { captureToken: true });
-});
-
-bot.onText(/\/use_oauth_token(?:\s+(.+))?$/, async (msg, match) => {
-  if (!isAuthorized(msg)) return;
-  const token = (match[1] || "").trim();
-  await deleteMessage(msg.message_id);
-  if (!token) {
-    pendingClaudeAuthProcess = { stdin: { write: (value) => saveClaudeOAuthToken(value.trim()) } };
-    pendingClaudeAuthLabel = "manual OAuth token save";
-    await send("Send the Claude OAuth token in your next message. I'll delete it and store it without echoing it.");
-    return;
-  }
-  if (!looksLikeClaudeToken(token)) return send("That doesn't look like a Claude OAuth token. Not saved.");
-  saveClaudeOAuthToken(token);
-  await send(`Claude OAuth token stored in .env${vault.isUnlocked() ? " and vault" : ""}. Restart the bot so launchd picks it up, or use /restart.`);
-  await sendClaudeAuthStatusSummary("Stored token. Current Claude auth status:");
-});
-
-bot.onText(/\/clear_oauth_token$/, async (msg) => {
-  if (!isAuthorized(msg)) return;
-  clearClaudeOAuthToken();
-  await send("Claude OAuth token cleared from .env/process" + (vault.isUnlocked() ? " and vault." : ". Unlock vault and run again if you also stored it there."));
-});
-
-// ── /vault with password protection ─────────────────────────────────
-
-bot.onText(/\/vault$/, async (msg) => {
-  if (!isAuthorized(msg)) return;
-  if (!vault.exists()) {
-    await send("No vault found. Run setup first: node setup.js");
-    return;
-  }
-  if (vault.isUnlocked()) {
-    const entries = vault.list();
-    const keys = Object.keys(entries);
-    if (keys.length === 0) await send("Vault is unlocked but empty.\n\nUse /vault set <name> <value>");
-    else await send("Vault (unlocked):\n\n" + keys.map(k => `${k}: ${entries[k]}`).join("\n") + "\n\nLocks automatically in 5 min.");
-  } else {
-    pendingVaultUnlock = true;
-    pendingVaultAction = { type: "list" };
-    await send("Vault is locked. Send your vault password.\n(Message will be deleted after reading)");
-  }
-});
-
-bot.onText(/\/vault set (\S+) (.+)/, async (msg, match) => {
-  if (!isAuthorized(msg)) return;
-  // Delete the message containing the value immediately
-  await deleteMessage(msg.message_id);
-  if (vault.isUnlocked()) {
-    vault.set(match[1], match[2].trim());
-    await send(`Saved: ${match[1]}`);
-  } else {
-    pendingVaultUnlock = true;
-    pendingVaultAction = { type: "set", key: match[1], value: match[2].trim() };
-    await send("Vault locked. Send password to unlock.");
-  }
-});
-
-bot.onText(/\/vault remove (\S+)/, async (msg, match) => {
-  if (!isAuthorized(msg)) return;
-  if (vault.isUnlocked()) {
-    vault.remove(match[1]);
-    await send(`Removed: ${match[1]}`);
-  } else {
-    pendingVaultUnlock = true;
-    pendingVaultAction = { type: "remove", key: match[1] };
-    await send("Vault locked. Send password to unlock.");
-  }
-});
-
-bot.onText(/\/vault lock/, async (msg) => {
-  if (!isAuthorized(msg)) return;
-  vault.lock();
-  await send("Vault locked.");
-});
-
-// ── /cron ───────────────────────────────────────────────────────────
-
-bot.onText(/\/cron$/, (msg) => {
-  if (!isAuthorized(msg)) return;
-  const list = loadCrons();
-  if (list.length === 0) {
-    send("No crons.\n\nAdd: /cron add \"<schedule>\" <project> \"<prompt>\"\n\nOr pick a preset:", {
-      keyboard: { inline_keyboard: [
-        [{ text: "Standup 9am", callback_data: "cp:standup" }, { text: "Git digest 6pm", callback_data: "cp:git" }],
-        [{ text: "Dep check Mon", callback_data: "cp:deps" }, { text: "Health 30min", callback_data: "cp:health" }],
-      ] },
-    });
-  } else {
-    send("Crons:\n\n" + list.map((c, i) => `${i + 1}. ${c.label} (${c.schedule}) — ${c.project}`).join("\n") + "\n\nRemove: /cron remove <#>");
-  }
-});
-
-bot.onText(/\/cron add "(.+)" (\S+) "(.+)"/, (msg, match) => {
-  if (!isAuthorized(msg)) return;
-  if (!cron.validate(match[1])) return send("Invalid cron schedule.");
-  const proj = findProject(match[2]);
-  if (!proj || Array.isArray(proj)) return send("Project not found.");
-  const c = { id: `cron_${Date.now()}`, schedule: match[1], project: proj, prompt: match[3], label: match[3].slice(0, 50) };
-  const list = loadCrons(); list.push(c); saveCrons(list); scheduleCron(c);
-  send(`Added: ${c.label} (${c.schedule}) for ${proj}`);
-});
-
-bot.onText(/\/cron remove (\d+)/, (msg, match) => {
-  if (!isAuthorized(msg)) return;
-  const list = loadCrons(); const idx = parseInt(match[1]) - 1;
-  if (idx < 0 || idx >= list.length) return send("Invalid number.");
-  const removed = list.splice(idx, 1)[0]; saveCrons(list);
-  if (activeCrons.has(removed.id)) { activeCrons.get(removed.id).task.stop(); activeCrons.delete(removed.id); }
-  send(`Removed: ${removed.label}`);
-});
-
-// ── Callback Queries ────────────────────────────────────────────────
-
-bot.on("callback_query", async (q) => {
-  const d = q.data;
-  await bot.answerCallbackQuery(q.id);
-
-  if (d.startsWith("auth:")) {
-    const callbackFromOwner = String(q.from?.id) === CHAT_ID || String(q.message?.chat?.id) === CHAT_ID;
-    if (!callbackFromOwner) {
-      await send("Owner only — auth approvals are restricted.");
-      return;
-    }
-
-    const [, action, chatId] = d.split(":");
-    if (!chatId || !["approve", "deny"].includes(action)) return;
-
-    const result = action === "approve"
-      ? await approveAuthRequest(chatId)
-      : await denyAuthRequest(chatId);
-
-    if (result.status === "not_found") {
-      await send(`No pending auth request found for ${chatId}.`);
-      return;
-    }
-
-    if (result.status === "already_authorized") {
-      await send(`Chat ${chatId} is already authorized.`);
-      return;
-    }
-
-    const label = authRequestLabel(result.request);
-    if (result.status === "approved") {
-      await bot.sendMessage(chatId, "Your access has been approved! You can now use the bot. Send /start to begin.").catch(() => {});
-      let edited = false;
-      if (q.message) {
-        edited = await bot.editMessageText(`Approved auth request from ${label} (${chatId}).`, {
-          chat_id: q.message.chat.id,
-          message_id: q.message.message_id,
-          reply_markup: { inline_keyboard: [] },
-        }).then(() => true).catch(() => false);
-      }
-      if (!edited) await send(`Approved ${label} (${chatId}).`);
-      return;
-    }
-
-    await bot.sendMessage(chatId, "Your access request was denied.").catch(() => {});
-    let edited = false;
-    if (q.message) {
-      edited = await bot.editMessageText(`Denied auth request from ${label} (${chatId}).`, {
-        chat_id: q.message.chat.id,
-        message_id: q.message.message_id,
-        reply_markup: { inline_keyboard: [] },
-      }).then(() => true).catch(() => false);
-    }
-    if (!edited) await send(`Denied ${label} (${chatId}).`);
-    return;
-  }
-
-  // Onboarding style selection
-  if (d.startsWith("ob:")) { finishOnboarding(d.slice(3)); return; }
-
-  if (d === "show:projects") { await send("Pick:", { keyboard: projectKeyboard() }); return; }
-  if (d.startsWith("s:")) { startSession(d.slice(2)); return; }
-  if (d.startsWith("ss:")) { if (currentSession) startSession(currentSession.name, d.slice(3)); return; }
-  if (d.startsWith("new:")) {
-    const proj = d.slice(4);
-    // Clear session history so startSession doesn't auto-resume
-    const sessions = loadSessions();
-    // Don't delete history, just start fresh
-    currentSession = { name: proj === "__workspace__" ? "Workspace" : proj, dir: proj === "__workspace__" ? WORKSPACE : path.join(WORKSPACE, proj) };
-    lastSessionId = null; isFirstMessage = true; messageQueue = []; resetSettings();
-    saveState();
-    await send(`Session: ${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 (currentSession) await runClaude("continue", currentSession.dir); else send("No session."); return; }
-  if (d === "a:end") { if (currentSession) { const n = currentSession.name; currentSession = null; lastSessionId = null; messageQueue = []; resetSettings(); saveState(); await send(`Ended: ${n}`, { keyboard: { inline_keyboard: [[{ text: "New", callback_data: "show:projects" }]] } }); } return; }
-  if (d.startsWith("m:")) { settings.model = d.slice(2) === "default" ? null : d.slice(2); await send(`Model: ${settings.model || "default"}`); return; }
-  if (d.startsWith("e:")) { const e = d.slice(2); settings.effort = e === "default" ? null : e; await send(`Effort: ${settings.effort || "default"}`); return; }
-  if (d.startsWith("b:")) { const b = d.slice(2); settings.budget = b === "none" ? null : parseFloat(b); await send(`Budget: ${settings.budget ? "$"+settings.budget : "none"}`); return; }
-  if (d.startsWith("be:")) {
-    const be = d.slice(3);
-    if (be === "cursor" && !resolvedCursorPath) { await send("Cursor Agent CLI not found."); return; }
-    settings.backend = be;
-    settings.model = null;
-    saveState();
-    const label = be === "cursor" ? "Cursor Agent" : "Claude Code";
-    await send(`Switched to ${label}.`);
-    return;
-  }
-
-  // Mode switching
-  if (d.startsWith("mode:")) {
-    const newMode = d.slice(5);
-    const modeFile = path.join(CONFIG_DIR, ".bot-mode");
-    fs.writeFileSync(modeFile, newMode);
-    await send(`Switching to ${newMode} mode... restarting.`);
-    setTimeout(() => process.exit(0), 500);
-    return;
-  }
-
-  // Cron presets
-  if (d.startsWith("cp:") && d !== "cp:clear") {
-    if (!currentSession) return send("Start a session first.");
-    const presets = {
-      standup: { schedule: "0 9 * * 1-5", prompt: "Morning standup: recent commits, failing tests, open TODOs, what to focus on today. Brief.", label: "Morning standup" },
-      git: { schedule: "0 18 * * 1-5", prompt: "Git digest: today's commits, changed files, uncommitted changes. Flag concerns.", label: "Git digest" },
-      deps: { schedule: "0 10 * * 1", prompt: "Check outdated/vulnerable dependencies. Brief — just what needs attention.", label: "Dep check" },
-      health: { schedule: "*/30 * * * *", prompt: "Quick health: can the project build? Run build/lint, report pass/fail.", label: "Health check" },
-    };
-    const p = presets[d.slice(3)];
-    if (!p) return;
-    const c = { id: `cron_${Date.now()}`, ...p, project: currentSession.name };
-    const list = loadCrons(); list.push(c); saveCrons(list); scheduleCron(c);
-    await send(`Added: ${c.label} for ${currentSession.name}`);
-    return;
-  }
-  if (d === "cp:clear") { for (const [,v] of activeCrons) v.task.stop(); activeCrons.clear(); saveCrons([]); await send("All crons cleared."); return; }
-});
-
-// ── Media Handlers ──────────────────────────────────────────────────
-
-bot.on("voice", async (msg) => {
-  if (isDuplicate(msg.message_id)) return;
-  if (!isAuthorized(msg)) return;
-  if (!requireSession(msg)) return;
-  try {
-    bot.sendChatAction(CHAT_ID, "typing");
-    const oggPath = await downloadFile(msg.voice.file_id, ".ogg");
-    const transcript = transcribeAudio(oggPath);
-    try { fs.unlinkSync(oggPath); } catch (e) {}
-    if (!transcript) return send("Couldn't transcribe. Try typing it.");
-    await send(`Heard: "${transcript}"`, { replyTo: msg.message_id });
-    lastInputWasVoice = true;
-    await runClaude(transcript, currentSession.dir, msg.message_id);
-  } catch (err) { await send(`Voice failed: ${err.message}`); }
-});
-
-bot.on("audio", async (msg) => {
-  if (isDuplicate(msg.message_id)) return;
-  if (!isAuthorized(msg)) return;
-  if (!requireSession(msg)) return;
-  try {
-    bot.sendChatAction(CHAT_ID, "typing");
-    const p = await downloadFile(msg.audio.file_id, path.extname(msg.audio.file_name || ".ogg"));
-    const t = transcribeAudio(p);
-    try { fs.unlinkSync(p); } catch (e) {}
-    if (!t) return send("Couldn't transcribe.");
-    await send(`Heard: "${t}"`, { replyTo: msg.message_id });
-    await runClaude(t, currentSession.dir, msg.message_id);
-  } catch (err) { await send(`Audio failed: ${err.message}`); }
-});
-
-bot.on("photo", async (msg) => {
-  if (isDuplicate(msg.message_id)) return;
-  if (!isAuthorized(msg)) return;
-  if (!requireSession(msg)) return;
-  try {
-    const p = await downloadFile(msg.photo[msg.photo.length - 1].file_id, ".jpg");
-    const caption = msg.caption || "Describe this image. If code/UI/error — explain and fix.";
-    await runClaude(`Image at ${p}\n\nView it, then: ${caption}`, currentSession.dir, msg.message_id);
-  } catch (err) { await send(`Image failed: ${err.message}`); }
-});
-
-bot.on("document", async (msg) => {
-  if (isDuplicate(msg.message_id)) return;
-  if (!isAuthorized(msg)) return;
-  if (!requireSession(msg)) return;
-  try {
-    const fileName = msg.document.file_name || `file-${Date.now()}`;
-    const mime = msg.document.mime_type || "";
-    // Save with original name to files dir
-    const savePath = path.join(FILES_DIR, fileName);
-    const file = await bot.getFile(msg.document.file_id);
-    const fileUrl = `https://api.telegram.org/file/bot${TOKEN}/${file.file_path}`;
-    await new Promise((resolve, reject) => {
-      const out = fs.createWriteStream(savePath);
-      https.get(fileUrl, (res) => { res.pipe(out); out.on("finish", () => { out.close(); resolve(); }); }).on("error", reject);
-    });
-    const caption = msg.caption || "";
-    const isImage = mime.startsWith("image/");
-    let prompt;
-    if (isImage) {
-      prompt = `Image file saved at ${savePath}\n\nView it, then: ${caption || "Describe this image. If code/UI/error — explain and fix."}`;
-    } else {
-      prompt = `File received: ${fileName} (${mime})\nSaved at: ${savePath}\n\nRead this file and ${caption || "summarize its contents. If it's code, explain what it does. If it's a document, give key points."}`;
-    }
-    await send(`File saved: ${fileName}`, { replyTo: msg.message_id });
-    await runClaude(prompt, currentSession.dir, msg.message_id);
-  } catch (err) { await send(`Failed: ${err.message}`); }
-});
-
-// ── Text Message Handler (handles onboarding, vault password, normal messages) ──
-
-bot.on("message", async (msg) => {
-  if (!isAuthorized(msg)) return;
-  if (!msg.text || msg.text.startsWith("/")) return;
-  if (msg.voice || msg.audio || msg.photo || msg.document || msg.video || msg.sticker) return;
-  if (isDuplicate(msg.message_id)) return;
-
-  // Handle pending manual OAuth token paste mode. Login codes must be sent explicitly
-  // with /auth_code so normal chat can never be deleted/consumed accidentally.
-  if (pendingClaudeAuthProcess && pendingClaudeAuthLabel === "manual OAuth token save") {
-    const text = msg.text.trim();
-    if (looksLikeClaudeToken(text)) {
-      await deleteMessage(msg.message_id);
-      clearPendingClaudeAuth();
-      saveClaudeOAuthToken(text);
-      await send(`Claude OAuth token stored in .env${vault.isUnlocked() ? " and vault" : ""}. Restart the bot so launchd picks it up, or use /restart.`);
-      await sendClaudeAuthStatusSummary("Stored token. Current Claude auth status:");
-      return;
-    }
-    await send("Token paste mode is active, but that does not look like a Claude OAuth token. I left your message visible and will handle it normally. Send /cancel_auth to stop token paste mode.");
-  }
-
-  if (pendingClaudeAuthProcess && pendingClaudeAuthLabel !== "manual OAuth token save") {
-    const text = msg.text.trim();
-    if (looksLikeClaudeAuthReply(text)) {
-      await send("That looks like a Claude login code/callback. I did not delete it or send it to Claude as a prompt. Please resend it as `/auth_code YOUR_CODE`, or use /cancel_auth to stop the login flow.");
-      return;
-    }
-    await send("Claude login is still waiting. I will not delete normal messages. If Claude gave you a code, send it as `/auth_code YOUR_CODE`, or use /cancel_auth.");
-  }
-
-  // Handle onboarding
-  if (!isOnboarded() && onboardingStep) {
-    await handleOnboarding(msg);
-    return;
-  }
-
-  // Handle vault password
-  if (pendingVaultUnlock) {
-    const password = msg.text;
-    // Delete the password message immediately
-    await deleteMessage(msg.message_id);
-
-    const ok = vault.unlock(password);
-    if (!ok) {
-      pendingVaultUnlock = false;
-      pendingVaultAction = null;
-      await send("Wrong password.");
-      return;
-    }
-
-    // Execute pending action
-    const action = pendingVaultAction;
-    pendingVaultUnlock = false;
-    pendingVaultAction = null;
-
-    if (action.type === "list") {
-      const entries = vault.list();
-      const keys = Object.keys(entries);
-      if (keys.length === 0) await send("Vault unlocked (empty).\n\nUse /vault set <name> <value>");
-      else await send("Vault unlocked:\n\n" + keys.map(k => `${k}: ${entries[k]}`).join("\n") + "\n\nAuto-locks in 5 min.");
-    } else if (action.type === "set") {
-      vault.set(action.key, action.value);
-      await send(`Saved: ${action.key}`);
-    } else if (action.type === "remove") {
-      vault.remove(action.key);
-      await send(`Removed: ${action.key}`);
-    }
-    return;
-  }
-
-  // Normal message
-  if (!requireSession(msg)) return;
-
-  // Detect credential-like messages and delete them from chat
-  const text = msg.text;
-  const credPatterns = [
-    /^(sk-ant-|sk-|glpat-|ghp_|gho_|github_pat_|xoxb-|xoxp-|AKIA|AIza)/,  // API keys
-    /^[A-Za-z0-9_-]{20,}$/,  // Long token-like strings with no spaces
-    /^(Bearer |token:|key:|secret:|password:)/i,  // Prefixed credentials
-  ];
-  const looksLikeCredential = credPatterns.some((p) => p.test(text.trim()));
-  if (looksLikeCredential) {
-    await deleteMessage(msg.message_id);
-  }
-
-  let prompt = msg.text;
-  const reply = msg.reply_to_message;
-  if (reply) {
-    let ctx = "";
-    if (reply.text) {
-      ctx = reply.text;
-    }
-    if (reply.caption) {
-      ctx += (ctx ? "\n" : "") + reply.caption;
-    }
-    if (reply.document) {
-      const fileName = reply.document.file_name || "unknown";
-      const filePath = path.join(FILES_DIR, fileName);
-      if (fs.existsSync(filePath)) {
-        ctx += (ctx ? "\n" : "") + `[Attached file: ${fileName} at ${filePath}]`;
-      } else {
-        // Download the file from the replied message
-        try {
-          const file = await bot.getFile(reply.document.file_id);
-          const fileUrl = `https://api.telegram.org/file/bot${TOKEN}/${file.file_path}`;
-          await new Promise((resolve, reject) => {
-            const out = fs.createWriteStream(filePath);
-            https.get(fileUrl, (res) => { res.pipe(out); out.on("finish", () => { out.close(); resolve(); }); }).on("error", reject);
-          });
-          ctx += (ctx ? "\n" : "") + `[Attached file: ${fileName} at ${filePath}]`;
-        } catch (e) {
-          ctx += (ctx ? "\n" : "") + `[Attached file: ${fileName} — could not download]`;
-        }
-      }
-    }
-    if (reply.photo) {
-      ctx += (ctx ? "\n" : "") + "[Attached photo]";
-    }
-    if (ctx) {
-      prompt = `Replying to message:\n---\n${ctx.length > 1000 ? ctx.slice(0, 1000) + "..." : ctx}\n---\n\n${msg.text}`;
-    }
-  }
-
-  await runClaude(prompt, currentSession.dir, msg.message_id);
-});
-
-// ── Startup ─────────────────────────────────────────────────────────
-initCrons();
-console.log("Claude Code Telegram bot running");
-console.log(`Workspace: ${WORKSPACE}`);
-console.log(`Soul: ${SOUL_FILE}`);
-console.log(`Vault: ${VAULT_FILE} (${vault.exists() ? "exists" : "not created"})`);
-console.log(`Onboarded: ${isOnboarded()}`);
-
-// Notify owner that bot is back online
-bot.sendMessage(CHAT_ID, `Back online and ready! Running v${CURRENT_VERSION}.`).catch(() => {});
+// Compatibility entrypoint for older services. Runtime behavior, including
+// agent-mode side responses, lives exclusively in the modular entrypoint.
+module.exports = require("./bot");