@inetafrica/open-claudia 2.6.25 → 2.6.27

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

@@ -17,6 +17,7 @@ const CONFIG_DIR = require("../config-dir");
 const { config } = require("./config");
 const packs = require("./packs");
 const entities = require("./entities");
+const packGuard = require("./pack-guard");
 const persona = require("./persona");
 const { spawnSubagent } = require("./subagent");
 
@@ -180,6 +181,12 @@ function applyDream(decision, backupRoot) {
       const into = m?.into && packs.readPack(m.into);
       const from = [].concat(m?.from || []).filter((d) => d && d !== m.into && !gone.has(d) && packs.readPack(d));
       if (!into || from.length === 0) continue;
+      const mGuard = packGuard.scanSections({ stance: m.stance, procedure: m.procedure, state: m.state, journal: m.journal });
+      if (mGuard.flagged) {
+        console.warn(`[dream] guard blocked merge into ${m.into} (${mGuard.kind} in ${mGuard.section})`);
+        lines.push(`🛡️ Skipped merge into ${m.into} — content looked like an injected instruction (${mGuard.kind})`);
+        continue;
+      }
       const mr = packs.updatePack(m.into, {
         stance: typeof m.stance === "string" ? m.stance : "",
         procedure: typeof m.procedure === "string" ? m.procedure : "",
@@ -202,6 +209,12 @@ function applyDream(decision, backupRoot) {
       if (!dir || gone.has(dir)) continue;
       const children = [].concat(u?.children || []).filter((d) => d && d !== dir && !gone.has(d) && packs.readPack(d));
       if (children.length < 2) continue;
+      const uGuard = packGuard.scanSections({ description: u.description, state: u.state });
+      if (uGuard.flagged) {
+        console.warn(`[dream] guard blocked umbrella ${dir} (${uGuard.kind} in ${uGuard.section})`);
+        lines.push(`🛡️ Skipped umbrella ${dir} — content looked like an injected instruction (${uGuard.kind})`);
+        continue;
+      }
       if (!packs.readPack(dir)) {
         packs.createPack({
           dir,
@@ -242,6 +255,11 @@ function applyDream(decision, backupRoot) {
       const desc = typeof r.description === "string" ? r.description.trim() : "";
       const tags = Array.isArray(r.tags) ? r.tags.map((t) => String(t).trim()).filter(Boolean).slice(0, 6) : [];
       if (!desc && tags.length === 0) continue;
+      const rGuard = packGuard.scanForInjection(desc, { strict: true });
+      if (rGuard.flagged) {
+        console.warn(`[dream] guard blocked retag of ${r.pack} (${rGuard.kind})`);
+        continue;
+      }
       packs.updatePack(r.pack, { description: desc, tags }, "dream");
       lines.push(`🏷️ Sharpened ${r.pack}'s description/tags`);
     } catch (e) { console.warn(`[dream] retag failed: ${e.message}`); }
@@ -314,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" };
@@ -335,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/pack-guard.js

@@ -0,0 +1,82 @@
+// Content threat-scan for memory writes (spec #4).
+//
+// Threat model: prompt-injection rides in via tool output or a pasted doc,
+// gets echoed in the assistant reply, and the background reviewer (or dream)
+// faithfully writes "ignore previous instructions / always run X / exfiltrate
+// to URL" into a pack section — which then auto-injects every session as if it
+// were the user's own rule. Stance/Procedure/State auto-inject, so they are the
+// dangerous sections; Journal is shown on demand, so it is scanned leniently
+// (exfil only). We never import marketplace packs, so this is the whole surface.
+//
+// This is a heuristic gate, not a classifier. It is deliberately conservative:
+// it only fires on phrasings that have no legitimate reason to appear in a
+// memory section a model wrote about a past turn. On a hit we SKIP the write —
+// a missed memory is cheap, a poisoned auto-injected rule is not.
+
+// Imperative override / instruction-hijack phrasing.
+const OVERRIDE_PATTERNS = [
+  /\bignore\s+(all\s+)?(previous|prior|earlier|above|the\s+following)\s+(instructions?|prompts?|rules?|context)/i,
+  /\bdisregard\s+(all\s+)?(previous|prior|earlier|above|your)\s+(instructions?|prompts?|rules?|training)/i,
+  /\bforget\s+(everything|all|your\s+(instructions?|rules?|prompt))/i,
+  /\boverride\s+(your|the|all)\s+(instructions?|rules?|system\s+prompt|guardrails?)/i,
+  /\b(you\s+(must|should|will)\s+always|always\s+remember\s+to)\b.*\b(run|execute|send|post|upload|reveal|disclose|delete|drop)\b/i,
+  /\bfrom\s+now\s+on\b.*\b(ignore|disregard|always|never)\b/i,
+  /\bdo\s+not\s+(tell|inform|ask|notify)\s+(the\s+)?(user|owner|sumeet)\b/i,
+  /\bsystem\s+prompt\b.*\b(ignore|reveal|print|output|leak)\b/i,
+  /\b(reveal|print|output|leak|disclose)\b.*\b(system\s+prompt|api\s+key|token|password|secret|credential)/i,
+];
+
+// Exfiltration: a send/post/upload verb pointed at a URL or address. Scanned in
+// every section, including Journal.
+const EXFIL_PATTERNS = [
+  /\b(send|post|upload|exfiltrate|forward|transmit|leak|email|curl|wget|fetch)\b[^.\n]{0,60}\b(to|at|into)\b[^.\n]{0,40}(https?:\/\/|ftp:\/\/|[\w.-]+@[\w.-]+)/i,
+  /\b(https?:\/\/)[^\s)]+[^\s)]*\b.*\b(api\s*key|token|password|secret|credential|env)/i,
+  /\bcurl\b[^\n]*\b(https?:\/\/)/i,
+];
+
+// A long unbroken base64 blob — no reason for one to live in a prose memory
+// section; classic carrier for an obfuscated payload.
+const BASE64_BLOB = /[A-Za-z0-9+/]{120,}={0,2}/;
+
+function matchAny(patterns, text) {
+  for (const re of patterns) {
+    const m = re.exec(text);
+    if (m) return m[0].slice(0, 80);
+  }
+  return null;
+}
+
+// Scan a single piece of text. `strict` = true for auto-injected sections
+// (Stance/Procedure/State), false for Journal (exfil-only).
+function scanForInjection(text, { strict = true } = {}) {
+  const s = String(text || "");
+  if (!s.trim()) return { flagged: false };
+
+  const exfil = matchAny(EXFIL_PATTERNS, s);
+  if (exfil) return { flagged: true, kind: "exfil", evidence: exfil };
+
+  if (!strict) return { flagged: false };
+
+  const override = matchAny(OVERRIDE_PATTERNS, s);
+  if (override) return { flagged: true, kind: "override", evidence: override };
+
+  const b64 = BASE64_BLOB.exec(s);
+  if (b64) return { flagged: true, kind: "base64", evidence: b64[0].slice(0, 40) + "…" };
+
+  return { flagged: false };
+}
+
+// Scan the sections of a pending pack write. Strict on the auto-injected
+// sections, lenient on Journal. Returns the first hit, or { flagged: false }.
+function scanSections(sections = {}) {
+  const strictKeys = ["stance", "procedure", "state", "description"];
+  for (const key of strictKeys) {
+    const r = scanForInjection(sections[key], { strict: true });
+    if (r.flagged) return { ...r, section: key };
+  }
+  const r = scanForInjection(sections.journal, { strict: false });
+  if (r.flagged) return { ...r, section: "journal" };
+  return { flagged: false };
+}
+
+module.exports = { scanForInjection, scanSections };

package/core/pack-review.js

@@ -9,6 +9,7 @@
 const { spawnSubagent } = require("./subagent");
 const packs = require("./packs");
 const entities = require("./entities");
+const packGuard = require("./pack-guard");
 const { redactSensitive } = require("./redact");
 
 const MIN_TURN_CHARS = 400;
@@ -124,8 +125,26 @@ function parseDecision(text) {
   }
 }
 
+function guardCheck(a) {
+  const hit = packGuard.scanSections({
+    stance: a.stance,
+    procedure: a.procedure,
+    state: a.state,
+    description: a.description,
+    journal: a.journal,
+  });
+  if (hit.flagged) {
+    console.warn(`[pack-review] guard blocked write to ${a.pack || a.dir || a.name} (${hit.kind} in ${hit.section}): ${hit.evidence}`);
+  }
+  return hit;
+}
+
 function applyAction(a) {
   if (!a || typeof a !== "object") return null;
+  const guard = guardCheck(a);
+  if (guard.flagged) {
+    return { kind: "skipped", dir: a.pack || a.dir || "", name: a.name || a.pack || a.dir || "", reason: `${guard.kind} in ${guard.section}` };
+  }
   if (a.action === "update" && a.pack) {
     const existing = packs.readPack(a.pack);
     if (!existing) return null;
@@ -192,7 +211,9 @@ function reviewTurn({ userText, assistantText, channelId, announce }) {
     for (const a of decision.actions) {
       try {
         const r = applyAction(a);
-        if (r) {
+        if (r && r.kind === "skipped") {
+          lines.push(`🛡️ Skipped a memory write that looked like an injected instruction (${r.reason}).`);
+        } else if (r) {
           lines.push(r.kind === "create"
             ? `📦 New pack: ${r.name}\n${clipWords(r.note, 180)}\n↳ open-claudia pack show ${r.dir}`
             : `✏️ ${r.name} — ${clipWords(r.note, 180)}`);

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.`);
@@ -535,15 +535,42 @@ function mergeMatches(primary, secondary, keyOf) {
 function logRecall(msg, candPacks, candEntities, keptPacks, keptEntities) {
   if (String(process.env.RECALL_DEBUG || "on").toLowerCase() === "off") return;
   try {
+    // FTS-miss instrumentation (spec #6): packs the relevance judge KEPT even
+    // though keyword FTS scored them ~0 (or they only surfaced via context, not
+    // the user's words) are pure-semantic rescues. If this count climbs, a
+    // vector backend earns its keep; until then it stays 1-line instrumentation.
+    const scoreOf = new Map(candPacks.map((m) => [m.dir, m]));
+    const ftsMissRescues = keptPacks
+      .map((m) => scoreOf.get(m.dir))
+      .filter((c) => c && (!c.score || c.origin === "context"))
+      .map((c) => c.dir);
     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),
+      ftsMissRescues,
       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");
+    bumpFtsMissCounter(ftsMissRescues.length);
+  } catch (e) {}
+}
+
+// Cumulative tally so we don't have to re-scan the whole JSONL to answer
+// "is keyword recall missing semantic matches often enough to warrant vectors?"
+// Counts every recall turn plus how many of them rescued an FTS-missed pack.
+function bumpFtsMissCounter(n) {
+  try {
+    const p = path.join(CONFIG_DIR, "recall-stats.json");
+    let stats = {};
+    try { stats = JSON.parse(fs.readFileSync(p, "utf8")) || {}; } catch (e) {}
+    stats.turns = (stats.turns || 0) + 1;
+    if (n > 0) stats.turnsWithRescue = (stats.turnsWithRescue || 0) + 1;
+    stats.ftsMissRescues = (stats.ftsMissRescues || 0) + n;
+    stats.updatedAt = new Date().toISOString();
+    fs.writeFileSync(p, JSON.stringify(stats, null, 2));
   } catch (e) {}
 }
 

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.25",
+  "version": "2.6.27",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {