@inetafrica/open-claudia 2.6.7 → 2.6.9

package/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## v2.6.8
+- **Tasks: a plan can't be completed while subtasks are still open.** `task done` (and the loopback task-update path) now refuses to flip a parent to completed if any child is not yet completed — it returns a blocked result listing the open children, and the CLI prints a clean "Can't complete <id>: N subtask(s) still open" message instead of silently corrupting the tree. Standalone tasks and completing the last open child (which removes the whole plan) are unchanged. Prevents the inflated-count drift where parents showed done over still-open children.
+
 ## v2.6.6
 - **Recall: recent-turns window as judge-gated context.** v2.6.5 fixed quotes, but a bare follow-up like "Push" with no quote still recalled nothing — recall only ever saw the current message. The last ~6 user/assistant turns on this channel (read from the project transcript, current turn excluded) now feed recall the same way the quote does: keyword-matched as origin "context", kept only when the haiku judge confirms relevance, dropped on fail-open. A stale thread can never force-inject packs on keywords alone, but terse follow-ups finally inherit the topic of the conversation.
 

package/bin/task.js

@@ -13,6 +13,7 @@ Per-channel todo list with optional plan/subtask hierarchy.
   open-claudia task list [--status pending|in_progress|completed]
   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
   open-claudia task remove <id>          # removing a plan removes its subtasks
   open-claudia task clear-completed      # prune any leftover completed entries
 
