@inetafrica/open-claudia 2.6.8 → 2.6.10

package/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## v2.6.10
+- **Sessions: wakeups join the live conversation instead of forking it.** A scheduled wakeup/cron captured the channel's `sessionId` at schedule time and resumed that *frozen* id when it fired — but every run writes its result id back to the shared `state.lastSessionId`, and a home-conversation compaction mints a brand-new id. So a pending wakeup carrying a pre-compaction id would yank the channel's live pointer onto a dead thread, and the user's next typed message landed on the stale session. Multiple concurrent wakeups froze different ids and forked the channel into parallel sessions. Fix (`core/scheduler.js`): a wakeup now resumes the channel's live `state.lastSessionId` (already ownership-guarded in the runner); the frozen `job.sessionId` is used only as a cold-start fallback when there is no live pointer. Wakeups scheduled after upgrade join the current context; already-pending wakeups still carry their old id until they fire.
+
 ## 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.
 

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

@@ -106,7 +106,10 @@ async function fireJob(job, retry = 0) {
 
     const { runClaude } = require("./runner");
     const runOpts = {};
-    if (job.sessionId) runOpts.resumeSessionId = job.sessionId;
+    // Join the channel's live conversation. Only fall back to the wakeup's
+    // frozen sessionId when there's no live pointer (cold start) — otherwise
+    // a stale, compacted-away id would yank the channel onto a dead thread.
+    if (!state.lastSessionId && job.sessionId) runOpts.resumeSessionId = job.sessionId;
     try {
       await runClaude(wrappedPrompt, cwd, null, runOpts);
       jobs.update(job.id, { lastFireAt: Date.now(), lastFireOk: true });

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/package.json

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