@inetafrica/open-claudia 2.6.38 → 2.6.39

package/core/handlers.js

@@ -966,8 +966,16 @@ register({
       setTimeout(() => killProcessTree(pid, "SIGKILL"), 3000);
       state.runningProcess = null;
       if (state.streamInterval) clearTimeout(state.streamInterval);
+      if (state.typingHeartbeat) { clearInterval(state.typingHeartbeat); state.typingHeartbeat = null; }
       state.messageQueue = [];
       await send("Cancelled.");
+    } else if (state.preparingRun) {
+      // Turn is mid-recall/compaction — no process to kill yet. Flag it so
+      // runClaude bails at its pre-spawn checkpoint, and stop typing now.
+      state.cancelRequested = true;
+      state.messageQueue = [];
+      if (state.typingHeartbeat) { clearInterval(state.typingHeartbeat); state.typingHeartbeat = null; }
+      await send("Cancelled.");
     } else await send("Nothing running.");
   },
 });

package/core/pack-review.js

@@ -14,8 +14,11 @@ const packGuard = require("./pack-guard");
 const { redactSensitive } = require("./redact");
 
 const MIN_TURN_CHARS = 400;
-const MAX_TEXT_CHARS = 7000;
-const REVIEW_MODEL = process.env.PACK_REVIEW_MODEL || "haiku";
+const MAX_TEXT_CHARS = 16000;
+// Create/merge decisions need real judgement (the cheap model over-created
+// per-version/per-facet packs), so default to the latest Sonnet. Override with
+// PACK_REVIEW_MODEL if cost/latency of running it on every substantial turn matters.
+const REVIEW_MODEL = process.env.PACK_REVIEW_MODEL || "claude-sonnet-4-6";
 const MAX_ACTIONS = 2;
 const MAX_ENTITY_ACTIONS = 3;
 // Lessons are precious always-on budget — at most one promotion per turn,
@@ -111,7 +114,7 @@ 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.
+- CREATE a pack ONLY when the turn worked on a durable topic that NO existing pack covers. Before creating, scan the existing packs above for one already about this project/system/domain — if one exists, UPDATE it instead. A new pack must be a genuinely DISTINCT topic, never a narrower facet, version, release, sub-feature, phase, or component of a topic an existing pack already owns. In particular: a release or version of a project (e.g. a pack named after "<project> v2.6.39") is a Journal line + State update on that project's EXISTING pack — NEVER its own pack. Likewise sub-features of one system belong in that system's pack, not in siblings. When unsure whether something is a new topic or a facet of an existing one, treat it as a facet and UPDATE. Do not create packs for one-off trivia.
 - ABILITY vs CONTEXT: most creates are context packs (a project/system tracker). Create an ability (kind:"ability") only for a genuinely reusable how-to as defined above, and always set learned_on + applied_on to the originating project dir. When a turn re-used an EXISTING ability on a NEW project, do NOT create anything — UPDATE that ability and put the new project dir in "applied_on" so the cross-project reuse is recorded.
 - 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.
@@ -164,6 +167,35 @@ function guardCheck(a) {
   return hit;
 }
 
+// Deterministic dedupe backstop for the create path. Even with the prompt rule,
+// a cheap model tends to spawn a fresh pack for each version/release/facet of a
+// project an existing pack already owns. This catches two robust signals — a
+// slug that is a hyphen-boundary prefix/extension of an existing pack dir, and a
+// version-named proposal whose name/description strongly matches an existing
+// pack — and the caller folds the proposal into that pack instead. Conservative
+// by design (only context packs; only a clear prefix relationship or a versioned
+// proposal with a strong text match) so genuinely distinct topics still get their
+// own pack. Mirrors the structural "no lesson without a trigger" enforcement.
+function findDuplicatePack({ dir, name, description, tags }) {
+  const slug = packs.slugify(dir || name || "");
+  if (!slug) return null;
+  const contextDirs = packs.listPacks().filter((p) => p.kind !== "ability").map((p) => p.dir);
+  for (const d of contextDirs) {
+    if (d === slug) continue;
+    if (slug.startsWith(d + "-") || d.startsWith(slug + "-")) return d;
+  }
+  const tagStr = Array.isArray(tags) ? tags.join(" ") : "";
+  const versioned = /\bv?\d+\.\d+(?:\.\d+)?\b|\brelease\b|\bv\d+\b/i.test(`${slug} ${name || ""} ${description || ""} ${tagStr}`);
+  if (versioned) {
+    const ctx = new Set(contextDirs);
+    const text = `${name || ""} ${description || ""} ${tagStr}`.trim();
+    for (const m of packs.matchPacks(text, { limit: 3, threshold: 4 })) {
+      if (m.dir !== slug && ctx.has(m.dir)) return m.dir;
+    }
+  }
+  return null;
+}
+
 function applyAction(a) {
   if (!a || typeof a !== "object") return null;
   const guard = guardCheck(a);
@@ -202,6 +234,15 @@ function applyAction(a) {
       if (kind === "ability") for (const proj of projects) packs.recordApplied(dir, proj);
       return { kind: "update", dir, name: a.name || dir, note: a.journal || "state updated" };
     }
+    // Deterministic dedupe: a versioned/facet proposal folds INTO the project
+    // pack it belongs to rather than spawning a sibling (abilities are exempt —
+    // they are activity-named and cross-project by design).
+    const dupeDir = kind === "context" ? findDuplicatePack({ dir, name: a.name, description: a.description, tags: a.tags }) : null;
+    if (dupeDir && packs.readPack(dupeDir)) {
+      packs.updatePack(dupeDir, { journal: a.journal || "", state: a.state || "" }, "reviewer");
+      const ex = packs.readPack(dupeDir);
+      return { kind: "update", dir: dupeDir, name: (ex && ex.name) || dupeDir, note: a.journal || "folded a new-pack proposal into the existing pack" };
+    }
     const pack = packs.createPack({
       dir,
       name: a.name,

package/core/runner.js

@@ -794,7 +794,21 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     resumeSessionId: opts.resumeSessionId || null,
   }, state, getActiveSessionId);
 
-  if (adapter && channelId) adapter.typing(channelId).catch(() => {});
+  // Typing heartbeat: keep the indicator alive continuously from message
+  // receipt through the recall/discoverer phase and into streaming, not just
+  // for the ~5s a single typing action lasts. Stored on state so /stop can
+  // clear it instantly. Cleared on close/error/cancel.
+  const startTyping = () => {
+    if (!adapter || !channelId) return;
+    adapter.typing(channelId).catch(() => {});
+    if (!state.typingHeartbeat) state.typingHeartbeat = setInterval(() => adapter.typing(channelId).catch(() => {}), 4000);
+  };
+  const stopTyping = () => { if (state.typingHeartbeat) { clearInterval(state.typingHeartbeat); state.typingHeartbeat = null; } };
+  // Pre-spawn window (recall/compaction/auth): /stop has no process to kill, so
+  // it sets state.cancelRequested and we bail at the checkpoint before spawning.
+  state.preparingRun = true;
+  state.cancelRequested = false;
+  startTyping();
   state.statusMessageId = null;
   state.streamBuffer = "";
   let assistantText = "";
@@ -883,7 +897,14 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     } catch (e) { /* announcements are best-effort */ }
   };
 
-  const args = await buildClaudeArgs(prompt, opts);
+  let args;
+  try {
+    args = await buildClaudeArgs(prompt, opts);
+  } catch (e) {
+    state.preparingRun = false;
+    stopTyping();
+    throw e;
+  }
   // Recall announcements are now fired at READ time, not injection time:
   // matched packs/entities enter context only as small headlines (see
   // system-prompt.js recallHeadline). The "📖 Recalled my notes on …" line is
@@ -902,6 +923,14 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
       else if (r.gated) send(`🧠 <b>Recall</b> (${esc(r.engine)}): skipped by pre-gate — trivial turn.`).catch(() => {});
     }
   } catch (e) { /* best-effort */ }
+  // /stop landed during the pre-spawn window (recall/compaction): bail before
+  // spawning. The /stop handler already acknowledged in chat, so stay silent.
+  if (state.cancelRequested) {
+    state.cancelRequested = false;
+    state.preparingRun = false;
+    stopTyping();
+    return;
+  }
   const binaryPath = getActiveBinary();
   const proc = spawn(binaryPath, args, {
     cwd,
@@ -911,6 +940,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   });
 
   state.runningProcess = proc;
+  state.preparingRun = false;
   const startTime = Date.now();
   let longRunningNotified = false;
 
@@ -1094,6 +1124,8 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
 
   proc.on("close", (code) => chatContext.run(store, async () => {
     state.runningProcess = null;
+    state.preparingRun = false;
+    stopTyping();
     clearTimeout(state.streamInterval); state.streamInterval = null;
     clearTimeout(processTimeout);
 
@@ -1240,6 +1272,8 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
 
   proc.on("error", (err) => chatContext.run(store, async () => {
     state.runningProcess = null;
+    state.preparingRun = false;
+    stopTyping();
     clearTimeout(state.streamInterval);
     clearTimeout(processTimeout);
     await send(`Error: ${err.message}`);

package/core/state.js

@@ -59,6 +59,9 @@ function createUserState(userId) {
     channelId: currentChannelId(),
     currentSession: saved.currentSession || null,
     runningProcess: null,
+    preparingRun: false,
+    cancelRequested: false,
+    typingHeartbeat: null,
     statusMessageId: null,
     streamBuffer: "",
     streamInterval: null,

package/package.json

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