@inetafrica/open-claudia 2.6.28 → 2.6.30

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## v2.6.30
+- **Cluster self-management for AgentSpace pods.** When running as an AgentSpace pod, the bot can inspect and manage its own deployment through the backend broker — `/cluster status|logs [n]|restart|start|stop|scale <0|1>|sync` (owner-gated) for humans, and `open-claudia cluster …` for the agent. Both are thin clients over `core/cluster-client.js`, which posts to the broker's capability-gated `/pods/self/cluster` endpoint with the pod's bearer token; the bot holds no Kubernetes credentials. `brokerConfigured()` requires both `AGENTSPACE_API_URL` and `AGENTSPACE_POD_TOKEN`, so an unconfigured local install safely replies "not available" while a provisioned pod reaches the broker. Also tightens the `core/pack-guard.js` exfil heuristic: the broad "URL co-occurring with a sensitive word" rule (which false-positived on legitimate infra notes) is replaced by two precise carriers — a send/store/upload verb pointed at a URL/address, and a credential attached directly to a URL as a query/fragment param.
+
+## v2.6.29
+- **Kazee channel hardening.** `send()` now retries up to 3× with 1s/2s backoff (skipping 4xx), `edit()` normalizes text the same way as `send()`, inbound handling is async and detects ogg/opus voice notes (promoting them from "audio" to "voice" so the router dispatches correctly), reply-to context best-effort fetches the replied-to message before emitting the envelope, and `format.js` converts stray Telegram HTML tags (`<b>`, `<code>`, `<pre>`, `<i>`, `<s>`, `<a>`) to Markdown as a safety net.
+
+## v2.6.28
+- **Usage: report true peak context, not the inflated per-turn sum.** The result event re-counted the cached prefix once per tool round-trip, so `contextTokens` ballooned into the millions and the "Context this turn" alert fired every turn. It now tracks the peak single-call prefix (input + cache_read + cache_creation) and reports that as `contextTokens`; the summed value is kept as `billedContextTokens` for cost attribution.
+
+## v2.6.27
+- **Tasks: recency-ranked injection, staleness footer, and dream hygiene.** Open-task injection now ranks by activity (max of root and child `updatedAt`) rather than status — the most-recently-worked render in full, colder ones render title-only with a `task get <id>` pointer (new accessor + loopback endpoint + CLI sub), and anything untouched >14d (`OPEN_CLAUDIA_TASK_STALE_DAYS`) collapses into a capped one-line stale footer. The dream pass gains a task-hygiene step that surfaces the stalest tasks in the morning report — flag-and-ask only; it never edits or deletes tasks.
+
+## v2.6.26
+- **Memory: threat-scan guard + FTS-miss instrumentation.** `core/pack-guard.js` scans reviewer/dream content before write (override/exfil/base64 heuristics; strict on the auto-injected Stance/Procedure/State/description, lenient on Journal) and is wired into the pack reviewer and dream merge/umbrella/retag — a hit skips the write and announces one line. `logRecall` now records FTS-miss rescues (packs the judge kept that FTS scored ~0) into `recall-stats.json`, so a vector backend becomes a data-driven decision.
+
+## v2.6.25
+- **Memory: provenance tracking for pack writes.** A per-pack `.provenance.json` sidecar records which origin (user / reviewer / dream) last authored each section; `updatePack`/`createPack` take an origin, and an automated writer never silently overwrites a user-authored Stance. An absent sidecar defaults to "user" (protect-by-default).
+
+## v2.6.24
+- **Memory: pack usage telemetry + lifecycle retirement.** Packs gain `usage_count` telemetry (bumped on each use alongside `last_used`), a dream archive action retires cold packs (idle ≥30d, used ≤3×) into `.archived` with safety guards, and `pack archive`/`restore`/`archived` CLI commands are added; `/skills` surfaces the archived count. Also adds a post-dream chat summary (`DREAM_SUMMARY`), toggled with the new `/dreamsummary on|off` command (default on); when off, the nightly consolidation runs silently.
+
+## v2.6.23
+- **Progressive pack disclosure on by default.** Injects Stance + State teasers with on-demand Procedure/Journal and widens the pack match limit to 6. Override with `PACK_PROGRESSIVE=off`.
+
+## v2.6.22
+- **Wire `/skills` and `/learn` into the context-pack store.** Both previously read from / wrote to the empty legacy `~/.claude/skills` dir; now `/skills` lists packs with show/remove, and `/learn` folds work into a matching pack's Procedure plus a dated Journal line.
+
+## v2.6.21
+- **CI: allow tests to run without bot env.** The test suite no longer requires bot environment variables to be present.
+
 ## v2.6.20
 - **AgentSpace pod durability.** `/upgrade` and password-change callbacks now preserve the `/api` base path expected by AgentSpace, CLI paths are resolved to concrete executables at startup, and runs repair a stale/missing session workspace before spawning Claude, Cursor, or Codex. This prevents misleading `spawn ... ENOENT` failures when the saved session cwd no longer exists.
 

package/README.md

@@ -47,6 +47,7 @@ Send text, voice notes, screenshots, and files from your phone. Your chosen AI a
 - **Token economy** — byte-stable system prompt for maximum Anthropic prompt-cache hits; dynamic state rides each message instead
 - **Web UI** — optional browser UI for setup and config (`open-claudia start --web`)
 - **Auto-updates** — checks npm every 5 minutes, upgrade with `/upgrade`
+- **Cluster self-management** — when running as an AgentSpace pod, the bot can inspect and manage its own deployment (`/cluster`, or `open-claudia cluster …` for the agent) through the broker, which authenticates, capability-checks, and audits every operation
 - **Requirements doctor** — `/doctor` checks CLI installs, auth, voice tools, and writable paths
 - **Cross-platform** — macOS, Linux, and Windows
 
@@ -187,6 +188,7 @@ When you select a project, the last conversation is automatically resumed. Tap "
 | `/learn [<hint>]` | Capture the last piece of work into the matching context pack |
 | `/skills [show\|remove <name>]` | List, show, or remove legacy learned skills |
 | `/soul` | View/edit assistant identity and personality |
+| `/dreamsummary [on\|off]` | Toggle the post-dream memory summary in chat |
 
 ### Automation
 
@@ -235,9 +237,23 @@ Tokens are redacted from chat output and logs.
 | `/version` | Show current running version |
 | `/upgrade` | Upgrade to latest version and restart (includes a post-upgrade doctor summary) |
 | `/restart` | Restart the bot |
+| `/dashboard` | Get a one-time login link to the web dashboard |
 | `/stop` | Cancel a running task |
 | `/help` | Show all commands |
 
+### Cluster control
+
+Available only when the bot runs as an AgentSpace-provisioned pod (the broker credentials `AGENTSPACE_API_URL` and `AGENTSPACE_POD_TOKEN` are present). Off this network the command replies that it isn't available and does nothing. Owner-gated; every operation is authenticated, capability-checked, and audited by the broker, and confined to the bot's own deployment.
+
+| Command | Description |
+|---------|-------------|
+| `/cluster status` | Deployment readiness/phase |
+| `/cluster logs [n]` | Tail the last n container log lines |
+| `/cluster restart` | Rollout restart (pulls latest image) |
+| `/cluster start` / `/cluster stop` | Scale to 1 / 0 replicas |
+| `/cluster scale <0\|1>` | Stop (0) or start (1) |
+| `/cluster sync` | Re-apply the deployment manifest |
+
 ## Memory & Long-Term Context
 
 Open Claudia layers three memory systems on top of the backend's native sessions:

package/bin/cli.js

@@ -274,6 +274,11 @@ switch (command) {
     break;
   }
 
+  case "cluster": {
+    require("./cluster").run(args.slice(1));
+    break;
+  }
+
   case "pack": {
     require("./pack").run(args.slice(1));
     break;
@@ -347,6 +352,9 @@ Background work (only inside an active bot-spawned task):
   open-claudia task add|list|start|done|remove     Per-channel todo (survives restarts)
   open-claudia agent "<prompt>" [--role X]         Spawn a throwaway sub-agent for research
 
+Cluster control (self-management of this bot's own deployment via the broker):
+  open-claudia cluster status|logs|restart|start|stop|scale <0|1>|sync
+
 Multi-user / cross-channel:
   open-claudia people list|show|add|note|link      Roster of known team members
   open-claudia intros list|approve|reject          Pending introductions from unknown chats

package/bin/cluster.js

@@ -0,0 +1,75 @@
+// open-claudia cluster <operation>
+//
+// Self-management of this bot's own Kubernetes deployment, mediated by the
+// AgentSpace broker. The bot has no direct cluster credentials — every command
+// here is a request the broker authenticates, capability-checks, audits, and
+// executes against the pod's own namespace.
+
+const { clusterRequest } = require("../core/cluster-client");
+
+const HELP = `
+Cluster control for this bot's own deployment (via the AgentSpace broker).
+
+  open-claudia cluster status            Show deployment readiness/phase
+  open-claudia cluster logs [n]          Tail the last n container log lines (default 100, max 1000)
+  open-claudia cluster restart           Rollout restart (pulls latest image)
+  open-claudia cluster start             Scale to 1 replica
+  open-claudia cluster stop              Scale to 0 replicas
+  open-claudia cluster scale <0|1>       Stop (0) or start (1)
+  open-claudia cluster sync              Re-apply the deployment manifest
+
+All operations are confined to this pod's own namespace and gated by the
+capabilities the broker has granted this bot.
+`;
+
+function ok(line) { if (line) console.log(line); process.exit(0); }
+function fail(line) { if (line) console.error(line); process.exit(1); }
+
+// Render a broker response into a human line + correct exit code.
+function report(res, successLine) {
+  if (res.status >= 200 && res.status < 300) {
+    ok(typeof successLine === "function" ? successLine(res.json || {}) : successLine);
+  }
+  const detail = res.json && res.json.error ? res.json.error : (res.body || "").slice(0, 400);
+  if (res.status === 0) fail(`Broker request failed: ${detail}`);
+  fail(`Broker ${res.status}: ${detail}`);
+}
+
+async function run(args) {
+  const op = (args[0] || "").toLowerCase();
+  const rest = args.slice(1);
+  if (!op || op === "help" || op === "--help") { console.log(HELP); process.exit(op ? 0 : 2); }
+
+  switch (op) {
+    case "status": {
+      const res = await clusterRequest("status");
+      return report(res, (j) =>
+        `Deployment: ${j.phase || "?"}${j.ready ? " (ready)" : ""}${j.message ? ` — ${j.message}` : ""}`);
+    }
+    case "logs": {
+      const tailLines = rest[0] ? parseInt(rest[0], 10) : undefined;
+      if (rest[0] && Number.isNaN(tailLines)) fail("Usage: cluster logs [n]  (n = number of lines)");
+      const res = await clusterRequest("logs", tailLines ? { tailLines } : {});
+      return report(res, (j) => (j.logs || "(no logs)"));
+    }
+    case "restart":
+      return report(await clusterRequest("restart"), (j) => j.message || "Restart requested.");
+    case "start":
+      return report(await clusterRequest("start"), (j) => j.message || "Started.");
+    case "stop":
+      return report(await clusterRequest("stop"), (j) => j.message || "Stopped.");
+    case "scale": {
+      const n = rest[0];
+      if (n !== "0" && n !== "1") fail("Usage: cluster scale <0|1>");
+      return report(await clusterRequest("scale", { replicas: parseInt(n, 10) }), (j) => j.message || `Scaled to ${n}.`);
+    }
+    case "sync":
+      return report(await clusterRequest("sync"), (j) => j.message || "Reconciled.");
+    default:
+      console.error(`Unknown cluster operation: ${op}`);
+      console.log(HELP);
+      process.exit(2);
+  }
+}
+
+module.exports = { run, HELP };

package/channels/kazee/adapter.js

@@ -12,6 +12,7 @@ const { TEMP_DIR, FILES_DIR } = require("../../core/config");
 const { canonicalForChannel } = require("../../core/identity");
 const { inlineKeyboardToPortable } = require("../types");
 const { createKazeeSocket } = require("./socket");
+const { normalize } = require("./format");
 
 class KazeeAdapter {
   constructor({ id = "kazee", url, token, ownerUserId, botUserId }) {
@@ -98,7 +99,7 @@ class KazeeAdapter {
     });
   }
 
-  _handleInboundMessage(msg) {
+  async _handleInboundMessage(msg) {
     if (!msg) return;
     const senderId = String(msg.sender?._id || msg.sender?.id || msg.senderId || "");
     if (this.botUserId && senderId === String(this.botUserId)) return; // ignore our own echoes
@@ -169,6 +170,37 @@ class KazeeAdapter {
       }
     }
 
+    // Voice/audio distinction: chat-central has no "voice" type, so voice
+    // notes arrive as "audio". Detect them by mimeType (ogg/opus) and
+    // promote to "voice" so the router can transcribe them correctly.
+    if (envelope.type === "audio" && envelope.media?.length) {
+      const mime = (envelope.media[0].mimeType || "").toLowerCase();
+      if (mime.includes("ogg") || mime.includes("opus")) {
+        envelope.type = "voice";
+        envelope.media[0].type = "voice";
+      }
+    }
+
+    // Reply-to context: fetch the replied-to message content so the router
+    // has the same context Telegram provides. Best-effort — failure is silent.
+    if (msg.replyTo) {
+      try {
+        const data = await this._request("GET", `/message/${encodeURIComponent(String(msg.replyTo))}`);
+        const m = data?.message || data;
+        if (m && (m._id || m.id)) {
+          envelope.reply = {
+            text: m.content || "",
+            from: {
+              id: String(m.sender?._id || m.sender?.id || ""),
+              name: m.sender?.name || m.sender?.displayName || "",
+              username: m.sender?.username || "",
+            },
+            messageId: m._id || m.id,
+          };
+        }
+      } catch (e) { /* best-effort — envelope is still valid without reply context */ }
+    }
+
     this._emit("message", envelope);
   }
 
@@ -184,24 +216,42 @@ class KazeeAdapter {
     const body = {
       chat_id: channelId,
       sender: this.botUserId,
-      content: text,
+      content: normalize(text),
       type: buttons ? "interactive" : "text",
       findMeCode: `oc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
     };
     if (opts.replyTo) body.replyTo = opts.replyTo;
     if (buttons) body.interactive = { buttons };
-    try {
-      const res = await this._request("POST", `/chat/${encodeURIComponent(channelId)}/message`, body);
-      return res?.message?._id || res?.messageId || res?._id || null;
-    } catch (e) {
-      console.error("Kazee send error:", e.message);
-      return null;
+
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        const res = await this._request("POST", `/chat/${encodeURIComponent(channelId)}/message`, body);
+        return res?.message?._id || res?.messageId || res?._id || null;
+      } catch (e) {
+        const errMsg = e.message || "";
+        // Don't retry on client errors (4xx) — they won't self-heal.
+        const statusMatch = errMsg.match(/→ (\d{3})/);
+        const status = statusMatch ? parseInt(statusMatch[1], 10) : 0;
+        if (status >= 400 && status < 500) {
+          console.error("Kazee send error (not retrying):", errMsg);
+          return null;
+        }
+        if (attempt < 2) {
+          const delay = (attempt + 1) * 1000;
+          console.error(`Kazee send error (attempt ${attempt + 1}/3, retrying in ${delay}ms):`, errMsg);
+          await new Promise((r) => setTimeout(r, delay));
+          continue;
+        }
+        console.error("Kazee send error (exhausted retries):", errMsg);
+        return null;
+      }
     }
+    return null;
   }
 
   async edit(channelId, messageId, text, opts = {}) {
     const buttons = this._normalizeKeyboard(opts.keyboard);
-    const body = { content: text };
+    const body = { content: normalize(text) };
     if (buttons) {
       body.type = "interactive";
       body.interactive = { buttons };

package/channels/kazee/format.js

@@ -1,9 +1,27 @@
-// Kazee uses standard markdown end-to-end. Telegram-flavoured asterisks
-// and underscores still render fine, so this is mostly a hook for future
-// divergence (image embeds, code-block fences, etc.).
+// Kazee renders standard markdown end-to-end. This module normalizes text
+// before sending: converts any stray Telegram HTML tags (which the model may
+// accidentally emit) into their markdown equivalents so they render correctly
+// instead of appearing as raw tag noise.
+
+function htmlToMarkdown(text) {
+  return String(text || "")
+    .replace(/<pre><code[^>]*>([\s\S]*?)<\/code><\/pre>/gi, (_, code) => "```\n" + code + "\n```")
+    .replace(/<pre>([\s\S]*?)<\/pre>/gi, (_, code) => "```\n" + code + "\n```")
+    .replace(/<code>([\s\S]*?)<\/code>/gi, "`$1`")
+    .replace(/<b>([\s\S]*?)<\/b>/gi, "**$1**")
+    .replace(/<strong>([\s\S]*?)<\/strong>/gi, "**$1**")
+    .replace(/<i>([\s\S]*?)<\/i>/gi, "_$1_")
+    .replace(/<em>([\s\S]*?)<\/em>/gi, "_$1_")
+    .replace(/<s>([\s\S]*?)<\/s>/gi, "~~$1~~")
+    .replace(/<strike>([\s\S]*?)<\/strike>/gi, "~~$1~~")
+    .replace(/<del>([\s\S]*?)<\/del>/gi, "~~$1~~")
+    .replace(/<a href="([^"]+)">([\s\S]*?)<\/a>/gi, "[$2]($1)")
+    .replace(/<[^>]+>/g, "")
+    .replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#(\d+);/g, (_, n) => String.fromCodePoint(Number(n)));
+}
 
 function normalize(text) {
-  return String(text || "");
+  return htmlToMarkdown(String(text || ""));
 }
 
 module.exports = { normalize };

package/core/cluster-client.js

@@ -0,0 +1,79 @@
+// Thin client for the AgentSpace cluster-control broker.
+//
+// Both entry points use this single implementation:
+//   - bin/cluster.js  (the `open-claudia cluster ...` CLI, driven by the agent)
+//   - core/handlers.js (the `/cluster` Telegram slash command, driven by a human)
+//
+// The bot holds no Kubernetes credentials. It authenticates to the broker as
+// itself with the pod-self token; the broker enforces capabilities, policy and
+// audit and performs the actual cluster operation on the pod's own namespace.
+
+const CLUSTER_OPERATIONS = ["status", "logs", "restart", "start", "stop", "scale", "sync"];
+
+function brokerConfigured() {
+  return !!(process.env.AGENTSPACE_API_URL && process.env.AGENTSPACE_POD_TOKEN);
+}
+
+// Build the absolute URL to a pods/self/* endpoint, mirroring the path-base
+// logic used by the upgrade flow in core/handlers.js.
+function endpoint(pathSuffix) {
+  const apiUrl = process.env.AGENTSPACE_API_URL;
+  const base = new URL(apiUrl);
+  if (base.pathname === "/") base.pathname = "/api/";
+  if (!base.pathname.endsWith("/")) base.pathname += "/";
+  return new URL(pathSuffix, base);
+}
+
+// POST a cluster operation to the broker. Resolves to { status, body, json }.
+// Never rejects on HTTP/transport errors — surfaces them via status 0 so callers
+// can format a single error path.
+function clusterRequest(operation, params = {}) {
+  return new Promise((resolve) => {
+    if (!brokerConfigured()) {
+      resolve({
+        status: 0,
+        body: "AgentSpace broker not configured (AGENTSPACE_API_URL / AGENTSPACE_POD_TOKEN missing). This only works inside a pod provisioned by AgentSpace.",
+        json: null,
+      });
+      return;
+    }
+
+    let u;
+    try {
+      u = endpoint("pods/self/cluster");
+    } catch (e) {
+      resolve({ status: 0, body: `Bad AGENTSPACE_API_URL: ${e.message || e}`, json: null });
+      return;
+    }
+
+    const payload = JSON.stringify({ operation, ...params });
+    const lib = u.protocol === "https:" ? require("https") : require("http");
+    const req = lib.request(
+      {
+        method: "POST",
+        hostname: u.hostname,
+        port: u.port || (u.protocol === "https:" ? 443 : 80),
+        path: u.pathname + u.search,
+        headers: {
+          Authorization: `Bearer ${process.env.AGENTSPACE_POD_TOKEN}`,
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(payload),
+        },
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (c) => { data += c; });
+        res.on("end", () => {
+          let json = null;
+          try { json = JSON.parse(data); } catch (e) {}
+          resolve({ status: res.statusCode, body: data, json });
+        });
+      }
+    );
+    req.on("error", (e) => resolve({ status: 0, body: String(e.message || e), json: null }));
+    req.setTimeout(20000, () => { req.destroy(new Error("timeout")); });
+    req.end(payload);
+  });
+}
+
+module.exports = { clusterRequest, brokerConfigured, CLUSTER_OPERATIONS };

package/core/handlers.js

@@ -525,6 +525,52 @@ register({
   },
 });
 
+register({
+  name: "cluster", description: "Control this bot's own deployment (status/logs/restart/start/stop/scale/sync)",
+  args: "<status|logs|restart|start|stop|scale 0|1|sync>", ownerOnly: true,
+  handler: async (env, { tail }) => {
+    if (!ownerEnv(env)) return;
+    const { clusterRequest, brokerConfigured } = require("./cluster-client");
+    if (!brokerConfigured()) {
+      return send("Cluster control isn't available — this bot isn't running under AgentSpace (no broker credentials).");
+    }
+    const parts = (tail || "").trim().split(/\s+/).filter(Boolean);
+    const op = (parts[0] || "").toLowerCase();
+    const allowed = ["status", "logs", "restart", "start", "stop", "scale", "sync"];
+    if (!op || !allowed.includes(op)) {
+      return send("Usage: /cluster <status | logs [n] | restart | start | stop | scale 0|1 | sync>");
+    }
+    const params = {};
+    if (op === "logs" && parts[1]) {
+      const n = parseInt(parts[1], 10);
+      if (!Number.isNaN(n)) params.tailLines = n;
+    }
+    if (op === "scale") {
+      const n = parts[1];
+      if (n !== "0" && n !== "1") return send("Usage: /cluster scale <0|1>");
+      params.replicas = parseInt(n, 10);
+    }
+    try {
+      const res = await clusterRequest(op, params);
+      if (res.status >= 200 && res.status < 300) {
+        const j = res.json || {};
+        if (op === "status") {
+          return send(`Deployment: ${j.phase || "?"}${j.ready ? " (ready)" : ""}${j.message ? ` — ${j.message}` : ""}`);
+        }
+        if (op === "logs") {
+          const logs = j.logs || "(no logs)";
+          return send(logs.length > 3500 ? logs.slice(-3500) : logs);
+        }
+        return send(j.message || "Done.");
+      }
+      const detail = (res.json && res.json.error) ? res.json.error : (res.body || "").slice(0, 300);
+      return send(res.status === 0 ? `Cluster request failed: ${detail}` : `Cluster ${res.status}: ${detail}`);
+    } catch (e) {
+      return send(`Cluster error: ${e.message || e}`);
+    }
+  },
+});
+
 register({
   name: "projects", description: "Browse all workspace projects",
   handler: async (env) => { if (authorized(env)) send("Pick:", { keyboard: projectKeyboard() }); },

package/core/pack-guard.js

@@ -29,8 +29,15 @@ const OVERRIDE_PATTERNS = [
 // 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,
+  // A send/store/upload verb pointed at a URL or address.
+  /\b(send|post|upload|exfiltrate|forward|transmit|leak|email|curl|wget|fetch|store|save|drop|put|copy)\b[^.\n]{0,60}\b(to|at|into)\b[^.\n]{0,40}(https?:\/\/|ftp:\/\/|[\w.-]+@[\w.-]+)/i,
+  // A credential embedded directly in a URL as a query/fragment param
+  // (e.g. https://evil/?token=…): the classic verbless exfil carrier. Prose that
+  // merely mentions a URL near the word "token" no longer trips — the credential
+  // must actually be attached to the URL with =/:, which legitimate infra/ops
+  // notes don't do. This replaces a broad URL+keyword co-occurrence rule that
+  // false-positived on benign sentences like "the API at <url> uses a token".
+  /(https?:\/\/)[^\s)]*?\b(api_?key|access_?token|token|password|secret|credential)\b\s*[=:]/i,
   /\bcurl\b[^\n]*\b(https?:\/\/)/i,
 ];
 

package/package.json

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