claude-threads 1.20.0 → 1.21.0

package/CHANGELOG.md

@@ -5,6 +5,37 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.21.0] - 2026-08-07
+
+### Fixed
+- **Task list display works again on modern Claude CLIs.** Claude Code moved task tracking from `TodoWrite` (whole list per call) to the incremental `TaskCreate`/`TaskUpdate` tools; verified against CLI 2.1.223, `TodoWrite` is never emitted anymore, so the bot's live task list in the thread had silently gone dark. A new per-session `TaskTracker` accumulates the incremental calls (a task's real id is only revealed by its tool result, which arrives later inside a `user` event) and feeds the existing task-list pipeline. `TaskUpdate` on an unknown id (tasks created before a resume, or by a subagent) shows a placeholder rather than nothing; `status: "deleted"` removes the task. `TodoWrite` still works for older CLIs. `TaskGet`/`TaskList` (read-only queries) are hidden from chat.
+- **Tool completion indicators (`↳ ✓` / `↳ ❌ Error`) fire again.** The real CLI delivers tool results as `tool_result` blocks inside `user` events; the bot only handled a legacy top-level `tool_result` event shape that modern CLIs never emit — so per-tool completion/error indicators, elapsed times, and the tool-completion flush never triggered. The transformer now processes `user` events. Indicators are only emitted for tools that were actually displayed (hidden tools like `TaskCreate` no longer risk orphaned indicators), and elapsed time works on the real event flow (start times were previously only recorded on the legacy shape). Bug-report context tracking (tool uses/errors) was extended to the real event shapes; the legacy shapes remain handled for old captures and test fixtures.
+- **Questions no longer trigger a duplicate permission prompt.** On modern CLIs `AskUserQuestion` routes through the `--permission-prompt-tool`, so next to the bot's proper question UI a generic "Permission requested: AskUserQuestion 👍✅👎" post appeared — and approving it just resolved the tool as unanswered. The MCP permission server now auto-allows `AskUserQuestion`; the question UI and reaction-answer flow are unchanged. Known limitation, verified on 2.1.223: with `--dangerously-skip-permissions` (bypass mode) the CLI does not expose `AskUserQuestion` at all, so bypass sessions cannot receive interactive questions — that is CLI behavior, not a bot regression. Also relevant: since CLI 2.1.200 an unanswered question no longer auto-continues after an idle timeout, which suits chat (users react late) — the previous auto-continue could race a slow reaction.
+
+### Added
+- **Structured rate-limit detection.** Modern CLIs emit a `rate_limit_event` with `rate_limit_info: {status, resetsAt, rateLimitType}` on every turn. The bot now feeds **`status: "rejected"`** events into the existing account-cooldown path (`resetsAt` epoch-seconds, sanity-bounded to at most 8 days out; slightly-past values from clock skew clamp to a brief cooldown), complementing the stderr phrase-scraping which remains for older CLIs. The predicate is strict equality on `rejected` — the SDK's status union is `allowed | allowed_warning | rejected`, and `allowed_warning` (~70%+ utilization, request went through) must not bench a healthy account: cooldowns only ever extend, so one warning would have parked the account until its weekly reset.
+- **The MCP plan-approval prompt now shows the plan.** On modern CLIs `ExitPlanMode` routes through the permission prompt; it used to render as a bare "Permission requested: ExitPlanMode" with no plan content. The prompt now carries the plan text (truncated at 1500 code points, with an unclosed code fence re-balanced so the reaction legend stays outside it; untruncated plans render exactly as authored). Known remaining conflict, left as follow-up work: the MCP prompt and the bot's plan-approval UI are two competing approval surfaces — reacting on the bot's UI alone lets the MCP prompt time out and deny the plan.
+
+### Hardening
+Three adversarial review rounds ran over this change; everything they confirmed is fixed here, with red-green tests.
+
+- **A resumed session can no longer lose its restored task list.** Task state is in-memory, so after a bot restart the resumed CLI session references task ids the fresh tracker has never seen. A single post-resume `TaskUpdate(completed)` created one completed placeholder, `allCompleted` fired on it, and the executor deleted the correctly-restored task-list post while reporting full completion. `allCompleted` now requires at least one task the tracker actually saw created, and a failed-create refresh on an empty tracker emits `update` (never `complete`) for the same reason. (Persisting tracker state across restarts, which would also restore full names instead of `Task #N` placeholders, is left as follow-up work.)
+- **Fresh-CLI restarts clear accumulated task state — safely.** `!cd` and worktree switches respawn Claude as a fresh session whose task numbering restarts at #1; stale `TaskTracker` entries would collide with the new ids and corrupt updates. `MessageManager.clearClaudeSessionState()` now runs on every `resume: false` respawn (resume restarts like `!permissions` keep their state). The respawn sites await the old process before clearing, and `kill()` was reworked to resolve on stdio close (late-buffered stream-json can arrive after `exit`) with an escalation to SIGKILL and a bounded timeout — previously a failed spawn or a SIGTERM-immune process could leave `kill()` pending forever, freezing the session in `restarting`.
+- **Failed `TaskCreate` calls no longer leave ghost tasks.** A create whose tool result is an error (or doesn't carry the expected "Task #N created" text — e.g. a future CLI rewording) removes the task and refreshes the display; previously it stayed forever as an un-updatable pending row that also pinned `allCompleted` at false. A non-error result with unexpected wording additionally logs a warning — that wording is the one CLI dependency whose drift would silently darken the task display again.
+- **Sidechain events are filtered everywhere.** Events carrying `parent_tool_use_id` (subagent activity forwarded by some CLI versions) no longer reach the transformer — a subagent's `TaskCreate`/`TaskUpdate` calls would otherwise permanently pollute the main thread's task list with colliding ids — and the event handlers apply the same filter: subagent text no longer executes `!cd`-style Claude commands against the main session, and subagent tool uses/errors no longer pollute bug-report context. PR-URL detection intentionally still sees subagent text.
+- **Task-list updates are coalesced per event.** A parallel burst of N `TaskCreate` calls in one assistant event — or N of their results failing in one `user` event — now yields one task-post update (the final snapshot) instead of N back-to-back `updatePost` calls that could trip platform rate limits.
+- **Rate-limit cooldown precision.** A reset-less hit (the 1-hour default guess) is ignored while a cooldown from an explicit reset time is running, so the guess can't stretch a known-shorter deadline — but reset-less repeats during a guess-based cooldown still extend it (the documented behavior), and an explicit reset that arrives too late to re-emit still records its explicitness so later guesses defer to it regardless of arrival order.
+- **Placeholder merge on late id resolution.** If a `TaskUpdate` for id N arrives before the corresponding create's result resolves that id, the placeholder and the real task are merged into one row (adopting the update's status and any rename) and the display refreshes immediately.
+- **Tracker robustness.** Numeric `taskId` values are coerced instead of silently freezing the displayed list; multi-MB tool results are no longer copied when no `TaskCreate` is pending; and a session mixing both task dialects no longer flip-flops — the full-list `TodoWrite` clears the incremental tracker.
+
+### Changed
+- **Verified against Claude CLI 2.1.223** (previously 2.1.116); suggested install version in error messages and onboarding updated. The compatible range is unchanged (`>=2.0.74 <2.2.0`).
+
+## [1.20.1] - 2026-08-06
+
+### Added
+- **"How it compares" section on the website and README** - A short, respectful comparison with the other ways to drive a coding agent from chat: Anthropic's own Claude Code in Slack / Claude Tag, OpenAI's Codex in Slack, Cursor in Slack, Cognition's Devin, and community Slack bots. The framing is a single axis — where the session runs (vendor cloud vs. your machine) — with claude-threads positioned as the local, self-hosted option that also speaks Mattermost. A closing note names the strongest differentiators beyond that: in-thread permission approvals, multiplayer sessions, the multi-account pool, and no GitHub assumption. The website's "Why I built this" note about Anthropic's integration was updated to match (it is no longer Enterprise-gated: Pro/Max plans have Claude Code in Slack, Team/Enterprise have Claude Tag).
+
 ## [1.20.0] - 2026-08-06
 
 ### Added

