@inetafrica/open-claudia 2.2.21 → 2.2.23

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## v2.2.23
+- **Token economy: tasks (R2).** The per-channel todo list no longer rides every prompt at full size.
+  - **Done means gone**: completing a task now deletes it from the store instead of leaving an `[x]` row. Finishing the last subtask of a plan deletes the whole plan. `tasks.complete()` wraps the status flip plus a `prune()` pass; the loopback `task-update` handler routes `status: completed` through it and reports how many entries were removed, so the CLI can tell the agent what disappeared. `prune()` also retires legacy debris — plans whose subtasks are all completed but whose own status was never flipped.
+  - **Once-per-session tree injection**: the full pending-task tree is only injected into the first turn of a session (after restart, new conversation, or compaction) — exactly when the agent needs to rediscover where it left off. Later turns get a one-line count (`## Pending tasks: N open (M in progress)`) with a pointer to `open-claudia task list`. Previously a large tree (~60 plans on a busy channel) was re-sent uncached on every single user turn.
+  - `formatTree` gained a `hideCompleted` option so any injected tree only shows remaining work; CLI help and the system-prompt task docs updated to describe the new semantics.
+
+## 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`.
 

package/bin/task.js

@@ -12,13 +12,14 @@ Per-channel todo list with optional plan/subtask hierarchy.
   open-claudia task plan "<title>" "<sub1>" "<sub2>" ... [--description "<...>"]
   open-claudia task list [--status pending|in_progress|completed]
   open-claudia task start <id>
-  open-claudia task done <id>
+  open-claudia task done <id>            # completes AND removes; last subtask done removes the plan
   open-claudia task remove <id>          # removing a plan removes its subtasks
-  open-claudia task clear-completed      # only clears plans whose subtasks are all done
+  open-claudia task clear-completed      # prune any leftover completed entries
 
 Use plans for any work with 3+ distinct steps. Mark subtasks in_progress
 as you start them and done as you finish, so a resumed turn or a new
-turn after compaction can pick up where you left off.
+turn after compaction can pick up where you left off. Done means gone:
+the list only ever shows remaining work.
 `;
 
 function statusMark(t) {
@@ -106,7 +107,12 @@ async function runUpdate(args, status) {
   try {
     const res = await postJson("task-update", { id, status });
     if (!res.ok) { console.error(`Not found: ${id}`); process.exit(1); }
-    console.log(`Task ${id} → ${status}.`);
+    if (status === "completed") {
+      const n = res.removedCount || 0;
+      console.log(n > 1 ? `Task ${id} completed and removed (plan finished — ${n} entries removed).` : `Task ${id} completed and removed from the list.`);
+    } else {
+      console.log(`Task ${id} → ${status}.`);
+    }
     process.exit(0);
   } catch (e) { console.error(e.message); process.exit(1); }
 }

package/core/loopback.js

@@ -224,6 +224,10 @@ async function handleJson(req, res, url, kind) {
 
   if (kind === "task-update") {
     if (!payload.id) return reply(res, 400, { error: "missing id" });
+    if (payload.status === "completed") {
+      const result = tasksStore.complete(adapterId, channelId, payload.id);
+      return reply(res, result ? 200 : 404, { ok: !!result, task: result ? result.task : null, removedCount: result ? result.removedCount : 0 });
+    }
     const patch = {};
     if (payload.status) patch.status = payload.status;
     if (typeof payload.content === "string") patch.content = payload.content;

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,15 +138,14 @@ 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. Completed means removed: \`task done\` deletes the entry, and finishing the last subtask deletes the whole plan. The list only ever contains remaining work. The full pending tree is injected into the Runtime state block once per session (first turn after restart/compaction); later turns show just a count — run \`open-claudia task list\` when you need the tree again.
 
 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.
 
 - \`open-claudia task plan "<plan title>" "<step 1>" "<step 2>" "<step 3>" [--description "<why / success criteria>"]\` — atomic create
 - \`open-claudia task add "<content>" [--parent <plan-id>] [--description "..."]\` — add a single task or subtask
 - \`open-claudia task list\` — renders as a tree
-- \`open-claudia task start <id>\` / \`task done <id>\` / \`task remove <id>\` (removing a plan removes its subtasks)
-- \`open-claudia task clear-completed\` — only clears plans whose subtasks are all done
+- \`open-claudia task start <id>\` / \`task done <id>\` (completes AND removes; finishing the last subtask removes the plan) / \`task remove <id>\` (removing a plan removes its subtasks)
 
 For one-off work under 3 steps, skip the plan and just track it in your own response.
 
@@ -214,4 +201,54 @@ 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.
+// The full task tree is large and rides the (uncached) tail of every
+// prompt, so inject it only once per session: on the first turn after a
+// bot restart, a new conversation, or a compaction (lastSessionId
+// changes in all three cases). Later turns get a one-line count; the
+// agent runs `open-claudia task list` when it needs detail.
+const taskTreeInjectedFor = new Map(); // `${adapterId}:${channelId}` -> sessionId
+
+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 key = `${adapter.id}:${channelId}`;
+        const sess = state.lastSessionId || "new";
+        if (taskTreeInjectedFor.get(key) !== sess) {
+          taskTreeInjectedFor.set(key, sess);
+          const tree = tasksStore.formatTree(adapter.id, channelId, { showIds: true, hideCompleted: 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. This tree is only shown once per session — run `open-claudia task list` to see it again later.", "", tree);
+        } else {
+          const inProgress = pending.filter((t) => t.status === "in_progress").length;
+          lines.push("", `## Pending tasks: ${pending.length} open${inProgress > 0 ? ` (${inProgress} in progress)` : ""} — run \`open-claudia task list\` for the tree. Keep statuses current as you work.`);
+        }
+      }
+    } 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/core/tasks.js

