@super-one/cli 0.75.2 → 0.75.3

package/lib/cli.mjs

@@ -137,8 +137,8 @@ import { fileURLToPath } from "node:url";
 function resolveCliReleaseVersion() {
   const fromEnv = process.env.SUPERONE_CLI_VERSION?.trim();
   if (fromEnv) return fromEnv;
-  if ("0.75.2".trim()) {
-    return "0.75.2".trim();
+  if ("0.75.3".trim()) {
+    return "0.75.3".trim();
   }
   const fromDist = readDistManifestVersion();
   if (fromDist) return fromDist;
@@ -5329,12 +5329,14 @@ var init_session_messages = __esm({
 function desktopShowsSession(holders) {
   return holders.some((holder) => holder.startsWith(DESKTOP_WINDOW_HOLDER_PREFIX));
 }
-var TRANSCRIPT_WINDOW_SCHEMA, TRANSCRIPT_WINDOW_METHOD, DESKTOP_WINDOW_HOLDER_PREFIX;
+var TRANSCRIPT_WINDOW_SCHEMA, TRANSCRIPT_WINDOW_METHOD, MAX_FOLD_FILES, TRANSCRIPT_FOLD_METHOD, DESKTOP_WINDOW_HOLDER_PREFIX;
 var init_transcript_window = __esm({
   "../../packages/shared/src/environment/transcript-window.ts"() {
     "use strict";
     TRANSCRIPT_WINDOW_SCHEMA = 1;
     TRANSCRIPT_WINDOW_METHOD = "session.transcriptWindow";
+    MAX_FOLD_FILES = 100;
+    TRANSCRIPT_FOLD_METHOD = "session.transcriptFold";
     DESKTOP_WINDOW_HOLDER_PREFIX = "desktop:";
   }
 });
@@ -8996,7 +8998,7 @@ var require_stream = __commonJS({
           callback();
           if (duplex._readableState.endEmitted) duplex.destroy();
         } else {
-          ws2._socket.once("finish", function finish() {
+          ws2._socket.once("finish", function finish2() {
             callback();
           });
           ws2.close();
@@ -10433,6 +10435,16 @@ function resolveCodexCommandActions(item, cwdFallback) {
     return reads && reads[0]?.path === action.path ? reads : [action];
   });
 }
+function codexCommandPresentation(item, cwdFallback) {
+  const actions = resolveCodexCommandActions(item, cwdFallback);
+  const types = new Set(actions.map((action) => action.type));
+  let kind = "bash";
+  if (actions.length && actions.every((action) => ["read", "search", "listFiles"].includes(action.type))) {
+    kind = types.size > 1 ? "explore" : types.has("read") ? "read" : types.has("search") ? "search" : "list";
+  }
+  const files = [...new Set(actions.filter((action) => action.type === "read" && action.path).map((action) => action.path))];
+  return { kind, actions, files };
+}
 function parsedCommandFromBashInput(toolUseId, input, facts = {}) {
   if (!input.includes('"commandActions"')) return null;
   let params;
@@ -10453,6 +10465,10 @@ function parsedCommandFromBashInput(toolUseId, input, facts = {}) {
     status: facts.running ? "in_progress" : facts.isError || (facts.exitCode ?? 0) !== 0 ? "failed" : "completed"
   };
 }
+function isReadOnlyParsedCommand(toolUseId, input) {
+  const item = parsedCommandFromBashInput(toolUseId, input);
+  return item !== null && codexCommandPresentation(item).kind !== "bash";
+}
 var init_codex_command_actions = __esm({
   "../../packages/shared/src/codex-command-actions.ts"() {
     "use strict";
@@ -11652,6 +11668,387 @@ var init_session_message_range = __esm({
   }
 });
 
+// ../../packages/shared/src/codex-async-question.ts
+function isCodexAsyncAnswer(message) {
+  return message.role === "user" && message.id.startsWith("codex_async_answer:");
+}
+function codexAsyncReplyText(message) {
+  return message?.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("\n") ?? null;
+}
+function isDismissedCodexAsyncAnswer(message, messages = []) {
+  if (!isCodexAsyncAnswer(message)) return false;
+  const reply = codexAsyncReplyText(message)?.trim();
+  if (reply === CODEX_ASYNC_QUESTION_DISMISSED) return true;
+  if (!reply) return false;
+  const questions = codexAsyncAnswerQuestions(message, messages);
+  return !!questions?.length && reply === formatCodexAsyncQuestionReply(questions, questions.map(() => CODEX_ASYNC_QUESTION_DISMISSED)).trim();
+}
+function codexAsyncQuestionRequest(item) {
+  return {
+    requestId: codexAsyncAnswerId(item.id),
+    questions: (item.questions ?? []).map((question, index) => ({
+      id: String(index),
+      question: question.title,
+      header: question.title,
+      multiSelect: false,
+      options: (question.options ?? []).map((label) => ({ label, description: "" }))
+    }))
+  };
+}
+function codexAsyncQuestionItems(message) {
+  return readableContent(message).flatMap((block) => block.type === "text" && block.id && !block.parentToolUseId && block.codexAsyncQuestions?.length ? [{ id: block.id, type: "agent_message", text: block.text, delivery: "async", questions: block.codexAsyncQuestions }] : []);
+}
+function pendingCodexAsyncQuestions(messages) {
+  const answered = new Set(messages.filter(isCodexAsyncAnswer).map((message) => message.id));
+  const seen = /* @__PURE__ */ new Set();
+  const pending3 = [];
+  for (const message of messages) {
+    if (message.role !== "assistant") continue;
+    for (const item of codexAsyncQuestionItems(message)) {
+      if (seen.has(item.id)) continue;
+      seen.add(item.id);
+      if (!answered.has(codexAsyncAnswerId(item.id))) pending3.push({ messageId: message.id, item, request: codexAsyncQuestionRequest(item) });
+    }
+  }
+  return pending3;
+}
+function codexAsyncQuestionQueue(session) {
+  const pending3 = session.pendingAsyncQuestions ?? pendingCodexAsyncQuestions(session.messages);
+  const answered = new Set(session.messages.filter(isCodexAsyncAnswer).map((message) => message.id));
+  return pending3.some((q2) => answered.has(q2.request.requestId)) ? pending3.filter((q2) => !answered.has(q2.request.requestId)) : pending3;
+}
+function codexAsyncAnswerQuestions(message, messages) {
+  if (!isCodexAsyncAnswer(message)) return void 0;
+  const stored = message.content.find((block) => block.type === "text" && block.codexAsyncQuestions?.length);
+  if (stored?.type === "text") return stored.codexAsyncQuestions;
+  const itemId = message.id.slice("codex_async_answer:".length);
+  for (const source of messages) {
+    const item = source.role === "assistant" ? codexAsyncQuestionItems(source).find((item2) => item2.id === itemId) : void 0;
+    if (item) return item.questions;
+  }
+  return void 0;
+}
+function formatCodexAsyncQuestionReply(questions, answers) {
+  if (questions.length === 1) return answers[0]?.trim() ?? "";
+  return questions.map((question, index) => `${question.title}
+${answers[index]?.trim() ?? ""}`).join("\n\n");
+}
+var codexAsyncAnswerId, CODEX_ASYNC_QUESTION_DISMISSED;
+var init_codex_async_question = __esm({
+  "../../packages/shared/src/codex-async-question.ts"() {
+    "use strict";
+    init_codex_content();
+    codexAsyncAnswerId = (itemId) => `codex_async_answer:${itemId}`;
+    CODEX_ASYNC_QUESTION_DISMISSED = "[The user dismissed this question.]";
+  }
+});
+
+// ../../packages/shared/src/transcript-boundary.ts
+function contentKeys(content) {
+  const counts = /* @__PURE__ */ new Map();
+  return content.map((block) => {
+    if (block.type === "notice" && block.fold) {
+      for (const [kind2, count2] of Object.entries(block.fold.keyCounts ?? {})) counts.set(kind2, (counts.get(kind2) ?? 0) + count2);
+      return block.fold.contentKey;
+    }
+    if (isToolUseBlock(block)) return `tool:${block.toolUseId}`;
+    if (isToolResultBlock(block)) return `result:${block.toolUseId}`;
+    const kind = contentKeyKind(block);
+    const count = counts.get(kind) ?? 0;
+    counts.set(kind, count + 1);
+    return `${kind}:${count}`;
+  });
+}
+function contentKeyKind(block) {
+  const parent = "parentToolUseId" in block ? block.parentToolUseId ?? "" : "";
+  return `${block.type}:${parent}`;
+}
+function contentKeySpan(content, keys, start, end) {
+  const keyCounts = {};
+  for (let i = start; i <= end; i++) {
+    const block = content[i];
+    if (isToolUseBlock(block) || isToolResultBlock(block)) continue;
+    const kind = contentKeyKind(block);
+    keyCounts[kind] = (keyCounts[kind] ?? 0) + 1;
+  }
+  return { contentKey: keys[start], ...Object.keys(keyCounts).length ? { keyCounts } : {} };
+}
+function blockText(block) {
+  return block.type === "text" ? block.text : block.type === "thinking" ? block.thinking : void 0;
+}
+function itemText(item) {
+  return "text" in item ? item.text : void 0;
+}
+function transcriptLengths(message) {
+  const keys = contentKeys(message.content);
+  return {
+    content: Object.fromEntries(message.content.map((block, index) => [keys[index], blockText(block)?.length ?? -1])),
+    items: Object.fromEntries((message.metadata?.codex?.items ?? []).map((item) => [item.id, itemText(item)?.length ?? -1]))
+  };
+}
+function resolveTranscriptBoundaries(cuts, lengths) {
+  let previous = { content: {}, items: {} };
+  return cuts.map((cut) => {
+    const cursor = cut.metadata.transcriptBoundary;
+    const asyncAnswer = isCodexAsyncAnswer(cut);
+    const resolved = { ...cursor, content: { ...previous.content }, items: { ...previous.items } };
+    for (const kind of ["content", "items"]) {
+      for (const [key, offset] of Object.entries(cursor[kind])) {
+        const end = asyncAnswer ? lengths[kind][key] ?? offset : offset;
+        resolved[kind][key] = Math.max(previous[kind][key] ?? -1, end);
+      }
+    }
+    previous = resolved;
+    return resolved;
+  });
+}
+function captureTranscriptBoundary(message, messages = []) {
+  let order = capturedOrders.get(message.id) ?? 0;
+  for (const row2 of messages) {
+    const cursor = row2.metadata?.transcriptBoundary;
+    if (cursor?.messageId === message.id) order = Math.max(order, cursor.order);
+  }
+  order += 1;
+  capturedOrders.delete(message.id);
+  capturedOrders.set(message.id, order);
+  if (capturedOrders.size > 1024) capturedOrders.delete(capturedOrders.keys().next().value);
+  return {
+    messageId: message.id,
+    order,
+    ...transcriptLengths(message)
+  };
+}
+function anchorAsyncAnswer(message, messages) {
+  if (!isCodexAsyncAnswer(message) || message.metadata?.transcriptBoundary) return message;
+  const itemId = message.id.slice("codex_async_answer:".length);
+  const source = messages.findLast((row2) => row2.status === "streaming" && row2.role === "assistant" && codexAsyncQuestionItems(row2).some((item) => item.id === itemId)) ?? messages.findLast((row2) => row2.status === "streaming" && row2.role === "assistant" && row2.providerId === "codex");
+  return source ? { ...message, metadata: { ...message.metadata, transcriptBoundary: captureTranscriptBoundary(source, messages) } } : message;
+}
+var capturedOrders;
+var init_transcript_boundary = __esm({
+  "../../packages/shared/src/transcript-boundary.ts"() {
+    "use strict";
+    init_codex_async_question();
+    init_content_delta();
+    capturedOrders = /* @__PURE__ */ new Map();
+  }
+});
+
+// ../../packages/shared/src/launch-options.ts
+var HARNESS_LAUNCH_OPTIONS;
+var init_launch_options = __esm({
+  "../../packages/shared/src/launch-options.ts"() {
+    "use strict";
+    HARNESS_LAUNCH_OPTIONS = {
+      claude: { permissionModes: ["default", "plan", "auto", "acceptEdits", "dontAsk", "bypassPermissions"], sandboxModes: ["off", "on", "auto"], defaultPermissionMode: "default" },
+      codex: { permissionModes: ["default", "auto", "bypassPermissions"], sandboxModes: [], defaultPermissionMode: "default" },
+      acp: { permissionModes: ["default", "plan", "auto", "bypassPermissions"], sandboxModes: [], defaultPermissionMode: "default" },
+      // OpenCode selects native agents; permissions come from its own configuration.
+      opencode: { permissionModes: [], sandboxModes: [], defaultPermissionMode: "default" },
+      cursor: { permissionModes: ["agent", "plan", "bypassPermissions"], sandboxModes: ["off", "on"], defaultPermissionMode: "agent" },
+      // Read-only first for display; dsh's own default preset is `workspace-write` (`default`).
+      dsh: { permissionModes: ["plan", "default", "bypassPermissions"], sandboxModes: [], defaultPermissionMode: "default" }
+    };
+  }
+});
+
+// ../../packages/shared/src/claude-fast-mode.ts
+function supportsClaudeFastMode(model, modelEnv) {
+  return !Object.keys(modelEnv ?? {}).length && model?.supportsFastMode === true;
+}
+var init_claude_fast_mode = __esm({
+  "../../packages/shared/src/claude-fast-mode.ts"() {
+    "use strict";
+  }
+});
+
+// ../../packages/shared/src/codex-fast-mode.ts
+function findCodexFastServiceTier(model) {
+  return model?.serviceTiers?.find((tier) => tier.id === "fast" || tier.id === "priority" || tier.name.trim().toLowerCase() === "fast");
+}
+var init_codex_fast_mode = __esm({
+  "../../packages/shared/src/codex-fast-mode.ts"() {
+    "use strict";
+  }
+});
+
+// ../../packages/shared/src/suggested-task-launch.ts
+function suggestedTaskSettings(settings) {
+  return Object.fromEntries(SUGGESTED_TASK_SETTING_KEYS.flatMap((key) => settings[key] === void 0 ? [] : [[key, settings[key]]]));
+}
+function suggestedTaskRunSettings(profile, settings, codexFast = true) {
+  const picked = suggestedTaskSettings(settings);
+  const model = profile.models.find((model2) => model2.id === (picked.model ?? profile.defaultConfig.model));
+  const modelEnv = profile.apiProviders.find((provider2) => provider2.id === (picked.apiProviderId ?? profile.defaultConfig.apiProviderId))?.modelEnv;
+  if (profile.harnessId !== "codex" || !codexFast || !findCodexFastServiceTier(model)) delete picked.fastMode;
+  if (profile.harnessId !== "claude" || !supportsClaudeFastMode(model, modelEnv)) delete picked.claudeFastMode;
+  if (picked.effort && profile.efforts.length && !profile.efforts.includes(picked.effort)) delete picked.effort;
+  return picked;
+}
+function suggestedTaskInitialChoice(profiles, providerId, settings) {
+  const own = profiles.find((profile) => profile.id === providerId);
+  if (!own) return profiles[0] ? { agentId: profiles[0].id, settings: {} } : null;
+  const picked = suggestedTaskSettings(settings);
+  if (picked.apiProviderId && !own.apiProviders.some((provider2) => provider2.id === picked.apiProviderId)) delete picked.apiProviderId;
+  return { agentId: own.id, settings: picked };
+}
+function suggestedTaskBranchName(title2, taskId) {
+  const slug = title2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40).replace(/-+$/, "");
+  const id = taskId.replace(/[^a-z0-9]/gi, "").slice(0, 8);
+  return `task/${slug ? `${slug}-` : ""}${id}`;
+}
+function parseSuggestedTaskChoice(value) {
+  const invalid11 = (message) => {
+    throw Object.assign(new Error(message), { code: "invalid_argument" });
+  };
+  if (value === void 0) return void 0;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return invalid11("invalid task launch choice");
+  const { agentId, settings } = value;
+  if (typeof agentId !== "string" || !agentId.trim() || !settings || typeof settings !== "object" || Array.isArray(settings)) return invalid11("task launch needs an agent and settings");
+  const input = settings;
+  const picked = {};
+  for (const key of SUGGESTED_TASK_SETTING_KEYS) {
+    const entry3 = input[key];
+    if (entry3 === void 0) continue;
+    const valid = key === "fastMode" || key === "claudeFastMode" ? typeof entry3 === "boolean" : key === "apiProviderId" && entry3 === null || typeof entry3 === "string";
+    if (!valid) return invalid11(`invalid task launch ${key}`);
+    if (key === "permissionMode" && !Object.values(HARNESS_LAUNCH_OPTIONS).some((option) => option.permissionModes.some((mode) => mode === entry3))) return invalid11("invalid permission mode");
+    if (key === "sandboxMode" && !Object.values(HARNESS_LAUNCH_OPTIONS).some((option) => option.sandboxModes.some((mode) => mode === entry3))) return invalid11("invalid sandbox mode");
+    Object.assign(picked, { [key]: entry3 });
+  }
+  return { agentId, settings: picked };
+}
+var SUGGESTED_TASK_SETTING_KEYS;
+var init_suggested_task_launch = __esm({
+  "../../packages/shared/src/suggested-task-launch.ts"() {
+    "use strict";
+    init_launch_options();
+    init_claude_fast_mode();
+    init_codex_fast_mode();
+    SUGGESTED_TASK_SETTING_KEYS = ["model", "effort", "apiProviderId", "permissionMode", "sandboxMode", "fastMode", "claudeFastMode"];
+  }
+});
+
+// ../../packages/shared/src/suggested-task.ts
+function record5(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function isSuggestTaskTool(toolName) {
+  if (typeof toolName !== "string") return false;
+  const mcp = parseMcpToolName(toolName);
+  return mcp?.serverName === "superone" && mcp.mcpToolName === SUGGEST_TASK_TOOL_NAME;
+}
+function parseInput2(raw) {
+  let value = raw;
+  if (typeof raw === "string") {
+    try {
+      value = JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  const input = record5(value);
+  const title2 = typeof input.title === "string" ? input.title.trim() : "";
+  const prompt = typeof input.prompt === "string" ? input.prompt.trim() : "";
+  if (!title2 || !prompt) return null;
+  const cwd = typeof input.cwd === "string" && input.cwd.trim() ? input.cwd.trim() : void 0;
+  return { title: title2, tldr: typeof input.tldr === "string" ? input.tldr.trim() : "", prompt, ...cwd ? { cwd } : {} };
+}
+function contentOf(message) {
+  const value = record5(message);
+  return readableContent({ content: Array.isArray(value.content) ? value.content : [], metadata: value.metadata }).map(record5);
+}
+function locateToolUse(messages, toolUseId) {
+  for (let messageIndex = messages.length - 1; messageIndex >= 0; messageIndex--) {
+    const use = contentOf(messages[messageIndex]).find((row2) => row2.type === "tool_use" && row2.toolUseId === toolUseId);
+    if (use) return isSuggestTaskTool(use.toolName) ? { messageIndex, rowId: String(use.toolUseId), row: use } : null;
+  }
+  return null;
+}
+function locate(messages, taskId) {
+  if (!taskId) return null;
+  for (let messageIndex = messages.length - 1; messageIndex >= 0; messageIndex--) {
+    const message = record5(messages[messageIndex]);
+    for (const block of contentOf(message)) {
+      if (block.type !== "tool_result" || typeof block.summary !== "string" || !block.summary.includes(taskId)) continue;
+      const use = locateToolUse(messages, block.toolUseId);
+      if (use) return use;
+    }
+  }
+  return null;
+}
+function findSuggestedTask(messages, taskId) {
+  const found = locate(messages, taskId);
+  if (!found) return null;
+  const input = parseInput2(found.row.input);
+  if (!input) return null;
+  const state = found.row.suggestedTask;
+  return { input, ...state ? { state } : {} };
+}
+function applySuggestedTaskUpdate(messages, taskId, state) {
+  const found = locate(messages, taskId);
+  if (!found || found.row.suggestedTask) return messages;
+  const patch = (row2) => {
+    const value = record5(row2);
+    const matches = value.type === "tool_use" && value.toolUseId === found.rowId || value.type === "mcp_tool_call" && value.id === found.rowId;
+    return matches ? { ...value, suggestedTask: state } : row2;
+  };
+  return messages.map((message, index) => {
+    if (index !== found.messageIndex) return message;
+    const value = record5(message);
+    const metadata = record5(value.metadata);
+    const codex = record5(metadata.codex);
+    return {
+      ...value,
+      ...Array.isArray(value.content) ? { content: value.content.map(patch) } : {},
+      ...Array.isArray(codex.items) ? { metadata: { ...metadata, codex: { ...codex, items: codex.items.map(patch) } } } : {}
+    };
+  });
+}
+var SUGGEST_TASK_TOOL_NAME;
+var init_suggested_task = __esm({
+  "../../packages/shared/src/suggested-task.ts"() {
+    "use strict";
+    init_codex_content();
+    init_tool_ui();
+    init_suggested_task_launch();
+    SUGGEST_TASK_TOOL_NAME = "session_suggest_task";
+  }
+});
+
+// ../../packages/shared/src/jev-run-result-shape.ts
+function isJevRunToolName(toolName) {
+  if (!toolName) return false;
+  return /(?:^|__)(?:browser|computer|device)_run$/.test(toolName);
+}
+function looksLikeJevRunResult(obj) {
+  const status2 = obj.status;
+  if (status2 !== "paused" && status2 !== "done" && status2 !== "aborted") return false;
+  if (typeof obj.runId !== "string") return false;
+  return Array.isArray(obj.since_last) || typeof obj.progress === "object" && obj.progress !== null || typeof obj.steps === "number";
+}
+var init_jev_run_result_shape = __esm({
+  "../../packages/shared/src/jev-run-result-shape.ts"() {
+    "use strict";
+  }
+});
+
+// ../../packages/chat-core/src/media-predicates.ts
+function isMediaGenerateVideoTool(toolName) {
+  return toolName === MEDIA_GENERATE_VIDEO_TOOL;
+}
+function isMediaVideoStatusTool(toolName) {
+  return toolName === MEDIA_VIDEO_STATUS_TOOL;
+}
+var MEDIA_GENERATE_VIDEO_TOOL, MEDIA_VIDEO_STATUS_TOOL;
+var init_media_predicates = __esm({
+  "../../packages/chat-core/src/media-predicates.ts"() {
+    "use strict";
+    MEDIA_GENERATE_VIDEO_TOOL = "mcp__superone__media_generate_video";
+    MEDIA_VIDEO_STATUS_TOOL = "mcp__superone__media_video_status";
+  }
+});
+
 // ../../packages/runtime/src/stream/delivery/transcript-access.ts
 function missingRow() {
   return Object.assign(new Error("transcript index out of range"), { code: "not_found" });
@@ -11665,7 +12062,8 @@ function arrayTranscript(messages) {
       if (!message) throw missingRow();
       return message;
     },
-    indexOf: (messageId) => (ids ??= new Map(messages.map((message, index) => [message.id, index]))).get(messageId) ?? -1
+    indexOf: (messageId) => (ids ??= new Map(messages.map((message, index) => [message.id, index]))).get(messageId) ?? -1,
+    boundaryMessages: () => messages.filter((message) => message.metadata?.transcriptBoundary)
   };
 }
 function sqliteTranscript(db, input) {
@@ -11678,6 +12076,7 @@ function sqliteTranscript(db, input) {
   const countBefore = db.prepare(`SELECT COUNT(*) AS count FROM ${table2} WHERE session_id = ? AND sort_order < ?`);
   const byIndex = /* @__PURE__ */ new Map();
   const idIndex = /* @__PURE__ */ new Map();
+  let boundaries;
   return {
     count: total,
     parsed: () => byIndex.size,
@@ -11703,6 +12102,14 @@ function sqliteTranscript(db, input) {
       if (index >= total) return -1;
       idIndex.set(messageId, index);
       return index;
+    },
+    boundaryMessages() {
+      if (!input.boundarySql) return [];
+      if (!boundaries) {
+        const rows = db.prepare(input.boundarySql).all?.(sessionId);
+        boundaries = (rows ?? []).map((row2) => input.parse(row2));
+      }
+      return boundaries;
     }
   };
 }
@@ -11712,24 +12119,6 @@ var init_transcript_access = __esm({
   }
 });
 
-// ../../packages/shared/src/launch-options.ts
-var HARNESS_LAUNCH_OPTIONS;
-var init_launch_options = __esm({
-  "../../packages/shared/src/launch-options.ts"() {
-    "use strict";
-    HARNESS_LAUNCH_OPTIONS = {
-      claude: { permissionModes: ["default", "plan", "auto", "acceptEdits", "dontAsk", "bypassPermissions"], sandboxModes: ["off", "on", "auto"], defaultPermissionMode: "default" },
-      codex: { permissionModes: ["default", "auto", "bypassPermissions"], sandboxModes: [], defaultPermissionMode: "default" },
-      acp: { permissionModes: ["default", "plan", "auto", "bypassPermissions"], sandboxModes: [], defaultPermissionMode: "default" },
-      // OpenCode selects native agents; permissions come from its own configuration.
-      opencode: { permissionModes: [], sandboxModes: [], defaultPermissionMode: "default" },
-      cursor: { permissionModes: ["agent", "plan", "bypassPermissions"], sandboxModes: ["off", "on"], defaultPermissionMode: "agent" },
-      // Read-only first for display; dsh's own default preset is `workspace-write` (`default`).
-      dsh: { permissionModes: ["plan", "default", "bypassPermissions"], sandboxModes: [], defaultPermissionMode: "default" }
-    };
-  }
-});
-
 // ../../packages/shared/src/window-layout.ts
 var WINDOW_LAYOUT_IPC_CHANNELS;
 var init_window_layout = __esm({
@@ -12438,6 +12827,7 @@ var init_agent_types = __esm({
       ENVIRONMENT_SEND_SESSION_MESSAGE: "environment:sendSessionMessage",
       /** Open a remote session in the chat at a node snapshot (`session.load`) and follow it. */
       ENVIRONMENT_OPEN_REMOTE_SESSION: "environment:openRemoteSession",
+      ENVIRONMENT_LOAD_TRANSCRIPT_FOLD: "environment:loadTranscriptFold",
       ENVIRONMENT_SUBSCRIBE_DETAIL: "environment:subscribeDetail",
       ENVIRONMENT_UNSUBSCRIBE_DETAIL: "environment:unsubscribeDetail",
       ENVIRONMENT_INTERRUPT_SESSION: "environment:interruptSession",
@@ -12617,16 +13007,6 @@ var init_harness_sandbox = __esm({
   }
 });
 
-// ../../packages/shared/src/codex-fast-mode.ts
-function findCodexFastServiceTier(model) {
-  return model?.serviceTiers?.find((tier) => tier.id === "fast" || tier.id === "priority" || tier.name.trim().toLowerCase() === "fast");
-}
-var init_codex_fast_mode = __esm({
-  "../../packages/shared/src/codex-fast-mode.ts"() {
-    "use strict";
-  }
-});
-
 // ../../packages/shared/src/model-option-params.ts
 function isEffortCatalogParam(param) {
   if (param.id === "thinking" || /^thinking$/i.test(param.displayName ?? "")) return false;
@@ -14373,17 +14753,17 @@ function mapQuestionRequest(payload, fallbackId) {
 function mapPlanRequest(payload, fallbackId) {
   const interactionId = asString2(payload.interactionId) ?? asString2(payload.requestId) ?? fallbackId;
   const input = asRecord2(payload.input);
-  let planContent = asString2(payload.plan) ?? asString2(payload.planContent) ?? asString2(input.plan) ?? asString2(input.planContent) ?? "";
-  if (!planContent && input.plan && typeof input.plan === "object") {
+  let planContent2 = asString2(payload.plan) ?? asString2(payload.planContent) ?? asString2(input.plan) ?? asString2(input.planContent) ?? "";
+  if (!planContent2 && input.plan && typeof input.plan === "object") {
     try {
-      planContent = JSON.stringify(input.plan);
+      planContent2 = JSON.stringify(input.plan);
     } catch {
-      planContent = "";
+      planContent2 = "";
     }
   }
   return {
     requestId: interactionId,
-    planContent: planContent || "Plan approval required",
+    planContent: planContent2 || "Plan approval required",
     planFilePath: asString2(payload.planFilePath) ?? asString2(input.planFilePath) ?? "",
     allowedPrompts: Array.isArray(payload.allowedPrompts) ? payload.allowedPrompts : Array.isArray(input.allowedPrompts) ? input.allowedPrompts : []
   };
@@ -19250,160 +19630,6 @@ var init_codex_metadata2 = __esm({
   }
 });
 
-// ../../packages/shared/src/claude-fast-mode.ts
-function supportsClaudeFastMode(model, modelEnv) {
-  return !Object.keys(modelEnv ?? {}).length && model?.supportsFastMode === true;
-}
-var init_claude_fast_mode = __esm({
-  "../../packages/shared/src/claude-fast-mode.ts"() {
-    "use strict";
-  }
-});
-
-// ../../packages/shared/src/suggested-task-launch.ts
-function suggestedTaskSettings(settings) {
-  return Object.fromEntries(SUGGESTED_TASK_SETTING_KEYS.flatMap((key) => settings[key] === void 0 ? [] : [[key, settings[key]]]));
-}
-function suggestedTaskRunSettings(profile, settings, codexFast = true) {
-  const picked = suggestedTaskSettings(settings);
-  const model = profile.models.find((model2) => model2.id === (picked.model ?? profile.defaultConfig.model));
-  const modelEnv = profile.apiProviders.find((provider2) => provider2.id === (picked.apiProviderId ?? profile.defaultConfig.apiProviderId))?.modelEnv;
-  if (profile.harnessId !== "codex" || !codexFast || !findCodexFastServiceTier(model)) delete picked.fastMode;
-  if (profile.harnessId !== "claude" || !supportsClaudeFastMode(model, modelEnv)) delete picked.claudeFastMode;
-  if (picked.effort && profile.efforts.length && !profile.efforts.includes(picked.effort)) delete picked.effort;
-  return picked;
-}
-function suggestedTaskInitialChoice(profiles, providerId, settings) {
-  const own = profiles.find((profile) => profile.id === providerId);
-  if (!own) return profiles[0] ? { agentId: profiles[0].id, settings: {} } : null;
-  const picked = suggestedTaskSettings(settings);
-  if (picked.apiProviderId && !own.apiProviders.some((provider2) => provider2.id === picked.apiProviderId)) delete picked.apiProviderId;
-  return { agentId: own.id, settings: picked };
-}
-function suggestedTaskBranchName(title2, taskId) {
-  const slug = title2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40).replace(/-+$/, "");
-  const id = taskId.replace(/[^a-z0-9]/gi, "").slice(0, 8);
-  return `task/${slug ? `${slug}-` : ""}${id}`;
-}
-function parseSuggestedTaskChoice(value) {
-  const invalid11 = (message) => {
-    throw Object.assign(new Error(message), { code: "invalid_argument" });
-  };
-  if (value === void 0) return void 0;
-  if (!value || typeof value !== "object" || Array.isArray(value)) return invalid11("invalid task launch choice");
-  const { agentId, settings } = value;
-  if (typeof agentId !== "string" || !agentId.trim() || !settings || typeof settings !== "object" || Array.isArray(settings)) return invalid11("task launch needs an agent and settings");
-  const input = settings;
-  const picked = {};
-  for (const key of SUGGESTED_TASK_SETTING_KEYS) {
-    const entry3 = input[key];
-    if (entry3 === void 0) continue;
-    const valid = key === "fastMode" || key === "claudeFastMode" ? typeof entry3 === "boolean" : key === "apiProviderId" && entry3 === null || typeof entry3 === "string";
-    if (!valid) return invalid11(`invalid task launch ${key}`);
-    if (key === "permissionMode" && !Object.values(HARNESS_LAUNCH_OPTIONS).some((option) => option.permissionModes.some((mode) => mode === entry3))) return invalid11("invalid permission mode");
-    if (key === "sandboxMode" && !Object.values(HARNESS_LAUNCH_OPTIONS).some((option) => option.sandboxModes.some((mode) => mode === entry3))) return invalid11("invalid sandbox mode");
-    Object.assign(picked, { [key]: entry3 });
-  }
-  return { agentId, settings: picked };
-}
-var SUGGESTED_TASK_SETTING_KEYS;
-var init_suggested_task_launch = __esm({
-  "../../packages/shared/src/suggested-task-launch.ts"() {
-    "use strict";
-    init_launch_options();
-    init_claude_fast_mode();
-    init_codex_fast_mode();
-    SUGGESTED_TASK_SETTING_KEYS = ["model", "effort", "apiProviderId", "permissionMode", "sandboxMode", "fastMode", "claudeFastMode"];
-  }
-});
-
-// ../../packages/shared/src/suggested-task.ts
-function record5(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function isSuggestTaskTool(toolName) {
-  if (typeof toolName !== "string") return false;
-  const mcp = parseMcpToolName(toolName);
-  return mcp?.serverName === "superone" && mcp.mcpToolName === SUGGEST_TASK_TOOL_NAME;
-}
-function parseInput2(raw) {
-  let value = raw;
-  if (typeof raw === "string") {
-    try {
-      value = JSON.parse(raw);
-    } catch {
-      return null;
-    }
-  }
-  const input = record5(value);
-  const title2 = typeof input.title === "string" ? input.title.trim() : "";
-  const prompt = typeof input.prompt === "string" ? input.prompt.trim() : "";
-  if (!title2 || !prompt) return null;
-  const cwd = typeof input.cwd === "string" && input.cwd.trim() ? input.cwd.trim() : void 0;
-  return { title: title2, tldr: typeof input.tldr === "string" ? input.tldr.trim() : "", prompt, ...cwd ? { cwd } : {} };
-}
-function contentOf(message) {
-  const value = record5(message);
-  return readableContent({ content: Array.isArray(value.content) ? value.content : [], metadata: value.metadata }).map(record5);
-}
-function locateToolUse(messages, toolUseId) {
-  for (let messageIndex = messages.length - 1; messageIndex >= 0; messageIndex--) {
-    const use = contentOf(messages[messageIndex]).find((row2) => row2.type === "tool_use" && row2.toolUseId === toolUseId);
-    if (use) return isSuggestTaskTool(use.toolName) ? { messageIndex, rowId: String(use.toolUseId), row: use } : null;
-  }
-  return null;
-}
-function locate(messages, taskId) {
-  if (!taskId) return null;
-  for (let messageIndex = messages.length - 1; messageIndex >= 0; messageIndex--) {
-    const message = record5(messages[messageIndex]);
-    for (const block of contentOf(message)) {
-      if (block.type !== "tool_result" || typeof block.summary !== "string" || !block.summary.includes(taskId)) continue;
-      const use = locateToolUse(messages, block.toolUseId);
-      if (use) return use;
-    }
-  }
-  return null;
-}
-function findSuggestedTask(messages, taskId) {
-  const found = locate(messages, taskId);
-  if (!found) return null;
-  const input = parseInput2(found.row.input);
-  if (!input) return null;
-  const state = found.row.suggestedTask;
-  return { input, ...state ? { state } : {} };
-}
-function applySuggestedTaskUpdate(messages, taskId, state) {
-  const found = locate(messages, taskId);
-  if (!found || found.row.suggestedTask) return messages;
-  const patch = (row2) => {
-    const value = record5(row2);
-    const matches = value.type === "tool_use" && value.toolUseId === found.rowId || value.type === "mcp_tool_call" && value.id === found.rowId;
-    return matches ? { ...value, suggestedTask: state } : row2;
-  };
-  return messages.map((message, index) => {
-    if (index !== found.messageIndex) return message;
-    const value = record5(message);
-    const metadata = record5(value.metadata);
-    const codex = record5(metadata.codex);
-    return {
-      ...value,
-      ...Array.isArray(value.content) ? { content: value.content.map(patch) } : {},
-      ...Array.isArray(codex.items) ? { metadata: { ...metadata, codex: { ...codex, items: codex.items.map(patch) } } } : {}
-    };
-  });
-}
-var SUGGEST_TASK_TOOL_NAME;
-var init_suggested_task = __esm({
-  "../../packages/shared/src/suggested-task.ts"() {
-    "use strict";
-    init_codex_content();
-    init_tool_ui();
-    init_suggested_task_launch();
-    SUGGEST_TASK_TOOL_NAME = "session_suggest_task";
-  }
-});
-
 // ../../packages/chat-core/src/ports.ts
 function createStreamingToolInputState() {
   return {
@@ -19456,81 +19682,6 @@ var init_ports = __esm({
   }
 });
 
-// ../../packages/shared/src/codex-async-question.ts
-function isCodexAsyncAnswer(message) {
-  return message.role === "user" && message.id.startsWith("codex_async_answer:");
-}
-function codexAsyncReplyText(message) {
-  return message?.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("\n") ?? null;
-}
-function isDismissedCodexAsyncAnswer(message, messages = []) {
-  if (!isCodexAsyncAnswer(message)) return false;
-  const reply = codexAsyncReplyText(message)?.trim();
-  if (reply === CODEX_ASYNC_QUESTION_DISMISSED) return true;
-  if (!reply) return false;
-  const questions = codexAsyncAnswerQuestions(message, messages);
-  return !!questions?.length && reply === formatCodexAsyncQuestionReply(questions, questions.map(() => CODEX_ASYNC_QUESTION_DISMISSED)).trim();
-}
-function codexAsyncQuestionRequest(item) {
-  return {
-    requestId: codexAsyncAnswerId(item.id),
-    questions: (item.questions ?? []).map((question, index) => ({
-      id: String(index),
-      question: question.title,
-      header: question.title,
-      multiSelect: false,
-      options: (question.options ?? []).map((label) => ({ label, description: "" }))
-    }))
-  };
-}
-function codexAsyncQuestionItems(message) {
-  return readableContent(message).flatMap((block) => block.type === "text" && block.id && !block.parentToolUseId && block.codexAsyncQuestions?.length ? [{ id: block.id, type: "agent_message", text: block.text, delivery: "async", questions: block.codexAsyncQuestions }] : []);
-}
-function pendingCodexAsyncQuestions(messages) {
-  const answered = new Set(messages.filter(isCodexAsyncAnswer).map((message) => message.id));
-  const seen = /* @__PURE__ */ new Set();
-  const pending3 = [];
-  for (const message of messages) {
-    if (message.role !== "assistant") continue;
-    for (const item of codexAsyncQuestionItems(message)) {
-      if (seen.has(item.id)) continue;
-      seen.add(item.id);
-      if (!answered.has(codexAsyncAnswerId(item.id))) pending3.push({ messageId: message.id, item, request: codexAsyncQuestionRequest(item) });
-    }
-  }
-  return pending3;
-}
-function codexAsyncQuestionQueue(session) {
-  const pending3 = session.pendingAsyncQuestions ?? pendingCodexAsyncQuestions(session.messages);
-  const answered = new Set(session.messages.filter(isCodexAsyncAnswer).map((message) => message.id));
-  return pending3.some((q2) => answered.has(q2.request.requestId)) ? pending3.filter((q2) => !answered.has(q2.request.requestId)) : pending3;
-}
-function codexAsyncAnswerQuestions(message, messages) {
-  if (!isCodexAsyncAnswer(message)) return void 0;
-  const stored = message.content.find((block) => block.type === "text" && block.codexAsyncQuestions?.length);
-  if (stored?.type === "text") return stored.codexAsyncQuestions;
-  const itemId = message.id.slice("codex_async_answer:".length);
-  for (const source of messages) {
-    const item = source.role === "assistant" ? codexAsyncQuestionItems(source).find((item2) => item2.id === itemId) : void 0;
-    if (item) return item.questions;
-  }
-  return void 0;
-}
-function formatCodexAsyncQuestionReply(questions, answers) {
-  if (questions.length === 1) return answers[0]?.trim() ?? "";
-  return questions.map((question, index) => `${question.title}
-${answers[index]?.trim() ?? ""}`).join("\n\n");
-}
-var codexAsyncAnswerId, CODEX_ASYNC_QUESTION_DISMISSED;
-var init_codex_async_question = __esm({
-  "../../packages/shared/src/codex-async-question.ts"() {
-    "use strict";
-    init_codex_content();
-    codexAsyncAnswerId = (itemId) => `codex_async_answer:${itemId}`;
-    CODEX_ASYNC_QUESTION_DISMISSED = "[The user dismissed this question.]";
-  }
-});
-
 // ../../packages/chat-core/src/codex.ts
 function reduceCodex(session, event, ports2 = defaultChatCorePorts) {
   switch (event.type) {
@@ -19674,22 +19825,6 @@ var init_transformers = __esm({
   }
 });
 
-// ../../packages/chat-core/src/media-predicates.ts
-function isMediaGenerateVideoTool(toolName) {
-  return toolName === MEDIA_GENERATE_VIDEO_TOOL;
-}
-function isMediaVideoStatusTool(toolName) {
-  return toolName === MEDIA_VIDEO_STATUS_TOOL;
-}
-var MEDIA_GENERATE_VIDEO_TOOL, MEDIA_VIDEO_STATUS_TOOL;
-var init_media_predicates = __esm({
-  "../../packages/chat-core/src/media-predicates.ts"() {
-    "use strict";
-    MEDIA_GENERATE_VIDEO_TOOL = "mcp__superone__media_generate_video";
-    MEDIA_VIDEO_STATUS_TOOL = "mcp__superone__media_video_status";
-  }
-});
-
 // ../../packages/chat-core/src/host-workflow-card.ts
 function runIdFromSummary(summary2) {
   if (!summary2) return void 0;
@@ -19880,6 +20015,99 @@ function todoWriteTodos(input) {
 function todoListUpdate(session, todos) {
   return { todos, _nextTodoId: Object.keys(todos).length + 1, ...!session._todosUserDismissed && { showTodos: true } };
 }
+function applyTodoToolInput(session, toolName, input, resultToolTodos) {
+  if (toolName === "TodoWrite") {
+    const listed = todoWriteTodos(input);
+    return listed ? todoListUpdate(session, listed) : null;
+  }
+  if (toolName === "TaskCreate") {
+    const resolvedId = resultToolTodos?.[0]?.taskId;
+    const id = resolvedId ?? String(session._nextTodoId);
+    return {
+      ...resolvedId ? {} : { _nextTodoId: session._nextTodoId + 1 },
+      showTodos: !session._todosUserDismissed,
+      todos: {
+        ...session.todos,
+        [id]: {
+          id,
+          subject: input.subject ?? "",
+          description: input.description ?? "",
+          status: "pending",
+          activeForm: input.activeForm
+        }
+      }
+    };
+  }
+  if (toolName === "TaskUpdate" && input.taskId) return mergeTaskUpdate(session, input.taskId, input);
+  return null;
+}
+function applyTodoResult(session, delta) {
+  const items = delta.toolTodos;
+  const toolName = delta.todoToolName;
+  if (!items || !toolName) return null;
+  if (toolName === "TodoWrite") {
+    return applyTodoToolInput(session, toolName, {
+      todos: items.map((item2) => ({
+        content: item2.subject ?? item2.content,
+        description: item2.description,
+        status: item2.status,
+        activeForm: item2.activeForm
+      }))
+    });
+  }
+  const item = items[0];
+  if (!item) return null;
+  if (toolName === "TaskCreate") {
+    return applyTodoToolInput(session, toolName, {
+      subject: item.subject ?? item.content,
+      description: item.description,
+      activeForm: item.activeForm
+    }, item.taskId ? [{ taskId: item.taskId }] : void 0);
+  }
+  if (toolName === "TaskUpdate") {
+    return applyTodoToolInput(session, toolName, {
+      taskId: item.taskId,
+      status: item.status || void 0,
+      subject: item.subject,
+      description: item.description,
+      activeForm: item.activeForm,
+      owner: item.owner,
+      addBlockedBy: item.addBlockedBy,
+      addBlocks: item.addBlocks
+    });
+  }
+  return null;
+}
+function mergeTaskUpdate(session, taskId, input) {
+  const existing = session.todos[taskId];
+  if (!existing) return null;
+  if (input.status === "deleted") {
+    const { [taskId]: _3, ...rest } = session.todos;
+    return { todos: rest };
+  }
+  const mergeIds = (prev, add) => {
+    if (!Array.isArray(add) || add.length === 0) return prev;
+    return Array.from(/* @__PURE__ */ new Set([...prev ?? [], ...add.map(String)]));
+  };
+  const nextBlockedBy = mergeIds(existing.blockedBy, input.addBlockedBy);
+  const nextBlocks = mergeIds(existing.blocks, input.addBlocks);
+  return {
+    ...!session._todosUserDismissed && { showTodos: true },
+    todos: {
+      ...session.todos,
+      [taskId]: {
+        ...existing,
+        ...input.status && { status: input.status },
+        ...input.subject && { subject: input.subject },
+        ...input.description && { description: input.description },
+        ...input.activeForm && { activeForm: input.activeForm },
+        ...input.owner && { owner: input.owner },
+        ...nextBlockedBy && { blockedBy: nextBlockedBy },
+        ...nextBlocks && { blocks: nextBlocks }
+      }
+    }
+  };
+}
 var init_todos = __esm({
   "../../packages/chat-core/src/todos.ts"() {
     "use strict";
@@ -19944,59 +20172,8 @@ function reduceContentDelta(session, event, ports2 = defaultChatCorePorts) {
       const tn2 = toolBlock.toolName;
       if (!resultDelta.isError && (tn2 === "TodoWrite" || tn2 === "TaskCreate" || tn2 === "TaskUpdate")) {
         try {
-          const input = JSON.parse(toolBlock.input);
-          const listed = tn2 === "TodoWrite" ? todoWriteTodos(input) : null;
-          if (listed) {
-            extraUpdates = todoListUpdate(session, listed);
-          } else if (tn2 === "TaskCreate") {
-            const resolvedId = resultDelta.toolTodos?.[0]?.taskId;
-            const id = resolvedId ?? String(session._nextTodoId);
-            extraUpdates = {
-              ...resolvedId ? {} : { _nextTodoId: session._nextTodoId + 1 },
-              showTodos: !session._todosUserDismissed,
-              todos: {
-                ...session.todos,
-                [id]: {
-                  id,
-                  subject: input.subject ?? "",
-                  description: input.description ?? "",
-                  status: "pending",
-                  activeForm: input.activeForm
-                }
-              }
-            };
-          } else if (tn2 === "TaskUpdate" && input.taskId) {
-            const existing = session.todos[input.taskId];
-            if (existing) {
-              if (input.status === "deleted") {
-                const { [input.taskId]: _3, ...rest } = session.todos;
-                extraUpdates = { todos: rest };
-              } else {
-                const mergeIds = (prev, add) => {
-                  if (!Array.isArray(add) || add.length === 0) return prev;
-                  return Array.from(/* @__PURE__ */ new Set([...prev ?? [], ...add.map(String)]));
-                };
-                const nextBlockedBy = mergeIds(existing.blockedBy, input.addBlockedBy);
-                const nextBlocks = mergeIds(existing.blocks, input.addBlocks);
-                extraUpdates = {
-                  ...!session._todosUserDismissed && { showTodos: true },
-                  todos: {
-                    ...session.todos,
-                    [input.taskId]: {
-                      ...existing,
-                      ...input.status && { status: input.status },
-                      ...input.subject && { subject: input.subject },
-                      ...input.description && { description: input.description },
-                      ...input.activeForm && { activeForm: input.activeForm },
-                      ...input.owner && { owner: input.owner },
-                      ...nextBlockedBy && { blockedBy: nextBlockedBy },
-                      ...nextBlocks && { blocks: nextBlocks }
-                    }
-                  }
-                };
-              }
-            }
-          }
+          const applied = applyTodoToolInput(session, tn2, JSON.parse(toolBlock.input), resultDelta.toolTodos);
+          if (applied) extraUpdates = applied;
         } catch {
         }
       }
@@ -20075,6 +20252,14 @@ function reduceContentDelta(session, event, ports2 = defaultChatCorePorts) {
     const stripped = dropHostWorkflowShadow(updatedMessages, resultDelta.toolUseId, resultDelta.summary);
     if (stripped) updatedMessages = stripped;
   }
+  if (event.delta.type === "todo_result") {
+    const resultDelta = event.delta;
+    ports2.streaming.clear(resultDelta.toolUseId);
+    const restPreviews = dropStreamingToolInputPreview(session._streamingToolInputPreviews, resultDelta.toolUseId);
+    if (restPreviews) extraUpdates._streamingToolInputPreviews = restPreviews;
+    const applied = applyTodoResult(session, resultDelta);
+    if (applied) extraUpdates = { ...extraUpdates, ...applied };
+  }
   return { messages: updatedMessages, lastEventAt: ports2.now(), ...extraUpdates };
 }
 var init_content = __esm({
@@ -20094,80 +20279,6 @@ var init_content = __esm({
   }
 });
 
-// ../../packages/shared/src/transcript-boundary.ts
-function contentKeys(content) {
-  const counts = /* @__PURE__ */ new Map();
-  return content.map((block) => {
-    if (isToolUseBlock(block)) return `tool:${block.toolUseId}`;
-    if (isToolResultBlock(block)) return `result:${block.toolUseId}`;
-    const parent = "parentToolUseId" in block ? block.parentToolUseId ?? "" : "";
-    const kind = `${block.type}:${parent}`;
-    const count = counts.get(kind) ?? 0;
-    counts.set(kind, count + 1);
-    return `${kind}:${count}`;
-  });
-}
-function blockText(block) {
-  return block.type === "text" ? block.text : block.type === "thinking" ? block.thinking : void 0;
-}
-function itemText(item) {
-  return "text" in item ? item.text : void 0;
-}
-function transcriptLengths(message) {
-  const keys = contentKeys(message.content);
-  return {
-    content: Object.fromEntries(message.content.map((block, index) => [keys[index], blockText(block)?.length ?? -1])),
-    items: Object.fromEntries((message.metadata?.codex?.items ?? []).map((item) => [item.id, itemText(item)?.length ?? -1]))
-  };
-}
-function resolveTranscriptBoundaries(cuts, lengths) {
-  let previous = { content: {}, items: {} };
-  return cuts.map((cut) => {
-    const cursor = cut.metadata.transcriptBoundary;
-    const asyncAnswer = isCodexAsyncAnswer(cut);
-    const resolved = { ...cursor, content: { ...previous.content }, items: { ...previous.items } };
-    for (const kind of ["content", "items"]) {
-      for (const [key, offset] of Object.entries(cursor[kind])) {
-        const end = asyncAnswer ? lengths[kind][key] ?? offset : offset;
-        resolved[kind][key] = Math.max(previous[kind][key] ?? -1, end);
-      }
-    }
-    previous = resolved;
-    return resolved;
-  });
-}
-function captureTranscriptBoundary(message, messages = []) {
-  let order = capturedOrders.get(message.id) ?? 0;
-  for (const row2 of messages) {
-    const cursor = row2.metadata?.transcriptBoundary;
-    if (cursor?.messageId === message.id) order = Math.max(order, cursor.order);
-  }
-  order += 1;
-  capturedOrders.delete(message.id);
-  capturedOrders.set(message.id, order);
-  if (capturedOrders.size > 1024) capturedOrders.delete(capturedOrders.keys().next().value);
-  return {
-    messageId: message.id,
-    order,
-    ...transcriptLengths(message)
-  };
-}
-function anchorAsyncAnswer(message, messages) {
-  if (!isCodexAsyncAnswer(message) || message.metadata?.transcriptBoundary) return message;
-  const itemId = message.id.slice("codex_async_answer:".length);
-  const source = messages.findLast((row2) => row2.status === "streaming" && row2.role === "assistant" && codexAsyncQuestionItems(row2).some((item) => item.id === itemId)) ?? messages.findLast((row2) => row2.status === "streaming" && row2.role === "assistant" && row2.providerId === "codex");
-  return source ? { ...message, metadata: { ...message.metadata, transcriptBoundary: captureTranscriptBoundary(source, messages) } } : message;
-}
-var capturedOrders;
-var init_transcript_boundary = __esm({
-  "../../packages/shared/src/transcript-boundary.ts"() {
-    "use strict";
-    init_codex_async_question();
-    init_content_delta();
-    capturedOrders = /* @__PURE__ */ new Map();
-  }
-});
-
 // ../../packages/shared/src/codex-timeline-rows.ts
 function stampCodexTimelineOrder(message, event) {
   const timeline = message.metadata?.codexTimeline;
@@ -22326,7 +22437,8 @@ var init_read_model = __esm({
             idColumn: "message_id",
             columns: "message_json, sort_order",
             sessionId,
-            parse: (row2) => JSON.parse(row2.message_json)
+            parse: (row2) => JSON.parse(row2.message_json),
+            boundarySql: `SELECT message_json, sort_order FROM session_messages WHERE session_id = ? AND instr(message_json, '"transcriptBoundary"') > 0 ORDER BY sort_order ASC`
           }),
           state: includeState ? coreState(core) : {},
           cursor: { sequence: this.log.headSequence(), epoch: this.log.epoch, version: checkpoint.applied_version }
@@ -40500,6 +40612,7 @@ var UI_SURFACE_CAPABILITY, ModUiUnavailableError, ModSurface;
 var init_mod_surface = __esm({
   "../../packages/claude/src/mod-surface/mod-surface.ts"() {
     "use strict";
+    init_slash_commands();
     init_mod_ui();
     init_wire();
     UI_SURFACE_CAPABILITY = "ui_surface_v1";
@@ -40520,7 +40633,10 @@ var init_mod_surface = __esm({
           promptSuggest: (req) => this.relayHostRequest("promptSuggest", req)
         });
         void query.initializationResult?.().then(
-          (init) => this.setAvailable(Array.isArray(init?.capabilities) && init.capabilities.includes(UI_SURFACE_CAPABILITY)),
+          (init) => {
+            this.setAvailable(Array.isArray(init?.capabilities) && init.capabilities.includes(UI_SURFACE_CAPABILITY));
+            if (!this.disposed && Array.isArray(init?.commands)) this.opts.emit({ type: "session_commands", commands: sdkSlashCommands(init.commands, void 0) });
+          },
           () => this.setAvailable(false)
         );
       }
@@ -42556,21 +42672,21 @@ function extractThinkingFromAssistant(item) {
   return asString4(get(item, "reasoning_content"));
 }
 function claudeToolUseToChatToolCall(item) {
-  const callId = asString4(get(item, "id")) ?? asString4(get(item, "tool_use_id"));
+  const callId2 = asString4(get(item, "id")) ?? asString4(get(item, "tool_use_id"));
   const name = asString4(get(item, "name"));
-  if (!callId || !name) return void 0;
+  if (!callId2 || !name) return void 0;
   const input = get(item, "input") ?? get(item, "arguments");
   return {
-    id: callId,
+    id: callId2,
     type: "function",
     function: { name, arguments: canonicalizeToolArguments(input) }
   };
 }
 function claudeFunctionCallToChatToolCall(functionCall) {
-  const callId = asString4(get(functionCall, "id")) ?? "call_0";
+  const callId2 = asString4(get(functionCall, "id")) ?? "call_0";
   const name = asString4(get(functionCall, "name")) ?? "";
   const args = canonicalizeToolArguments(get(functionCall, "arguments"));
-  return { id: callId, type: "function", function: { name, arguments: args } };
+  return { id: callId2, type: "function", function: { name, arguments: args } };
 }
 function claudeToolResultToChat(item) {
   const toolUseId = asString4(get(item, "tool_use_id")) ?? asString4(get(item, "call_id")) ?? "";
@@ -42761,24 +42877,24 @@ function chatToolCallsToOutputItems(message) {
   return output;
 }
 function chatToolCallToOutputItem(toolCall, index) {
-  const callId = asString4(get(toolCall, "id"))?.trim() || `call_${index}`;
+  const callId2 = asString4(get(toolCall, "id"))?.trim() || `call_${index}`;
   const fn = get(toolCall, "function");
   const name = asString4(get(fn, "name")) ?? "";
   const args = canonicalizeToolArguments(get(fn, "arguments"));
   return {
     type: "tool_use",
-    id: callId,
+    id: callId2,
     name,
     input: safeJsonParse(args)
   };
 }
 function chatLegacyFunctionCallToOutputItem(functionCall) {
-  const callId = asString4(get(functionCall, "id"))?.trim() || "call_0";
+  const callId2 = asString4(get(functionCall, "id"))?.trim() || "call_0";
   const name = asString4(get(functionCall, "name")) ?? "";
   const args = canonicalizeToolArguments(get(functionCall, "arguments"));
   return {
     type: "tool_use",
-    id: callId,
+    id: callId2,
     name,
     input: safeJsonParse(args)
   };
@@ -43766,8 +43882,8 @@ function appendResponsesItem(item, messages, state) {
     }
     case "function_call_output": {
       flushPendingToolCalls(messages, state);
-      const callId = asString6(get2(item, "call_id")) ?? "";
-      messages.push({ role: "tool", tool_call_id: callId, content: functionCallOutput(get2(item, "output")) });
+      const callId2 = asString6(get2(item, "call_id")) ?? "";
+      messages.push({ role: "tool", tool_call_id: callId2, content: functionCallOutput(get2(item, "output")) });
       return;
     }
     case "reasoning": {
@@ -43899,10 +44015,10 @@ function responsesContentToChatContent(content) {
   return chatParts;
 }
 function responsesFunctionCallToChatToolCall(item) {
-  const callId = asString6(get2(item, "call_id")) ?? asString6(get2(item, "id")) ?? "";
+  const callId2 = asString6(get2(item, "call_id")) ?? asString6(get2(item, "id")) ?? "";
   const name = asString6(get2(item, "name")) ?? "";
   return {
-    id: callId,
+    id: callId2,
     type: "function",
     function: { name, arguments: canonicalizeToolArguments2(get2(item, "arguments")) }
   };
@@ -44069,12 +44185,12 @@ function chatToolCallsToOutputItems2(message, reasoning) {
   }
   return output;
 }
-function functionCallItem(itemId, callId, name, args, reasoning) {
+function functionCallItem(itemId, callId2, name, args, reasoning) {
   const item = {
     id: itemId,
     type: "function_call",
     status: "completed",
-    call_id: callId,
+    call_id: callId2,
     name,
     arguments: args
   };
@@ -44082,17 +44198,17 @@ function functionCallItem(itemId, callId, name, args, reasoning) {
   return item;
 }
 function chatToolCallToOutputItem2(toolCall, index, reasoning) {
-  const callId = asString6(get2(toolCall, "id"))?.trim() || `call_${index}`;
+  const callId2 = asString6(get2(toolCall, "id"))?.trim() || `call_${index}`;
   const fn = get2(toolCall, "function");
   const name = asString6(get2(fn, "name")) ?? "";
   const args = canonicalizeToolArguments2(get2(fn, "arguments"));
-  return functionCallItem(`fc_${callId}`, callId, name, args, reasoning);
+  return functionCallItem(`fc_${callId2}`, callId2, name, args, reasoning);
 }
 function chatLegacyFunctionCallToOutputItem2(functionCall, reasoning) {
-  const callId = asString6(get2(functionCall, "id"))?.trim() || "call_0";
+  const callId2 = asString6(get2(functionCall, "id"))?.trim() || "call_0";
   const name = asString6(get2(functionCall, "name")) ?? "";
   const args = canonicalizeToolArguments2(get2(functionCall, "arguments"));
-  return functionCallItem(`fc_${callId}`, callId, name, args, reasoning);
+  return functionCallItem(`fc_${callId2}`, callId2, name, args, reasoning);
 }
 function chatUsageToResponsesUsage(usage2) {
   const obj = asObject4(usage2);
@@ -44164,12 +44280,12 @@ data: ${JSON.stringify(data)}
 
 `;
 }
-function functionCallItem2(itemId, status2, callId, name, args, reasoning) {
+function functionCallItem2(itemId, status2, callId2, name, args, reasoning) {
   const item = {
     id: itemId,
     type: "function_call",
     status: status2,
-    call_id: callId,
+    call_id: callId2,
     name,
     arguments: args
   };
@@ -70763,23 +70879,6 @@ var init_computer_use_result_shape = __esm({
   }
 });
 
-// ../../packages/shared/src/jev-run-result-shape.ts
-function isJevRunToolName(toolName) {
-  if (!toolName) return false;
-  return /(?:^|__)(?:browser|computer|device)_run$/.test(toolName);
-}
-function looksLikeJevRunResult(obj) {
-  const status2 = obj.status;
-  if (status2 !== "paused" && status2 !== "done" && status2 !== "aborted") return false;
-  if (typeof obj.runId !== "string") return false;
-  return Array.isArray(obj.since_last) || typeof obj.progress === "object" && obj.progress !== null || typeof obj.steps === "number";
-}
-var init_jev_run_result_shape = __esm({
-  "../../packages/shared/src/jev-run-result-shape.ts"() {
-    "use strict";
-  }
-});
-
 // ../../packages/acp/src/tool-result-map.ts
 function formatAcpRawOutput(raw) {
   return formatAgentToolOutput(raw);
@@ -73042,13 +73141,13 @@ function createAcpAgentTurnRunner(opts = {}) {
         if (!input.onPlan) return formatGrokExitPlanCancelled();
         const raw = ctx.params && typeof ctx.params === "object" && !Array.isArray(ctx.params) ? ctx.params : {};
         const toolCallId = typeof raw.toolCallId === "string" ? raw.toolCallId : typeof raw.tool_call_id === "string" ? raw.tool_call_id : `acp_plan_${Date.now().toString(36)}`;
-        const planContent = typeof raw.planContent === "string" ? raw.planContent : typeof raw.plan_content === "string" ? raw.plan_content : "";
+        const planContent2 = typeof raw.planContent === "string" ? raw.planContent : typeof raw.plan_content === "string" ? raw.plan_content : "";
         try {
           const result3 = await input.onPlan({
             interactionId: toolCallId,
             kind: "plan",
             toolUseId: toolCallId,
-            input: { planContent, ...raw },
+            input: { planContent: planContent2, ...raw },
             createdAt: Date.now()
           });
           return formatGrokExitPlanFromDecision(result3.decision, result3.options);
@@ -73415,7 +73514,7 @@ async function waitForServer(child, exited, timeoutMs, signal2) {
   let output = "";
   return new Promise((resolve22, reject) => {
     let settled = false;
-    const finish = (error51, url2) => {
+    const finish2 = (error51, url2) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
@@ -73428,18 +73527,18 @@ async function waitForServer(child, exited, timeoutMs, signal2) {
     const onData = (chunk) => {
       output = appendOutput(output, chunk);
       const match = output.match(/^(?:opencode )?server listening.*?\s+(https?:\/\/[^\s]+)/im);
-      if (match?.[1]) finish(void 0, match[1]);
+      if (match?.[1]) finish2(void 0, match[1]);
     };
-    const onAbort = () => finish(new Error("OpenCode server startup aborted"));
+    const onAbort = () => finish2(new Error("OpenCode server startup aborted"));
     const timer = setTimeout(
-      () => finish(new Error(`Timed out waiting for OpenCode server: ${output.trim()}`)),
+      () => finish2(new Error(`Timed out waiting for OpenCode server: ${output.trim()}`)),
       timeoutMs
     );
     child.stdout.on("data", onData);
     child.stderr.on("data", onData);
-    child.once("error", (error51) => finish(error51));
+    child.once("error", (error51) => finish2(error51));
     void exited.then(
-      ({ code, signal: sig }) => finish(new Error(`OpenCode server exited (${code ?? sig ?? "unknown"}): ${output.trim()}`))
+      ({ code, signal: sig }) => finish2(new Error(`OpenCode server exited (${code ?? sig ?? "unknown"}): ${output.trim()}`))
     );
     signal2?.addEventListener("abort", onAbort, { once: true });
     if (signal2?.aborted) onAbort();
@@ -73466,13 +73565,13 @@ async function startOpenCodeServer(opts) {
   });
   const exited = new Promise((resolve22) => {
     let settled = false;
-    const finish = (code, signal2) => {
+    const finish2 = (code, signal2) => {
       if (settled) return;
       settled = true;
       resolve22({ code, signal: signal2 });
     };
-    child.once("exit", finish);
-    child.once("close", finish);
+    child.once("exit", finish2);
+    child.once("close", finish2);
   });
   try {
     const url2 = await waitForServer(child, exited, opts.timeoutMs ?? 1e4, opts.signal);
@@ -74429,7 +74528,7 @@ var init_client_gen2 = __esm({
 });
 
 // ../../node_modules/@opencode-ai/sdk/dist/v2/gen/sdk.gen.js
-var HeyApiClient, HeyApiRegistry, Auth, App, ControlPlane, Capabilities, Console, Session, Resource, ProjectCopy, Adapter, Workspace, Experimental, Config, Global, Event2, Config2, Tool, Worktree, Find, File2, Instance, Path, Diff2, Vcs, Command, Lsp, Formatter, Auth2, Mcp, Project, Pty, Question, Permission, Oauth, Provider, Session2, Part, History, Sync, Control, Tui, Health, Location, Agent, Revert, Permission2, Question2, Session3, Model, Provider2, Connect, Attempt, Integration, Credential, Request2, Saved, Permission3, Fs2, Command2, Skill, Event22, Pty2, Request22, Question3, Reference, ProjectCopy2, V2, OpencodeClient;
+var HeyApiClient, HeyApiRegistry, Auth, App, ControlPlane, Capabilities, Console, Session, Resource, ProjectCopy, Adapter, Workspace, Experimental, Config, Global, Event2, Config2, Tool, Worktree, Find, File2, Instance, Path, Diff3, Vcs, Command, Lsp, Formatter, Auth2, Mcp, Project, Pty, Question, Permission, Oauth, Provider, Session2, Part, History, Sync, Control, Tui, Health, Location, Agent, Revert, Permission2, Question2, Session3, Model, Provider2, Connect, Attempt, Integration, Credential, Request2, Saved, Permission3, Fs2, Command2, Skill, Event22, Pty2, Request22, Question3, Reference, ProjectCopy2, V2, OpencodeClient;
 var init_sdk_gen = __esm({
   "../../node_modules/@opencode-ai/sdk/dist/v2/gen/sdk.gen.js"() {
     init_client_gen2();
@@ -75478,7 +75577,7 @@ var init_sdk_gen = __esm({
         });
       }
     };
-    Diff2 = class extends HeyApiClient {
+    Diff3 = class extends HeyApiClient {
       /**
        * Get raw VCS diff
        *
@@ -75591,7 +75690,7 @@ var init_sdk_gen = __esm({
       }
       _diff;
       get diff2() {
-        return this._diff ??= new Diff2({ client: this.client });
+        return this._diff ??= new Diff3({ client: this.client });
       }
     };
     Command = class extends HeyApiClient {
@@ -80160,7 +80259,7 @@ function make7(connect) {
           let started = false;
           let completion;
           let connection;
-          function finish(result3, discard = true) {
+          function finish2(result3, discard = true) {
             completion = result3;
             if (discard)
               queued.length = 0;
@@ -80175,12 +80274,12 @@ function make7(connect) {
             });
           }
           function abort() {
-            finish({});
+            finish2({});
           }
           const subscriber = {
             activity: options?.onActivity,
             finish(result3) {
-              finish(result3, false);
+              finish2(result3, false);
             },
             push(value) {
               if (completion)
@@ -80191,7 +80290,7 @@ function make7(connect) {
                 return;
               }
               if (queued.length === capacity) {
-                finish({ error: new Error(`Event subscriber exceeded its ${capacity}-event capacity`) });
+                finish2({ error: new Error(`Event subscriber exceeded its ${capacity}-event capacity`) });
                 return;
               }
               queued.push(value);
@@ -80236,7 +80335,7 @@ function make7(connect) {
               return request.promise;
             },
             return() {
-              finish({});
+              finish2({});
               return Promise.resolve({ done: true, value: void 0 });
             }
           };
@@ -82514,18 +82613,18 @@ var init_opencode_v2_event_map = __esm({
         switch (event.type) {
           case "permission.asked": {
             const data = event.data;
-            const callId = data.source?.id;
+            const callId2 = data.source?.id;
             return [{
               type: "permission",
               permission: data.action,
-              toolInput: callId && this.toolInputs.get(callId) || null,
+              toolInput: callId2 && this.toolInputs.get(callId2) || null,
               request: mapOpenCodePermissionRequest({
                 id: data.id,
                 permission: data.action,
                 patterns: data.resources,
                 metadata: data.metadata,
                 always: data.save,
-                toolUseId: callId,
+                toolUseId: callId2,
                 message: data.message,
                 source: data.source ? {
                   toolUseId: data.source.id,
@@ -83598,18 +83697,18 @@ var init_opencode_oauth = __esm({
           throw new Error("This OpenCode sign-in method requires an unsupported external form field");
         const form = { id: `superone-oauth-${randomUUID13()}`, sessionID: this.deps.sessionId, title: title2, fields };
         return new Promise((resolve22, reject) => {
-          const finish = (answer) => {
+          const finish2 = (answer) => {
             this.forms.delete(form.id);
             signal2.removeEventListener("abort", aborted2);
             this.emit(answer ? "form.replied" : "form.cancelled", { id: form.id, ...answer ? { answer } : {} });
             if (answer) resolve22(answer);
             else reject(signal2.reason ?? new Error("OpenCode sign-in cancelled"));
           };
-          const aborted2 = () => finish();
+          const aborted2 = () => finish2();
           this.forms.set(form.id, {
             form,
             owner: controller,
-            reply: (answer) => finish(answer),
+            reply: (answer) => finish2(answer),
             cancel: () => controller.abort(new Error("OpenCode sign-in cancelled"))
           });
           signal2.addEventListener("abort", aborted2, { once: true });
@@ -83982,17 +84081,17 @@ async function createOpenCodeV2Runtime(server, opts, ports2) {
     if (agentRevision !== revision) return Promise.resolve();
     abortController.signal.throwIfAborted();
     return new Promise((resolve22, reject) => {
-      const finish = (error51) => {
+      const finish2 = (error51) => {
         clearTimeout(timer);
         agentCatalogWaiters.delete(updated);
         abortController.signal.removeEventListener("abort", aborted2);
         if (error51) reject(error51);
         else resolve22();
       };
-      const updated = () => finish();
-      const aborted2 = () => finish(abortController.signal.reason);
+      const updated = () => finish2();
+      const aborted2 = () => finish2(abortController.signal.reason);
       const timer = setTimeout(
-        () => finish(new Error("OpenCode agent catalog did not finish loading; try refreshing again")),
+        () => finish2(new Error("OpenCode agent catalog did not finish loading; try refreshing again")),
         3e3
       );
       agentCatalogWaiters.add(updated);
@@ -86875,7 +86974,7 @@ function stringifyPayload(value) {
 }
 function extractToolCallParts(update) {
   const rec = asRecord17(update) ?? {};
-  const callId = extractCursorCallId(update);
+  const callId2 = extractCursorCallId(update);
   const nested = asRecord17(rec.toolCall);
   if (nested) {
     const toolType2 = typeof nested.type === "string" && nested.type ? nested.type : "Tool";
@@ -86883,7 +86982,7 @@ function extractToolCallParts(update) {
     const resultRec = asRecord17(result3);
     const isError = resultRec?.status === "error" || Boolean(rec.isError);
     return {
-      callId,
+      callId: callId2,
       toolType: toolType2,
       args: nested.args ?? nested.input ?? {},
       result: resultRec?.status === "success" ? resultRec.value ?? result3 : resultRec?.status === "error" ? resultRec.error ?? result3 : result3,
@@ -86892,7 +86991,7 @@ function extractToolCallParts(update) {
   }
   const toolType = strField2(rec, "name") || strField2(rec, "type") || "Tool";
   return {
-    callId,
+    callId: callId2,
     toolType,
     args: rec.args ?? rec.input ?? {},
     result: rec.result,
@@ -86927,7 +87026,7 @@ function canonicalizeCursorHostTool(toolType, args, result3) {
     ...shaped.isError ? { resultIsError: true } : {}
   };
 }
-function toolUseEvent(messageId, callId, toolType, args, status2, result3) {
+function toolUseEvent(messageId, callId2, toolType, args, status2, result3) {
   const mcp = unwrapCursorMcpTool(toolType, args);
   const unwrapped = canonicalizeCursorHostTool(mcp.toolType, mcp.args, result3);
   const toolName = toolDisplayName(unwrapped.toolType);
@@ -86937,7 +87036,7 @@ function toolUseEvent(messageId, callId, toolType, args, status2, result3) {
     delta: {
       type: "tool_use",
       toolName,
-      toolUseId: callId,
+      toolUseId: callId2,
       input: stringifyPayload(normalizeCursorToolInput(toolName, unwrapped.args)),
       status: status2,
       ...status2 === "streaming" ? { startedAt: Date.now() } : {}
@@ -86976,14 +87075,14 @@ function mergeCursorToolResultArgs(toolType, args, result3) {
   }
   return changed ? next : rec;
 }
-function toolResultEvent(messageId, callId, result3, isError, toolType, args) {
+function toolResultEvent(messageId, callId2, result3, isError, toolType, args) {
   const host = toolType != null ? canonicalizeCursorHostTool(unwrapCursorMcpTool(toolType, args).toolType, args, result3) : null;
   return {
     type: "content_delta",
     messageId,
     delta: {
       type: "tool_result",
-      toolUseId: callId,
+      toolUseId: callId2,
       summary: host?.resultSummary ?? (formatTranscriptToolResult(result3) || stringifyPayload(result3)),
       isError: isError || host?.resultIsError === true
     }
@@ -87206,8 +87305,8 @@ function mapConversationStep(messageId, step, options) {
   if (stepType === "toolCall") {
     const message = rec.message ?? rec.toolCall ?? rec;
     const nested = asRecord17(message);
-    const callId = extractCursorCallId(rec) || options?.resolveCallId?.(step) || null;
-    if (!callId) {
+    const callId2 = extractCursorCallId(rec) || options?.resolveCallId?.(step) || null;
+    if (!callId2) {
       return events;
     }
     const toolType = nested && typeof nested.type === "string" && nested.type ? nested.type : strField2(rec, "name") || "Tool";
@@ -87216,7 +87315,7 @@ function mapConversationStep(messageId, step, options) {
     const resultValue = resultRec?.status === "success" ? resultRec.value ?? nested?.result : nested?.result;
     events.push(toolUseEvent(
       messageId,
-      callId,
+      callId2,
       toolType,
       mergeCursorToolResultArgs(toolType, args, resultValue),
       "complete"
@@ -87491,10 +87590,10 @@ var init_cursor_event_map = __esm({
         if (type !== "tool-call-started" && type !== "partial-tool-call" && type !== "tool-call-completed") {
           return;
         }
-        const callId = extractCursorCallId(update);
-        if (!callId || this.seen.has(callId)) return;
-        this.seen.add(callId);
-        this.queue.push(callId);
+        const callId2 = extractCursorCallId(update);
+        if (!callId2 || this.seen.has(callId2)) return;
+        this.seen.add(callId2);
+        this.queue.push(callId2);
       }
       /** FIFO claim for the next onStep toolCall (or null if nothing to associate). */
       claimNextCallId() {
@@ -100520,6 +100619,44 @@ function resolveTodoToolTodos(toolName, input, resultToolTodos) {
   if (computed?.length) return [{ ...computed[0], taskId: resolvedId }];
   return resultToolTodos;
 }
+function todoItemsForResult(toolName, input, resultToolTodos) {
+  const items = resolveTodoToolTodos(toolName, input, resultToolTodos);
+  if (toolName !== "TaskUpdate" || !items?.[0]) return items;
+  let status2;
+  try {
+    status2 = JSON.parse(input)?.status;
+  } catch {
+    return items;
+  }
+  if (status2 == null || status2 === "") return [{ ...items[0], status: "" }];
+  return items;
+}
+function todoResultForCall(toolName, input, result3) {
+  const toolTodos = result3.isError ? void 0 : todoItemsForResult(toolName, input, result3.toolTodos);
+  return {
+    type: "todo_result",
+    toolUseId: result3.toolUseId,
+    summary: result3.summary,
+    parentToolUseId: result3.parentToolUseId,
+    todoToolName: toolName,
+    ...toolTodos ? { toolTodos } : {}
+  };
+}
+function revealTodoResults(message) {
+  const calls2 = /* @__PURE__ */ new Map();
+  for (const block of message.content) {
+    if (block.type === "tool_use" && TODO_TOOLS.has(block.toolName)) calls2.set(block.toolUseId, { toolName: block.toolName, input: block.input });
+  }
+  if (!calls2.size) return message;
+  let changed = false;
+  const content = message.content.map((block) => {
+    if (block.type !== "tool_result" || !calls2.has(block.toolUseId)) return block;
+    const entry3 = calls2.get(block.toolUseId);
+    changed = true;
+    return todoResultForCall(entry3.toolName, entry3.input, block);
+  });
+  return changed ? { ...message, content } : message;
+}
 function countLines(s4) {
   if (!s4) return 0;
   return s4.split("\n").length;
@@ -100984,8 +101121,7 @@ function stripMessagesForRemote(messages, projectPath, options = {}) {
       content: msg.content.filter((b3) => !(b3.type === "tool_use" && TODO_TOOLS.has(b3.toolName))).flatMap((b3) => {
         if (b3.type === "tool_result" && todoInputs.has(b3.toolUseId)) {
           const entry3 = todoInputs.get(b3.toolUseId);
-          const toolTodos = resolveTodoToolTodos(entry3.toolName, entry3.input, b3.toolTodos);
-          return { type: "todo_result", toolUseId: b3.toolUseId, summary: b3.summary, parentToolUseId: b3.parentToolUseId, todoToolName: entry3.toolName, toolTodos };
+          return todoResultForCall(entry3.toolName, entry3.input, b3);
         }
         if (b3.type === "tool_result" && widgetIds.has(b3.toolUseId)) return b3;
         if (b3.type === "text") {
@@ -101126,8 +101262,7 @@ var EventProfile = class {
       }
       if (event.delta.type === "tool_result" && tools.todoInputs.has(event.delta.toolUseId)) {
         const entry3 = tools.todoInputs.get(event.delta.toolUseId);
-        const toolTodos = resolveTodoToolTodos(entry3.toolName, entry3.input, event.delta.toolTodos);
-        return { ...event, delta: { type: "todo_result", toolUseId: event.delta.toolUseId, summary: event.delta.summary, parentToolUseId: event.delta.parentToolUseId, todoToolName: entry3.toolName, toolTodos } };
+        return { ...event, delta: todoResultForCall(entry3.toolName, entry3.input, event.delta) };
       }
       if (event.delta.type === "tool_result" && tools.widgetIds.has(event.delta.toolUseId)) {
         return { ...event, delta: event.delta };
@@ -101428,6 +101563,15 @@ function toolDetail(message, id) {
   const result3 = message.content.find((block) => block.type === "tool_result" && block.toolUseId === id);
   const projected = stripMessagesForRemote([{ ...message, metadata: void 0, content: [tool2, ...result3 ? [result3] : []] }])[0].content[0];
   const children = message.content.filter((block) => block.type !== "thinking" && "parentToolUseId" in block && block.parentToolUseId === id).map((block) => "toolName" in block ? projectTool(block, JSON.stringify([message.id, "tool", block.toolUseId])) : block.type === "tool_result" ? { type: "tool_result", toolUseId: block.toolUseId, summary: "", isError: block.isError } : block);
+  const transcriptChildren = children.some((block) => block.type === "tool_use") || !isSubagentToolName(tool2.toolName) || !tool2.taskOutputFile ? [] : remoteContentPorts().readAgentOutput(tool2.taskOutputFile).toolEntries.flatMap((entry3, index) => isAlwaysHiddenToolName(entry3.toolName) ? [] : [{
+    type: "tool_use",
+    toolName: entry3.toolName,
+    toolUseId: `${id}:transcript:${index}`,
+    input: "{}",
+    status: "complete",
+    toolSummary: entry3.description,
+    parentToolUseId: id
+  }]);
   const output = result3 && "summary" in result3 ? result3.summary : tool2.liveOutput;
   const projectedTool = projected && "toolName" in projected ? projected : void 0;
   const input = parseInput(tool2.input) ?? {};
@@ -101440,7 +101584,7 @@ function toolDetail(message, id) {
     // A background task's `result` is only its launch receipt; the run's own
     // output is patched onto the block when the task_notification lands.
     taskResultText: tool2.taskResultText,
-    childBlocks: children,
+    childBlocks: transcriptChildren.length > 0 ? transcriptChildren : children,
     toolDiff: projectedTool?.toolDiff,
     toolDiffTokens: projectedTool?.toolDiffTokens,
     toolLineDelta: projectedTool?.toolLineDelta,
@@ -101716,7 +101860,9 @@ function projectEvent(event, messages) {
     return { ...event, delta: projectTool(event.delta, reference(event.messageId, "tool", event.delta.toolUseId)) };
   }
   if (event.type === "content_delta" && event.delta.type === "tool_result" && message) {
-    const projected = projectProgressiveMessage(message).content.find((block) => block.type === "tool_result" && block.toolUseId === event.delta.toolUseId);
+    const toolUseId = event.delta.toolUseId;
+    const revealed = revealTodoResults(message);
+    const projected = projectProgressiveMessage(revealed).content.find((block) => (block.type === "tool_result" || block.type === "todo_result") && block.toolUseId === toolUseId);
     if (projected) return { ...event, delta: projected };
   }
   if ("metadata" in event && event.metadata?.codex) {
@@ -101726,6 +101872,9 @@ function projectEvent(event, messages) {
   return event;
 }
 
+// ../../packages/runtime/src/stream/delivery/window-views.ts
+init_codex_content();
+
 // ../../packages/shared/src/transcript-window/content-digest.ts
 function contentDigest(input) {
   let a = 2166136261;
@@ -101856,17 +102005,19 @@ var MessageFragmenter = class {
     const previous = this.memo.get(message.id);
     const next = /* @__PURE__ */ new Map();
     const fragments = (message.attachments ?? []).map((attachment, index) => attachmentEntry(index, attachment));
+    const blocks = fragments.map(() => -1);
     const keys = blockKeys(content);
     content.forEach((block, index) => {
       const key = keys[index];
       const memo = blockFragments(block, key, previous?.get(key));
       next.set(key, memo);
       fragments.push(...memo.entries);
+      for (let i = 0; i < memo.entries.length; i++) blocks.push(index);
     });
     this.memo.set(message.id, next);
     const meta3 = windowMeta(message);
     const metaJson = JSON.stringify(meta3);
-    return { id: message.id, meta: meta3, metaDigest: contentDigest(metaJson), metaBytes: utf8Length(metaJson), fragments };
+    return { id: message.id, meta: meta3, metaDigest: contentDigest(metaJson), metaBytes: utf8Length(metaJson), fragments, blocks };
   }
   forget(messageId) {
     this.memo.delete(messageId);
@@ -101970,6 +102121,77 @@ function fitMeta(meta3) {
   return bare;
 }
 
+// ../../packages/shared/src/transcript-window/folds.ts
+var FOLD_KEY_PREFIX = "fold:";
+var PAGE_BLOCK_CHARS = 120;
+function foldRevision(fragments) {
+  return contentDigest(fragments.map((fragment) => `${fragment.key} ${fragment.digest}`).join("\n"));
+}
+function foldMessageFragments(message, ranges) {
+  const fragments = [];
+  const blocks = [];
+  const folds = /* @__PURE__ */ new Map();
+  let r = 0;
+  for (let i = 0; i < message.fragments.length; ) {
+    const block = message.blocks[i];
+    while (r < ranges.length && ranges[r].end < block) r++;
+    const range = ranges[r];
+    if (!range || block < range.start) {
+      fragments.push(message.fragments[i]);
+      blocks.push(block);
+      i++;
+      continue;
+    }
+    const inner = { entries: [], blocks: [] };
+    for (; i < message.fragments.length && message.blocks[i] <= range.end; i++) {
+      inner.entries.push(message.fragments[i]);
+      inner.blocks.push(message.blocks[i]);
+    }
+    const key = FOLD_KEY_PREFIX + inner.entries[0].key;
+    folds.set(key, inner);
+    fragments.push(entry(key, { kind: "fold", revision: foldRevision(inner.entries), summary: { ...range.summary, fragments: inner.entries.length } }, 0));
+    blocks.push(range.start);
+    r++;
+  }
+  return { ...message, fragments, blocks, folds };
+}
+function selectFoldPage(inner, after, budget) {
+  const start = after === void 0 ? 0 : inner.entries.findIndex((fragment) => fragment.key === after) + 1;
+  if (start <= 0 && after !== void 0) return null;
+  let end = start;
+  let bytes = 0;
+  let chars = 0;
+  const calls2 = /* @__PURE__ */ new Set();
+  for (; end < inner.entries.length; end++) {
+    const fragment = inner.entries[end];
+    if (end > start && (end - start >= budget.maxFragments || bytes + fragment.bytes > budget.maxBytes || chars >= budget.targetChars)) break;
+    bytes += fragment.bytes;
+    chars += PAGE_BLOCK_CHARS;
+    const call2 = callId(fragment);
+    if (call2) calls2.add(call2);
+  }
+  if (end > start && end < inner.entries.length && inner.blocks[end] === inner.blocks[end - 1]) {
+    const block = inner.blocks[end - 1];
+    let first = end - 1;
+    while (first > start && inner.blocks[first - 1] === block) first--;
+    if (first > start) end = first;
+    else while (end < inner.entries.length && inner.blocks[end] === block) end++;
+  }
+  for (; end < inner.entries.length; end++) {
+    const result3 = resultOf(inner.entries[end]);
+    if (!result3 || !calls2.has(result3)) break;
+  }
+  return { start, end };
+}
+function callId(fragment) {
+  const block = fragment.body.kind === "block" ? fragment.body.block : void 0;
+  return block && "toolName" in block ? block.toolUseId : void 0;
+}
+function resultOf(fragment) {
+  const block = fragment.body.kind === "block" ? fragment.body.block : void 0;
+  return block && !("toolName" in block) && "toolUseId" in block ? block.toolUseId : void 0;
+}
+
 // ../../packages/shared/src/transcript-window/select-window.ts
 var DEFAULT_WINDOW_BUDGET = { maxBytes: 128 * 1024, maxFragments: 48, targetChars: 6e3 };
 var MIN_WINDOW_BYTES = MAX_FRAGMENT_BYTES + MAX_META_BYTES + 1024;
@@ -102083,9 +102305,1314 @@ function clamp(value, min, max) {
   return Number.isFinite(value) ? Math.min(max, Math.max(min, Math.floor(value))) : min;
 }
 
+// ../../packages/chat-core/src/turn-process/process-folds.ts
+init_content_delta();
+init_codex_content();
+init_transcript_window();
+init_transcript_boundary();
+
+// ../../packages/shared/src/transcript-segments.ts
+init_transcript_boundary();
+init_content_delta();
+init_codex_async_question();
+init_codex_content();
+var cachedSegments = /* @__PURE__ */ new WeakMap();
+function sliceBlock(block, from, to2) {
+  if (from === 0 && to2 === blockText(block)?.length) return block;
+  if (block.type === "text") return to2 > from ? { ...block, text: block.text.slice(from, to2) } : null;
+  if (block.type === "thinking") return to2 > from || "remoteDetail" in block && block.remoteDetail ? { ...block, thinking: block.thinking.slice(from, to2) } : null;
+  return block;
+}
+function sliceItem(item, from, to2) {
+  if (from === 0 && to2 === itemText(item)?.length) return item;
+  if (!("text" in item)) return item;
+  if (to2 <= from && !(item.type === "agent_message" && item.questions?.length) && !(item.type === "reasoning" && item.remoteDetail)) return null;
+  return { ...item, text: item.text.slice(from, to2) };
+}
+function contentGroups(content) {
+  const groups = [[]];
+  const owners = /* @__PURE__ */ new Map();
+  for (const block of content) {
+    const parent = "parentToolUseId" in block ? block.parentToolUseId : null;
+    const owner = parent ? owners.get(parent) : isToolResultBlock(block) ? owners.get(block.toolUseId) : void 0;
+    if (owner) {
+      owner.push(block);
+      if (isToolUseBlock(block)) owners.set(block.toolUseId, owner);
+      continue;
+    }
+    if (block.type === "text" && !parent && groups.at(-1).length) groups.push([]);
+    const group = groups.at(-1);
+    group.push(block);
+    if (isToolUseBlock(block)) owners.set(block.toolUseId, group);
+  }
+  return groups;
+}
+function itemGroups(items) {
+  const groups = [[]];
+  for (const item of items) {
+    if (item.type === "agent_message" && item.delivery !== "async" && groups.at(-1).length) groups.push([]);
+    groups.at(-1).push(item);
+  }
+  return groups;
+}
+function interval(source, previous, next) {
+  const keys = contentKeys(source.content);
+  const parents = new Map(source.content.flatMap((block) => isToolUseBlock(block) && "parentToolUseId" in block && block.parentToolUseId ? [[block.toolUseId, block.parentToolUseId]] : []));
+  const rootOwner = (id) => {
+    const seen = /* @__PURE__ */ new Set();
+    while (parents.has(id) && !seen.has(id)) {
+      seen.add(id);
+      id = parents.get(id);
+    }
+    return `tool:${id}`;
+  };
+  const content = source.content.flatMap((block, index) => {
+    const key = keys[index];
+    const ownerKey = "parentToolUseId" in block && block.parentToolUseId ? rootOwner(block.parentToolUseId) : isToolResultBlock(block) ? rootOwner(block.toolUseId) : key;
+    const start = previous?.content[ownerKey];
+    const end = next?.content[ownerKey];
+    const text2 = blockText(block);
+    if (ownerKey !== key) return start !== void 0 || next && end === void 0 ? [] : [block];
+    if (text2 === void 0) return start !== void 0 || next && end === void 0 ? [] : [block];
+    if (next && end === void 0) return [];
+    if (start === -1) return [];
+    if (start !== void 0 && text2.length <= start) return [];
+    const value = sliceBlock(block, Math.max(0, start ?? 0), Math.min(text2.length, end ?? text2.length));
+    return value ? [value] : [];
+  });
+  const items = (source.metadata?.codex?.items ?? []).flatMap((item) => {
+    const start = previous?.items[item.id];
+    const end = next?.items[item.id];
+    const text2 = itemText(item);
+    if (text2 === void 0) return start !== void 0 || next && end === void 0 ? [] : [item];
+    if (next && end === void 0) return [];
+    if (start === -1) return [];
+    if (start !== void 0 && text2.length <= start) return [];
+    const value = sliceItem(item, Math.max(0, start ?? 0), Math.min(text2.length, end ?? text2.length));
+    return value ? [value] : [];
+  });
+  return { content, items };
+}
+function transcriptSegments(messages) {
+  return transcriptView(messages).segments;
+}
+function transcriptView(messages) {
+  const displayed = messages.filter((message) => !isDismissedCodexAsyncAnswer(message, messages));
+  const sources = new Set(displayed.map((message) => message.id));
+  const boundaries = /* @__PURE__ */ new Map();
+  const consumed = /* @__PURE__ */ new Set();
+  for (const message of displayed) {
+    const cursor = message.metadata?.transcriptBoundary;
+    if (!cursor || !sources.has(cursor.messageId) || cursor.messageId === message.id) continue;
+    const cutRows = boundaries.get(cursor.messageId) ?? [];
+    cutRows.push(message);
+    boundaries.set(cursor.messageId, cutRows);
+    consumed.add(message.id);
+  }
+  const result3 = [];
+  const rows = [];
+  for (const source of displayed) {
+    if (consumed.has(source.id)) continue;
+    if (source.role !== "assistant" || source.providerId === "system") {
+      const cursor = source.metadata?.transcriptBoundary;
+      result3.push({
+        id: source.id,
+        message: source,
+        source,
+        final: true,
+        anchorId: cursor?.messageId ?? source.id,
+        offset: cursor?.order ?? 0
+      });
+      rows.push({ id: source.id, message: source, source, final: true });
+      continue;
+    }
+    const cuts = (boundaries.get(source.id) ?? []).sort((a, b3) => a.metadata.transcriptBoundary.order - b3.metadata.transcriptBoundary.order);
+    const cached5 = cachedSegments.get(source);
+    if (cached5 && cached5.cuts.length === cuts.length && cached5.cuts.every((cut, index) => cut === cuts[index])) {
+      result3.push(...cached5.segments);
+      rows.push(...cached5.rows);
+      continue;
+    }
+    const cursors = cuts.length ? resolveTranscriptBoundaries(cuts, transcriptLengths(source)) : [];
+    const legacy = isLegacyCodexMessage(source);
+    const segmentOf = (message) => legacy ? withCodexContent(message) : message;
+    const finalResponse = (content) => content.filter((block) => block.type === "text" && block.id === void 0);
+    const sliceOf = (content, items) => segmentOf({
+      ...source,
+      status: "complete",
+      content,
+      metadata: { ...source.metadata, ...legacy ? { codex: { ...source.metadata.codex, items, finalResponse: void 0 } } : {} }
+    });
+    const keys = contentKeys(source.content);
+    const keyByBlock = new Map(source.content.map((block, index) => [block, keys[index]]));
+    const firstResult = result3.length;
+    const firstRow = rows.length;
+    let previous;
+    let firstTurnRow = true;
+    for (let part = 0; part <= cuts.length; part++) {
+      const next = cuts[part];
+      const slice = interval(source, cursors[part - 1], cursors[part]);
+      const groups = legacy ? itemGroups(slice.items).map((items, index, all) => ({
+        items,
+        content: index === all.length - 1 ? finalResponse(slice.content) : []
+      })) : contentGroups(slice.content).map((content) => ({ content, items: [] }));
+      const partSegments = [];
+      for (let group = 0; group < groups.length; group++) {
+        const value = groups[group];
+        if (!value.content.length && !value.items.length && next) continue;
+        const key = value.items[0]?.id ?? keyByBlock.get(value.content[0]) ?? `part-${part}`;
+        const id = result3.length === firstResult ? source.id : previous && group === 0 ? `${source.id}:after:${previous.id}` : `${source.id}:segment:${key}`;
+        const anchorId = source.id;
+        const offset = (previous ? previous.metadata.transcriptBoundary.order + 0.1 : 0) + group / (groups.length + 1) * 0.5;
+        const segment = { id, source, final: false, anchorId, offset, message: sliceOf(value.content, value.items) };
+        result3.push(segment);
+        partSegments.push({ segment, opens: { block: value.content[0], itemId: value.items[0]?.id } });
+      }
+      if (partSegments.length) {
+        const [first, ...rest] = partSegments;
+        const message = rest.length ? sliceOf(legacy ? finalResponse(slice.content) : slice.content, slice.items) : first.segment.message;
+        const anchors = /* @__PURE__ */ new Map();
+        for (const { segment, opens } of rest) {
+          const block = legacy ? message.content.find((candidate) => "id" in candidate && candidate.id === opens.itemId) : opens.block;
+          if (block) anchors.set(block, segment.id);
+        }
+        const following = next ? interval(source, cursors[part]) : void 0;
+        rows.push({
+          id: first.segment.id,
+          message,
+          source,
+          final: false,
+          first: firstTurnRow,
+          ...anchors.size ? { anchors } : {},
+          ...following ? { following: sliceOf(following.content, following.items) } : {}
+        });
+        firstTurnRow = false;
+      }
+      if (next) {
+        result3.push({
+          id: next.id,
+          message: next,
+          source: next,
+          final: true,
+          anchorId: source.id,
+          offset: next.metadata.transcriptBoundary.order
+        });
+        rows.push({ id: next.id, message: next, source: next, final: true });
+      }
+      previous = next;
+    }
+    const last = result3.findLast((segment) => segment.source === source);
+    const lastRow = rows.findLast((row2) => row2.source === source);
+    if (last) {
+      const shared = lastRow?.message === last.message;
+      last.final = true;
+      last.message = segmentOf({ ...last.message, status: source.status });
+      if (shared) lastRow.message = last.message;
+    }
+    if (lastRow) {
+      lastRow.final = true;
+      if (lastRow.message.status !== source.status) lastRow.message = segmentOf({ ...lastRow.message, status: source.status });
+    }
+    cachedSegments.set(source, { cuts, segments: result3.slice(firstResult), rows: rows.slice(firstRow) });
+  }
+  return { segments: result3, rows };
+}
+
+// ../../packages/chat-core/src/turn-process/compact-mode.ts
+init_suggested_task();
+function isPinnedToolName(toolName, ports2) {
+  return ports2.isWidgetShowTool(toolName) || toolName === "AskUserQuestion" || toolName.endsWith("__AskUserQuestion") || isSuggestTaskTool(toolName);
+}
+var MIN_PROCESS_SEGMENTS_TO_COLLAPSE = 3;
+function compactTurnRuns(items, isPinned, neighbors) {
+  if (!neighbors) return partitionTurnForCompactMode(items, isPinned);
+  return partitionTurnForCompactMode(
+    items,
+    isPinned,
+    neighbors.following?.some(isPinned) ?? false,
+    neighbors.source?.some(isPinned) ?? false
+  );
+}
+function partitionTurnForCompactMode(items, isPinned, hasFollowingPinned = false, hasPrecedingPinned = false) {
+  if (items.length === 0) return [];
+  let lastPinned = -1;
+  for (let i = items.length - 1; i >= 0; i--) {
+    if (isPinned(items[i])) {
+      lastPinned = i;
+      break;
+    }
+  }
+  if (lastPinned < 0) return [{ collapsible: hasFollowingPinned || !hasPrecedingPinned, start: 0, items: items.slice() }];
+  const runs = [];
+  for (let i = 0; i < items.length; i++) {
+    const collapsible = (hasFollowingPinned || i < lastPinned) && !isPinned(items[i]);
+    const last = runs[runs.length - 1];
+    if (last && last.collapsible === collapsible) last.items.push(items[i]);
+    else runs.push({ collapsible, start: i, items: [items[i]] });
+  }
+  return runs;
+}
+function collapsibleItems(runs) {
+  return runs.flatMap((run) => run.collapsible ? run.items : []);
+}
+function isClaudePinnedSegment(seg, ports2) {
+  if (seg.kind === "subagent" || seg.kind === "workflow") return true;
+  if (seg.kind !== "block" || !seg.block) return false;
+  if (seg.block.type === "text" || seg.block.type === "insight" || seg.block.type === "plan") return true;
+  return seg.block.type === "tool_use" && (Boolean(seg.block.app) || isPinnedToolName(seg.block.toolName ?? "", ports2));
+}
+function isVisibleClaudeProcessSegment(seg, opts) {
+  const { toolResultAt, isHiddenTool } = opts;
+  if (seg.kind === "thinking" || seg.kind === "subagent" || seg.kind === "workflow") {
+    return true;
+  }
+  if (seg.kind === "tools" || seg.kind === "app-tools") {
+    return (seg.blocks ?? []).some(
+      (b3) => b3.type === "tool_use" && !isHiddenTool(b3.toolName ?? "", toolResultAt(b3.toolUseId ?? ""))
+    );
+  }
+  if (seg.kind === "block" && seg.block) {
+    const b3 = seg.block;
+    if (b3.type === "tool_result") return false;
+    if (b3.type === "tool_use") {
+      return !isHiddenTool(b3.toolName ?? "", toolResultAt(b3.toolUseId ?? ""));
+    }
+    return true;
+  }
+  return true;
+}
+function countVisibleClaudeProcessSegments(segs, opts) {
+  let n = 0;
+  for (const seg of segs) {
+    if (seg.kind === "block" && seg.block?.fold) n += seg.block.fold.segments;
+    else if (isVisibleClaudeProcessSegment(seg, opts)) n += 1;
+  }
+  return n;
+}
+
+// ../../packages/chat-core/src/turn-process/group-content.ts
+init_content_delta();
+init_jev_run_result_shape();
+init_codex_command_actions();
+var COLLAPSIBLE_TOOLS = /* @__PURE__ */ new Set(["Read", "Glob", "Grep", "WebSearch", "WebFetch"]);
+function runIdIn(text2) {
+  const match = text2 ? /"runId"\s*:\s*"([^"]+)"/.exec(text2) : null;
+  return match?.[1] ?? null;
+}
+function groupContentPresenter(content, ports2) {
+  const toolNameMap = /* @__PURE__ */ new Map();
+  const toolResultMap = /* @__PURE__ */ new Map();
+  const timedOutToolIds = /* @__PURE__ */ new Set();
+  const errorToolIds = /* @__PURE__ */ new Set();
+  const outputPathMap = /* @__PURE__ */ new Map();
+  const bashEditDiffMap = /* @__PURE__ */ new Map();
+  const exitCodeMap = /* @__PURE__ */ new Map();
+  const resultTitleMap = /* @__PURE__ */ new Map();
+  const toolAppMap = /* @__PURE__ */ new Map();
+  const taskToolUseIds = /* @__PURE__ */ new Set();
+  const collapsibleIds = /* @__PURE__ */ new Set();
+  for (const block of content) {
+    if (block.type === "tool_use") {
+      toolNameMap.set(block.toolUseId, block.toolName);
+      if (ports2.isSubagentToolName(block.toolName)) taskToolUseIds.add(block.toolUseId);
+      if (COLLAPSIBLE_TOOLS.has(block.toolName) || block.toolName === "Bash" && isReadOnlyParsedCommand(block.toolUseId, block.input)) {
+        collapsibleIds.add(block.toolUseId);
+      }
+    } else if (isToolResultBlock(block)) {
+      if (block.summary) toolResultMap.set(block.toolUseId, block.summary);
+      if ("isTimedOut" in block && block.isTimedOut) timedOutToolIds.add(block.toolUseId);
+      if ("isError" in block && block.isError) errorToolIds.add(block.toolUseId);
+      if ("outputPath" in block && block.outputPath) outputPathMap.set(block.toolUseId, block.outputPath);
+      if ("bashEditDiff" in block && block.bashEditDiff) bashEditDiffMap.set(block.toolUseId, block.bashEditDiff);
+      if ("exitCode" in block && block.exitCode !== void 0) exitCodeMap.set(block.toolUseId, block.exitCode);
+      if ("resultTitle" in block && block.resultTitle) resultTitleMap.set(block.toolUseId, block.resultTitle);
+      if ("app" in block && block.app) toolAppMap.set(block.toolUseId, block.app);
+    }
+  }
+  const appToolIdToAppId = /* @__PURE__ */ new Map();
+  for (const block of content) {
+    if (block.type !== "tool_use") continue;
+    const resolved = ports2.resolveAppTool(block.toolName, block.input);
+    if (!resolved || resolved.standalone || !resolved.groupable) continue;
+    appToolIdToAppId.set(block.toolUseId, resolved.appId);
+  }
+  const runOwnerByRunId = /* @__PURE__ */ new Map();
+  const runContinuationOwner = /* @__PURE__ */ new Map();
+  const runContinuations = /* @__PURE__ */ new Map();
+  for (const block of content) {
+    if (block.type !== "tool_use" || !isJevRunToolName(block.toolName)) continue;
+    const resumes = runIdIn(block.input);
+    const owner = resumes ? runOwnerByRunId.get(resumes) : void 0;
+    if (owner) {
+      runContinuationOwner.set(block.toolUseId, owner);
+      runContinuations.set(owner, [...runContinuations.get(owner) ?? [], block]);
+      continue;
+    }
+    const started = runIdIn(toolResultMap.get(block.toolUseId));
+    if (started && !runOwnerByRunId.has(started)) runOwnerByRunId.set(started, block.toolUseId);
+  }
+  const segments = [];
+  let group = [];
+  let groupStart = 0;
+  let appGroup = [];
+  let appGroupId = null;
+  let appGroupStart = 0;
+  const activeSubagents = /* @__PURE__ */ new Map();
+  const activeWorkflows = /* @__PURE__ */ new Map();
+  const agentToParent = /* @__PURE__ */ new Map();
+  const topAncestorSubagent = (parentId) => {
+    let current = parentId;
+    const seen = /* @__PURE__ */ new Set();
+    while (current && agentToParent.has(current) && !seen.has(current)) {
+      seen.add(current);
+      const parent = agentToParent.get(current) ?? null;
+      if (parent == null) break;
+      current = parent;
+    }
+    return current && activeSubagents.has(current) ? current : null;
+  };
+  const flush = () => {
+    if (group.length === 0) return;
+    segments.push({ kind: "tools", blocks: group, startIndex: groupStart });
+    group = [];
+  };
+  const flushAppGroup = () => {
+    if (appGroup.length === 0) return;
+    segments.push({
+      kind: "app-tools",
+      appId: appGroupId,
+      blocks: appGroup,
+      startIndex: appGroupStart
+    });
+    appGroup = [];
+    appGroupId = null;
+  };
+  for (let index = 0; index < content.length; index++) {
+    const block = content[index];
+    const parentId = "parentToolUseId" in block ? block.parentToolUseId ?? null : null;
+    if (parentId) {
+      if (block.type === "tool_use" && ports2.isSubagentToolName(block.toolName)) {
+        agentToParent.set(block.toolUseId, parentId);
+      }
+      const top = topAncestorSubagent(parentId);
+      if (top) {
+        activeSubagents.get(top).childBlocks.push(block);
+        continue;
+      }
+    }
+    if (isToolResultBlock(block) && taskToolUseIds.has(block.toolUseId) && activeSubagents.has(block.toolUseId)) {
+      activeSubagents.get(block.toolUseId).resultBlock = block;
+      continue;
+    }
+    if (block.type === "tool_use" && ports2.isSubagentToolName(block.toolName)) {
+      flush();
+      flushAppGroup();
+      const segment = {
+        kind: "subagent",
+        taskBlock: block,
+        childBlocks: [],
+        startIndex: index
+      };
+      segments.push(segment);
+      activeSubagents.set(block.toolUseId, segment);
+      agentToParent.set(block.toolUseId, null);
+      continue;
+    }
+    if (isToolResultBlock(block) && activeWorkflows.has(block.toolUseId)) {
+      activeWorkflows.get(block.toolUseId).resultBlock = block;
+      activeWorkflows.delete(block.toolUseId);
+      continue;
+    }
+    if ((block.type === "tool_use" || isToolResultBlock(block)) && runContinuationOwner.has(block.toolUseId)) continue;
+    if (block.type === "tool_use" && block.toolName === "Workflow" && !ports2.isWorkflowSmokeCheck(block.input)) {
+      flush();
+      flushAppGroup();
+      const segment = {
+        kind: "workflow",
+        toolBlock: block,
+        startIndex: index
+      };
+      segments.push(segment);
+      activeWorkflows.set(block.toolUseId, segment);
+      continue;
+    }
+    if (block.type === "tool_use" && appToolIdToAppId.has(block.toolUseId)) {
+      flush();
+      const blockAppId = appToolIdToAppId.get(block.toolUseId);
+      if (appGroupId !== blockAppId) {
+        flushAppGroup();
+        appGroupId = blockAppId;
+        appGroupStart = index;
+      }
+      appGroup.push(block);
+      continue;
+    }
+    if (isToolResultBlock(block) && appToolIdToAppId.has(block.toolUseId)) {
+      appGroup.push(block);
+      continue;
+    }
+    if (isToolResultBlock(block) && toolNameMap.has(block.toolUseId)) continue;
+    flushAppGroup();
+    if (block.type === "tool_use" && collapsibleIds.has(block.toolUseId)) {
+      if (group.length === 0) groupStart = index;
+      group.push(block);
+    } else if (block.type === "tool_use" && ports2.isHiddenToolBlock(block.toolName, toolResultMap.get(block.toolUseId))) {
+      flush();
+    } else if (block.type === "thinking") {
+      flush();
+      const last = segments[segments.length - 1];
+      if (last?.kind === "thinking") last.blocks.push(block);
+      else segments.push({ kind: "thinking", blocks: [block], startIndex: index });
+    } else {
+      flush();
+      segments.push({ kind: "block", block, index });
+    }
+  }
+  flush();
+  flushAppGroup();
+  return {
+    segments,
+    toolNameMap,
+    toolResultMap,
+    timedOutToolIds,
+    errorToolIds,
+    outputPathMap,
+    bashEditDiffMap,
+    exitCodeMap,
+    resultTitleMap,
+    toolAppMap,
+    runContinuations
+  };
+}
+
+// ../../packages/chat-core/src/turn-process/media-tools.ts
+init_codex_content();
+
+// ../../packages/shared/src/generative-ui/native-widgets.ts
+var NATIVE_TEMPLATE_PREFIX = "@native/";
+var NATIVE_WIDGET_TYPES = ["image-gallery", "video-gallery", "files-previewer"];
+function isNativeTemplateId(template) {
+  return template.startsWith(NATIVE_TEMPLATE_PREFIX);
+}
+function nativeTypeFromTemplateId(template) {
+  if (!isNativeTemplateId(template)) return null;
+  const suffix = template.slice(NATIVE_TEMPLATE_PREFIX.length);
+  return NATIVE_WIDGET_TYPES.includes(suffix) ? suffix : null;
+}
+function renderableItems(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => {
+    if (!item || typeof item !== "object") return false;
+    const path = item.savedPath;
+    return typeof path === "string" && path.trim().length > 0;
+  });
+}
+function parseNativeWidgetResult(resultText) {
+  if (!resultText) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(resultText);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const record13 = parsed;
+  if (record13.kind !== "native") return null;
+  const nativeType = typeof record13.nativeType === "string" ? nativeTypeFromTemplateId(NATIVE_TEMPLATE_PREFIX + record13.nativeType) : null;
+  if (!nativeType) return null;
+  const title2 = typeof record13.title === "string" ? record13.title : "";
+  if (nativeType === "image-gallery") {
+    const images = renderableItems(record13.images);
+    return images.length > 0 ? { kind: "native", nativeType, title: title2, images } : null;
+  }
+  if (nativeType === "files-previewer") {
+    if (record13.images !== void 0 || record13.videos !== void 0) return null;
+    const files = previewerFiles(record13.files);
+    const root = typeof record13.root === "string" ? record13.root : "";
+    return files.length > 0 && root ? { kind: "native", nativeType, title: title2, root, files } : null;
+  }
+  const videos = renderableItems(record13.videos);
+  return videos.length > 0 ? { kind: "native", nativeType, title: title2, videos } : null;
+}
+var PREVIEWER_KINDS = /* @__PURE__ */ new Set([
+  "image",
+  "pdf",
+  "video",
+  "audio",
+  "model",
+  "markdown",
+  "notebook",
+  "text",
+  "unpreviewable",
+  "missing"
+]);
+function previewerFiles(value) {
+  if (!Array.isArray(value)) return [];
+  const files = [];
+  for (const item of value) {
+    if (!item || typeof item !== "object") continue;
+    const r = item;
+    if (typeof r.path !== "string" || typeof r.absolutePath !== "string" || typeof r.name !== "string") continue;
+    if (typeof r.kind !== "string" || !PREVIEWER_KINDS.has(r.kind)) continue;
+    files.push({
+      path: r.path,
+      absolutePath: r.absolutePath,
+      name: r.name,
+      kind: r.kind,
+      ...typeof r.size === "number" && Number.isFinite(r.size) ? { size: r.size } : {},
+      ...typeof r.reason === "string" ? { reason: r.reason } : {},
+      ...typeof r.note === "string" && r.note ? { note: r.note } : {}
+    });
+  }
+  return files;
+}
+
+// ../../packages/chat-core/src/turn-process/media-tools.ts
+init_tool_ui();
+init_media_predicates();
+var MEDIA_GENERATE_IMAGE_TOOL = "mcp__superone__media_generate_image";
+var WIDGET_SHOW_TOOL = "mcp__superone__widget_show";
+var GROK_IMAGE_GEN_TOOLS = /* @__PURE__ */ new Set(["ImageGen", "ImageEdit", "image_gen", "image_edit"]);
+var GROK_VIDEO_GEN_TOOLS = /* @__PURE__ */ new Set([
+  "ImageToVideo",
+  "ReferenceToVideo",
+  "image_to_video",
+  "reference_to_video"
+]);
+var GROK_MEDIA_OUTPUT_TYPES = /* @__PURE__ */ new Set(["ImageGen", "ImageEdit", "ImageToVideo", "ReferenceToVideo"]);
+function isMediaGenerateImageTool(toolName) {
+  return toolName === MEDIA_GENERATE_IMAGE_TOOL || GROK_IMAGE_GEN_TOOLS.has(toolName);
+}
+function isGrokVideoGenTool(toolName) {
+  return GROK_VIDEO_GEN_TOOLS.has(toolName);
+}
+function isWidgetShowTool(toolName) {
+  return toolName === WIDGET_SHOW_TOOL;
+}
+function nativeWidgetImages(resultText) {
+  return parseNativeWidgetResult(resultText)?.images ?? [];
+}
+function nativeWidgetVideos(resultText) {
+  return parseNativeWidgetResult(resultText)?.videos ?? [];
+}
+function coerceGenerationResult(parsed) {
+  const saved = toSavedPaths(parsed);
+  if (saved.length > 0) {
+    return {
+      ...parsed,
+      status: parsed.status === "error" ? "error" : parsed.status ?? "generated",
+      savedPaths: saved
+    };
+  }
+  const path = typeof parsed.path === "string" ? parsed.path.trim() : "";
+  if (path) {
+    const type = typeof parsed.type === "string" ? parsed.type : void 0;
+    if (type && !GROK_MEDIA_OUTPUT_TYPES.has(type)) {
+      if (!/\.(png|jpe?g|gif|webp|bmp|mp4|webm|mov)$/i.test(path) && !path.includes("/images/")) {
+        return parsed;
+      }
+    }
+    return {
+      status: "generated",
+      savedPaths: [path],
+      provider: parsed.provider ?? "grok",
+      model: parsed.model,
+      warnings: parsed.warnings,
+      generationId: parsed.generationId
+    };
+  }
+  return parsed;
+}
+function parseGenerationResult(resultText) {
+  if (!resultText) return null;
+  try {
+    const parsed = JSON.parse(resultText);
+    if (!parsed || typeof parsed !== "object") return null;
+    return coerceGenerationResult(parsed);
+  } catch {
+    return null;
+  }
+}
+function toSavedPaths(parsed) {
+  return Array.isArray(parsed.savedPaths) ? parsed.savedPaths.filter((p3) => typeof p3 === "string") : [];
+}
+function isSuccessfulGenerationResult(resultText) {
+  const parsed = parseGenerationResult(resultText);
+  if (!parsed || parsed.status === "error") return false;
+  return toSavedPaths(parsed).length > 0;
+}
+function isVideoStatusStillRunning(resultText) {
+  return parseGenerationResult(resultText)?.status === "running";
+}
+function isHiddenToolBlock(toolName, result3) {
+  if (isAlwaysHiddenToolName(toolName)) return true;
+  if (toolName === CODEX_AGENT_WAIT_TOOL) return result3 !== void 0;
+  if (isWidgetShowTool(toolName)) return nativeWidgetImages(result3).length > 0 || nativeWidgetVideos(result3).length > 0;
+  if (isMediaGenerateImageTool(toolName)) return !result3 || isSuccessfulGenerationResult(result3);
+  if (isGrokVideoGenTool(toolName)) return !result3 || isSuccessfulGenerationResult(result3);
+  if (isMediaVideoStatusTool(toolName)) {
+    return !result3 || isVideoStatusStillRunning(result3) || isSuccessfulGenerationResult(result3);
+  }
+  return false;
+}
+function isTurnGallerySourceTool(toolName) {
+  return toolName === CODEX_IMAGE_GENERATION_TOOL || isWidgetShowTool(toolName) || isMediaGenerateImageTool(toolName) || isMediaGenerateVideoTool(toolName) || isMediaVideoStatusTool(toolName) || isGrokVideoGenTool(toolName);
+}
+
+// ../../packages/chat-core/src/turn-process/portable.ts
+init_tool_ui();
+function isOffTranscript(block, failed2) {
+  if (block.type === "text") return Boolean(block.codexAsyncQuestions?.length);
+  return failed2 && block.type === "notice" && block.level === "error";
+}
+function isOffTranscriptBlock(block, message) {
+  return isOffTranscript(block, message.status === "error");
+}
+function turnDisplayContent(message) {
+  const failed2 = message.status === "error";
+  return message.content.some((block) => isOffTranscript(block, failed2)) ? message.content.filter((block) => !isOffTranscript(block, failed2)) : message.content;
+}
+function portableToolBlock(block) {
+  return "toolName" in block && block.type !== "tool_use" ? { ...block, type: "tool_use" } : block;
+}
+function portableToolBlocks(content) {
+  return content.map(portableToolBlock);
+}
+function parseRecord(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function isWorkflowSmokeCheck(input) {
+  const parsed = parseRecord(input);
+  return parsed.validate_only === true || parsed.validateOnly === true || /"(?:validate_only|validateOnly)"\s*:\s*true/.test(input);
+}
+function isPortableWidgetShowTool(toolName) {
+  return toolName === "widget_show" || toolName.endsWith("__widget_show");
+}
+var PORTABLE_GROUP_PORTS = {
+  isSubagentToolName,
+  isWorkflowSmokeCheck,
+  isHiddenToolBlock,
+  resolveAppTool: () => null
+};
+function isPortablePinnedSegment(segment) {
+  return isClaudePinnedSegment(segment, { isWidgetShowTool: isPortableWidgetShowTool });
+}
+
+// ../../packages/chat-core/src/turn-process/process-stats.ts
+init_tool_ui();
+
+// ../../node_modules/diff/libesm/diff/base.js
+var Diff2 = class {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a3;
+    const done = (value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return void 0;
+      } else {
+        return value;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a3 = options.timeout) !== null && _a3 !== void 0 ? _a3 : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = void 0;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    };
+    if (callback) {
+      (function exec2() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(void 0);
+          }
+          if (!execEditLength()) {
+            exec2();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path, added, removed, oldPosInc, options) {
+    const last = path.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array2) {
+    const ret = [];
+    for (let i = 0; i < array2.length; i++) {
+      if (array2[i]) {
+        ret.push(array2[i]);
+      }
+    }
+    return ret;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  castInput(value, options) {
+    return value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            const oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+};
+
+// ../../node_modules/diff/libesm/diff/line.js
+var LineDiff2 = class extends Diff2 {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize2;
+  }
+  equals(left, right, options) {
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes("\n")) {
+        left = left.trim();
+      }
+      if (!options.newlineIsToken || !right.includes("\n")) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith("\n")) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith("\n")) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options);
+  }
+};
+var lineDiff2 = new LineDiff2();
+function diffLines2(oldStr, newStr, options) {
+  return lineDiff2.diff(oldStr, newStr, options);
+}
+function tokenize2(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, "\n");
+  }
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (i % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
+}
+
+// ../../packages/chat-core/src/turn-process/line-delta.ts
+function splitContentLines(text2) {
+  if (!text2) return [];
+  return text2.replace(/\r\n/g, "\n").replace(/\n$/, "").split("\n");
+}
+function countContentLines(text2) {
+  return splitContentLines(text2).length;
+}
+function ensureTrailingNewline(s4) {
+  if (!s4) return s4;
+  return s4.endsWith("\n") ? s4 : s4 + "\n";
+}
+function countEditDelta2(oldStr, newStr) {
+  let added = 0;
+  let removed = 0;
+  for (const change of diffLines2(ensureTrailingNewline(oldStr), ensureTrailingNewline(newStr))) {
+    if (change.added) added += change.count ?? 0;
+    else if (change.removed) removed += change.count ?? 0;
+  }
+  return { added, removed };
+}
+function countUnifiedDiffDelta(diff) {
+  if (!diff) return null;
+  const lines2 = diff.replace(/\r\n/g, "\n").split("\n");
+  let inHunk = false;
+  let added = 0;
+  let removed = 0;
+  for (const line of lines2) {
+    if (line.startsWith("@@")) {
+      inHunk = true;
+      continue;
+    }
+    if (!inHunk || line.startsWith("\\")) continue;
+    if (line.startsWith("+")) added++;
+    else if (line.startsWith("-")) removed++;
+  }
+  return added > 0 || removed > 0 ? { added, removed } : null;
+}
+function countPrefixedDiffDelta(diff) {
+  if (!diff) return null;
+  const lines2 = diff.replace(/\r\n/g, "\n").split("\n");
+  let added = 0;
+  let removed = 0;
+  for (const line of lines2) {
+    if (line.startsWith("+") && !line.startsWith("+++")) added++;
+    else if (line.startsWith("-") && !line.startsWith("---")) removed++;
+  }
+  return added > 0 || removed > 0 ? { added, removed } : null;
+}
+function countParamsDiffDelta(params) {
+  const diff = String(params.diff ?? params.diffString ?? "");
+  if (diff) {
+    const counted = countUnifiedDiffDelta(diff) ?? countPrefixedDiffDelta(diff);
+    if (counted) return counted;
+  }
+  const added = Number(params.linesAdded);
+  const removed = Number(params.linesRemoved);
+  const hasAdded = Number.isFinite(added) && added > 0;
+  const hasRemoved = Number.isFinite(removed) && removed > 0;
+  if (!hasAdded && !hasRemoved) return null;
+  return { added: hasAdded ? added : 0, removed: hasRemoved ? removed : 0 };
+}
+function computeLineDelta(toolName, params) {
+  if (toolName === "Write") {
+    const content = String(params.content ?? "");
+    if (!content) return null;
+    const added = countContentLines(content);
+    return { added, removed: 0 };
+  }
+  if (toolName === "Edit") {
+    const oldStr = String(params.old_string ?? "");
+    const newStr = String(params.new_string ?? "");
+    if (oldStr || newStr) {
+      const { added, removed } = countEditDelta2(oldStr, newStr);
+      return added > 0 || removed > 0 ? { added, removed } : null;
+    }
+    return countParamsDiffDelta(params);
+  }
+  if (toolName === "Delete") return countParamsDiffDelta(params);
+  if (toolName === "FileChange") {
+    const kind = String(params.kind ?? "");
+    const diff = String(params.diff ?? "");
+    if (!diff) return null;
+    if (kind === "add") return { added: countContentLines(diff), removed: 0 };
+    if (kind === "delete") return { added: 0, removed: countContentLines(diff) };
+    return countUnifiedDiffDelta(diff) ?? countPrefixedDiffDelta(diff);
+  }
+  return null;
+}
+
+// ../../packages/chat-core/src/turn-process/process-stats.ts
+var EMPTY_TURN_PROCESS_STATS = {
+  toolCalls: 0,
+  filesChanged: 0,
+  added: 0,
+  removed: 0
+};
+function parseToolInput(input) {
+  try {
+    const parsed = JSON.parse(input);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function* eachClaudeToolUse(seg) {
+  if (seg.kind === "block" && seg.block?.type === "tool_use") {
+    yield seg.block;
+    return;
+  }
+  if (seg.kind === "tools" || seg.kind === "app-tools") {
+    for (const block of seg.blocks ?? []) {
+      if (block.type === "tool_use") yield block;
+    }
+    return;
+  }
+  if (seg.kind === "subagent" && seg.taskBlock) yield seg.taskBlock;
+  if (seg.kind === "workflow" && seg.toolBlock) yield seg.toolBlock;
+}
+function* eachSubagentEdit(seg) {
+  if (seg.kind !== "subagent") return;
+  if (seg.childBlocks?.length) {
+    for (const block of seg.childBlocks) {
+      if (block.type === "tool_use") yield { block };
+    }
+    return;
+  }
+  for (const change of seg.taskBlock?.taskFileChanges ?? []) yield { change };
+}
+function lineDeltaForMutation(toolName, params) {
+  if (toolName === "NotebookEdit") {
+    return computeLineDelta("Edit", {
+      old_string: String(params.old_source ?? ""),
+      new_string: String(params.new_source ?? "")
+    });
+  }
+  return computeLineDelta(toolName, params);
+}
+function accumulateMutation(stats, files, toolName, rawInput, projected) {
+  if (isPatchToolCall(toolName, rawInput)) {
+    const patchFiles = patchToolFiles(rawInput);
+    for (const file2 of patchFiles) files.add(file2.movePath ?? file2.path);
+    const summary2 = summarizePatchToolFiles(patchFiles);
+    stats.added += summary2.added;
+    stats.removed += summary2.removed;
+    return;
+  }
+  const normalized = normalizeTranscriptTool(toolName, rawInput);
+  if (!isFileMutationTool(normalized.toolName)) return;
+  const path = fileMutationPath(normalized.input) || projected?.path || "";
+  if (path) files.add(path);
+  const delta = lineDeltaForMutation(normalized.toolName, normalized.input) ?? projected?.delta ?? null;
+  if (!delta) return;
+  stats.added += delta.added;
+  stats.removed += delta.removed;
+}
+function summarizeClaudeProcessFiles(segs, opts) {
+  const stats = { ...EMPTY_TURN_PROCESS_STATS };
+  const files = /* @__PURE__ */ new Set();
+  let moreFiles = 0;
+  const failed2 = (toolUseId, result3) => opts.isErrorTool?.(toolUseId) === true || result3?.startsWith("[denied] ") === true;
+  const accumulateChange = (change) => {
+    if (change.path) files.add(change.path);
+    stats.added += change.added;
+    stats.removed += change.removed;
+  };
+  const accumulateBlock = (block) => {
+    const bashEditDiff = block.toolName === "Bash" ? opts.bashEditDiffAt?.(block.toolUseId ?? "") : void 0;
+    if (bashEditDiff) {
+      for (const change of bashEditFileChanges(bashEditDiff)) accumulateChange(change);
+      return;
+    }
+    accumulateMutation(stats, files, block.toolName ?? "", parseToolInput(block.input ?? ""), {
+      path: block.toolFilePath,
+      delta: block.toolLineDelta
+    });
+  };
+  for (const seg of segs) {
+    const fold = seg.kind === "block" ? seg.block?.fold : void 0;
+    if (fold) {
+      stats.toolCalls += fold.toolCalls;
+      stats.added += fold.added;
+      stats.removed += fold.removed;
+      for (const path of fold.files) files.add(path);
+      moreFiles += fold.moreFiles ?? 0;
+      continue;
+    }
+    for (const block of eachClaudeToolUse(seg)) {
+      const toolName = block.toolName ?? "";
+      const toolUseId = block.toolUseId ?? "";
+      const result3 = opts.toolResultAt(toolUseId);
+      if (opts.isHiddenTool(toolName, result3)) continue;
+      stats.toolCalls += 1;
+      if (!failed2(toolUseId, result3)) accumulateBlock(block);
+    }
+    for (const edit of eachSubagentEdit(seg)) {
+      if ("change" in edit) {
+        accumulateChange(edit.change);
+        continue;
+      }
+      const toolUseId = edit.block.toolUseId ?? "";
+      if (!failed2(toolUseId, opts.toolResultAt(toolUseId))) accumulateBlock(edit.block);
+    }
+  }
+  stats.filesChanged = files.size + moreFiles;
+  return { stats, files, moreFiles };
+}
+
+// ../../packages/chat-core/src/turn-process/process-folds.ts
+var MIN_FOLD_BLOCKS = 4;
+var NO_FOLDS = { ranges: [], summarize: () => ({ segments: 0, toolCalls: 0, files: [], added: 0, removed: 0, contentKey: "" }) };
+function planProcessFolds(message, context) {
+  if (message.role !== "assistant" || message.status === "streaming") return NO_FOLDS;
+  const cuts = (context?.cuts ?? []).filter((cut) => cut.metadata?.transcriptBoundary?.messageId === message.id);
+  if (cuts.length > 0 && message.id && !isLegacyCodexMessage(message)) return planSliced(message, cuts);
+  return planContent(message, message.content);
+}
+function planSliced(message, cuts) {
+  const source = {
+    id: message.id,
+    role: "assistant",
+    status: message.status === "error" ? "error" : "complete",
+    createdAt: "",
+    providerId: message.providerId ?? "claude",
+    content: message.content,
+    ...message.metadata ? { metadata: message.metadata } : {}
+  };
+  const grouped = groupTurn(turnDisplayContent(source));
+  const opts = visibility(grouped);
+  if (countVisibleClaudeProcessSegments(collapsibleItems(compactTurnRuns(grouped.segments, isPortablePinnedSegment)), opts) < MIN_PROCESS_SEGMENTS_TO_COLLAPSE) return NO_FOLDS;
+  const indexOf = new Map(message.content.map((block, index) => [block, index]));
+  const foldable = new Array(message.content.length);
+  const anchored = /* @__PURE__ */ new Map();
+  const calls2 = /* @__PURE__ */ new Set();
+  const sliceEnds = /* @__PURE__ */ new Set();
+  for (const row2 of transcriptView([source, ...cuts]).rows) {
+    if (row2.source.id !== source.id) continue;
+    let last = -1;
+    for (const block of row2.message.content) {
+      const index = indexOf.get(block);
+      if (index !== void 0) last = Math.max(last, index);
+    }
+    if (last >= 0) sliceEnds.add(last);
+    const slice = groupTurn(turnDisplayContent(row2.message));
+    const following = row2.following ? groupTurn(turnDisplayContent(row2.following)) : void 0;
+    const runs = compactTurnRuns(slice.segments, isPortablePinnedSegment, { source: grouped.segments, following: following?.segments });
+    markFoldable(runs, (block) => indexOf.get(block), foldable, anchored, calls2);
+  }
+  for (const block of message.content) {
+    const index = indexOf.get(block);
+    if (index !== void 0 && isToolResultBlock(block) && calls2.has(block.toolUseId)) foldable[index] = block;
+  }
+  return finish(message.content, foldable, anchored, visibility(grouped), sliceEnds);
+}
+function planContent(message, content) {
+  const indexes = [];
+  const blocks = [];
+  content.forEach((block, index) => {
+    if (isOffTranscriptBlock(block, message)) return;
+    indexes.push(index);
+    blocks.push(portableToolBlock(block));
+  });
+  const grouped = groupContentPresenter(blocks, PORTABLE_GROUP_PORTS);
+  const opts = visibility(grouped);
+  const runs = compactTurnRuns(grouped.segments, isPortablePinnedSegment);
+  if (countVisibleClaudeProcessSegments(collapsibleItems(runs), opts) < MIN_PROCESS_SEGMENTS_TO_COLLAPSE) return NO_FOLDS;
+  const position2 = new Map(blocks.map((block, index) => [block, index]));
+  const foldable = new Array(content.length);
+  const anchored = /* @__PURE__ */ new Map();
+  const calls2 = /* @__PURE__ */ new Set();
+  markFoldable(runs, (block) => indexes[position2.get(block)], foldable, anchored, calls2);
+  for (const block of blocks) {
+    if (isToolResultBlock(block) && calls2.has(block.toolUseId)) foldable[indexes[position2.get(block)]] = block;
+  }
+  return finish(content, foldable, anchored, opts);
+}
+function groupTurn(content) {
+  return groupContentPresenter(portableToolBlocks(content), PORTABLE_GROUP_PORTS);
+}
+function visibility(grouped) {
+  return {
+    toolResultAt: (id) => grouped.toolResultMap.get(id),
+    isHiddenTool: isHiddenToolBlock,
+    isErrorTool: (id) => grouped.errorToolIds.has(id),
+    bashEditDiffAt: (id) => grouped.bashEditDiffMap.get(id)
+  };
+}
+function markFoldable(runs, contentIndex, foldable, anchored, calls2) {
+  for (const run of runs) {
+    if (!run.collapsible) continue;
+    for (const segment of run.items) {
+      const members = segmentBlocks(segment);
+      const first = members[0] ? contentIndex(members[0]) : void 0;
+      if (first !== void 0) anchored.set(first, segment);
+      for (const block of members) {
+        const index = contentIndex(block);
+        if (index === void 0) continue;
+        if ("toolName" in block && isTurnGallerySourceTool(block.toolName)) continue;
+        foldable[index] = block;
+        if ("toolName" in block) calls2.add(block.toolUseId);
+      }
+    }
+  }
+}
+function finish(content, foldable, anchored, opts, sliceEnds) {
+  const keys = contentKeys(content);
+  const summarize = (start, end) => {
+    let segments = 0;
+    const tools = [];
+    for (let i = start; i <= end; i++) {
+      const segment = anchored.get(i);
+      if (segment && foldable[i] && isVisibleClaudeProcessSegment(segment, opts)) segments++;
+      const block = foldable[i];
+      if (block?.type === "tool_use") tools.push({ kind: "block", block, index: i });
+    }
+    const { stats, files, moreFiles } = summarizeClaudeProcessFiles(tools, opts);
+    const listed = [...files].slice(0, MAX_FOLD_FILES);
+    const more = files.size - listed.length + moreFiles;
+    return {
+      segments,
+      toolCalls: stats.toolCalls,
+      files: listed,
+      ...more ? { moreFiles: more } : {},
+      added: stats.added,
+      removed: stats.removed,
+      ...contentKeySpan(content, keys, start, end)
+    };
+  };
+  const ranges = [];
+  for (let start = 0; start < foldable.length; ) {
+    if (!foldable[start]) {
+      start++;
+      continue;
+    }
+    let end = start;
+    while (end + 1 < foldable.length && foldable[end + 1] && !sliceEnds?.has(end)) end++;
+    if (end - start + 1 >= MIN_FOLD_BLOCKS) ranges.push({ start, end, summary: summarize(start, end) });
+    start = end + 1;
+  }
+  return ranges.length ? { ranges, summarize } : NO_FOLDS;
+}
+function segmentBlocks(segment) {
+  switch (segment.kind) {
+    case "block":
+      return [segment.block];
+    case "subagent":
+      return [segment.taskBlock, ...segment.childBlocks, ...segment.resultBlock ? [segment.resultBlock] : []];
+    case "workflow":
+      return [segment.toolBlock, ...segment.resultBlock ? [segment.resultBlock] : []];
+    default:
+      return segment.blocks;
+  }
+}
+
 // ../../packages/runtime/src/stream/delivery/window-projection.ts
 function projectWindowMessage(message) {
-  return stripMessagesForRemote([projectProgressiveMessage(message)], void 0, { splitText: false })[0];
+  return stripMessagesForRemote([projectProgressiveMessage(revealTodoResults(message))], void 0, { splitText: false })[0];
 }
 var WINDOW_TEXT_DELTAS = /* @__PURE__ */ new Set(["text", "thinking", "plan", "review", "notice"]);
 var WINDOW_CONTENT_EVENTS = /* @__PURE__ */ new Set([
@@ -102141,34 +103668,80 @@ var LIVE_MESSAGE_BUDGET = { maxBytes: 64 * 1024, maxFragments: 24, targetChars:
 var LIVE_PATCH_BYTES = 256 * 1024;
 var MAX_HELD = 64;
 var SessionFragments = class {
+  /** Times a message was fragmented and planned. A reparsed copy of the same content does not count. */
+  plans = 0;
   fragmenter = new MessageFragmenter();
   cache = /* @__PURE__ */ new WeakMap();
-  of(message) {
-    let fragments = this.cache.get(message);
-    if (!fragments) {
-      fragments = this.fragmenter.fragment(projectWindowMessage(message));
-      this.cache.set(message, fragments);
-    }
-    return fragments;
+  foldedCache = /* @__PURE__ */ new WeakMap();
+  /** Last plan for a message id, so a newly parsed row does not plan the message again. */
+  bySignature = /* @__PURE__ */ new Map();
+  of(message, folds = false, cuts) {
+    return folds ? this.folded(message, cuts).fragments : this.entry(message).fragments;
   }
-  source(transcript) {
+  /**
+   * The message with the process its settled turn collapses cut down to folds.
+   * `cuts` are the other rows that split this turn. A later read of the same
+   * content, parsed into a new object, reuses the plan; pass `cuts` only when
+   * they may have changed.
+   */
+  folded(message, cuts) {
+    const cutKey = foldCutKey(cuts);
+    const cached5 = this.foldedCache.get(message);
+    if (cached5 && (cuts === void 0 || cached5.cutKey === cutKey)) return cached5.view;
+    const contentKey = foldContentKey(message);
+    const stored = this.bySignature.get(message.id);
+    if (stored && stored.contentKey === contentKey && (cuts === void 0 || stored.cutKey === cutKey)) {
+      this.foldedCache.set(message, { cutKey: stored.cutKey, view: stored.view });
+      return stored.view;
+    }
+    this.plans++;
+    const { projected, fragments } = this.entry(message);
+    const content = readableContent(projected);
+    const planning = content === projected.content ? projected : { ...projected, content: [...content] };
+    const plan = planProcessFolds(planning, cuts?.length ? { cuts } : void 0);
+    const view = { fragments: foldMessageFragments(fragments, plan.ranges), plan };
+    this.bySignature.set(message.id, { contentKey, cutKey, view });
+    this.foldedCache.set(message, { cutKey, view });
+    return view;
+  }
+  source(transcript, folds = false, cuts) {
     return {
       count: transcript.count,
-      at: (index) => this.of(transcript.messageAt(index)),
+      at: (index) => {
+        const message = transcript.messageAt(index);
+        return this.of(message, folds, cuts?.get(message.id));
+      },
       indexOf: (messageId) => transcript.indexOf(messageId)
     };
   }
+  entry(message) {
+    let entry3 = this.cache.get(message);
+    if (!entry3) {
+      const projected = projectWindowMessage(message);
+      entry3 = { projected, fragments: this.fragmenter.fragment(projected) };
+      this.cache.set(message, entry3);
+    }
+    return entry3;
+  }
   retain(messages) {
-    this.fragmenter.retain(messages);
+    const keep = new Set(messages);
+    this.fragmenter.retain(keep);
+    for (const id of this.bySignature.keys()) if (!keep.has(id)) this.bySignature.delete(id);
   }
 };
 var WindowViews = class {
   sessions = /* @__PURE__ */ new Map();
+  /** Fold plans for a session this connection has not opened a window on yet. */
+  spare = /* @__PURE__ */ new Map();
   /** Holders the 64-window cap dropped since the last drain. Switching a holder off a session is not an eviction. */
   evicted = [];
   has(sessionId) {
     return (this.sessions.get(sessionId)?.holders.size ?? 0) > 0;
   }
+  /** How many times this connection fragmented a message to plan its folds. */
+  plannedFolds(sessionId) {
+    return this.fragmentsFor(sessionId).plans;
+  }
   /** Holder ids following `sessionId`, oldest serve first. */
   holderIds(sessionId) {
     return [...this.sessions.get(sessionId)?.holders.keys() ?? []];
@@ -102180,14 +103753,16 @@ var WindowViews = class {
   serve(input) {
     const transcript = input.transcript ?? (input.messages ? arrayTranscript(input.messages) : null);
     if (!transcript) throw new Error("transcript window needs messages");
+    const folds = input.request.folds === true;
     const session = this.session(input.sessionId);
-    const selected = selectTranscriptWindow(session.fragments.source(transcript), input.request, input.budget);
+    const cuts = boundaryCuts(input.messages ?? transcript.boundaryMessages?.() ?? []);
+    const selected = selectTranscriptWindow(session.fragments.source(transcript, folds, cuts), input.request, input.budget);
     const extend2 = input.request.anchor && input.request.direction !== "around" ? input.request.direction ?? "before" : null;
     const previous = session.holders.get(input.holder);
-    const held = extend2 && previous ? previous : { messages: /* @__PURE__ */ new Map(), order: [], atTail: false, total: 0, seen: /* @__PURE__ */ new Map() };
+    const held = extend2 && previous?.folds === folds ? previous : { messages: /* @__PURE__ */ new Map(), order: [], atTail: false, total: 0, seen: /* @__PURE__ */ new Map(), folds };
     for (const message of selected.messages) {
       const source = transcript.messageAt(message.index);
-      const fragments = session.fragments.of(source);
+      const fragments = session.fragments.of(source, folds, cuts.get(source.id));
       if (!held.messages.has(message.id)) held.seen.set(message.id, source);
       recordMessage(held, message, fragments, extend2 === "before" ? "before" : extend2 === "after" ? "after" : null);
     }
@@ -102211,9 +103786,10 @@ var WindowViews = class {
   patches(sessionId, messages) {
     const session = this.sessions.get(sessionId);
     if (!session) return [];
+    const cuts = boundaryCuts(messages);
     const out = [];
     for (const [holder, held] of session.holders) {
-      const patch = diffHeld(held, messages, session.fragments);
+      const patch = diffHeld(held, messages, session.fragments, cuts);
       if (patch) out.push({ holder, patch });
     }
     if (out.length) {
@@ -102222,6 +103798,30 @@ var WindowViews = class {
     }
     return out;
   }
+  /**
+   * The page behind fold `request.fold` of `message`, cut as this
+   * connection's windows cut it. It changes no held window: the fold stays
+   * one fragment there, and its pages live with the client.
+   */
+  fold(sessionId, message, request, budget) {
+    const fragments = this.fragmentsFor(sessionId);
+    const view = fragments.folded(message);
+    if (!this.sessions.has(sessionId)) fragments.retain([message.id]);
+    const inner = view.fragments.folds.get(request.fold);
+    if (!inner) throw Object.assign(new Error("Fold no longer exists"), { code: "not_found" });
+    if (foldRevision(inner.entries) !== request.revision) throw Object.assign(new Error("Fold changed"), { code: "failed_precondition" });
+    const page2 = selectFoldPage(inner, request.after, budget);
+    if (!page2) throw Object.assign(new Error("Fold page anchor no longer exists"), { code: "not_found" });
+    const rest = page2.end < inner.entries.length ? { ...view.plan.summarize(inner.blocks[page2.end], inner.blocks[inner.blocks.length - 1]), fragments: inner.entries.length - page2.end } : null;
+    return {
+      sessionId,
+      messageId: message.id,
+      fold: request.fold,
+      revision: request.revision,
+      fragments: inner.entries.slice(page2.start, page2.end).map(({ key, digest, body }) => ({ key, digest, body })),
+      rest
+    };
+  }
   close(sessionId, holder) {
     if (holder === void 0) {
       this.sessions.delete(sessionId);
@@ -102236,9 +103836,29 @@ var WindowViews = class {
   }
   session(sessionId) {
     let session = this.sessions.get(sessionId);
-    if (!session) this.sessions.set(sessionId, session = { fragments: new SessionFragments(), holders: /* @__PURE__ */ new Map() });
+    if (!session) {
+      const fragments = this.spare.get(sessionId) ?? new SessionFragments();
+      this.spare.delete(sessionId);
+      this.sessions.set(sessionId, session = { fragments, holders: /* @__PURE__ */ new Map() });
+    }
     return session;
   }
+  /** The fragmenter a window already holds, or the one fold pages keep warm. */
+  fragmentsFor(sessionId) {
+    const held = this.sessions.get(sessionId);
+    if (held) return held.fragments;
+    let fragments = this.spare.get(sessionId);
+    if (!fragments) {
+      fragments = new SessionFragments();
+      this.spare.set(sessionId, fragments);
+      while (this.spare.size > MAX_HELD) {
+        const oldest = this.spare.keys().next().value;
+        if (oldest === void 0) break;
+        this.spare.delete(oldest);
+      }
+    }
+    return fragments;
+  }
   /** Most recently used sessions last, so eviction takes the stalest first. */
   touch(sessionId) {
     const session = this.sessions.get(sessionId);
@@ -102266,6 +103886,27 @@ var WindowViews = class {
     }
   }
 };
+function boundaryCuts(messages) {
+  const cuts = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    const id = message.metadata?.transcriptBoundary?.messageId;
+    if (!id || id === message.id) continue;
+    const list = cuts.get(id);
+    if (list) list.push(message);
+    else cuts.set(id, [message]);
+  }
+  return cuts;
+}
+function foldContentKey(message) {
+  return contentDigest(JSON.stringify([message.role, message.status, readableContent(message)]));
+}
+function foldCutKey(cuts) {
+  if (!cuts?.length) return "";
+  return cuts.map((cut) => {
+    const boundary = cut.metadata?.transcriptBoundary;
+    return `${cut.id}:${boundary?.order ?? ""}:${JSON.stringify(boundary?.content ?? {})}`;
+  }).join("|");
+}
 function recordMessage(held, message, fragments, join54) {
   const previous = held.messages.get(message.id);
   const sent = message.fragments.map((fragment) => fragment.key);
@@ -102296,7 +103937,7 @@ function recordMessage(held, message, fragments, join54) {
 function heldFragment(digest, body) {
   return body.kind === "text" ? { digest, textLength: body.text.length } : { digest };
 }
-function diffHeld(held, messages, fragments) {
+function diffHeld(held, messages, fragments, cuts) {
   const index = new Map(messages.map((message, i) => [message.id, i]));
   const present = held.order.filter((id) => index.has(id));
   const removed = held.order.filter((id) => !index.has(id));
@@ -102313,7 +103954,7 @@ function diffHeld(held, messages, fragments) {
   for (let r = range.length - 1; r >= 0; r--) {
     const source = messages[range[r]];
     if (held.seen.get(source.id) === source && held.messages.has(source.id)) continue;
-    const { message, record: record13 } = diffMessage(held.messages.get(source.id), fragments.of(source), range[r], Math.max(0, Math.min(LIVE_MESSAGE_BUDGET.maxBytes, remaining)));
+    const { message, record: record13 } = diffMessage(held.messages.get(source.id), fragments.of(source, held.folds, cuts.get(source.id)), range[r], Math.max(0, Math.min(LIVE_MESSAGE_BUDGET.maxBytes, remaining)));
     const bytes = message ? patchBytes(message) : 0;
     if (bytes > remaining && changed.length) {
       start = r + 1;
@@ -106764,12 +108405,14 @@ init_transcript_window();
 var detailMessages = (sessions, sessionId) => sessions.detailMessages?.(sessionId) ?? sessions.messages(sessionId);
 function deliverLoad(result3, delivery) {
   if (!delivery) return result3;
-  if (summarizesTranscripts(delivery.policy) && !delivery.views.has(result3.sessionId)) delivery.views.open(result3.sessionId, true);
-  const messages = delivery.messages(result3.messages, result3.sessionId);
-  const activeTurn = result3.activeTurn && delivery.messages(result3.activeTurn, result3.sessionId);
+  const summarize = summarizesTranscripts(delivery.policy);
+  if (summarize && !delivery.views.has(result3.sessionId)) delivery.views.open(result3.sessionId, true);
+  const deliverMessages = (messages2) => summarize ? delivery.messages(messages2, result3.sessionId) : messages2;
+  const messages = deliverMessages(result3.messages);
+  const activeTurn = result3.activeTurn && deliverMessages(result3.activeTurn);
   const restore = result3.restore && {
     ...result3.restore,
-    ...result3.restore.realtimeThreadMessages ? { realtimeThreadMessages: delivery.messages(result3.restore.realtimeThreadMessages, result3.sessionId) } : {}
+    ...result3.restore.realtimeThreadMessages ? { realtimeThreadMessages: deliverMessages(result3.restore.realtimeThreadMessages) } : {}
   };
   const state = { ...result3.state };
   if (Array.isArray(state.queuedMessages)) {
@@ -106786,7 +108429,7 @@ function deliverLoad(result3, delivery) {
     ...restore ? { restore } : {},
     ...activeTurn ? { activeTurn } : {}
   };
-  return delivery.views.has(result3.sessionId) ? { ...delivered, summarized: true } : delivered;
+  return summarize ? { ...delivered, summarized: true } : delivered;
 }
 function deliverFrame(frame, delivery, sessions) {
   const changed = /* @__PURE__ */ new Set();
@@ -106795,12 +108438,18 @@ function deliverFrame(frame, delivery, sessions) {
     const event = agentEventOf(envelope, sessions);
     if (!event) return [envelope];
     const sessionId = envelope.aggregateId;
-    const summarized = delivery.views.has(sessionId);
-    if (summarized) changed.add(sessionId);
     const holdsWindow = delivery.windows.has(sessionId);
     if (holdsWindow) windowed.set(sessionId, envelope);
+    const desktopView = holdsWindow && desktopShowsSession(delivery.windows.holderIds(sessionId));
+    if (!desktopView && delivery.views.has(sessionId) && !summarizesTranscripts(delivery.policy)) delivery.views.close(sessionId);
+    else if (desktopView && !delivery.views.has(sessionId)) delivery.views.open(sessionId, true);
+    const summarized = delivery.views.has(sessionId);
+    if (summarized) changed.add(sessionId);
     const shaped = delivery.event(event, sessionId, summarized ? sessions.messages(sessionId) : []);
-    const live = holdsWindow && !desktopShowsSession(delivery.windows.holderIds(sessionId)) ? shaped.flatMap((next) => windowLiveEvent(next) ?? []) : shaped;
+    const live = holdsWindow ? shaped.flatMap((next) => {
+      const kept = windowLiveEvent(next);
+      return kept ? [desktopView ? stripEventForRemote(kept) : kept] : [];
+    }) : shaped;
     return live.map((next) => ({
       ...envelope,
       eventType: SESSION_DURABLE_EVENT.agentEvent,
@@ -106814,7 +108463,13 @@ function deliverFrame(frame, delivery, sessions) {
     }
   }
   const details = [...changed].flatMap((sessionId) => delivery.views.hasDetails(sessionId) ? delivery.details(sessionId, detailMessages(sessions, sessionId)).flatMap((event) => event.type === "remote_detail" ? [{ sessionId, update: { subscriptionId: event.subscriptionId, revision: event.revision, offset: event.offset, text: event.text } }] : []) : []);
-  const dropped = delivery.windows.drainEvicted().map((item) => item.sessionId);
+  const evicted = delivery.windows.drainEvicted();
+  if (!summarizesTranscripts(delivery.policy)) {
+    for (const item of evicted) {
+      if (!desktopShowsSession(delivery.windows.holderIds(item.sessionId))) delivery.views.close(item.sessionId);
+    }
+  }
+  const dropped = evicted.map((item) => item.sessionId);
   const resnapshot = dropped.length ? [.../* @__PURE__ */ new Set([...frame.resnapshot ?? [], ...dropped])] : frame.resnapshot;
   return { frame: { ...frame, events: foldDeltas(events), ...resnapshot?.length ? { resnapshot } : {} }, details };
 }
@@ -106866,215 +108521,6 @@ function agentEventOf(envelope, sessions) {
 // ../../packages/shared/src/turn-outline.ts
 init_codex_async_question();
 init_transcript_markers();
-
-// ../../packages/shared/src/transcript-segments.ts
-init_transcript_boundary();
-init_content_delta();
-init_codex_async_question();
-init_codex_content();
-var cachedSegments = /* @__PURE__ */ new WeakMap();
-function sliceBlock(block, from, to2) {
-  if (from === 0 && to2 === blockText(block)?.length) return block;
-  if (block.type === "text") return to2 > from ? { ...block, text: block.text.slice(from, to2) } : null;
-  if (block.type === "thinking") return to2 > from || "remoteDetail" in block && block.remoteDetail ? { ...block, thinking: block.thinking.slice(from, to2) } : null;
-  return block;
-}
-function sliceItem(item, from, to2) {
-  if (from === 0 && to2 === itemText(item)?.length) return item;
-  if (!("text" in item)) return item;
-  if (to2 <= from && !(item.type === "agent_message" && item.questions?.length) && !(item.type === "reasoning" && item.remoteDetail)) return null;
-  return { ...item, text: item.text.slice(from, to2) };
-}
-function contentGroups(content) {
-  const groups = [[]];
-  const owners = /* @__PURE__ */ new Map();
-  for (const block of content) {
-    const parent = "parentToolUseId" in block ? block.parentToolUseId : null;
-    const owner = parent ? owners.get(parent) : isToolResultBlock(block) ? owners.get(block.toolUseId) : void 0;
-    if (owner) {
-      owner.push(block);
-      if (isToolUseBlock(block)) owners.set(block.toolUseId, owner);
-      continue;
-    }
-    if (block.type === "text" && !parent && groups.at(-1).length) groups.push([]);
-    const group = groups.at(-1);
-    group.push(block);
-    if (isToolUseBlock(block)) owners.set(block.toolUseId, group);
-  }
-  return groups;
-}
-function itemGroups(items) {
-  const groups = [[]];
-  for (const item of items) {
-    if (item.type === "agent_message" && item.delivery !== "async" && groups.at(-1).length) groups.push([]);
-    groups.at(-1).push(item);
-  }
-  return groups;
-}
-function interval(source, previous, next) {
-  const keys = contentKeys(source.content);
-  const parents = new Map(source.content.flatMap((block) => isToolUseBlock(block) && "parentToolUseId" in block && block.parentToolUseId ? [[block.toolUseId, block.parentToolUseId]] : []));
-  const rootOwner = (id) => {
-    const seen = /* @__PURE__ */ new Set();
-    while (parents.has(id) && !seen.has(id)) {
-      seen.add(id);
-      id = parents.get(id);
-    }
-    return `tool:${id}`;
-  };
-  const content = source.content.flatMap((block, index) => {
-    const key = keys[index];
-    const ownerKey = "parentToolUseId" in block && block.parentToolUseId ? rootOwner(block.parentToolUseId) : isToolResultBlock(block) ? rootOwner(block.toolUseId) : key;
-    const start = previous?.content[ownerKey];
-    const end = next?.content[ownerKey];
-    const text2 = blockText(block);
-    if (ownerKey !== key) return start !== void 0 || next && end === void 0 ? [] : [block];
-    if (text2 === void 0) return start !== void 0 || next && end === void 0 ? [] : [block];
-    if (next && end === void 0) return [];
-    if (start === -1) return [];
-    if (start !== void 0 && text2.length <= start) return [];
-    const value = sliceBlock(block, Math.max(0, start ?? 0), Math.min(text2.length, end ?? text2.length));
-    return value ? [value] : [];
-  });
-  const items = (source.metadata?.codex?.items ?? []).flatMap((item) => {
-    const start = previous?.items[item.id];
-    const end = next?.items[item.id];
-    const text2 = itemText(item);
-    if (text2 === void 0) return start !== void 0 || next && end === void 0 ? [] : [item];
-    if (next && end === void 0) return [];
-    if (start === -1) return [];
-    if (start !== void 0 && text2.length <= start) return [];
-    const value = sliceItem(item, Math.max(0, start ?? 0), Math.min(text2.length, end ?? text2.length));
-    return value ? [value] : [];
-  });
-  return { content, items };
-}
-function transcriptSegments(messages) {
-  return transcriptView(messages).segments;
-}
-function transcriptView(messages) {
-  const displayed = messages.filter((message) => !isDismissedCodexAsyncAnswer(message, messages));
-  const sources = new Set(displayed.map((message) => message.id));
-  const boundaries = /* @__PURE__ */ new Map();
-  const consumed = /* @__PURE__ */ new Set();
-  for (const message of displayed) {
-    const cursor = message.metadata?.transcriptBoundary;
-    if (!cursor || !sources.has(cursor.messageId) || cursor.messageId === message.id) continue;
-    const cutRows = boundaries.get(cursor.messageId) ?? [];
-    cutRows.push(message);
-    boundaries.set(cursor.messageId, cutRows);
-    consumed.add(message.id);
-  }
-  const result3 = [];
-  const rows = [];
-  for (const source of displayed) {
-    if (consumed.has(source.id)) continue;
-    if (source.role !== "assistant" || source.providerId === "system") {
-      const cursor = source.metadata?.transcriptBoundary;
-      result3.push({
-        id: source.id,
-        message: source,
-        source,
-        final: true,
-        anchorId: cursor?.messageId ?? source.id,
-        offset: cursor?.order ?? 0
-      });
-      rows.push({ id: source.id, message: source, source, final: true });
-      continue;
-    }
-    const cuts = (boundaries.get(source.id) ?? []).sort((a, b3) => a.metadata.transcriptBoundary.order - b3.metadata.transcriptBoundary.order);
-    const cached5 = cachedSegments.get(source);
-    if (cached5 && cached5.cuts.length === cuts.length && cached5.cuts.every((cut, index) => cut === cuts[index])) {
-      result3.push(...cached5.segments);
-      rows.push(...cached5.rows);
-      continue;
-    }
-    const cursors = cuts.length ? resolveTranscriptBoundaries(cuts, transcriptLengths(source)) : [];
-    const legacy = isLegacyCodexMessage(source);
-    const segmentOf = (message) => legacy ? withCodexContent(message) : message;
-    const finalResponse = (content) => content.filter((block) => block.type === "text" && block.id === void 0);
-    const sliceOf = (content, items) => segmentOf({
-      ...source,
-      status: "complete",
-      content,
-      metadata: { ...source.metadata, ...legacy ? { codex: { ...source.metadata.codex, items, finalResponse: void 0 } } : {} }
-    });
-    const keys = contentKeys(source.content);
-    const keyByBlock = new Map(source.content.map((block, index) => [block, keys[index]]));
-    const firstResult = result3.length;
-    const firstRow = rows.length;
-    let previous;
-    let firstTurnRow = true;
-    for (let part = 0; part <= cuts.length; part++) {
-      const next = cuts[part];
-      const slice = interval(source, cursors[part - 1], cursors[part]);
-      const groups = legacy ? itemGroups(slice.items).map((items, index, all) => ({
-        items,
-        content: index === all.length - 1 ? finalResponse(slice.content) : []
-      })) : contentGroups(slice.content).map((content) => ({ content, items: [] }));
-      const partSegments = [];
-      for (let group = 0; group < groups.length; group++) {
-        const value = groups[group];
-        if (!value.content.length && !value.items.length && next) continue;
-        const key = value.items[0]?.id ?? keyByBlock.get(value.content[0]) ?? `part-${part}`;
-        const id = result3.length === firstResult ? source.id : previous && group === 0 ? `${source.id}:after:${previous.id}` : `${source.id}:segment:${key}`;
-        const anchorId = source.id;
-        const offset = (previous ? previous.metadata.transcriptBoundary.order + 0.1 : 0) + group / (groups.length + 1) * 0.5;
-        const segment = { id, source, final: false, anchorId, offset, message: sliceOf(value.content, value.items) };
-        result3.push(segment);
-        partSegments.push({ segment, opens: { block: value.content[0], itemId: value.items[0]?.id } });
-      }
-      if (partSegments.length) {
-        const [first, ...rest] = partSegments;
-        const message = rest.length ? sliceOf(legacy ? finalResponse(slice.content) : slice.content, slice.items) : first.segment.message;
-        const anchors = /* @__PURE__ */ new Map();
-        for (const { segment, opens } of rest) {
-          const block = legacy ? message.content.find((candidate) => "id" in candidate && candidate.id === opens.itemId) : opens.block;
-          if (block) anchors.set(block, segment.id);
-        }
-        const following = next ? interval(source, cursors[part]) : void 0;
-        rows.push({
-          id: first.segment.id,
-          message,
-          source,
-          final: false,
-          first: firstTurnRow,
-          ...anchors.size ? { anchors } : {},
-          ...following ? { following: sliceOf(following.content, following.items) } : {}
-        });
-        firstTurnRow = false;
-      }
-      if (next) {
-        result3.push({
-          id: next.id,
-          message: next,
-          source: next,
-          final: true,
-          anchorId: source.id,
-          offset: next.metadata.transcriptBoundary.order
-        });
-        rows.push({ id: next.id, message: next, source: next, final: true });
-      }
-      previous = next;
-    }
-    const last = result3.findLast((segment) => segment.source === source);
-    const lastRow = rows.findLast((row2) => row2.source === source);
-    if (last) {
-      const shared = lastRow?.message === last.message;
-      last.final = true;
-      last.message = segmentOf({ ...last.message, status: source.status });
-      if (shared) lastRow.message = last.message;
-    }
-    if (lastRow) {
-      lastRow.final = true;
-      if (lastRow.message.status !== source.status) lastRow.message = segmentOf({ ...lastRow.message, status: source.status });
-    }
-    cachedSegments.set(source, { cuts, segments: result3.slice(firstResult), rows: rows.slice(firstRow) });
-  }
-  return { segments: result3, rows };
-}
-
-// ../../packages/shared/src/turn-outline.ts
 function textOf2(message) {
   if (isCodexAsyncAnswer(message)) {
     const questions = codexAsyncAnswerQuestions(message, []);
@@ -107292,9 +108738,9 @@ async function handleSessionTranscriptWindow(payload, ctx) {
   if ("error" in target2) return target2;
   const parsed = parseWindowRequest(p3);
   if ("error" in parsed) return parsed;
-  const { anchor, direction, viewport, budget, have, holder } = parsed;
+  const { anchor, direction, viewport, budget, have, holder, folds } = parsed;
   const includeState = parsed.includeState ?? !anchor;
-  const request = { anchor, direction, have };
+  const request = { anchor, direction, have, folds };
   const limits = windowBudget({ budget, viewport });
   try {
     if (sessions.readTranscriptWindow) {
@@ -107324,6 +108770,8 @@ function windowResult(ctx, sessionId, holder, request, budget, view, includeStat
     request,
     budget
   });
+  const desktopWindow = Boolean(delivery) && holder.startsWith(DESKTOP_WINDOW_HOLDER_PREFIX);
+  if (desktopWindow) delivery?.views.open(sessionId, true);
   const shaped = deliverLoad({
     sessionId,
     state: view.state,
@@ -107341,22 +108789,38 @@ function windowResult(ctx, sessionId, holder, request, budget, view, includeStat
     total: selected.total,
     ...includeState ? { state: shaped.state, ...shaped.restore ? { restore: shaped.restore } : {} } : {},
     cursor: view.cursor,
-    ...shaped.summarized ? { summarized: true } : {}
+    ...shaped.summarized || desktopWindow ? { summarized: true } : {}
   };
   return { result: result3 };
 }
-function parseWindowRequest(p3) {
-  let anchor;
-  if (p3.anchor !== void 0) {
-    const a = asRecord(p3.anchor);
-    if (typeof a.messageId !== "string" || !a.messageId) return invalid5("anchor.messageId must be a non-empty string");
-    if (a.key !== void 0 && typeof a.key !== "string") return invalid5("anchor.key must be a string");
-    anchor = { messageId: a.messageId, ...typeof a.key === "string" ? { key: a.key } : {} };
-  }
-  if (p3.direction !== void 0 && p3.direction !== "before" && p3.direction !== "after" && p3.direction !== "around") {
-    return invalid5("direction must be before|after|around");
+async function handleSessionTranscriptFold(payload, ctx) {
+  const denied = requireScopes(ctx.client, OPERATION_SCOPES.readSession);
+  if (denied) return denied;
+  const sessions = ctx.sessions;
+  if (!sessions) return mapThrown(unsupportedMethodError(TRANSCRIPT_FOLD_METHOD));
+  const p3 = asRecord(payload);
+  const target2 = readSessionTarget(p3, sessions);
+  if ("error" in target2) return target2;
+  if (typeof p3.messageId !== "string" || !p3.messageId) return invalid5("messageId must be a non-empty string");
+  if (typeof p3.fold !== "string" || !p3.fold) return invalid5("fold must be a non-empty string");
+  if (typeof p3.revision !== "string" || !p3.revision) return invalid5("revision must be a non-empty string");
+  if (p3.after !== void 0 && typeof p3.after !== "string") return invalid5("after must be a string");
+  const limits = parseBudget(p3);
+  if ("error" in limits) return limits;
+  try {
+    const message = sessions.detailMessage ? sessions.detailMessage(target2.sessionId, p3.messageId) : sessions.messages(target2.sessionId).find((candidate) => candidate.id === p3.messageId);
+    if (!message) return { error: { code: "not_found", message: "History message no longer exists" } };
+    const result3 = (ctx.streams?.delivery?.windows ?? new WindowViews()).fold(target2.sessionId, message, {
+      fold: p3.fold,
+      revision: p3.revision,
+      ...typeof p3.after === "string" ? { after: p3.after } : {}
+    }, windowBudget(limits));
+    return { result: result3 };
+  } catch (err) {
+    return mapThrown(err);
   }
-  if (p3.direction !== void 0 && !anchor) return invalid5("direction requires an anchor");
+}
+function parseBudget(p3) {
   let viewport;
   if (p3.viewport !== void 0) {
     const v3 = asRecord(p3.viewport);
@@ -107371,16 +108835,33 @@ function parseWindowRequest(p3) {
     }
     budget = { maxBytes: b3.maxBytes, maxFragments: b3.maxFragments, targetChars: b3.targetChars };
   }
+  return { ...viewport ? { viewport } : {}, ...budget ? { budget } : {} };
+}
+function parseWindowRequest(p3) {
+  let anchor;
+  if (p3.anchor !== void 0) {
+    const a = asRecord(p3.anchor);
+    if (typeof a.messageId !== "string" || !a.messageId) return invalid5("anchor.messageId must be a non-empty string");
+    if (a.key !== void 0 && typeof a.key !== "string") return invalid5("anchor.key must be a string");
+    anchor = { messageId: a.messageId, ...typeof a.key === "string" ? { key: a.key } : {} };
+  }
+  if (p3.direction !== void 0 && p3.direction !== "before" && p3.direction !== "after" && p3.direction !== "around") {
+    return invalid5("direction must be before|after|around");
+  }
+  if (p3.direction !== void 0 && !anchor) return invalid5("direction requires an anchor");
+  const limits = parseBudget(p3);
+  if ("error" in limits) return limits;
   if (p3.have !== void 0 && !Array.isArray(p3.have)) return invalid5("have must be a list");
   if (p3.includeState !== void 0 && typeof p3.includeState !== "boolean") return invalid5("includeState must be boolean");
+  if (p3.folds !== void 0 && typeof p3.folds !== "boolean") return invalid5("folds must be boolean");
   if (p3.holder !== void 0 && (typeof p3.holder !== "string" || p3.holder.length > MAX_HOLDER_LENGTH)) return invalid5("holder must be a short string");
   return {
     anchor,
     direction: p3.direction,
-    viewport,
-    budget,
+    ...limits,
     have: p3.have,
     includeState: p3.includeState,
+    folds: p3.folds === true,
     holder: typeof p3.holder === "string" ? p3.holder : ""
   };
 }
@@ -108445,6 +109926,7 @@ var HANDLERS = {
   "session.messages.list": (payload, ctx) => handleSessionMessagesList(payload, ctx),
   "session.load": (payload, ctx) => handleSessionLoad(payload, ctx),
   "session.transcriptWindow": (payload, ctx) => handleSessionTranscriptWindow(payload, ctx),
+  "session.transcriptFold": (payload, ctx) => handleSessionTranscriptFold(payload, ctx),
   "session.historyIndex": (payload, ctx) => handleSessionHistoryIndex(payload, ctx),
   "session.subscribeDetail": (payload, ctx) => handleSessionSubscribeDetail(payload, ctx),
   "session.unsubscribeDetail": (payload, ctx) => handleSessionUnsubscribeDetail(payload, ctx),
@@ -116454,7 +117936,7 @@ var readBodyDirect = (request) => {
   const promise2 = new Promise((resolve22, reject) => {
     const chunks = [];
     let settled = false;
-    const finish = (callback) => {
+    const finish2 = (callback) => {
       if (settled) return;
       settled = true;
       cleanup();
@@ -116463,7 +117945,7 @@ var readBodyDirect = (request) => {
     const recoverCompleteBodyAfterDisconnect = (error51) => {
       const streamError = incoming.errored ?? error51;
       if (!isRecoverableDisconnectedIncoming(incoming) || streamError && streamError.code !== "ECONNRESET") return false;
-      finish(() => {
+      finish2(() => {
         const recovered = readBodyBufferedBeforeDisconnect(incoming, chunks);
         if (recovered instanceof Error) reject(recovered);
         else if (recovered === void 0) reject(error51 ?? normalizeAbortError(request, incoming));
@@ -116478,7 +117960,7 @@ var readBodyDirect = (request) => {
       chunks.push(toBufferChunk(chunk, incoming.readableEncoding));
     };
     const onEnd = () => {
-      finish(() => {
+      finish2(() => {
         const buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks);
         request[bodyBufferKey] = buffer;
         resolve22(buffer);
@@ -116486,7 +117968,7 @@ var readBodyDirect = (request) => {
     };
     const onError = (error51) => {
       if (recoverCompleteBodyAfterDisconnect(error51)) return;
-      finish(() => {
+      finish2(() => {
         reject(error51);
       });
     };
@@ -116496,7 +117978,7 @@ var readBodyDirect = (request) => {
         return;
       }
       if (recoverCompleteBodyAfterDisconnect()) return;
-      finish(() => {
+      finish2(() => {
         reject(normalizeAbortError(request, incoming));
       });
     };