@inetafrica/open-claudia 2.2.20 → 2.2.22

package/.env.example

@@ -17,7 +17,7 @@ KAZEE_DEBUG_EVENTS=
 WORKSPACE=/path/to/your/workspace
 CLAUDE_PATH=/path/to/claude
 # Default Claude Code model when users haven't selected one with /model.
-CLAUDE_MODEL=claude-opus-4-8
+CLAUDE_MODEL=claude-fable-5
 CURSOR_PATH=
 CODEX_PATH=
 AUTO_COMPACT_TOKENS=280000

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## v2.2.22
+- **Token economy: stable prompt-cache prefix (R1).** The per-turn churning lines — `Vault: unlocked/locked`, `Session: resuming/new`, and the full pending-tasks tree — moved out of the `--append-system-prompt` block into a "Runtime state (current turn)" header prepended to each user prompt (`promptWithDynamicContext`). The appended system prompt precedes the entire conversation in every API request, so any byte that changed between turns invalidated Anthropic's prompt-cache prefix and re-billed the whole history at 1.25x write price instead of 0.1x read price; on long sessions this churn was the dominant bot cost. `buildSystemPrompt()` is now byte-stable within a session (remaining interpolations — project path, channel, voice, team/speaker — only change on rare events), and the dynamic state rides at the end of the request where it is always uncached anyway. Transcripts still log the bare prompt; Cursor/Codex paths unchanged.
+- Compaction is much less lossy. Three changes to `compactActiveSession`:
+  - **Two-tier brief**: every compaction brief is now archived verbatim to `~/.open-claudia/briefs/<project-prefix>-<timestamp>.md` before seeding the fresh session, and the seed prompt tells the new session where the archive lives. Repeated compactions previously re-summarized prior summaries, blurring older facts each round — now the new session can reread earlier briefs at full fidelity instead of guessing. The summary prompt also drops length pressure ("length is NOT a constraint") since the brief is archived anyway. The summarizer additionally emits a `=== CONDENSED SEED ===` section (300-500 words: goal, next step, gated actions, load-bearing paths); when present and the full brief made it to disk, only the condensed section is seeded into the live context — cutting the per-turn context cost of the carried summary — while the detailed brief stays on disk for on-demand reads. Missing marker or failed archive falls back to seeding the full text exactly as before.
+  - **Machine-generated repo state**: the seed prompt now includes a git-generated block (branch, dirty files, ahead/behind upstream, last commit) for the session cwd — or its direct child repos (capped at 10) when the cwd itself isn't a git repo. Repo state was exactly the class of fact summarizers hallucinated or dropped; this block is produced by `git`, not model recall, and the seed says to trust it over the summary on conflict.
+  - **Verbatim recency tail**: the last 6 user/assistant turns (1,500 chars each, compact-summary/seed entries filtered out) are carried into the seed raw from the project transcript. Users most often reference the exchange immediately before compaction ("as I said", "do that thing you showed"), which summaries flatten; now those turns survive as exact quotes. Captured before the summarizer runs so the tail reflects real conversation.
+- All three collectors are fail-soft: any error (missing transcript, unreadable repo, git timeout) degrades to the previous behaviour rather than blocking compaction.
+
+## v2.2.21
+- Add Claude Fable 5 (`claude-fable-5`) to the Claude model picker and make it the default Claude Code model used when no per-user model override is selected. The default can still be overridden with `CLAUDE_MODEL`.
+
 ## v2.2.19
 - Add Claude Opus 4.8 (`claude-opus-4-8`) to the Claude model picker and make it the default Claude Code model used when no per-user model override is selected. The default can still be overridden with `CLAUDE_MODEL`, now documented in `.env.example`.
 

package/bot-agent.js

@@ -78,7 +78,7 @@ const CHAT_ID = CHAT_IDS[0]; // Primary owner chat for crons/notifications
 const WORKSPACE = config.WORKSPACE;
 const CLAUDE_PATH = config.CLAUDE_PATH;
 const CURSOR_PATH = config.CURSOR_PATH || null;
-const DEFAULT_CLAUDE_MODEL = config.CLAUDE_MODEL || process.env.CLAUDE_MODEL || "claude-opus-4-8";
+const DEFAULT_CLAUDE_MODEL = config.CLAUDE_MODEL || process.env.CLAUDE_MODEL || "claude-fable-5";
 
 // Resolve Cursor Agent CLI (optional)
 let resolvedCursorPath = CURSOR_PATH;
