claude-threads 1.20.1 → 1.21.1

package/CHANGELOG.md

@@ -5,6 +5,39 @@ 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.1] - 2026-08-07
+
+### Fixed
+- **A respawning session can no longer be torn down by its own dying Claude process.** Two stacked races made `!cd` / `!permissions` / worktree respawns flaky (seen as the recurring `!cd should restart Claude CLI` failure on main's Integration Tests): a last event flushed by the dying process ran `resetSessionActivity`, which unconditionally flipped the session's `restarting` state back to `active` — so when the old process's exit landed, `handleExit` mistook it for the current process dying and did a full session teardown mid-restart. `resetSessionActivity` now leaves `restarting`/`cancelling` states alone, `handleExit` ignores exits from a CLI instance that is no longer the session's current one (the exit event can be delivered after the respawn already swapped in the new instance), and a successful respawn transitions to `active` explicitly instead of relying on the old exit's side effect. `ClaudeCli.kill()` gained an integration-test caller trace, mirroring the existing `sendMessage` one — attributing kills is the key question when debugging these races in CI logs.
+- **`checkGitHubCli` unit tests no longer spawn the real `gh` CLI.** The two subprocess probes each carry a 5s timeout, overrunning bun's 5s per-test budget on a slow runner (the flaky `checkGitHubCli` timeout on main's CI). The exec call is now injectable and the tests cover all three outcomes (installed+authenticated, not installed, not authenticated) deterministically.
+- **Integration: the `!cd` confirmation wait no longer matches the user's own message.** The loose `/changed|directory|\/tmp/i` pattern matched the `!cd /tmp` command itself, ending the test while the respawn was still in flight — `afterEach`'s `killAllSessions` then raced the restart and leaked an orphaned mock CLI into the next test.
+
+## [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

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);
   }
