claude-threads 1.36.0 → 1.36.1

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.36.1] - 2026-09-10
+
+### Fixed
+- **An answer given before the option emojis finish landing is no longer lost.** A question or plan-approval post goes up first, then its 1️⃣/2️⃣ (or 👍/👎) options are added one API round trip at a time. The post is already visible and reactable for that whole window, but the bot only claimed it afterwards: `MessageManager` registered the post id in the session's reaction index after `createInteractivePost` resolved, and `QuestionApprovalExecutor` recorded `currentPostId` / `pendingApproval` at the same late moment. A reaction arriving in between matched nothing and was discarded silently, with no retry and no fallback. On a modern CLI, where `AskUserQuestion` and `ExitPlanMode` block on the MCP permission prompt, the cost is not a missed click: the decision bridge stays parked and the session hangs until `MCP_TOOL_TIMEOUT` (an hour by default) on a decision the user already made. Both the post id and the executor's pending state are now claimed in a pre-reaction callback, before the first option emoji is sent. The same ordering is fixed for every reaction-gated prompt that goes through `postInteractiveAndRegister` (worktree prompts, message approvals, update prompts, bug reports, routine and watch confirmations). Whoever reacts fastest was most likely to lose their answer, and a loaded host widened the window enough to make it reproducible.
+- **A reaction that beats the bot's own create response survives too.** Claiming the post id before the option emojis go out closes only the second half of the race. The platform starts accepting reactions the instant it stores the post, which is earlier still than the `POST /posts` response getting back to the bot, so on a slow or contended link a user can answer before the bot has any idea the post exists. The reaction arrives as a live websocket push and is never re-delivered, so `findByPost` dropped it for good and the session hung on the decision bridge exactly as before. A thread now announces an interactive-post create before issuing it, and a reaction on an unknown post id waits (up to 5s) for that registration instead of being discarded. The wait applies only while a create is genuinely outstanding: a reaction on any unrelated post still returns immediately, so nothing else pays for it.
+
 ## [1.36.0] - 2026-09-10
 
 ### Added

package/dist/index.js

@@ -53278,15 +53278,21 @@ async function postError(session, message, addBugReaction = true) {
   }
   return result;
 }
-async function postInteractive(session, message, reactions) {
-  const post = await session.platform.createInteractivePost(message, reactions, session.threadId);
-  updateLastMessage(session, post);
-  return post;
+async function postInteractive(session, message, reactions, onPostCreated) {
+  const doneInFlight = typeof session.messageManager?.markInteractivePostInFlight === "function" ? session.messageManager.markInteractivePostInFlight() : () => {};
+  try {
+    const post = await session.platform.createInteractivePost(message, reactions, session.threadId, (created) => {
+      onPostCreated?.(created);
+      doneInFlight();
+    });
+    updateLastMessage(session, post);
+    return post;
+  } finally {
+    doneInFlight();
+  }
 }
 async function postInteractiveAndRegister(session, message, reactions, registerPost) {
-  const post = await postInteractive(session, message, reactions);
-  registerPost(post.id, session.threadId);
-  return post;
+  return postInteractive(session, message, reactions, (created) => registerPost(created.id, session.threadId));
 }
 async function updatePost(session, postId, message) {
   await withErrorHandling(() => session.platform.updatePost(postId, message), { action: "Update post", session });
@@ -61156,16 +61162,26 @@ class QuestionApprovalExecutor extends BaseExecutor {
 
 ` + ctx.formatter.formatItalic("React to respond");
     }
+    let claimed = false;
     const post = await ctx.createInteractivePost(message, [APPROVAL_EMOJIS[0], DENIAL_EMOJIS[0]], {
       type: "plan_approval",
       interactionType: "plan_approval",
       toolUseId: op.toolUseId
+    }, (created) => {
+      claimed = true;
+      this.state.pendingApproval = {
+        postId: created.id,
+        type: op.approvalType,
+        toolUseId: op.toolUseId
+      };
     });
-    this.state.pendingApproval = {
-      postId: post.id,
-      type: op.approvalType,
-      toolUseId: op.toolUseId
-    };
+    if (!claimed) {
+      this.state.pendingApproval = {
+        postId: post.id,
+        type: op.approvalType,
+        toolUseId: op.toolUseId
+      };
+    }
     ctx.logger.debug(`Created ${op.approvalType} approval post ${formatShortId(post.id)}`);
   }
   async postCurrentQuestion(ctx) {
@@ -61191,13 +61207,21 @@ class QuestionApprovalExecutor extends BaseExecutor {
       message += `
 `;
     }
+    let claimed = false;
     const reactionOptions = NUMBER_EMOJIS.slice(0, q.options.length);
     const post = await ctx.createInteractivePost(message, reactionOptions, {
       type: "question",
       interactionType: "question",
       toolUseId: this.state.pendingQuestionSet.toolUseId
+    }, (created) => {
+      claimed = true;
+      if (this.state.pendingQuestionSet) {
+        this.state.pendingQuestionSet.currentPostId = created.id;
+      }
     });
-    this.state.pendingQuestionSet.currentPostId = post.id;
+    if (!claimed && this.state.pendingQuestionSet) {
+      this.state.pendingQuestionSet.currentPostId = post.id;
+    }
   }
   async handleQuestionAnswer(postId, optionIndex, ctx) {
     if (!this.state.pendingQuestionSet)
@@ -61881,6 +61905,7 @@ class MessageManager {
   worktreePath;
   worktreeBranch;
   registerPost;
+  beginInteractivePost;
   updateLastMessage;
   buildMessageContentCallback;
   startTypingCallback;
@@ -61902,6 +61927,7 @@ class MessageManager {
     this.worktreePath = options.worktreePath;
     this.worktreeBranch = options.worktreeBranch;
     this.registerPost = options.registerPost;
+    this.beginInteractivePost = options.beginInteractivePost;
     this.updateLastMessage = options.updateLastMessage;
     this.buildMessageContentCallback = options.buildMessageContent;
     this.startTypingCallback = options.startTyping;
@@ -62086,14 +62112,25 @@ class MessageManager {
         this.updateLastMessage(post);
         return post;
       },
-      createInteractivePost: async (content, reactions, options) => {
-        const post = await this.platform.createInteractivePost(content, reactions, this.threadId);
-        this.registerPost(post.id, options);
-        this.updateLastMessage(post);
-        return post;
+      createInteractivePost: async (content, reactions, options, onPostCreated) => {
+        const doneInFlight = this.beginInteractivePost?.(this.threadId);
+        try {
+          const post = await this.platform.createInteractivePost(content, reactions, this.threadId, (created) => {
+            this.registerPost(created.id, options);
+            doneInFlight?.();
+            onPostCreated?.(created);
+          });
+          this.updateLastMessage(post);
+          return post;
+        } finally {
+          doneInFlight?.();
+        }
       }
     };
   }
+  markInteractivePostInFlight() {
+    return this.beginInteractivePost?.(this.threadId) ?? (() => {});
+  }
   setWorktreeInfo(path, branch) {
     this.worktreePath = path;
     this.worktreeBranch = branch;
@@ -66727,6 +66764,60 @@ class SessionRegistry {
   }
   registerPost(postId, threadId) {
     this.postIndex.set(postId, threadId);
+    const waiters = this.pendingPostWaiters.get(postId);
+    if (waiters) {
+      this.pendingPostWaiters.delete(postId);
+      for (const resolve of waiters)
+        resolve();
+    }
+  }
+  inFlightInteractivePosts = new Map;
+  pendingPostWaiters = new Map;
+  hasInFlightInteractivePost() {
+    return this.inFlightInteractivePosts.size > 0;
+  }
+  beginInteractivePost(threadId) {
+    this.inFlightInteractivePosts.set(threadId, (this.inFlightInteractivePosts.get(threadId) ?? 0) + 1);
+    let done = false;
+    return () => {
+      if (done)
+        return;
+      done = true;
+      const depth = (this.inFlightInteractivePosts.get(threadId) ?? 1) - 1;
+      if (depth <= 0)
+        this.inFlightInteractivePosts.delete(threadId);
+      else
+        this.inFlightInteractivePosts.set(threadId, depth);
+    };
+  }
+  async awaitPendingPost(postId, timeoutMs) {
+    if (this.postIndex.has(postId))
+      return;
+    if (!this.hasInFlightInteractivePost())
+      return;
+    await new Promise((resolve) => {
+      const waiters = this.pendingPostWaiters.get(postId) ?? [];
+      let settled = false;
+      const finish = () => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(timer);
+        const list = this.pendingPostWaiters.get(postId);
+        if (list) {
+          const idx = list.indexOf(finish);
+          if (idx >= 0)
+            list.splice(idx, 1);
+          if (list.length === 0)
+            this.pendingPostWaiters.delete(postId);
+        }
+        resolve();
+      };
+      const timer = setTimeout(finish, timeoutMs);
+      timer.unref?.();
+      waiters.push(finish);
+      this.pendingPostWaiters.set(postId, waiters);
+    });
   }
   unregisterPost(postId) {
     this.postIndex.delete(postId);
@@ -67248,6 +67339,7 @@ function createMessageManager(session, ctx) {
       ctx.ops.registerPost(postId, session.threadId);
       postTracker.register(postId, session.threadId, session.sessionId, options);
     },
+    beginInteractivePost: (threadId) => ctx.ops.beginInteractivePost(threadId),
     updateLastMessage: (post) => {
       updateLastMessage(session, post);
     },
@@ -69846,8 +69938,9 @@ class BasePlatformClient extends EventEmitter3 {
   getBotName() {
     return this.botName;
   }
-  async createInteractivePost(message, reactions, threadId) {
+  async createInteractivePost(message, reactions, threadId, onPostCreated) {
     const post = await this.createPost(message, threadId);
+    onPostCreated?.(post);
     for (const emoji of reactions) {
       try {
         await this.addReaction(post.id, emoji);
@@ -72662,6 +72755,7 @@ function shouldPostResumeRefusal(platformId, threadId, username, now = Date.now(
 // src/session/reaction-router.ts
 init_logger();
 var log52 = createLogger("manager");
+var UNKNOWN_POST_GRACE_MS = 5000;
 async function handleReaction(deps, platformId, postId, emojiName, username, action) {
   const normalizedEmoji = normalizeEmojiName(emojiName);
   if (action === "added" && isResumeEmoji(normalizedEmoji)) {
@@ -72669,9 +72763,13 @@ async function handleReaction(deps, platformId, postId, emojiName, username, act
     if (resumed)
       return;
   }
-  const session = deps.registry.findByPost(postId);
-  if (!session)
-    return;
+  let session = deps.registry.findByPost(postId);
+  if (!session) {
+    await deps.registry.awaitPendingPost(postId, UNKNOWN_POST_GRACE_MS);
+    session = deps.registry.findByPost(postId);
+    if (!session)
+      return;
+  }
   if (session.platformId !== platformId)
     return;
   const ownerScoped = resolveApprovals(session.platform.approvals, isDcmThreadId(session.threadId)) === "owner";
@@ -72975,6 +73073,7 @@ class SessionManager extends EventEmitter4 {
       getSessionId: (pid, tid) => this.getSessionId(pid, tid),
       findSessionByThreadId: (tid) => this.findSessionByThreadId(tid),
       registerPost: (pid, tid) => this.registerPost(pid, tid),
+      beginInteractivePost: (tid) => this.registry.beginInteractivePost(tid),
       flush: async (s) => {
         if (s.messageManager) {
           await s.messageManager.flush();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-threads",
-  "version": "1.36.0",
+  "version": "1.36.1",
   "description": "Run Claude Code from Slack or Mattermost. Sessions stream live into threads where your whole team can watch and steer.",
   "main": "dist/index.js",
   "type": "module",