@inetafrica/open-claudia 3.0.24 → 3.0.25

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## v3.0.25 — The bot types back on a Spaces task
+
+- **"Open Claudia is typing…" now shows on a Spaces task thread while the bot composes.** Core already runs a typing heartbeat around every agent turn (calling `adapter.typing()` every ~4s and `adapter.typingStop()` at turn-end); on Spaces those were no-op stubs. They now re-emit the exact `comment:typing` event a human client sends over the adapter's existing authenticated socket, so a teammate watching a task sees the bot compose like any other member — the same three-dot indicator the web and mobile apps already render.
+- **Part 4 of the cross-repo typing indicator.** The backend (`comment:typing` re-broadcast to the `space:<id>` room, identity stamped from the authenticated socket, no persistence), web, and mobile surfaces shipped in prior deploys — human↔human typing was already live end-to-end. This closes the loop so the bot participates too.
+- **Minimal by construction.** The adapter caches each task's `spaceId` (from the notification payload and the thread-context fetch) so the heartbeat — which only knows the `task:<id>` channel — can name the room. The emit sends just `targetId + spaceId + isTyping`; the server derives who is typing. Fully best-effort: no socket, no cached space, or a transport blip is a silent no-op, so a typing dot can never affect or delay the actual reply.
+- **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.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.

package/channels/spaces/adapter.js

@@ -59,6 +59,7 @@ class SpacesAdapter {
     this._socket = null;
     this._seen = new Set(); // notification-id dedup across socket + poll
     this._taskChains = new Map(); // taskId -> tail promise, for per-task serialization
+    this._taskSpace = new Map(); // taskId -> spaceId, so typing() can name the room
     this._pollTimer = null;
     this._initTimer = null;
   }
@@ -230,6 +231,10 @@ class SpacesAdapter {
     const n = this._normalize(payload);
     if (!n.taskId) return;
 
+    // Cache the task's space so typing() can address the space:<id> room later —
+    // the heartbeat only gets a channelId ("task:<id>"), not the spaceId.
+    if (n.spaceId) this._taskSpace.set(String(n.taskId), String(n.spaceId));
+
     // Receiving any Spaces notification proves membership → mark connected. This
     // is the socket half of the hybrid "connected ⇒ conversational" signal; no
     // env flag needed to turn auto-replies on.
@@ -317,6 +322,15 @@ class SpacesAdapter {
     try { task = await this.client.getTask(taskId); }
     catch (e) { task = null; }
 
+    // Cache the task's space for typing() — buildThreadContext runs at the very
+    // start of an engaged turn, before the typing heartbeat first fires.
+    if (task && typeof task === "object") {
+      const sid = task.spaceId && typeof task.spaceId === "object"
+        ? (task.spaceId.id || task.spaceId._id || null)
+        : (task.spaceId || null);
+      if (sid) this._taskSpace.set(String(taskId), String(sid));
+    }
+
     const lines = ["[Kazee Spaces thread context]"];
     lines.push(`Task: ${(task && task.title) || envelope.spaces?.title || "(untitled task)"}`);
 
@@ -473,13 +487,32 @@ class SpacesAdapter {
     }
   }
 
-  // Spaces has no per-thread bot typing indicator, and comment edit/delete are
-  // out of scope for v1. These keep the adapter contract total so core code can
-  // call them unconditionally.
+  // Comment edit/delete are out of scope for v1. These keep the adapter contract
+  // total so core code can call them unconditionally.
   async edit() { /* not supported */ }
   async delete() { /* not supported */ }
-  async typing() { /* no-op */ }
-  async typingStop() { /* no-op */ }
+
+  // Ephemeral "Open Claudia is typing…" on the task thread. Core's typing
+  // heartbeat (runner.js) calls typing() every ~4s during a run and typingStop()
+  // at turn-end; we re-emit the same comment:typing event a human client sends,
+  // so teammates watching the thread see the bot compose like anyone else. The
+  // backend stamps identity from the authenticated socket and re-broadcasts to
+  // space:<id> (excluding us), so we only send targetId + spaceId + isTyping.
+  // Best-effort: no socket, no cached space, or a transport blip is silently a
+  // no-op — a typing dot must never affect the actual reply.
+  async typing(channelId) { this._emitTyping(channelId, true); }
+  async typingStop(channelId) { this._emitTyping(channelId, false); }
+
+  _emitTyping(channelId, isTyping) {
+    try {
+      if (!this._socket?.connected) return;
+      const taskId = String(channelId || "").replace(/^task:/, "");
+      if (!taskId) return;
+      const spaceId = this._taskSpace.get(taskId);
+      if (!spaceId) return;
+      this._socket.emit("comment:typing", { targetType: "task", targetId: taskId, spaceId, isTyping: !!isTyping });
+    } catch (e) { /* typing is best-effort */ }
+  }
   async sendVoice() { return false; }
   async sendPhoto() { return false; }
   async sendFile() { return false; }

package/package.json

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

package/test-provider-language.js

@@ -32,16 +32,15 @@ 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.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");
+// 3.0.25 approved by Sumeet 2026-07-15 ("Ship it"): the bot now emits its own
+// comment:typing on a Spaces task thread. Core's typing heartbeat drives the
+// SpacesAdapter typing()/typingStop() (previously no-op stubs), which re-emit the
+// same ephemeral event a human client sends, so teammates watching a task see
+// "Open Claudia is typing…" while it composes a reply. Part 4 of the cross-repo
+// typing-indicator work (backend/web/mobile shipped in prior deploys); the
+// backend stamps identity from the authenticated socket and re-broadcasts to the
+// space room, so the adapter only sends targetId + spaceId + isTyping.
+assert.strictEqual(pkg.version, "3.0.25", "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}`);
 }