package/README.md

@@ -170,6 +170,27 @@ Restrict who can use the bot during setup, or reconfigure later with `claude-thr
 
 Who may do what (start sessions, react to permission prompts, approve guest messages) is written down in the [authorization model](https://github.com/anneschuth/claude-threads/blob/main/SECURITY.md).
 
+## How it compares
+
+Driving a coding agent from chat is a busy space: Anthropic, OpenAI, Cursor, and Cognition each ship their own integration, and other open-source projects exist too — several of them excellent. The main difference is where the session actually runs.
+
+| Product                                                                                                                              | Sessions run on                                             | Chat platforms                                  | Account                                       |
+| :----------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------- | :---------------------------------------------- | :-------------------------------------------- |
+| **claude-threads** (open source, Apache-2.0)                                                                                          | Your machine — local checkout, your MCP servers and plugins | Slack + Mattermost, multiple workspaces at once | Any Claude subscription or API key            |
+| [Claude Code in Slack](https://code.claude.com/docs/en/slack) / [Claude Tag](https://claude.com/docs/claude-tag/overview) (Anthropic) | Anthropic's cloud, against GitHub repos                     | Slack                                           | Claude Pro/Max; Claude Tag on Team/Enterprise |
+| [Codex in Slack](https://slack.com/marketplace/A09F5C369E3-openai-codex) (OpenAI)                                                     | OpenAI's Codex cloud                                        | Slack                                           | ChatGPT plan                                  |
+| [Cursor in Slack](https://cursor.com/docs/integrations/slack)                                                                         | Cursor's cloud agents                                       | Slack                                           | Cursor plan                                   |
+| [Devin](https://devin.ai/) (Cognition)                                                                                                | Cognition's cloud                                           | Slack (also Linear and Jira tickets)            | Devin plan                                    |
+| Community bots such as [claude-code-slack-bot](https://github.com/mpociot/claude-code-slack-bot)                                      | Your machine                                                | Slack                                           | Claude subscription or API key                |
+
+The cloud products share a working style: you delegate from a thread, the work runs in a vendor-hosted sandbox, and progress updates and a pull request come back — Claude Tag additionally stays in the conversation as a shared teammate the whole channel can talk to. If your repositories live on GitHub and you want nothing to host, they are a good choice; Anthropic's own integration in particular runs the same Claude Code this bot does.
+
+claude-threads makes the opposite choice: the whole session stays in the thread and on your hardware. Output streams live, permission prompts land as emoji reactions, invited teammates type into the same session, and Claude works against a local checkout with whatever MCP servers and plugins you already configured. That fit matters when chat is self-hosted Mattermost, when code cannot leave the building, or when you want a session in chat to behave exactly like the one at your desk. The trade-off: you run the bot yourself, on a machine that has the repository.
+
+A few more things set it apart. The full Claude Code permission model lives in the thread: every tool use can prompt for 👍/✅/👎 approval, with three modes switchable mid-session. Sessions are multiplayer: `!invite` teammates while Claude works, messages from uninvited users are gated behind approval, and commits credit everyone involved as co-author. An optional [account pool](https://github.com/anneschuth/claude-threads/blob/main/docs/CONFIGURATION.md#claude-accounts-optional-multi-account-mode) routes each new session to the Claude subscription with the most headroom and cools down rate-limited ones. And nothing assumes GitHub — the session works against any local checkout, whatever its host.
+
+This table is current as of August 2026. All of these products move quickly — if it has gone stale, [open an issue](https://github.com/anneschuth/claude-threads/issues).
+
 ## Documentation
 
 - **[Setup Guide](https://github.com/anneschuth/claude-threads/blob/main/SETUP_GUIDE.md)** - Creating the bot account on Mattermost or Slack, step by step

package/dist/index.js

@@ -51448,7 +51448,7 @@ function validateClaudeCli() {
       version: result.version,
       compatible: false,
       message: `Claude CLI version ${result.version} is not compatible. Required: ${CLAUDE_CLI_VERSION_RANGE}
-` + `Install a compatible version: npm install -g @anthropic-ai/claude-code@2.1.116`,
+` + `Install a compatible version: npm install -g @anthropic-ai/claude-code@2.1.223`,
       rawOutput: result.rawOutput ?? undefined
     };
   }
