@inetafrica/open-claudia 1.4.5 → 1.6.0

package/bot.js

@@ -7,10 +7,40 @@ const cron = require("node-cron");
 const Vault = require("./vault");
 const CONFIG_DIR = require("./config-dir");
 
-// ── Graceful shutdown ──────────────────────────────────────────────
+// ── 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");
@@ -140,6 +170,7 @@ bot.setMyCommands([
   { command: "compact", description: "Summarize conversation context" },
   { command: "continue", description: "Resume last conversation" },
   { command: "worktree", description: "Toggle isolated git branch" },
+  { command: "agents", description: "Toggle direct/parallel agent mode" },
   { command: "cron", description: "Manage scheduled tasks" },
   { command: "vault", description: "Manage credentials (password required)" },
   { command: "soul", description: "View/edit assistant identity" },
@@ -237,7 +268,8 @@ const savedState = loadState();
 
 // ── State ───────────────────────────────────────────────────────────
 let currentSession = savedState.currentSession || null;
-let runningProcess = null;
+let runningProcess = null;        // Primary process (direct mode)
+let runningTasks = new Map();     // taskId -> { proc, statusMessageId, streamInterval, startTime } (parallel mode)
 let statusMessageId = null;
 let streamBuffer = "";
 let streamInterval = null;
@@ -247,13 +279,14 @@ let activeCrons = new Map();
 let pendingVaultUnlock = false; // Waiting for password
 let pendingVaultAction = null;  // What to do after unlock
 let isFirstMessage = !lastSessionId; // Track if this is first message in session
+let taskCounter = 0;
 
 let settings = savedState.settings || {
-  model: null, effort: null, budget: null, permissionMode: null, worktree: false,
+  model: null, effort: null, budget: null, permissionMode: null, worktree: false, agentMode: "direct",
 };
 
 function resetSettings() {
-  settings = { model: null, effort: null, budget: null, permissionMode: null, worktree: false };
+  settings = { model: null, effort: null, budget: null, permissionMode: null, worktree: false, agentMode: settings.agentMode };
 }
 
 function isAuthorized(msg) {
@@ -524,19 +557,41 @@ async function send(text, opts = {}) {
   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;
-  try {
-    const msg = await bot.sendMessage(CHAT_ID, text, o);
-    return msg.message_id;
-  } catch (e) {
-    if (opts.parseMode) {
-      try {
-        const f = {}; if (opts.keyboard) f.reply_markup = opts.keyboard;
-        return (await bot.sendMessage(CHAT_ID, text, f)).message_id;
-      } catch (e2) { /* ignore */ }
+
+  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 error:", e.message);
-    return null;
   }
+  console.error("Send: exhausted retries");
+  return null;
 }
 
 async function editMessage(messageId, text, opts = {}) {
@@ -544,7 +599,17 @@ async function editMessage(messageId, text, opts = {}) {
     const o = { chat_id: CHAT_ID, message_id: messageId };
     if (opts.keyboard) o.reply_markup = opts.keyboard;
     await bot.editMessageText(text, o);
-  } catch (e) { /* ignore */ }
+  } 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) {
@@ -591,6 +656,19 @@ function parseStreamEvents(data) {
   return events;
 }
 
+/**
+ * Route to the appropriate runner based on agent mode setting.
+ * In direct mode: serial execution with shared session.
+ * In parallel mode: concurrent independent processes.
+ * Commands like /compact and /continue always use direct mode (they need session context).
+ */
+async function runClaudeRouted(prompt, cwd, replyToMsgId, opts = {}) {
+  if (opts.forceDirect || settings.agentMode !== "parallel") {
+    return runClaude(prompt, cwd, replyToMsgId, opts);
+  }
+  return runClaudeParallel(prompt, cwd, replyToMsgId, opts);
+}
+
 function buildClaudeArgs(prompt, opts = {}) {
   const args = ["-p", "--verbose", "--output-format", "stream-json",
     "--append-system-prompt", buildSystemPrompt()];
@@ -634,24 +712,36 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   let longRunningNotified = false;
 
   let lastUpdate = "";
-  streamInterval = setInterval(async () => {
-    bot.sendChatAction(CHAT_ID, "typing");
+  // Adaptive update interval: 2s for first 2min, then 5s to avoid rate limits
+  const scheduleUpdate = () => {
     const elapsed = Math.floor((Date.now() - startTime) / 1000);
-    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);
+    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;
       }
-      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.`);
+      // 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);
     }
-  }, 1500);
+    if (runningProcess) scheduleUpdate();
+  };
+  scheduleUpdate();
 
   proc.stdout.on("data", (data) => {
     streamBuffer += data.toString();
@@ -686,16 +776,25 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
 
   proc.on("close", async (code) => {
     runningProcess = null;
-    clearInterval(streamInterval); streamInterval = null;
-    const finalText = assistantText || "(no output)";
-    const chunks = splitMessage(finalText);
-    // Keep the streaming progress message and send final result as a new message
-    // This ensures the user gets a notification for the final answer
-    await send(chunks[0], { replyTo: replyToMsgId });
-    for (let i = 1; i < chunks.length; i++) {
-      await send(chunks[i]);
+    clearTimeout(streamInterval); streamInterval = null;
+    try {
+      const finalText = assistantText || "(no output)";
+      const chunks = splitMessage(finalText);
+      // Send final result as a new message (triggers notification)
+      const sent = await send(chunks[0], { replyTo: replyToMsgId });
+      if (!sent) {
+        // Fallback: if the first send failed completely, try without any options
+        await send(chunks[0]);
+      }
+      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);
+      // Last-resort attempt to notify user something went wrong
+      await send("Task completed but failed to deliver the response. Send /continue to see the result.");
     }
-    if (code !== 0 && code !== null) await send(`Exit code: ${code}`);
     if (settings.budget) settings.budget = null;
     statusMessageId = null;
 
@@ -712,11 +811,131 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   });
 
   proc.on("error", async (err) => {
-    runningProcess = null; clearInterval(streamInterval);
+    runningProcess = null; clearTimeout(streamInterval);
     await send(`Error: ${err.message}`); statusMessageId = null;
   });
 }
 
+/**
+ * Run Claude in parallel mode — each call gets its own independent process.
+ * No queueing, no shared session. Multiple tasks can run simultaneously.
+ */
+async function runClaudeParallel(prompt, cwd, replyToMsgId, opts = {}) {
+  bot.sendChatAction(CHAT_ID, "typing").catch(() => {});
+
+  const taskId = `task-${++taskCounter}`;
+  let taskStatusMsgId = null;
+  let taskStreamBuf = "";
+  let taskText = "";
+  let taskToolUses = [];
+  let taskCurrentTool = null;
+  let taskCurrentToolDetail = "";
+  let taskSessionId = null;
+
+  // Build args — always fresh session in parallel mode (no --resume)
+  const args = ["-p", "--verbose", "--output-format", "stream-json",
+    "--append-system-prompt", buildSystemPrompt()];
+  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);
+
+  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",
+  });
+
+  const startTime = Date.now();
+  let taskInterval = null;
+  let lastUpdate = "";
+
+  // Adaptive progress updates
+  const scheduleTaskUpdate = () => {
+    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+    const interval = elapsed > 120 ? 5000 : 2000;
+    taskInterval = setTimeout(doTaskUpdate, interval);
+  };
+  const doTaskUpdate = async () => {
+    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+    try {
+      bot.sendChatAction(CHAT_ID, "typing").catch(() => {});
+      const display = formatProgress(taskText, taskToolUses, taskCurrentTool, elapsed, taskCurrentToolDetail);
+      if (display && display !== lastUpdate) {
+        if (!taskStatusMsgId && taskText) {
+          taskStatusMsgId = await send(display.length > 4000 ? display.slice(-4000) : display, { replyTo: replyToMsgId });
+        } else if (taskStatusMsgId) {
+          await editMessage(taskStatusMsgId, display.length > 4000 ? display.slice(-4000) : display);
+        }
+        lastUpdate = display;
+      }
+    } catch (e) {
+      console.error(`Task ${taskId} progress error:`, e.message);
+    }
+    if (runningTasks.has(taskId)) scheduleTaskUpdate();
+  };
+
+  runningTasks.set(taskId, { proc, startTime, prompt: prompt.slice(0, 50) });
+  scheduleTaskUpdate();
+
+  proc.stdout.on("data", (data) => {
+    taskStreamBuf += data.toString();
+    const events = parseStreamEvents(taskStreamBuf);
+    const lastNewline = taskStreamBuf.lastIndexOf("\n");
+    taskStreamBuf = lastNewline >= 0 ? taskStreamBuf.slice(lastNewline + 1) : taskStreamBuf;
+    for (const evt of events) {
+      if (evt.type === "assistant" && evt.message?.content) {
+        for (const block of evt.message.content) {
+          if (block.type === "text") taskText += block.text;
+          else if (block.type === "tool_use") {
+            taskCurrentTool = block.name;
+            taskToolUses.push(block.name);
+            const input = block.input || {};
+            if (block.name === "Bash" && input.command) taskCurrentToolDetail = input.command.slice(0, 80);
+            else if ((block.name === "Read" || block.name === "Edit" || block.name === "Write") && input.file_path)
+              taskCurrentToolDetail = input.file_path.split("/").slice(-2).join("/");
+            else if (block.name === "Grep" && input.pattern) taskCurrentToolDetail = input.pattern.slice(0, 40);
+            else if (block.name === "Glob" && input.pattern) taskCurrentToolDetail = input.pattern;
+            else taskCurrentToolDetail = "";
+          }
+        }
+      }
+      if (evt.type === "result" && evt.session_id) taskSessionId = evt.session_id;
+      if (evt.type === "result" && evt.result) taskText = evt.result;
+    }
+  });
+
+  proc.stderr.on("data", (d) => console.error(`Task ${taskId} STDERR:`, d.toString()));
+
+  proc.on("close", async (code) => {
+    runningTasks.delete(taskId);
+    clearTimeout(taskInterval);
+    try {
+      const finalText = taskText || "(no output)";
+      const chunks = splitMessage(finalText);
+      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]);
+      if (code !== 0 && code !== null) await send(`Exit code: ${code}`);
+    } catch (e) {
+      console.error(`Task ${taskId} final delivery failed:`, e.message);
+      await send("Task completed but failed to deliver the response.");
+    }
+  });
+
+  proc.on("error", async (err) => {
+    runningTasks.delete(taskId);
+    clearTimeout(taskInterval);
+    await send(`Task error: ${err.message}`, { replyTo: replyToMsgId });
+  });
+
+  return taskId;
+}
+
 async function runClaudeSilent(prompt, cwd, label) {
   return new Promise((resolve) => {
     const args = ["-p", "--output-format", "text", "--verbose",
@@ -827,7 +1046,7 @@ bot.onText(/\/help/, (msg) => {
   if (!isAuthorized(msg)) return;
   send([
     "Session: /session /sessions /projects /continue /status /stop /end",
-    "Settings: /model /effort /budget /plan /compact /worktree",
+    "Settings: /model /effort /budget /plan /compact /worktree /agents",
     "Automation: /cron /vault /soul",
     "System: /restart /upgrade",
     "",
@@ -935,37 +1154,79 @@ bot.onText(/\/compact/, async (msg) => { if (!isAuthorized(msg)) return; if (!re
 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(/\/agents$/, (msg) => {
+  if (!isAuthorized(msg)) return;
+  const mode = settings.agentMode || "direct";
+  send(`Agent mode: *${mode}*\n\n` +
+    `*direct* — one task at a time, shared session context, queues messages\n` +
+    `*parallel* — concurrent tasks, independent sessions, no queue`, {
+    parseMode: "Markdown",
+    keyboard: { inline_keyboard: [
+      [{ text: mode === "direct" ? "Direct (active)" : "Switch to Direct", callback_data: "am:direct" },
+       { text: mode === "parallel" ? "Parallel (active)" : "Switch to Parallel", callback_data: "am:parallel" }],
+    ] },
+  });
+});
+
 bot.onText(/\/stop/, async (msg) => {
   if (!isAuthorized(msg)) return;
+
+  // Stop parallel tasks
+  if (runningTasks.size > 0) {
+    for (const [taskId, task] of runningTasks) {
+      try { process.kill(-task.proc.pid, "SIGTERM"); } catch (e) {
+        try { task.proc.kill("SIGTERM"); } catch (e2) {}
+      }
+      setTimeout(() => { try { process.kill(-task.proc.pid, "SIGKILL"); } catch (e) {} }, 3000);
+    }
+    const count = runningTasks.size;
+    runningTasks.clear();
+    await send(`Cancelled ${count} task${count > 1 ? "s" : ""}.`);
+    return;
+  }
+
+  // Stop direct mode process
   if (runningProcess) {
     const pid = runningProcess.pid;
     try {
-      // Kill entire process group to catch child processes (dev servers, etc.)
       process.kill(-pid, "SIGTERM");
     } catch (e) {
       try { runningProcess.kill("SIGTERM"); } catch (e2) {}
     }
-    // Force kill after 3 seconds if still alive
     setTimeout(() => {
       try { process.kill(-pid, "SIGKILL"); } catch (e) {}
     }, 3000);
     runningProcess = null;
-    if (streamInterval) clearInterval(streamInterval);
+    if (streamInterval) clearTimeout(streamInterval);
     messageQueue = [];
     await send("Cancelled.");
+    return;
   }
-  else await send("Nothing running.");
+
+  await send("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" }]] } });
-  send([
+  const mode = settings.agentMode || "direct";
+  const lines = [
     `Project: ${currentSession.name}`,
-    `Model: ${settings.model || "default"} | Effort: ${settings.effort || "default"}`,
+    `Model: ${settings.model || "default"} | Effort: ${settings.effort || "default"} | Mode: ${mode}`,
     `Vault: ${vault.isUnlocked() ? "unlocked" : "locked"} | Crons: ${activeCrons.size}`,
-    runningProcess ? "Working..." : "Ready.",
-  ].join("\n"));
+  ];
+  if (mode === "parallel" && runningTasks.size > 0) {
+    lines.push(`Running: ${runningTasks.size} task${runningTasks.size > 1 ? "s" : ""}`);
+    for (const [id, task] of runningTasks) {
+      const elapsed = Math.floor((Date.now() - task.startTime) / 1000);
+      lines.push(`  ${id}: ${task.prompt}... (${elapsed}s)`);
+    }
+  } else if (runningProcess) {
+    lines.push("Working...");
+  } else {
+    lines.push("Ready.");
+  }
+  send(lines.join("\n"));
 });
 
 bot.onText(/\/end/, (msg) => {
@@ -1101,6 +1362,7 @@ bot.on("callback_query", async (q) => {
   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("am:")) { settings.agentMode = d.slice(3); saveState(); await send(`Agent mode: ${settings.agentMode}`); return; }
 
   // Cron presets
   if (d.startsWith("cp:") && d !== "cp:clear") {
@@ -1134,7 +1396,7 @@ bot.on("voice", async (msg) => {
     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);
+    await runClaudeRouted(transcript, currentSession.dir, msg.message_id);
   } catch (err) { await send(`Voice failed: ${err.message}`); }
 });
 
@@ -1149,7 +1411,7 @@ bot.on("audio", async (msg) => {
     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);
+    await runClaudeRouted(t, currentSession.dir, msg.message_id);
   } catch (err) { await send(`Audio failed: ${err.message}`); }
 });
 
@@ -1160,7 +1422,7 @@ bot.on("photo", async (msg) => {
   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);
+    await runClaudeRouted(`Image at ${p}\n\nView it, then: ${caption}`, currentSession.dir, msg.message_id);
   } catch (err) { await send(`Image failed: ${err.message}`); }
 });
 
@@ -1188,7 +1450,7 @@ bot.on("document", async (msg) => {
       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);
+    await runClaudeRouted(prompt, currentSession.dir, msg.message_id);
   } catch (err) { await send(`Failed: ${err.message}`); }
 });
 
@@ -1293,7 +1555,7 @@ bot.on("message", async (msg) => {
     }
   }
 
-  await runClaude(prompt, currentSession.dir, msg.message_id);
+  await runClaudeRouted(prompt, currentSession.dir, msg.message_id);
 });
 
 // ── Startup ─────────────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "1.4.5",
+  "version": "1.6.0",
   "description": "Your always-on AI coding assistant — Claude Code via Telegram",
   "main": "bot.js",
   "bin": {