@inetafrica/open-claudia 2.14.3 → 2.14.5

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## v2.14.5
+- **`/channel remove <id>` is now a complete teardown — a re-add starts from a genuinely clean slate.** Removal used to clear only the `.env` channel config (`CHANNELS` + the `KAZEE_*` keys), but the wizard's v2.14.4 owner-capture also links the owner's Kazee handle onto their people record (`people.linkHandle`) and mirrors an identity mapping into `identities.json` (`setIdentityMapping`). Those were left behind, so a subsequent `/channel add kazee` stacked on stale handle + identity state. `/channel remove` now also drops every handle for that transport across all people records (new `people.unlinkAdapterHandles`) and removes its identity mappings — channel→canonical links and preferred-channel pointers (new `identity.removeTransportIdentities`) — and clears the previously-orphaned `KAZEE_BOT_USER_ID`.
+- **The cleanup goes through the in-memory stores, so disk and the running process stay consistent.** `identities.json` is loaded once at boot into a shared in-memory object (`identity.js`), and `saveIdentities()` re-serializes that whole object on every write. Because `router.js` calls `autoLinkOwnerChannel` → `setIdentityMapping` → `saveIdentities` on each owner message, any entry lingering in memory is rewritten to disk continuously — so an out-of-band file edit can't stick, and a partial teardown leaves ghosts that reappear. Removing through the in-memory maps (then persisting) means the teardown holds. The `/channel remove` reply now reports what it cleared (e.g. `Removed channel: kazee — cleared 1 handle + identity links`).
+- **Agent-space / OpenClaw:** no new deps, no new env, no schema change; Docker image builds identically. Scoped entirely to the owner-driven `/channel remove` path — inert for deployments that never remove a channel. Full `npm test` green.
+
+## v2.14.4
+- **The owner no longer gets asked to double-approve their own Kazee reply — split-brain owner resolution is fixed.** On Kazee a person is identified by `userId` while the room is `channelId` (the chat-document); the two differ. The auth layer already recognised the owner correctly (via `access.matchesTransportOwner` → `currentUserId()`), but the independent relationship guardrail re-derived ownership from `channelId` — which never equals the configured `KAZEE_OWNER_USER_ID` — and so classed the owner as *external*, escalating the owner's own approval a second time. `relationship.speakerFor` now takes an optional third `userId` and keys identity/owner classification off `speakerId = userId || channelId` (the person), while still replying/escalating to `channelId` (the room). The raw per-user id is threaded to every subprocess egress guard via a new `OC_CHANNEL_USER_ID` env var + loopback query/body param (`bin/cli.js`, `bin/entity.js`, `bin/tool.js`, `bin/loopback-client.js`, `core/io.js`, `core/loopback.js`, `core/system-prompt.js`). **On Telegram `userId === channelId` in DMs, so this is a strict no-op** for existing Telegram deployments.
+- **`/channel add kazee` now links the owner's Kazee handle at capture time.** Owner recognition previously lived only in the env/adapter (`KAZEE_OWNER_USER_ID`); the owner's people record had no Kazee handle, so the guardrail (which resolves through canonical identity) re-derived the operator as external. `finalizeOwner` now calls `people.linkHandle(owner.id, { adapter: "kazee", channelId: ownerUserId, … })` so the wizard's captured owner is recognised the same way the rest of the bot resolves identity — belt-and-suspenders with the `speakerFor` fix above.
+- **Debug/internal chatter is owner-only.** Recall banners (`/recall`), tool/skill traces (`/tooltrace`), and usage/cost alerts are now suppressed for a guarded (external) speaker regardless of the toggle state — internal mechanics of how the assistant works must never leak to a non-owner. Resolved once per turn (`isCurrentSpeakerGuarded`) and applied at all three emitters (`core/runner.js`).
+- **Escalation & approval prompts render properly on Telegram.** The external-guardrail Approve/Deny/Always-allow message (`core/enforcer.js`) and the destructive-tool approval prompt (`core/loopback.js`) build HTML (`<b>`/`<pre>`, all dynamic content `esc()`-escaped) but were sent without a parse mode, so the tags showed literally. They now set `parseMode: "HTML"` **only for the Telegram adapter** (other adapters ignore it).
+- **Friendlier stale-button handling.** A wizard callback pressed after the session is gone (bot restart / timeout) previously did nothing — a dead button reads as a hang. It now replies *"That setup step expired — I'm no longer listening. Run /channel add kazee to start again."*
+- **Agent-space / OpenClaw:** no new deps, no new required env (`OC_CHANNEL_USER_ID` is bot-internal, injected per-turn), no schema change; Docker image builds identically. Correctness fix to owner recognition on Kazee + polish to the onboarding wizard — inert for Telegram-only deployments (userId === channelId). Full `npm test` green.
+
 ## v2.14.3
 - **`/channel add kazee` owner-confirm no longer depends on the inline button round-tripping.** After the wizard captures a candidate owner message it asks *"Is this you — the owner?"* with Yes/No/Skip buttons on the operator's channel — but if that button callback never reaches the bot (e.g. a channel that drops `message:action` server-side), the operator was stuck: the confirm step (`core/channel-wizard.js` `handleText`) only understood "skip" or a pasted 24-hex id, so typing "yes" did nothing. It now accepts **typed "yes"/"no"** (plus y/n/yep/yeah/nope) as a first-class answer — "yes" finalizes the captured candidate as owner, "no" clears it and keeps listening — and any other text nudges with the three options. The confirm prompt now reads *"Tap a button below, or just reply "yes" / "no"."*
 - **Agent-space / OpenClaw:** no new deps, no new env, no schema change; Docker image builds identically. Purely a robustness fix to the Kazee onboarding wizard's owner-confirm step — inert for deployments that never run `/channel add kazee`.