@@ -51698,7 +51698,7 @@ async function runOnboarding(reconfigure = false) {
       console.log(dim(`  ⚠️  Claude Code CLI ${claudeCheck.version} is not compatible`));
       console.log("");
       console.log(dim(`  Install a compatible version:`));
-      console.log(dim("    npm install -g @anthropic-ai/claude-code@2.1.1"));
+      console.log(dim("    npm install -g @anthropic-ai/claude-code@2.1.223"));
     } else {
       console.log(dim("  ⚠️  Claude Code CLI found but version could not be determined"));
       if (claudeCheck.rawOutput) {
@@ -55918,6 +55918,25 @@ function extractResetAt(text, now) {
   }
   return;
 }
+function parseRateLimitEvent(event, now = Date.now()) {
+  const info = event?.rate_limit_info;
+  if (!info || typeof info !== "object")
+    return { detected: false };
+  const { status, resetsAt } = info;
+  if (status !== "rejected")
+    return { detected: false };
+  const PAST_SKEW_TOLERANCE_MS = 2 * 60000;
+  let resetAtEpochMs;
+  if (typeof resetsAt === "number") {
+    const ms = resetsAt * 1000;
+    if (ms > now && ms - now < 8 * 86400000) {
+      resetAtEpochMs = ms;
+    } else if (ms <= now && now - ms < PAST_SKEW_TOLERANCE_MS) {
+      resetAtEpochMs = now + 60000;
+    }
+  }
+  return { detected: true, matched: `rate_limit_event status=${status}`, resetAtEpochMs };
+}
 
 // src/claude/cli.ts
 var log8 = createLogger("claude");
@@ -56054,6 +56073,7 @@ class ClaudeCli extends EventEmitter2 {
   stderrBuffer = "";
   mcpConfigTempFile = null;
   lastEmittedRateLimitDeadline = 0;
+  lastEmittedHitHadExplicitReset = false;
   log;
   constructor(options) {
     super();
@@ -56107,6 +56127,7 @@ class ClaudeCli extends EventEmitter2 {
     totalStderrBytes -= this.stderrBuffer.length;
     this.stderrBuffer = "";
     this.lastEmittedRateLimitDeadline = 0;
+    this.lastEmittedHitHadExplicitReset = false;
     cleanupBrowserBridgeSockets();
     const claudePath = getClaudePath();
     const args = [
@@ -56256,18 +56277,31 @@ class ClaudeCli extends EventEmitter2 {
         if (event.type === "result" && isErrorResultEvent(event)) {
           this.maybeEmitRateLimit(trimmed);
         }
+        if (event.type === "rate_limit_event") {
+          this.maybeEmitRateLimitHit(parseRateLimitEvent(event));
+        }
       } catch {}
     }
   }
   maybeEmitRateLimit(text) {
-    const hit = detectRateLimit(text);
+    this.maybeEmitRateLimitHit(detectRateLimit(text));
+  }
+  maybeEmitRateLimitHit(hit) {
     if (!hit.detected)
       return;
+    if (!hit.resetAtEpochMs && this.lastEmittedHitHadExplicitReset && this.lastEmittedRateLimitDeadline > Date.now()) {
+      return;
+    }
     const newDeadline = cooldownDeadline(hit);
     const MIN_ADVANCE_MS = 60000;
-    if (newDeadline - this.lastEmittedRateLimitDeadline < MIN_ADVANCE_MS)
+    if (newDeadline - this.lastEmittedRateLimitDeadline < MIN_ADVANCE_MS) {
+      if (hit.resetAtEpochMs !== undefined) {
+        this.lastEmittedHitHadExplicitReset = true;
+      }
       return;
+    }
     this.lastEmittedRateLimitDeadline = newDeadline;
+    this.lastEmittedHitHadExplicitReset = hit.resetAtEpochMs !== undefined;
     this.log.warn(`Rate limit detected: ${hit.matched ?? "(no match text)"}`);
     this.emit("rate-limit", hit);
   }
@@ -56322,12 +56356,22 @@ class ClaudeCli extends EventEmitter2 {
           proc.kill("SIGTERM");
         } catch {}
       }, 2000);
-      proc.once("exit", (code) => {
-        this.log.debug(`Claude process exited (code=${code})`);
+      const settle = (reason) => {
+        this.log.debug(`Claude process gone (${reason})`);
         clearTimeout(secondSigint);
         clearTimeout(forceKillTimeout);
+        clearTimeout(lastResort);
         resolve4();
-      });
+      };
+      const lastResort = setTimeout(() => {
+        try {
+          this.log.warn("Claude process did not exit after SIGTERM — sending SIGKILL");
+          proc.kill("SIGKILL");
+        } catch {}
+        settle("kill timeout");
+      }, 5000);
+      proc.once("close", (code) => settle(`closed, code=${code}`));
+      proc.once("error", () => settle("spawn error"));
     });
   }
   interrupt() {
@@ -63986,11 +64030,26 @@ var bashToolFormatter = {
 };
 // src/operations/tool-formatters/task-tools.ts
 var taskToolsFormatter = {
-  toolNames: ["TodoWrite", "Task", "EnterPlanMode", "ExitPlanMode", "AskUserQuestion"],
-  format(toolName, _input, options) {
+  toolNames: [
+    "TodoWrite",
+    "TaskCreate",
+    "TaskUpdate",
+    "TaskGet",
+    "TaskList",
+    "Task",
+    "EnterPlanMode",
+    "ExitPlanMode",
+    "AskUserQuestion"
+  ],
+  format(toolName, input, options) {
     const { formatter } = options;
     switch (toolName) {
       case "TodoWrite":
+      case "TaskCreate":
+      case "TaskUpdate":
+        return { display: null, hidden: true };
+      case "TaskGet":
+      case "TaskList":
         return { display: null, hidden: true };
       case "Task":
         return { display: null, hidden: true };
@@ -63999,8 +64058,25 @@ var taskToolsFormatter = {
           display: `\uD83D\uDCCB ${formatter.formatBold("Planning...")}`,
           permissionText: `\uD83D\uDCCB ${formatter.formatBold("Planning...")}`
         };
-      case "ExitPlanMode":
-        return { display: null, hidden: true };
+      case "ExitPlanMode": {
+        const plan = typeof input.plan === "string" ? input.plan : "";
+        const points = Array.from(plan);
+        const truncated = points.length > 1500;
+        let preview = truncated ? `${points.slice(0, 1500).join("")}
+…` : plan;
+        if (truncated) {
+          const fenceCount = (preview.match(/^```/gm) || []).length;
+          if (fenceCount % 2 === 1)
+            preview += "\n```";
+        }
+        return {
+          display: null,
+          hidden: true,
+          permissionText: preview ? `\uD83D\uDCCB ${formatter.formatBold("Plan approval requested")}
+
+${preview}` : `\uD83D\uDCCB ${formatter.formatBold("Plan approval requested")}`
+        };
+      }
       case "AskUserQuestion":
         return { display: null, hidden: true };
       default:
@@ -64539,9 +64615,14 @@ function createStatusUpdateOp(sessionId, options) {
 }
 // src/operations/transformer.ts
 function transformEvent(event, ctx) {
+  if (event.parent_tool_use_id) {
+    return [];
+  }
   switch (event.type) {
     case "assistant":
       return transformAssistant(event, ctx);
+    case "user":
+      return transformUser(event, ctx);
     case "tool_use":
       return transformToolUse(event, ctx);
     case "tool_result":
@@ -64583,6 +64664,9 @@ function transformAssistant(event, ctx) {
         if (result.display && !result.hidden) {
           flushTextBuffer();
           operations.push(createAppendContentOp(ctx.sessionId, result.display, true));
+          if (block.id) {
+            ctx.toolStartTimes.set(block.id, Date.now());
+          }
         }
       }
     } else if (block.type === "thinking" && block.thinking) {
@@ -64597,8 +64681,70 @@ function transformAssistant(event, ctx) {
     }
   }
   flushTextBuffer();
+  const taskListOps = operations.filter((op) => op.type === "task_list");
+  if (taskListOps.length > 1) {
+    const last = taskListOps[taskListOps.length - 1];
+    return operations.filter((op) => op.type !== "task_list" || op === last);
+  }
+  return operations;
+}
+function transformUser(event, ctx) {
+  const msg = event.message;
+  if (!Array.isArray(msg?.content)) {
+    return [];
+  }
+  const operations = [];
+  let indicatorCount = 0;
+  for (const block of msg.content) {
+    if (block?.type !== "tool_result" || !block.tool_use_id)
+      continue;
+    if (ctx.taskTracker.hasPendingCreate(block.tool_use_id)) {
+      const resolution = ctx.taskTracker.resolveCreatedId(block.tool_use_id, toolResultContentText(block.content), block.is_error === true);
+      if (resolution === "removed" || resolution === "merged") {
+        const action = ctx.taskTracker.allCompleted ? "complete" : "update";
+        operations.push(createTaskListOp(ctx.sessionId, action, ctx.taskTracker.toTaskItems()));
+      }
+    }
+    if (ctx.toolStartTimes.has(block.tool_use_id)) {
+      operations.push(createResultIndicatorOp(block.tool_use_id, block.is_error === true, ctx));
+      indicatorCount++;
+    }
+  }
+  const taskListOps = operations.filter((op) => op.type === "task_list");
+  if (taskListOps.length > 1) {
+    const last = taskListOps[taskListOps.length - 1];
+    const coalesced = operations.filter((op) => op.type !== "task_list" || op === last);
+    operations.length = 0;
+    operations.push(...coalesced);
+  }
+  if (indicatorCount > 0) {
+    operations.push(createFlushOp(ctx.sessionId, "tool_complete"));
+  }
   return operations;
 }
+function toolResultContentText(content) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    return content.map((b) => b && typeof b === "object" && typeof b.text === "string" ? b.text : "").join(`
+`);
+  }
+  return "";
+}
+function createResultIndicatorOp(toolUseId, isError, ctx) {
+  let elapsed = "";
+  const startTime = ctx.toolStartTimes.get(toolUseId);
+  if (startTime) {
+    const secs = Math.round((Date.now() - startTime) / 1000);
+    if (secs >= 3) {
+      elapsed = ` (${secs}s)`;
+    }
+    ctx.toolStartTimes.delete(toolUseId);
+  }
+  const icon = isError ? "❌" : "✓";
+  const errorNote = isError ? " Error" : "";
+  return createAppendContentOp(ctx.sessionId, `  ↳ ${icon}${errorNote}${elapsed}`, true);
+}
 function transformToolUse(event, ctx) {
   const tool = event.tool_use;
   if (tool.id) {
@@ -64623,23 +64769,10 @@ function transformToolResult(event, ctx) {
     return [];
   }
   const result = event.tool_result;
-  const operations = [];
-  let elapsed = "";
-  if (result.tool_use_id) {
-    const startTime = ctx.toolStartTimes.get(result.tool_use_id);
-    if (startTime) {
-      const secs = Math.round((Date.now() - startTime) / 1000);
-      if (secs >= 3) {
-        elapsed = ` (${secs}s)`;
-      }
-      ctx.toolStartTimes.delete(result.tool_use_id);
-    }
-  }
-  const icon = result.is_error ? "❌" : "✓";
-  const errorNote = result.is_error ? " Error" : "";
-  operations.push(createAppendContentOp(ctx.sessionId, `  ↳ ${icon}${errorNote}${elapsed}`, true));
-  operations.push(createFlushOp(ctx.sessionId, "tool_complete"));
-  return operations;
+  return [
+    createResultIndicatorOp(result.tool_use_id || "", result.is_error === true, ctx),
+    createFlushOp(ctx.sessionId, "tool_complete")
+  ];
 }
 function transformResult(event, ctx) {
   const operations = [];
@@ -64656,6 +64789,10 @@ function handleSpecialTool(toolName, toolUseId, input, ctx) {
   switch (toolName) {
     case "TodoWrite":
       return handleTodoWrite(input, ctx);
+    case "TaskCreate":
+      return handleTaskCreate(toolUseId, input, ctx);
+    case "TaskUpdate":
+      return handleTaskUpdate(input, ctx);
     case "Task":
       return handleTaskStart(toolUseId, input, ctx);
     case "AskUserQuestion":
@@ -64673,10 +64810,22 @@ function handleTodoWrite(input, ctx) {
     status: t.status,
     activeForm: t.activeForm
   }));
+  ctx.taskTracker.clear();
   const allCompleted = tasks.every((t) => t.status === "completed");
   const action = allCompleted ? "complete" : "update";
   return [createTaskListOp(ctx.sessionId, action, tasks)];
 }
+function handleTaskCreate(toolUseId, input, ctx) {
+  ctx.taskTracker.create(toolUseId, input);
+  return [createTaskListOp(ctx.sessionId, "update", ctx.taskTracker.toTaskItems())];
+}
+function handleTaskUpdate(input, ctx) {
+  const changed = ctx.taskTracker.update(input);
+  if (!changed)
+    return [];
+  const action = ctx.taskTracker.allCompleted ? "complete" : "update";
+  return [createTaskListOp(ctx.sessionId, action, ctx.taskTracker.toTaskItems())];
+}
 function handleTaskStart(toolUseId, input, ctx) {
   const description = input.description || input.prompt || "Subagent";
   const subagentType = input.subagent_type || "general-purpose";
@@ -64710,6 +64859,102 @@ function truncateAtWord2(text, maxLength) {
   }
   return truncated + "...";
 }
+// src/operations/task-tracker.ts
+var CREATED_RESULT_RE = /Task #(\S+) created/;
+
+class TaskTracker {
+  tasks = [];
+  pendingCreates = new Map;
+  unmatchedCreateResults = 0;
+  create(toolUseId, input) {
+    const task = {
+      subject: typeof input.subject === "string" ? input.subject : "Task",
+      activeForm: typeof input.activeForm === "string" ? input.activeForm : undefined,
+      status: "pending"
+    };
+    this.tasks.push(task);
+    if (toolUseId) {
+      this.pendingCreates.set(toolUseId, task);
+    }
+  }
+  hasPendingCreate(toolUseId) {
+    return this.pendingCreates.has(toolUseId);
+  }
+  resolveCreatedId(toolUseId, resultContent, isError = false) {
+    const task = this.pendingCreates.get(toolUseId);
+    if (!task)
+      return "ignored";
+    this.pendingCreates.delete(toolUseId);
+    const match = isError ? null : CREATED_RESULT_RE.exec(resultContent);
+    if (!match) {
+      if (!isError)
+        this.unmatchedCreateResults++;
+      this.tasks = this.tasks.filter((t) => t !== task);
+      return "removed";
+    }
+    const placeholder = this.tasks.find((t) => t !== task && t.taskId === match[1]);
+    if (placeholder) {
+      task.status = placeholder.status;
+      if (placeholder.subject !== `Task #${match[1]}`)
+        task.subject = placeholder.subject;
+      if (placeholder.activeForm && !task.activeForm)
+        task.activeForm = placeholder.activeForm;
+      this.tasks = this.tasks.filter((t) => t !== placeholder);
+    }
+    task.taskId = match[1];
+    return placeholder ? "merged" : "resolved";
+  }
+  consumeUnmatchedCreateResultFlag() {
+    if (this.unmatchedCreateResults === 0)
+      return false;
+    this.unmatchedCreateResults = 0;
+    return true;
+  }
+  update(input) {
+    const taskId = typeof input.taskId === "string" ? input.taskId : typeof input.taskId === "number" ? String(input.taskId) : undefined;
+    if (!taskId)
+      return false;
+    let task = this.tasks.find((t) => t.taskId === taskId);
+    const status = typeof input.status === "string" ? input.status : undefined;
+    if (status === "deleted") {
+      if (!task)
+        return false;
+      this.tasks = this.tasks.filter((t) => t !== task);
+      return true;
+    }
+    if (!task) {
+      task = { taskId, subject: `Task #${taskId}`, status: "pending", isPlaceholder: true };
+      this.tasks.push(task);
+    }
+    if (typeof input.subject === "string")
+      task.subject = input.subject;
+    if (typeof input.activeForm === "string")
+      task.activeForm = input.activeForm;
+    if (status === "pending" || status === "in_progress" || status === "completed") {
+      task.status = status;
+    }
+    return true;
+  }
+  toTaskItems() {
+    return this.tasks.map((t) => ({
+      content: t.subject,
+      status: t.status,
+      activeForm: t.activeForm ?? t.subject
+    }));
+  }
+  get isEmpty() {
+    return this.tasks.length === 0;
+  }
+  get allCompleted() {
+    return this.tasks.length > 0 && this.tasks.every((t) => t.status === "completed") && this.tasks.some((t) => !t.isPlaceholder);
+  }
+  clear() {
+    this.tasks = [];
+    this.pendingCreates.clear();
+    this.unmatchedCreateResults = 0;
+  }
+}
+
 // src/operations/executors/base.ts
 class BaseExecutor {
   state;
@@ -66462,6 +66707,7 @@ class MessageManager {
   startTypingCallback;
   emitSessionUpdateCallback;
   toolStartTimes = new Map;
+  taskTracker = new TaskTracker;
   flushTimer = null;
   static DEFAULT_FLUSH_DELAY_MS = 500;
   flushDelayMs;
@@ -66532,10 +66778,14 @@ class MessageManager {
       sessionId: this.sessionId,
       formatter: this.platform.getFormatter(),
       toolStartTimes: this.toolStartTimes,
+      taskTracker: this.taskTracker,
       detailed: true,
       worktreeInfo: this.worktreePath && this.worktreeBranch ? { path: this.worktreePath, branch: this.worktreeBranch } : undefined
     };
     const ops = transformEvent(event, transformCtx);
+    if (this.taskTracker.consumeUnmatchedCreateResultFlag()) {
+      logger.warn('TaskCreate result did not match the expected "Task #N created" wording — ' + "task dropped from the displayed list. If this repeats, the Claude CLI " + "likely changed its result text and the task display will be incomplete.");
+    }
     if (ops.length === 0) {
       if (event.type !== "system") {
         logger.debug(`No operations from event: ${event.type}`);
@@ -66919,9 +67169,14 @@ class MessageManager {
     logger.debug("Reaction not handled by any executor");
     return false;
   }
+  clearClaudeSessionState() {
+    this.toolStartTimes.clear();
+    this.taskTracker.clear();
+  }
   reset() {
     this.cancelScheduledFlush();
     this.toolStartTimes.clear();
+    this.taskTracker.clear();
     this.contentExecutor.reset();
     this.taskListExecutor.reset();
     this.questionApprovalExecutor.reset();
@@ -67957,7 +68212,7 @@ async function createAndSwitchToWorktree(session, branch, username, options) {
       if (session.claude.isRunning()) {
         options.stopTyping(session);
         transitionTo(session, "restarting");
-        session.claude.kill();
+        await session.claude.kill();
         await options.flush(session);
         const newSessionId = randomUUID2();
         session.claudeSessionId = newSessionId;
@@ -67977,6 +68232,7 @@ async function createAndSwitchToWorktree(session, branch, username, options) {
           resume: false,
           appendSystemPrompt: await buildAppendSystemPrompt(session.platform, session.platformId, existing.path, session.threadId, session.startedBy, session.sessionAllowedUsers, options.appendSystemPrompt ?? "", options.githubEmailsStore, { omitSessionContext: !needsTitlePrompt, userAttribution: session.userAttribution })
         };
+        session.messageManager?.clearClaudeSessionState();
         session.claude = new ClaudeCli(cliOptions);
         session.claude.on("event", (e) => options.handleEvent(session.sessionId, e));
         session.claude.on("exit", (code) => options.handleExit(session.sessionId, code));
@@ -68049,7 +68305,7 @@ ${fmt.formatItalic("Claude Code restarted in the worktree")}`);
     if (session.claude.isRunning()) {
       options.stopTyping(session);
       transitionTo(session, "restarting");
-      session.claude.kill();
+      await session.claude.kill();
       await options.flush(session);
       const newSessionId = randomUUID2();
       session.claudeSessionId = newSessionId;
@@ -68069,6 +68325,7 @@ ${fmt.formatItalic("Claude Code restarted in the worktree")}`);
         resume: false,
         appendSystemPrompt: await buildAppendSystemPrompt(session.platform, session.platformId, worktreePath, session.threadId, session.startedBy, session.sessionAllowedUsers, options.appendSystemPrompt ?? "", options.githubEmailsStore, { omitSessionContext: !needsTitlePrompt, userAttribution: session.userAttribution })
       };
+      session.messageManager?.clearClaudeSessionState();
       session.claude = new ClaudeCli(cliOptions);
       session.claude.on("event", (e) => options.handleEvent(session.sessionId, e));
       session.claude.on("exit", (code) => options.handleExit(session.sessionId, code));
@@ -68342,6 +68599,9 @@ function extractAndUpdatePullRequest(text, session, ctx) {
     ctx.ops.updateSessionHeader(session).catch(() => {});
   }
 }
+function isSidechainEvent(event) {
+  return Boolean(event.parent_tool_use_id);
+}
 function handleEventPreProcessing(session, event, ctx) {
   session.threadLogger?.logEvent(event);
   resetSessionActivity(session);
@@ -68363,6 +68623,16 @@ function handleEventPreProcessing(session, event, ctx) {
       handleCompactionComplete(session, e.compact_metadata, ctx);
     }
   }
+  if (event.type === "assistant" && !isSidechainEvent(event)) {
+    const msg = event.message;
+    if (Array.isArray(msg?.content)) {
+      for (const block of msg.content) {
+        if (block.type === "tool_use" && block.name) {
+          trackEvent(session, "tool_use", block.name);
+        }
+      }
+    }
+  }
   if (event.type === "tool_use") {
     const tool = event.tool_use;
     trackEvent(session, "tool_use", tool.name);
@@ -68374,7 +68644,9 @@ function handleEventPostProcessing(session, event, ctx) {
     for (const block of msg?.content || []) {
       if (block.type === "text" && block.text) {
         extractAndUpdatePullRequest(block.text, session, ctx);
-        detectAndExecuteClaudeCommands(block.text, session, ctx);
+        if (!isSidechainEvent(event)) {
+          detectAndExecuteClaudeCommands(block.text, session, ctx);
+        }
       }
     }
   }
@@ -68384,6 +68656,16 @@ function handleEventPostProcessing(session, event, ctx) {
     ctx.ops.emitSessionUpdate(session.sessionId, { status: getSessionStatus(session) });
     updateUsageStats(session, event, ctx);
   }
+  if (event.type === "user" && !isSidechainEvent(event)) {
+    const msg = event.message;
+    if (Array.isArray(msg?.content)) {
+      for (const block of msg.content) {
+        if (block.type === "tool_result" && block.is_error) {
+          trackEvent(session, "tool_error", "Tool execution failed");
+        }
+      }
+    }
+  }
   if (event.type === "tool_result") {
     const result = event.tool_result;
     if (result.is_error) {
@@ -68943,8 +69225,11 @@ function commonRestartCliOptions(session, ctx) {
 async function restartClaudeSession(session, cliOptions, ctx, actionName) {
   ctx.ops.stopTyping(session);
   transitionTo(session, "restarting");
-  session.claude.kill();
+  await session.claude.kill();
   await ctx.ops.flush(session);
+  if (!cliOptions.resume) {
+    session.messageManager?.clearClaudeSessionState();
+  }
   session.claude = new ClaudeCli(cliOptions);
   session.claude.on("event", (e) => ctx.ops.handleEvent(session.sessionId, e));
   session.claude.on("exit", (code) => ctx.ops.handleExit(session.sessionId, code));

package/dist/mcp/mcp-server.js

@@ -48574,11 +48574,26 @@ var bashToolFormatter = {
 };
 // src/operations/tool-formatters/task-tools.ts
 var taskToolsFormatter = {
-  toolNames: ["TodoWrite", "Task", "EnterPlanMode", "ExitPlanMode", "AskUserQuestion"],
-  format(toolName, _input, options) {
+  toolNames: [
+    "TodoWrite",
+    "TaskCreate",
+    "TaskUpdate",
+    "TaskGet",
+    "TaskList",
+    "Task",
+    "EnterPlanMode",
+    "ExitPlanMode",
+    "AskUserQuestion"
+  ],
+  format(toolName, input, options) {
     const { formatter } = options;
     switch (toolName) {
       case "TodoWrite":
+      case "TaskCreate":
+      case "TaskUpdate":
+        return { display: null, hidden: true };
+      case "TaskGet":
+      case "TaskList":
         return { display: null, hidden: true };
       case "Task":
         return { display: null, hidden: true };
@@ -48587,8 +48602,25 @@ var taskToolsFormatter = {
           display: `\uD83D\uDCCB ${formatter.formatBold("Planning...")}`,
           permissionText: `\uD83D\uDCCB ${formatter.formatBold("Planning...")}`
         };
-      case "ExitPlanMode":
-        return { display: null, hidden: true };
+      case "ExitPlanMode": {
+        const plan = typeof input.plan === "string" ? input.plan : "";
+        const points = Array.from(plan);
+        const truncated = points.length > 1500;
+        let preview = truncated ? `${points.slice(0, 1500).join("")}
+…` : plan;
+        if (truncated) {
+          const fenceCount = (preview.match(/^```/gm) || []).length;
+          if (fenceCount % 2 === 1)
+            preview += "\n```";
+        }
+        return {
+          display: null,
+          hidden: true,
+          permissionText: preview ? `\uD83D\uDCCB ${formatter.formatBold("Plan approval requested")}
+
+${preview}` : `\uD83D\uDCCB ${formatter.formatBold("Plan approval requested")}`
+        };
+      }
       case "AskUserQuestion":
         return { display: null, hidden: true };
       default:
@@ -49135,9 +49167,14 @@ function createStatusUpdateOp(sessionId, options) {
 }
 // src/operations/transformer.ts
 function transformEvent(event, ctx) {
+  if (event.parent_tool_use_id) {
+    return [];
+  }
   switch (event.type) {
     case "assistant":
       return transformAssistant(event, ctx);
+    case "user":
+      return transformUser(event, ctx);
     case "tool_use":
       return transformToolUse(event, ctx);
     case "tool_result":
@@ -49179,6 +49216,9 @@ function transformAssistant(event, ctx) {
         if (result.display && !result.hidden) {
           flushTextBuffer();
           operations.push(createAppendContentOp(ctx.sessionId, result.display, true));
+          if (block.id) {
+            ctx.toolStartTimes.set(block.id, Date.now());
+          }
         }
       }
     } else if (block.type === "thinking" && block.thinking) {
@@ -49193,8 +49233,70 @@ function transformAssistant(event, ctx) {
     }
   }
   flushTextBuffer();
+  const taskListOps = operations.filter((op) => op.type === "task_list");
+  if (taskListOps.length > 1) {
+    const last = taskListOps[taskListOps.length - 1];
+    return operations.filter((op) => op.type !== "task_list" || op === last);
+  }
   return operations;
 }
+function transformUser(event, ctx) {
+  const msg = event.message;
+  if (!Array.isArray(msg?.content)) {
+    return [];
+  }
+  const operations = [];
+  let indicatorCount = 0;
+  for (const block of msg.content) {
+    if (block?.type !== "tool_result" || !block.tool_use_id)
+      continue;
+    if (ctx.taskTracker.hasPendingCreate(block.tool_use_id)) {
+      const resolution = ctx.taskTracker.resolveCreatedId(block.tool_use_id, toolResultContentText(block.content), block.is_error === true);
+      if (resolution === "removed" || resolution === "merged") {
+        const action = ctx.taskTracker.allCompleted ? "complete" : "update";
+        operations.push(createTaskListOp(ctx.sessionId, action, ctx.taskTracker.toTaskItems()));
+      }
+    }
+    if (ctx.toolStartTimes.has(block.tool_use_id)) {
+      operations.push(createResultIndicatorOp(block.tool_use_id, block.is_error === true, ctx));
+      indicatorCount++;
+    }
+  }
+  const taskListOps = operations.filter((op) => op.type === "task_list");
+  if (taskListOps.length > 1) {
+    const last = taskListOps[taskListOps.length - 1];
+    const coalesced = operations.filter((op) => op.type !== "task_list" || op === last);
+    operations.length = 0;
+    operations.push(...coalesced);
+  }
+  if (indicatorCount > 0) {
+    operations.push(createFlushOp(ctx.sessionId, "tool_complete"));
+  }
+  return operations;
+}
+function toolResultContentText(content) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    return content.map((b) => b && typeof b === "object" && typeof b.text === "string" ? b.text : "").join(`
+`);
+  }
+  return "";
+}
+function createResultIndicatorOp(toolUseId, isError, ctx) {
+  let elapsed = "";
+  const startTime = ctx.toolStartTimes.get(toolUseId);
+  if (startTime) {
+    const secs = Math.round((Date.now() - startTime) / 1000);
+    if (secs >= 3) {
+      elapsed = ` (${secs}s)`;
+    }
+    ctx.toolStartTimes.delete(toolUseId);
+  }
+  const icon = isError ? "❌" : "✓";
+  const errorNote = isError ? " Error" : "";
+  return createAppendContentOp(ctx.sessionId, `  ↳ ${icon}${errorNote}${elapsed}`, true);
+}
 function transformToolUse(event, ctx) {
   const tool = event.tool_use;
   if (tool.id) {
@@ -49219,23 +49321,10 @@ function transformToolResult(event, ctx) {
     return [];
   }
   const result = event.tool_result;
-  const operations = [];
-  let elapsed = "";
-  if (result.tool_use_id) {
-    const startTime = ctx.toolStartTimes.get(result.tool_use_id);
-    if (startTime) {
-      const secs = Math.round((Date.now() - startTime) / 1000);
-      if (secs >= 3) {
-        elapsed = ` (${secs}s)`;
-      }
-      ctx.toolStartTimes.delete(result.tool_use_id);
-    }
-  }
-  const icon = result.is_error ? "❌" : "✓";
-  const errorNote = result.is_error ? " Error" : "";
-  operations.push(createAppendContentOp(ctx.sessionId, `  ↳ ${icon}${errorNote}${elapsed}`, true));
-  operations.push(createFlushOp(ctx.sessionId, "tool_complete"));
-  return operations;
+  return [
+    createResultIndicatorOp(result.tool_use_id || "", result.is_error === true, ctx),
+    createFlushOp(ctx.sessionId, "tool_complete")
+  ];
 }
 function transformResult(event, ctx) {
   const operations = [];
@@ -49252,6 +49341,10 @@ function handleSpecialTool(toolName, toolUseId, input, ctx) {
   switch (toolName) {
     case "TodoWrite":
       return handleTodoWrite(input, ctx);
+    case "TaskCreate":
+      return handleTaskCreate(toolUseId, input, ctx);
+    case "TaskUpdate":
+      return handleTaskUpdate(input, ctx);
     case "Task":
       return handleTaskStart(toolUseId, input, ctx);
     case "AskUserQuestion":
@@ -49269,10 +49362,22 @@ function handleTodoWrite(input, ctx) {
     status: t.status,
     activeForm: t.activeForm
   }));
+  ctx.taskTracker.clear();
   const allCompleted = tasks.every((t) => t.status === "completed");
   const action = allCompleted ? "complete" : "update";
   return [createTaskListOp(ctx.sessionId, action, tasks)];
 }
+function handleTaskCreate(toolUseId, input, ctx) {
+  ctx.taskTracker.create(toolUseId, input);
+  return [createTaskListOp(ctx.sessionId, "update", ctx.taskTracker.toTaskItems())];
+}
+function handleTaskUpdate(input, ctx) {
+  const changed = ctx.taskTracker.update(input);
+  if (!changed)
+    return [];
+  const action = ctx.taskTracker.allCompleted ? "complete" : "update";
+  return [createTaskListOp(ctx.sessionId, action, ctx.taskTracker.toTaskItems())];
+}
 function handleTaskStart(toolUseId, input, ctx) {
   const description = input.description || input.prompt || "Subagent";
   const subagentType = input.subagent_type || "general-purpose";
@@ -49306,6 +49411,102 @@ function truncateAtWord(text, maxLength) {
   }
   return truncated + "...";
 }
+// src/operations/task-tracker.ts
+var CREATED_RESULT_RE = /Task #(\S+) created/;
+
+class TaskTracker {
+  tasks = [];
+  pendingCreates = new Map;
+  unmatchedCreateResults = 0;
+  create(toolUseId, input) {
+    const task = {
+      subject: typeof input.subject === "string" ? input.subject : "Task",
+      activeForm: typeof input.activeForm === "string" ? input.activeForm : undefined,
+      status: "pending"
+    };
+    this.tasks.push(task);
+    if (toolUseId) {
+      this.pendingCreates.set(toolUseId, task);
+    }
+  }
+  hasPendingCreate(toolUseId) {
+    return this.pendingCreates.has(toolUseId);
+  }
+  resolveCreatedId(toolUseId, resultContent, isError = false) {
+    const task = this.pendingCreates.get(toolUseId);
+    if (!task)
+      return "ignored";
+    this.pendingCreates.delete(toolUseId);
+    const match = isError ? null : CREATED_RESULT_RE.exec(resultContent);
+    if (!match) {
+      if (!isError)
+        this.unmatchedCreateResults++;
+      this.tasks = this.tasks.filter((t) => t !== task);
+      return "removed";
+    }
+    const placeholder = this.tasks.find((t) => t !== task && t.taskId === match[1]);
+    if (placeholder) {
+      task.status = placeholder.status;
+      if (placeholder.subject !== `Task #${match[1]}`)
+        task.subject = placeholder.subject;
+      if (placeholder.activeForm && !task.activeForm)
+        task.activeForm = placeholder.activeForm;
+      this.tasks = this.tasks.filter((t) => t !== placeholder);
+    }
+    task.taskId = match[1];
+    return placeholder ? "merged" : "resolved";
+  }
+  consumeUnmatchedCreateResultFlag() {
+    if (this.unmatchedCreateResults === 0)
+      return false;
+    this.unmatchedCreateResults = 0;
+    return true;
+  }
+  update(input) {
+    const taskId = typeof input.taskId === "string" ? input.taskId : typeof input.taskId === "number" ? String(input.taskId) : undefined;
+    if (!taskId)
+      return false;
+    let task = this.tasks.find((t) => t.taskId === taskId);
+    const status = typeof input.status === "string" ? input.status : undefined;
+    if (status === "deleted") {
+      if (!task)
+        return false;
+      this.tasks = this.tasks.filter((t) => t !== task);
+      return true;
+    }
+    if (!task) {
+      task = { taskId, subject: `Task #${taskId}`, status: "pending", isPlaceholder: true };
+      this.tasks.push(task);
+    }
+    if (typeof input.subject === "string")
+      task.subject = input.subject;
+    if (typeof input.activeForm === "string")
+      task.activeForm = input.activeForm;
+    if (status === "pending" || status === "in_progress" || status === "completed") {
+      task.status = status;
+    }
+    return true;
+  }
+  toTaskItems() {
+    return this.tasks.map((t) => ({
+      content: t.subject,
+      status: t.status,
+      activeForm: t.activeForm ?? t.subject
+    }));
+  }
+  get isEmpty() {
+    return this.tasks.length === 0;
+  }
+  get allCompleted() {
+    return this.tasks.length > 0 && this.tasks.every((t) => t.status === "completed") && this.tasks.some((t) => !t.isPlaceholder);
+  }
+  clear() {
+    this.tasks = [];
+    this.pendingCreates.clear();
+    this.unmatchedCreateResults = 0;
+  }
+}
+
 // src/operations/executors/base.ts
 class BaseExecutor {
   state;
@@ -51367,6 +51568,7 @@ class MessageManager {
   startTypingCallback;
   emitSessionUpdateCallback;
   toolStartTimes = new Map;
+  taskTracker = new TaskTracker;
   flushTimer = null;
   static DEFAULT_FLUSH_DELAY_MS = 500;
   flushDelayMs;
@@ -51437,10 +51639,14 @@ class MessageManager {
       sessionId: this.sessionId,
       formatter: this.platform.getFormatter(),
       toolStartTimes: this.toolStartTimes,
+      taskTracker: this.taskTracker,
       detailed: true,
       worktreeInfo: this.worktreePath && this.worktreeBranch ? { path: this.worktreePath, branch: this.worktreeBranch } : undefined
     };
     const ops = transformEvent(event, transformCtx);
+    if (this.taskTracker.consumeUnmatchedCreateResultFlag()) {
+      logger.warn('TaskCreate result did not match the expected "Task #N created" wording — ' + "task dropped from the displayed list. If this repeats, the Claude CLI " + "likely changed its result text and the task display will be incomplete.");
+    }
     if (ops.length === 0) {
       if (event.type !== "system") {
         logger.debug(`No operations from event: ${event.type}`);
@@ -51824,9 +52030,14 @@ class MessageManager {
     logger.debug("Reaction not handled by any executor");
     return false;
   }
+  clearClaudeSessionState() {
+    this.toolStartTimes.clear();
+    this.taskTracker.clear();
+  }
   reset() {
     this.cancelScheduledFlush();
     this.toolStartTimes.clear();
+    this.taskTracker.clear();
     this.contentExecutor.reset();
     this.taskListExecutor.reset();
     this.questionApprovalExecutor.reset();
@@ -55629,6 +55840,25 @@ function extractResetAt(text, now) {
   }
   return;
 }
+function parseRateLimitEvent(event, now = Date.now()) {
+  const info = event?.rate_limit_info;
+  if (!info || typeof info !== "object")
+    return { detected: false };
+  const { status, resetsAt } = info;
+  if (status !== "rejected")
+    return { detected: false };
+  const PAST_SKEW_TOLERANCE_MS = 2 * 60000;
+  let resetAtEpochMs;
+  if (typeof resetsAt === "number") {
+    const ms = resetsAt * 1000;
+    if (ms > now && ms - now < 8 * 86400000) {
+      resetAtEpochMs = ms;
+    } else if (ms <= now && now - ms < PAST_SKEW_TOLERANCE_MS) {
+      resetAtEpochMs = now + 60000;
+    }
+  }
+  return { detected: true, matched: `rate_limit_event status=${status}`, resetAtEpochMs };
+}
 
 // src/claude/cli.ts
 var log8 = createLogger("claude");
@@ -55765,6 +55995,7 @@ class ClaudeCli extends EventEmitter2 {
   stderrBuffer = "";
   mcpConfigTempFile = null;
   lastEmittedRateLimitDeadline = 0;
+  lastEmittedHitHadExplicitReset = false;
   log;
   constructor(options) {
     super();
@@ -55818,6 +56049,7 @@ class ClaudeCli extends EventEmitter2 {
     totalStderrBytes -= this.stderrBuffer.length;
     this.stderrBuffer = "";
     this.lastEmittedRateLimitDeadline = 0;
+    this.lastEmittedHitHadExplicitReset = false;
     cleanupBrowserBridgeSockets();
     const claudePath = getClaudePath();
     const args = [
@@ -55967,18 +56199,31 @@ class ClaudeCli extends EventEmitter2 {
         if (event.type === "result" && isErrorResultEvent(event)) {
           this.maybeEmitRateLimit(trimmed);
         }
+        if (event.type === "rate_limit_event") {
+          this.maybeEmitRateLimitHit(parseRateLimitEvent(event));
+        }
       } catch {}
     }
   }
   maybeEmitRateLimit(text) {
-    const hit = detectRateLimit(text);
+    this.maybeEmitRateLimitHit(detectRateLimit(text));
+  }
+  maybeEmitRateLimitHit(hit) {
     if (!hit.detected)
       return;
+    if (!hit.resetAtEpochMs && this.lastEmittedHitHadExplicitReset && this.lastEmittedRateLimitDeadline > Date.now()) {
+      return;
+    }
     const newDeadline = cooldownDeadline(hit);
     const MIN_ADVANCE_MS = 60000;
-    if (newDeadline - this.lastEmittedRateLimitDeadline < MIN_ADVANCE_MS)
+    if (newDeadline - this.lastEmittedRateLimitDeadline < MIN_ADVANCE_MS) {
+      if (hit.resetAtEpochMs !== undefined) {
+        this.lastEmittedHitHadExplicitReset = true;
+      }
       return;
+    }
     this.lastEmittedRateLimitDeadline = newDeadline;
+    this.lastEmittedHitHadExplicitReset = hit.resetAtEpochMs !== undefined;
     this.log.warn(`Rate limit detected: ${hit.matched ?? "(no match text)"}`);
     this.emit("rate-limit", hit);
   }
@@ -56033,12 +56278,22 @@ class ClaudeCli extends EventEmitter2 {
           proc.kill("SIGTERM");
         } catch {}
       }, 2000);
-      proc.once("exit", (code) => {
-        this.log.debug(`Claude process exited (code=${code})`);
+      const settle = (reason) => {
+        this.log.debug(`Claude process gone (${reason})`);
         clearTimeout(secondSigint);
         clearTimeout(forceKillTimeout);
+        clearTimeout(lastResort);
         resolve5();
-      });
+      };
+      const lastResort = setTimeout(() => {
+        try {
+          this.log.warn("Claude process did not exit after SIGTERM — sending SIGKILL");
+          proc.kill("SIGKILL");
+        } catch {}
+        settle("kill timeout");
+      }, 5000);
+      proc.once("close", (code) => settle(`closed, code=${code}`));
+      proc.once("error", () => settle("spawn error"));
     });
   }
   interrupt() {
@@ -58181,6 +58436,10 @@ async function handlePermissionWith(toolName, toolInput, cfg) {
     mcpLogger.debug(`Skipping standard prompt for ${toolName} (handler enforces its own gate)`);
     return { behavior: "allow", updatedInput: toolInput };
   }
+  if (toolName === "AskUserQuestion") {
+    mcpLogger.debug("Auto-allowing AskUserQuestion (question UI is handled by the main bot)");
+    return { behavior: "allow", updatedInput: toolInput };
+  }
   if (cfg.getAllowAll()) {
     mcpLogger.debug(`Auto-allowing ${toolName} (allow all active)`);
     return { behavior: "allow", updatedInput: toolInput };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-threads",
-  "version": "1.20.0",
+  "version": "1.21.0",
   "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",