@inetafrica/open-claudia 2.2.22 → 2.2.24

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## v2.2.24
+- Fix one-shot wakeups being lost across restarts when their fire collided with a busy channel. `fireJob` removed the wakeup from `jobs.json` as soon as it returned — but on a busy channel the actual run was deferred to an in-memory 30s retry timer, so the job was already gone from disk and a bot restart during the deferral window (e.g. `/upgrade`) silently dropped it. The wakeup now stays persisted until it actually runs (or is conclusively skipped after retries); a restart mid-deferral re-arms it from `jobs.json` via the existing missed-wakeup grace pass.
+
+## 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`:

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/scheduler.js

@@ -78,11 +78,13 @@ async function fireJob(job, retry = 0) {
     raw: null,
   };
 
+  let deferred = false;
   await runInChat(ctx, async () => {
     const state = getUserState(canonicalUserId);
     if (state.runningProcess) {
       if (retry < 4) {
         console.log(`scheduler: ${job.id} busy, deferring ${DEFER_BUSY_MS / 1000}s (retry ${retry + 1})`);
+        deferred = true;
         setTimeout(() => fireJob(job, retry + 1), DEFER_BUSY_MS);
         return;
       }
@@ -115,7 +117,11 @@ async function fireJob(job, retry = 0) {
     }
   });
 
-  if (job.kind === "wakeup") {
+  // Only delete a one-shot wakeup once it actually ran (or was skipped).
+  // Removing it while a busy-deferral is pending would leave the retry
+  // living only in an in-memory setTimeout — a restart during that
+  // window (e.g. /upgrade) would silently lose the wakeup.
+  if (job.kind === "wakeup" && !deferred) {
     jobs.remove(job.id);
     timers.delete(job.id);
   }

package/core/system-prompt.js

@@ -138,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" inside the Runtime state block at the top of the user message; 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.
 
@@ -208,6 +207,13 @@ If you tell the user "I'll check back in N minutes" or "I'll run this every morn
 // 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();
@@ -221,8 +227,16 @@ function buildDynamicContextBlock() {
     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);
+        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) {}
   }

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.22",
+  "version": "2.2.24",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {