@inetafrica/open-claudia 1.17.0 → 1.18.0

package/.env.example

@@ -3,6 +3,8 @@ TELEGRAM_CHAT_ID=your-chat-id
 WORKSPACE=/path/to/your/workspace
 CLAUDE_PATH=/path/to/claude
 CURSOR_PATH=
+CODEX_PATH=
+AUTO_COMPACT_TOKENS=140000
 WHISPER_CLI=
 WHISPER_MODEL=
 FFMPEG=

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## v1.18.0
+- Auto-compacts high-context sessions before the next turn (`AUTO_COMPACT_TOKENS`, default 140k): summarizes the old session, seeds a fresh session, then continues the user's request there
+- `/compact` now creates a fresh compacted continuation session instead of only adding another summary turn to the existing session
+- `/continue` resumes the selected stored session ID with `--resume` instead of using cwd-most-recent `--continue`
+- Stabilized the mobile system prompt: no timestamps, dynamic file lists, vault key names, or raw Telegram token curl examples
+- Reply context is no longer redundantly injected when replying to the bot's own prior text from the active session
+
 ## v1.17.0
 - **Multi-user / team mode**: a single bot can now serve multiple authorized users in parallel. Each user has their own conversation thread, project session, settings, model, backend, runningProcess, queue, and usage counters
 - Per-user state lives in `userStates: Map<chatId, UserState>`; an `AsyncLocalStorage` chat context routes `send()`/`editMessage()`/typing indicators back to whoever triggered the work

package/bot.js

@@ -150,6 +150,7 @@ const WORKSPACE = config.WORKSPACE;
 const CLAUDE_PATH = config.CLAUDE_PATH;
 const CURSOR_PATH = config.CURSOR_PATH || null;
 const CODEX_PATH = config.CODEX_PATH || null;
+const AUTO_COMPACT_TOKENS = parseInt(config.AUTO_COMPACT_TOKENS || process.env.AUTO_COMPACT_TOKENS || "140000", 10);
 
 // Validate critical config at startup
 if (!TOKEN) { console.error("TELEGRAM_BOT_TOKEN not set"); process.exit(1); }
@@ -385,6 +386,8 @@ function createUserState(chatId) {
     pendingVaultAction: null,
     pendingClaudeAuthProcess: null,
     pendingClaudeAuthLabel: null,
+    isCompacting: false,
+    lastCompactedAt: saved.lastCompactedAt || 0,
   };
 }
 
@@ -426,6 +429,7 @@ function saveState() {
       codexSessionId: s.codexSessionId,
       settings: s.settings,
       sessionUsage: s.sessionUsage,
+      lastCompactedAt: s.lastCompactedAt || 0,
     };
   }
   try { fs.writeFileSync(STATE_FILE, JSON.stringify(data)); } catch (e) {}
