@inetafrica/open-claudia 2.6.3 → 2.6.5

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## v2.6.4
+- **Recall matcher: kill false-positive pack/entity injections.** Three compounding fixes after Sharon/Euvencia/higgsfield got recalled on turns that had nothing to do with them:
+  - **Match only the user's own words.** The FTS routers used the full composed prompt — so a Telegram reply-quote fed the entire quoted message (~40 terms) into matching, and any entity named in the quote scored straight past the threshold. The reply-quote block and any 📖 recall-announcement echoes are now stripped before matching (`recallMatchText`); the verbatim prompt still goes to the model untouched.
+  - **Haiku relevance gate (`core/recall-filter.js`).** When keywords produce candidates, a cheap model judges which the message is genuinely about — "zoom" no longer drags in the video-gen pack via word collision. Fail-open: error/timeout/garbage keeps the keyword baseline. Costs one haiku call (~3-6s) only on turns that matched something; `RECALL_FILTER=off` to disable, `RECALL_FILTER_MODEL`/`RECALL_FILTER_TIMEOUT_MS` to tune.
+  - Quoting a 📖 announcement no longer re-injects every entity it names (the self-reinforcing feedback loop).
+
+## v2.6.3
+- Inject local time + off-hours awareness into the runtime state block, so suggestions respect working hours.
+
+## v2.6.2
+- Announce freshly recalled packs/entities in chat (📖 line), mirroring the write-side notes.
+
 ## v2.6.1
 - **Fix: replying to a bot message now carries the quoted context.** Since v2.0.0 the router skipped reply context when the replied-to message came from the bot itself (assuming it was already in conversation context) — which silently dropped the link whenever that message was old or compacted away. Reply context is now always injected, labelled with provenance ("your earlier assistant message" vs "this message").
 

package/core/recall-filter.js

@@ -0,0 +1,75 @@
+// LLM relevance gate over keyword recall candidates. The FTS matchers in
+// packs.js/entities.js are high-recall but dumb — "zoom" pulls in the
+// video-gen pack, "kazee" pulls in every colleague. When keywords produce
+// candidates, a cheap model judges which are genuinely about the message.
+// Fail-open: any error, timeout, or unparseable reply keeps all candidates,
+// so recall never gets worse than the keyword baseline.
+
+const { spawnSubagent } = require("./subagent");
+
+const FILTER_MODEL = process.env.RECALL_FILTER_MODEL || "haiku";
+const FILTER_TIMEOUT_MS = Number(process.env.RECALL_FILTER_TIMEOUT_MS || 20000);
+const MESSAGE_CLIP_CHARS = 1500;
+
+function enabled() {
+  return (process.env.RECALL_FILTER || "on").toLowerCase() !== "off";
+}
+
+const FILTER_SYSTEM_PROMPT = [
+  "You are a relevance judge for an assistant's memory recall.",
+  "Reply with ONLY a JSON array of candidate ids — no prose, no markdown fences.",
+].join("\n");
+
+// candidates: [{ id, name, description }]. opts.context: surrounding
+// conversation text (e.g. the message the user replied to) used to
+// disambiguate pronouns like "the app" — context only, not a topic
+// source in its own right. Returns a Set of kept ids, or null to
+// signal fail-open (caller decides what that keeps).
+async function judgeRelevance(message, candidates, opts = {}) {
+  if (!enabled() || candidates.length === 0) return null;
+  const msg = String(message || "").slice(0, MESSAGE_CLIP_CHARS);
+  const context = String(opts.context || "").slice(0, MESSAGE_CLIP_CHARS);
+  const lines = candidates.map((c) => `- ${c.id}: ${c.name}${c.description ? ` — ${c.description}` : ""}`);
+  const prompt = [
+    "A user sent this message to their assistant:",
+    "<<<",
+    msg,
+    ">>>",
+    ...(context
+      ? [
+          "",
+          "It was a reply to this earlier message (context for resolving references like \"the app\" or \"it\" — judge relevance against what the user's message is about in light of it):",
+          "<<<",
+          context,
+          ">>>",
+        ]
+      : []),
+    "",
+    "These stored memory notes were keyword-matched as possibly relevant.",
+    "Keep only the ones the message is GENUINELY about — the topic, project, or person itself.",
+    "Sharing an incidental word with the note (e.g. \"zoom\" matching a video tool, a person's employer matching a project name) is NOT relevance.",
+    "If the conversation context shows the user means a different project than a candidate (e.g. they are discussing app A, and a candidate is the unrelated app B that merely shares words like \"mobile\" or \"gradient\"), drop that candidate.",
+    "",
+    "Candidates:",
+    ...lines,
+    "",
+    `Reply with ONLY a JSON array of the relevant ids, e.g. ["${candidates[0].id}"]. Use [] if none are relevant.`,
+  ].join("\n");
+  try {
+    const { text } = await spawnSubagent(prompt, {
+      model: FILTER_MODEL,
+      systemPrompt: FILTER_SYSTEM_PROMPT,
+      timeoutMs: FILTER_TIMEOUT_MS,
+    });
+    const match = String(text || "").match(/\[[\s\S]*?\]/);
+    if (!match) return null;
+    const ids = JSON.parse(match[0]);
+    if (!Array.isArray(ids)) return null;
+    const known = new Set(candidates.map((c) => c.id));
+    return new Set(ids.filter((id) => typeof id === "string" && known.has(id)));
+  } catch (e) {
+    return null;
+  }
+}
+
+module.exports = { judgeRelevance };