@@ -56307,6 +56341,12 @@ class ClaudeCli extends EventEmitter2 {
     const pid = proc.pid;
     this.process = null;
     this.log.debug(`Killing Claude process (pid=${pid})`);
+    if (process.env.INTEGRATION_TEST === "1") {
+      const stack = new Error().stack?.split(`
+`).slice(2, 7).join(" > ").replace(/\s+at\s+/g, " < ") ?? "?";
+      process.stderr.write(`[claude-cli kill pid=${pid}] | ${stack}
+`);
+    }
     return new Promise((resolve4) => {
       this.log.debug("Sending first SIGINT");
       proc.kill("SIGINT");
@@ -56322,12 +56362,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() {
@@ -58482,7 +58532,10 @@ function resetSessionActivity(session) {
   session.lastActivityAt = new Date;
   session.timeoutWarningPosted = false;
   session.lifecyclePostId = undefined;
-  transitionTo(session, "active");
+  const state = session.lifecycle.state;
+  if (state !== "restarting" && state !== "cancelling") {
+    transitionTo(session, "active");
+  }
   if (session.worktreeInfo?.worktreePath) {
     updateWorktreeActivity(session.worktreeInfo.worktreePath, session.sessionId);
   }
@@ -62597,9 +62650,9 @@ _Reported via claude-threads bug report feature_`);
 function escapeShell(str2) {
   return str2.replace(/"/g, "\\\"");
 }
-function checkGitHubCli() {
+function checkGitHubCli(exec2 = execSync2) {
   try {
-    execSync2("gh --version", {
+    exec2("gh --version", {
       encoding: "utf-8",
       timeout: 5000,
       stdio: ["pipe", "pipe", "pipe"]
@@ -62612,7 +62665,7 @@ function checkGitHubCli() {
     };
   }
   try {
-    execSync2("gh auth status", {
+    exec2("gh auth status", {
       encoding: "utf-8",
       timeout: 5000,
       stdio: ["pipe", "pipe", "pipe"]
@@ -63986,11 +64039,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 +64067,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 +64624,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 +64673,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 +64690,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 +64778,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 +64798,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 +64819,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 +64868,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 +66716,7 @@ class MessageManager {
   startTypingCallback;
   emitSessionUpdateCallback;
   toolStartTimes = new Map;
+  taskTracker = new TaskTracker;
   flushTimer = null;
   static DEFAULT_FLUSH_DELAY_MS = 500;
   flushDelayMs;
@@ -66532,10 +66787,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 +67178,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 +68221,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,10 +68241,15 @@ 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.claude = new ClaudeCli(cliOptions);
-        session.claude.on("event", (e) => options.handleEvent(session.sessionId, e));
-        session.claude.on("exit", (code) => options.handleExit(session.sessionId, code));
-        session.claude.start();
+        session.messageManager?.clearClaudeSessionState();
+        const newClaude = new ClaudeCli(cliOptions);
+        session.claude = newClaude;
+        newClaude.on("event", (e) => options.handleEvent(session.sessionId, e));
+        newClaude.on("exit", (code) => options.handleExit(session.sessionId, code, newClaude));
+        newClaude.start();
+        if (isSessionRestarting(session)) {
+          transitionTo(session, "active");
+        }
       }
       await options.updateSessionHeader(session);
       await post(session, "success", `${fmt.formatBold("Joined existing worktree")} for branch ${fmt.formatCode(branch)}
@@ -68049,7 +68318,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,10 +68338,15 @@ ${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.claude = new ClaudeCli(cliOptions);
-      session.claude.on("event", (e) => options.handleEvent(session.sessionId, e));
-      session.claude.on("exit", (code) => options.handleExit(session.sessionId, code));
-      session.claude.start();
+      session.messageManager?.clearClaudeSessionState();
+      const newClaude = new ClaudeCli(cliOptions);
+      session.claude = newClaude;
+      newClaude.on("event", (e) => options.handleEvent(session.sessionId, e));
+      newClaude.on("exit", (code) => options.handleExit(session.sessionId, code, newClaude));
+      newClaude.start();
+      if (isSessionRestarting(session)) {
+        transitionTo(session, "active");
+      }
     }
     await options.updateSessionHeader(session);
     const shortWorktreePath = shortenPath(worktreePath, undefined, { path: worktreePath, branch });
@@ -68342,6 +68616,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 +68640,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 +68661,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 +68673,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,17 +69242,26 @@ 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);
-  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));
-  session.claude.on("rate-limit", (hit) => handleRateLimit(session, hit, ctx));
+  if (!cliOptions.resume) {
+    session.messageManager?.clearClaudeSessionState();
+  }
+  const newClaude = new ClaudeCli(cliOptions);
+  session.claude = newClaude;
+  newClaude.on("event", (e) => ctx.ops.handleEvent(session.sessionId, e));
+  newClaude.on("exit", (code) => ctx.ops.handleExit(session.sessionId, code, newClaude));
+  newClaude.on("rate-limit", (hit) => handleRateLimit(session, hit, ctx));
   try {
-    session.claude.start();
+    newClaude.start();
+    if (isSessionRestarting(session)) {
+      transitionTo(session, "active");
+    }
     return true;
   } catch (err) {
-    transitionTo(session, "active");
+    if (isSessionRestarting(session)) {
+      transitionTo(session, "active");
+    }
     await logAndNotify(err, { action: actionName, session });
     return false;
   }
@@ -70066,7 +70374,7 @@ async function startSession(options, username, displayName, replyToPostId, platf
   await ctx.ops.updateStickyMessage();
   ctx.ops.startTyping(session);
   claude.on("event", (e) => ctx.ops.handleEvent(sessionId, e));
-  claude.on("exit", (code) => ctx.ops.handleExit(sessionId, code));
+  claude.on("exit", (code) => ctx.ops.handleExit(sessionId, code, claude));
   claude.on("rate-limit", (hit) => handleRateLimit(session, hit, ctx));
   try {
     claude.start();
@@ -70261,7 +70569,7 @@ Please start a new session.`), { action: "Post resume failure notification" });
   ctx.ops.emitSessionAdd(session);
   keepAlive.sessionStarted();
   claude.on("event", (e) => ctx.ops.handleEvent(sessionId, e));
-  claude.on("exit", (code) => ctx.ops.handleExit(sessionId, code));
+  claude.on("exit", (code) => ctx.ops.handleExit(sessionId, code, claude));
   claude.on("rate-limit", (hit) => handleRateLimit(session, hit, ctx));
   try {
     claude.start();
@@ -70349,7 +70657,7 @@ async function resumePausedSession(threadId, message, files, ctx, username) {
     log31.warn(`Failed to resume session ${shortId}..., could not send message`);
   }
 }
-async function handleExit(sessionId, code, ctx) {
+async function handleExit(sessionId, code, ctx, source) {
   const session = mutableSessions(ctx).get(sessionId);
   const shortId = sessionId.substring(0, 8);
   sessionLog6(session).debug(`handleExit called code=${code} isShuttingDown=${ctx.state.isShuttingDown}`);
@@ -70357,6 +70665,10 @@ async function handleExit(sessionId, code, ctx) {
     log31.debug(`Session ${shortId}... not found (already cleaned up)`);
     return;
   }
+  if (source && session.claude !== source) {
+    sessionLog6(session).debug(`Ignoring exit from replaced Claude process`);
+    return;
+  }
   if (isSessionRestarting(session)) {
     sessionLog6(session).debug(`Restarting, skipping cleanup`);
     transitionTo(session, "active");
@@ -71080,7 +71392,7 @@ class SessionManager extends EventEmitter4 {
       updateSessionHeader: (s) => this.updateSessionHeader(s),
       updateStickyMessage: () => this.updateStickyMessage(),
       handleEvent: (sid, e) => this.handleEvent(sid, e),
-      handleExit: (sid, code) => this.handleExit(sid, code),
+      handleExit: (sid, code, source) => this.handleExit(sid, code, source),
       killSession: (tid) => this.killSession(tid),
       shouldPromptForWorktree: (s) => this.shouldPromptForWorktree(s),
       postWorktreePrompt: (s, r) => this.postWorktreePrompt(s, r),
@@ -71184,8 +71496,8 @@ class SessionManager extends EventEmitter4 {
     session.messageManager.handleEvent(event);
     handleEventPostProcessing(session, event, this.getContext());
   }
-  async handleExit(sessionId, code) {
-    await handleExit(sessionId, code, this.getContext());
+  async handleExit(sessionId, code, source) {
+    await handleExit(sessionId, code, this.getContext(), source);
   }
   startTyping(session) {
     const wasTyping = session.timers.typingTimer !== null;
@@ -71700,7 +72012,7 @@ class SessionManager extends EventEmitter4 {
       worktreeMode: this.worktreeMode,
       permissionTimeoutMs: this.limits.permissionTimeoutSeconds * 1000,
       handleEvent: (tid, e) => this.handleEvent(tid, e),
-      handleExit: (tid, code) => this.handleExit(tid, code),
+      handleExit: (tid, code, source) => this.handleExit(tid, code, source),
       updateSessionHeader: (s) => this.updateSessionHeader(s),
       flush: async (s) => {
         if (s.messageManager) {

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);
   }
@@ -56018,6 +56263,12 @@ class ClaudeCli extends EventEmitter2 {
     const pid = proc.pid;
     this.process = null;
     this.log.debug(`Killing Claude process (pid=${pid})`);
+    if (process.env.INTEGRATION_TEST === "1") {
+      const stack = new Error().stack?.split(`
+`).slice(2, 7).join(" > ").replace(/\s+at\s+/g, " < ") ?? "?";
+      process.stderr.write(`[claude-cli kill pid=${pid}] | ${stack}
+`);
+    }
     return new Promise((resolve5) => {
       this.log.debug("Sending first SIGINT");
       proc.kill("SIGINT");
@@ -56033,12 +56284,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 +58442,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.1",
+  "version": "1.21.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",