package/bin/cli.js

@@ -60,6 +60,7 @@ function sendViaLoopback(kind, restArgs) {
   const fileName = path.basename(filePath);
   const stat = fs.statSync(filePath);
   const params = new URLSearchParams({ channelId, adapter: adapterId, fileName });
+  if (process.env.OC_CHANNEL_USER_ID) params.set("userId", process.env.OC_CHANNEL_USER_ID);
   if (caption) params.set("caption", caption);
 
   const req = http.request({

package/bin/entity.js

@@ -71,7 +71,7 @@ function run(args) {
       // owner person (R1) — a note can never confer owner powers.
       try {
         const relationship = require("../core/relationship");
-        const sp = relationship.speakerFor(process.env.OC_CHANNEL_ADAPTER, process.env.OC_CHANNEL_ID);
+        const sp = relationship.speakerFor(process.env.OC_CHANNEL_ADAPTER, process.env.OC_CHANNEL_ID, process.env.OC_CHANNEL_USER_ID);
         if (relationship.guardActive(sp)) {
           console.error("⛔ Only the owner can set a persona/mandate.");
           process.exitCode = 3; return;

package/bin/loopback-client.js

@@ -36,6 +36,7 @@ function context() {
     sendToken,
     channelId: process.env.OC_CHANNEL_ID,
     adapterId: process.env.OC_CHANNEL_ADAPTER,
+    userId: process.env.OC_CHANNEL_USER_ID || null,
     canonicalUserId: process.env.OC_CANONICAL_USER_ID || null,
     sessionId: process.env.OC_LAST_SESSION_ID || null,
     sessionKey: process.env.OC_LAST_SESSION_KEY || null,
@@ -57,6 +58,7 @@ function postJson(kind, body) {
   const payload = JSON.stringify({
     channelId: ctx.channelId,
     adapter: ctx.adapterId,
+    userId: ctx.userId,
     canonicalUserId: ctx.canonicalUserId,
     sessionId: ctx.sessionId,
     sessionKey: ctx.sessionKey,

package/bin/tool.js

@@ -388,7 +388,7 @@ async function run(args) {
         let speaker = null;
         try {
           const relationship = require("../core/relationship");
-          const sp = relationship.speakerFor(process.env.OC_CHANNEL_ADAPTER, process.env.OC_CHANNEL_ID);
+          const sp = relationship.speakerFor(process.env.OC_CHANNEL_ADAPTER, process.env.OC_CHANNEL_ID, process.env.OC_CHANNEL_USER_ID);
           if (relationship.guardActive(sp)) speaker = sp; // else owner/no-context → ungated
         } catch (e) { speaker = null; }
         if (speaker) {

package/core/channel-wizard.js

@@ -20,6 +20,7 @@ const { send, deleteMessage } = require("./io");
 const { publicCommands } = require("./commands");
 const registry = require("./adapter-registry");
 const { validateKazee } = require("./kazee-probe");
+const people = require("./people");
 
 const sessions = new Map(); // canonicalUserId -> session
 
@@ -208,7 +209,12 @@ async function handleAction(envelope) {
     await cancel(envelope.canonicalUserId);
     return true;
   }
-  if (!session) return true; // stale button — swallow so it doesn't fall through
+  if (!session) {
+    // Session gone (bot restart or timeout). Don't silently swallow — a dead
+    // button that does nothing reads as a hang. Tell the operator to re-run.
+    await send("That setup step expired — I'm no longer listening. Run /channel add kazee to start again.");
+    return true;
+  }
 
   if (payload === "chw:owner-yes") {
     const cand = session.data.candidate;
@@ -293,6 +299,23 @@ async function finalizeOwner(canonicalUserId, session, ownerUserId) {
   config.KAZEE_OWNER_USER_ID = ownerUserId;
   const adapter = registry.findAdapter("kazee");
   if (adapter) adapter.ownerUserId = ownerUserId;
+  // Link the owner's Kazee handle onto their people record so relationship
+  // resolution (speakerFor → channelIsOwner) recognizes their Kazee messages
+  // as the owner. Without this, ownership is only known to the env/adapter and
+  // the guardrail re-derives the operator as external → spurious re-approval.
+  if (ownerUserId) {
+    try {
+      const owner = people.owners()[0];
+      if (owner) {
+        people.linkHandle(owner.id, {
+          adapter: "kazee",
+          channelId: ownerUserId,
+          displayName: session.data?.candidate?.name || null,
+          approvedBy: "channel-wizard",
+        });
+      }
+    } catch (e) { console.error("channel-wizard linkHandle:", e.message); }
+  }
   sessions.delete(canonicalUserId);
   await sayToOrigin(
     session,

package/core/handlers.js

@@ -1674,21 +1674,32 @@ register({
       if (id === "telegram") return send("Refusing to remove the Telegram adapter from a /channel command — that's your own connection.");
       const result = await registry.removeAdapter(id);
       if (!result.ok) return send(result.error);
+      const transport = id.split(":")[0];
       // Strip from .env so the change survives restart.
       const channels = (config.CHANNELS || "telegram").split(",").map((s) => s.trim()).filter(Boolean);
-      const kept = channels.filter((c) => c !== id && !c.startsWith(id + ":") && c !== id.split(":")[0]);
+      const kept = channels.filter((c) => c !== id && !c.startsWith(id + ":") && c !== transport);
       const next = kept.join(",") || "telegram";
       saveEnvKey("CHANNELS", next);
       config.CHANNELS = next;
-      if (id === "kazee") {
-        saveEnvKey("KAZEE_URL", "");
-        saveEnvKey("KAZEE_BOT_TOKEN", "");
-        saveEnvKey("KAZEE_OWNER_USER_ID", "");
-        config.KAZEE_URL = "";
-        config.KAZEE_BOT_TOKEN = "";
-        config.KAZEE_OWNER_USER_ID = "";
+      if (transport === "kazee") {
+        for (const k of ["KAZEE_URL", "KAZEE_BOT_TOKEN", "KAZEE_OWNER_USER_ID", "KAZEE_BOT_USER_ID"]) {
+          saveEnvKey(k, "");
+          config[k] = "";
+        }
       }
-      return send(`Removed channel: ${id}`);
+      // Complete the teardown: drop this transport's handles from every person
+      // record and its identity mappings. Both mutate through the in-memory
+      // stores, so disk and the running process stay consistent — otherwise a
+      // stale handle/link survives in memory and gets rewritten on the next
+      // add, which is exactly what made a re-add feel un-clean.
+      let unlinked = 0;
+      try { unlinked = require("./people").unlinkAdapterHandles(transport).length; } catch (e) {}
+      let idsCleared = false;
+      try { idsCleared = require("./identity").removeTransportIdentities(transport); } catch (e) {}
+      const extra = (unlinked || idsCleared)
+        ? ` — cleared ${unlinked} handle${unlinked === 1 ? "" : "s"} + identity links`
+        : "";
+      return send(`Removed channel: ${id}${extra}`);
     }
 
     send("Usage: /channel | /channel add kazee | /channel remove <id>");

package/core/identity.js

@@ -137,6 +137,25 @@ function setIdentityMapping(transport, channelId, canonicalUserId) {
   };
 }
 
+// Remove every identity mapping for a transport — used when a channel is torn
+// down (/channel remove) so no stale channel→canonical link or preferred-channel
+// pointer lingers to be rewritten to disk on the next identity write. Mutates
+// the in-memory map the whole process shares, THEN persists, so memory and disk
+// stay in sync (a disk-only edit would be resurrected by the cached object).
+function removeTransportIdentities(transport) {
+  const t = String(transport || "").toLowerCase();
+  if (!t) return false;
+  let changed = false;
+  for (const key of Object.keys(identities.channels)) {
+    if (key.slice(0, t.length + 1) === t + ":") { delete identities.channels[key]; changed = true; }
+  }
+  for (const [userId, pref] of Object.entries(identities.preferred)) {
+    if (pref && String(pref.transport || "").toLowerCase() === t) { delete identities.preferred[userId]; changed = true; }
+  }
+  if (changed) saveIdentities();
+  return changed;
+}
+
 module.exports = {
   identities,
   normalizeCanonicalUserId,
@@ -149,5 +168,6 @@ module.exports = {
   canonicalForTelegram,
   canonicalForStoredUserKey,
   setIdentityMapping,
+  removeTransportIdentities,
   saveIdentities,
 };

package/core/io.js

@@ -2,7 +2,7 @@
 // here so that the right adapter is invoked for the in-flight message
 // without each handler having to know about transports.
 
-const { currentAdapter, currentChannelId } = require("./context");
+const { currentAdapter, currentChannelId, currentUserId } = require("./context");
 
 async function send(text, opts = {}) {
   const adapter = currentAdapter();
@@ -53,7 +53,7 @@ async function sendFile(filePath, caption) {
   // (external) speaker. Owner / no-context → guardActive is false → no-op.
   try {
     const relationship = require("./relationship");
-    if (relationship.guardActive(relationship.speakerFor(adapter.type, channelId))) {
+    if (relationship.guardActive(relationship.speakerFor(adapter.type, channelId, currentUserId()))) {
       console.error("sendFile blocked: external speaker — file egress requires owner approval");
       return false;
     }

package/core/loopback.js

@@ -106,6 +106,7 @@ function readBodyAsString(req, max = 64 * 1024) {
 
 async function handleSend(req, res, url, kind) {
   const channelId = url.searchParams.get("channelId");
+  const userId = url.searchParams.get("userId") || "";
   const adapterId = url.searchParams.get("adapter");
   const caption = url.searchParams.get("caption") || "";
   const fileName = url.searchParams.get("fileName") || `file-${Date.now()}.bin`;
@@ -119,7 +120,7 @@ async function handleSend(req, res, url, kind) {
   // unaffected — guardActive is false there, so this is a strict no-op for them.
   try {
     const relationship = require("./relationship");
-    const speaker = relationship.speakerFor(adapter.type, channelId);
+    const speaker = relationship.speakerFor(adapter.type, channelId, userId);
     if (relationship.guardActive(speaker)) {
       return reply(res, 403, { error: "file egress to an external contact is blocked by the guardrail — an unvetted file cannot be sent to a non-owner; ask the owner to send it" });
     }
@@ -152,6 +153,7 @@ async function handleJson(req, res, url, kind) {
     catch (e) { return reply(res, 400, { error: "invalid JSON body" }); }
   }
   const channelId = String(payload.channelId || url.searchParams.get("channelId") || "");
+  const userId = String(payload.userId || url.searchParams.get("userId") || "");
   const adapterId = String(payload.adapter || url.searchParams.get("adapter") || "");
   if (!channelId || !adapterId) return reply(res, 400, { error: "missing channelId/adapter" });
   const adapter = registry.findAdapter(adapterId);
@@ -485,7 +487,7 @@ async function handleJson(req, res, url, kind) {
       // non-owner, refuse: never hand an external the approve button (R8/R10).
       try {
         const relationship = require("./relationship");
-        const speaker = relationship.speakerFor(adapter.type, channelId);
+        const speaker = relationship.speakerFor(adapter.type, channelId, userId);
         if (relationship.guardActive(speaker)) {
           return reply(res, 403, { error: "approval requests are owner-only; external mutating runs escalate through the guardrail" });
         }
@@ -507,7 +509,10 @@ async function handleJson(req, res, url, kind) {
         { text: "✅ Approve", callback_data: `apr:${rec.id}:ok` },
         { text: "⛔ Deny", callback_data: `apr:${rec.id}:no` },
       ]] };
-      const ok = await adapter.send(channelId, text, { keyboard });
+      // <pre> needs Telegram's HTML parse mode to render; other adapters ignore it.
+      const sendOpts = { keyboard };
+      if (adapter.type === "telegram") sendOpts.parseMode = "HTML";
+      const ok = await adapter.send(channelId, text, sendOpts);
       if (!ok) { approvals.decide(rec.id, "denied", "send-failed"); return reply(res, 500, { error: "could not deliver approval prompt" }); }
       audit.log("tool.approval.requested", { id: rec.id, tool: rec.tool, verb: rec.verb, channelId });
       return reply(res, 200, { ok: true, id: rec.id });

package/core/people.js

@@ -159,6 +159,30 @@ function unlinkHandle(personId, { adapter, channelId }) {
   return p;
 }
 
+// Remove every handle for a given adapter across ALL people records — used when
+// a channel is torn down (/channel remove) so no stranded handle survives to be
+// re-linked or re-mirrored on a later add. primaryChannel falls back to the next
+// remaining handle. Returns the ids of the people that were changed.
+function unlinkAdapterHandles(adapter) {
+  const a = String(adapter || "").toLowerCase();
+  if (!a) return [];
+  const all = load();
+  const affected = [];
+  for (const p of all) {
+    const before = (p.handles || []).length;
+    if (!before) continue;
+    p.handles = p.handles.filter((h) => h.adapter !== a);
+    if (p.handles.length === before) continue;
+    if (p.primaryChannel && p.primaryChannel.adapter === a) {
+      p.primaryChannel = p.handles[0] ? { adapter: p.handles[0].adapter, channelId: p.handles[0].channelId } : null;
+    }
+    p.updatedAt = nowIso();
+    affected.push(p.id);
+  }
+  if (affected.length) save(all);
+  return affected;
+}
+
 function setPrimary(personId, { adapter, channelId }) {
   const all = load();
   const p = all.find((x) => x.id === personId);
@@ -264,7 +288,7 @@ module.exports = {
   load, save, list, roster,
   add, update, remove,
   findById, findByName, findByCanonicalUserId, findByHandle,
-  linkHandle, unlinkHandle, setPrimary,
+  linkHandle, unlinkHandle, unlinkAdapterHandles, setPrimary,
   note, removeNote,
   setEntitySlug, resolveEntitySlug,
   owners, hasOwnerRecord, seedOwnerFromLegacy,

package/core/relationship.js

@@ -13,11 +13,19 @@
 //    ungated. This is what keeps the owner reply/tool/file paths byte-for-byte
 //    unchanged when the guardrail is dormant (R9/R14).
 
-function speakerFor(adapterType, channelId) {
+// `userId` (optional) is the PERSON's id, distinct from `channelId` (the
+// reply target / room) on transports that separate them — Kazee sets
+// userId = the sender and channelId = the chat-document. Identity (owner
+// classification + person lookup) must key off the person, never the room,
+// or the owner is falsely classed external on Kazee (channelId ≠ the
+// configured KAZEE_OWNER_USER_ID). On Telegram userId === channelId, so
+// passing it is a strict no-op. channelId is still what we reply/escalate to.
+function speakerFor(adapterType, channelId, userId) {
   try {
     if (!adapterType || !channelId) return null;
+    const speakerId = String(userId || channelId);
     const people = require("./people");
-    const person = people.findByHandle(adapterType, channelId);
+    const person = people.findByHandle(adapterType, speakerId);
 
     // Ownership is resolved through canonical identity — the SAME source of
     // truth the queue/state/run-lock uses — so the owner is recognised on every
@@ -30,7 +38,7 @@ function speakerFor(adapterType, channelId) {
     // a note can never trip it (R1 preserved — the owner stays anchored to a
     // real owner record via ownerCanonical → people.isOwner).
     let ownerByCanonical = false;
-    try { ownerByCanonical = require("./identity").channelIsOwner(adapterType, channelId); } catch (e) {}
+    try { ownerByCanonical = require("./identity").channelIsOwner(adapterType, speakerId); } catch (e) {}
 
     if (ownerByCanonical || (person && person.isOwner)) {
       let ownerPerson = person && person.isOwner ? person : null;
@@ -80,11 +88,11 @@ function speakerFor(adapterType, channelId) {
 
 function currentSpeaker() {
   try {
-    const { currentAdapter, currentChannelId } = require("./context");
+    const { currentAdapter, currentChannelId, currentUserId } = require("./context");
     const adapter = currentAdapter();
     const channelId = currentChannelId();
     if (!adapter || !channelId) return null; // no context → ungated (owner-local)
-    return speakerFor(adapter.type, channelId);
+    return speakerFor(adapter.type, channelId, currentUserId());
   } catch (e) {
     return null;
   }

package/core/runner.js

@@ -12,7 +12,7 @@ const {
   CONFIG_DIR, WORKSPACE, config,
 } = require("./config");
 const { currentState, saveState, recordSession, userOwnsClaudeSession, resetSessionUsage } = require("./state");
-const { chatContext, currentChannelId, currentAdapter } = require("./context");
+const { chatContext, currentChannelId, currentAdapter, currentUserId } = require("./context");
 const { splitLeadingOriginGroup } = require("./queue-drain");
 const { buildSystemPrompt, promptWithDynamicContext } = require("./system-prompt");
 const { redactSensitive } = require("./redact");
@@ -169,7 +169,11 @@ function logTurnUsage(state, usage, costUsd, announce, opts = {}) {
   const result = evaluateUsageAlert(previousRecords, record, policy, lastAlertAt);
   if (result.alert) {
     state.usageAlertLastAt = Date.now();
-    if (announce) {
+    // Owner-only: version/model/context internals must never surface to an
+    // external speaker, regardless of the usage-alert policy.
+    let usageOwnerOnly = true;
+    try { usageOwnerOnly = !require("./relationship").isCurrentSpeakerGuarded(); } catch (e) {}
+    if (announce && usageOwnerOnly) {
       const baseline = result.trend?.baselineAvgContextTokens || 0;
       const rate = result.trend?.latestRate || 0;
       const contextLabel = usageScope === "turn_delta" ? "Context this turn" : "Session context total";
@@ -197,6 +201,11 @@ function chatEnvOverlay() {
   const overlay = {};
   if (adapter && adapter.id) overlay.OC_CHANNEL_ADAPTER = adapter.id;
   if (channelId) overlay.OC_CHANNEL_ID = String(channelId);
+  // Raw per-user id (distinct from channelId on Kazee) so subprocess egress
+  // guards classify the speaker by person, not room — matching in-process
+  // relationship.speakerFor. On Telegram this equals channelId.
+  const uid = currentUserId();
+  if (uid) overlay.OC_CHANNEL_USER_ID = String(uid);
   if (lb) {
     overlay.OC_SEND_URL = lb.url;
     overlay.OC_SEND_TOKEN = lb.token;
@@ -780,6 +789,11 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   const channelId = currentChannelId();
   const adapter = currentAdapter();
   const { settings } = state;
+  // Owner-vs-external, resolved once per turn. All internal-activity chatter
+  // (recall banners, tool/skill traces, usage alerts) is owner-only so nothing
+  // about how the assistant works leaks to an external speaker.
+  let externalSpeaker = false;
+  try { externalSpeaker = require("./relationship").isCurrentSpeakerGuarded(); } catch (e) {}
   cwd = resolveRunCwd(cwd);
 
   if (state.runningProcess) {
@@ -920,6 +934,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
   // is invoked or its SKILL.md is written/patched. Deduped per turn.
   const skillNotified = new Set();
   const notifySkill = (key, text) => {
+    if (externalSpeaker) return; // never leak internal activity to a non-owner
     if (skillNotified.has(key)) return;
     skillNotified.add(key);
     chatContext.run(store, () => send(text).catch(() => {}));
@@ -1085,14 +1100,17 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
       turnRecallTier = String(r.tier || "");
       const esc = (s) => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
       const fmt = (arr, icon) => arr.map((x) => (x.why ? `${icon} <b>${esc(x.name)}</b> — ${esc(x.why)}` : `${icon} <b>${esc(x.name)}</b>`));
+      // Debug traces are owner-only: recall/tool/engine internals must never
+      // leak to an external speaker even when a debug toggle is left on.
+      const traceOwnerOnly = !externalSpeaker;
       // 🧠 packs/entities recall — gated by /recall.
-      if (settings.showRecall) {
+      if (traceOwnerOnly && settings.showRecall) {
         const lines = [...fmt(r.packs || [], "📦"), ...fmt(r.entities || [], "👤"), ...fmt(r.episodes || [], "📓")];
         if (lines.length) send(`🧠 <b>Recall this turn</b> (${esc(r.engine)})\n${lines.join("\n")}`, telegramHtmlOpts()).catch(() => {});
         else if (r.gated) send(`🧠 <b>Recall</b> (${esc(r.engine)}): skipped by pre-gate — trivial turn.`, telegramHtmlOpts()).catch(() => {});
       }
       // 🔧 tools surfaced this turn (first-class discoverer nodes) — gated by /tooltrace.
-      if (settings.showToolTrace) {
+      if (traceOwnerOnly && settings.showToolTrace) {
         const toolLines = fmt(r.tools || [], "🔧");
         if (toolLines.length) send(`🔧 <b>Tools surfaced this turn</b>\n${toolLines.join("\n")}`, telegramHtmlOpts()).catch(() => {});
       }

package/core/system-prompt.js

@@ -7,7 +7,7 @@ const path = require("path");
 const { SOUL_FILE, CRONS_FILE, VAULT_FILE, FILES_DIR, BOT_DIR, WHISPER_CLI, FFMPEG, config } = require("./config");
 const CONFIG_DIR = require("../config-dir");
 const { currentState } = require("./state");
-const { currentAdapter, currentChannelId } = require("./context");
+const { currentAdapter, currentChannelId, currentUserId } = require("./context");
 const { vault } = require("./vault-store");
 const { transcriptPointerNote } = require("./transcripts");
 const tasksStore = require("./tasks");
@@ -146,7 +146,10 @@ function buildSystemPrompt() {
     }
 
     if (adapter && channelId) {
-      const speaker = people.findByHandle(adapter.type, channelId);
+      // Identify the speaker by their person id (userId), not the room —
+      // on Kazee channelId is the chat-document, so a channelId lookup would
+      // never match the owner's handle. On Telegram the two are equal.
+      const speaker = people.findByHandle(adapter.type, String(currentUserId() || channelId));
       if (speaker) {
         const recentNotes = (speaker.notes || []).slice(-3).map((n) => `- [${n.at?.slice(0, 10) || ""}] ${n.text}`).join("\n");
         currentSpeakerBlock = `\n## Speaker\nYou are talking to ${speaker.name}${speaker.isOwner ? " (the owner)" : ""} on ${adapter.type}.${speaker.bio ? "\nBio: " + speaker.bio : ""}${recentNotes ? "\nRecent notes:\n" + recentNotes : ""}\n`;

package/package.json

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