claude-threads 1.38.1 → 1.39.1

package/CHANGELOG.md

@@ -5,6 +5,23 @@ 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.39.1] - 2026-09-25
+
+### Fixed
+- **A long burst or a long code block no longer overflows one post** (#617, #619). When a lot of text reached a reply that already had a post, the part that did not fit went into one new post of any size, and a code block Claude was still writing kept growing the last post without limit. Slack cut such a post off; Mattermost refused it, and the text was posted twice later. Both now split over posts that fit, with code blocks closed and reopened with their language. Normal replies below the limit are unchanged.
+
+## [1.39.0] - 2026-09-25
+
+### Added
+- **Per-platform `toolActivity`: `summary` or `hidden` instead of the tool stream** (#534, thanks @kaza). `summary` replaces the inline `Bash …` / `↳ ✓` lines with one live line at the top of the turn's post — `🔧 12 tools · 40 s · Bash`, naming the tool most recently started so the line stays a liveness signal; `hidden` says nothing about tools at all. `toolDetails: thread` keeps the full rendering in a thread under the reply, `none` drops it. Defaults are unchanged (`full` / `none`). Permission prompts, plan approvals, questions, task lists and errors are untouched in every mode. Part of #505. Hardened before release in #616: the turn marker keeps the summary line, details in a thread session arrive after the whole reply, and long or rate-limited turns lose no tool lines.
+
+### Fixed
+- **Long replies are no longer cut off at the platform limit** (#616). A reply that reached the chat in one large burst, with no post of its own yet, was truncated past the limit (about 12K characters on Slack, 16K on Mattermost), with "(truncated)" at the end. It is now split over several posts; a code block cut in two is closed and reopened with its language. Normal streaming replies are unchanged.
+- **A refused post no longer loses part of a long reply** (#616). When the platform refused one post of a reply split over several (a rate limit, for instance), the text of that post was dropped once a later one went through, and anything Claude streamed meanwhile could be wiped. The refused part is now kept and posted on the next flush.
+
+### Changed
+- `hono` 4.13.7 → 4.13.8 (#608).
+
 ## [1.38.1] - 2026-09-24
 
 ### Fixed

package/dist/index.js

@@ -2278,6 +2278,27 @@ function resolveTurnMarker(mode, emoji, platformType, fieldPath) {
     return { mode: "reaction", emoji: emoji ?? DEFAULT_TURN_MARKER_EMOJI };
   return { mode: m };
 }
+function resolveToolActivity(activity, details, fieldPath) {
+  const act = activity === undefined || activity === null ? "full" : activity;
+  if (!TOOL_ACTIVITY_VALUES.includes(act)) {
+    throw new Error(`Invalid ${fieldPath}.toolActivity: expected one of ${TOOL_ACTIVITY_VALUES.join(", ")}, got ${JSON.stringify(activity)}`);
+  }
+  const mode = act;
+  if (details !== undefined && details !== null && !TOOL_DETAILS_VALUES.includes(details)) {
+    throw new Error(`Invalid ${fieldPath}.toolDetails: expected one of ${TOOL_DETAILS_VALUES.join(", ")}, got ${JSON.stringify(details)}`);
+  }
+  const det = details;
+  if (mode === "full") {
+    if (det !== undefined && det !== null) {
+      throw new Error(`Invalid ${fieldPath}.toolDetails: only meaningful with toolActivity summary or hidden`);
+    }
+    return { activity: "full", details: "none" };
+  }
+  if (mode === "hidden" && det === "thread") {
+    throw new Error(`Invalid ${fieldPath}.toolDetails: hidden has no post of its own to thread under; use summary, or none`);
+  }
+  return { activity: mode, details: det ?? (mode === "summary" ? "thread" : "none") };
+}
 function resolveMemoryConfig(value, fieldPath) {
   if (value === undefined || value === null || value === true)
     return DEFAULT_MEMORY_CONFIG;
@@ -2452,7 +2473,7 @@ function effectivePermissionMode(input) {
     return "default";
   return input.botWideMode;
 }
-var OVERHEAD_VISIBILITY_VALUES, DEFAULT_OVERHEAD_VISIBILITY = "full", RECONNECT_POLICY_VALUES, DEFAULT_RECONNECT_POLICY = "retry", PRESENTATION_MODE_VALUES, PRESENTATION_MODE_EXPANSIONS, TURN_MARKER_VALUES, DEFAULT_TURN_MARKER, DEFAULT_TURN_MARKER_EMOJI = "checkered_flag", TURN_COMPLETE_EVENT_TYPE = "claude_threads_turn_complete", TURN_COMPLETE_PAYLOAD_VERSION = 1, DEFAULT_MEMORY_CONFIG, MEMORY_DISABLED, BOT_MCP_SERVER_NAME = "claude-threads-mcp", STDIO_KEYS, REMOTE_KEYS, LIMITS_DEFAULTS, MODE_INFO;
+var OVERHEAD_VISIBILITY_VALUES, DEFAULT_OVERHEAD_VISIBILITY = "full", RECONNECT_POLICY_VALUES, DEFAULT_RECONNECT_POLICY = "retry", PRESENTATION_MODE_VALUES, PRESENTATION_MODE_EXPANSIONS, TURN_MARKER_VALUES, DEFAULT_TURN_MARKER, DEFAULT_TURN_MARKER_EMOJI = "checkered_flag", TURN_COMPLETE_EVENT_TYPE = "claude_threads_turn_complete", TURN_COMPLETE_PAYLOAD_VERSION = 1, TOOL_ACTIVITY_VALUES, TOOL_DETAILS_VALUES, DEFAULT_TOOL_ACTIVITY, DEFAULT_MEMORY_CONFIG, MEMORY_DISABLED, BOT_MCP_SERVER_NAME = "claude-threads-mcp", STDIO_KEYS, REMOTE_KEYS, LIMITS_DEFAULTS, MODE_INFO;
 var init_types = __esm(() => {
   OVERHEAD_VISIBILITY_VALUES = ["full", "minimal", "hidden"];
   RECONNECT_POLICY_VALUES = ["retry", "exit"];
@@ -2467,6 +2488,9 @@ var init_types = __esm(() => {
   };
   TURN_MARKER_VALUES = ["reaction", "metadata", "off"];
   DEFAULT_TURN_MARKER = { mode: "off" };
+  TOOL_ACTIVITY_VALUES = ["full", "summary", "hidden"];
+  TOOL_DETAILS_VALUES = ["thread", "none"];
+  DEFAULT_TOOL_ACTIVITY = { activity: "full", details: "none" };
   DEFAULT_MEMORY_CONFIG = {
     enabled: true,
     repoLayer: true,
@@ -59501,6 +59525,9 @@ toolFormatterRegistry.register(playwrightToolsFormatter);
 toolFormatterRegistry.register(figmaToolsFormatter);
 toolFormatterRegistry.register(context7ToolsFormatter);
 // src/operations/types.ts
+function isToolActivityOp(op) {
+  return op.type === "tool_activity";
+}
 function isContentOp(op) {
   return op.type === "append_content";
 }
@@ -59537,6 +59564,9 @@ function createAppendContentOp(sessionId, content, isToolOutput) {
     isToolOutput
   };
 }
+function createToolActivityOp(sessionId, detail) {
+  return { type: "tool_activity", sessionId, timestamp: Date.now(), ...detail };
+}
 function createFlushOp(sessionId, reason, resultOk) {
   return {
     type: "flush",
@@ -59599,6 +59629,9 @@ function createStatusUpdateOp(sessionId, options) {
 }
 // src/operations/transformer.ts
 init_cli();
+function toolsInline(ctx) {
+  return (ctx.toolActivity ?? "full") === "full";
+}
 function transformEvent(event, ctx) {
   if (event.parent_tool_use_id) {
     return [];
@@ -59648,7 +59681,16 @@ function transformAssistant(event, ctx) {
         });
         if (result.display && !result.hidden) {
           flushTextBuffer();
-          operations.push(createAppendContentOp(ctx.sessionId, result.display, true));
+          if (toolsInline(ctx)) {
+            operations.push(createAppendContentOp(ctx.sessionId, result.display, true));
+          } else {
+            operations.push(createToolActivityOp(ctx.sessionId, {
+              kind: "start",
+              toolUseId: block.id || "",
+              name: block.name,
+              display: result.display
+            }));
+          }
           if (block.id) {
             ctx.toolStartTimes.set(block.id, Date.now());
           }
@@ -59662,7 +59704,14 @@ function transformAssistant(event, ctx) {
     } else if (block.type === "server_tool_use" && block.name) {
       flushTextBuffer();
       const inputStr = block.input ? JSON.stringify(block.input).substring(0, 50) : "";
-      operations.push(createAppendContentOp(ctx.sessionId, `\uD83C\uDF10 ${ctx.formatter.formatBold(block.name)} ${inputStr}`, true));
+      const display = `\uD83C\uDF10 ${ctx.formatter.formatBold(block.name)} ${inputStr}`;
+      if (toolsInline(ctx)) {
+        operations.push(createAppendContentOp(ctx.sessionId, display, true));
+      } else {
+        const toolUseId = block.id || "";
+        operations.push(createToolActivityOp(ctx.sessionId, { kind: "start", toolUseId, name: block.name, display }));
+        operations.push(createToolActivityOp(ctx.sessionId, { kind: "end", toolUseId, ok: true, elapsedMs: 0, display: "  ↳ ✓" }));
+      }
     }
   }
   flushTextBuffer();
@@ -59691,7 +59740,7 @@ function transformUser(event, ctx) {
       }
     }
     if (ctx.toolStartTimes.has(block.tool_use_id)) {
-      operations.push(createResultIndicatorOp(block.tool_use_id, block.is_error === true, ctx));
+      operations.push(toolsInline(ctx) ? createResultIndicatorOp(block.tool_use_id, block.is_error === true, ctx) : createToolEndOp(block.tool_use_id, block.is_error === true, ctx));
       indicatorCount++;
     }
   }
@@ -59730,6 +59779,12 @@ function createResultIndicatorOp(toolUseId, isError, ctx) {
   const errorNote = isError ? " Error" : "";
   return createAppendContentOp(ctx.sessionId, `  ↳ ${icon}${errorNote}${elapsed}`, true);
 }
+function createToolEndOp(toolUseId, isError, ctx) {
+  const startTime = ctx.toolStartTimes.get(toolUseId);
+  const elapsedMs = startTime ? Date.now() - startTime : 0;
+  const indicator = createResultIndicatorOp(toolUseId, isError, ctx);
+  return createToolActivityOp(ctx.sessionId, { kind: "end", toolUseId, ok: !isError, elapsedMs, display: indicator.content });
+}
 function transformToolUse(event, ctx) {
   const tool = event.tool_use;
   if (tool.id) {
@@ -59745,7 +59800,9 @@ function transformToolUse(event, ctx) {
     worktreeInfo: ctx.worktreeInfo
   });
   if (result.display && !result.hidden) {
-    return [createAppendContentOp(ctx.sessionId, result.display, true)];
+    return [
+      toolsInline(ctx) ? createAppendContentOp(ctx.sessionId, result.display, true) : createToolActivityOp(ctx.sessionId, { kind: "start", toolUseId: tool.id || "", name: tool.name, display: result.display })
+    ];
   }
   return [];
 }
@@ -59754,13 +59811,18 @@ function transformToolResult(event, ctx) {
     return [];
   }
   const result = event.tool_result;
+  const toolUseId = result.tool_use_id || "";
+  const isError = result.is_error === true;
   return [
-    createResultIndicatorOp(result.tool_use_id || "", result.is_error === true, ctx),
+    toolsInline(ctx) ? createResultIndicatorOp(toolUseId, isError, ctx) : createToolEndOp(toolUseId, isError, ctx),
     createFlushOp(ctx.sessionId, "tool_complete")
   ];
 }
 function transformResult(event, ctx) {
   const operations = [];
+  if (!toolsInline(ctx)) {
+    operations.push(createToolActivityOp(ctx.sessionId, { kind: "turn_end" }));
+  }
   operations.push(createFlushOp(ctx.sessionId, "result", !isErrorResultEvent(event)));
   const result = event;
   const r = result.result;
@@ -59844,6 +59906,210 @@ function truncateAtWord2(text, maxLength) {
   }
   return truncated + "...";
 }
+// src/operations/executors/tool-activity.ts
+var fresh = () => ({ started: 0, finished: 0, failed: 0, firstStartAt: null, lastEndAt: null, lastTool: null });
+function shortToolName(name) {
+  return parseMcpToolName(name)?.tool || name;
+}
+function renderToolSummary(stats, now, link, formatter) {
+  const running = stats.started > stats.finished;
+  const until = running || stats.lastEndAt === null ? now : stats.lastEndAt;
+  const seconds = stats.firstStartAt === null ? 0 : Math.max(0, Math.round((until - stats.firstStartAt) / 1000));
+  const parts = [`\uD83D\uDD27 ${stats.started} ${stats.started === 1 ? "tool" : "tools"}`, `${seconds} s${running ? "…" : ""}`];
+  if (stats.lastTool)
+    parts.push(shortToolName(stats.lastTool));
+  if (stats.failed > 0)
+    parts.push(`${stats.failed} ❌`);
+  if (link)
+    parts.push(formatter.formatLink("details", link));
+  return parts.join(" · ");
+}
+
+class ToolActivityExecutor {
+  options;
+  stats = fresh();
+  open = new Set;
+  constructor(options) {
+    this.options = options;
+  }
+  getStats() {
+    return this.stats;
+  }
+  async execute(op, ctx) {
+    const now = this.options.now?.() ?? Date.now();
+    if (op.kind === "start") {
+      this.stats.started++;
+      this.open.add(op.toolUseId);
+      this.stats.firstStartAt ??= now;
+      this.stats.lastTool = op.name;
+      this.renderHeader(now, ctx);
+      await this.options.sink.append(op, ctx);
+    } else if (op.kind === "end") {
+      if (!this.open.delete(op.toolUseId))
+        return;
+      this.stats.finished++;
+      if (!op.ok)
+        this.stats.failed++;
+      this.stats.lastEndAt = now;
+      this.renderHeader(now, ctx);
+      await this.options.sink.append(op, ctx);
+    } else if (this.stats.started > 0) {
+      if (this.stats.started > this.stats.finished) {
+        this.stats.finished = this.stats.started;
+        this.stats.lastEndAt = now;
+      }
+      this.open.clear();
+      this.renderHeader(now, ctx);
+    }
+  }
+  async afterResultFlush(ctx) {
+    if (this.stats.started === 0)
+      return;
+    this.stats = fresh();
+    this.open.clear();
+    try {
+      await this.options.sink.turnEnded(ctx);
+    } catch (err) {
+      ctx.logger.warn(`tool details: delivering the turn failed: ${err.message ?? err}`);
+    }
+  }
+  reset() {
+    if (this.stats.started === 0)
+      return;
+    this.stats = fresh();
+    this.open.clear();
+    this.options.sink.reset();
+  }
+  wake() {
+    this.options.sink.wake?.();
+  }
+  renderHeader(now, ctx) {
+    if (this.options.mode !== "summary")
+      return;
+    this.options.onHeader(renderToolSummary(this.stats, now, this.options.sink.link(), ctx.formatter));
+  }
+}
+
+// src/operations/tool-details/thread.ts
+function createThreadSink(deps) {
+  const flushDelayMs = deps.flushDelayMs ?? 500;
+  const newTurn = () => ({ queued: [], executor: null, ctx: null, timer: null, chain: Promise.resolve(), dead: false });
+  let turn = newTurn();
+  function enqueue(t, work) {
+    const run = t.chain.then(() => t.dead ? undefined : work());
+    t.chain = run.catch(() => {
+      return;
+    });
+    return run;
+  }
+  async function drain(t) {
+    if (t.queued.length === 0)
+      return;
+    t.ctx ??= deps.contextFor();
+    if (!t.ctx)
+      return;
+    t.executor ??= deps.makeExecutor();
+    const lines = t.queued;
+    t.queued = [];
+    const chunk = Math.floor(t.ctx.platform.getMessageLimits().hardThreshold / 2);
+    let nextFlushAt = chunk;
+    for (const line of lines) {
+      await t.executor.executeAppend(createAppendContentOp(t.ctx.sessionId, line, true), t.ctx);
+      if (t.dead)
+        return;
+      const pending = t.executor.getState().pendingContent.length;
+      if (pending >= nextFlushAt) {
+        await t.executor.executeFlush(createFlushOp(t.ctx.sessionId, "soft_threshold"), t.ctx);
+        if (t.dead)
+          return;
+        const left = t.executor.getState().pendingContent.length;
+        nextFlushAt = left >= pending ? pending * 2 : chunk;
+      }
+    }
+  }
+  function scheduleFlush(t) {
+    if (t.timer || t.dead)
+      return;
+    t.timer = setTimeout(() => {
+      t.timer = null;
+      enqueue(t, async () => {
+        if (t.executor && t.ctx)
+          await t.executor.executeFlush(createFlushOp(t.ctx.sessionId, "soft_threshold"), t.ctx);
+      });
+    }, flushDelayMs);
+  }
+  function stopTimer(t) {
+    if (t.timer) {
+      clearTimeout(t.timer);
+      t.timer = null;
+    }
+  }
+  return {
+    async append(op) {
+      const t = turn;
+      t.queued.push(op.display);
+      if (deps.holdUntilTurnEnd)
+        return;
+      await enqueue(t, async () => {
+        await drain(t);
+        if (t.executor)
+          scheduleFlush(t);
+      });
+    },
+    async turnEnded(ctx) {
+      const t = turn;
+      turn = newTurn();
+      stopTimer(t);
+      t.ctx ??= deps.contextFor();
+      await enqueue(t, async () => {
+        await drain(t);
+        if (t.executor && t.ctx) {
+          await t.executor.executeFlush(createFlushOp(t.ctx.sessionId, "result"), t.ctx);
+          t.executor.closeCurrentPost(t.ctx);
+        }
+        if (t.queued.length > 0) {
+          ctx.logger.warn(`tool details: ${t.queued.length} line(s) dropped, the turn has no post to thread under`);
+          t.queued = [];
+        }
+      });
+    },
+    link: () => null,
+    wake() {
+      const t = turn;
+      if (deps.holdUntilTurnEnd || t.ctx || t.queued.length === 0)
+        return;
+      enqueue(t, async () => {
+        await drain(t);
+        if (t.executor)
+          scheduleFlush(t);
+      }).catch(() => {
+        return;
+      });
+    },
+    reset() {
+      const t = turn;
+      t.dead = true;
+      stopTimer(t);
+      t.executor?.reset();
+      turn = newTurn();
+    }
+  };
+}
+
+// src/operations/tool-details/types.ts
+var noneSink = {
+  append: async () => {
+    return;
+  },
+  turnEnded: async () => {
+    return;
+  },
+  link: () => null,
+  reset: () => {
+    return;
+  }
+};
+
 // src/operations/message-manager.ts
 init_types();
 
@@ -60009,9 +60275,66 @@ class ContentExecutor extends BaseExecutor {
       currentPostId: null,
       currentPostContent: "",
       pendingContent: "",
-      updateTimer: null
+      updateTimer: null,
+      header: null,
+      headerDirty: false,
+      headerPostId: null,
+      headerBody: "",
+      turnOpen: false,
+      paragraphBreak: false
     };
   }
+  setHeader(line) {
+    if (!this.state.turnOpen) {
+      this.state.turnOpen = true;
+      this.state.headerPostId = this.state.currentPostId;
+      this.state.headerBody = this.state.currentPostContent;
+    }
+    this.state.header = line;
+    this.state.headerDirty = true;
+  }
+  getHeaderPostId() {
+    return this.state.headerPostId;
+  }
+  abandonHeaderTurn() {
+    this.state.header = null;
+    this.state.headerDirty = false;
+    this.state.headerPostId = null;
+    this.state.headerBody = "";
+    this.state.turnOpen = false;
+  }
+  getRenderedCurrentPost() {
+    const postId = this.state.currentPostId;
+    if (!postId)
+      return null;
+    return { postId, text: this.renderFor(postId, this.state.currentPostContent) };
+  }
+  renderFor(postId, body) {
+    if (this.state.header && postId !== null && postId === this.state.headerPostId) {
+      return body ? `${this.state.header}
+
+${body}` : this.state.header;
+    }
+    return body;
+  }
+  headerReserve(postId) {
+    const header = this.state.header;
+    if (!header)
+      return 0;
+    const applies = postId === this.state.headerPostId || postId === null && this.state.headerPostId === null && this.state.turnOpen;
+    return applies ? header.length + 2 : 0;
+  }
+  async renderHeaderOnly(ctx) {
+    this.state.headerDirty = false;
+    if (this.state.headerPostId) {
+      const postId = this.state.headerPostId;
+      await this.tryUpdatePost(ctx, postId, this.state.headerBody, "header", { reason: "header_update", headerLength: this.state.header?.length ?? 0 }, { reason: "header_update_failed" }, () => {}, () => {});
+      return;
+    }
+    if (this.state.header && this.state.turnOpen) {
+      await this.createNewPost(ctx, "", "");
+    }
+  }
   getInitialState() {
     return ContentExecutor.createInitialState();
   }
@@ -60023,7 +60346,11 @@ class ContentExecutor extends BaseExecutor {
   }
   async tryUpdatePost(ctx, postId, content, logTag, successDetails, failureDetails, onSuccess, onFailure) {
     try {
-      await ctx.platform.updatePost(postId, content);
+      await ctx.platform.updatePost(postId, this.renderFor(postId, content));
+      if (postId === this.state.headerPostId) {
+        this.state.headerBody = content;
+        this.state.headerDirty = false;
+      }
       onSuccess();
       ctx.threadLogger?.logExecutor("content", "update", postId, successDetails, logTag);
     } catch (err) {
@@ -60045,8 +60372,14 @@ class ContentExecutor extends BaseExecutor {
       }, "closeCurrentPost");
     }
   }
+  markParagraphBreak() {
+    this.state.paragraphBreak = true;
+  }
   async executeAppend(op, _ctx) {
-    if (op.isToolOutput && this.state.pendingContent.length > 0) {
+    const breakBefore = this.state.paragraphBreak && !op.isToolOutput;
+    if (!op.isToolOutput)
+      this.state.paragraphBreak = false;
+    if ((op.isToolOutput || breakBefore) && this.state.pendingContent.length > 0) {
       if (!this.state.pendingContent.endsWith(`
 
 `)) {
@@ -60079,10 +60412,21 @@ class ContentExecutor extends BaseExecutor {
       this.flush(ctx, "soft_threshold");
     }, delayMs);
   }
-  async flush(ctx, _reason) {
+  async flush(ctx, reason) {
     if (!this.state.pendingContent.trim()) {
+      if (this.state.headerDirty)
+        await this.renderHeaderOnly(ctx);
+      if (reason === "result")
+        this.state.turnOpen = false;
       return;
     }
+    await this.flushPending(ctx);
+    if (this.state.headerDirty)
+      await this.renderHeaderOnly(ctx);
+    if (reason === "result")
+      this.state.turnOpen = false;
+  }
+  async flushPending(ctx) {
     const pendingAtFlushStart = this.state.pendingContent;
     let content = ctx.formatter.formatMarkdown(pendingAtFlushStart).trim();
     const { maxLength: MAX_POST_LENGTH, hardThreshold: HARD_CONTINUATION_THRESHOLD } = ctx.platform.getMessageLimits();
@@ -60098,13 +60442,14 @@ class ContentExecutor extends BaseExecutor {
       combinedContent = content;
     }
     const shouldBreakEarly = this.state.currentPostId && combinedContent.length > MIN_BREAK_THRESHOLD && ctx.contentBreaker.shouldFlushEarly(combinedContent);
-    if (this.state.currentPostId && (combinedContent.length > HARD_CONTINUATION_THRESHOLD || shouldBreakEarly)) {
+    const reserve = this.headerReserve(this.state.currentPostId);
+    if (this.state.currentPostId && (combinedContent.length + reserve > HARD_CONTINUATION_THRESHOLD || shouldBreakEarly)) {
       await this.handleSplit(ctx, combinedContent, pendingAtFlushStart, HARD_CONTINUATION_THRESHOLD);
       return;
     }
-    if (content.length > MAX_POST_LENGTH) {
+    if (this.state.currentPostId && content.length + reserve > MAX_POST_LENGTH) {
       ctx.logger.warn(`Content too long (${content.length}), truncating`);
-      content = truncateMessageSafely(content, MAX_POST_LENGTH, ctx.formatter.formatItalic("... (truncated)"));
+      content = truncateMessageSafely(content, MAX_POST_LENGTH - reserve, ctx.formatter.formatItalic("... (truncated)"));
     }
     if (this.state.currentPostId) {
       const postId = this.state.currentPostId;
@@ -60119,7 +60464,7 @@ class ContentExecutor extends BaseExecutor {
       } else {
         combinedContent = content;
       }
-      if (combinedContent.length > MAX_POST_LENGTH) {
+      if (combinedContent.length + reserve > MAX_POST_LENGTH) {
         ctx.logger.debug(`Combined content (${combinedContent.length}) would exceed max (${MAX_POST_LENGTH}), creating continuation post`);
         ctx.threadLogger?.logExecutor("content", "create_start", "none", {
           contentLength: content.length,
@@ -60139,18 +60484,57 @@ class ContentExecutor extends BaseExecutor {
         this.state.currentPostContent = "";
       });
     } else {
-      const chunks = splitContentForHeight(content, ctx.contentBreaker);
+      const chunks = splitContentForHeight(content, ctx.contentBreaker).flatMap((chunk) => chunk.length + reserve > MAX_POST_LENGTH ? splitByLength(chunk, HARD_CONTINUATION_THRESHOLD - reserve) : [chunk]);
       ctx.threadLogger?.logExecutor("content", "create_start", "none", {
         contentLength: content.length,
         chunkCount: chunks.length,
         reason: "no_currentPostId"
       }, "flush");
-      for (let i = 0;i < chunks.length; i++) {
-        await this.createNewPost(ctx, chunks[i], pendingAtFlushStart);
-        if (i < chunks.length - 1) {
-          this.state.currentPostId = null;
-          this.state.currentPostContent = "";
+      await this.postChunks(ctx, chunks, pendingAtFlushStart, false);
+    }
+  }
+  async splitOversized(ctx, content, pendingAtFlushStart, hardThreshold) {
+    const postId = this.state.currentPostId;
+    if (!postId)
+      return false;
+    const reserve = this.headerReserve(postId);
+    if (content.length + reserve <= ctx.platform.getMessageLimits().maxLength)
+      return false;
+    const [firstPiece, ...rest] = splitByLength(content, hardThreshold - reserve);
+    let landed = false;
+    await this.tryUpdatePost(ctx, postId, firstPiece, "handleSplit", { reason: "oversized_code_block", contentLength: content.length, pieces: rest.length + 1 }, { reason: "oversized_code_block_failed" }, () => {
+      landed = true;
+    }, () => {
+      if (postId === this.state.headerPostId)
+        this.state.headerBody = firstPiece;
+    });
+    this.state.currentPostId = null;
+    this.state.currentPostContent = "";
+    if (landed)
+      this.clearFlushedContent(pendingAtFlushStart);
+    await this.postChunks(ctx, rest, pendingAtFlushStart, landed);
+    return true;
+  }
+  async postChunks(ctx, chunks, pendingAtFlushStart, flushCleared) {
+    let cleared = flushCleared;
+    for (let i = 0;i < chunks.length; i++) {
+      const created = await this.createNewPost(ctx, chunks[i], cleared ? "" : pendingAtFlushStart);
+      if (!created) {
+        if (cleared) {
+          this.state.pendingContent = chunks.slice(i).join(`
+
+`) + (this.state.pendingContent ? `
+
+${this.state.pendingContent}` : "");
         }
+        this.state.currentPostId = null;
+        this.state.currentPostContent = "";
+        return;
+      }
+      cleared = true;
+      if (i < chunks.length - 1) {
+        this.state.currentPostId = null;
+        this.state.currentPostContent = "";
       }
     }
   }
@@ -60211,6 +60595,8 @@ class ContentExecutor extends BaseExecutor {
     }
     if (codeBlockOpenPosition !== undefined) {
       if (codeBlockOpenPosition === 0) {
+        if (await this.splitOversized(ctx, content, pendingAtFlushStart, hardThreshold))
+          return;
         if (this.state.currentPostId) {
           const postId = this.state.currentPostId;
           await this.tryUpdatePost(ctx, postId, content, "handleSplit", { reason: "code_block_at_start", contentLength: content.length }, { reason: "code_block_at_start_failed" }, () => {
@@ -60228,6 +60614,8 @@ class ContentExecutor extends BaseExecutor {
       if (breakBeforeCodeBlock > 0) {
         breakPoint = breakBeforeCodeBlock;
       } else {
+        if (await this.splitOversized(ctx, content, pendingAtFlushStart, hardThreshold))
+          return;
         if (this.state.currentPostId) {
           const postId = this.state.currentPostId;
           await this.tryUpdatePost(ctx, postId, content, "handleSplit", { reason: "no_break_before_code_block", contentLength: content.length }, { reason: "no_break_before_code_block_failed" }, () => {
@@ -60243,20 +60631,47 @@ class ContentExecutor extends BaseExecutor {
     }
     const firstPart = content.substring(0, breakPoint).trim();
     const remainder = content.substring(breakPoint).trim();
+    let firstPartLanded = false;
     if (this.state.currentPostId) {
       const postId = this.state.currentPostId;
-      await this.tryUpdatePost(ctx, postId, firstPart, "handleSplit", { reason: "split_first_part", firstPartLength: firstPart.length, remainderLength: remainder.length }, { reason: "split_first_part_failed" }, () => {}, () => {});
+      await this.tryUpdatePost(ctx, postId, firstPart, "handleSplit", { reason: "split_first_part", firstPartLength: firstPart.length, remainderLength: remainder.length }, { reason: "split_first_part_failed" }, () => {
+        firstPartLanded = true;
+      }, () => {
+        if (postId === this.state.headerPostId) {
+          this.state.headerBody = firstPart;
+        }
+      });
     }
     this.state.currentPostId = null;
     this.state.currentPostContent = "";
     if (remainder) {
-      await this.createNewPost(ctx, remainder, pendingAtFlushStart);
+      const MAX_POST_LENGTH = ctx.platform.getMessageLimits().maxLength;
+      const reserve = this.headerReserve(null);
+      const chunks = remainder.length + reserve > MAX_POST_LENGTH ? splitByLength(remainder, hardThreshold - reserve) : [remainder];
+      if (firstPartLanded)
+        this.clearFlushedContent(pendingAtFlushStart);
+      await this.postChunks(ctx, chunks, pendingAtFlushStart, firstPartLanded);
+    } else if (firstPartLanded) {
+      this.clearFlushedContent(pendingAtFlushStart);
     }
   }
   async createNewPost(ctx, content, pendingAtFlushStart) {
+    const header = this.state.header;
+    const becomesHeaderPost = this.state.turnOpen && this.state.headerPostId === null && header !== null;
+    const rendered = becomesHeaderPost && header !== null ? content ? `${header}
+
+${content}` : header : content;
+    const adoptAsHeaderPost = (postId) => {
+      if (becomesHeaderPost) {
+        this.state.headerPostId = postId;
+        this.state.headerBody = content;
+        this.state.headerDirty = false;
+      }
+    };
     if (this.onBumpTaskList) {
-      const bumpedPostId = await this.onBumpTaskList(content, ctx);
+      const bumpedPostId = await this.onBumpTaskList(rendered, ctx);
       if (bumpedPostId) {
+        adoptAsHeaderPost(bumpedPostId);
         this.state.currentPostId = bumpedPostId;
         this.state.currentPostContent = content;
         this.clearFlushedContent(pendingAtFlushStart);
@@ -60267,11 +60682,12 @@ class ContentExecutor extends BaseExecutor {
         if (this.onBumpTaskListToBottom) {
           await this.onBumpTaskListToBottom();
         }
-        return;
+        return true;
       }
     }
     try {
-      const post = await ctx.createPost(content, { type: "content" });
+      const post = await ctx.createPost(rendered, { type: "content" });
+      adoptAsHeaderPost(post.id);
       this.state.currentPostId = post.id;
       this.state.currentPostContent = content;
       this.clearFlushedContent(pendingAtFlushStart);
@@ -60283,8 +60699,10 @@ class ContentExecutor extends BaseExecutor {
       if (this.onBumpTaskListToBottom) {
         await this.onBumpTaskListToBottom();
       }
+      return true;
     } catch (err) {
       ctx.logger.error(`Failed to create post: ${err}`);
+      return false;
     }
   }
   clearFlushedContent(flushedContent) {
@@ -60295,6 +60713,40 @@ class ContentExecutor extends BaseExecutor {
     }
   }
 }
+var FENCE_LINE = /^```.*$/gm;
+var FENCE_CLOSE = "\n```";
+function splitByLength(text, max) {
+  const room = max - FENCE_CLOSE.length;
+  if (room < 1)
+    return [text];
+  const pieces = [];
+  let rest = text;
+  while (rest.length > max) {
+    let cut = rest.lastIndexOf(`
+`, room);
+    if (cut < room * 0.5)
+      cut = room;
+    let piece = rest.slice(0, cut);
+    let next = rest.slice(cut).replace(/^\n+/, "");
+    const fences = piece.match(FENCE_LINE) ?? [];
+    const opener = fences[fences.length - 1];
+    if (fences.length % 2 === 1 && opener !== undefined && `${opener}
+${next}`.length < rest.length) {
+      piece += FENCE_CLOSE;
+      next = `${opener}
+${next}`;
+    }
+    pieces.push(piece);
+    if (next.length >= rest.length) {
+      rest = next;
+      break;
+    }
+    rest = next;
+  }
+  if (rest)
+    pieces.push(rest);
+  return pieces;
+}
 // src/operations/executors/task-list.ts
 init_emoji();
 class TaskListExecutor extends BaseExecutor {
@@ -61806,6 +62258,8 @@ class MessageManager {
   platform;
   postTracker;
   contentBreaker;
+  toolActivity;
+  toolActivityExecutor = null;
   turnMarker;
   flushInFlight = null;
   turn = 0;
@@ -61897,6 +62351,39 @@ class MessageManager {
       updateLastMessage: options.updateLastMessage,
       events: this.events
     });
+    this.toolActivity = options.toolActivity ?? { activity: "full", details: "none" };
+    if (this.toolActivity.activity !== "full") {
+      const sink = this.toolActivity.details === "thread" ? createThreadSink({
+        contextFor: () => this.toolDetailsContext(),
+        holdUntilTurnEnd: !isDcmThreadId(this.threadId),
+        makeExecutor: () => new ContentExecutor({ registerPost: options.registerPost, updateLastMessage: () => {
+          return;
+        } })
+      }) : noneSink;
+      this.toolActivityExecutor = new ToolActivityExecutor({
+        mode: this.toolActivity.activity,
+        sink,
+        onHeader: (line) => {
+          this.contentExecutor.setHeader(line);
+          this.scheduleFlush(this.getExecutorContext());
+        }
+      });
+    }
+  }
+  toolDetailsContext() {
+    const replyPost = this.contentExecutor.getHeaderPostId();
+    if (!replyPost)
+      return null;
+    const root = isDcmThreadId(this.threadId) ? replyPost : this.threadId;
+    const base = this.getExecutorContext();
+    return {
+      ...base,
+      createPost: async (content, options) => {
+        const post = await this.platform.createPost(content, root);
+        this.registerPost(post.id, { ...options, type: "tool_details" });
+        return post;
+      }
+    };
   }
   async handleEvent(event) {
     const logger = log16.forSession(this.sessionId);
@@ -61906,6 +62393,7 @@ class MessageManager {
       toolStartTimes: this.toolStartTimes,
       taskTracker: this.taskTracker,
       detailed: true,
+      toolActivity: this.toolActivity.activity,
       worktreeInfo: this.worktreePath && this.worktreeBranch ? { path: this.worktreePath, branch: this.worktreeBranch } : undefined
     };
     const ops = transformEvent(event, transformCtx);
@@ -61958,6 +62446,10 @@ class MessageManager {
     try {
       if (isContentOp(op)) {
         await this.handleContentOp(op, ctx);
+      } else if (isToolActivityOp(op)) {
+        if (op.kind === "start")
+          this.contentExecutor.markParagraphBreak();
+        await this.toolActivityExecutor?.execute(op, ctx);
       } else if (isFlushOp(op)) {
         await this.handleFlushOp(op, ctx);
       } else if (isTaskListOp(op)) {
@@ -61997,25 +62489,26 @@ class MessageManager {
       await this.flushInFlight.catch(() => {
         return;
       });
-    if (op.reason === "result")
-      this.turn++;
+    const turn = op.reason === "result" ? ++this.turn : this.turn;
     await this.runTrackedFlush(op, ctx);
     if (op.reason === "result") {
-      await this.markTurnComplete(ctx, op.resultOk !== false);
+      await this.toolActivityExecutor?.afterResultFlush(ctx);
+      await this.markTurnComplete(ctx, op.resultOk !== false, turn);
     }
   }
-  async markTurnComplete(ctx, ok) {
+  async markTurnComplete(ctx, ok, turn) {
     if (this.turnMarker.mode === "off")
       return;
-    const { currentPostId, currentPostContent } = this.contentExecutor.getState();
-    if (!currentPostId)
+    const current = this.contentExecutor.getRenderedCurrentPost();
+    if (!current)
       return;
+    const { postId: currentPostId, text: currentPostText } = current;
     try {
       if (this.turnMarker.mode === "metadata") {
-        await this.platform.updatePost(currentPostId, currentPostContent, {
+        await this.platform.updatePost(currentPostId, currentPostText, {
           metadata: {
             event_type: TURN_COMPLETE_EVENT_TYPE,
-            event_payload: { v: TURN_COMPLETE_PAYLOAD_VERSION, session: this.sessionId, turn: this.turn, ok }
+            event_payload: { v: TURN_COMPLETE_PAYLOAD_VERSION, session: this.sessionId, turn, ok }
           }
         });
       } else {
@@ -62035,6 +62528,7 @@ class MessageManager {
     });
     this.flushInFlight = running;
     await running;
+    this.toolActivityExecutor?.wake();
   }
   scheduleFlush(ctx) {
     if (this.flushTimer)
@@ -62431,15 +62925,21 @@ class MessageManager {
     this.pendingBridgeQuestion = null;
   }
   clearClaudeSessionState() {
+    this.clearTurnState();
     this.toolStartTimes.clear();
     this.taskTracker.clear();
     this.denyPendingBridgeRequests("Claude was restarted before a decision was made");
   }
+  clearTurnState() {
+    this.toolActivityExecutor?.reset();
+    this.contentExecutor.abandonHeaderTurn();
+  }
   reset() {
     this.cancelScheduledFlush();
     this.toolStartTimes.clear();
     this.taskTracker.clear();
     this.contentExecutor.reset();
+    this.toolActivityExecutor?.reset();
     this.taskListExecutor.reset();
     this.questionApprovalExecutor.reset();
     this.messageApprovalExecutor.reset();
@@ -65782,6 +66282,7 @@ async function restartClaudeSession(session, cliOptions, ctx, actionName) {
   await session.claude.kill();
   await ctx.ops.flush(session);
   session.messageManager?.denyPendingBridgeRequests("Claude was restarted before a decision was made");
+  session.messageManager?.clearTurnState();
   if (!cliOptions.resume) {
     session.messageManager?.clearClaudeSessionState();
   }
@@ -67301,6 +67802,7 @@ function createMessageManager(session, ctx) {
     sessionId: session.sessionId,
     worktreePath: session.worktreeInfo?.worktreePath,
     worktreeBranch: session.worktreeInfo?.branch,
+    toolActivity: ctx.ops.getPlatformOverhead(session.platformId).tools,
     turnMarker: ctx.ops.getPlatformOverhead(session.platformId).turnMarker,
     registerPost: (postId, options) => {
       ctx.ops.registerPost(postId, session.threadId);
@@ -72954,7 +73456,8 @@ class SessionManager extends EventEmitter4 {
       sessionHeader: options?.overhead?.sessionHeader ?? DEFAULT_OVERHEAD_VISIBILITY,
       stickyMessage: options?.overhead?.stickyMessage ?? DEFAULT_OVERHEAD_VISIBILITY,
       lifecycle: options?.overhead?.lifecycle ?? DEFAULT_OVERHEAD_VISIBILITY,
-      turnMarker: options?.overhead?.turnMarker ?? DEFAULT_TURN_MARKER
+      turnMarker: options?.overhead?.turnMarker ?? DEFAULT_TURN_MARKER,
+      tools: options?.overhead?.tools ?? DEFAULT_TOOL_ACTIVITY
     });
     this.platformMemory.set(platformId, options?.memory ?? DEFAULT_MEMORY_CONFIG);
     this.platformRoutines.set(platformId, options?.routinesEnabled ?? true);
@@ -73094,7 +73597,8 @@ class SessionManager extends EventEmitter4 {
         sessionHeader: DEFAULT_OVERHEAD_VISIBILITY,
         stickyMessage: DEFAULT_OVERHEAD_VISIBILITY,
         lifecycle: DEFAULT_OVERHEAD_VISIBILITY,
-        turnMarker: DEFAULT_TURN_MARKER
+        turnMarker: DEFAULT_TURN_MARKER,
+        tools: DEFAULT_TOOL_ACTIVITY
       },
       getPlatformMemoryConfig: (pid) => this.platformMemory.get(pid) ?? DEFAULT_MEMORY_CONFIG,
       isRoutinesEnabled: (pid) => this.platformRoutines.get(pid) ?? true,
@@ -87519,7 +88023,8 @@ async function startWithoutDaemon() {
     session.addPlatform(platformConfig.id, client, {
       overhead: {
         ...resolvePresentationOverhead(platformConfig, `platforms[${platformConfig.id}]`),
-        turnMarker: resolveTurnMarker(platformConfig.turnMarker, platformConfig.turnMarkerEmoji, platformConfig.type, `platforms[${platformConfig.id}]`)
+        turnMarker: resolveTurnMarker(platformConfig.turnMarker, platformConfig.turnMarkerEmoji, platformConfig.type, `platforms[${platformConfig.id}]`),
+        tools: resolveToolActivity(platformConfig.toolActivity, platformConfig.toolDetails, `platforms[${platformConfig.id}]`)
       },
       memory: resolveMemoryConfig(platformConfig.memory, `platforms[${platformConfig.id}].memory`),
       routinesEnabled: resolveRoutinesEnabled(platformConfig.routines, `platforms[${platformConfig.id}].routines`),
@@ -87547,6 +88052,7 @@ async function startWithoutDaemon() {
         overhead: {
           ...resolvePresentationOverhead(dmConfig, `dm[${dmConfig.id}]`),
           stickyMessage: "hidden",
+          tools: resolveToolActivity(dmConfig.toolActivity, dmConfig.toolDetails, `dm[${dmConfig.id}]`),
           turnMarker: resolveTurnMarker(dmConfig.turnMarker, dmConfig.turnMarkerEmoji, dmConfig.type, `dm[${dmConfig.id}]`)
         },
         memory: resolveMemoryConfig(dmConfig.memory, `dm[${dmConfig.id}].memory`),

package/dist/mcp/mcp-server.js

@@ -34639,11 +34639,6 @@ var METADATA_STORE_PATH = path.join(stateHome(), ".claude-threads", "worktree-me
 var log5 = createLogger("helpers");
 var sessionLog = createSessionLog(log5);
 
-// src/operations/message-manager.ts
-init_types();
-
-// src/operations/task-tracker.ts
-var VALID_STATUSES = new Set(["pending", "in_progress", "completed"]);
 // src/platform/utils.ts
 function formatWebSocketError(err) {
   if (err instanceof Error)
@@ -34764,6 +34759,12 @@ function isDcmThreadId(threadId) {
 function resolvePostThreadId(threadId) {
   return isDcmThreadId(threadId) ? undefined : threadId;
 }
+
+// src/operations/message-manager.ts
+init_types();
+
+// src/operations/task-tracker.ts
+var VALID_STATUSES = new Set(["pending", "in_progress", "completed"]);
 // src/operations/executors/task-list.ts
 init_emoji();
 // src/operations/executors/subagent.ts

package/docs/CONFIGURATION.md

@@ -423,6 +423,32 @@ platforms:
 
 Note: the per-platform `stickyMessage: <mode>` field is distinct from the top-level `Config.stickyMessage: { description, footer }` block, which still customizes the full sticky for platforms not in `hidden` mode.
 
+#### Tool activity: a summary line instead of the stream
+
+By default every tool Claude uses streams into the reply (`Bash …`, `Read …`, `↳ ✓`). For an assistant-style channel where you want the answer, not the shopping, two per-platform fields change that:
+
+```yaml
+platforms:
+  - id: slack-assistant
+    type: slack
+    # ... credentials ...
+    toolActivity: summary    # full (default) | summary | hidden
+    toolDetails: thread      # thread (default for summary) | none
+```
+
+| `toolActivity` | The reply |
+|---|---|
+| `full` | unchanged: every tool inline with its completion indicator |
+| `summary` | one live line at the top of the turn's post, `🔧 12 tools · 40 s · Bash`, updated as tools run; the name is the tool most recently started, so the line shows what the bot is doing; `· 1 ❌` when a tool failed. Claude's text follows |
+| `hidden` | nothing about tools at all |
+
+| `toolDetails` | Where the full tool stream goes when `toolActivity` is not `full` |
+|---|---|
+| `thread` | posted as replies in a thread under the turn's post (in a thread-mode session, after the reply in the same thread, once the turn ends: Slack has no nested threads) |
+| `none` | dropped |
+
+Permission prompts, plan approvals, questions, task lists and errors post as before in every mode. `toolDetails` with `full`, or `thread` with `hidden`, is a startup config error.
+
 #### End-of-turn marker
 
 Integrations that read the channel (a voice front end, a phone bridge, a dashboard) need to know when Claude's answer is complete. The daemon streams by editing one post, so without help they can only guess from the text going quiet. With a marker, the daemon stamps the turn's last reply post the moment the turn ends:

package/docs/quiet-tools-spec.md

@@ -0,0 +1,232 @@
+# Tool activity: summary line instead of the stream, details one click away
+
+Upstream discussion: anneschuth/claude-threads#505 (shape proposed in the
+2026-09-02 comment; `hidden` was agreed by the maintainer on 2026-08-25).
+
+## What it does
+
+Today every tool Claude uses renders into the reply post as it happens
+(`Bash …`, `Read …`, then `↳ ✓ (5s)`), and there is no switch. For a coding
+session that is the point; for an assistant-style channel the answer is
+buried under the commands that produced it.
+
+Two per-platform settings, beside `sessionHeader` / `stickyMessage` /
+`lifecycle`:
+
+```yaml
+platforms:
+  - id: assistant
+    type: slack
+    toolActivity: summary     # full (default) | summary | hidden
+    toolDetails: thread       # thread (default with summary) | none
+```
+
+`toolDetails: file`, with `toolDetailsDir` / `toolDetailsUrl`, arrives in
+PR 2 (see **Delivery**); this PR rejects those three at startup.
+
+| `toolActivity` | The reply post |
+|---|---|
+| `full` | unchanged: every tool inline with its `↳` indicator |
+| `summary` | one **live line at the top of the turn's post**, `🔧 12 tools · 40 s · Bash`, updated as tools start and finish; the name is the tool most recently started, so the line says what the bot is doing and not only how much it has done (@thejdubb02 in #505); `· 1 ❌` appended when a tool failed; with `toolDetails: file` and a URL (PR 2), the line links to the details page. Claude's text follows as today |
+| `hidden` | nothing about tools at all, and no `↳` orphans. What the maintainer agreed to in #505 |
+
+| `toolDetails` | Where the full rendering goes when `toolActivity` is not `full` |
+|---|---|
+| `thread` | posted as replies **in a thread under the turn's post**, streamed the same way the reply is (edit-in-place, split on length). In a thread-mode session the turn's post is already a thread reply and Slack has no nested threads, so the details land in the same thread after the reply; that is `full` with the tools moved below the answer, and documented as such |
+| `file` (PR 2) | appended to `<toolDetailsDir>/<platformId>/<sessionId>/<turn>.html`, one file per turn, plus `index.html` per session listing turns. Serving the directory is the operator's job. With `toolDetailsUrl` the summary line links to `<url>/<platformId>/<sessionId>/<turn>.html` |
+| `none` | the summary only |
+
+Default: `full` / `none`, so an existing config behaves exactly as before.
+`summary` without `toolDetails` means `thread`. Config errors, thrown with
+the field path at startup like the other per-platform fields: `toolDetails`
+with `full`; `hidden` with `thread` (hidden has no post of its own to hang
+a thread on; use `summary`, or — from PR 2 — `file`); `toolDetailsDir` /
+`toolDetailsUrl` with anything but `file`.
+
+Untouched in every mode: permission prompts, plan approvals, questions, task
+lists, `send_file`, the bug button, session errors. Those are not tool
+rendering; they are interactive or they are failures. A *tool* that fails is
+Claude's business and shows only as the `❌` count.
+
+## Why
+
+- Assistant use (#505): replies only, but the receipt stays one click away.
+- Anything that consumes the reply post as an answer — text-to-speech, a
+  digest, a downstream bot — has to skip forty tool lines to find it.
+  `summary` is what makes the post the answer.
+- `file` (PR 2) over a web server outside the daemon: the daemon writes, the
+  operator's existing server serves, nothing new listens. ⚠️ Tool details
+  contain command lines and outputs. The directory must be served **behind
+  auth**; the spec says so, the README says so, and the default is no URL.
+
+Considered and dropped: a git commit per tool call (a `Read` has no diff;
+forty commits a turn would wreck the repo the agent works in) and a
+`!tools` runtime toggle (round 2 if anyone asks; the config is enough to
+start).
+
+## How
+
+### Transformer (`src/operations/transformer.ts`)
+
+Tool rendering already produces ops tagged `isToolOutput` (tool_use display,
+`server_tool_use`, and the `↳` result indicator). With `toolActivity !== 'full'`
+the transformer emits, instead of those ops, a `tool_activity` op:
+
+```ts
+{ type: 'tool_activity', kind: 'start', toolUseId, name, display }      // display: the same rendered line
+{ type: 'tool_activity', kind: 'end',   toolUseId, ok, elapsedMs, display } // display: the ↳ line
+```
+
+Nothing else in the transformer changes; special tools keep their own ops.
+A `TransformContext.toolActivity` field carries the mode (default `full`).
+
+### Executors
+
+- **`ToolActivityExecutor`** (new, `src/operations/executors/tool-activity.ts`)
+  owns the per-turn counter
+  `{ started, finished, failed, firstStartAt, lastEndAt, lastTool }`
+  and renders the summary line. On each op it asks the content executor to
+  re-render the post header (debounced through the existing 500 ms flush).
+  The transformer emits an explicit `{ kind: 'turn_end' }` op from the
+  `result` event (inferring it from a flush reason would couple the executor
+  to flush internals); the last render is the final line, the sink's
+  `turnEnded()` runs, and the counter resets.
+- **Content executor**: every write to a post goes through one
+  `renderPost(postId, body)` path (today `flush`, `handleSplit` and the
+  task-list repurpose branch each write directly; Codex plan review), which
+  prepends the header when `postId` is the turn's first post. A header
+  update with nothing pending still renders: it edits the first post, or
+  creates it header-only when the turn has no post yet. Length and height
+  decisions for the first post use `header + body`. Gains an optional
+  `header` (one line) that belongs to the **first post of the turn only**. The executor remembers
+  `turnFirstPostId` and that post's body; a header update re-renders that
+  post as `header + body` even after streaming has moved on to a
+  continuation post. Continuation posts never carry the header, so a split
+  cannot bake a stale receipt into one post and a fresh one into the next
+  (Gemini plan review). The header is not part of `pendingContent`, so
+  splitting and length checks are unchanged apart from counting its length
+  on the first post.
+- **Details sinks** (`src/operations/tool-details/`), one interface:
+  `ToolDetailsSink { append(op): void; turnEnded(): Promise<void>; linkFor(turn): string | null }`.
+  - `thread`: a second `ContentExecutor` **without** the task-list bump
+    callbacks (they would let a details post repurpose the task-list post)
+    and with its own `createPost` that registers posts as `tool_details`
+    and does **not** touch `updateLastMessage` (a details post must never
+    become the session's "latest reply"). Its context posts with
+    `rootId = turnFirstPostId` of the main executor in direct-channel mode
+    (the reply is a channel post, the details thread hangs under it), and
+    `rootId = the session's threadId` in thread mode (Slack has no nested
+    threads; `thread_ts` of a reply is rejected with `invalid_thread_ts`), so
+    there the details land as peers after the reply. In that mode they are
+    held until the turn ends and then posted in one go, because a details
+    post made mid-turn would sit above reply posts that are still to come.
+    In direct-channel mode they have a thread of their own and stream the
+    `display` strings exactly like the reply, starting lazily on the first
+    tool of a turn; if the main post does not exist yet, the first header
+    render creates it. Each turn's details are written on a serial chain of
+    their own, so a streaming flush and the turn-end flush never overlap,
+    and the next turn's first tool never lands in the turn being closed.
+  - `file`: appends escaped `<pre>` blocks to the turn file (ANSI escape
+    sequences stripped first; tool output is full of them) and rewrites
+    `index.html`; deterministic path so the link exists from the first tool.
+    Writes are sequential per session. A write error is **reported once in
+    the channel as a system error and the sink stops for the session**; the
+    reply itself keeps streaming. Not silent, not fatal to the answer.
+  - `none`: no-op.
+
+### Config (`src/config/types.ts`)
+
+`PlatformInstanceConfig.toolActivity?`, `toolDetails?`, `toolDetailsDir?`,
+`toolDetailsUrl?`; resolved next to the overhead fields into
+`PlatformOverhead.tools: { activity, details, dir, url }` with the same
+`resolve…` validation and the same wiring through `src/index.ts` →
+`SessionManager` → `TransformContext` / executor options as `lifecycle`.
+
+### Turn boundaries
+
+A turn's counter and its details sink describe **one CLI process**. Every
+respawn — `!cd`, a worktree switch, `!permissions interactive` — kills that
+process mid-turn, so both must start over. `MessageManager.clearTurnState()`
+does exactly that and `restartClaudeSession` calls it unconditionally:
+`clearClaudeSessionState()` is not enough, because a resume restart
+deliberately skips it to keep its task numbering.
+
+### Delivery
+
+Two PRs so each stands alone:
+
+1. `pr/quiet-tools`: `full | summary | hidden`, `thread | none`, transformer
+   op, executors, config, tests. (#505's tool half.)
+2. `pr/quiet-tools-file` stacked on it: the `file` sink and `toolDetailsUrl`.
+
+## Tests (first)
+
+- transformer: each mode × (tool_use, server_tool_use, tool_result ok/error,
+  special tool) → which ops come out; in both quiet modes no
+  `append_content` op carries tool text, and the start time is consumed by
+  the end op (so `elapsedMs` exists and no `↳` line can orphan).
+- ToolActivityExecutor: counter and line text through start/end/error/turn
+  end; the line with and without a link.
+- content executor: header stays on the first post of the turn across a split;
+  the continuation post has none; a header update after the split edits the
+  first post, not the current one; a final header set after a split still
+  reaches the header post when the closing text lands on the continuation.
+- respawn: `restartClaudeSession` clears the turn in progress whether or not
+  it resumes, and the next turn's counter starts at one.
+- content executor: header rendered above content, survives a split, counted
+  in length checks.
+- thread sink: posts under the main post's id, lazy start, thread-mode
+  degrade.
+- file sink: path, escaping, index rewrite, write error propagates.
+- config: defaults, `summary` implies `thread`, `toolDetails` with `full`
+  rejected with the config path in the message.
+
+## Decisions
+
+| Decision | Why |
+|---|---|
+| Two fields, not one enum | what to show and where to keep the rest are independent; `summary+file` and `hidden+file` are both real |
+| Summary line at the top of the post, not the bottom | it is the receipt for the whole turn and must not move as text streams in |
+| Details as a second content executor | the streaming, splitting and rate behaviour already exist there; a new poster would reimplement them badly |
+| `file` writes HTML, not markdown | the point is a browser; markdown in a browser is raw text |
+| Keep an explicit `turn_end` op rather than finalising from the existing `StatusUpdateOp` (Codex suggested the latter) | `turn_end` is emitted *before* the final flush, so the final summary line lands in the same edit as the last text; the status op comes after the flush and would cost one more edit of the first post per turn |
+| The header post is the post being written when the turn's first tool starts, not retroactively the turn's very first post (Codex code review asked for the latter) | if a long preamble was already split into two posts before the first tool, the receipt sits on the post where the work began and the details thread hangs there too; it never moves after adoption, which is what the reader needs. Chasing the earlier post would mean editing a post the executor has already left behind, for no gain |
+| No HTTP server in the daemon | one more listener, auth, TLS; the operator already has a web server |
+| Flat fields, not a nested `tools:` block (Gemini suggested nesting) | the sibling dials `sessionHeader` / `stickyMessage` / `lifecycle` are flat and `toolActivity` is the name agreed in #505; PR 1 adds two fields, the dir/url pair only comes with PR 2 |
+| Resolved settings ride on the same per-platform record as the other dials (Gemini wanted a separate type) | one map, one wiring path, already threaded through `SessionManager`; a second type for two fields is plumbing for its own sake |
+
+## Open
+
+(none)
+
+## Decided during review
+
+- Q-001: does the summary line also name the last tool (`· Bash`)? **Yes.**
+  @thejdubb02 asked for it in #505 and the maintainer agreed in #534: once
+  the stream is hidden this line is the only liveness signal, so it has to
+  say what the bot is doing. MCP names are shortened to the tool part —
+  `mcp__playwright__browser_navigate` renders as `browser_navigate`.
+
+## Lessons learned
+
+- **A reset nobody calls is not a reset.** `ToolActivityExecutor.reset()`
+  existed from the first commit and had a test, but its only caller,
+  `MessageManager.reset()`, has no production caller — the respawn paths use
+  `clearClaudeSessionState()`. Tested and wired are different properties.
+- **A one-line header on a post that a split has already left behind needs
+  its own render pass.** Every write clears `headerDirty` only when it wrote
+  the header post; a flush that writes the continuation post leaves the
+  header running forever. Checking the flag after the flush covers every
+  path, which comparing post ids at each call site would not.
+- **Half the turn state lived somewhere else.** Resetting the tool counter
+  left `turnOpen` / `headerPostId` set on the content executor, which clear
+  only on a `result` flush — and a respawn never produces one. The next
+  turn's summary then edited the abandoned reply and its details threaded
+  under it: the *same* bug, one layer down. `abandonHeaderTurn()` releases
+  the other half.
+- **A retry needs to know what was attempted, not what was confirmed.**
+  `headerBody` advanced only on a successful update, so a lost response left
+  it stale — and the new header re-render then overwrote the post with the
+  older body, deleting text the platform had already accepted. Since an
+  update replaces the whole post, recording the attempted body is right
+  whether or not it arrived.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-threads",
-  "version": "1.38.1",
+  "version": "1.39.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",
@@ -78,7 +78,7 @@
     "cross-spawn": "^7.0.6",
     "diff": "^8.0.3",
     "express-rate-limit": "^8.3.0",
-    "hono": "4.13.7",
+    "hono": "4.13.8",
     "ink": "^6.6.0",
     "ink-scroll-view": "^0.3.5",
     "js-yaml": "^4.3.1",
@@ -102,7 +102,7 @@
     "@types/ws": "^8.18.0",
     "eslint": "^10.7.0",
     "husky": "^9.1.7",
-    "knip": "6.35.1",
+    "knip": "6.37.0",
     "lint-staged": "^17.0.4",
     "prettier": "^3.9.5",
     "react-devtools-core": "^8.0.0",