@@ -667,65 +671,38 @@ function saveCrons(list) {
 
 function buildSystemPrompt() {
   const state = currentState();
-  const chatId = state.chatId;
   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: ${state.currentSession ? state.currentSession.name + " (" + state.currentSession.dir + ")" : "none"}
+## Runtime Context
+- Interface: Telegram mobile chat through Open Claudia.
+- Active project path: ${state.currentSession ? state.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." : ""}
+- Vault: ${vault.isUnlocked() ? "unlocked" : "locked"}
+- Session: ${state.lastSessionId ? "resuming existing conversation" : "new conversation"}
 
-### ${path.join(BOT_DIR, "bot.js")}
-The bot code. Read to understand capabilities. Only modify if explicitly asked.
+## Stable Local Paths
+- Bot code: ${path.join(BOT_DIR, "bot.js")}
+- Personality file: ${SOUL_FILE}
+- Cron config: ${CRONS_FILE}
+- Vault file: ${VAULT_FILE}
+- Bot environment: ${path.join(BOT_DIR, ".env")} (sensitive; never expose values)
+- Received user files directory: ${FILES_DIR}
 
-### ${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 who triggered this turn (chat_id ${chatId}):
-
-Text: curl -s -X POST "https://api.telegram.org/bot${TOKEN}/sendMessage" -d chat_id=${chatId} -d text="message"
-File: curl -s -X POST "https://api.telegram.org/bot${TOKEN}/sendDocument" -F chat_id=${chatId} -F document=@/path/to/file
-Image: curl -s -X POST "https://api.telegram.org/bot${TOKEN}/sendPhoto" -F chat_id=${chatId} -F photo=@/path/to/image.png
-
-## Session
-${state.lastSessionId ? "Resuming conversation — you have prior context." : "New conversation."}
+## Telegram Delivery
+Reply normally in your final answer. If you must send a large file, image, or artifact directly, use the Telegram API with the configured bot token from the environment/config; never print or embed the token in prompts, commands, logs, or messages.
 
 ## 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.
+- For long output (logs, diffs, large code), save to a file and send it as an artifact instead of pasting 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 the user sends a file, it is saved in the received files directory above. 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.
+- When asked to change your personality, edit the personality file above.
 - 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.
@@ -1246,7 +1223,8 @@ function buildClaudeArgs(prompt, opts = {}) {
   if (settings.backend === "codex") return buildCodexArgs(prompt, opts);
   const args = ["-p", "--verbose", "--output-format", "stream-json",
     "--append-system-prompt", buildSystemPrompt()];
-  if (opts.continueSession) args.push("--continue");
+  if (opts.resumeSessionId) args.push("--resume", opts.resumeSessionId);
+  else if (opts.continueSession) args.push("--continue");
   else if (state.lastSessionId && !opts.fresh) args.push("--resume", state.lastSessionId);
   if (settings.model) args.push("--model", settings.model);
   if (settings.effort) args.push("--effort", settings.effort);
@@ -1262,7 +1240,8 @@ function buildCursorArgs(prompt, opts = {}) {
   const state = currentState();
   const { settings } = state;
   const args = ["--print", "--trust", "--output-format", "stream-json"];
-  if (opts.continueSession) args.push("--continue");
+  if (opts.resumeSessionId) args.push("--resume", opts.resumeSessionId);
+  else if (opts.continueSession) args.push("--continue");
   else if (state.cursorSessionId && !opts.fresh) args.push("--resume", state.cursorSessionId);
   if (settings.model) args.push("--model", settings.model);
   if (settings.permissionMode === "plan") args.push("--mode", "plan");
@@ -1279,7 +1258,7 @@ function buildCodexArgs(prompt, opts = {}) {
   const state = currentState();
   const { settings, codexSessionId } = state;
   const args = [];
-  const resumeId = (!opts.fresh && !opts.continueSession) ? codexSessionId : null;
+  const resumeId = opts.resumeSessionId || ((!opts.fresh && !opts.continueSession) ? codexSessionId : null);
   if (opts.continueSession && codexSessionId) {
     args.push("exec", "resume", codexSessionId);
   } else if (resumeId) {
@@ -1312,6 +1291,165 @@ function getActiveSessionId() {
   return state.lastSessionId;
 }
 
+function getActiveSessionKey(state = currentState()) {
+  if (state.settings.backend === "cursor") return "cursorSessionId";
+  if (state.settings.backend === "codex") return "codexSessionId";
+  return "lastSessionId";
+}
+
+function shouldAutoCompact(state = currentState(), opts = {}) {
+  if (opts.skipAutoCompact || opts.fresh || opts.continueSession || state.isCompacting) return false;
+  if (!state[getActiveSessionKey(state)]) return false;
+  const threshold = Number.isFinite(AUTO_COMPACT_TOKENS) ? AUTO_COMPACT_TOKENS : 140000;
+  return (state.sessionUsage?.lastInputTokens || 0) >= threshold;
+}
+
+function compactSummaryPrompt() {
+  return [
+    "Summarize this conversation for a fresh compacted continuation.",
+    "Include only durable context needed to continue effectively:",
+    "- current user goal and constraints",
+    "- important decisions and preferences",
+    "- files/repos touched and current code state",
+    "- commands/tests already run and results",
+    "- open TODOs, blockers, and exact next step",
+    "Do not include secrets, raw tokens, or irrelevant chat transcript."
+  ].join("\n");
+}
+
+function compactSeedPrompt(summary) {
+  return [
+    "This is a compacted continuation of a previous Open Claudia session.",
+    "Treat the following summary as the prior conversation context. Do not repeat it back unless asked.",
+    "Continue from this state in future turns.",
+    "",
+    "Compacted summary:",
+    summary
+  ].join("\n");
+}
+
+async function runClaudeCapture(prompt, cwd, opts = {}) {
+  const state = currentState();
+  const chatId = state.chatId;
+  if (state.runningProcess) throw new Error("Another task is already running.");
+  const authPreflight = preflightClaudeAuthMessage();
+  if (authPreflight) throw new Error(authPreflight);
+
+  return new Promise((resolve, reject) => {
+    let assistantText = "";
+    let stderrBuffer = "";
+    let streamBuffer = "";
+    let sessionId = null;
+    const args = buildClaudeArgs(prompt, { ...opts, skipAutoCompact: true });
+    const proc = spawn(getActiveBinary(), args, {
+      cwd,
+      env: claudeSubprocessEnv(),
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32",
+    });
+    state.runningProcess = proc;
+    const timeout = setTimeout(() => {
+      if (state.runningProcess === proc) {
+        killProcessTree(proc.pid, "SIGTERM");
+        setTimeout(() => killProcessTree(proc.pid, "SIGKILL"), 5000);
+      }
+    }, MAX_PROCESS_TIMEOUT);
+
+    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;
+          }
+        }
+        if (evt.type === "item.completed" && evt.item?.type === "agent_message" && typeof evt.item.text === "string") {
+          assistantText += (assistantText ? "\n" : "") + evt.item.text;
+        }
+        if (evt.type === "thread.started" && evt.thread_id) {
+          state.codexSessionId = evt.thread_id;
+          sessionId = evt.thread_id;
+          saveState();
+        }
+        if (evt.type === "result" && evt.session_id) {
+          if (state.settings.backend === "cursor") state.cursorSessionId = evt.session_id;
+          else state.lastSessionId = evt.session_id;
+          sessionId = evt.session_id;
+          if (evt.usage) {
+            const u = state.sessionUsage;
+            u.turns += 1;
+            u.inputTokens += evt.usage.input_tokens || 0;
+            u.outputTokens += evt.usage.output_tokens || 0;
+            u.cacheReadTokens += evt.usage.cache_read_input_tokens || 0;
+            u.cacheCreationTokens += evt.usage.cache_creation_input_tokens || 0;
+            u.lastInputTokens = (evt.usage.input_tokens || 0) +
+              (evt.usage.cache_read_input_tokens || 0) +
+              (evt.usage.cache_creation_input_tokens || 0);
+          }
+          if (typeof evt.total_cost_usd === "number") state.sessionUsage.costUsd += evt.total_cost_usd;
+          saveState();
+        }
+        if (evt.type === "result" && evt.result) assistantText = evt.result;
+      }
+    });
+    proc.stderr.on("data", (d) => { stderrBuffer += d.toString(); });
+    proc.on("close", (code) => chatContext.run(chatId, () => {
+      if (state.runningProcess === proc) state.runningProcess = null;
+      clearTimeout(timeout);
+      if (code !== 0 && code !== null) {
+        reject(new Error(claudeEmptyFailureMessage(code, stderrBuffer)));
+        return;
+      }
+      resolve({ text: redactSensitive(assistantText.trim()), sessionId });
+    }));
+    proc.on("error", (err) => chatContext.run(chatId, () => {
+      if (state.runningProcess === proc) state.runningProcess = null;
+      clearTimeout(timeout);
+      reject(err);
+    }));
+  });
+}
+
+async function compactActiveSession(cwd, opts = {}) {
+  const state = currentState();
+  const sessionKey = getActiveSessionKey(state);
+  const oldSessionId = state[sessionKey];
+  if (!oldSessionId) return { compacted: false, reason: "No conversation." };
+  if (state.isCompacting) return { compacted: false, reason: "Compaction already in progress." };
+
+  state.isCompacting = true;
+  try {
+    if (opts.notify) await send(opts.message || "Context is getting large, compacting first so this stays fast…");
+    const summaryRun = await runClaudeCapture(compactSummaryPrompt(), cwd, { resumeSessionId: oldSessionId, skipAutoCompact: true });
+    const summary = summaryRun.text || "No prior context was returned by the summarizer.";
+
+    state[sessionKey] = null;
+    resetSessionUsage(state);
+    state.isFirstMessage = true;
+    saveState();
+
+    const seedRun = await runClaudeCapture(compactSeedPrompt(summary), cwd, { fresh: true, skipAutoCompact: true });
+    const newSessionId = seedRun.sessionId || state[sessionKey];
+    if (newSessionId) state[sessionKey] = newSessionId;
+    state.isFirstMessage = false;
+    state.lastCompactedAt = Date.now();
+    resetSessionUsage(state);
+    saveState();
+
+    if (newSessionId && state.currentSession) {
+      const title = `Compacted ${new Date().toLocaleDateString()}`;
+      recordSession(state.chatId, state.currentSession.name, newSessionId, title);
+    }
+    return { compacted: true, oldSessionId, newSessionId, summary };
+  } finally {
+    state.isCompacting = false;
+    saveState();
+  }
+}
+
 async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   // Capture per-user state at entry so event callbacks (stdout/stderr/close)
   // operate on the right user's thread even though AsyncLocalStorage
@@ -1333,6 +1471,17 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     return;
   }
 
+  if (shouldAutoCompact(state, opts)) {
+    try {
+      await compactActiveSession(cwd, {
+        notify: true,
+        message: "Context is getting large, compacting first so this stays fast…",
+      });
+    } catch (e) {
+      await send(`Compaction failed: ${redactSensitive(e.message)}\nContinuing in the existing session.`, { replyTo: replyToMsgId });
+    }
+  }
+
   bot.sendChatAction(chatId, "typing");
   state.statusMessageId = null;
   state.streamBuffer = "";
@@ -1582,14 +1731,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
         if (voicePath) await sendVoice(voicePath);
       }
 
