@inetafrica/open-claudia 3.0.25 → 3.0.26

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # 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.

package/channels/spaces/adapter.js

@@ -202,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,
@@ -261,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,
@@ -473,15 +489,24 @@ 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;
     }

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.25",
+  "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,15 +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.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");
+// 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}`);
 }