@inetafrica/open-claudia 3.0.20 → 3.0.24

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## v3.0.24 — Spaces threads read like a group chat; memory notes go quiet unless you're watching
+
+- **The "🧠 Jotted this down" memory notes are now gated behind `/recall`.** After each turn the pack reviewer still writes to long-term memory exactly as before — but the chat announcement of what it filed away only surfaces when `/recall` is on (`state.settings.showRecall`), the same toggle that already gates the recall/tool banners. Off by default, so ordinary turns stay clean; flip `/recall on` to watch memory (and recall) work. That announcement was the one learning-surface bypassing the gate; it no longer does.
+- **Re-ship of v3.0.23, which never published.** Its tag build failed the version-approval CI gate — `package.json` was bumped without mirroring the assertion in `test-provider-language.js`. Same gate that caught v3.0.21; corrected here as v3.0.24, exactly as v3.0.22 re-shipped v3.0.21.
+- **An engaged Spaces turn now arrives knowing the whole thread, not just one bare comment.** When a tag/reply/assignment engages the bot on a task, the router pulls a **thread-context block** from the adapter and prepends it to the prompt: the task's metadata (title, status/priority/due, assignees, a clipped description) **plus every comment posted since the bot last replied**. So the bot answers like a member who's been reading along, instead of replying blind. The full task + entire comment history stays one `spaces read` tool call away.
+- **"Group chat the bot is a member of."** Untagged comments still never trigger a turn (the engage gate is unchanged — mentions/replies/assignments only). But the next time the bot *is* addressed, everything said in between is caught up in one batched injection. The delta is derived server-side from a per-task **context watermark**, so a missed poll or a restart self-heals — the next engage still pulls the true set. The bot's own prior reply is re-surfaced too, which keeps continuity across auto-compaction.
+- **Bounded by construction.** The catch-up is capped (newest 12 comments, each body clipped) so a busy thread can't blow the prompt; the very first engage on a long-idle task shows recent history, not the entire backlog. Auto-compaction absorbs the rest — no new wiring, it's already per-thread and token-triggered.
+- **Rendered cleanly, not stitched into the message.** Context is delivered via a new channel-agnostic `buildThreadContext()` adapter method that the router renders — `envelope.text` stays pristine, so command detection and the credential scrub are unaffected (the old approach mutated the message text). The seam is generic: Kazee group rooms can implement the same method later, and the since-last-reply delta is exactly the input a future lightweight activation agent would judge to decide whether to chip in unprompted — provisioned, not built.
+- **The bot now leaves a read receipt, like a teammate.** When an engaged turn catches up on a thread, it marks every comment it just read as *seen by* the bot (`comments/mark-seen` → server `$addToSet`s the bot into each comment's `seenBy` and broadcasts `comment:seen`). So a human watching a task sees the bot appear on "seen by" exactly like another member the moment it reads their message — not only when it replies. Fire-and-forget and fully swallowed: it rides the same member/admin `comments.update` scope the reply already uses, and a scope or network failure degrades to silent (never breaks or delays a turn). Only ever fires on an engaged turn — the awareness poll still never mutates Spaces state.
+- **Agent-space / OpenClaw:** no new deps, no new env, no schema change; Docker image builds identically (FROM the pre-baked `:base`). Existing pods pick this up on their next approved upgrade.
+
 ## v3.0.20 — Spaces answers tags, and knows the owner
 
 - **A tag now actually gets a reply.** The Spaces server labels notifications with **plural** categories (`mentions`, `comments`, `reactions`, `task_updated`), but the conversational plane's engage set only matched the singular `mention` — so every real `@`-tag was silently downgraded to awareness-only and the bot never spoke. `ENGAGE_TYPES` now matches the plural forms (`mentions`/`replies`, singular aliases kept for safety). Plain comments, reactions and task updates stay awareness-only, so the "untagged comments hit the radar without auto-answering" rule is unchanged. Confirmed live: a real `mentions` notification was arriving and being dropped.

package/channels/spaces/adapter.js

@@ -30,6 +30,17 @@ const spacesState = require("./state");
 // never auto-reply.
 const ENGAGE_TYPES = new Set(["mention", "mentions", "reply", "replies", "task_assigned"]);
 
+// Description clip length for the front-loaded task context. Long descriptions
+// are deliberately truncated — the agent can pull the full task + comment
+// history on demand via the `spaces` tool's read verb, so we keep the prompt
+// lean instead of pasting a wall of text every turn.
+const TASK_DESC_LIMIT = 800;
+// Catch-up bounds for the "comments since your last reply" block. Cap the count
+// (also bounds the very first engage, which has no watermark) and clip each body
+// so a busy thread can't blow the prompt. Auto-compaction absorbs the rest.
+const CATCHUP_MAX = 12;
+const CATCHUP_BODY_LIMIT = 500;
+
 class SpacesAdapter {
   constructor({ id = "spaces", url = "https://api.spaces.kazee.africa", token, ownerUserId = "", taskLoopMode = "advisory", pollMs }) {
     this.id = id;
@@ -272,7 +283,10 @@ class SpacesAdapter {
   }
 
   // Await every registered message listener (the router turn resolves when the
-  // agent run completes) so the per-task chain doesn't advance early.
+  // agent run completes) so the per-task chain doesn't advance early. Task
+  // context is no longer stitched onto envelope.text here — the router pulls it
+  // via buildThreadContext() and renders it, keeping envelope.text pristine for
+  // command detection and the credential scrub.
   async _deliverMessage(envelope) {
     for (const fn of [...(this._listeners.message || [])]) {
       try { await fn(envelope); }
@@ -280,6 +294,165 @@ class SpacesAdapter {
     }
   }
 
+  // Channel-agnostic thread-context provider (ChannelAdapter contract). The
+  // router calls this on an engaged turn and prepends the returned contextBlock
+  // to the prompt, so the agent arrives on a Spaces thread already knowing what
+  // it's looking at — the task's metadata AND every comment posted since it last
+  // replied — instead of answering blind to one bare comment. Two read-only GETs
+  // (task + comments); any failure returns null so the reply still goes out.
+  //
+  // "Task as a group chat the bot is a member of": untagged comments never fire a
+  // turn (ENGAGE_TYPES gates that), but they're caught up here the next time the
+  // bot IS addressed. The delta is server-derived from a watermark, so a missed
+  // poll or a restart self-heals — the next engage still pulls the true set.
+  //
+  // The same _commentsSince() delta is the exact input a future Haiku activation
+  // agent would judge to decide whether to chip in unprompted — left as a seam,
+  // not built.
+  async buildThreadContext(envelope) {
+    const taskId = envelope?.spaces?.taskId;
+    if (!taskId) return null;
+
+    let task = null;
+    try { task = await this.client.getTask(taskId); }
+    catch (e) { task = null; }
+
+    const lines = ["[Kazee Spaces thread context]"];
+    lines.push(`Task: ${(task && task.title) || envelope.spaces?.title || "(untitled task)"}`);
+
+    if (task && typeof task === "object") {
+      const meta = [];
+      if (task.status) meta.push(`Status: ${task.status}`);
+      if (task.priority) meta.push(`Priority: ${task.priority}`);
+      if (task.dueDate) meta.push(`Due: ${String(task.dueDate).slice(0, 10)}`);
+      if (meta.length) lines.push(meta.join(" · "));
+
+      const people = this._collectPeople(task);
+      if (people.length) lines.push(`Assignees: ${people.join(", ")}`);
+
+      const desc = contentText(task.description || task.content || "");
+      if (desc) {
+        const clipped = desc.length > TASK_DESC_LIMIT
+          ? desc.slice(0, TASK_DESC_LIMIT).trimEnd() + " …[truncated]"
+          : desc;
+        lines.push(`Description: ${clipped}`);
+      }
+    }
+    lines.push(`(Full task + entire comment history on demand: \`spaces\` tool → read --task-id ${taskId}.)`);
+
+    // Catch-up: comments since the bot's last engaged turn, minus the triggering
+    // comment (already the main prompt). Advance the watermark to the newest
+    // comment seen so nothing is re-injected next time.
+    try {
+      const { catchUp, watermark, seenIds } = await this._commentsSince(taskId, envelope.text || "");
+      if (catchUp.length) {
+        lines.push("");
+        lines.push("Comments since your last reply (oldest→newest):");
+        for (const c of catchUp) lines.push(`  [${c.ago}] ${c.who}: ${c.body}`);
+      }
+      if (watermark) { try { spacesState.setContextWatermark(taskId, watermark); } catch (e) {} }
+      // Read receipt: the bot has now read this thread — mark those comments seen
+      // so a human sees the bot on "seen by" like a teammate. Fire-and-forget.
+      if (seenIds && seenIds.length) this._markSeen(taskId, seenIds);
+    } catch (e) { /* catch-up is best-effort; metadata still ships */ }
+
+    const who = envelope.from?.name || "Someone";
+    lines.push("");
+    lines.push(`${who} just commented — reply to this:`);
+
+    return { contextBlock: lines.join("\n") };
+  }
+
+  // Fire-and-forget read-receipt write. Deliberately not awaited by
+  // buildThreadContext: the engaged reply must never wait on it, and any failure
+  // (a scope 403 if the bot token lacks comments.update, a transport blip) is
+  // swallowed. It self-verifies on the first real engage — a persistent 403 in
+  // the logs is the signal that the token needs the comments.update grant.
+  _markSeen(taskId, commentIds) {
+    Promise.resolve()
+      .then(() => this.client.markCommentsSeen({ taskId, commentIds }))
+      .catch((e) => console.error("spaces mark-seen:", e.message));
+  }
+
+  // Read-only comment delta for a task: everything newer than the stored context
+  // watermark, capped and clipped, with the triggering comment (matched by body)
+  // removed so it isn't echoed. Also returns the watermark to advance to (the
+  // newest comment's createdAt). Shared shape so a future activation agent can
+  // reuse it to reason over "what's been said since I last spoke".
+  async _commentsSince(taskId, triggeringText) {
+    let comments = [];
+    try { comments = await this.client.listComments(taskId, 100); }
+    catch (e) { return { catchUp: [], watermark: null, seenIds: [] }; }
+    if (!Array.isArray(comments) || !comments.length) return { catchUp: [], watermark: null, seenIds: [] };
+
+    const ts = (c) => Date.parse(c.createdAt || c.updatedAt || 0) || 0;
+    comments.sort((a, b) => ts(a) - ts(b));
+    const watermark = comments[comments.length - 1].createdAt || null;
+    // Every comment the bot just pulled into this turn is one it has now read —
+    // the id set for the read receipt. The server no-ops the bot's own and
+    // already-seen comments, so passing the whole thread is safe and idempotent.
+    const seenIds = comments.map((c) => c._id || c.id).filter(Boolean).map(String);
+
+    const since = spacesState.getContextWatermark(taskId);
+    const sinceMs = since ? Date.parse(since) || 0 : 0;
+    const trigger = contentText(triggeringText || "").trim();
+
+    const fresh = comments.filter((c) => (sinceMs ? ts(c) > sinceMs : true));
+    const rendered = fresh
+      .map((c) => {
+        const au = c.authorId || c.author || c.userId || {};
+        const who = (typeof au === "object")
+          ? (`${au.firstName || ""} ${au.lastName || ""}`.trim() || au.name || au.email || "?")
+          : String(au || "?");
+        const body = contentText(c.content || "");
+        return { who, body: body.trim(), createdAt: c.createdAt };
+      })
+      .filter((c) => c.body && c.body !== trigger)
+      .map((c) => ({
+        who: c.who,
+        ago: this._ago(c.createdAt),
+        body: c.body.length > CATCHUP_BODY_LIMIT ? c.body.slice(0, CATCHUP_BODY_LIMIT).trimEnd() + " …" : c.body,
+      }));
+
+    // Newest N — a long-idle thread's very first engage shows recent history, not
+    // the entire backlog.
+    const catchUp = rendered.slice(-CATCHUP_MAX);
+    return { catchUp, watermark, seenIds };
+  }
+
+  // Compact relative-time label for a comment timestamp.
+  _ago(iso) {
+    const t = Date.parse(iso || 0);
+    if (!t) return "?";
+    const s = Math.max(0, Math.floor((Date.now() - t) / 1000));
+    if (s < 60) return `${s}s ago`;
+    const m = Math.floor(s / 60);
+    if (m < 60) return `${m}m ago`;
+    const h = Math.floor(m / 60);
+    if (h < 24) return `${h}h ago`;
+    return `${Math.floor(h / 24)}d ago`;
+  }
+
+  // Gather human-readable names attached to a task, deduped. Spaces uses a
+  // singular `assignee` object plus optional `assignees`/`members`/`participants`
+  // arrays depending on the endpoint, so we defensively merge all of them.
+  _collectPeople(task) {
+    const names = [];
+    const seen = new Set();
+    const add = (u) => {
+      if (!u || typeof u !== "object") return;
+      const full = `${u.firstName || ""} ${u.lastName || ""}`.trim() || u.name || u.email;
+      if (!full) return;
+      const key = String(u.id || u._id || full);
+      if (seen.has(key)) return;
+      seen.add(key);
+      names.push(full);
+    };
+    add(task.assignee);
+    for (const m of (task.assignees || task.members || task.participants || [])) add(m);
+    return names;
+  }
+
   // send() posts a comment back to the task thread. channelId is
   // "task:<taskId>"; opts.mentions is an array of {userId,label}; opts.replyTo
   // threads the reply under a comment id (parentId).

package/channels/spaces/client.js

@@ -5,10 +5,14 @@
 // tool logs a human in for a bearer; here the bot presents its own kzb_ token
 // directly (Spaces accepts it — verified via central /api/principal/verify).
 //
-// Everything here is READ-ONLY except createComment (the conversational reply)
-// — the data/awareness plane never mutates Spaces state, so the poller carries
-// no write risk. Notification "seen" tracking is a local cursor, not a
-// server-side mark-read, precisely to keep that plane read-only.
+// Everything here is READ-ONLY except two writes, both member/admin-tier and
+// both only fired on an ENGAGED turn (never from the awareness poll):
+//   • createComment    — the conversational reply (comments.create).
+//   • markCommentsSeen — the read receipt: marks the thread the bot just read as
+//     seen by the bot, so a human sees it on "seen by" like a teammate
+//     (comments.update; server $addToSets seenBy + broadcasts comment:seen).
+// The awareness/poll plane still never mutates Spaces state — notification "seen"
+// tracking there is a local cursor, not a server-side mark-read.
 
 const https = require("https");
 const http = require("http");
@@ -178,6 +182,23 @@ class SpacesClient {
     const res = await this._post("/api/comments", payload);
     return (res && (res.comment || res.data)) || res || null;
   }
+
+  // The second write: mark a set of task comments as seen by the bot — the read
+  // receipt. The server $addToSets the bot into each comment's seenBy (skipping
+  // ones it already saw or authored) and broadcasts a `comment:seen` socket
+  // event, so a human sees the bot on "seen by" exactly like another teammate.
+  // Needs the comments.update scope — the same member/admin tier the working
+  // createComment already relies on. Best-effort at the call site.
+  async markCommentsSeen({ taskId, commentIds }) {
+    const ids = (Array.isArray(commentIds) ? commentIds : []).map(String).filter(Boolean);
+    if (!ids.length) return null;
+    const res = await this._post("/api/comments/mark-seen", {
+      targetType: "task",
+      targetId: taskId,
+      commentIds: ids,
+    });
+    return res || null;
+  }
 }
 
 module.exports = { SpacesClient, flattenContent, contentText, buildCommentContent, asArray };

package/channels/spaces/state.js

@@ -92,6 +92,27 @@ function getCursor(taskId) {
   return s.tasks[String(taskId || "")] || null;
 }
 
+// Context watermark: the createdAt (ISO) of the newest comment the bot has
+// already folded into an engaged turn for this task. buildThreadContext reads
+// it to compute the "comments since my last reply" delta and advances it after
+// each engage, so the same comment is never re-injected. Distinct from the
+// notification cursor above (which tracks awareness activity, not turn context).
+function setContextWatermark(taskId, iso) {
+  const id = String(taskId || "");
+  if (!id || !iso) return;
+  const s = load();
+  const cur = s.tasks[id] || { count: 0 };
+  cur.contextAt = String(iso);
+  s.tasks[id] = cur;
+  save();
+}
+
+function getContextWatermark(taskId) {
+  const s = load();
+  const t = s.tasks[String(taskId || "")];
+  return (t && t.contextAt) || null;
+}
+
 // Mark that a task has had an agent turn emitted for it (from any source: a
 // socket/poll notification OR the reconciliation poll). The reconciliation poll
 // reads this to avoid re-engaging a task the socket already handled — dedup is
@@ -212,7 +233,8 @@ function controlSnapshot() {
 }
 
 module.exports = {
-  markProcessed, recordCursor, getCursor, markTaskEngaged, taskEngaged, snapshot, STATE_FILE,
+  markProcessed, recordCursor, getCursor, setContextWatermark, getContextWatermark,
+  markTaskEngaged, taskEngaged, snapshot, STATE_FILE,
   markSocketConnected, markRestConnected, setCentralConnected, isConnected,
   setMuted, setTaskLoopMode, taskLoopMode, conversationalActive, controlSnapshot,
 };

package/core/actions.js

@@ -575,19 +575,20 @@ async function handleAction(envelope) {
     };
     const p = presets[d.slice(3)];
     if (!p) return;
+    const cronProject = getProjectKey(state);
     scheduler.addJob({
       kind: "cron",
       adapter: envelope.adapter.id,
       adapterType: envelope.adapter.type,
       channelId: String(envelope.channelId),
       canonicalUserId: envelope.canonicalUserId,
-      project: state.currentSession.name,
+      project: cronProject,
       prompt: p.prompt,
       label: p.label,
       source: "user",
       schedule: p.schedule,
     });
-    await send(`Added: ${p.label} for ${state.currentSession.name}`);
+    await send(`Added: ${p.label} for ${cronProject}`);
     return;
   }
   if (d === "cp:clear") {

package/core/context.js

@@ -6,8 +6,8 @@ const { AsyncLocalStorage } = require("node:async_hooks");
 
 const chatContext = new AsyncLocalStorage();
 
-function runInChat({ adapter, channelId, canonicalUserId, userId, transport, raw }, fn) {
-  return chatContext.run({ adapter, channelId, canonicalUserId, userId, transport, raw }, fn);
+function runInChat({ adapter, channelId, canonicalUserId, userId, transport, raw, conversationKey }, fn) {
+  return chatContext.run({ adapter, channelId, canonicalUserId, userId, transport, raw, conversationKey }, fn);
 }
 
 function currentStore() {
@@ -44,6 +44,16 @@ function currentTransport() {
   return s ? s.transport : null;
 }
 
+// The per-thread conversation key for this turn (e.g. "telegram:6251055967",
+// "spaces:task:42"). Distinct from the (possibly unified) canonical speaker
+// identity: identity says WHO is talking, conversationKey says WHICH thread —
+// so the owner's Telegram DM and the owner's Spaces task keep separate live
+// conversations even though both resolve to the same canonical self.
+function currentConversationKey() {
+  const s = currentStore();
+  return s && s.conversationKey ? s.conversationKey : null;
+}
+
 module.exports = {
   chatContext,
   runInChat,
@@ -52,5 +62,6 @@ module.exports = {
   currentCanonicalUserId,
   currentUserId,
   currentTransport,
+  currentConversationKey,
   currentRaw,
 };

package/core/handlers.js

@@ -15,7 +15,7 @@ const { register } = require("./commands");
 const { send, deleteMessage } = require("./io");
 const {
   currentState, saveState, rootSession,
-  freshUsage, getActiveProvider, getProviderSession, setProviderSession, clearProviderSession,
+  freshUsage, getActiveProvider, getProjectKey, getProviderSession, setProviderSession, clearProviderSession,
   getProviderSettings,
   getProjectSessions, getLastProjectSession, userOwnsProviderSession,
   createSessionCallbackToken, linkIdentity,
@@ -207,7 +207,7 @@ function switchProviderState(providerId, options = {}) {
   };
   state.settings.backend = provider;
   if (Object.prototype.hasOwnProperty.call(options, "model")) state.settings.model = options.model;
-  const project = state.currentSession?.name || null;
+  const project = getProjectKey(state);
   if (project && !getProviderSession(state, provider, project)) {
     const last = getLastProjectSession(state.userId, project, provider);
     if (last) setProviderSession(state, provider, project, last.id);
@@ -237,9 +237,10 @@ function selectProjectState(project, options = {}) {
   clearTransientQueue(state, "Project changed before the queued run started");
   state.currentSession = { name: project.name.trim(), dir: project.dir || null };
   const provider = getActiveProvider(state);
-  const last = provider ? getLastProjectSession(state.userId, state.currentSession.name, provider) : null;
-  if (last) setProviderSession(state, provider, state.currentSession.name, last.id);
-  const sessionId = getProviderSession(state, provider, state.currentSession.name);
+  const key = getProjectKey(state);
+  const last = provider ? getLastProjectSession(state.userId, key, provider) : null;
+  if (last) setProviderSession(state, provider, key, last.id);
+  const sessionId = getProviderSession(state, provider, key);
   state.isFirstMessage = !sessionId;
   const persisted = persistSessionControl(state, options, () => {
     state.currentSession = previous.currentSession;
@@ -251,7 +252,7 @@ function selectProjectState(project, options = {}) {
 
 function startNewConversation(options = {}) {
   const state = options.state || currentState();
-  const project = state.currentSession?.name || null;
+  const project = getProjectKey(state);
   if (!project || (options.projectName && options.projectName !== project)) {
     return { ok: false, error: Object.assign(new Error("The selected project changed"), { code: "STALE_PROJECT" }) };
   }
@@ -277,7 +278,7 @@ function startNewConversation(options = {}) {
 function endCurrentSession(options = {}) {
   const state = options.state || currentState();
   const previous = { currentSession: state.currentSession, isFirstMessage: state.isFirstMessage };
-  const project = state.currentSession?.name || "Workspace";
+  const project = getProjectKey(state) || "Workspace";
   clearTransientQueue(state, "The conversation ended before the queued run started");
   state.currentSession = rootSession();
   state.isFirstMessage = true;
@@ -292,7 +293,7 @@ function endCurrentSession(options = {}) {
 function activeContinueOptions(state = currentState()) {
   const provider = getActiveProvider(state);
   if (!provider) return null;
-  const sessionId = getProviderSession(state, provider, state.currentSession?.name);
+  const sessionId = getProviderSession(state, provider, getProjectKey(state));
   return sessionId ? { provider, resumeSessionId: sessionId } : null;
 }
 
@@ -301,7 +302,7 @@ function activeContinueOptions(state = currentState()) {
 function startSession(name, resumeSessionId, options = {}) {
   const state = currentState();
   const provider = options.provider || getActiveProvider(state);
-  const projectName = "Workspace";
+  const projectName = getProjectKey(state);
 
   if (!provider) return send("Choose Claude Code or OpenAI Codex with /backend before starting a conversation.");
 
@@ -891,10 +892,10 @@ register({
     const state = currentState();
     const provider = getActiveProvider(state);
     if (!provider) return send("Choose Claude Code or OpenAI Codex with /backend first.");
-    const project = state.currentSession.name;
+    const project = getProjectKey(state);
     const sessions = getProjectSessions(state.userId, project, provider)
       .filter((session) => session.selectable !== false);
-    if (sessions.length === 0) return send("No past conversations for this project.");
+    if (sessions.length === 0) return send("No past conversations in this thread.");
     const rows = sessions.slice(0, 10).map((s) => {
       const date = new Date(s.lastUsed).toLocaleDateString();
       const active = getProviderSession(state, provider, project) === s.id ? " (active)" : "";
@@ -905,12 +906,12 @@ register({
         sessionId: s.id,
       });
       return [{
-        text: `${s.title}${active} · ${s.provider} · ${project} — ${date}`,
+        text: `${s.title}${active} · ${s.provider} — ${date}`,
         callback_data: `ss:${token}`,
       }];
     });
-    rows.push([{ text: "New conversation", callback_data: `new:${state.currentSession.name}` }]);
-    send(`Conversations in ${state.currentSession.name}:`, { keyboard: { inline_keyboard: rows } });
+    rows.push([{ text: "New conversation", callback_data: `new:${project}` }]);
+    send(`Conversations in this thread:`, { keyboard: { inline_keyboard: rows } });
   },
 });
 
@@ -1054,7 +1055,7 @@ register({
     }
     send(
       `Recall debug: ${settings.showRecall ? "on" : "off"}\n\n` +
-      "When on, I post a short \"🧠 Recall this turn\" line before each reply, showing which packs/entities surfaced (and, on the discoverer engine, why). Lets you watch recall work.",
+      "When on, I post a short \"🧠 Recall this turn\" line before each reply, showing which packs/entities surfaced (and, on the discoverer engine, why), plus the \"🧠 Jotted this down\" notes whenever I update long-term memory. When off, recall and memory-writes still happen — you just don't see the banners.",
       { keyboard: { inline_keyboard: [
         [{ text: "On", callback_data: "rcl:on" }, { text: "Off", callback_data: "rcl:off" }],
       ] } },

package/core/identity.js

@@ -18,6 +18,14 @@ function defaultCanonicalForChannel(transport, channelId) {
   return channelKey(transport, channelId);
 }
 
+// The conversation (thread) key for a channel. Deliberately identical to the
+// pre-unification default canonical: a thread is keyed by its raw channel
+// identity, never by the unified speaker canonical. This is what keeps each
+// surface's live conversation separate even when the speaker is one being.
+function conversationKeyFor(transport, channelId) {
+  return channelKey(transport, channelId);
+}
+
 function loadIdentities() {
   const raw = readJsonWithFallback(IDENTITIES_FILE, null);
   return {
@@ -187,6 +195,7 @@ module.exports = {
   normalizeCanonicalUserId,
   channelKey,
   defaultCanonicalForChannel,
+  conversationKeyFor,
   isConfiguredOwnerChannel,
   ownerCanonical,
   channelIsOwner,

package/core/router.js

@@ -5,6 +5,7 @@
 const fs = require("fs");
 const path = require("path");
 const { runInChat } = require("./context");
+const { conversationKeyFor } = require("./identity");
 const { dispatch } = require("./commands");
 const { handleAction } = require("./actions");
 const { isChatAuthorized } = require("./access");
@@ -79,6 +80,7 @@ function scope(envelope, fn) {
     userId: envelope.userId,
     transport: envelope.adapter?.type,
     raw: envelope.raw,
+    conversationKey: conversationKeyFor(envelope.adapter?.type, envelope.channelId),
   }, fn);
 }
 
@@ -454,6 +456,24 @@ async function handleText(envelope) {
     }
   }
 
+  // Thread-membership context. Multi-participant thread surfaces (Kazee Spaces
+  // tasks today; Kazee group rooms later) can supply a context block — thread
+  // metadata plus any messages posted since the bot last replied — so an
+  // engaged turn arrives knowing the whole thread, not just the one triggering
+  // message. The adapter owns WHAT to fetch; the router owns WHEN and HOW to
+  // render it. Channels without the method (Telegram, Kazee DM, voice, web) are
+  // untouched. Best-effort: a failure never blocks the turn.
+  if (typeof envelope.adapter?.buildThreadContext === "function") {
+    try {
+      const threadCtx = await envelope.adapter.buildThreadContext(envelope);
+      if (threadCtx && threadCtx.contextBlock) {
+        prompt = `${threadCtx.contextBlock}\n\n${prompt}`;
+      }
+    } catch (e) {
+      console.error("router: buildThreadContext:", e.message);
+    }
+  }
+
   return runAgent(prompt, runContext.cwd, envelope.messageId, {
     runContext,
     imagePaths,

package/core/run-context.js

@@ -2,6 +2,7 @@
 
 const crypto = require("crypto");
 const path = require("path");
+const { currentConversationKey } = require("./context");
 
 function cloneSerializable(value, label = "run context value") {
   if (value === undefined) return undefined;
@@ -23,7 +24,18 @@ function deepFreeze(value, seen = new Set()) {
 }
 
 function projectSnapshot(state, cwd, requestedProject) {
-  const value = requestedProject !== undefined ? requestedProject : state.currentSession;
+  let value = requestedProject;
+  if (value === undefined) {
+    // No explicit project ⇒ this is a live chat turn: key the conversation
+    // (provider session) by the per-thread conversation key so each surface
+    // keeps its own session. dir stays the workspace root. Outside a turn
+    // (background jobs, tests) there is no conversation key ⇒ fall back to the
+    // shared currentSession, preserving prior behaviour byte-for-byte.
+    const convo = currentConversationKey();
+    value = convo
+      ? { name: convo, dir: state.currentSession?.dir || cwd || null }
+      : state.currentSession;
+  }
   if (value && typeof value === "object") {
     const dir = value.dir || value.path || cwd || null;
     return {
@@ -146,7 +158,13 @@ function sameCapturedProject(state, runContext) {
   const live = state?.currentSession;
   const captured = runContext?.project;
   if (!live || !captured) return !live && !captured;
-  return String(live.name || "") === String(captured.name || "")
+  // "Same project" now means "same live conversation thread". Compare the
+  // captured key against the live conversation key (falling back to the shared
+  // currentSession name outside a chat turn), so a run that resumes/compacts is
+  // matched to the thread it was admitted on — not to whichever thread most
+  // recently touched the shared currentSession.
+  const liveName = currentConversationKey() || live.name || "";
+  return String(liveName) === String(captured.name || "")
     && String(live.dir || live.path || "") === String(captured.dir || captured.path || "");
 }
 

package/core/runner.js

@@ -1836,9 +1836,12 @@ function createForegroundService({ state, store, stopTyping, capture, ownsAdmiss
   return service;
 }
 
-async function handoffMemoryReview(result, runContext, store) {
+async function handoffMemoryReview(result, runContext, store, state) {
   if (!result.ok || !result.text || runContext.purpose !== "foreground") return;
   const recall = result.recallMetadata || {};
+  // Memory is always written; the chat announcement of what was jotted is a
+  // /recall-gated debug surface — silent unless the owner turned recall on.
+  const showRecall = !!state?.settings?.showRecall;
   packReview.reviewTurn({
     userText: runContext.userPrompt,
     assistantText: result.text,
@@ -1853,7 +1856,7 @@ async function handoffMemoryReview(result, runContext, store) {
         return speaker ? { name: speaker.name, isOwner: !!speaker.isOwner } : null;
       } catch (_) { return null; }
     })(),
-    announce: (text) => chatContext.run(store, () => send(text)),
+    announce: showRecall ? (text) => chatContext.run(store, () => send(text)) : null,
   });
 }
 
@@ -1916,7 +1919,7 @@ async function executeAdmittedRun(runContext, state, store, capture, ownsAdmissi
   if (!capture && service.turnObserver && runContext.purpose === "foreground") {
     try { service.turnObserver.onTurnSettled(!!result.ok); } catch (e) { /* best-effort */ }
   }
-  if (!internalCapture) await handoffMemoryReview(result, runContext, store);
+  if (!internalCapture) await handoffMemoryReview(result, runContext, store, state);
   if (!internalCapture && state.settings?.backend === runContext.provider && state.settings.budget) {
     state.settings.budget = null;
     try { saveState({ strict: true }); }

package/core/scheduler.js

@@ -328,6 +328,10 @@ function createSchedulerService(dependencies = {}) {
       userId,
       transport: adapter.type,
       raw: null,
+      // Key the resumed conversation by the job's saved thread, not the live
+      // shared session. Matches captured project.name (projectDescriptor(job).name)
+      // so sameCapturedProject / getProjectKey resolve the right thread mid-run.
+      conversationKey: projectDescriptor(job).name,
     };
 
     return runInChat(chat, async () => {

package/core/state.js

@@ -20,7 +20,7 @@ const {
   channelKey,
   identities,
 } = require("./identity");
-const { currentChannelId, currentCanonicalUserId } = require("./context");
+const { currentChannelId, currentCanonicalUserId, currentConversationKey } = require("./context");
 const { atomicWriteFileSync, readJsonWithFallback } = require("./fsutil");
 const {
   defaultMigrationSources,
@@ -385,7 +385,16 @@ function getActiveProvider(state) {
 }
 
 function getProjectKey(state, projectName) {
-  return projectNameFrom(projectName === undefined ? state?.currentSession : projectName);
+  if (projectName !== undefined) return projectNameFrom(projectName);
+  // Conversation-per-thread: with no explicit project the caller means "the
+  // current thread", whose key is the live conversation key — so each surface
+  // (Telegram DM, Spaces task, Kazee chat) owns a separate provider session and
+  // usage bucket, even when they resolve to one unified canonical speaker.
+  // Outside a chat turn (background jobs, CLI, tests) there is no conversation
+  // key, so we fall back to currentSession — byte-identical to prior behaviour.
+  const convo = currentConversationKey();
+  if (convo) return convo;
+  return projectNameFrom(state?.currentSession);
 }
 
 function getProviderSession(state, providerId, projectName) {
@@ -558,6 +567,48 @@ function createUserState(userId) {
   return state;
 }
 
+// Carry the legacy shared "Workspace" conversation into its per-thread key on
+// the channel that owns it, so moving to conversation-per-thread keying never
+// resets a live conversation. In-memory + non-destructive: the "Workspace"
+// bucket is copied (not moved) and the natural post-run save persists it, so a
+// restart before that save simply re-seeds deterministically. Only the "home"
+// channel — the one whose raw identity equals this state's canonical — inherits
+// it; secondary unified channels (the owner's Spaces task) start clean, which
+// is the whole point (they must not resume another thread's session).
+function seedConversationContinuity(state) {
+  const convo = currentConversationKey();
+  if (!convo || convo === "Workspace") return;
+  if (normalizeCanonicalUserId(convo) !== normalizeCanonicalUserId(state.userId)) return;
+  if (!isRecord(state.activeSessions)) return;
+  const legacy = state.activeSessions.Workspace;
+  if (!isRecord(legacy) || isRecord(state.activeSessions[convo])) return;
+  state.activeSessions[convo] = { ...legacy };
+  if (isRecord(state.usageBySession)) {
+    const prefix = "Workspace";
+    for (const [key, usage] of Object.entries(state.usageBySession)) {
+      if (key.startsWith(prefix) && isRecord(usage)) {
+        const moved = `${convo}${key.slice(prefix.length)}`;
+        if (!state.usageBySession[moved]) state.usageBySession[moved] = { ...usage };
+      }
+    }
+    state.usageBySession = boundUsageBySession(state.usageBySession);
+  }
+  // Carry the shared "Workspace" session history (sessions.json) into the
+  // per-thread key too, so /sessions listing and resume-ownership checks — both
+  // keyed by conversationKey — keep the home channel's existing conversations.
+  // Best-effort and run-once: reached only on the same first call that seeds
+  // activeSessions above (later calls early-return at the activeSessions guard).
+  try {
+    const uid = normalizeCanonicalUserId(state.userId);
+    const all = loadSessions();
+    const userSessions = all[uid];
+    if (isRecord(userSessions) && Array.isArray(userSessions.Workspace) && !userSessions[convo]) {
+      userSessions[convo] = userSessions.Workspace.map((record) => ({ ...record, project: convo }));
+      saveSessions(all, { strict: false });
+    }
+  } catch (e) {}
+}
+
 function getUserState(userId) {
   const id = normalizeCanonicalUserId(userId);
   if (!userStates.has(id)) userStates.set(id, createUserState(id));
@@ -571,6 +622,7 @@ function getUserState(userId) {
     }
   }
   state.channelId = currentChannelId() || state.channelId;
+  try { seedConversationContinuity(state); } catch (e) {}
   return state;
 }
 

package/core/turn-observer.js

@@ -32,6 +32,16 @@ function createTurnObserver({ state, store }) {
   try { guarded = chatContext.run(store, () => require("./relationship").isCurrentSpeakerGuarded()); }
   catch (e) { guarded = true; }
 
+  // Spaces is a customer-facing surface that renders neither Telegram HTML nor
+  // internal recall/tool banners meaningfully — a <b> banner shows the literal
+  // tags. Suppress all owner-only chat visibility there; memory + graph feeding
+  // still run, only the chat emissions are muted.
+  let suppressChatVisibility = false;
+  try {
+    const adapter = chatContext.run(store, () => currentAdapter());
+    suppressChatVisibility = adapter?.type === "spaces";
+  } catch (e) { suppressChatVisibility = false; }
+
   const packsLib = require("./packs");
   const entitiesLib = require("./entities");
   const toolsLib = require("./tools");
@@ -40,7 +50,7 @@ function createTurnObserver({ state, store }) {
   // Deduped per turn: a node touched twice announces once.
   const notified = new Set();
   const notify = (key, text, opts) => {
-    if (guarded) return;
+    if (guarded || suppressChatVisibility) return;
     if (notified.has(key)) return;
     notified.add(key);
     try { chatContext.run(store, () => send(text, opts).catch(() => {})); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "3.0.20",
+  "version": "3.0.24",
   "description": "An always-on, provider-agnostic coding-agent harness for Claude Code and OpenAI Codex via chat",
   "main": "bot.js",
   "bin": {

package/test-provider-gateway.js

@@ -404,6 +404,7 @@ function queueProbe() {
     currentChannelId: () => store.channelId,
     currentAdapter: () => store.adapter,
     currentUserId: () => store.userId,
+    currentConversationKey: () => store.conversationKey || null,
   });
   installStub("./core/io", {
     send: async () => ({ ok: true, messageId: "queued", editable: true }),

package/test-provider-language.js

@@ -32,14 +32,16 @@ assert.doesNotMatch(setup, /Your Claude Code bot is connected|Description=Claude
 
 const pkg = JSON.parse(read("package.json"));
 assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
-// 3.0.20 approved by Sumeet 2026-07-14 ("Yeh push it"): two Spaces fixes. (1)
-// The Spaces server emits PLURAL notification categories (mentions/comments/
-// reactions), so ENGAGE_TYPES now matches "mentions"/"replies" — matching only
-// singular "mention" silently dropped every real tag. (2) isConfiguredOwnerChannel
-// gained a "spaces" branch mapping to KAZEE_OWNER_USER_ID (Spaces principals are
-// central/Kazee ids), so the owner is no longer classed external (default-deny)
-// on their own Spaces comments. 3.0.19 flattened the folder-project model.
-assert.strictEqual(pkg.version, "3.0.20", "release version must remain unchanged without explicit approval");
+// 3.0.24 approved by Sumeet 2026-07-14: turn-context add-on (an engaged Spaces
+// turn gets task metadata + every comment since the bot's last reply, via the
+// channel-agnostic buildThreadContext() adapter seam the router prepends) PLUS
+// /recall now gates the "🧠 Jotted this down" memory-write announcements — memory
+// still writes every turn, the chat note only surfaces when /recall is on
+// (state.settings.showRecall), matching how the recall/tool banners already gate.
+// 3.0.23 shipped the turn-context work but its CI build failed on THIS gate
+// (package.json bumped without updating the assertion) — nothing published under
+// 3.0.23; 3.0.24 is the corrected re-ship (same pattern as 3.0.21 → 3.0.22).
+assert.strictEqual(pkg.version, "3.0.24", "release version must remain unchanged without explicit approval");
 for (const keyword of ["claude", "codex", "coding-agent", "provider-agnostic"]) {
   assert.ok(pkg.keywords.includes(keyword), `package keyword missing: ${keyword}`);
 }