@inetafrica/open-claudia 3.0.24 → 3.0.26

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## v3.0.26 — Spaces replies actually post (and stop saying "Queued.")
+
+- **An engaged Spaces reply no longer fails with 400 "Parent comment not found."** Core threads every agent reply under the triggering message id — a Telegram-ism. On Spaces that id is a *notification* id, not a comment id, so the backend rejected the whole post and the bot silently failed to answer any mention. `send()` now only threads under an explicit `comment:`-prefixed id and otherwise posts a top-level task comment; if a stale/deleted parent still 400s, it retries once at top level so the reply always lands.
+- **The bot threads its reply under the exact comment it's answering.** When a notification names a specific comment (a reply's `replyId`, or a mention/comment that targets a comment), the reply is threaded under it instead of floating at the task root. Task-level mentions and assignments stay top-level, as before.
+- **No more "Queued." noise on a task thread.** The transient queue/compaction acknowledgement is a chat-UX affordance for Telegram/Kazee. On a Spaces task it posted a throwaway "Queued." comment when a second turn stacked (and, pre-fix, that post itself 400'd). Spaces now stays silent while queued and simply posts the real reply when its turn runs. Per-identity run serialization is unchanged and intended — one being, one hand.
+- **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.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;
   }
@@ -201,9 +202,22 @@ class SpacesAdapter {
       actorName = actorName || `${actorId.firstName || ""} ${actorId.lastName || ""}`.trim() || actorId.email;
       actorId = actorId.id || actorId._id;
     }
+    // The specific comment to thread a reply under, when the event is about one:
+    // a reply → the reply comment (replyId); a comment/mention that targets a
+    // comment → that comment id. Absent for task-level mentions and assignments,
+    // where the reply is a top-level task comment.
+    const commentId = String(
+      data.replyId || inner.replyId
+      || data.commentId || inner.commentId
+      || (data.targetType === "comment" ? data.targetId : "")
+      || (inner.targetType === "comment" ? inner.targetId : "")
+      || (payload.targetType === "comment" ? payload.targetId : "")
+      || "",
+    );
     return {
       type,
       taskId,
+      commentId,
       actorId: actorId ? String(actorId) : "",
       actorName: actorName || "",
       spaceId: payload.spaceId || inner.spaceId || null,
@@ -230,6 +244,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.
@@ -256,7 +274,10 @@ class SpacesAdapter {
       userId: n.actorId || n.taskId,
       type: "text",
       text: n.content || `[${n.type} on task ${n.title || n.taskId}]`,
-      messageId: id,
+      // Thread the bot's reply under the exact comment that triggered this engage
+      // (a reply, or a mention targeting a comment). Falls back to the
+      // notification id, which send() posts as a top-level task comment.
+      messageId: n.commentId ? `comment:${n.commentId}` : id,
       from: { id: n.actorId, name: n.actorName },
       spaces: { taskId: n.taskId, spaceId: n.spaceId, notificationType: n.type, deepLink: n.deepLink, title: n.title, mode: this._taskLoopMode() },
       raw: payload,
@@ -317,6 +338,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)"}`);
 
@@ -459,27 +489,55 @@ class SpacesAdapter {
   async send(channelId, text, opts = {}) {
     const taskId = String(channelId || "").replace(/^task:/, "");
     if (!taskId) { console.error("Spaces send: no taskId in channelId", channelId); return null; }
+    // Thread only under an EXPLICIT comment id (a "comment:"-prefixed replyTo,
+    // set on an engaged reply/comment-mention). Core's default replyTo is the
+    // triggering NOTIFICATION id, which is not a comment — threading under it
+    // 400s ("Parent comment not found"), so treat anything else as a top-level
+    // task comment.
+    const replyTo = String(opts.replyTo || "");
+    const parentId = replyTo.startsWith("comment:") ? replyTo.slice("comment:".length) : null;
+    const post = (parent) => this.client.createComment({ taskId, text, mentions: opts.mentions || [], parentId: parent });
+    const idOf = (c) => (c && (c._id || c.id) ? String(c._id || c.id) : true);
     try {
-      const comment = await this.client.createComment({
-        taskId,
-        text,
-        mentions: opts.mentions || [],
-        parentId: opts.replyTo ? String(opts.replyTo).replace(/^comment:/, "") : null,
-      });
-      return comment && (comment._id || comment.id) ? String(comment._id || comment.id) : true;
+      return idOf(await post(parentId));
     } catch (e) {
+      // A stale/deleted parent 400s; retry once at top level so the reply always
+      // lands on the task rather than being dropped.
+      if (parentId && /parent comment not found/i.test(e.message || "")) {
+        try { return idOf(await post(null)); }
+        catch (e2) { console.error("Spaces send error (top-level retry):", e2.message); return null; }
+      }
       console.error("Spaces send error:", e.message);
       return null;
     }
   }
 
-  // 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/core/runner.js

@@ -1982,7 +1982,13 @@ function runAgent(prompt, cwd, replyToMsgId, opts = {}) {
     }
     const deferred = deferredRunResult();
     state.messageQueue.push({ runContext, store, deferred, queuedAt: Date.now() });
-    send(state.isCompacting ? "Compacting context, will pick this up next…" : "Queued.", { replyTo: replyToMsgId }).catch(() => {});
+    // Transient queue/compaction acks are a chat-UX affordance (Telegram/Kazee).
+    // On a Spaces task thread they'd post a throwaway "Queued." comment on the
+    // task — noise. Spaces stays quiet and just posts the real reply when its
+    // turn runs.
+    if (currentAdapter()?.type !== "spaces") {
+      send(state.isCompacting ? "Compacting context, will pick this up next…" : "Queued.", { replyTo: replyToMsgId }).catch(() => {});
+    }
     return deferred.promise;
   }
   return executeAdmittedRun(runContext, state, store, false, true);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "3.0.24",
+  "version": "3.0.26",
   "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,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.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.26 approved by Sumeet 2026-07-15: fix Spaces reply posting. (1) An engaged
+// reply no longer 400s — send() only threads under an explicit "comment:"-prefixed
+// id (the triggering reply/comment-mention) and otherwise posts a top-level task
+// comment, with a top-level retry if a stale parent 400s. (2) The bot threads its
+// reply under the exact triggering comment when the notification names one
+// (replyId / comment-target). (3) The transient "Queued." ack is suppressed on
+// Spaces — a stacked turn stays silent and just posts the real reply when it runs,
+// instead of dropping a throwaway "Queued." comment on the task. Builds on 3.0.25's
+// comment:typing emit.
+assert.strictEqual(pkg.version, "3.0.26", "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}`);
 }