@@ -1661,9 +1661,9 @@ bot.onText(/\/model$/, (msg) => {
     [{ text: "GPT-5.4", callback_data: "m:gpt-5.4-medium" }, { text: "GPT-5.4 High", callback_data: "m:gpt-5.4-high" }],
     [{ text: "Auto", callback_data: "m:auto" }, { text: "Default", callback_data: "m:default" }],
   ] : [
-    [{ text: "Opus 4.8", callback_data: "m:claude-opus-4-8" }, { text: "Opus 4.7", callback_data: "m:claude-opus-4-7" }],
-    [{ text: "Sonnet", callback_data: "m:sonnet" }, { text: "Haiku", callback_data: "m:haiku" }],
-    [{ text: "Default", callback_data: "m:default" }],
+    [{ text: "Fable 5", callback_data: "m:claude-fable-5" }, { text: "Opus 4.8", callback_data: "m:claude-opus-4-8" }],
+    [{ text: "Opus 4.7", callback_data: "m:claude-opus-4-7" }, { text: "Sonnet", callback_data: "m:sonnet" }],
+    [{ text: "Haiku", callback_data: "m:haiku" }, { text: "Default", callback_data: "m:default" }],
   ];
   const label = settings.backend === "cursor" ? "Cursor Agent" : "Claude Code";
   send(`${label} model: ${settings.model || "default"}\n\nOr type /model <name> for any model.`, { keyboard: { inline_keyboard: keyboard } });

package/core/config.js

@@ -47,7 +47,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 DEFAULT_CLAUDE_MODEL = config.CLAUDE_MODEL || process.env.CLAUDE_MODEL || "claude-opus-4-8";
+const DEFAULT_CLAUDE_MODEL = config.CLAUDE_MODEL || process.env.CLAUDE_MODEL || "claude-fable-5";
 const AUTO_COMPACT_TOKENS = parseInt(config.AUTO_COMPACT_TOKENS || process.env.AUTO_COMPACT_TOKENS || "380000", 10);
 const MIN_COMPACT_INTERVAL_MS = parseInt(config.MIN_COMPACT_INTERVAL_MS || process.env.MIN_COMPACT_INTERVAL_MS || "1800000", 10);
 const PROJECT_TRANSCRIPTS = configTruthy(config.PROJECT_TRANSCRIPTS || process.env.PROJECT_TRANSCRIPTS, true);

package/core/handlers.js

@@ -535,7 +535,10 @@ register({
     const rows = [];
     rows.push([{ text: "── Claude ──", callback_data: "noop" }]);
     rows.push([
+      { text: "Fable 5", callback_data: "mb:claude:claude-fable-5" },
       { text: "Opus 4.8", callback_data: "mb:claude:claude-opus-4-8" },
+    ]);
+    rows.push([
       { text: "Opus 4.7", callback_data: "mb:claude:claude-opus-4-7" },
       { text: "Opus 4.6", callback_data: "mb:claude:claude-opus-4-6" },
     ]);

package/core/runner.js

@@ -3,14 +3,17 @@
 // progress UI. All IO routes through core/io.js so the same runner
 // works on every channel.
 
-const { spawn } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const { spawn, execFileSync } = require("child_process");
 const {
   CLAUDE_PATH, DEFAULT_CLAUDE_MODEL, resolvedCursorPath, resolvedCodexPath,
   AUTO_COMPACT_TOKENS, MIN_COMPACT_INTERVAL_MS, MAX_PROCESS_TIMEOUT, COMPACT_SUMMARY_TIMEOUT, botSubprocessEnv,
+  CONFIG_DIR,
 } = require("./config");
 const { currentState, saveState, recordSession, userOwnsClaudeSession } = require("./state");
 const { chatContext, currentChannelId, currentAdapter } = require("./context");
-const { buildSystemPrompt } = require("./system-prompt");
+const { buildSystemPrompt, promptWithDynamicContext } = require("./system-prompt");
 const { redactSensitive } = require("./redact");
 const { send, editMessage, sendVoice, splitMessage } = require("./io");
 const { textToVoice, TTS_CMD } = require("./media");
@@ -130,7 +133,9 @@ function buildClaudeArgs(prompt, opts = {}) {
   if (settings.permissionMode) args.push("--permission-mode", settings.permissionMode);
   else args.push("--dangerously-skip-permissions");
   if (settings.worktree) args.push("--worktree");
-  args.push(prompt);
+  // Dynamic state rides in the user prompt so the appended system prompt
+  // stays byte-stable across turns and the prompt-cache prefix survives.
+  args.push(promptWithDynamicContext(prompt));
   return args;
 }
 
@@ -237,29 +242,177 @@ function compactSummaryPrompt() {
     "",
     "Do not include: secrets, raw tokens, full file dumps, or chat pleasantries.",
     "Be concrete. Names of files, commands, flags, tags, and commits beat paraphrase. If a fact was load-bearing in this session, write it down verbatim.",
+    "Length is NOT a constraint for the brief — it is archived verbatim to disk and reread later. When in doubt, include the fact rather than dropping it for brevity.",
+    "",
+    "After the brief, output a final section that begins with a line containing exactly:",
+    "=== CONDENSED SEED ===",
+    "Below that marker write a tight condensed version, 300-500 words max: current goal, exact next step, hard constraints and gated actions (pushes, deploys, anything awaiting user approval), unresolved questions, and the load-bearing paths/IDs. The condensed section lives in the active context every single turn, so optimize it for token economy; the full brief above is read from disk only when needed, so optimize it for completeness.",
   ].join("\n");
 }
 
-function compactSeedPrompt(summary) {
-  return [
+const CONDENSED_MARKER_RE = /^[=#*\s]*CONDENSED SEED[=#*\s]*$/i;
+
+function splitCompactionBrief(summary) {
+  const text = String(summary || "");
+  const lines = text.split("\n");
+  let markerIdx = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (lines[i].length <= 60 && CONDENSED_MARKER_RE.test(lines[i])) { markerIdx = i; break; }
+  }
+  if (markerIdx === -1) return { fullBrief: text, condensed: null };
+  const condensed = lines.slice(markerIdx + 1).join("\n").trim();
+  const fullBrief = lines.slice(0, markerIdx).join("\n").trim();
+  if (condensed.length < 80 || !fullBrief) return { fullBrief: text, condensed: null };
+  return { fullBrief, condensed };
+}
+
+function compactSeedPrompt(summary, extras = {}) {
+  const parts = [
     "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.",
     "",
     "Before telling the user you lack context on something they reference:",
     "1. Check the summary below.",
-    "2. Search the project transcript with `open-claudia transcript-window <pattern>`.",
+    "2. Read the full archived brief on disk (path given below, when present) — it is the detailed version of this summary.",
+    "3. Search the project transcript with `open-claudia transcript-window <pattern>`.",
     "   It returns each hit with surrounding turns of context, capped per turn so it stays bounded.",
     "   Useful flags: --before N / --after N (default 2), --max-turns K (default 10), --regex.",
     "   Fall back to `grep -n -C 5 <pattern> <transcript-path>` (path in your system prompt under",
     "   'Project Transcript Memory') only if the helper does not fit your search.",
-    "Only ask the user if both turn up nothing.",
+    "Only ask the user if all of these turn up nothing.",
     "",
     "If a fact in the summary contradicts current repo state (a file path, a command, a flag, a version), trust what you observe now and proceed without flagging it unless the user asks.",
     "",
-    "Compacted summary:",
+    extras.condensed
+      ? "Compacted summary (condensed — the full detailed brief is archived on disk at the path below):"
+      : "Compacted summary:",
     summary,
-  ].join("\n");
+  ];
+  if (extras.briefPath) {
+    parts.push(
+      "",
+      `Full detailed brief for this compaction: ${extras.briefPath}`,
+      `Read it before re-deriving or re-asking anything the summary covers only thinly. Older compaction briefs for this project live in the same directory (${path.dirname(extras.briefPath)}, same filename prefix) — repeated compaction blurs older facts, so consult them for older work before falling back to transcript search.`
+    );
+  }
+  if (extras.repoFacts) {
+    parts.push(
+      "",
+      "Machine-generated repo state at compaction time (produced by git, not model recall — trust it over the summary if they disagree):",
+      extras.repoFacts
+    );
+  }
+  if (extras.recentTurns) {
+    parts.push(
+      "",
+      "Verbatim final turns before compaction (raw, most recent last). The user is most likely to reference these; treat them as exact quotes, unlike the summary above:",
+      extras.recentTurns
+    );
+  }
+  return parts.join("\n");
+}
+
+const BRIEFS_DIR = path.join(CONFIG_DIR, "briefs");
+
+function briefArchivePrefix(state = currentState()) {
+  const tinfo = transcriptProjectInfo(state);
+  if (tinfo && tinfo.transcriptPath) return path.basename(tinfo.transcriptPath, ".jsonl");
+  const channel = String(currentChannelId() || "unknown").replace(/[^a-zA-Z0-9_-]/g, "_");
+  return `channel-${channel}`;
+}
+
+function archiveCompactionBrief(summary, state = currentState()) {
+  try {
+    fs.mkdirSync(BRIEFS_DIR, { recursive: true, mode: 0o700 });
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const filePath = path.join(BRIEFS_DIR, `${briefArchivePrefix(state)}-${stamp}.md`);
+    const header = [
+      `# Compaction brief — ${new Date().toISOString()}`,
+      state.currentSession ? `Project: ${state.currentSession.name} (${state.currentSession.dir})` : null,
+      "",
+      "",
+    ].filter((line) => line !== null).join("\n");
+    fs.writeFileSync(filePath, header + summary + "\n", { mode: 0o600 });
+    return filePath;
+  } catch (e) {
+    console.warn(`[compact] brief archive failed: ${redactSensitive(e.message)}`);
+    return null;
+  }
+}
+
+function gitFactsForRepo(repoDir) {
+  const run = (args) => execFileSync("git", ["-C", repoDir, ...args], {
+    timeout: 4000, stdio: ["ignore", "pipe", "ignore"],
+  }).toString().trim();
+  const branch = run(["rev-parse", "--abbrev-ref", "HEAD"]);
+  const dirty = run(["status", "--porcelain"]).split("\n").filter(Boolean);
+  const lastCommit = run(["log", "-1", "--format=%h %s"]);
+  let upstream;
+  try {
+    const [behind, ahead] = run(["rev-list", "--left-right", "--count", "@{upstream}...HEAD"]).split(/\s+/);
+    upstream = (ahead === "0" && behind === "0") ? "in sync with upstream" : `${ahead} ahead / ${behind} behind upstream`;
+  } catch (e) {
+    upstream = "no upstream";
+  }
+  const dirtyNote = dirty.length
+    ? `${dirty.length} uncommitted: ${dirty.slice(0, 8).map((l) => l.trim().replace(/^\S+\s+/, "")).join(", ")}${dirty.length > 8 ? ", …" : ""}`
+    : "clean";
+  return `${repoDir} — branch ${branch}, ${dirtyNote}, ${upstream}, last commit: ${lastCommit}`;
+}
+
+function collectRepoStateFacts(cwd) {
+  try {
+    let repos = [];
+    if (fs.existsSync(path.join(cwd, ".git"))) {
+      repos = [cwd];
+    } else {
+      repos = fs.readdirSync(cwd, { withFileTypes: true })
+        .filter((d) => d.isDirectory() && fs.existsSync(path.join(cwd, d.name, ".git")))
+        .slice(0, 10)
+        .map((d) => path.join(cwd, d.name));
+    }
+    const lines = [];
+    for (const repo of repos) {
+      try { lines.push(`- ${gitFactsForRepo(repo)}`); } catch (e) { /* unreadable repo — skip */ }
+    }
+    return lines.length ? lines.join("\n") : null;
+  } catch (e) {
+    return null;
+  }
+}
+
+function collectRecentTurns(state = currentState(), maxTurns = 6, maxCharsPerTurn = 1500) {
+  try {
+    const tinfo = transcriptProjectInfo(state);
+    if (!tinfo || !tinfo.transcriptPath || !fs.existsSync(tinfo.transcriptPath)) return null;
+    const stat = fs.statSync(tinfo.transcriptPath);
+    const readBytes = Math.min(stat.size, 256 * 1024);
+    if (!readBytes) return null;
+    const fd = fs.openSync(tinfo.transcriptPath, "r");
+    const buf = Buffer.alloc(readBytes);
+    try {
+      fs.readSync(fd, buf, 0, readBytes, stat.size - readBytes);
+    } finally {
+      fs.closeSync(fd);
+    }
+    const lines = buf.toString("utf8").split("\n").filter((l) => l.trim());
+    const turns = [];
+    for (let i = lines.length - 1; i >= 0 && turns.length < maxTurns; i--) {
+      let entry;
+      try { entry = JSON.parse(lines[i]); } catch (e) { continue; /* partial first line of the byte window */ }
+      if (entry.role !== "user" && entry.role !== "assistant") continue;
+      const label = entry.metadata && entry.metadata.label;
+      if (label === "compact-summary" || label === "compact-seed") continue;
+      const text = String(entry.text || "").trim();
+      if (!text) continue;
+      const clipped = text.length > maxCharsPerTurn ? `${text.slice(0, maxCharsPerTurn)} …[truncated]` : text;
+      turns.push(`[${entry.role} @ ${entry.timestamp || "?"}]\n${clipped}`);
+    }
+    return turns.length ? turns.reverse().join("\n\n") : null;
+  } catch (e) {
+    return null;
+  }
 }
 
 function formatProgress(text, tools, currentTool, elapsed, toolDetail) {
@@ -380,6 +533,7 @@ async function compactActiveSession(cwd, opts = {}) {
 
   state.isCompacting = true;
   let summary;
+  const recentTurns = collectRecentTurns(state);
   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, label: "compact-summary", timeoutMs: COMPACT_SUMMARY_TIMEOUT });
@@ -393,7 +547,12 @@ async function compactActiveSession(cwd, opts = {}) {
     saveState();
   }
 
-  const seedRun = await runClaudeCapture(compactSeedPrompt(summary), cwd, { fresh: true, skipAutoCompact: true, label: "compact-seed" });
+  const { fullBrief, condensed } = splitCompactionBrief(summary);
+  const briefPath = archiveCompactionBrief(fullBrief, state);
+  // Only seed with the condensed version when the full text actually made it to disk.
+  const seedSummary = (condensed && briefPath) ? condensed : (condensed ? `${fullBrief}\n\n${condensed}` : fullBrief);
+  const repoFacts = collectRepoStateFacts(cwd);
+  const seedRun = await runClaudeCapture(compactSeedPrompt(seedSummary, { briefPath, condensed: !!(condensed && briefPath), repoFacts, recentTurns }), cwd, { fresh: true, skipAutoCompact: true, label: "compact-seed" });
   const newSessionId = seedRun.sessionId || state[sessionKey];
   if (newSessionId) state[sessionKey] = newSessionId;
   state.isFirstMessage = false;
@@ -739,7 +898,7 @@ 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];
+      "--dangerously-skip-permissions", promptWithDynamicContext(prompt)];
     const proc = spawn(CLAUDE_PATH, args, {
       cwd, env: claudeSubprocessEnv(),
       stdio: ["ignore", "pipe", "pipe"],
@@ -766,6 +925,11 @@ module.exports = {
   getActiveSessionKey,
   shouldAutoCompact,
   effectiveCompactThreshold,
+  compactSeedPrompt,
+  splitCompactionBrief,
+  archiveCompactionBrief,
+  collectRepoStateFacts,
+  collectRecentTurns,
   formatProgress,
   preflightClaudeAuthMessage,
   claudeEmptyFailureMessage,

package/core/system-prompt.js

@@ -28,17 +28,6 @@ function buildSystemPrompt() {
     ? (adapter.type === "kazee" ? "Kazee Chat" : adapter.type === "telegram" ? "Telegram" : adapter.type)
     : "Telegram";
 
-  let pendingTasksBlock = "";
-  if (adapter && channelId) {
-    try {
-      const pending = tasksStore.pendingSummary(adapter.id, channelId);
-      if (pending.length > 0) {
-        const tree = tasksStore.formatTree(adapter.id, channelId, { showIds: true });
-        pendingTasksBlock = `\n## Pending tasks\nYou may be resuming prior work. Before starting anything new, review these and decide whether to continue, update, or abandon them. Mark a subtask in_progress when you actually start it and completed when it's done.\n\n${tree}\n`;
-      }
-    } catch (e) {}
-  }
-
   let teamBlock = "";
   let currentSpeakerBlock = "";
   try {
@@ -115,8 +104,7 @@ ${soul}
 - Interface: ${channelLabel} chat through Open Claudia.
 - Active project path: ${state.currentSession ? state.currentSession.dir : "none"}
 - Voice notes: ${hasVoice ? "enabled" : "disabled"}
-- Vault: ${vault.isUnlocked() ? "unlocked" : "locked"}
-- Session: ${state.lastSessionId ? "resuming existing conversation" : "new conversation"}
+- Vault status, session state, and any pending tasks arrive in a "Runtime state" block at the top of each user message, not here.
 
 ## Stable Local Paths
 - Bot code: ${path.join(BOT_DIR, "bot.js")}
@@ -127,7 +115,7 @@ ${soul}
 - Received user files directory: ${FILES_DIR}
 
 ${transcriptPointerNote(state)}
-${currentSpeakerBlock}${teamBlock}${pendingTasksBlock}${slashCommandsBlock}${channelFormattingBlock}
+${currentSpeakerBlock}${teamBlock}${slashCommandsBlock}${channelFormattingBlock}
 ## Delivery
 Reply normally in your final answer. To send a file, image, or voice clip back to the current chat, run the bot CLI from inside this task — channel context is already in the env:
 - \`open-claudia send-file <path> [caption]\` — any document/binary
@@ -150,7 +138,7 @@ Persistent todo list with plans + subtasks (per channel; survives compaction and
 
 Note: any \`<system-reminder>\` you see about "task tools" / TaskCreate / TaskUpdate is from the underlying Claude Code harness — that's a different, ephemeral todo system. Open Claudia work belongs in \`open-claudia task\` (the persistent, channel-scoped one). Don't double-track.
 
-Use a plan when work is likely to outlive a single turn — i.e. it may hit a compaction, a restart, or a scheduled wakeup before completing, or its progress is something the user will want to see between turns. The plan is a parent task whose children are the steps. As you work, mark each subtask in_progress when you begin and completed when done — this is how a resumed turn sees where you left off. If pending tasks already exist when you start a turn they will be shown under "## Pending tasks" above; check them first.
+Use a plan when work is likely to outlive a single turn — i.e. it may hit a compaction, a restart, or a scheduled wakeup before completing, or its progress is something the user will want to see between turns. The plan is a parent task whose children are the steps. As you work, mark each subtask in_progress when you begin and completed when done — this is how a resumed turn sees where you left off. If pending tasks already exist when you start a turn they will be shown under "## Pending tasks" inside the Runtime state block at the top of the user message; check them first.
 
 Skip the plan for work that visibly completes within the current turn (e.g. running a few CLI commands in sequence and replying). A plan there is overhead the user has to read past.
 
@@ -214,4 +202,39 @@ If you tell the user "I'll check back in N minutes" or "I'll run this every morn
 `.trim();
 }
 
-module.exports = { loadSoul, buildSystemPrompt };
+// Per-turn churning state. Lives in the user prompt, NOT the appended
+// system prompt: the system prompt precedes the whole conversation in
+// every API request, so any byte that changes between turns invalidates
+// the prompt-cache prefix and re-bills the full history at write price
+// instead of 0.1x read price. Keep buildSystemPrompt() byte-stable
+// within a session; put anything that flips between turns here.
+function buildDynamicContextBlock() {
+  const state = currentState();
+  const adapter = currentAdapter();
+  const channelId = currentChannelId();
+  const lines = [
+    "## Runtime state (current turn)",
+    `- Vault: ${vault.isUnlocked() ? "unlocked" : "locked"}`,
+    `- Session: ${state.lastSessionId ? "resuming existing conversation" : "new conversation"}`,
+  ];
+  if (adapter && channelId) {
+    try {
+      const pending = tasksStore.pendingSummary(adapter.id, channelId);
+      if (pending.length > 0) {
+        const tree = tasksStore.formatTree(adapter.id, channelId, { showIds: true });
+        lines.push("", "## Pending tasks", "You may be resuming prior work. Before starting anything new, review these and decide whether to continue, update, or abandon them. Mark a subtask in_progress when you actually start it and completed when it's done.", "", tree);
+      }
+    } catch (e) {}
+  }
+  return lines.join("\n");
+}
+
+function promptWithDynamicContext(prompt) {
+  try {
+    return `${buildDynamicContextBlock()}\n\nCurrent user request:\n${prompt}`;
+  } catch (e) {
+    return prompt;
+  }
+}
+
+module.exports = { loadSoul, buildSystemPrompt, buildDynamicContextBlock, promptWithDynamicContext };

package/package.json

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