@@ -92,6 +92,42 @@ function remove(adapter, channelId, id) {
   return { removed: target, alsoRemoved: ids.size - 1 };
 }
 
+// Done means gone: completed items leave the list instead of lingering
+// as [x] rows that get re-injected into every prompt. Removes completed
+// subtasks, completed standalone tasks, and any plan whose subtasks are
+// all completed (the plan is implicitly finished even if its own status
+// was never flipped). Returns the remaining list.
+function prune(adapter, channelId) {
+  const all = load(adapter, channelId);
+  const drop = new Set();
+  for (const t of all) {
+    if (t.parentId) {
+      if (t.status === "completed") drop.add(t.id);
+      continue;
+    }
+    const kids = all.filter((c) => c.parentId === t.id);
+    const kidsAllDone = kids.length > 0 && kids.every((c) => c.status === "completed");
+    if (kidsAllDone || (t.status === "completed" && kids.length === 0)) {
+      drop.add(t.id);
+      for (const c of kids) drop.add(c.id);
+    }
+  }
+  if (drop.size === 0) return all;
+  const remaining = all.filter((t) => !drop.has(t.id));
+  save(adapter, channelId, remaining);
+  return remaining;
+}
+
+// Mark a task completed, then prune. Reports how many entries left the
+// list so callers can tell the agent what disappeared.
+function complete(adapter, channelId, id) {
+  const t = update(adapter, channelId, id, { status: "completed" });
+  if (!t) return null;
+  const before = load(adapter, channelId).length;
+  const remaining = prune(adapter, channelId);
+  return { task: t, removedCount: before - remaining.length };
+}
+
 function clearCompleted(adapter, channelId) {
   const all = load(adapter, channelId);
   const drop = new Set();
@@ -146,7 +182,12 @@ function format(t, idx) {
 
 function formatTree(adapter, channelId, opts = {}) {
   const showIds = opts.showIds !== false;
-  const t = tree(adapter, channelId);
+  let t = tree(adapter, channelId);
+  if (opts.hideCompleted) {
+    t = t
+      .map((r) => ({ ...r, children: r.children.filter((c) => c.status !== "completed") }))
+      .filter((r) => r.status !== "completed" || r.children.length > 0);
+  }
   const lines = [];
   t.forEach((root, i) => {
     const head = `${i + 1}. ${statusMark(root)} ${root.content}` + (showIds ? `    (${root.id})` : "");
@@ -163,6 +204,7 @@ module.exports = {
   filePathFor,
   load, save,
   add, plan, update, remove, list, tree, clearCompleted,
+  prune, complete,
   pendingSummary,
   format, formatTree, statusMark,
 };

package/package.json

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