package/core/runner.js

@@ -112,7 +112,7 @@ function shouldAutoCompact(state = currentState(), opts = {}) {
   return true;
 }
 
-function buildClaudeArgs(prompt, opts = {}) {
+async function buildClaudeArgs(prompt, opts = {}) {
   const state = currentState();
   const { settings } = state;
   if (settings.backend === "cursor") return buildCursorArgs(prompt, opts);
@@ -139,7 +139,7 @@ function buildClaudeArgs(prompt, opts = {}) {
   if (settings.worktree) args.push("--worktree");
   // 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));
+  args.push(await promptWithDynamicContext(prompt));
   return args;
 }
 
@@ -439,6 +439,7 @@ async function runClaudeCapture(prompt, cwd, opts = {}) {
   const authPreflight = preflightClaudeAuthMessage();
   if (authPreflight) throw new Error(authPreflight);
 
+  const args = await buildClaudeArgs(prompt, { ...opts, skipAutoCompact: true });
   return new Promise((resolve, reject) => {
     let assistantText = "";
     let stderrBuffer = "";
@@ -451,7 +452,6 @@ async function runClaudeCapture(prompt, cwd, opts = {}) {
       continueSession: !!opts.continueSession,
       resumeSessionId: opts.resumeSessionId || null,
     }, state, getActiveSessionId);
-    const args = buildClaudeArgs(prompt, { ...opts, skipAutoCompact: true });
     const proc = spawn(getActiveBinary(), args, {
       cwd,
       env: subprocessEnv(),
@@ -646,7 +646,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     } catch (e) { /* announcements are best-effort */ }
   };
 
-  const args = buildClaudeArgs(prompt, opts);
+  const args = await buildClaudeArgs(prompt, opts);
   // Recall announcements: mirror the write-side "🧠 jotted down" notes with
   // a read-side line whenever packs/entities freshly enter context this turn.
   try {
@@ -966,10 +966,11 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
 }
 
 async function runClaudeSilent(prompt, cwd, label) {
+  const dynamicPrompt = await promptWithDynamicContext(prompt);
   return new Promise((resolve) => {
     const args = ["-p", "--output-format", "text", "--verbose",
       "--append-system-prompt", buildSystemPrompt(),
-      "--dangerously-skip-permissions", promptWithDynamicContext(prompt)];
+      "--dangerously-skip-permissions", dynamicPrompt];
     const proc = spawn(CLAUDE_PATH, args, {
       cwd, env: claudeSubprocessEnv(),
       stdio: ["ignore", "pipe", "pipe"],

package/core/system-prompt.js

@@ -316,10 +316,9 @@ function formatPackForContext(pack, packsLib) {
   return clip(parts.join("\n\n"), PACK_INJECT_MAX_CHARS);
 }
 
-function buildPackBlock(prompt) {
+function buildPackBlock(matches) {
   try {
     const packsLib = require("./packs");
-    const matches = packsLib.matchPacks(prompt, { limit: 3 });
     if (matches.length === 0) return "";
     const state = currentState();
     const adapter = currentAdapter();
@@ -363,10 +362,9 @@ function formatEntityForContext(ent) {
   return clip(parts.join("\n\n"), ENTITY_INJECT_MAX_CHARS);
 }
 
-function buildEntityBlock(prompt) {
+function buildEntityBlock(matches) {
   try {
     const entitiesLib = require("./entities");
-    const matches = entitiesLib.matchEntities(prompt, { limit: 4 });
     if (matches.length === 0) return "";
     const state = currentState();
     const adapter = currentAdapter();
@@ -393,10 +391,98 @@ function buildEntityBlock(prompt) {
   }
 }
 
-function promptWithDynamicContext(prompt) {
+// The composed prompt can carry text the user didn't write this turn:
+// router.js wraps Telegram reply-quotes in "Replying to …:\n---\n…\n---",
+// and quoting a 📖 recall announcement echoes every entity named in it.
+// Matching recall over that text re-injects whatever was quoted (names
+// score 2 — instant threshold). So we split: the user's own words drive
+// recall as before, and the quoted text is kept separately as context.
+// Context-derived candidates only survive if the LLM relevance judge
+// confirms them — without a working judge they are dropped, so a quote
+// can never force-inject on keywords alone.
+function stripRecallAnnouncements(text) {
+  return String(text || "").split("\n").filter((l) => !l.includes("📖")).join("\n").trim();
+}
+
+function recallMatchParts(prompt) {
+  const text = String(prompt || "");
+  const m = text.match(/^Replying to [^\n]*:\n---\n([\s\S]*?)\n---\n+/);
+  return {
+    userText: stripRecallAnnouncements(m ? text.slice(m[0].length) : text),
+    contextText: stripRecallAnnouncements(m ? m[1] : ""),
+  };
+}
+
+// packMatches/entityMatches carry an `origin` of "user" or "context".
+// Fail-open keeps user-text candidates (the keyword baseline) but drops
+// context-only ones — those are only trustworthy with a working judge.
+async function filterMatches(userText, contextText, packMatches, entityMatches) {
+  const failOpen = () => ({
+    packMatches: packMatches.filter((m) => m.origin === "user"),
+    entityMatches: entityMatches.filter((m) => m.origin === "user"),
+  });
+  if (packMatches.length === 0 && entityMatches.length === 0) {
+    return { packMatches, entityMatches };
+  }
+  try {
+    const packsLib = require("./packs");
+    const entitiesLib = require("./entities");
+    const candidates = [];
+    for (const m of packMatches) {
+      const p = packsLib.readPack(m.dir);
+      candidates.push({ id: `pack:${m.dir}`, name: m.name, description: p?.description || "" });
+    }
+    for (const m of entityMatches) {
+      const e = entitiesLib.readEntity(m.slug);
+      candidates.push({ id: `entity:${m.slug}`, name: m.name, description: e?.description || "" });
+    }
+    const kept = await require("./recall-filter").judgeRelevance(userText, candidates, { context: contextText });
+    if (!kept) return failOpen();
+    return {
+      packMatches: packMatches.filter((m) => kept.has(`pack:${m.dir}`)),
+      entityMatches: entityMatches.filter((m) => kept.has(`entity:${m.slug}`)),
+    };
+  } catch (e) {
+    return failOpen();
+  }
+}
+
+function mergeMatches(primary, secondary, keyOf) {
+  const out = primary.map((m) => ({ ...m, origin: "user" }));
+  const seen = new Set(primary.map(keyOf));
+  for (const m of secondary) {
+    if (seen.has(keyOf(m))) continue;
+    out.push({ ...m, origin: "context" });
+  }
+  return out;
+}
+
+async function promptWithDynamicContext(prompt) {
   lastInjected = { packs: [], entities: [] };
   try {
-    return `${buildDynamicContextBlock()}${buildPackBlock(prompt)}${buildEntityBlock(prompt)}\n\nCurrent user request:\n${prompt}`;
+    const { userText, contextText } = recallMatchParts(prompt);
+    const packsLib = require("./packs");
+    const entitiesLib = require("./entities");
+    let packMatches = [];
+    let entityMatches = [];
+    try {
+      packMatches = mergeMatches(
+        packsLib.matchPacks(userText, { limit: 3 }),
+        contextText ? packsLib.matchPacks(contextText, { limit: 3 }) : [],
+        (m) => m.dir,
+      );
+    } catch (e) {}
+    try {
+      entityMatches = mergeMatches(
+        entitiesLib.matchEntities(userText, { limit: 4 }),
+        contextText ? entitiesLib.matchEntities(contextText, { limit: 4 }) : [],
+        (m) => m.slug,
+      );
+    } catch (e) {}
+    ({ packMatches, entityMatches } = await filterMatches(userText, contextText, packMatches, entityMatches));
+    packMatches = packMatches.slice(0, 3);
+    entityMatches = entityMatches.slice(0, 4);
+    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.3",
+  "version": "2.6.5",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {