@sideboard-ai/core 0.1.263 → 0.1.266

package/dist/chunk-FAGK33E2.js

@@ -0,0 +1,994 @@
+import {
+  clipToolResultForStore
+} from "./chunk-5N4Q46SG.js";
+
+// src/agents/message-parts.ts
+function asRecord(input) {
+  if (input && typeof input === "object" && !Array.isArray(input)) {
+    return input;
+  }
+  return void 0;
+}
+function str(v) {
+  return typeof v === "string" && v.trim() ? v : void 0;
+}
+var CHAT_DETAIL_MAX = 72;
+function clipChatLine(value, max = CHAT_DETAIL_MAX) {
+  const line = value.trim().split(/\r?\n/, 1)[0] ?? "";
+  if (line.length <= max) return line;
+  return `${line.slice(0, Math.max(1, max - 1))}\u2026`;
+}
+var SHELL_BIN_DIR = /^(?:\/usr\/local\/bin|\/usr\/bin|\/bin|\/opt\/homebrew\/bin|\/sbin|\/usr\/sbin)\//;
+function rootedPathWithSpaces(trimmed) {
+  const [head = "", ...rest] = trimmed.split(/\s+/);
+  if (SHELL_BIN_DIR.test(head)) return false;
+  return rest.every((tok) => !/^[-/~$]/.test(tok) && !tok.includes("="));
+}
+function looksLikeFilePath(value) {
+  const trimmed = value.trim();
+  if (!trimmed || /[\r\n;|&<>]/.test(trimmed)) return false;
+  const rooted = trimmed.startsWith("/") || trimmed.startsWith("~/") || /^[A-Za-z]:[\\/]/.test(trimmed);
+  if (/\s/.test(trimmed)) return rooted && rootedPathWithSpaces(trimmed);
+  if (rooted) return true;
+  return trimmed.includes("/") || trimmed.includes("\\");
+}
+function stripWorktreePrefix(path, worktreePath) {
+  if (!worktreePath) return path;
+  const prefix = worktreePath.replace(/[/\\]+$/, "");
+  if (path === prefix || path === `${prefix}/`) return "";
+  if (path.startsWith(`${prefix}/`)) return path.slice(prefix.length + 1);
+  return path;
+}
+function visibleToolRowDetail(detail, description, worktreePath) {
+  if (!detail?.trim()) return void 0;
+  const raw = detail.trim();
+  const desc = (description ?? "").trim();
+  if (!looksLikeFilePath(raw)) {
+    const clipped = clipChatLine(raw);
+    if (!clipped || desc === clipped || desc === raw) return void 0;
+    return clipped;
+  }
+  const rel = stripWorktreePrefix(raw, worktreePath);
+  if (!rel) return void 0;
+  const base = fileBasename(rel);
+  if (desc && (desc === base || desc.endsWith(` ${base}`))) return void 0;
+  if (rel.length <= 42) return rel;
+  const parts = rel.split(/[/\\]/).filter(Boolean);
+  if (parts.length >= 2) return `\u2026/${parts.slice(-2).join("/")}`;
+  return base;
+}
+function isSkillToolName(name) {
+  const n = (name ?? "").trim();
+  if (/^(Skill|SlashCommand)$/i.test(n)) return true;
+  return /(?:^|__)Skill$/i.test(n);
+}
+function skillCommandFromInput(input) {
+  const raw = str(input?.skill) ?? str(input?.command) ?? str(input?.name) ?? str(input?.skill_name) ?? str(input?.skillName);
+  if (raw) return raw.replace(/^\//, "").trim() || void 0;
+  const path = str(input?.file_path) ?? str(input?.path);
+  if (path && /SKILL\.md$/i.test(path)) {
+    const parts = path.replace(/\\/g, "/").split("/");
+    const dir = parts[parts.length - 2];
+    if (dir && dir !== "skills") return dir;
+  }
+  return void 0;
+}
+function looksLikeComposerSkillExpansion(text) {
+  const t = text.trim();
+  return /^## Skill: \//m.test(t) && /Follow this skill for the request above:/i.test(t);
+}
+var SKILL_FRONTMATTER_NAME = /^\s*name\s*:\s*['"]?([A-Za-z0-9][A-Za-z0-9._-]*)['"]?\s*$/m;
+function skillNameFromFrontmatter(text) {
+  const t = text.trim();
+  if (!t) return void 0;
+  let yaml = t;
+  if (!yaml.startsWith("---")) {
+    const at = t.search(/(?:^|\n)---(?:\r?\n)/);
+    if (at < 0 || at > 800) return void 0;
+    yaml = t.slice(at).replace(/^\n/, "");
+  }
+  if (!yaml.startsWith("---")) return void 0;
+  const close = yaml.indexOf("\n---", 3);
+  if (close < 0) return void 0;
+  return yaml.slice(3, close).match(SKILL_FRONTMATTER_NAME)?.[1];
+}
+function skillCommandFromBody(text) {
+  return skillNameFromFrontmatter(text) ?? text.match(/^## Skill: \/([A-Za-z0-9][A-Za-z0-9._-]*)/m)?.[1] ?? text.match(/^Launching skill:\s*\/?([A-Za-z0-9][A-Za-z0-9._-]*)/im)?.[1];
+}
+function looksLikeSkillBody(text) {
+  const t = text.trim();
+  if (!t) return false;
+  if (looksLikeComposerSkillExpansion(t)) return true;
+  if (skillNameFromFrontmatter(t) != null) return true;
+  return /^Launching skill:/im.test(t) && /Base directory for this skill:/i.test(t);
+}
+function looksLikeIncompleteSkillDump(text) {
+  const t = text.trim();
+  if (!t || looksLikeSkillBody(t)) return false;
+  if (/^## Skill: \//m.test(t)) return true;
+  if (/^Launching skill:/im.test(t)) return true;
+  if (/Base directory for this skill:/i.test(t)) return true;
+  return t.startsWith("---") && SKILL_FRONTMATTER_NAME.test(t);
+}
+function isCompactToolName(name) {
+  const short = (name ?? "").replace(/^mcp__[^_]+__/, "").trim();
+  return /^(Compact|ConversationCompact|summarize_context|SummarizeContext|SummarizeConversation)$/i.test(
+    short
+  );
+}
+function isContextCompactDone(text) {
+  return /\bContext compressed\b/i.test(text.trim());
+}
+function isContextCompactInProgress(text) {
+  const t = text.trim();
+  if (isContextCompactDone(t)) return false;
+  return /^Compressing context/i.test(t);
+}
+function isSystemStatusThinking(event) {
+  if (event.replace) return true;
+  const t = (event.data ?? "").trim();
+  if (!t) return true;
+  if (/^API retry\b/i.test(t)) return true;
+  if (/^MCP:/i.test(t)) return true;
+  if (isContextCompactInProgress(t) || isContextCompactDone(t)) return true;
+  return false;
+}
+function looksLikeConversationSummary(text) {
+  const t = text.trim();
+  if (t.length < 80) return false;
+  if (/<summarized_conversation\b/i.test(t) || /<conversation_summary\b/i.test(t)) {
+    return true;
+  }
+  if (/this session is being continued from a previous conversation/i.test(t)) {
+    return true;
+  }
+  if (/conversation compacted|replaced with a summary/i.test(t)) return true;
+  if (/^## Prior summary\b/m.test(t)) return true;
+  if (/_Automatic extractive summary/i.test(t)) return true;
+  if (/"context_summary"\s*:/.test(t)) return true;
+  if (/^(?:#+\s*)?(?:conversation summary|summary of (?:the )?conversation|compacted (?:conversation|context))\b/im.test(
+    t
+  )) {
+    return true;
+  }
+  return false;
+}
+function toolDetail(name, input) {
+  if (isSkillToolName(name) || isCompactToolName(name)) return void 0;
+  if (!input) return void 0;
+  const command = str(input.command) ?? str(input.cmd);
+  if (command) return clipChatLine(command);
+  const pattern = str(input.pattern) ?? str(input.glob) ?? str(input.glob_pattern);
+  const isSearch = /grep|glob|search|ripgrep|findfiles|semsearch/i.test(name);
+  if (isSearch && pattern) {
+    return pattern.length > 80 ? `${pattern.slice(0, 77)}\u2026` : pattern;
+  }
+  const path = str(input.file_path) ?? str(input.path) ?? str(input.filePath) ?? str(input.filename);
+  if (path) return path;
+  if (pattern) return pattern.length > 80 ? `${pattern.slice(0, 77)}\u2026` : pattern;
+  const query = str(input.query) ?? str(input.prompt);
+  if (query) return query.length > 80 ? `${query.slice(0, 77)}\u2026` : query;
+  try {
+    const raw = JSON.stringify(input);
+    return raw.length > 80 ? `${raw.slice(0, 77)}\u2026` : raw;
+  } catch {
+    return name;
+  }
+}
+function toolDescription(name, input) {
+  const n = name.replace(/^mcp__/, "").replace(/__/g, " \xB7 ");
+  if (/^get_record_types$|recordTypes/i.test(name)) return "List record types";
+  if (/connectedAgentRequest/i.test(name)) {
+    return str(input?.agent_id) ? `Ask connected agent` : "Ask connected agent";
+  }
+  if (/present_artifact$/i.test(name)) {
+    return str(input?.title) ? `Present ${str(input?.title)}` : "Present artifact";
+  }
+  if (/present_plan$/i.test(name)) {
+    return str(input?.title) ? `Plan ${str(input?.title)}` : "Present plan";
+  }
+  if (/present_schema$/i.test(name)) {
+    return str(input?.title) ? `Schema ${str(input?.title)}` : "Present schema";
+  }
+  if (/present_files$/i.test(name)) {
+    return str(input?.title) ? `Files ${str(input?.title)}` : "Present files";
+  }
+  if (/wait_for_job$/i.test(name)) {
+    return str(input?.id) ? `Wait for ${str(input?.id)}` : "Wait for job";
+  }
+  if (/stop_job$/i.test(name)) {
+    return str(input?.id) ? `Stop ${str(input?.id)}` : "Stop job";
+  }
+  if (/list_run_scripts$/i.test(name)) return "List run scripts";
+  if (/run_dev_script$/i.test(name)) {
+    return str(input?.name) ? `Start ${str(input?.name)}` : "Start Dev script";
+  }
+  if (/stop_dev_script$/i.test(name)) {
+    return str(input?.name) ? `Stop ${str(input?.name)}` : "Stop Dev script";
+  }
+  if (/get_run_log$/i.test(name)) {
+    return str(input?.name) ? `Read ${str(input?.name)} log` : "Read Dev log";
+  }
+  if (/notify_orchestrator$/i.test(name)) return "Notify orchestrator";
+  if (/list_schedules$/i.test(name)) return "List schedules";
+  if (/create_schedule$/i.test(name)) {
+    return str(input?.name) ? `Schedule ${str(input?.name)}` : "Create schedule";
+  }
+  if (/update_schedule$/i.test(name)) return "Update schedule";
+  if (/delete_schedule$/i.test(name)) return "Delete schedule";
+  if (/run_schedule$/i.test(name)) return "Run schedule";
+  if (isSkillToolName(name)) {
+    const cmd = skillCommandFromInput(input);
+    return cmd ? `Using /${cmd}` : "Using skill";
+  }
+  if (isCompactToolName(name)) {
+    const trigger = str(input?.trigger);
+    if (trigger && !/^auto$/i.test(trigger) && trigger !== "injected") {
+      return `Summarized conversation (${trigger})`;
+    }
+    return "Summarized conversation";
+  }
+  if (isSubagentToolName(name)) {
+    const desc = str(input?.description);
+    const sub = asRecord(input?.subagentType);
+    const kind = str(sub?.name) ?? str(sub?.kind) ?? str(input?.subagent_type) ?? str(input?.subagentType);
+    if (/^spawn_agent$/i.test(name)) {
+      return str(input?.prompt) ?? desc ?? "Subagent";
+    }
+    if (/connectedAgentRequest/i.test(name)) {
+      return str(input?.agent_id) ? `Ask connected agent` : "Ask connected agent";
+    }
+    if (desc && kind) return `${kind}: ${desc}${subagentLiveSuffix(input)}`;
+    if (desc) return `${desc}${subagentLiveSuffix(input)}`;
+    return `Subagent${subagentLiveSuffix(input)}`;
+  }
+  if (/^(create|update)_artifact$/i.test(name.replace(/^mcp__[^_]+__/, ""))) {
+    return str(input?.title) ? `Artifact ${str(input?.title)}` : "Artifact";
+  }
+  if (!input) return n;
+  if (/bash|shell|terminal/i.test(name) && str(input.command)) {
+    const cmd = str(input.command);
+    if (/git\s+fetch/i.test(cmd)) return "Fetch latest from origin and check status";
+    if (/git\s+status/i.test(cmd)) return "Check git status";
+    if (/git\s+log/i.test(cmd)) return "Inspect recent commits";
+    if (/git\s+branch/i.test(cmd)) return "List branches";
+    if (/grep|rg\b/i.test(cmd)) return "Search repository";
+    return "Run shell command";
+  }
+  if (/edit|write|apply/i.test(name)) {
+    const path = str(input.file_path) ?? str(input.path);
+    return path ? `Edit ${path.split("/").pop()}` : "Edit file";
+  }
+  if (/read/i.test(name)) {
+    const path = str(input.file_path) ?? str(input.path);
+    return path ? `Read ${path.split("/").pop()}` : "Read file";
+  }
+  if (/grep/i.test(name)) return "Search files";
+  if (/glob/i.test(name)) return "Find files";
+  const compact = n.replace(/[_-]/g, "");
+  if (/^taskoutput$/i.test(compact)) {
+    return str(input.task_id) ? `Wait for ${str(input.task_id)}` : "Wait for background task";
+  }
+  if (/^taskstop$/i.test(compact)) {
+    return str(input.task_id) ? `Stop ${str(input.task_id)}` : "Stop background task";
+  }
+  if (/^monitor$/i.test(compact)) {
+    const command = str(input.command);
+    return command ? `Watch ${command.length > 48 ? `${command.slice(0, 45)}\u2026` : command}` : "Watch command";
+  }
+  return n;
+}
+function subagentLiveSuffix(input) {
+  if (!input) return "";
+  const bits = [];
+  const status = str(input.live_status);
+  if (status && !/^runn(ing)?$|^working$/i.test(status)) bits.push(status);
+  if (typeof input.live_tool_uses === "number") bits.push(`${input.live_tool_uses} tools`);
+  if (typeof input.live_duration_ms === "number") {
+    bits.push(`${Math.max(0, Math.round(Number(input.live_duration_ms) / 1e3))}s`);
+  }
+  const last = str(input.live_last_tool);
+  if (last) bits.push(last);
+  return bits.length ? ` \xB7 ${bits.join(" \xB7 ")}` : "";
+}
+function isSubagentToolName(name) {
+  const n = (name ?? "").trim();
+  if (/^(task|agent|spawn_agent)$/i.test(n)) return true;
+  return /connectedAgentRequest/i.test(n);
+}
+function isInternalAgentStatusText(text) {
+  const t = text.trim();
+  if (!t) return false;
+  if (/waiting for gate to pass/i.test(t)) return true;
+  if (/^agent is running\b/i.test(t) && t.length < 160) return true;
+  return false;
+}
+function isPollWrapperToolName(name) {
+  const n = (name ?? "").replace(/[_-]/g, "");
+  return /^(taskoutput|taskstop|sleep)$/i.test(n);
+}
+function lastTextPart(parts, type) {
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const p = parts[i];
+    if (p.type !== type) continue;
+    const text = p.text.trim();
+    if (!text || isInternalAgentStatusText(text)) continue;
+    return text;
+  }
+  return "";
+}
+function toolLabel(tool) {
+  return tool.description || toolDescription(tool.name, tool.input) || tool.name;
+}
+function fileBasename(path) {
+  const parts = path.replace(/\/$/, "").split(/[/\\]/);
+  return parts[parts.length - 1] || path;
+}
+function classifyTool(name) {
+  const compact = name.replace(/^mcp__[^_]+__/, "").replace(/[_-]/g, "");
+  if (/bash|shell|terminal|^zsh$|^sh$/i.test(compact)) return "shell";
+  if (/grep|glob|search|ripgrep|findfiles|semsearch/i.test(compact)) return "search";
+  if (/^(read|cat)$/i.test(compact) || /^read/i.test(compact)) return "read";
+  if (/edit|write|apply|strreplace|multiedit|updatefile|createfile/i.test(compact)) {
+    return "edit";
+  }
+  return "other";
+}
+function isShellToolName(name) {
+  return classifyTool(name ?? "") === "shell";
+}
+function toolActivityLine(parts) {
+  const tools = parts.filter((p) => {
+    if (p.type !== "tool" || p.parentId) return false;
+    if (isPollWrapperToolName(p.name)) return false;
+    if (/present_plan$/i.test(p.name ?? "")) return false;
+    if (/ask_user|AskUserQuestion/i.test(p.name ?? "")) return false;
+    return true;
+  });
+  if (tools.length === 0) return null;
+  const edited = [];
+  const skillNames = [];
+  let compacts = 0;
+  let reads = 0;
+  let searches = 0;
+  let shells = 0;
+  let others = 0;
+  let additions = 0;
+  let deletions = 0;
+  for (const tool of tools) {
+    const kind = classifyTool(tool.name);
+    if (isSkillToolName(tool.name)) {
+      const cmd = skillCommandFromInput(tool.input);
+      skillNames.push(cmd ? `/${cmd}` : "skill");
+    } else if (isCompactToolName(tool.name)) {
+      compacts += 1;
+    } else if (kind === "edit") {
+      const path = tool.filePath ?? toolFilePath(tool.input);
+      edited.push({
+        name: path ? fileBasename(path) : tool.name,
+        running: tool.status === "running"
+      });
+    } else if (kind === "read") reads += 1;
+    else if (kind === "search") searches += 1;
+    else if (kind === "shell") shells += 1;
+    else others += 1;
+    if (typeof tool.additions === "number") additions += tool.additions;
+    if (typeof tool.deletions === "number") deletions += tool.deletions;
+  }
+  const bits = [];
+  const editing = edited.filter((e) => e.running);
+  const editedDone = edited.filter((e) => !e.running);
+  if (editing.length === 1) bits.push(`Editing ${editing[0].name}`);
+  else if (editing.length > 1) bits.push(`Editing ${editing.length} files`);
+  if (editedDone.length === 1) bits.push(`${editing.length ? "edited" : "Edited"} ${editedDone[0].name}`);
+  else if (editedDone.length > 1) {
+    bits.push(`${editing.length ? "edited" : "Edited"} ${editedDone.length} files`);
+  }
+  if (reads === 1) bits.push("explored 1 file");
+  else if (reads > 1) bits.push(`explored ${reads} files`);
+  if (searches === 1) bits.push("1 search");
+  else if (searches > 1) bits.push(`${searches} searches`);
+  if (shells === 1) bits.push("ran 1 command");
+  else if (shells > 1) bits.push(`ran ${shells} commands`);
+  if (skillNames.length === 1) bits.push(`used ${skillNames[0]}`);
+  else if (skillNames.length > 1) bits.push(`used ${skillNames.length} skills`);
+  if (compacts === 1) bits.push("summarized conversation");
+  else if (compacts > 1) bits.push(`summarized conversation \xD7${compacts}`);
+  if (others === 1) bits.push("1 tool");
+  else if (others > 1) bits.push(`${others} tools`);
+  if (bits.length === 0) return null;
+  return { text: bits.join(", "), additions, deletions };
+}
+function liveActivitySummary(parts, opts) {
+  if (opts?.queued && parts.length === 0) {
+    return "Queued \u2014 waiting for a slot";
+  }
+  const tools = parts.filter((p) => p.type === "tool");
+  const runningSubs = tools.filter(
+    (t) => t.status === "running" && !t.parentId && isSubagentToolName(t.name)
+  );
+  const runningNested = [...tools].reverse().find((t) => t.status === "running" && t.parentId && !isPollWrapperToolName(t.name));
+  const runningTop = [...tools].reverse().find(
+    (t) => t.status === "running" && !t.parentId && !isPollWrapperToolName(t.name) && !isSubagentToolName(t.name)
+  );
+  const runningPoll = [...tools].reverse().find((t) => t.status === "running" && isPollWrapperToolName(t.name));
+  const thinking = lastTextPart(parts, "thinking");
+  const text = lastTextPart(parts, "text");
+  if (runningSubs.length > 0) {
+    const heads = runningSubs.map(toolLabel);
+    const head = runningSubs.length === 1 ? heads[0] : `${runningSubs.length} subagents \xB7 ${heads.slice(0, 2).join(" \xB7 ")}`;
+    if (runningNested) return `${head} \xB7 ${toolLabel(runningNested)}`;
+    return head;
+  }
+  if (runningTop) return toolLabel(runningTop);
+  if (runningPoll) return toolLabel(runningPoll);
+  if (thinking) return thinking.length > 96 ? `\u2026${thinking.slice(-96)}` : thinking;
+  if (text) return "Writing reply\u2026";
+  const last = [...tools].reverse().find((t) => !isPollWrapperToolName(t.name)) ?? tools.at(-1);
+  if (last) {
+    const label = toolLabel(last);
+    return last.status === "running" ? label : `Finished ${label}`;
+  }
+  return "Working\u2026";
+}
+function messagePartParentId(part) {
+  if ("parentId" in part && typeof part.parentId === "string" && part.parentId.trim()) {
+    return part.parentId;
+  }
+  return void 0;
+}
+function sameParentId(a, b) {
+  return (a ?? "") === (b ?? "");
+}
+function withEventParentId(event, parentId) {
+  if (!parentId) return event;
+  if (event.type === "stdout" || event.type === "thinking" || event.type === "tool_use" || event.type === "tool_result") {
+    return { ...event, parentId: event.parentId ?? parentId };
+  }
+  return event;
+}
+function withEventsParentId(events, parentId) {
+  if (!parentId) return events;
+  return events.map((event) => withEventParentId(event, parentId));
+}
+function toolFilePath(input) {
+  if (!input) return void 0;
+  return str(input.file_path) ?? str(input.path) ?? str(input.filePath) ?? str(input.filename);
+}
+function countLines(text) {
+  if (!text) return 0;
+  return text.split("\n").length;
+}
+function diffFromInput(input) {
+  if (!input) return {};
+  const oldS = str(input.old_string) ?? str(input.oldString);
+  const newS = str(input.new_string) ?? str(input.newString) ?? str(input.content);
+  if (oldS != null || newS != null) {
+    return {
+      additions: countLines(newS),
+      deletions: countLines(oldS)
+    };
+  }
+  return {};
+}
+function parseDiffStat(result) {
+  if (!result) return {};
+  const paired = result.match(/\+(\d+)\s+-(\d+)/);
+  if (paired) {
+    return {
+      additions: Number(paired[1]),
+      deletions: Number(paired[2])
+    };
+  }
+  const verbose = result.match(
+    /(\d+)\s+insertions?(?:,\s*(\d+)\s+deletions?)?/i
+  );
+  if (verbose) {
+    return {
+      additions: Number(verbose[1]),
+      deletions: verbose[2] != null ? Number(verbose[2]) : void 0
+    };
+  }
+  return {};
+}
+var THINKING_PART_MAX_CHARS = 64e3;
+function clipThinkingForStore(text, max = THINKING_PART_MAX_CHARS) {
+  if (text.length <= max) return text;
+  const marker = "\u2026(earlier thinking trimmed)\n";
+  return marker + text.slice(text.length - Math.max(1, max - marker.length));
+}
+var STDOUT_EVENT_MAX_CHARS = 16e3;
+var STDERR_EVENT_MAX_CHARS = 4e3;
+function clipEventTail(text, max) {
+  if (text.length <= max) return text;
+  const marker = "\u2026(truncated)\n";
+  return marker + text.slice(text.length - Math.max(1, max - marker.length));
+}
+function clipAgentEventForPaint(event) {
+  if (event.type === "tool_result" && event.content) {
+    const content = clipToolResultForStore(event.content);
+    if (content === event.content) return event;
+    return { ...event, content };
+  }
+  if (event.type === "thinking" && event.data.length > THINKING_PART_MAX_CHARS) {
+    return { ...event, data: clipThinkingForStore(event.data) };
+  }
+  if (event.type === "stdout" && event.data.length > STDOUT_EVENT_MAX_CHARS) {
+    return { ...event, data: clipEventTail(event.data, STDOUT_EVENT_MAX_CHARS) };
+  }
+  if (event.type === "stderr" && event.data.length > STDERR_EVENT_MAX_CHARS) {
+    return { ...event, data: clipEventTail(event.data, STDERR_EVENT_MAX_CHARS) };
+  }
+  return event;
+}
+function withPartTimes(next, prev) {
+  const now = Date.now();
+  const startedAt = prev && typeof prev.startedAt === "number" ? prev.startedAt : now;
+  return { ...next, startedAt, updatedAt: now };
+}
+function skillToolFromTextPart(part, id, status = "done") {
+  const command = skillCommandFromBody(part.text);
+  const input = command ? { skill: command } : void 0;
+  return {
+    type: "tool",
+    id: command ? `skill-${command}` : id,
+    name: "Skill",
+    input,
+    description: toolDescription("Skill", input),
+    status,
+    result: clipToolResultForStore(part.text),
+    ...part.parentId ? { parentId: part.parentId } : {},
+    startedAt: part.startedAt,
+    updatedAt: Date.now()
+  };
+}
+function lastSkillToolIndex(parts, parentId) {
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const p = parts[i];
+    if (p.type === "tool" && isSkillToolName(p.name) && sameParentId(p.parentId, parentId)) {
+      return i;
+    }
+  }
+  return -1;
+}
+function lastRunningSkillIndex(parts, parentId) {
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const p = parts[i];
+    if (p.type === "tool" && isSkillToolName(p.name) && p.status === "running" && sameParentId(p.parentId, parentId)) {
+      return i;
+    }
+  }
+  return -1;
+}
+function markRunningSkillsDone(parts, parentId) {
+  return parts.map((p) => {
+    if (p.type === "tool" && isSkillToolName(p.name) && p.status === "running" && sameParentId(p.parentId, parentId)) {
+      return withPartTimes({ ...p, status: "done" }, p);
+    }
+    return p;
+  });
+}
+function promoteOrFoldSkillText(parts, textIdx) {
+  const acc = parts[textIdx];
+  if (acc?.type !== "text") return parts;
+  const complete = looksLikeSkillBody(acc.text);
+  const incomplete = looksLikeIncompleteSkillDump(acc.text);
+  if (!complete && !incomplete) return parts;
+  const existing = lastSkillToolIndex(parts, acc.parentId);
+  if (existing >= 0 && existing !== textIdx) {
+    const prev = parts[existing];
+    const next2 = parts.filter((_, i) => i !== textIdx);
+    const existingIdx = lastSkillToolIndex(next2, acc.parentId);
+    if (existingIdx < 0) return parts;
+    next2[existingIdx] = withPartTimes(
+      {
+        ...prev,
+        status: complete ? "done" : prev.status,
+        result: clipToolResultForStore(acc.text) ?? prev.result
+      },
+      prev
+    );
+    return next2;
+  }
+  const next = [...parts];
+  next[textIdx] = skillToolFromTextPart(
+    acc,
+    `skill-${next.length}`,
+    complete ? "done" : "running"
+  );
+  return next;
+}
+function compactSummaryPart(text, id = "compact-summary") {
+  return compactToolPart(text, id, { status: "done" });
+}
+function compactPartsForSummaryMessage(message) {
+  const existing = (message.parts ?? []).filter(
+    (p) => p.type === "tool" && isCompactToolName(p.name)
+  );
+  if (existing.length) return existing;
+  return [compactSummaryPart(message.text ?? "")];
+}
+function compactToolPart(text, id, opts) {
+  const input = { trigger: opts?.trigger ?? "auto" };
+  return withPartTimes(
+    {
+      type: "tool",
+      id,
+      name: "Compact",
+      input,
+      description: toolDescription("Compact", input),
+      status: opts?.status ?? "done",
+      result: clipToolResultForStore(text) ?? "",
+      ...opts?.parentId ? { parentId: opts.parentId } : {}
+    },
+    opts?.prev
+  );
+}
+function contextCompactInProgress(parts, parentId) {
+  let compressing = false;
+  for (const p of parts) {
+    if (!sameParentId(p.parentId, parentId)) continue;
+    if (p.type === "thinking" && isContextCompactInProgress(p.text)) compressing = true;
+    if (p.type === "thinking" && isContextCompactDone(p.text)) compressing = false;
+  }
+  return compressing;
+}
+function lastRunningCompactIndex(parts, parentId) {
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const p = parts[i];
+    if (p.type === "tool" && isCompactToolName(p.name) && p.status === "running" && sameParentId(p.parentId, parentId)) {
+      return i;
+    }
+  }
+  return -1;
+}
+function markRunningCompactDone(parts, parentId) {
+  return parts.map((p) => {
+    if (p.type === "tool" && isCompactToolName(p.name) && p.status === "running" && sameParentId(p.parentId, parentId)) {
+      return withPartTimes({ ...p, status: "done" }, p);
+    }
+    return p;
+  });
+}
+function ensureCompactTool(parts, parentId) {
+  const hasCompact = parts.some(
+    (p) => p.type === "tool" && isCompactToolName(p.name) && sameParentId(p.parentId, parentId)
+  );
+  if (hasCompact) return parts;
+  return [
+    ...parts,
+    compactToolPart("Context compressed", `compact-${parts.length}`, {
+      parentId,
+      status: "done"
+    })
+  ];
+}
+function withCompactFinish(parts, thinking, parentId) {
+  if (!isContextCompactDone(thinking)) return parts;
+  return ensureCompactTool(markRunningCompactDone(parts, parentId), parentId);
+}
+function applyAgentEvent(parts, event) {
+  if (event.type === "stdout") {
+    const data = event.data;
+    if (!data) return parts;
+    const runningIdx = lastRunningCompactIndex(parts, event.parentId);
+    if (runningIdx >= 0) {
+      const prev = parts[runningIdx];
+      const next2 = [...parts];
+      next2[runningIdx] = withPartTimes(
+        {
+          ...prev,
+          result: clipToolResultForStore(`${prev.result ?? ""}${data}`)
+        },
+        prev
+      );
+      return next2;
+    }
+    const runningSkillIdx = lastRunningSkillIndex(parts, event.parentId);
+    if (runningSkillIdx >= 0) {
+      const prev = parts[runningSkillIdx];
+      const result = `${prev.result ?? ""}${data}`;
+      const next2 = [...parts];
+      next2[runningSkillIdx] = withPartTimes(
+        {
+          ...prev,
+          result: clipToolResultForStore(result),
+          // Stay running after the YAML `name:` fence so later content_block_delta
+          // tokens of SKILL.md stay on this row. thinking / tool_use / finalizeParts
+          // mark the row done so the real reply can be chat.
+          status: "running"
+        },
+        prev
+      );
+      return next2;
+    }
+    if (contextCompactInProgress(parts, event.parentId)) {
+      return [
+        ...parts,
+        compactToolPart(data, `compact-${parts.length}`, {
+          parentId: event.parentId,
+          status: "running"
+        })
+      ];
+    }
+    const next = [...parts];
+    const last = next[next.length - 1];
+    if (last?.type === "text" && sameParentId(last.parentId, event.parentId)) {
+      next[next.length - 1] = withPartTimes(
+        {
+          type: "text",
+          text: last.text + data,
+          ...event.parentId ? { parentId: event.parentId } : {}
+        },
+        last
+      );
+    } else {
+      next.push(
+        withPartTimes({
+          type: "text",
+          text: data,
+          ...event.parentId ? { parentId: event.parentId } : {}
+        })
+      );
+    }
+    const acc = next[next.length - 1];
+    if (acc?.type === "text" && (looksLikeSkillBody(acc.text) || looksLikeIncompleteSkillDump(acc.text))) {
+      return promoteOrFoldSkillText(next, next.length - 1);
+    }
+    if (acc?.type === "text" && looksLikeConversationSummary(acc.text)) {
+      next[next.length - 1] = compactToolPart(acc.text, `compact-${next.length}`, {
+        parentId: acc.parentId,
+        status: "done",
+        prev: acc
+      });
+    }
+    return next;
+  }
+  if (event.type === "thinking") {
+    const data = event.data;
+    if (!data) return parts;
+    if (!isSystemStatusThinking(event)) {
+      parts = markRunningSkillsDone(parts, event.parentId);
+    }
+    const next = [...parts];
+    if (event.replace) {
+      for (let i = next.length - 1; i >= 0; i--) {
+        const prev = next[i];
+        if (prev?.type === "thinking" && sameParentId(prev.parentId, event.parentId)) {
+          next[i] = withPartTimes(
+            {
+              type: "thinking",
+              text: clipThinkingForStore(data),
+              ...event.parentId ? { parentId: event.parentId } : {}
+            },
+            prev
+          );
+          return withCompactFinish(next, data, event.parentId);
+        }
+      }
+      next.push(
+        withPartTimes({
+          type: "thinking",
+          text: clipThinkingForStore(data),
+          ...event.parentId ? { parentId: event.parentId } : {}
+        })
+      );
+      return withCompactFinish(next, data, event.parentId);
+    }
+    const last = next[next.length - 1];
+    if (last?.type === "thinking" && sameParentId(last.parentId, event.parentId)) {
+      next[next.length - 1] = withPartTimes(
+        {
+          type: "thinking",
+          text: clipThinkingForStore(last.text + data),
+          ...event.parentId ? { parentId: event.parentId } : {}
+        },
+        last
+      );
+    } else {
+      next.push(
+        withPartTimes({
+          type: "thinking",
+          text: clipThinkingForStore(data),
+          ...event.parentId ? { parentId: event.parentId } : {}
+        })
+      );
+    }
+    return withCompactFinish(next, data, event.parentId);
+  }
+  if (event.type === "tool_use") {
+    parts = markRunningSkillsDone(parts, event.parentId);
+    const input = asRecord(event.input);
+    const diff = diffFromInput(input);
+    const existing = parts.findIndex((p) => p.type === "tool" && p.id === event.id);
+    if (existing >= 0) {
+      const prev = parts[existing];
+      const next = [...parts];
+      const mergedInput = {
+        ...prev.input ?? {},
+        ...input ?? {}
+      };
+      const mergedRecord = Object.keys(mergedInput).length > 0 ? mergedInput : void 0;
+      next[existing] = withPartTimes(
+        {
+          ...prev,
+          name: event.name || prev.name,
+          input: mergedRecord,
+          description: toolDescription(event.name || prev.name, mergedRecord),
+          detail: toolDetail(event.name || prev.name, mergedRecord) ?? prev.detail,
+          filePath: toolFilePath(mergedRecord) ?? prev.filePath,
+          additions: diff.additions ?? prev.additions,
+          deletions: diff.deletions ?? prev.deletions,
+          parentId: event.parentId ?? prev.parentId
+        },
+        prev
+      );
+      return next;
+    }
+    return [
+      ...parts,
+      withPartTimes({
+        type: "tool",
+        id: event.id,
+        name: event.name,
+        input,
+        description: toolDescription(event.name, input),
+        detail: toolDetail(event.name, input),
+        status: "running",
+        filePath: toolFilePath(input),
+        ...event.parentId ? { parentId: event.parentId } : {},
+        ...diff
+      })
+    ];
+  }
+  if (event.type === "tool_result") {
+    const existing = parts.findIndex((p) => p.type === "tool" && p.id === event.id);
+    const fromResult = parseDiffStat(event.content);
+    if (event.partial) {
+      if (existing < 0) {
+        return [
+          ...parts,
+          withPartTimes({
+            type: "tool",
+            id: event.id,
+            name: "tool",
+            description: "tool",
+            status: event.isError ? "error" : "running",
+            result: clipToolResultForStore(event.content),
+            ...event.parentId ? { parentId: event.parentId } : {}
+          })
+        ];
+      }
+      return parts.map((p, i) => {
+        if (i !== existing || p.type !== "tool") return p;
+        if (p.status === "done" || p.status === "error") return p;
+        return withPartTimes(
+          {
+            ...p,
+            result: clipToolResultForStore(event.content) ?? p.result
+          },
+          p
+        );
+      });
+    }
+    if (existing < 0) {
+      return [
+        ...parts,
+        withPartTimes({
+          type: "tool",
+          id: event.id,
+          name: "tool",
+          description: "tool",
+          status: event.isError ? "error" : "done",
+          result: clipToolResultForStore(event.content),
+          ...event.parentId ? { parentId: event.parentId } : {},
+          ...fromResult.additions != null ? { additions: fromResult.additions } : {},
+          ...fromResult.deletions != null ? { deletions: fromResult.deletions } : {}
+        })
+      ];
+    }
+    return parts.map((p, i) => {
+      if (i !== existing || p.type !== "tool") return p;
+      return withPartTimes(
+        {
+          ...p,
+          status: event.isError ? "error" : "done",
+          result: clipToolResultForStore(event.content),
+          ...fromResult.additions != null ? { additions: fromResult.additions } : {},
+          ...fromResult.deletions != null ? { deletions: fromResult.deletions } : {}
+        },
+        p
+      );
+    });
+  }
+  return parts;
+}
+function partsToAssistantText(parts) {
+  return parts.filter(
+    (p) => p.type === "text" && !messagePartParentId(p)
+  ).map((p) => p.text).join("").trim();
+}
+function visibleAssistantText(text, parts) {
+  const fromParts = partsToAssistantText(parts ?? []);
+  if (fromParts) return fromParts;
+  if (parts?.some((p) => p.type === "tool" || p.type === "thinking")) return "";
+  return (text ?? "").trim();
+}
+function lastAssistantMessageText(parts) {
+  if (!parts?.length) return "";
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const p = parts[i];
+    if (!p || p.type !== "text" || messagePartParentId(p)) continue;
+    const text = p.text.trim();
+    if (!text || isInternalAgentStatusText(text)) continue;
+    return text;
+  }
+  return "";
+}
+function stripBrightsyNdjsonNoise(text) {
+  if (!text || !text.includes('"type"')) return text;
+  let out = text;
+  out = out.replace(
+    /\{"type":"(?:tool_use|tool_result|tool|thinking|usage|done|error)"[\s\S]*?\}\s*(?=\{"type":"|$|(?=[A-Za-z*#]))/g,
+    ""
+  );
+  out = out.replace(/\{"type":"(?:tool_use|tool_result|tool)"[\s\S]*$/g, "");
+  return out.trim();
+}
+function isBrightsyNdjsonLine(line) {
+  const t = line.trim();
+  if (!t.startsWith("{")) return false;
+  return /"type"\s*:\s*"(tool_use|tool_result|tool|thinking|usage|done|error|text)"/.test(t);
+}
+function finalizeParts(parts) {
+  return parts.map(
+    (p) => p.type === "tool" && p.status === "running" ? { ...p, status: "done" } : p
+  );
+}
+function normalizeParseResult(parsed) {
+  if (!parsed) return [];
+  return Array.isArray(parsed) ? parsed : [parsed];
+}
+
+export {
+  visibleToolRowDetail,
+  isSkillToolName,
+  skillCommandFromInput,
+  looksLikeComposerSkillExpansion,
+  skillNameFromFrontmatter,
+  skillCommandFromBody,
+  looksLikeSkillBody,
+  looksLikeIncompleteSkillDump,
+  isCompactToolName,
+  isContextCompactDone,
+  isContextCompactInProgress,
+  isSystemStatusThinking,
+  looksLikeConversationSummary,
+  toolDetail,
+  toolDescription,
+  isSubagentToolName,
+  isInternalAgentStatusText,
+  isPollWrapperToolName,
+  isShellToolName,
+  toolActivityLine,
+  liveActivitySummary,
+  messagePartParentId,
+  withEventParentId,
+  withEventsParentId,
+  toolFilePath,
+  THINKING_PART_MAX_CHARS,
+  clipThinkingForStore,
+  STDOUT_EVENT_MAX_CHARS,
+  STDERR_EVENT_MAX_CHARS,
+  clipAgentEventForPaint,
+  compactSummaryPart,
+  compactPartsForSummaryMessage,
+  applyAgentEvent,
+  partsToAssistantText,
+  visibleAssistantText,
+  lastAssistantMessageText,
+  stripBrightsyNdjsonNoise,
+  isBrightsyNdjsonLine,
+  finalizeParts,
+  normalizeParseResult
+};