claude-threads 1.38.0 → 1.39.0

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,
@@ -2514,20 +2538,487 @@ var init_types = __esm(() => {
   };
 });
 
-// src/utils/spawn.ts
-import { spawn as nodeSpawn, spawnSync as nodeSpawnSync } from "child_process";
-function addWindowsShell(options) {
-  if (isWindows && options.shell === undefined) {
-    return { ...options, shell: true };
+// node_modules/isexe/windows.js
+var require_windows = __commonJS(function(exports, module) {
+  module.exports = isexe;
+  isexe.sync = sync;
+  var fs = __require("fs");
+  function checkPathExt(path, options) {
+    var pathext = options.pathExt !== undefined ? options.pathExt : process.env.PATHEXT;
+    if (!pathext) {
+      return true;
+    }
+    pathext = pathext.split(";");
+    if (pathext.indexOf("") !== -1) {
+      return true;
+    }
+    for (var i = 0;i < pathext.length; i++) {
+      var p = pathext[i].toLowerCase();
+      if (p && path.substr(-p.length).toLowerCase() === p) {
+        return true;
+      }
+    }
+    return false;
   }
-  return options;
-}
+  function checkStat(stat, path, options) {
+    if (!stat.isSymbolicLink() && !stat.isFile()) {
+      return false;
+    }
+    return checkPathExt(path, options);
+  }
+  function isexe(path, options, cb) {
+    fs.stat(path, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, path, options));
+    });
+  }
+  function sync(path, options) {
+    return checkStat(fs.statSync(path), path, options);
+  }
+});
+
+// node_modules/isexe/mode.js
+var require_mode = __commonJS(function(exports, module) {
+  module.exports = isexe;
+  isexe.sync = sync;
+  var fs = __require("fs");
+  function isexe(path, options, cb) {
+    fs.stat(path, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, options));
+    });
+  }
+  function sync(path, options) {
+    return checkStat(fs.statSync(path), options);
+  }
+  function checkStat(stat, options) {
+    return stat.isFile() && checkMode(stat, options);
+  }
+  function checkMode(stat, options) {
+    var mod = stat.mode;
+    var uid = stat.uid;
+    var gid = stat.gid;
+    var myUid = options.uid !== undefined ? options.uid : process.getuid && process.getuid();
+    var myGid = options.gid !== undefined ? options.gid : process.getgid && process.getgid();
+    var u = parseInt("100", 8);
+    var g = parseInt("010", 8);
+    var o = parseInt("001", 8);
+    var ug = u | g;
+    var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+    return ret;
+  }
+});
+
+// node_modules/isexe/index.js
+var require_isexe = __commonJS(function(exports, module) {
+  var fs = __require("fs");
+  var core;
+  if (process.platform === "win32" || global.TESTING_WINDOWS) {
+    core = require_windows();
+  } else {
+    core = require_mode();
+  }
+  module.exports = isexe;
+  isexe.sync = sync;
+  function isexe(path, options, cb) {
+    if (typeof options === "function") {
+      cb = options;
+      options = {};
+    }
+    if (!cb) {
+      if (typeof Promise !== "function") {
+        throw new TypeError("callback not provided");
+      }
+      return new Promise(function(resolve, reject) {
+        isexe(path, options || {}, function(er, is) {
+          if (er) {
+            reject(er);
+          } else {
+            resolve(is);
+          }
+        });
+      });
+    }
+    core(path, options || {}, function(er, is) {
+      if (er) {
+        if (er.code === "EACCES" || options && options.ignoreErrors) {
+          er = null;
+          is = false;
+        }
+      }
+      cb(er, is);
+    });
+  }
+  function sync(path, options) {
+    try {
+      return core.sync(path, options || {});
+    } catch (er) {
+      if (options && options.ignoreErrors || er.code === "EACCES") {
+        return false;
+      } else {
+        throw er;
+      }
+    }
+  }
+});
+
+// node_modules/which/which.js
+var require_which = __commonJS(function(exports, module) {
+  var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+  var path = __require("path");
+  var COLON = isWindows ? ";" : ":";
+  var isexe = require_isexe();
+  var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+  var getPathInfo = (cmd, opt) => {
+    const colon = opt.colon || COLON;
+    const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
+      ...isWindows ? [process.cwd()] : [],
+      ...(opt.path || process.env.PATH || "").split(colon)
+    ];
+    const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+    const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+    if (isWindows) {
+      if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
+        pathExt.unshift("");
+    }
+    return {
+      pathEnv,
+      pathExt,
+      pathExtExe
+    };
+  };
+  var which = (cmd, opt, cb) => {
+    if (typeof opt === "function") {
+      cb = opt;
+      opt = {};
+    }
+    if (!opt)
+      opt = {};
+    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+    const found = [];
+    const step = (i) => new Promise((resolve, reject) => {
+      if (i === pathEnv.length)
+        return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+      const ppRaw = pathEnv[i];
+      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+      const pCmd = path.join(pathPart, cmd);
+      const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+      resolve(subStep(p, i, 0));
+    });
+    const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+      if (ii === pathExt.length)
+        return resolve(step(i + 1));
+      const ext = pathExt[ii];
+      isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+        if (!er && is) {
+          if (opt.all)
+            found.push(p + ext);
+          else
+            return resolve(p + ext);
+        }
+        return resolve(subStep(p, i, ii + 1));
+      });
+    });
+    return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+  };
+  var whichSync = (cmd, opt) => {
+    opt = opt || {};
+    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+    const found = [];
+    for (let i = 0;i < pathEnv.length; i++) {
+      const ppRaw = pathEnv[i];
+      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+      const pCmd = path.join(pathPart, cmd);
+      const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+      for (let j = 0;j < pathExt.length; j++) {
+        const cur = p + pathExt[j];
+        try {
+          const is = isexe.sync(cur, { pathExt: pathExtExe });
+          if (is) {
+            if (opt.all)
+              found.push(cur);
+            else
+              return cur;
+          }
+        } catch (ex) {}
+      }
+    }
+    if (opt.all && found.length)
+      return found;
+    if (opt.nothrow)
+      return null;
+    throw getNotFoundError(cmd);
+  };
+  module.exports = which;
+  which.sync = whichSync;
+});
+
+// node_modules/path-key/index.js
+var require_path_key = __commonJS(function(exports, module) {
+  var pathKey = (options = {}) => {
+    const environment = options.env || process.env;
+    const platform = options.platform || process.platform;
+    if (platform !== "win32") {
+      return "PATH";
+    }
+    return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+  };
+  module.exports = pathKey;
+  module.exports.default = pathKey;
+});
+
+// node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS(function(exports, module) {
+  var path = __require("path");
+  var which = require_which();
+  var getPathKey = require_path_key();
+  function resolveCommandAttempt(parsed, withoutPathExt) {
+    const env = parsed.options.env || process.env;
+    const cwd = process.cwd();
+    const hasCustomCwd = parsed.options.cwd != null;
+    const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
+    if (shouldSwitchCwd) {
+      try {
+        process.chdir(parsed.options.cwd);
+      } catch (err) {}
+    }
+    let resolved;
+    try {
+      resolved = which.sync(parsed.command, {
+        path: env[getPathKey({ env })],
+        pathExt: withoutPathExt ? path.delimiter : undefined
+      });
+    } catch (e) {} finally {
+      if (shouldSwitchCwd) {
+        process.chdir(cwd);
+      }
+    }
+    if (resolved) {
+      resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+    }
+    return resolved;
+  }
+  function resolveCommand(parsed) {
+    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+  }
+  module.exports = resolveCommand;
+});
+
+// node_modules/cross-spawn/lib/util/escape.js
+var require_escape = __commonJS(function(exports, module) {
+  var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+  function escapeCommand(arg) {
+    arg = arg.replace(metaCharsRegExp, "^$1");
+    return arg;
+  }
+  function escapeArgument(arg, doubleEscapeMetaChars) {
+    arg = `${arg}`;
+    arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+    arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+    arg = `"${arg}"`;
+    arg = arg.replace(metaCharsRegExp, "^$1");
+    if (doubleEscapeMetaChars) {
+      arg = arg.replace(metaCharsRegExp, "^$1");
+    }
+    return arg;
+  }
+  exports.command = escapeCommand;
+  exports.argument = escapeArgument;
+});
+
+// node_modules/shebang-regex/index.js
+var require_shebang_regex = __commonJS(function(exports, module) {
+  module.exports = /^#!(.*)/;
+});
+
+// node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS(function(exports, module) {
+  var shebangRegex = require_shebang_regex();
+  module.exports = (string = "") => {
+    const match = string.match(shebangRegex);
+    if (!match) {
+      return null;
+    }
+    const [path, argument] = match[0].replace(/#! ?/, "").split(" ");
+    const binary = path.split("/").pop();
+    if (binary === "env") {
+      return argument;
+    }
+    return argument ? `${binary} ${argument}` : binary;
+  };
+});
+
+// node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS(function(exports, module) {
+  var fs = __require("fs");
+  var shebangCommand = require_shebang_command();
+  function readShebang(command) {
+    const size = 150;
+    const buffer = Buffer.alloc(size);
+    let fd;
+    try {
+      fd = fs.openSync(command, "r");
+      fs.readSync(fd, buffer, 0, size, 0);
+      fs.closeSync(fd);
+    } catch (e) {}
+    return shebangCommand(buffer.toString());
+  }
+  module.exports = readShebang;
+});
+
+// node_modules/cross-spawn/lib/parse.js
+var require_parse = __commonJS(function(exports, module) {
+  var path = __require("path");
+  var resolveCommand = require_resolveCommand();
+  var escape = require_escape();
+  var readShebang = require_readShebang();
+  var isWin = process.platform === "win32";
+  var isExecutableRegExp = /\.(?:com|exe)$/i;
+  var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+  function detectShebang(parsed) {
+    parsed.file = resolveCommand(parsed);
+    const shebang = parsed.file && readShebang(parsed.file);
+    if (shebang) {
+      parsed.args.unshift(parsed.file);
+      parsed.command = shebang;
+      return resolveCommand(parsed);
+    }
+    return parsed.file;
+  }
+  function parseNonShell(parsed) {
+    if (!isWin) {
+      return parsed;
+    }
+    const commandFile = detectShebang(parsed);
+    const needsShell = !isExecutableRegExp.test(commandFile);
+    if (parsed.options.forceShell || needsShell) {
+      const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+      parsed.command = path.normalize(parsed.command);
+      parsed.command = escape.command(parsed.command);
+      parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+      const shellCommand = [parsed.command].concat(parsed.args).join(" ");
+      parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
+      parsed.command = process.env.comspec || "cmd.exe";
+      parsed.options.windowsVerbatimArguments = true;
+    }
+    return parsed;
+  }
+  function parse(command, args, options) {
+    if (args && !Array.isArray(args)) {
+      options = args;
+      args = null;
+    }
+    args = args ? args.slice(0) : [];
+    options = Object.assign({}, options);
+    const parsed = {
+      command,
+      args,
+      options,
+      file: undefined,
+      original: {
+        command,
+        args
+      }
+    };
+    return options.shell ? parsed : parseNonShell(parsed);
+  }
+  module.exports = parse;
+});
+
+// node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS(function(exports, module) {
+  var isWin = process.platform === "win32";
+  function notFoundError(original, syscall) {
+    return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+      code: "ENOENT",
+      errno: "ENOENT",
+      syscall: `${syscall} ${original.command}`,
+      path: original.command,
+      spawnargs: original.args
+    });
+  }
+  function hookChildProcess(cp, parsed) {
+    if (!isWin) {
+      return;
+    }
+    const originalEmit = cp.emit;
+    cp.emit = function(name, arg1) {
+      if (name === "exit") {
+        const err = verifyENOENT(arg1, parsed);
+        if (err) {
+          return originalEmit.call(cp, "error", err);
+        }
+      }
+      return originalEmit.apply(cp, arguments);
+    };
+  }
+  function verifyENOENT(status, parsed) {
+    if (isWin && status === 1 && !parsed.file) {
+      return notFoundError(parsed.original, "spawn");
+    }
+    return null;
+  }
+  function verifyENOENTSync(status, parsed) {
+    if (isWin && status === 1 && !parsed.file) {
+      return notFoundError(parsed.original, "spawnSync");
+    }
+    return null;
+  }
+  module.exports = {
+    hookChildProcess,
+    verifyENOENT,
+    verifyENOENTSync,
+    notFoundError
+  };
+});
+
+// node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS(function(exports, module) {
+  var cp = __require("child_process");
+  var parse = require_parse();
+  var enoent = require_enoent();
+  function spawn(command, args, options) {
+    const parsed = parse(command, args, options);
+    const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+    enoent.hookChildProcess(spawned, parsed);
+    return spawned;
+  }
+  function spawnSync(command, args, options) {
+    const parsed = parse(command, args, options);
+    const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+    result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+    return result;
+  }
+  module.exports = spawn;
+  module.exports.spawn = spawn;
+  module.exports.sync = spawnSync;
+  module.exports._parse = parse;
+  module.exports._enoent = enoent;
+});
+
+// src/utils/spawn.ts
+import { win32 as win32Path } from "path";
 function crossSpawn(command, args, options) {
-  return nodeSpawn(command, args, addWindowsShell(options ?? {}));
+  return import_cross_spawn.default(command, args, options ?? {});
+}
+function crossSpawnSync(command, args, options) {
+  return import_cross_spawn.default.sync(command, args, options ?? {});
+}
+function findWindowsGitBash(env, exists) {
+  const systemRoot = (env.SystemRoot ?? env.SYSTEMROOT ?? "C:\\Windows").toLowerCase();
+  const isWslLauncher = (dir) => {
+    const lower = dir.toLowerCase().replace(/[\\/]+$/, "");
+    return lower.startsWith(`${systemRoot}\\system32`) || lower.startsWith(`${systemRoot}\\sysnative`) || lower.endsWith("\\windowsapps");
+  };
+  const pathDirs = (env.PATH ?? env.Path ?? "").split(";").filter(Boolean);
+  const candidates = [
+    ...pathDirs.filter((dir) => !isWslLauncher(dir)).map((dir) => win32Path.join(dir, "bash.exe")),
+    ...[env.ProgramFiles, env.ProgramW6432, env["ProgramFiles(x86)"]].filter((dir) => Boolean(dir)).map((dir) => win32Path.join(dir, "Git", "bin", "bash.exe")),
+    ...env.LOCALAPPDATA ? [win32Path.join(env.LOCALAPPDATA, "Programs", "Git", "bin", "bash.exe")] : []
+  ];
+  return candidates.find((candidate) => exists(candidate)) ?? null;
 }