-      // Suggest /compact when context gets large (once per threshold crossing)
-      const ctx = state.sessionUsage.lastInputTokens;
-      if (ctx > 150000 && !state.sessionUsage.warnedHighContext) {
-        state.sessionUsage.warnedHighContext = true;
-        await send(`Heads up: context is ${(ctx / 1000).toFixed(0)}k tokens. Use /compact to summarize or /end for a fresh start — keeps cost down.`);
-      } else if (ctx < 80000 && state.sessionUsage.warnedHighContext) {
-        state.sessionUsage.warnedHighContext = false;
-      }
+      // High-context sessions are compacted automatically before the next turn.
     } 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.");
@@ -1966,8 +2108,27 @@ bot.onText(/\/ask$/, wrapHandler((msg) => {
   settings.permissionMode = a ? null : "ask";
   send(a ? "Ask mode off." : "Ask mode on (read-only Q&A, no edits).");
 }));
-bot.onText(/\/compact/, wrapHandler(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.", currentState().currentSession.dir, msg.message_id); }));
-bot.onText(/\/continue$/, wrapHandler(async (msg) => { if (!isAuthorized(msg)) return; if (!requireSession(msg)) return; await runClaude("continue where we left off", currentState().currentSession.dir, msg.message_id, { continueSession: true }); }));
+bot.onText(/\/compact/, wrapHandler(async (msg) => {
+  if (!isAuthorized(msg)) return;
+  if (!requireSession(msg)) return;
+  if (!getActiveSessionId()) return send("No conversation.");
+  try {
+    const result = await compactActiveSession(currentState().currentSession.dir, {
+      notify: true,
+      message: "Compacting this conversation into a fresh session…",
+    });
+    if (result.compacted) await send(`Compacted into a fresh session${result.newSessionId ? ` (${result.newSessionId.slice(0, 8)}…)` : ""}. Continue normally.`, { replyTo: msg.message_id });
+    else await send(result.reason || "Could not compact.", { replyTo: msg.message_id });
+  } catch (e) {
+    await send(`Compaction failed: ${redactSensitive(e.message)}`, { replyTo: msg.message_id });
+  }
+}));
+bot.onText(/\/continue$/, wrapHandler(async (msg) => {
+  if (!isAuthorized(msg)) return;
+  if (!requireSession(msg)) return;
+  if (!getActiveSessionId()) return send("No conversation to continue.");
+  await runClaude("continue where we left off", currentState().currentSession.dir, msg.message_id);
+}));
 bot.onText(/\/worktree$/, wrapHandler((msg) => { if (!isAuthorized(msg)) return; const { settings } = currentState(); settings.worktree = !settings.worktree; send(settings.worktree ? "Worktree on." : "Worktree off."); }));
 
 bot.onText(/\/cursor$/, wrapHandler(async (msg) => {
@@ -2083,7 +2244,7 @@ bot.onText(/\/usage$/, wrapHandler((msg) => {
     `Cost: $${u.costUsd.toFixed(4)}`,
     `Last turn context: ${fmt(u.lastInputTokens)}`,
   ];
-  if (u.lastInputTokens > 100000) lines.push("\nTip: context is large. Use /compact to summarize, or /end for a clean slate.");
+  if (u.lastInputTokens > 100000) lines.push(`\nTip: context is large. The bot auto-compacts before the next turn at ${fmt(AUTO_COMPACT_TOKENS)} tokens; /compact does it now.`);
   send(lines.join("\n"), { parseMode: "Markdown" });
 }));
 
@@ -2308,7 +2469,7 @@ bot.on("callback_query", wrapHandler(async (q) => {
     await send(`Session: ${state.currentSession.name}\nNew conversation\n\nSend text, voice, or images.\n\n/sessions — switch conversation\n/session — switch project`);
     return;
   }
-  if (d === "a:continue") { if (state.currentSession) await runClaude("continue", state.currentSession.dir); else send("No session."); return; }
+  if (d === "a:continue") { if (state.currentSession && getActiveSessionId()) await runClaude("continue", state.currentSession.dir); else send("No session to continue."); return; }
   if (d === "a:end") {
     if (state.currentSession) {
       const n = state.currentSession.name;
@@ -2563,7 +2724,8 @@ bot.on("message", wrapHandler(async (msg) => {
 
   let prompt = msg.text;
   const reply = msg.reply_to_message;
-  if (reply) {
+  const skipReplyContext = reply?.from?.is_bot && !reply.document && !reply.photo;
+  if (reply && !skipReplyContext) {
     let ctx = "";
     if (reply.text) {
       ctx = reply.text;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram",
   "main": "bot.js",
   "bin": {