@inetafrica/open-claudia 1.6.0 → 1.7.0

package/bot-agent.js

@@ -0,0 +1,1487 @@
+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");
+
+// ── 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 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),
+  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;
+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 (latest && 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: "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: "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,
+    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 messageQueue = [];            // Fallback queue (only used if chat process also fails)
+let activeCrons = new Map();
+let pendingVaultUnlock = false;
+let pendingVaultAction = null;
+let isFirstMessage = !lastSessionId;
+
+let settings = savedState.settings || {
+  model: null, effort: null, budget: null, permissionMode: null, worktree: false,
+};
+
+function resetSettings() {
+  settings = { model: null, effort: null, budget: null, permissionMode: null, worktree: false };
+}
+
+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 auth.authorized.some((a) => a.chatId === chatId);
+  } catch (e) {}
+  return false;
+}
+
+function isOwner(msg) {
+  return String(msg.chat.id) === CHAT_ID;
+}
+
+// ── 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
+  let auth;
+  try {
+    auth = JSON.parse(fs.readFileSync(AUTH_FILE, "utf-8"));
+  } catch (e) {
+    auth = { authorized: [], pending: [] };
+  }
+
+  // Check if already pending
+  if (auth.pending.some((p) => 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(),
+  });
+  fs.writeFileSync(AUTH_FILE, JSON.stringify(auth, null, 2));
+
+  bot.sendMessage(msg.chat.id, "Access requested! The bot owner will review your request.");
+
+  // Notify owner
+  const label = username ? `@${username}` : name;
+  bot.sendMessage(CHAT_ID, `New auth request from ${label} (${chatId}).\nRun 'open-claudia auth' to approve or deny.`);
+});
+
+// ── 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 o = {};
+  if (opts.parseMode) o.parse_mode = opts.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, text, 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 without it
+      if (opts.parseMode && o.parse_mode) {
+        delete o.parse_mode;
+        continue;
+      }
+
+      console.error("Send error:", errMsg);
+      return null;
+    }
+  }
+  console.error("Send: exhausted retries");
+  return null;
+}
+
+async function editMessage(messageId, text, opts = {}) {
+  try {
+    const o = { chat_id: CHAT_ID, message_id: messageId };
+    if (opts.keyboard) o.reply_markup = opts.keyboard;
+    await bot.editMessageText(text, 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;
+    // 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();
+}
+
+// Delete a message (used for vault password cleanup)
+async function deleteMessage(msgId) {
+  try { await bot.deleteMessage(CHAT_ID, msgId); } catch (e) { /* ignore */ }
+}
+
+// ── 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 = {}) {
+  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);
+  if (settings.model) args.push("--model", settings.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;
+}
+
+/**
+ * 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"];
+  if (settings.model) args.push("--model", settings.model);
+  args.push(contextPrompt);
+
+  const proc = spawn(CLAUDE_PATH, args, {
+    cwd,
+    env: { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME },
+    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;
+  }
+
+  bot.sendChatAction(CHAT_ID, "typing");
+  statusMessageId = null;
+  streamBuffer = "";
+  let assistantText = "";
+  let toolUses = [];
+  let currentTool = null;
+  let currentToolDetail = "";
+
+  const args = buildClaudeArgs(prompt, opts);
+  const proc = spawn(CLAUDE_PATH, args, {
+    cwd,
+    env: { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME },
+    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;
+
+  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);
+    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) => {
+    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);
+            // Extract useful detail from tool input
+            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 = "";
+          }
+        }
+      }
+      if (evt.type === "result" && evt.session_id) { lastSessionId = evt.session_id; saveState(); }
+      if (evt.type === "result" && evt.result) assistantText = evt.result;
+    }
+  });
+
+  proc.stderr.on("data", (d) => console.error("STDERR:", d.toString()));
+
+  proc.on("close", async (code) => {
+    runningProcess = null; runningProcessPrompt = null;
+    clearTimeout(streamInterval); streamInterval = null;
+    try {
+      const finalText = assistantText || "(no output)";
+      const chunks = splitMessage(finalText);
+      const firstChunk = chunks[0];
+
+      const progressAlreadyHasFinal = statusMessageId && lastUpdate &&
+        firstChunk.length < 4000 && chunks.length === 1 &&
+        lastUpdate.includes(firstChunk.slice(0, 200));
+
+      if (progressAlreadyHasFinal) {
+        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}`);
+    } 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: { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME },
+      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${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",
+    "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;
+  // Check if there's actually a newer version
+  try {
+    const 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 (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,
+      env: { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME || require("os").homedir() },
+    });
+    // Read version from newly installed package
+    const root = execSync("npm root -g", { encoding: "utf-8", env: { ...process.env, PATH: FULL_PATH } }).trim();
+    const newPkg = JSON.parse(fs.readFileSync(path.join(root, "@inetafrica", "open-claudia", "package.json"), "utf-8"));
+    await send(`Installed v${newPkg.version}. Going offline to restart...`);
+  } 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;
+  send(`Model: ${settings.model || "default"}`, { keyboard: { inline_keyboard: [
+    [{ text: "Opus", callback_data: "m:opus" }, { text: "Sonnet", callback_data: "m:sonnet" }, { text: "Haiku", callback_data: "m:haiku" }],
+    [{ text: "Default", callback_data: "m:default" }],
+  ] } });
+});
+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;
+  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; 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;
+  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; 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"; send(p ? "Plan mode off." : "Plan mode on."); });
+bot.onText(/\/compact/, async (msg) => { if (!isAuthorized(msg)) return; if (!requireSession(msg)) return; if (!lastSessionId) 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(/\/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 lines = [
+    `Project: ${currentSession.name} (agent mode)`,
+    `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.`);
+});
+
+// ── /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);
+
+  // 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; }
+
+  // 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 });
+    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 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(() => {});