@inetafrica/open-claudia 2.6.26 → 2.6.28

package/bin/task.js

@@ -11,6 +11,7 @@ Per-channel todo list with optional plan/subtask hierarchy.
   open-claudia task add "<content>" [--parent <id>] [--description "<...>"]
   open-claudia task plan "<title>" "<sub1>" "<sub2>" ... [--description "<...>"]
   open-claudia task list [--status pending|in_progress|completed]
+  open-claudia task get <id>             # full detail for one task (+ its plan/subtasks)
   open-claudia task start <id>
   open-claudia task done <id>            # completes AND removes; last subtask done removes the plan
                                          # a plan won't complete while any subtask is still open
@@ -102,6 +103,27 @@ async function runList(args) {
   } catch (e) { console.error(e.message); process.exit(1); }
 }
 
+async function runGet(args) {
+  const id = args[0];
+  if (!id) { console.error("Usage: task get <id>"); process.exit(2); }
+  try {
+    const res = await postJson("task-get", { id });
+    if (!res.ok) { console.error(`Not found: ${id}`); process.exit(1); }
+    const t = res.task;
+    if (res.parent) console.log(`Plan: ${statusMark(res.parent)} ${res.parent.content}    (${res.parent.id})`);
+    console.log(`${statusMark(t)} ${t.content}    (${t.id})`);
+    if (t.description) console.log(`\n${t.description}`);
+    const kids = res.children || [];
+    if (kids.length > 0) {
+      console.log("\nSubtasks:");
+      kids.forEach((c) => console.log(`  ${statusMark(c)} ${c.content}    (${c.id})`));
+    }
+    const upd = t.updatedAt ? new Date(t.updatedAt).toISOString() : "?";
+    console.log(`\nstatus: ${t.status} · updated: ${upd}`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
 async function runUpdate(args, status) {
   const id = args[0];
   if (!id) { console.error(`Usage: task ${status === "in_progress" ? "start" : "done"} <id>`); process.exit(2); }
@@ -152,6 +174,7 @@ async function run(args) {
     case "add": return runAdd(rest);
     case "plan": return runPlan(rest);
     case "list": case "ls": return runList(rest);
+    case "get": case "show": return runGet(rest);
     case "start": return runUpdate(rest, "in_progress");
     case "done": case "complete": return runUpdate(rest, "completed");
     case "pending": return runUpdate(rest, "pending");

package/core/dream.js

@@ -332,6 +332,25 @@ function applyDream(decision, backupRoot) {
   return lines;
 }
 
+// Task-hygiene pass: surface tasks gone cold for the owner to decide on.
+// Flag-and-ask only — tasks are user intent, so dream NEVER edits or deletes
+// them; it just lists the stalest few in the morning report. Reports against
+// the owner's Telegram channel (where the dream summary lands).
+const STALE_REPORT_MAX = Number(process.env.DREAM_STALE_TASK_MAX) || 8;
+function staleTaskReport() {
+  try {
+    const tasks = require("./tasks");
+    const { CHAT_ID } = require("./config");
+    if (!CHAT_ID) return "";
+    const stale = tasks.staleRoots("telegram", String(CHAT_ID));
+    if (!stale.length) return "";
+    const shown = stale.slice(0, STALE_REPORT_MAX);
+    const lines = shown.map((s) => `   - ${s.content}  (${s.id}) · ${s.idleDays}d idle`);
+    const more = stale.length > shown.length ? `\n   …and ${stale.length - shown.length} more` : "";
+    return `🧹 ${stale.length} task${stale.length === 1 ? "" : "s"} have gone cold (untouched >${tasks.STALE_DAYS}d). Worth closing or reviving?\n${lines.join("\n")}${more}\nClose with \`open-claudia task done <id>\`, or tell me to.`;
+  } catch (e) { return ""; }
+}
+
 async function runDream({ trigger = "manual" } = {}) {
   if (!enabled()) return { skipped: "dream is disabled (DREAM=off)" };
   if (_dreaming) return { skipped: "a dream is already in progress" };
@@ -353,11 +372,14 @@ async function runDream({ trigger = "manual" } = {}) {
     const applied = applyDream(decision, backupRoot);
     const report = decision.report || (applied.length > 0 ? "Tidied up my memory overnight." : "");
 
-    const message = applied.length > 0
+    const staleNote = staleTaskReport();
+
+    let message = applied.length > 0
       ? `💤 ${report}\n\n${applied.join("\n")}\n\n🗄 Anything merged away is backed up under ${backupRoot}`
       : (report ? `💤 ${report}` : "");
+    if (staleNote) message = message ? `${message}\n\n${staleNote}` : `💤 ${staleNote}`;
 
-    return { applied, report, message, trigger };
+    return { applied, report, message, staleNote, trigger };
   } finally {
     _dreaming = false;
   }

package/core/loopback.js

@@ -73,7 +73,7 @@ function readBodyToFile(req, dest) {
 const SEND_KINDS = new Set(["send-file", "send-voice", "send-photo"]);
 const JSON_KINDS = new Set([
   "schedule-wakeup", "cron-add", "cron-remove", "job-list",
-  "task-add", "task-plan", "task-update", "task-remove", "task-list", "task-tree", "task-clear-completed",
+  "task-add", "task-plan", "task-update", "task-remove", "task-list", "task-get", "task-tree", "task-clear-completed",
   "people-list", "people-show", "people-add", "people-note", "people-link", "people-unlink",
   "people-remove", "people-set-primary",
   "intros-list", "intros-approve", "intros-reject",
@@ -248,6 +248,12 @@ async function handleJson(req, res, url, kind) {
     return reply(res, 200, { ok: true, tasks: list });
   }
 
+  if (kind === "task-get") {
+    if (!payload.id) return reply(res, 400, { error: "missing id" });
+    const got = tasksStore.get(adapterId, channelId, payload.id);
+    return reply(res, got ? 200 : 404, { ok: !!got, ...(got || {}) });
+  }
+
   if (kind === "task-clear-completed") {
     const remaining = tasksStore.clearCompleted(adapterId, channelId);
     return reply(res, 200, { ok: true, tasks: remaining });

package/core/runner.js

@@ -130,6 +130,11 @@ function logTurnUsage(state, usage, costUsd, announce, opts = {}) {
   const backend = state.settings?.backend || "claude";
   const parts = usageParts(usage, backend);
   const usageScope = opts.usageScope || "turn_delta";
+  // `parts.context` is the per-turn SUM of every API call's prefix, inflated
+  // by re-counting the cached prefix once per tool round-trip. When the caller
+  // tracked the true peak single-call prefix, report that as contextTokens and
+  // keep the inflated sum as billedContextTokens for cost attribution.
+  const hasPeak = Number.isFinite(opts.liveContextTokens) && opts.liveContextTokens > 0;
   const record = {
     ts: new Date().toISOString(),
     version: PKG_VERSION,
@@ -142,7 +147,8 @@ function logTurnUsage(state, usage, costUsd, announce, opts = {}) {
     outputTokens: parts.output,
     cacheReadTokens: parts.cacheRead,
     cacheCreationTokens: parts.cacheCreation,
-    contextTokens: parts.context,
+    contextTokens: hasPeak ? opts.liveContextTokens : parts.context,
+    billedContextTokens: parts.context,
     costUsd: typeof costUsd === "number" ? costUsd : 0,
   };
   if (opts.rawUsage && opts.rawUsage !== usage) {
@@ -785,6 +791,11 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   let toolUses = [];
   let currentTool = null;
   let currentToolDetail = "";
+  // True context-window occupancy is the largest single API call's prefix
+  // (input + cache_read + cache_creation), NOT the per-turn sum the result
+  // event reports — that sum re-counts the cached prefix once per tool
+  // round-trip and balloons to millions. Track the peak per-call prefix.
+  let peakContextTokens = 0;
 
   // Hermes-style skill announcements: one chat line when a learned skill
   // is invoked or its SKILL.md is written/patched. Deduped per turn.
@@ -897,6 +908,10 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     const lastNewline = state.streamBuffer.lastIndexOf("\n");
     state.streamBuffer = lastNewline >= 0 ? state.streamBuffer.slice(lastNewline + 1) : state.streamBuffer;
     for (const evt of events) {
+      if (evt.type === "assistant" && evt.message?.usage) {
+        const callPrefix = usageParts(evt.message.usage, settings.backend || "claude").context;
+        if (callPrefix > peakContextTokens) peakContextTokens = callPrefix;
+      }
       if (evt.type === "assistant" && evt.message?.content) {
         for (const block of evt.message.content) {
           if (block.type === "text") assistantText += block.text;
@@ -1003,8 +1018,10 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
         // Codex already reports usage at turn.completed. A result usage block,
         // if present, is the same cumulative total and must not be counted again.
         if (evt.usage && settings.backend !== "codex") {
-          applyUsageToState(state, evt.usage, typeof evt.total_cost_usd === "number" ? evt.total_cost_usd : 0, { usageScope: "turn_delta" });
-          logTurnUsage(state, evt.usage, typeof evt.total_cost_usd === "number" ? evt.total_cost_usd : 0, (text) => chatContext.run(store, () => send(text)), { usageScope: "turn_delta" });
+          const peakOpts = { usageScope: "turn_delta" };
+          if (peakContextTokens > 0) peakOpts.liveContextTokens = peakContextTokens;
+          applyUsageToState(state, evt.usage, typeof evt.total_cost_usd === "number" ? evt.total_cost_usd : 0, peakOpts);
+          logTurnUsage(state, evt.usage, typeof evt.total_cost_usd === "number" ? evt.total_cost_usd : 0, (text) => chatContext.run(store, () => send(text)), peakOpts);
         }
         if (typeof evt.total_cost_usd === "number" && settings.backend === "codex") state.sessionUsage.costUsd += evt.total_cost_usd;
         saveState();

package/core/system-prompt.js

@@ -270,8 +270,8 @@ function buildDynamicContextBlock() {
         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);
+          const tree = tasksStore.formatForInjection(adapter.id, channelId, { showIds: true });
+          lines.push("", "## Pending tasks", "Ranked by recent activity (`updatedAt`). The most-recently-worked items show in full; colder ones are title-only; stale ones (untouched >2w) are batched at the bottom — they're likely finished or abandoned, so close them with `open-claudia task done <id>` or reopen by working them. Mark a task in_progress when you actually start it and done when finished, so this ranking stays honest. If something in our conversation shows a task is already finished, proactively offer to close it. Shown once per session — run `open-claudia task list` for the full tree.", "", 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.`);

package/core/tasks.js

@@ -213,6 +213,102 @@ function formatTree(adapter, channelId, opts = {}) {
   return lines.join("\n");
 }
 
+// --- Task hygiene (recency + staleness) ---------------------------------
+// updatedAt is the honest activity signal — a task can rot in "in_progress"
+// forever, so status is a poor proxy for what's actually being worked on.
+// updatedAt only moves on mutation (add/update/start/done/edit), so this
+// rewards keeping statuses current and lets cold work fall to the bottom.
+
+const STALE_DAYS = Number(process.env.OPEN_CLAUDIA_TASK_STALE_DAYS) || 14;
+const RECENCY_FULL = Number(process.env.OPEN_CLAUDIA_TASK_RECENCY_FULL) || 6;
+const DAY_MS = 86400000;
+
+// A plan is as fresh as its most recently touched part: a plan root rarely
+// gets edited while its subtasks churn, so fold child activity into the root.
+function lastActivityOf(root) {
+  let latest = root.updatedAt || root.createdAt || 0;
+  for (const c of root.children || []) {
+    latest = Math.max(latest, c.updatedAt || c.createdAt || 0);
+  }
+  return latest;
+}
+
+function openTree(adapter, channelId) {
+  return tree(adapter, channelId)
+    .map((r) => ({ ...r, children: (r.children || []).filter((c) => c.status !== "completed") }))
+    .filter((r) => r.status !== "completed" || r.children.length > 0);
+}
+
+// Fetch one task with its surrounding context, for the `task get <id>` hint
+// the injection block points cold tasks at.
+function get(adapter, channelId, id) {
+  const all = load(adapter, channelId);
+  const t = all.find((x) => x.id === id);
+  if (!t) return null;
+  const children = all.filter((c) => c.parentId === id);
+  const parent = t.parentId ? all.find((p) => p.id === t.parentId) || null : null;
+  return { task: t, children, parent };
+}
+
+// Roots untouched for longer than `days` (default STALE_DAYS), oldest first.
+// Used by the dream task-hygiene pass to surface cold work for a user
+// decision — it flags and asks, never deletes (tasks are user intent).
+function staleRoots(adapter, channelId, opts = {}) {
+  const days = Number(opts.days) || STALE_DAYS;
+  const now = opts.now || Date.now();
+  return openTree(adapter, channelId)
+    .map((r) => ({ root: r, idleDays: (now - lastActivityOf(r)) / DAY_MS }))
+    .filter((x) => x.idleDays > days)
+    .sort((a, b) => b.idleDays - a.idleDays)
+    .map((x) => ({ id: x.root.id, content: x.root.content, status: x.root.status, idleDays: Math.round(x.idleDays) }));
+}
+
+function renderRootFull(root, num, showIds) {
+  const idTag = showIds ? `    (${root.id})` : "";
+  const lines = [`${num}. ${statusMark(root)} ${root.content}${idTag}`];
+  if (root.description) lines.push(`      ${root.description}`);
+  for (const c of root.children || []) {
+    lines.push(`    ${statusMark(c)} ${c.content}${showIds ? `    (${c.id})` : ""}`);
+  }
+  return lines;
+}
+
+// Recency-ranked injection body. The few most-recently-active roots render
+// in full; the rest render title-only with a `task get` pointer; anything
+// untouched past STALE_DAYS is batched one-line into a stale footer so it
+// stops eating fresh tokens regardless of status. Returns "" when empty.
+function formatForInjection(adapter, channelId, opts = {}) {
+  const showIds = opts.showIds !== false;
+  const now = opts.now || Date.now();
+  const fullCount = Number.isFinite(opts.fullCount) ? opts.fullCount : RECENCY_FULL;
+  const staleDays = Number(opts.staleDays) || STALE_DAYS;
+
+  const roots = openTree(adapter, channelId);
+  if (roots.length === 0) return "";
+
+  const decorated = roots.map((r) => ({ root: r, idleDays: (now - lastActivityOf(r)) / DAY_MS }));
+  const stale = decorated.filter((x) => x.idleDays > staleDays).sort((a, b) => b.idleDays - a.idleDays);
+  const active = decorated.filter((x) => x.idleDays <= staleDays).sort((a, b) => lastActivityOf(b.root) - lastActivityOf(a.root));
+
+  const lines = [];
+  let n = 0;
+  const full = active.slice(0, fullCount);
+  const brief = active.slice(fullCount);
+  for (const x of full) lines.push(...renderRootFull(x.root, ++n, showIds));
+  if (brief.length > 0) {
+    lines.push("", `Less recently touched — title only (run \`open-claudia task get <id>\` for detail):`);
+    for (const x of brief) lines.push(`${++n}. ${statusMark(x.root)} ${x.root.content}${showIds ? `    (${x.root.id})` : ""}`);
+  }
+  if (stale.length > 0) {
+    const staleMax = Number.isFinite(opts.staleMax) ? opts.staleMax : 10;
+    const shown = stale.slice(0, staleMax);
+    lines.push("", `+${stale.length} stale — untouched >${staleDays}d, likely finished or abandoned. Review and close with \`open-claudia task done <id>\` (or \`task get <id>\` first):`);
+    for (const x of shown) lines.push(`   - ${statusMark(x.root)} ${x.root.content}    (${x.root.id}) · ${Math.round(x.idleDays)}d idle`);
+    if (stale.length > shown.length) lines.push(`   …and ${stale.length - shown.length} more — \`open-claudia task list\` for all`);
+  }
+  return lines.join("\n");
+}
+
 module.exports = {
   filePathFor,
   load, save,
@@ -220,4 +316,6 @@ module.exports = {
   prune, complete,
   pendingSummary,
   format, formatTree, statusMark,
+  get, staleRoots, formatForInjection, lastActivityOf,
+  STALE_DAYS, RECENCY_FULL,
 };

package/package.json

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