-var isWindows;
+var import_cross_spawn;
 var init_spawn = __esm(() => {
-  isWindows = process.platform === "win32";
+  import_cross_spawn = __toESM(require_cross_spawn(), 1);
 });
 
 // node_modules/semver/internal/constants.js
@@ -2970,7 +3461,7 @@ var require_semver = __commonJS(function(exports, module) {
 });
 
 // node_modules/semver/functions/parse.js
-var require_parse = __commonJS(function(exports, module) {
+var require_parse2 = __commonJS(function(exports, module) {
   var SemVer = require_semver();
   var parse = (version, options, throwErrors = false) => {
     if (version instanceof SemVer) {
@@ -2990,7 +3481,7 @@ var require_parse = __commonJS(function(exports, module) {
 
 // node_modules/semver/functions/valid.js
 var require_valid = __commonJS(function(exports, module) {
-  var parse = require_parse();
+  var parse = require_parse2();
   var valid = (version, options) => {
     const v = parse(version, options);
     return v ? v.version : null;
@@ -3000,7 +3491,7 @@ var require_valid = __commonJS(function(exports, module) {
 
 // node_modules/semver/functions/clean.js
 var require_clean = __commonJS(function(exports, module) {
-  var parse = require_parse();
+  var parse = require_parse2();
   var clean = (version, options) => {
     const s = parse(version.trim().replace(/^[=v]+/, ""), options);
     return s ? s.version : null;
@@ -3028,7 +3519,7 @@ var require_inc = __commonJS(function(exports, module) {
 
 // node_modules/semver/functions/diff.js
 var require_diff = __commonJS(function(exports, module) {
-  var parse = require_parse();
+  var parse = require_parse2();
   var diff = (version1, version2) => {
     const v1 = parse(version1, null, true);
     const v2 = parse(version2, null, true);
@@ -3090,7 +3581,7 @@ var require_patch = __commonJS(function(exports, module) {
 
 // node_modules/semver/functions/prerelease.js
 var require_prerelease = __commonJS(function(exports, module) {
-  var parse = require_parse();
+  var parse = require_parse2();
   var prerelease = (version, options) => {
     const parsed = parse(version, options);
     return parsed && parsed.prerelease.length ? parsed.prerelease : null;
@@ -3236,7 +3727,7 @@ var require_cmp = __commonJS(function(exports, module) {
 // node_modules/semver/functions/coerce.js
 var require_coerce = __commonJS(function(exports, module) {
   var SemVer = require_semver();
-  var parse = require_parse();
+  var parse = require_parse2();
   var { safeRe: re, t } = require_re();
   var coerce = (version, options) => {
     if (version instanceof SemVer) {
@@ -3278,7 +3769,7 @@ var require_coerce = __commonJS(function(exports, module) {
 
 // node_modules/semver/functions/truncate.js
 var require_truncate = __commonJS(function(exports, module) {
-  var parse = require_parse();
+  var parse = require_parse2();
   var constants = require_constants();
   var SemVer = require_semver();
   var truncate = (version, truncation, options) => {
@@ -4286,7 +4777,7 @@ var require_semver2 = __commonJS(function(exports, module) {
   var constants = require_constants();
   var SemVer = require_semver();
   var identifiers = require_identifiers();
-  var parse = require_parse();
+  var parse = require_parse2();
   var valid = require_valid();
   var clean = require_clean();
   var inc = require_inc();
@@ -55272,7 +55763,7 @@ import process8 from "node:process";
 import path9 from "node:path";
 import os4 from "node:os";
 import fs4 from "node:fs";
-var isWindows2 = process8.platform === "win32";
+var isWindows = process8.platform === "win32";
 var readRc = (filePath) => {
   try {
     return import_ini.default.parse(fs4.readFileSync(filePath, "utf8")).prefix;
@@ -55280,7 +55771,7 @@ var readRc = (filePath) => {
 };
 var getEnvNpmPrefix = () => Object.keys(process8.env).reduce((prefix, name) => /^npm_config_prefix$/i.test(name) ? process8.env[name] : prefix, undefined);
 var getGlobalNpmrc = () => {
-  if (isWindows2 && process8.env.APPDATA) {
+  if (isWindows && process8.env.APPDATA) {
     return path9.join(process8.env.APPDATA, "/npm/etc/npmrc");
   }
   if (process8.execPath.includes("/Cellar/node")) {
@@ -55293,7 +55784,7 @@ var getGlobalNpmrc = () => {
   }
 };
 var getDefaultNpmPrefix = () => {
-  if (isWindows2) {
+  if (isWindows) {
     const { APPDATA } = process8.env;
     return APPDATA ? path9.join(APPDATA, "npm") : path9.dirname(process8.execPath);
   }
@@ -55319,7 +55810,7 @@ var getNpmPrefix = () => {
 };
 var npmPrefix = path9.resolve(getNpmPrefix());
 var getYarnWindowsDirectory = () => {
-  if (isWindows2 && process8.env.LOCALAPPDATA) {
+  if (isWindows && process8.env.LOCALAPPDATA) {
     const dir = path9.join(process8.env.LOCALAPPDATA, "Yarn");
     if (fs4.existsSync(dir)) {
       return dir;
@@ -55348,8 +55839,8 @@ var getYarnPrefix = () => {
 var globalDirectory = {};
 globalDirectory.npm = {};
 globalDirectory.npm.prefix = npmPrefix;
-globalDirectory.npm.packages = path9.join(npmPrefix, isWindows2 ? "node_modules" : "lib/node_modules");
-globalDirectory.npm.binaries = isWindows2 ? npmPrefix : path9.join(npmPrefix, "bin");
+globalDirectory.npm.packages = path9.join(npmPrefix, isWindows ? "node_modules" : "lib/node_modules");
+globalDirectory.npm.binaries = isWindows ? npmPrefix : path9.join(npmPrefix, "bin");
 var yarnPrefix = path9.resolve(getYarnPrefix());
 globalDirectory.yarn = {};
 globalDirectory.yarn.prefix = yarnPrefix;
@@ -59034,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";
 }
@@ -59070,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",
@@ -59132,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 [];
@@ -59181,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());
           }
@@ -59195,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();
@@ -59224,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++;
     }
   }
@@ -59263,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) {
@@ -59278,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 [];
 }
@@ -59287,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;
@@ -59377,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();
 
@@ -59542,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();
   }
@@ -59556,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) {
@@ -59578,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(`
 
 `)) {
@@ -59612,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();
@@ -59631,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;
@@ -59652,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,
@@ -59672,14 +60484,28 @@ 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");
+      let lastPosted = null;
       for (let i = 0;i < chunks.length; i++) {
-        await this.createNewPost(ctx, chunks[i], pendingAtFlushStart);
+        const created = await this.createNewPost(ctx, chunks[i], lastPosted ? "" : pendingAtFlushStart);
+        if (!created) {
+          if (lastPosted) {
+            this.state.pendingContent = chunks.slice(i).join(`
+
+`) + (this.state.pendingContent ? `
+
+${this.state.pendingContent}` : "");
+          }
+          this.state.currentPostId = null;
+          this.state.currentPostContent = "";
+          break;
+        }
+        lastPosted = { id: this.state.currentPostId, content: this.state.currentPostContent };
         if (i < chunks.length - 1) {
           this.state.currentPostId = null;
           this.state.currentPostContent = "";
@@ -59778,7 +60604,11 @@ class ContentExecutor extends BaseExecutor {
     const remainder = content.substring(breakPoint).trim();
     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" }, () => {}, () => {
+        if (postId === this.state.headerPostId) {
+          this.state.headerBody = firstPart;
+        }
+      });
     }
     this.state.currentPostId = null;
     this.state.currentPostContent = "";
@@ -59787,9 +60617,22 @@ class ContentExecutor extends BaseExecutor {
     }
   }
   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);
@@ -59800,11 +60643,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);
@@ -59816,8 +60660,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) {
@@ -59828,6 +60674,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 {
@@ -61339,6 +62219,8 @@ class MessageManager {
   platform;
   postTracker;
   contentBreaker;
+  toolActivity;
+  toolActivityExecutor = null;
   turnMarker;
   flushInFlight = null;
   turn = 0;
@@ -61430,6 +62312,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);
@@ -61439,6 +62354,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);
@@ -61491,6 +62407,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)) {
@@ -61530,25 +62450,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 {
@@ -61568,6 +62489,7 @@ class MessageManager {
     });
     this.flushInFlight = running;
     await running;
+    this.toolActivityExecutor?.wake();
   }
   scheduleFlush(ctx) {
     if (this.flushTimer)
@@ -61964,15 +62886,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();
@@ -65315,6 +66243,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();
   }
@@ -66834,6 +67763,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);
@@ -72487,7 +73417,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);
@@ -72627,7 +73558,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,
@@ -73708,7 +74640,7 @@ var isSharedWorker = typeof SharedWorkerGlobalScope !== "undefined" && globalThi
 var isServiceWorker = typeof ServiceWorkerGlobalScope !== "undefined" && globalThis instanceof ServiceWorkerGlobalScope;
 var platform = globalThis.navigator?.userAgentData?.platform;
 var isMacOs = platform === "macOS" || globalThis.navigator?.platform === "MacIntel" || globalThis.navigator?.userAgent?.includes(" Mac ") === true || globalThis.process?.platform === "darwin";
-var isWindows3 = platform === "Windows" || globalThis.navigator?.platform === "Win32" || globalThis.process?.platform === "win32";
+var isWindows2 = platform === "Windows" || globalThis.navigator?.platform === "Win32" || globalThis.process?.platform === "win32";
 var isLinux = platform === "Linux" || globalThis.navigator?.platform?.startsWith("Linux") === true || globalThis.navigator?.userAgent?.includes(" Linux ") === true || globalThis.process?.platform === "linux";
 var isIos = platform === "iOS" || globalThis.navigator?.platform === "MacIntel" && globalThis.navigator?.maxTouchPoints > 1 || /iPad|iPhone|iPod/.test(globalThis.navigator?.platform);
 var isAndroid = platform === "Android" || globalThis.navigator?.platform === "Android" || globalThis.navigator?.userAgent?.includes(" Android ") === true || globalThis.process?.platform === "android";
@@ -73717,7 +74649,7 @@ var isAndroid = platform === "Android" || globalThis.navigator?.platform === "An
 var ESC = "\x1B[";
 var SEP = ";";
 var isTerminalApp = !isBrowser && process11.env.TERM_PROGRAM === "Apple_Terminal";
-var isWindows4 = !isBrowser && process11.platform === "win32";
+var isWindows3 = !isBrowser && process11.platform === "win32";
 var isTmux = !isBrowser && (process11.env.TERM?.startsWith("screen") || process11.env.TERM?.startsWith("tmux") || process11.env.TMUX !== undefined);
 var cwdFunction = isBrowser ? () => {
   throw new Error("`process.cwd()` only works in Node.js, not the browser.");
@@ -73761,7 +74693,7 @@ var scrollUp = ESC + "S";
 var scrollDown = ESC + "T";
 var clearViewport = `${eraseScreen}${ESC}H`;
 var isOldWindows = () => {
-  if (isBrowser || !isWindows4) {
+  if (isBrowser || !isWindows3) {
     return false;
   }
   const parts = os5.release().split(".");
@@ -86036,37 +86968,37 @@ class UpdateScheduler extends EventEmitter8 {
 }
 
 // src/auto-update/installer.ts
+init_spawn();
 init_state_home();
-import { spawn as spawn4, spawnSync } from "child_process";
 import { existsSync as existsSync17, readFileSync as readFileSync12, mkdirSync as mkdirSync8 } from "fs";
 import { dirname as dirname9, resolve as resolve8 } from "path";
 import { homedir as homedir3 } from "os";
 init_logger();
 var log56 = createLogger("installer");
 function detectPackageManager() {
-  const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+  const npmCmd = "npm";
   const originalInstaller = detectOriginalInstaller();
   if (originalInstaller) {
     log56.debug(`Detected original installer: ${originalInstaller}`);
     if (originalInstaller === "bun") {
-      const bunCheck = spawnSync("bun", ["--version"], { stdio: "ignore" });
+      const bunCheck = crossSpawnSync("bun", ["--version"], { stdio: "ignore" });
       if (bunCheck.status === 0) {
         return { cmd: "bun", isBun: true };
       }
       log56.warn("Originally installed with bun, but bun not found. Falling back to npm.");
     } else {
-      const npmCheck = spawnSync(npmCmd, ["--version"], { stdio: "ignore" });
+      const npmCheck = crossSpawnSync(npmCmd, ["--version"], { stdio: "ignore" });
       if (npmCheck.status === 0) {
         return { cmd: npmCmd, isBun: false };
       }
       log56.warn("Originally installed with npm, but npm not found. Falling back to bun.");
     }
   }
-  const bunCheck = spawnSync("bun", ["--version"], { stdio: "ignore" });
+  const bunCheck = crossSpawnSync("bun", ["--version"], { stdio: "ignore" });
   if (bunCheck.status === 0) {
     return { cmd: "bun", isBun: true };
   }
-  const npmCheck = spawnSync(npmCmd, ["--version"], { stdio: "ignore" });
+  const npmCheck = crossSpawnSync(npmCmd, ["--version"], { stdio: "ignore" });
   if (npmCheck.status === 0) {
     return { cmd: npmCmd, isBun: false };
   }
@@ -86085,13 +87017,12 @@ function detectOriginalInstaller() {
     if (scriptPath.startsWith(bunGlobalDir)) {
       return "bun";
     }
-    const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
-    const npmPrefixResult = spawnSync(npmCmd, ["prefix", "-g"], {
+    const npmPrefixResult = crossSpawnSync("npm", ["prefix", "-g"], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
     });
     if (npmPrefixResult.status === 0 && npmPrefixResult.stdout) {
-      const npmPrefix = normalizePath(npmPrefixResult.stdout.trim());
+      const npmPrefix = normalizePath(String(npmPrefixResult.stdout).trim());
       if (scriptPath.startsWith(npmPrefix)) {
         return "npm";
       }
@@ -86181,7 +87112,7 @@ async function installVersion(version) {
     const { cmd, isBun } = pm;
     const args = ["install", "-g", `${PACKAGE_NAME2}@${version}`];
     log56.debug(`Using ${isBun ? "bun" : "npm"} for installation`);
-    const child = spawn4(cmd, args, {
+    const child = crossSpawn(cmd, args, {
       stdio: ["ignore", "pipe", "pipe"],
       env: {
         ...process.env,
@@ -86264,7 +87195,7 @@ class UpdateInstaller {
 
 // src/auto-update/respawn.ts
 init_logger();
-import { spawn as spawn5 } from "child_process";
+init_spawn();
 import { existsSync as existsSync18, statSync as statSync5 } from "fs";
 import { delimiter, join as join18 } from "path";
 var log57 = createLogger("respawn");
@@ -86334,14 +87265,12 @@ function spawnReplacement(argv = process.argv.slice(2), binPath = resolveClaudeT
   const childEnv = { ...process.env };
   delete childEnv.CLAUDE_THREADS_BIN;
   delete childEnv.CLAUDE_THREADS_INTERACTIVE;
-  const useShell = process.platform === "win32";
   let child;
   try {
-    child = spawn5(binPath, argv, {
+    child = crossSpawn(binPath, argv, {
       detached: true,
       stdio: "inherit",
-      env: childEnv,
-      shell: useShell
+      env: childEnv
     });
   } catch (err) {
     log57.error(`spawn() threw: ${err instanceof Error ? err.message : String(err)}`);
@@ -86708,6 +87637,8 @@ async function main() {
     const { spawn } = await import("child_process");
     const { dirname, resolve } = await import("path");
     const { fileURLToPath } = await import("url");
+    const { existsSync } = await import("fs");
+    await Promise.resolve().then(() => init_spawn());
     const __filename2 = fileURLToPath(import.meta.url);
     const __dirname2 = dirname(__filename2);
     const daemonPath = resolve(__dirname2, "..", "bin", "claude-threads-daemon");
@@ -86717,7 +87648,14 @@ async function main() {
     const binPath = __filename2;
     let child;
     if (process.platform === "win32") {
-      child = spawn("bash", [daemonPath, "--restart-on-error", ...args], {
+      const bashPath = findWindowsGitBash(process.env, existsSync);
+      if (!bashPath) {
+        console.error("Auto-restart requires Git for Windows (bash.exe). Starting without auto-restart...");
+        console.error("");
+        await startWithoutDaemon();
+        return;
+      }
+      child = spawn(bashPath, [daemonPath, "--restart-on-error", ...args], {
         stdio: "inherit",
         env: {
           ...process.env,
@@ -87046,7 +87984,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`),
@@ -87074,6 +88013,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`),