claude-threads 0.16.4 → 0.16.6

package/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+- **Worktree context**: Replay first user prompt after mid-session worktree creation (`!worktree create`)
+- **Thread context prompt**: When starting a session mid-thread (replying to an existing thread), offers to include previous conversation context
+  - Shows options for last 3, 5, or 10 messages (only options that make sense for available message count)
+  - "All X messages" option when message count doesn't match standard options
+  - 30-second timeout defaults to no context
+  - Context is prepended to the initial prompt so Claude understands the conversation history
+
+### Fixed
+- **Plan mode approval**: Fixed API error "unexpected tool_use_id found in tool_result blocks" when approving plans
+  - Claude Code CLI handles ExitPlanMode internally; changed to send user message instead of duplicate tool_result
+- **Question reactions**: Fixed 2nd+ questions not responding to emoji reactions
+  - Follow-up question posts weren't registered for reaction routing
+- **Question answering**: Fixed duplicate tool_result when answering AskUserQuestion
+  - Claude Code CLI handles AskUserQuestion internally; changed to send user message
+- Session timeout warning showing negative minutes (e.g., "-24min")
+- Warning now fires 5 minutes before timeout instead of after 5 minutes idle
+- Stale sessions are now cleaned from persistence on startup
+
 ## [0.16.3] - 2025-12-31
 
 ### Fixed

package/dist/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 // @bun
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
@@ -13395,6 +13395,37 @@ class MattermostClient extends EventEmitter {
       return null;
     }
   }
+  async getThreadHistory(threadId, options) {
+    try {
+      const response = await this.api("GET", `/posts/${threadId}/thread`);
+      const messages = [];
+      for (const postId of response.order) {
+        const post = response.posts[postId];
+        if (!post)
+          continue;
+        if (options?.excludeBotMessages && post.user_id === this.botUserId) {
+          continue;
+        }
+        const user = await this.getUser(post.user_id);
+        const username = user?.username || "unknown";
+        messages.push({
+          id: post.id,
+          userId: post.user_id,
+          username,
+          message: post.message,
+          createAt: post.create_at
+        });
+      }
+      messages.sort((a, b) => a.createAt - b.createAt);
+      if (options?.limit && messages.length > options.limit) {
+        return messages.slice(-options.limit);
+      }
+      return messages;
+    } catch (err) {
+      console.error(`  \u26A0\uFE0F Failed to get thread history for ${threadId}:`, err);
+      return [];
+    }
+  }
   async connect() {
     await this.getBotUser();
     wsLogger.debug(`Bot user ID: ${this.botUserId}`);
@@ -14747,10 +14778,7 @@ function formatEvent(session, e, ctx) {
 async function handleExitPlanMode(session, toolUseId, ctx) {
   if (session.planApproved) {
     if (ctx.debug)
-      console.log("  \u21AA Plan already approved, sending acknowledgment");
-    if (session.claude.isRunning()) {
-      session.claude.sendToolResult(toolUseId, "Plan already approved. Proceeding.");
-    }
+      console.log("  \u21AA Plan already approved, letting CLI handle it");
     return;
   }
   if (session.pendingApproval && session.pendingApproval.type === "plan") {
@@ -14933,7 +14961,7 @@ async function handleQuestionReaction(session, postId, emojiName, username, ctx)
   if (session.pendingQuestionSet.currentIndex < questions.length) {
     await postCurrentQuestion(session, {
       debug: ctx.debug,
-      registerPost: () => {},
+      registerPost: ctx.registerPost,
       flush: async () => {},
       startTyping: ctx.startTyping,
       stopTyping: ctx.stopTyping,
@@ -14948,10 +14976,9 @@ async function handleQuestionReaction(session, postId, emojiName, username, ctx)
     }
     if (ctx.debug)
       console.log("  \u2705 All questions answered");
-    const toolUseId = session.pendingQuestionSet.toolUseId;
     session.pendingQuestionSet = null;
     if (session.claude.isRunning()) {
-      session.claude.sendToolResult(toolUseId, answersText);
+      session.claude.sendMessage(answersText);
       ctx.startTyping(session);
     }
   }
@@ -14963,7 +14990,7 @@ async function handleApprovalReaction(session, emojiName, username, ctx) {
   const isReject = isDenialEmoji(emojiName);
   if (!isApprove && !isReject)
     return;
-  const { postId, toolUseId } = session.pendingApproval;
+  const { postId } = session.pendingApproval;
   const shortId = session.threadId.substring(0, 8);
   console.log(`  ${isApprove ? "\u2705" : "\u274C"} Plan ${isApprove ? "approved" : "rejected"} (${shortId}\u2026) by @${username}`);
   try {
@@ -14977,8 +15004,8 @@ async function handleApprovalReaction(session, emojiName, username, ctx) {
     session.planApproved = true;
   }
   if (session.claude.isRunning()) {
-    const response = isApprove ? "Approved. Please proceed with the implementation." : "Please revise the plan. I would like some changes.";
-    session.claude.sendToolResult(toolUseId, response);
+    const message = isApprove ? "Plan approved! Please proceed with the implementation." : "Please revise the plan. I would like some changes.";
+    session.claude.sendMessage(message);
     ctx.startTyping(session);
   }
 }
@@ -18995,6 +19022,7 @@ async function startSession(options, username, replyToPostId, platformId, ctx) {
     ctx.sessions.delete(session.sessionId);
     return;
   }
+  session.firstPrompt = options.prompt;
   const shouldPrompt = await ctx.shouldPromptForWorktree(session);
   if (shouldPrompt) {
     session.queuedPrompt = options.prompt;
@@ -19004,6 +19032,13 @@ async function startSession(options, username, replyToPostId, platformId, ctx) {
     return;
   }
   const content = await ctx.buildMessageContent(options.prompt, session.platform, options.files);
+  const messageText = typeof content === "string" ? content : options.prompt;
+  if (replyToPostId) {
+    const contextOffered = await ctx.offerContextPrompt(session, messageText);
+    if (contextOffered) {
+      return;
+    }
+  }
   claude.sendMessage(content);
   ctx.persistSession(session);
 }
@@ -19072,7 +19107,8 @@ async function resumeSession(state, ctx) {
     worktreeInfo: state.worktreeInfo,
     pendingWorktreePrompt: state.pendingWorktreePrompt,
     worktreePromptDisabled: state.worktreePromptDisabled,
-    queuedPrompt: state.queuedPrompt
+    queuedPrompt: state.queuedPrompt,
+    firstPrompt: state.firstPrompt
   };
   ctx.sessions.set(sessionId, session);
   if (state.sessionStartPostId) {
@@ -19241,8 +19277,9 @@ function cleanupIdleSessions(timeoutMs, warningMs, ctx) {
       killSession(session, false, ctx);
       continue;
     }
-    if (idleMs > warningMs && !session.timeoutWarningPosted) {
-      const remainingMins = Math.round((timeoutMs - idleMs) / 60000);
+    const warningThresholdMs = timeoutMs - warningMs;
+    if (idleMs > warningThresholdMs && !session.timeoutWarningPosted) {
+      const remainingMins = Math.max(0, Math.round((timeoutMs - idleMs) / 60000));
       session.platform.createPost(`\u23F0 **Session idle** - will timeout in ~${remainingMins} minutes without activity`, session.threadId).catch(() => {});
       session.timeoutWarningPosted = true;
       console.log(`  \u23F0 Session (${shortId}\u2026) idle warning posted`);
@@ -19560,9 +19597,14 @@ async function createAndSwitchToWorktree(session, branch, username, options) {
     session.lastActivityAt = new Date;
     session.timeoutWarningPosted = false;
     options.persistSession(session);
-    if (wasPending && queuedPrompt && session.claude.isRunning()) {
-      session.claude.sendMessage(queuedPrompt);
-      options.startTyping(session);
+    if (session.claude.isRunning()) {
+      if (wasPending && queuedPrompt) {
+        session.claude.sendMessage(queuedPrompt);
+        options.startTyping(session);
+      } else if (!wasPending && session.firstPrompt) {
+        session.claude.sendMessage(session.firstPrompt);
+        options.startTyping(session);
+      }
     }
     console.log(`  \uD83C\uDF3F Session (${shortId}\u2026) switched to worktree ${branch} at ${shortWorktreePath}`);
   } catch (err) {
@@ -19655,6 +19697,117 @@ async function disableWorktreePrompt(session, username, persistSession) {
   await session.platform.createPost(`\u2705 Worktree prompts disabled for this session`, session.threadId);
 }
 
+// src/session/context-prompt.ts
+var CONTEXT_PROMPT_TIMEOUT_MS = 30000;
+var CONTEXT_OPTIONS = [3, 5, 10];
+async function getThreadContextCount(session, excludePostId) {
+  try {
+    const messages = await session.platform.getThreadHistory(session.threadId, { excludeBotMessages: true });
+    const relevantMessages = excludePostId ? messages.filter((m) => m.id !== excludePostId) : messages;
+    return relevantMessages.length;
+  } catch {
+    return 0;
+  }
+}
+function getValidContextOptions(messageCount) {
+  return CONTEXT_OPTIONS.filter((opt) => opt <= messageCount);
+}
+async function postContextPrompt(session, queuedPrompt, messageCount, registerPost, onTimeout) {
+  const validOptions = getValidContextOptions(messageCount);
+  let optionsText = "";
+  const reactionOptions = [];
+  for (let i = 0;i < validOptions.length; i++) {
+    const opt = validOptions[i];
+    const emoji = ["1\uFE0F\u20E3", "2\uFE0F\u20E3", "3\uFE0F\u20E3"][i];
+    optionsText += `${emoji} Last ${opt} messages
+`;
+    reactionOptions.push(NUMBER_EMOJIS[i]);
+  }
+  if (validOptions.length === 0 || messageCount > validOptions[validOptions.length - 1]) {
+    const nextIndex = validOptions.length;
+    if (nextIndex < 3) {
+      const emoji = ["1\uFE0F\u20E3", "2\uFE0F\u20E3", "3\uFE0F\u20E3"][nextIndex];
+      optionsText += `${emoji} All ${messageCount} messages
+`;
+      reactionOptions.push(NUMBER_EMOJIS[nextIndex]);
+    }
+  }
+  optionsText += `\u274C No context (default after 30s)`;
+  reactionOptions.push(DENIAL_EMOJIS[0]);
+  const message = `\uD83E\uDDF5 **Include thread context?**
+` + `This thread has ${messageCount} message${messageCount === 1 ? "" : "s"} before this point.
+` + `React to include previous messages, or continue without context.
+
+` + optionsText;
+  const post = await session.platform.createInteractivePost(message, reactionOptions, session.threadId);
+  registerPost(post.id, session.threadId);
+  const timeoutId = setTimeout(onTimeout, CONTEXT_PROMPT_TIMEOUT_MS);
+  const availableOptions = [...validOptions];
+  if (validOptions.length === 0 || messageCount > validOptions[validOptions.length - 1]) {
+    if (validOptions.length < 3) {
+      availableOptions.push(messageCount);
+    }
+  }
+  return {
+    postId: post.id,
+    queuedPrompt,
+    threadMessageCount: messageCount,
+    createdAt: Date.now(),
+    timeoutId,
+    availableOptions
+  };
+}
+function getContextSelectionFromReaction(emojiName, availableOptions) {
+  const numberIndex = getNumberEmojiIndex(emojiName);
+  if (numberIndex >= 0 && numberIndex < availableOptions.length) {
+    return availableOptions[numberIndex];
+  }
+  if (isDenialEmoji(emojiName)) {
+    return 0;
+  }
+  if (emojiName === "x") {
+    return 0;
+  }
+  return null;
+}
+async function getThreadMessagesForContext(session, limit, excludePostId) {
+  const messages = await session.platform.getThreadHistory(session.threadId, { limit, excludeBotMessages: true });
+  return excludePostId ? messages.filter((m) => m.id !== excludePostId) : messages;
+}
+function formatContextForClaude(messages) {
+  if (messages.length === 0)
+    return "";
+  const lines = ["[Previous conversation in this thread:]", ""];
+  for (const msg of messages) {
+    const content = msg.message.length > 500 ? msg.message.substring(0, 500) + "..." : msg.message;
+    lines.push(`@${msg.username}: ${content}`);
+  }
+  lines.push("", "---", "", "[Current request:]");
+  return lines.join(`
+`);
+}
+async function updateContextPromptPost(session, postId, selection, username) {
+  let message;
+  if (selection === "timeout") {
+    message = "\u23F1\uFE0F Continuing without context (no response)";
+  } else if (selection === "skip" || selection === 0) {
+    message = username ? `\u2705 Continuing without context (skipped by @${username})` : "\u2705 Continuing without context";
+  } else {
+    message = username ? `\u2705 Including last ${selection} messages (selected by @${username})` : `\u2705 Including last ${selection} messages`;
+  }
+  try {
+    await session.platform.updatePost(postId, message);
+  } catch (err) {
+    console.error("  \u26A0\uFE0F Failed to update context prompt post:", err);
+  }
+}
+function clearContextPromptTimeout(pending) {
+  if (pending.timeoutId) {
+    clearTimeout(pending.timeoutId);
+    pending.timeoutId = undefined;
+  }
+}
+
 // src/session/types.ts
 var MAX_SESSIONS = parseInt(process.env.MAX_SESSIONS || "5", 10);
 var SESSION_TIMEOUT_MS = parseInt(process.env.SESSION_TIMEOUT_MS || "1800000", 10);
@@ -19720,7 +19873,8 @@ class SessionManager {
       updateSessionHeader: (s) => this.updateSessionHeader(s),
       shouldPromptForWorktree: (s) => this.shouldPromptForWorktree(s),
       postWorktreePrompt: (s, r) => this.postWorktreePrompt(s, r),
-      buildMessageContent: (t, p, f) => this.buildMessageContent(t, p, f)
+      buildMessageContent: (t, p, f) => this.buildMessageContent(t, p, f),
+      offerContextPrompt: (s, q) => this.offerContextPrompt(s, q)
     };
   }
   getEventContext() {
@@ -19738,7 +19892,8 @@ class SessionManager {
       debug: this.debug,
       startTyping: (s) => this.startTyping(s),
       stopTyping: (s) => this.stopTyping(s),
-      updateSessionHeader: (s) => this.updateSessionHeader(s)
+      updateSessionHeader: (s) => this.updateSessionHeader(s),
+      registerPost: (pid, tid) => this.registerPost(pid, tid)
     };
   }
   getCommandContext() {
@@ -19785,6 +19940,10 @@ class SessionManager {
       await handleWorktreeSkip(session, username, (s) => this.persistSession(s), (s) => this.startTyping(s));
       return;
     }
+    if (session.pendingContextPrompt?.postId === postId) {
+      await this.handleContextPromptReaction(session, emojiName, username);
+      return;
+    }
     if (session.sessionStartPostId === postId) {
       if (isCancelEmoji(emojiName)) {
         await cancelSession(session, username, this.getCommandContext());
@@ -19808,6 +19967,74 @@ class SessionManager {
       return;
     }
   }
+  async handleContextPromptReaction(session, emojiName, username) {
+    if (!session.pendingContextPrompt)
+      return;
+    const selection = getContextSelectionFromReaction(emojiName, session.pendingContextPrompt.availableOptions);
+    if (selection === null)
+      return;
+    const pending = session.pendingContextPrompt;
+    clearContextPromptTimeout(pending);
+    await updateContextPromptPost(session, pending.postId, selection, username);
+    const queuedPrompt = pending.queuedPrompt;
+    session.pendingContextPrompt = undefined;
+    let messageToSend = queuedPrompt;
+    if (selection > 0) {
+      const messages = await getThreadMessagesForContext(session, selection, pending.postId);
+      if (messages.length > 0) {
+        const contextPrefix = formatContextForClaude(messages);
+        messageToSend = contextPrefix + queuedPrompt;
+      }
+    }
+    if (session.claude.isRunning()) {
+      session.claude.sendMessage(messageToSend);
+      this.startTyping(session);
+    }
+    this.persistSession(session);
+    if (this.debug) {
+      const shortId = session.threadId.substring(0, 8);
+      console.log(`  \uD83E\uDDF5 Session (${shortId}\u2026) context selection: ${selection === 0 ? "none" : `last ${selection} messages`} by @${username}`);
+    }
+  }
+  async handleContextPromptTimeout(session) {
+    if (!session.pendingContextPrompt)
+      return;
+    const pending = session.pendingContextPrompt;
+    await updateContextPromptPost(session, pending.postId, "timeout");
+    const queuedPrompt = pending.queuedPrompt;
+    session.pendingContextPrompt = undefined;
+    if (session.claude.isRunning()) {
+      session.claude.sendMessage(queuedPrompt);
+      this.startTyping(session);
+    }
+    this.persistSession(session);
+    if (this.debug) {
+      const shortId = session.threadId.substring(0, 8);
+      console.log(`  \uD83E\uDDF5 Session (${shortId}\u2026) context prompt timed out, continuing without context`);
+    }
+  }
+  async offerContextPrompt(session, queuedPrompt) {
+    const messageCount = await getThreadContextCount(session);
+    if (messageCount === 0) {
+      if (session.claude.isRunning()) {
+        session.claude.sendMessage(queuedPrompt);
+        this.startTyping(session);
+      }
+      return false;
+    }
+    const pending = await postContextPrompt(session, queuedPrompt, messageCount, (pid, tid) => this.registerPost(pid, tid), () => this.handleContextPromptTimeout(session));
+    session.pendingContextPrompt = pending;
+    this.persistSession(session);
+    if (this.debug) {
+      const shortId = session.threadId.substring(0, 8);
+      console.log(`  \uD83E\uDDF5 Session (${shortId}\u2026) context prompt posted (${messageCount} messages available)`);
+    }
+    return true;
+  }
+  hasPendingContextPrompt(threadId) {
+    const session = this.findSessionByThreadId(threadId);
+    return session?.pendingContextPrompt !== undefined;
+  }
   handleEvent(sessionId, event) {
     const session = this.sessions.get(sessionId);
     if (!session)
@@ -19855,6 +20082,16 @@ class SessionManager {
     this.stopTyping(session);
   }
   persistSession(session) {
+    let persistedContextPrompt;
+    if (session.pendingContextPrompt) {
+      persistedContextPrompt = {
+        postId: session.pendingContextPrompt.postId,
+        queuedPrompt: session.pendingContextPrompt.queuedPrompt,
+        threadMessageCount: session.pendingContextPrompt.threadMessageCount,
+        createdAt: session.pendingContextPrompt.createdAt,
+        availableOptions: session.pendingContextPrompt.availableOptions
+      };
+    }
     const state = {
       platformId: session.platformId,
       threadId: session.threadId,
@@ -19872,7 +20109,9 @@ class SessionManager {
       worktreeInfo: session.worktreeInfo,
       pendingWorktreePrompt: session.pendingWorktreePrompt,
       worktreePromptDisabled: session.worktreePromptDisabled,
-      queuedPrompt: session.queuedPrompt
+      queuedPrompt: session.queuedPrompt,
+      firstPrompt: session.firstPrompt,
+      pendingContextPrompt: persistedContextPrompt
     };
     this.sessionStore.save(session.sessionId, state);
   }
@@ -19883,6 +20122,10 @@ class SessionManager {
     await updateSessionHeader(session, this.getCommandContext());
   }
   async initialize() {
+    const staleIds = this.sessionStore.cleanStale(SESSION_TIMEOUT_MS * 2);
+    if (staleIds.length > 0) {
+      console.log(`  \uD83E\uDDF9 Cleaned ${staleIds.length} stale session(s) from persistence`);
+    }
     const persisted = this.sessionStore.load();
     if (persisted.size === 0)
       return;

package/dist/mcp/permission-server.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 // @bun
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-threads",
-  "version": "0.16.4",
+  "version": "0.16.6",
   "description": "Share Claude Code sessions live in a Mattermost channel with interactive features",
   "main": "dist/index.js",
   "type": "module",