@@ -106,6 +107,12 @@ async function runUpdate(args, status) {
   if (!id) { console.error(`Usage: task ${status === "in_progress" ? "start" : "done"} <id>`); process.exit(2); }
   try {
     const res = await postJson("task-update", { id, status });
+    if (res.blocked) {
+      const kids = res.openChildren || [];
+      const names = kids.map((c) => `  - ${c.content} (${c.id})`).join("\n");
+      console.error(`Can't complete ${id}: ${kids.length} subtask${kids.length === 1 ? "" : "s"} still open. Finish or remove ${kids.length === 1 ? "it" : "them"} first:\n${names}`);
+      process.exit(1);
+    }
     if (!res.ok) { console.error(`Not found: ${id}`); process.exit(1); }
     if (status === "completed") {
       const n = res.removedCount || 0;

package/core/entities.js

@@ -287,7 +287,9 @@ function queryTerms(text) {
   const terms = [];
   for (const raw of String(text || "").toLowerCase().split(/[^a-z0-9_.-]+/)) {
     const t = raw.replace(/^[.-]+|[.-]+$/g, "");
-    if (t.length < 3 || STOPWORDS.has(t) || seen.has(t)) continue;
+    // 2-char floor (not 3): keep technical acronyms like ip/ci/ha/ws/db/s3;
+    // common 2-letter words (is/it/in/of/on...) are caught by STOPWORDS.
+    if (t.length < 2 || STOPWORDS.has(t) || seen.has(t)) continue;
     seen.add(t);
     terms.push(t);
     if (terms.length >= 40) break;

package/core/loopback.js

@@ -226,7 +226,9 @@ async function handleJson(req, res, url, kind) {
     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 });
+      if (!result) return reply(res, 404, { ok: false, task: null, removedCount: 0 });
+      if (result.blocked) return reply(res, 200, { ok: false, blocked: true, task: result.task, openChildren: result.openChildren });
+      return reply(res, 200, { ok: true, task: result.task, removedCount: result.removedCount });
     }
     const patch = {};
     if (payload.status) patch.status = payload.status;

package/core/pack-review.js

@@ -90,6 +90,7 @@ ${clip(assistantText)}
 Decide. Rules:
 - Bias toward action: if the turn did real work on an identifiable topic (a named system, project, server, app, person, or domain), record it — at minimum a journal line. Most working turns deserve one. Reserve empty actions for small talk, pure status checks, and turns that contain nothing new.
 - UPDATE an existing pack when the turn touched that topic: append a journal line, and rewrite State if where-things-stand changed. Update Stance when the user expressed a lasting preference or rule; Procedure when a verified working method emerged.
+- PROMOTE durable conclusions out of the Journal. A confirmed root-cause diagnosis, an established fact, or a settled design decision must go into Stance/Procedure/State (the parts always injected in full), NOT only a Journal line — Journal is truncated to the last few lines on injection, so a conclusion left only there will silently fall out of recall over time.
 - CREATE a pack when the turn worked on a durable topic no existing pack covers. Topics recur more than you expect — a named system or project is durable by default. Do not create packs for one-off trivia, and prefer update when an existing pack fits.
 - Never store secrets, tokens, passwords, or credentials.
 - State should be concise (under 150 words). Journal entries one sentence. Never start a journal or log sentence with a date — dates are prepended automatically.

package/core/packs.js

@@ -287,7 +287,9 @@ function queryTerms(text) {
   const terms = [];
   for (const raw of String(text || "").toLowerCase().split(/[^a-z0-9_.-]+/)) {
     const t = raw.replace(/^[.-]+|[.-]+$/g, "");
-    if (t.length < 3 || STOPWORDS.has(t) || seen.has(t)) continue;
+    // 2-char floor (not 3): keep technical acronyms like ip/ci/ha/ws/db/s3;
+    // common 2-letter words (is/it/in/of/on...) are caught by STOPWORDS.
+    if (t.length < 2 || STOPWORDS.has(t) || seen.has(t)) continue;
     seen.add(t);
     terms.push(t);
     if (terms.length >= 40) break;

package/core/system-prompt.js

@@ -5,6 +5,7 @@
 const fs = require("fs");
 const path = require("path");
 const { SOUL_FILE, CRONS_FILE, VAULT_FILE, FILES_DIR, BOT_DIR, WHISPER_CLI, FFMPEG } = require("./config");
+const CONFIG_DIR = require("../config-dir");
 const { currentState } = require("./state");
 const { currentAdapter, currentChannelId } = require("./context");
 const { vault } = require("./vault-store");
@@ -311,11 +312,27 @@ function formatPackForContext(pack, packsLib) {
     const body = (pack.sections[section] || "").trim();
     if (body) parts.push(`#### ${section}\n${body}`);
   }
-  const journal = (pack.sections.Journal || "").trim().split("\n").filter(Boolean).slice(-6).join("\n");
+  const journal = (pack.sections.Journal || "").trim().split("\n").filter(Boolean).slice(-10).join("\n");
   if (journal) parts.push(`#### Journal (recent)\n${journal}`);
   return clip(parts.join("\n\n"), PACK_INJECT_MAX_CHARS);
 }
 
+// Compact anchor re-injected on later turns of the same session: the full
+// pack was already shown once, but compaction can silently drop it from
+// the rolling context, leaving a recall hole. A short Stance+State+latest
+// reminder keeps the pack "present" without re-paying the full token cost.
+function formatPackCompact(pack) {
+  const clip = (s, n) => (s.length > n ? s.slice(0, n) + "\n…[truncated]" : s);
+  const parts = [`### Pack: ${pack.name} (${pack.dir}) — recalled (full version shown earlier this session; read PACK.md for detail)`];
+  const stance = (pack.sections.Stance || "").trim();
+  if (stance) parts.push(`#### Stance\n${stance}`);
+  const state = (pack.sections.State || "").trim();
+  if (state) parts.push(`#### State\n${state}`);
+  const journal = (pack.sections.Journal || "").trim().split("\n").filter(Boolean).slice(-1).join("\n");
+  if (journal) parts.push(`#### Journal (latest)\n${journal}`);
+  return clip(parts.join("\n\n"), 1200);
+}
+
 function buildPackBlock(matches) {
   try {
     const packsLib = require("./packs");
@@ -332,9 +349,14 @@ function buildPackBlock(matches) {
       used.push(m.dir);
       const key = `${adapter?.id || "?"}:${channelId || "?"}:${m.dir}`;
       const stamp = `${sess}:${pack.updated}`;
-      if (packsInjectedFor.get(key) === stamp) continue;
-      packsInjectedFor.set(key, stamp);
       lastInjected.packs.push(pack.name || m.dir);
+      if (packsInjectedFor.get(key) === stamp) {
+        // Already injected the full pack this session-version; re-inject a
+        // compact anchor so compaction can't silently drop it.
+        blocks.push(formatPackCompact(pack));
+        continue;
+      }
+      packsInjectedFor.set(key, stamp);
       blocks.push(formatPackForContext(pack, packsLib));
     }
     if (used.length > 0) setImmediate(() => { try { packsLib.touchUsed(used); } catch (e) {} });
@@ -458,6 +480,24 @@ function mergeMatches(primary, secondary, keyOf) {
   return out;
 }
 
+// Append one JSONL line per turn recording what recall matched vs. what
+// survived the relevance gate. This is the data we tune the match
+// threshold with — disable via RECALL_DEBUG=off.
+function logRecall(msg, candPacks, candEntities, keptPacks, keptEntities) {
+  if (String(process.env.RECALL_DEBUG || "on").toLowerCase() === "off") return;
+  try {
+    const rec = {
+      ts: new Date().toISOString(),
+      msg: String(msg || "").slice(0, 200),
+      candidatePacks: candPacks.map((m) => ({ dir: m.dir, score: m.score, origin: m.origin })),
+      keptPacks: keptPacks.map((m) => m.dir),
+      candidateEntities: candEntities.map((m) => ({ slug: m.slug, score: m.score, origin: m.origin })),
+      keptEntities: keptEntities.map((m) => m.slug),
+    };
+    fs.appendFileSync(path.join(CONFIG_DIR, "recall-debug.jsonl"), JSON.stringify(rec) + "\n");
+  } catch (e) {}
+}
+
 async function promptWithDynamicContext(prompt) {
   lastInjected = { packs: [], entities: [] };
   try {
@@ -485,9 +525,12 @@ async function promptWithDynamicContext(prompt) {
         (m) => m.slug,
       );
     } catch (e) {}
+    const candPacks = packMatches;
+    const candEntities = entityMatches;
     ({ packMatches, entityMatches } = await filterMatches(userText, fullContext, packMatches, entityMatches));
     packMatches = packMatches.slice(0, 3);
     entityMatches = entityMatches.slice(0, 4);
+    logRecall(userText, candPacks, candEntities, packMatches, entityMatches);
     return `${buildDynamicContextBlock()}${buildPackBlock(packMatches)}${buildEntityBlock(entityMatches)}\n\nCurrent user request:\n${prompt}`;
   } catch (e) {
     return prompt;

package/core/tasks.js

@@ -120,7 +120,20 @@ function prune(adapter, channelId) {
 
 // Mark a task completed, then prune. Reports how many entries left the
 // list so callers can tell the agent what disappeared.
+//
+// A plan can't be completed while any of its subtasks are still open:
+// flipping the parent to [x] over [ ] children leaves a contradictory
+// row that lingers (prune only drops a parent once all kids are done)
+// and inflates the visible list. Refuse instead, naming the open kids
+// so the caller finishes or removes them first.
 function complete(adapter, channelId, id) {
+  const list = load(adapter, channelId);
+  const target = list.find((t) => t.id === id);
+  if (!target) return null;
+  if (!target.parentId) {
+    const openChildren = list.filter((c) => c.parentId === id && c.status !== "completed");
+    if (openChildren.length > 0) return { blocked: true, task: target, openChildren };
+  }
   const t = update(adapter, channelId, id, { status: "completed" });
   if (!t) return null;
   const before = load(adapter, channelId).length;

package/package.json

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