@opengeni/react 3.3.2 → 3.4.0

package/dist/chunk-ADWCLI4G.js

@@ -0,0 +1,2028 @@
+"use client";
+import {
+  timelineGroupContainsPresentedImage
+} from "./chunk-5YJLGOM5.js";
+import {
+  mcpToolLeaf,
+  toolDisplayName
+} from "./chunk-3PVDYTTB.js";
+import {
+  formatClockTime,
+  stringifyPayload,
+  tryParseJson
+} from "./chunk-BLL56F7R.js";
+
+// src/timeline/parsers.ts
+import {
+  normalizeMcpOutput,
+  parseGeneratedImageReceipt
+} from "@opengeni/sdk";
+function sandboxCommandExitCode(out) {
+  const match = String(out ?? "").match(/Process exited with code (-?\d+)/);
+  return match ? Number(match[1]) : null;
+}
+function parseExecBannerSessionId(out) {
+  const text = String(out ?? "");
+  const outputIdx = text.indexOf("\nOutput:\n");
+  const banner = outputIdx >= 0 ? text.slice(0, outputIdx) : text.startsWith("Output:\n") ? "" : text;
+  const match = banner.match(/Process running with session ID (\d+)/);
+  if (!match) {
+    return null;
+  }
+  const n = Number.parseInt(match[1], 10);
+  return Number.isFinite(n) ? n : null;
+}
+function stripExecBanner(out) {
+  const text = String(out ?? "");
+  const marker = text.indexOf("\nOutput:\n");
+  if (marker >= 0) {
+    return text.slice(marker + "\nOutput:\n".length);
+  }
+  if (text.startsWith("Output:\n")) {
+    return text.slice("Output:\n".length);
+  }
+  return text;
+}
+function execTruncated(out) {
+  return /Total output lines:|\.{3}\d+ tokens truncated\.{3}|\[\.{3}\d+ characters truncated/.test(
+    String(out ?? "")
+  );
+}
+function isExecSessionLostBanner(out) {
+  return /write_stdin failed: session not found: \d+/.test(String(out ?? ""));
+}
+function looksBinary(text) {
+  return text.includes("\0") || text.startsWith("\x7FELF");
+}
+function controlCaret(printable) {
+  return String(printable).replace(
+    /[\u0000-\u001f]/g,
+    (c) => `^${String.fromCharCode(c.charCodeAt(0) + 64)}`
+  );
+}
+function v4aToGitFileDiff(op) {
+  const status = op.type === "create_file" ? "added" : op.type === "delete_file" ? "deleted" : op.moveTo ? "renamed" : "modified";
+  const oldPath = op.moveTo ? op.path : null;
+  const path = op.moveTo || op.path;
+  const hunks = [];
+  let additions = 0;
+  let deletions = 0;
+  let sawHunkAnchor = false;
+  if (op.type !== "delete_file") {
+    const lines = (op.diff ?? "").split("\n");
+    let cur = null;
+    let oldNo = 1;
+    let newNo = 1;
+    for (const raw of lines) {
+      if (raw.startsWith("@@")) {
+        sawHunkAnchor = true;
+        const match = raw.match(/-(\d+)(?:,\d+)?\s+\+(\d+)/);
+        oldNo = match ? Number(match[1]) : 1;
+        newNo = match ? Number(match[2]) : 1;
+        cur = {
+          oldStart: oldNo,
+          oldLines: 0,
+          newStart: newNo,
+          newLines: 0,
+          header: raw,
+          lines: [{ type: "meta", oldNo: null, newNo: null, text: raw }]
+        };
+        hunks.push(cur);
+      } else if (cur || op.type === "create_file") {
+        if (!cur) {
+          cur = {
+            oldStart: 0,
+            oldLines: 0,
+            newStart: 1,
+            newLines: 0,
+            header: "",
+            lines: []
+          };
+          hunks.push(cur);
+          oldNo = 0;
+          newNo = 1;
+        }
+        if (raw.startsWith("+")) {
+          cur.lines.push({
+            type: "add",
+            oldNo: null,
+            newNo: newNo++,
+            text: raw.slice(1)
+          });
+          cur.newLines += 1;
+          additions += 1;
+        } else if (raw.startsWith("-")) {
+          cur.lines.push({
+            type: "del",
+            oldNo: oldNo++,
+            newNo: null,
+            text: raw.slice(1)
+          });
+          cur.oldLines += 1;
+          deletions += 1;
+        } else {
+          cur.lines.push({
+            type: "context",
+            oldNo: oldNo++,
+            newNo: newNo++,
+            text: raw.replace(/^ /, "")
+          });
+          cur.oldLines += 1;
+          cur.newLines += 1;
+        }
+      }
+    }
+    if (op.type === "update_file" && !sawHunkAnchor && lines.some((l) => l.trim().length > 0)) {
+      throw new Error("malformed V4A: no @@ hunk anchor");
+    }
+  }
+  return {
+    path,
+    oldPath,
+    status,
+    isBinary: false,
+    isImage: false,
+    additions,
+    deletions,
+    hunks,
+    truncated: false
+  };
+}
+var BEGIN_PATCH = "*** Begin Patch";
+var END_PATCH = "*** End Patch";
+var ADD_FILE = "*** Add File: ";
+var DELETE_FILE = "*** Delete File: ";
+var UPDATE_FILE = "*** Update File: ";
+var MOVE_TO = "*** Move to: ";
+var APPLY_PATCH_OP_TYPES = /* @__PURE__ */ new Set(["create_file", "update_file", "delete_file"]);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function freeformApplyPatchOps(rawPatch) {
+  return parseFreeformApplyPatch(rawPatch.trimStart());
+}
+function asApplyPatchOperation(value) {
+  if (!isRecord(value)) return null;
+  if (typeof value.type !== "string" || !APPLY_PATCH_OP_TYPES.has(value.type)) {
+    return null;
+  }
+  if (typeof value.path !== "string" || !value.path) {
+    return null;
+  }
+  const op = {
+    type: value.type,
+    path: value.path
+  };
+  if (typeof value.diff === "string") op.diff = value.diff;
+  if (typeof value.moveTo === "string" && value.moveTo.length > 0) op.moveTo = value.moveTo;
+  return op;
+}
+function parseStructuredOperations(payloads) {
+  if (payloads.length === 0) return [];
+  const operations = [];
+  for (const payload of payloads) {
+    const op = asApplyPatchOperation(payload);
+    if (!op) return [];
+    operations.push(op);
+  }
+  return operations;
+}
+function parseFreeformApplyPatch(rawPatch) {
+  const lines = rawPatch.split(/\r?\n/);
+  if (lines.at(-1) === "") lines.pop();
+  if (lines[0] !== BEGIN_PATCH) return [];
+  if (lines.length < 2 || lines.at(-1) !== END_PATCH) return [];
+  const operations = [];
+  let index = 1;
+  while (index < lines.length - 1) {
+    const line = lines[index];
+    let parsed = null;
+    if (line.startsWith(ADD_FILE)) parsed = parseAddFilePatch(lines, index);
+    else if (line.startsWith(DELETE_FILE)) parsed = parseDeleteFilePatch(lines, index);
+    else if (line.startsWith(UPDATE_FILE)) parsed = parseUpdateFilePatch(lines, index);
+    else return [];
+    if (!parsed || "error" in parsed) return [];
+    operations.push(parsed.operation);
+    index = parsed.nextIndex;
+  }
+  return operations.length > 0 ? operations : [];
+}
+function parsePatchHeader(line, prefix) {
+  const path = line.slice(prefix.length).trim();
+  return path || null;
+}
+function isFileOperationHeader(line) {
+  return line.startsWith(ADD_FILE) || line.startsWith(DELETE_FILE) || line.startsWith(UPDATE_FILE);
+}
+function joinDiff(lines) {
+  return `${lines.join("\n")}
+`;
+}
+function parseAddFilePatch(lines, index) {
+  const path = parsePatchHeader(lines[index], ADD_FILE);
+  if (!path) return { error: true };
+  index += 1;
+  const diffLines = [];
+  while (index < lines.length - 1 && !isFileOperationHeader(lines[index])) {
+    const line = lines[index];
+    if (!line.startsWith("+")) return { error: true };
+    diffLines.push(line);
+    index += 1;
+  }
+  if (diffLines.length === 0) return { error: true };
+  return {
+    operation: { type: "create_file", path, diff: joinDiff(diffLines) },
+    nextIndex: index
+  };
+}
+function parseDeleteFilePatch(lines, index) {
+  const path = parsePatchHeader(lines[index], DELETE_FILE);
+  if (!path) return { error: true };
+  index += 1;
+  if (index < lines.length - 1 && !isFileOperationHeader(lines[index])) {
+    return { error: true };
+  }
+  return { operation: { type: "delete_file", path }, nextIndex: index };
+}
+function parseUpdateFilePatch(lines, index) {
+  const path = parsePatchHeader(lines[index], UPDATE_FILE);
+  if (!path) return { error: true };
+  index += 1;
+  let moveTo;
+  if (index < lines.length - 1 && lines[index].startsWith(MOVE_TO)) {
+    const parsedMoveTo = parsePatchHeader(lines[index], MOVE_TO);
+    if (!parsedMoveTo) return { error: true };
+    moveTo = parsedMoveTo;
+    index += 1;
+  }
+  const diffLines = [];
+  while (index < lines.length - 1 && !isFileOperationHeader(lines[index])) {
+    diffLines.push(lines[index]);
+    index += 1;
+  }
+  if (diffLines.length === 0 && !moveTo) return { error: true };
+  return {
+    operation: {
+      type: "update_file",
+      path,
+      diff: diffLines.length > 0 ? joinDiff(diffLines) : "",
+      ...moveTo ? { moveTo } : {}
+    },
+    nextIndex: index
+  };
+}
+function applyPatchOps(raw) {
+  if (raw == null) return [];
+  if (typeof raw === "string") {
+    const trimmed = raw.trimStart();
+    if (trimmed.startsWith(BEGIN_PATCH)) return freeformApplyPatchOps(trimmed);
+    const parsed = tryParseJson(trimmed);
+    return parsed === void 0 ? [] : applyPatchOps(parsed);
+  }
+  if (Array.isArray(raw)) return parseStructuredOperations(raw);
+  if (!isRecord(raw)) return [];
+  if (typeof raw.patch === "string") return freeformApplyPatchOps(raw.patch);
+  if (Array.isArray(raw.command)) {
+    const [commandName, patch] = raw.command;
+    if (commandName === "apply_patch" && typeof patch === "string") {
+      return freeformApplyPatchOps(patch);
+    }
+  }
+  if (Array.isArray(raw.operations) && raw.operations.length > 0) {
+    return parseStructuredOperations(raw.operations);
+  }
+  if (raw.operation !== void 0) {
+    const op = asApplyPatchOperation(raw.operation);
+    return op ? [op] : [];
+  }
+  const flat = asApplyPatchOperation(raw);
+  return flat ? [flat] : [];
+}
+function applyPatchOpsFromToolItem(item) {
+  const fromRaw = applyPatchOps(item.raw);
+  if (fromRaw.length > 0) return fromRaw;
+  if (isRecord(item.raw)) {
+    const nested = item.raw.arguments ?? item.raw.input;
+    if (nested !== void 0 && nested !== item.arguments) {
+      const fromNested = applyPatchOps(nested);
+      if (fromNested.length > 0) return fromNested;
+    }
+  }
+  if (item.arguments !== void 0 && item.arguments !== null) {
+    return applyPatchOps(item.arguments);
+  }
+  return [];
+}
+function isApplyPatch(item) {
+  const type = item.raw && typeof item.raw === "object" ? item.raw.type : void 0;
+  if (type === "apply_patch_call") {
+    return true;
+  }
+  const name = item.name;
+  return name === "apply_patch_call" || name === "apply_patch" || name.endsWith("__apply_patch");
+}
+function parseToolArgs(args) {
+  if (args == null) {
+    return {};
+  }
+  if (typeof args === "string") {
+    const parsed = tryParseJson(args);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  }
+  return typeof args === "object" ? args : {};
+}
+function tailPeek(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return "";
+  }
+  const lines = trimmed.split("\n");
+  return lines[lines.length - 1] ?? "";
+}
+function unwrapMcpOutput(output) {
+  const normalized = normalizeMcpOutput(output);
+  return { text: normalized.text, isError: normalized.isError };
+}
+function screenshotDataUrl(out) {
+  if (typeof out === "string") {
+    if (out.startsWith("data:image")) {
+      return out;
+    }
+    if (out.startsWith("{") || out.startsWith("[")) {
+      const parsed = tryParseJson(out);
+      if (parsed !== void 0 && parsed !== out) {
+        return screenshotDataUrl(parsed);
+      }
+    }
+    return null;
+  }
+  if (Array.isArray(out)) {
+    for (const entry of out) {
+      const url = screenshotDataUrl(entry);
+      if (url) {
+        return url;
+      }
+    }
+    return null;
+  }
+  if (out === null || typeof out !== "object") {
+    return null;
+  }
+  const record = out;
+  const imageUrl = record.image_url ?? record.imageUrl;
+  if (typeof imageUrl === "string" && imageUrl.startsWith("data:image")) {
+    return imageUrl;
+  }
+  if (imageUrl && typeof imageUrl === "object") {
+    const url = imageUrl.url;
+    if (typeof url === "string" && url.startsWith("data:image")) {
+      return url;
+    }
+  }
+  const image = record.image;
+  if (image && typeof image === "object") {
+    const mediaType = typeof image.mediaType === "string" ? image.mediaType : "image/png";
+    const base64 = bytesToBase64(image.data);
+    if (base64) {
+      return `data:${mediaType};base64,${base64}`;
+    }
+    if (typeof image.data === "string" && image.data.length > 0) {
+      return `data:${mediaType};base64,${image.data}`;
+    }
+  }
+  return null;
+}
+function retainedScreenshotMetadata(out) {
+  if (typeof out === "string" && (out.startsWith("{") || out.startsWith("["))) {
+    const parsed = tryParseJson(out);
+    if (parsed !== void 0 && parsed !== out) return retainedScreenshotMetadata(parsed);
+  }
+  if (Array.isArray(out)) {
+    for (const entry of out) {
+      const metadata = retainedScreenshotMetadata(entry);
+      if (metadata) return metadata;
+    }
+    return null;
+  }
+  if (!out || typeof out !== "object") return null;
+  const value = out;
+  if (typeof value.artifactId !== "string" || typeof value.available !== "boolean") return null;
+  if (!value.available) {
+    return typeof value.reason === "string" ? value : null;
+  }
+  return (value.kind === "computer_screenshot" || value.kind === "browser_screenshot") && ["image/png", "image/jpeg", "image/webp"].includes(String(value.contentType)) && typeof value.originalBytes === "number" && typeof value.sha256 === "string" && value.dimensions !== null && typeof value.dimensions === "object" && value.retention !== null && typeof value.retention === "object" && value.retention.policy === "session_screenshot" ? value : null;
+}
+function generatedImageReceipt(out) {
+  return parseGeneratedImageReceipt(out);
+}
+function retainedToolResultImages(out) {
+  const parsed = typeof out === "string" && (out.startsWith("{") || out.startsWith("[")) ? tryParseJson(out) : out;
+  const split = (entries) => {
+    const images = [];
+    const rest = entries.filter((entry) => {
+      if (!entry || typeof entry !== "object" || Array.isArray(entry)) return true;
+      const receipt = retainedScreenshotMetadata(entry);
+      if (!receipt?.available) return true;
+      images.push(receipt);
+      return false;
+    });
+    return { images, rest };
+  };
+  if (Array.isArray(parsed)) {
+    const { images, rest } = split(parsed);
+    return images.length ? { images, output: rest } : { images, output: out };
+  }
+  if (parsed && typeof parsed === "object") {
+    const record = parsed;
+    if (Array.isArray(record.content)) {
+      const { images, rest } = split(record.content);
+      return images.length ? { images, output: { ...record, content: rest } } : { images, output: out };
+    }
+  }
+  return { images: [], output: out };
+}
+function mediaPreviewFact(out) {
+  if (typeof out === "string" && (out.startsWith("{") || out.startsWith("["))) {
+    const parsed = tryParseJson(out);
+    if (parsed !== void 0 && parsed !== out) return mediaPreviewFact(parsed);
+  }
+  if (Array.isArray(out)) {
+    for (const entry of out) {
+      const preview = mediaPreviewFact(entry);
+      if (preview) return preview;
+    }
+    return null;
+  }
+  if (!out || typeof out !== "object") return null;
+  const record = out;
+  if (record.type !== "media_preview" || typeof record.mediaType !== "string" || record.fullOutputAvailable !== false || typeof record.preview !== "string" || record.inlineBytes !== null && typeof record.inlineBytes !== "number") {
+    return null;
+  }
+  return record;
+}
+function bytesToBase64(data) {
+  const isByte = (n) => typeof n === "number" && Number.isInteger(n) && n >= 0 && n <= 255;
+  let bytes = null;
+  if (Array.isArray(data) && data.every(isByte)) {
+    bytes = data;
+  } else if (data && typeof data === "object") {
+    const record = data;
+    if (record.type === "Buffer" && Array.isArray(record.data) && record.data.every(isByte)) {
+      bytes = record.data;
+    } else {
+      const keys = Object.keys(record);
+      if (keys.length > 0 && keys.every((key) => /^\d+$/.test(key))) {
+        const values = keys.sort((a, b) => Number(a) - Number(b)).map((key) => record[key]);
+        if (values.every(isByte)) {
+          bytes = values;
+        }
+      }
+    }
+  }
+  if (!bytes || bytes.length === 0) {
+    return null;
+  }
+  try {
+    let binary = "";
+    const CHUNK = 32768;
+    for (let i = 0; i < bytes.length; i += CHUNK) {
+      binary += String.fromCharCode(...bytes.slice(i, i + CHUNK));
+    }
+    return typeof btoa === "function" ? btoa(binary) : Buffer.from(binary, "binary").toString("base64");
+  } catch {
+    return null;
+  }
+}
+
+// src/timeline/registry.ts
+function rawTypeOf(item) {
+  const raw = item.raw;
+  if (raw && typeof raw === "object" && typeof raw.type === "string") {
+    return raw.type;
+  }
+  return null;
+}
+function createToolRegistry(baseEntries, baseFallback, options = {}) {
+  const entries = [...options.entries ?? [], ...baseEntries];
+  const fallback = options.fallback ?? baseFallback;
+  const byRawType = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
+  const byPrefixedLeaf = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.match === "rawType") {
+      if (!byRawType.has(entry.type)) {
+        byRawType.set(entry.type, entry.render);
+      }
+    } else if (!byName.has(entry.name)) {
+      byName.set(entry.name, entry.render);
+    }
+    if (entry.match === "name" && entry.matchPrefixedLeaf !== false) {
+      if (!byPrefixedLeaf.has(entry.name)) {
+        byPrefixedLeaf.set(entry.name, entry.render);
+      }
+    }
+  }
+  const resolve = (item) => {
+    const rawType = rawTypeOf(item);
+    if (rawType) {
+      const byType = byRawType.get(rawType);
+      if (byType) {
+        return byType;
+      }
+    }
+    const exact = byName.get(item.name);
+    if (exact) {
+      return exact;
+    }
+    const leaf = mcpToolLeaf(item.name);
+    if (leaf !== item.name) {
+      const byLeaf = byPrefixedLeaf.get(leaf);
+      if (byLeaf) {
+        return byLeaf;
+      }
+    }
+    return fallback;
+  };
+  return { resolve, fallback };
+}
+
+// src/timeline/turn-summary-model.ts
+var BUILT_IN_TURN_SUMMARY_FACET_IDS = [
+  "steps",
+  "files",
+  "commands",
+  "screenshots",
+  "memories",
+  "compacted",
+  "duration"
+];
+function formatElapsed(durationMs) {
+  const totalSeconds = Math.max(0, Math.floor(durationMs / 1e3));
+  if (totalSeconds < 60) {
+    return `${totalSeconds}s`;
+  }
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  if (totalMinutes < 60) {
+    const seconds = totalSeconds % 60;
+    return seconds ? `${totalMinutes}m ${seconds}s` : `${totalMinutes}m`;
+  }
+  const hours = Math.floor(totalMinutes / 60);
+  return `${hours}h ${String(totalMinutes % 60).padStart(2, "0")}m`;
+}
+function createTurnSummaryContext(items, outcome, failureText, durationMs, contextCompactionCount) {
+  const itemSnapshot = Object.freeze([...items]);
+  const toolCalls = Object.freeze(
+    itemSnapshot.filter((item) => item.kind === "tool-call")
+  );
+  const settled = itemSnapshot.every((item) => {
+    if (item.kind === "reasoning" || item.kind === "agent-message") {
+      return !item.streaming;
+    }
+    if (item.kind === "tool-call" || item.kind === "worker" || item.kind === "sandbox" || item.kind === "startup-phase") {
+      return item.status !== "running";
+    }
+    return true;
+  });
+  return Object.freeze({
+    items: itemSnapshot,
+    toolCalls,
+    outcome,
+    failureText,
+    durationMs,
+    settled,
+    contextCompactionCount: Math.max(0, Math.floor(contextCompactionCount))
+  });
+}
+var BUILT_IN_TURN_SUMMARY_FACETS = Object.freeze([
+  {
+    id: "steps",
+    summarize: ({ items }) => {
+      const count = items.filter(
+        (item) => item.kind !== "startup-phase" && item.kind !== "agent-message"
+      ).length;
+      return count ? { content: `${count} ${count === 1 ? "step" : "steps"}` } : items.some((item) => item.kind === "startup-phase") ? { content: "Preparation" } : null;
+    }
+  },
+  {
+    id: "files",
+    summarize: ({ toolCalls }) => {
+      let files = 0;
+      for (const item of toolCalls) {
+        if (isApplyPatch(item)) {
+          files += applyPatchOpsFromToolItem(item).length;
+        }
+      }
+      return files ? { content: `${files} ${files === 1 ? "file" : "files"} edited` } : null;
+    }
+  },
+  {
+    id: "commands",
+    summarize: ({ toolCalls }) => {
+      const commands = toolCalls.filter((item) => item.name === "exec_command").length;
+      return commands ? { content: `${commands} ${commands === 1 ? "command" : "commands"}` } : null;
+    }
+  },
+  {
+    id: "screenshots",
+    summarize: ({ toolCalls }) => {
+      let screenshots = 0;
+      for (const item of toolCalls) {
+        const leaf = mcpToolLeaf(item.name);
+        if ((rawTypeOf(item) === "computer_call" || item.name === "computer_call" || item.name === "computer_screenshot" || leaf === "browser_screenshot" || leaf === "browser_observe" || leaf === "browser_act") && (retainedScreenshotMetadata(item.output) !== null || screenshotDataUrl(item.output) !== null || mediaPreviewFact(item.output) !== null)) {
+          screenshots += 1;
+        }
+      }
+      return screenshots ? {
+        content: `${screenshots} ${screenshots === 1 ? "screenshot" : "screenshots"}`
+      } : null;
+    }
+  },
+  {
+    id: "memories",
+    summarize: ({ items }) => {
+      let saved = 0;
+      let updated = 0;
+      for (const item of items) {
+        if (item.kind !== "memory") {
+          continue;
+        }
+        if (item.variant === "corrected") {
+          updated += 1;
+        } else {
+          saved += 1;
+        }
+      }
+      const parts = [];
+      if (saved) {
+        parts.push(`${saved} ${saved === 1 ? "memory" : "memories"} saved`);
+      }
+      if (updated) {
+        parts.push(`${updated} ${updated === 1 ? "memory" : "memories"} updated`);
+      }
+      return parts.length > 0 ? { content: parts.join(" \xB7 ") } : null;
+    }
+  },
+  {
+    id: "compacted",
+    summarize: ({ contextCompactionCount }) => contextCompactionCount > 0 ? {
+      content: contextCompactionCount === 1 ? "compacted" : `${contextCompactionCount} compacts`,
+      ariaLabel: contextCompactionCount === 1 ? "Conversation history compacted" : `${contextCompactionCount} conversation history compactions`
+    } : null
+  },
+  {
+    id: "duration",
+    summarize: ({ durationMs }) => {
+      const duration = formatDurationFacet(durationMs);
+      return duration ? { content: duration } : null;
+    }
+  }
+]);
+function resolveTurnSummaryFacets(configuration) {
+  const requested = configuration?.replace ?? [
+    ...BUILT_IN_TURN_SUMMARY_FACETS.filter(
+      (facet) => !configuration?.remove?.includes(facet.id)
+    ),
+    ...configuration?.add ?? []
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  return requested.filter((facet) => {
+    if (!facet.id || seen.has(facet.id)) {
+      return false;
+    }
+    seen.add(facet.id);
+    return true;
+  });
+}
+function formatDurationFacet(durationMs) {
+  if (durationMs === void 0 || !Number.isFinite(durationMs) || durationMs < 1e3) {
+    return null;
+  }
+  const totalSeconds = Math.floor(durationMs / 1e3);
+  if (totalSeconds < 60) {
+    return `${totalSeconds}s`;
+  }
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  if (totalMinutes < 60) {
+    return `${totalMinutes}m`;
+  }
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  return `${hours}h ${String(minutes).padStart(2, "0")}m`;
+}
+function hasFacetContent(content) {
+  return content !== null && content !== void 0 && content !== false && content !== "";
+}
+function selectTurnSummaryFacets(definitions, context, statusKind) {
+  return definitions.flatMap((facet) => {
+    if (statusKind && (facet.id === "duration" || facet === BUILT_IN_TURN_SUMMARY_FACETS[0] && context.items.every(
+      (item) => item.kind === "startup-phase" || item.kind === "agent-message"
+    ) || statusKind !== "worked" && facet.id !== "steps" && BUILT_IN_TURN_SUMMARY_FACET_IDS.includes(facet.id))) {
+      return [];
+    }
+    try {
+      const result = facet.summarize(context);
+      return result && hasFacetContent(result.content) ? [{ facet, result }] : [];
+    } catch {
+      return [];
+    }
+  });
+}
+
+// src/timeline/work-presentation.ts
+function durationBetween(startedAt, endedAt) {
+  const started = Date.parse(startedAt);
+  const ended = Date.parse(endedAt);
+  if (!Number.isFinite(started) || !Number.isFinite(ended) || ended < started) {
+    return void 0;
+  }
+  return ended - started;
+}
+function compactedLandmarkCount(groups) {
+  return groups.filter(
+    (group) => group.kind === "item" && group.item.kind === "context-compaction" && group.item.phase === "compacted"
+  ).length;
+}
+function clusterIsSettled(group) {
+  return group.items.every((item) => {
+    if (item.kind === "reasoning" || item.kind === "agent-message") {
+      return !item.streaming;
+    }
+    if (item.kind === "memory" || item.kind === "fleet-decision") {
+      return true;
+    }
+    return item.status !== "running";
+  });
+}
+function flattenActivityItems(groups) {
+  const items = [];
+  for (const group of groups) {
+    if (group.kind === "activity") {
+      items.push(...flattenActivityItems(group.work?.details ?? []), ...group.items);
+    } else if (group.kind === "turn") {
+      items.push(...flattenActivityItems(group.groups));
+    }
+  }
+  return items;
+}
+function isPreparingWork(group, options) {
+  if (!group.work) return false;
+  const phases = group.items.filter((item) => item.kind === "startup-phase");
+  return !options.startupDetails && !options.startupDismissed && !group.work.endedAt && !group.work.waiting && phases.length > 0 && group.items.every(
+    (item) => item.kind === "startup-phase" || item.kind === "reasoning" && !item.text.trim()
+  ) && !phases.some((item) => item.status === "failed" || item.status === "cancelled");
+}
+function readableWorkHasDetails(group, options) {
+  return group.work.details.some(
+    (detail) => options.startupDetails || detail.kind !== "activity" || Boolean(detail.work) || !detail.items.every(
+      (item) => item.kind === "startup-phase" && item.status !== "failed" && item.status !== "cancelled" || item.kind === "reasoning" && !item.text.trim()
+    )
+  );
+}
+function readableWorkStatus(group) {
+  const end = group.work.endedAt;
+  const pausedMs = group.work.pausedMs ?? 0;
+  if (end) {
+    const durationMs = durationBetween(group.work.startedAt, end);
+    const cycles = group.work.cycles;
+    if (cycles) return { kind: "worked", label: `${cycles.count} updates over`, durationMs };
+    return {
+      kind: "worked",
+      durationMs: durationMs === void 0 ? void 0 : Math.max(0, durationMs - pausedMs)
+    };
+  }
+  if (group.work.waiting) {
+    const { untimed, since, ...waiting } = group.work.waiting;
+    return { kind: "waiting", ...waiting, ...untimed ? {} : { since } };
+  }
+  const started = Date.parse(group.work.startedAt);
+  return {
+    kind: "working",
+    since: pausedMs > 0 && Number.isFinite(started) ? new Date(started + pausedMs).toISOString() : group.work.startedAt
+  };
+}
+function readableWorkDefaultOpen(group) {
+  const phases = group.items.filter((item) => item.kind === "startup-phase");
+  return timelineGroupContainsPresentedImage(group) || group.outcome === "failed" || phases.some((item) => item.status === "failed" || item.status === "cancelled") ? true : void 0;
+}
+function readableWorkShowsPreview(group) {
+  return !timelineGroupContainsPresentedImage(group);
+}
+function rollingActivityItem(items, previousItem, mounted = true) {
+  const work = items.filter(
+    (item2) => item2.kind !== "startup-phase" && item2.kind !== "agent-message"
+  );
+  const active = work.filter(
+    (item2) => item2.kind === "reasoning" ? item2.streaming : "status" in item2 && item2.status === "running"
+  );
+  const item = !mounted && previousItem && previousItem.kind !== "agent-message" ? previousItem : work.at(-1);
+  if (!item) return null;
+  return {
+    item,
+    running: active.some((entry) => entry.id === item.id),
+    earlierCount: Math.max(
+      0,
+      work.findIndex((entry) => entry.id === item.id)
+    )
+  };
+}
+
+// src/timeline/tool-presentation.ts
+function withComputePreview(label, preview) {
+  if (!label) {
+    return preview;
+  }
+  return `on ${label} \xB7 ${preview}`;
+}
+function truncatePreview(text, max) {
+  const cleaned = text.replace(/\s+/g, " ").trim();
+  if (!cleaned) {
+    return "";
+  }
+  return cleaned.length > max ? `${cleaned.slice(0, max - 1)}\u2026` : cleaned;
+}
+function textPreview(text, running) {
+  return running ? { kind: "text", text, running: true } : { kind: "text", text };
+}
+function execPresentation(item, context = {}) {
+  const args = parseToolArgs(item.arguments);
+  const cmd = typeof args.cmd === "string" ? args.cmd : "";
+  const workdir = typeof args.workdir === "string" ? args.workdir : null;
+  const out = item.output;
+  const title = `$ ${cmd}`;
+  const computeLabel = context.computeLabel ?? null;
+  const base = {
+    tool: "exec",
+    icon: "terminal",
+    title,
+    titleMono: true
+  };
+  if (item.status === "failed" && out === void 0) {
+    return {
+      ...base,
+      iconTone: "failed",
+      chip: { tone: "bad", text: "failed" },
+      preview: textPreview(
+        withComputePreview(computeLabel, "output lost \u2014 NUL byte could not be stored")
+      ),
+      body: {
+        kind: "note",
+        tone: "error",
+        text: "output contained a NUL byte and could not be stored; the turn failed on this tool's output insert \u2014 no output event ever arrived."
+      }
+    };
+  }
+  if (item.status === "failed" && (out == null || out === "")) {
+    return {
+      ...base,
+      iconTone: "failed",
+      chip: { tone: "bad", text: "failed" },
+      preview: textPreview(withComputePreview(computeLabel, "tool call failed")),
+      body: {
+        kind: "note",
+        tone: "error",
+        text: "the tool call failed with no output."
+      }
+    };
+  }
+  if (item.status === "running") {
+    const streamed = typeof out === "string" ? stripExecBanner(out) : "";
+    const runningPreview = streamed ? `${streamed.split("\n").length} lines` : "running\u2026";
+    return {
+      ...base,
+      iconTone: "running",
+      running: true,
+      preview: textPreview(withComputePreview(computeLabel, runningPreview), true),
+      body: {
+        kind: "term",
+        command: null,
+        workdir,
+        output: streamed,
+        live: true
+      }
+    };
+  }
+  const text = typeof out === "string" ? out : stringifyPayload(out);
+  const stripped = stripExecBanner(text);
+  const bgSession = parseExecBannerSessionId(text);
+  const exitCode = sandboxCommandExitCode(text);
+  const binary = looksBinary(stripped);
+  let chip;
+  let iconTone = "muted";
+  if (bgSession != null) {
+    chip = { tone: "muted", text: `session ${bgSession}` };
+  } else if (exitCode != null && exitCode !== 0) {
+    chip = { tone: "bad", text: `exit ${exitCode}` };
+    iconTone = "failed";
+  }
+  const peek = binary ? "binary output" : tailPeek(stripped) || "(no output)";
+  const truncated = execTruncated(text);
+  const preview = withComputePreview(computeLabel, truncated ? `\u22EF truncated \xB7 ${peek}` : peek);
+  return {
+    ...base,
+    iconTone,
+    ...chip ? { chip } : {},
+    failed: item.status === "failed",
+    cancelled: item.status === "cancelled",
+    preview: textPreview(preview),
+    body: {
+      kind: "term",
+      command: null,
+      workdir,
+      output: binary ? "(binary output suppressed)" : stripped,
+      failed: item.status === "failed" || exitCode != null && exitCode !== 0,
+      ...bgSession != null ? {
+        note: `\u21B3 session ${bgSession} \u2014 a later write_stdin can target this PTY.`
+      } : {}
+    }
+  };
+}
+function writeStdinPresentation(item) {
+  const args = parseToolArgs(item.arguments);
+  const sessionId = typeof args.session_id === "string" || typeof args.session_id === "number" ? args.session_id : void 0;
+  const text = typeof item.output === "string" ? item.output : stringifyPayload(item.output);
+  const lost = isExecSessionLostBanner(text);
+  const keys = controlCaret(typeof args.chars === "string" ? args.chars : "");
+  const exitCode = sandboxCommandExitCode(text);
+  const stripped = stripExecBanner(text);
+  const title = `session ${sessionId} \u2190 ${keys || "\u2205"}`;
+  const base = {
+    tool: "write_stdin",
+    icon: "keyboard",
+    title,
+    titleMono: true
+  };
+  if (item.status === "running") {
+    return {
+      ...base,
+      iconTone: "running",
+      running: true,
+      preview: textPreview("sending\u2026", true),
+      body: { kind: "note", text: `sending input to session ${sessionId}\u2026` }
+    };
+  }
+  let chip;
+  if (lost) {
+    chip = { tone: "bad", text: "lost" };
+  } else if (exitCode != null && exitCode !== 0) {
+    chip = { tone: "bad", text: `exit ${exitCode}` };
+  }
+  return {
+    ...base,
+    iconTone: lost ? "failed" : "muted",
+    ...chip ? { chip } : {},
+    failed: item.status === "failed",
+    cancelled: item.status === "cancelled",
+    preview: textPreview(lost ? `session ${sessionId} PTY vanished` : tailPeek(stripped) || "sent"),
+    body: lost ? { kind: "note", tone: "error", text: stripped || text } : {
+      kind: "term",
+      command: `write_stdin \u2192 session ${sessionId}`,
+      workdir: null,
+      output: stripped
+    }
+  };
+}
+function patchVerb(op) {
+  if (!op) {
+    return "Edited";
+  }
+  return op.type === "create_file" ? "Created" : op.type === "delete_file" ? "Deleted" : op.moveTo ? "Renamed" : "Edited";
+}
+function pathBasename(path) {
+  const parts = path.split("/").filter(Boolean);
+  return parts.length ? parts[parts.length - 1] : path;
+}
+function pathDirname(path) {
+  const idx = path.lastIndexOf("/");
+  return idx >= 0 ? path.slice(0, idx + 1) : "";
+}
+function safeParsePatchOp(op) {
+  try {
+    return v4aToGitFileDiff(op);
+  } catch {
+    return null;
+  }
+}
+function patchFiles(ops, parsed) {
+  return ops.map((op, index) => ({
+    key: `${op.type}:${op.path}:${index}`,
+    path: op.path,
+    file: parsed ? parsed[index] ?? null : safeParsePatchOp(op),
+    diff: op.diff ?? ""
+  }));
+}
+function applyPatchPresentation(item) {
+  const ops = applyPatchOpsFromToolItem(item);
+  const cancelled = item.status === "cancelled";
+  const firstOp = ops[0];
+  const base = { tool: "apply_patch", icon: "file-diff" };
+  if (item.status === "running") {
+    const fileCount = ops.length;
+    const titleVerb = firstOp ? `Applying ${pathBasename(firstOp.path)}` : "Applying patch";
+    return {
+      ...base,
+      iconTone: "running",
+      title: fileCount > 1 ? `Applying ${fileCount} files` : titleVerb,
+      running: true,
+      preview: textPreview(
+        fileCount > 1 ? `${fileCount} files` : firstOp ? firstOp.path : "applying\u2026",
+        true
+      ),
+      body: { kind: "patch", files: patchFiles(ops) }
+    };
+  }
+  if (item.status === "failed") {
+    return {
+      ...base,
+      iconTone: "failed",
+      title: firstOp ? `${patchVerb(firstOp)} ${pathBasename(firstOp.path)}` : "apply_patch",
+      chip: { tone: "bad", text: "failed" },
+      preview: textPreview(typeof item.output === "string" ? item.output : "patch failed"),
+      body: {
+        kind: "payloads",
+        blocks: [{ label: "Error", value: item.output, failed: true }]
+      }
+    };
+  }
+  if (ops.length > 1) {
+    const parsed = ops.map((op) => safeParsePatchOp(op));
+    const goodFiles = parsed.filter((f) => f !== null);
+    const add = goodFiles.reduce((n, f) => n + f.additions, 0);
+    const del = goodFiles.reduce((n, f) => n + f.deletions, 0);
+    return {
+      ...base,
+      iconTone: "accent",
+      title: `Edited ${ops.length} files`,
+      cancelled,
+      preview: { kind: "files", count: ops.length, add, del },
+      body: { kind: "patch", files: patchFiles(ops, parsed) }
+    };
+  }
+  if (!firstOp) {
+    return null;
+  }
+  if (firstOp.type === "delete_file") {
+    return {
+      ...base,
+      iconTone: "failed",
+      title: `Deleted ${pathBasename(firstOp.path)}`,
+      cancelled,
+      preview: { kind: "path", path: firstOp.path },
+      body: { kind: "note", text: "File deleted \u2014 no diff to show." }
+    };
+  }
+  const file = safeParsePatchOp(firstOp);
+  if (!file) {
+    return {
+      ...base,
+      iconTone: "accent",
+      title: `${patchVerb(firstOp)} ${pathBasename(firstOp.path)}`,
+      cancelled,
+      preview: { kind: "malformed", name: pathBasename(firstOp.path) },
+      body: { kind: "patch", files: patchFiles([firstOp], [null]), bare: true }
+    };
+  }
+  return {
+    ...base,
+    iconTone: "accent",
+    title: `${patchVerb(firstOp)} ${pathBasename(file.path)}`,
+    cancelled,
+    preview: {
+      kind: "path",
+      path: file.path,
+      add: file.additions,
+      del: file.deletions
+    },
+    body: { kind: "patch", files: patchFiles([firstOp], [file]) }
+  };
+}
+function webSearchQueryFromArguments(args) {
+  if (typeof args === "string") {
+    const trimmed = args.trim();
+    if (!trimmed) {
+      return null;
+    }
+    try {
+      return webSearchQueryFromArguments(JSON.parse(trimmed));
+    } catch {
+      return trimmed;
+    }
+  }
+  if (!args || typeof args !== "object") {
+    return null;
+  }
+  const record = args;
+  if (typeof record.query === "string" && record.query.trim().length > 0) {
+    return record.query;
+  }
+  if (Array.isArray(record.queries)) {
+    const first = record.queries.find(
+      (value) => typeof value === "string" && value.trim().length > 0
+    );
+    if (first) {
+      return first;
+    }
+  }
+  return null;
+}
+function webSearchPresentation(item) {
+  const raw = item.raw ?? {};
+  const action = raw.providerData?.action ?? {};
+  const actionType = action.type ?? "search";
+  const queries = (action.queries ?? []).filter(
+    (value) => typeof value === "string" && value.trim().length > 0
+  );
+  const searchQuery = (typeof action.query === "string" && action.query.trim().length > 0 ? action.query : null) ?? queries[0] ?? webSearchQueryFromArguments(item.arguments);
+  const running = item.status === "running";
+  const query = actionType === "open_page" ? action.url ?? "(page unavailable)" : actionType === "find_in_page" ? action.pattern && action.url ? `"${action.pattern}" in ${action.url}` : action.pattern ?? action.url ?? "(page unavailable)" : (
+    // Codex often emits the live card before action.query/queries land.
+    searchQuery ?? (running ? "\u2026" : "(query unavailable)")
+  );
+  const variants = queries.length > 1 ? ` +${queries.length - 1} variants` : "";
+  const base = { tool: "web_search", icon: "search" };
+  if (running) {
+    return {
+      ...base,
+      iconTone: "running",
+      title: actionType === "open_page" ? "Opening web page" : actionType === "find_in_page" ? "Searching within page" : "Searching the web",
+      running: true,
+      preview: textPreview(`${query}${variants}`, true),
+      body: {
+        kind: "note",
+        text: "searching\u2026 results fold into the model context (no output event)."
+      }
+    };
+  }
+  const rawResults = item.output?.results;
+  const results = Array.isArray(rawResults) ? rawResults.filter((r) => !!r && typeof r === "object") : null;
+  return {
+    ...base,
+    iconTone: "muted",
+    title: actionType === "open_page" ? "Opened web page" : actionType === "find_in_page" ? "Searched within page" : "Searched the web",
+    preview: textPreview(`${query}${variants}`),
+    failed: item.status === "failed",
+    cancelled: item.status === "cancelled",
+    body: { kind: "web-results", results }
+  };
+}
+function askToolPreview(args) {
+  const record = args && typeof args === "object" ? args : null;
+  const questions = Array.isArray(record?.questions) ? record.questions : null;
+  if (!questions || questions.length === 0) {
+    return null;
+  }
+  const first = questions[0];
+  if (!first || typeof first !== "object") {
+    return null;
+  }
+  const q = first;
+  const text = typeof q.label === "string" && q.label.trim() ? q.label.trim() : typeof q.prompt === "string" && q.prompt.trim() ? q.prompt.trim() : null;
+  if (!text) {
+    return null;
+  }
+  const preview = truncatePreview(text, 90);
+  return questions.length > 1 ? `${preview} \xB7 ${questions.length} questions` : preview;
+}
+function runOnTargetName(output) {
+  const { text } = unwrapMcpOutput(output);
+  const parsed = tryParseJson(text);
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    const name = parsed.targetName;
+    if (typeof name === "string" && name.trim()) {
+      return name.trim();
+    }
+  }
+  return null;
+}
+function runOnOpPreview(args) {
+  const op = args.op;
+  if (!op || typeof op !== "object" || Array.isArray(op)) {
+    return null;
+  }
+  const record = op;
+  if (record.kind === "exec" && typeof record.cmd === "string" && record.cmd.trim()) {
+    return `$ ${record.cmd.trim()}`;
+  }
+  if ((record.kind === "read" || record.kind === "write") && typeof record.path === "string" && record.path.trim()) {
+    return truncatePreview(record.path.trim(), 72);
+  }
+  return null;
+}
+function goalToolPreview(name, args) {
+  const leaf = mcpToolLeaf(name);
+  if (leaf !== "goal_set" && leaf !== "goal_update" && leaf !== "goal_complete" && leaf !== "goal_pause" && leaf !== "wait_for_input") {
+    return null;
+  }
+  const record = args && typeof args === "object" ? args : null;
+  if (!record) {
+    return null;
+  }
+  const text = typeof record.text === "string" ? record.text : typeof record.evidence === "string" ? record.evidence : typeof record.rationale === "string" ? record.rationale : typeof record.reason === "string" ? record.reason : typeof record.progressNote === "string" ? record.progressNote : null;
+  return text ? truncatePreview(text, 90) : null;
+}
+function genericToolIconKind(name) {
+  const leaf = mcpToolLeaf(name);
+  return leaf === "request_human_input" ? "question" : leaf.startsWith("goal_") ? "target" : leaf.startsWith("memory_") || leaf === "preference_registry_summary" || leaf === "preference_registry_get" ? "brain" : leaf.startsWith("session_") || leaf === "sessions_list" || leaf === "set_session_title" || leaf === "set_other_session_title" ? "sessions" : leaf.startsWith("sandbox") || leaf === "sandboxes_list" || leaf === "run_on" ? "server" : leaf.startsWith("rig_") ? "server-cog" : leaf.startsWith("scheduled_") ? "calendar" : leaf.startsWith("artifacts_") ? "panels" : leaf.startsWith("social_") ? "share" : leaf.startsWith("slack_") ? "message" : leaf.startsWith("github_") ? "git" : leaf.startsWith("variable_") ? "box" : leaf.startsWith("environment_") ? "key" : leaf.includes("document") || leaf.includes("knowledge") || leaf === "list_document_bases" ? "file-search" : leaf === "tool_search" ? "package-search" : leaf.startsWith("skill_") ? "plug" : "wrench";
+}
+function mcpRowPresentation(item, options) {
+  const args = parseToolArgs(item.arguments);
+  const base = { tool: options.tool, icon: options.icon, title: options.title };
+  if (item.status === "running") {
+    return {
+      ...base,
+      iconTone: "running",
+      running: true,
+      preview: options.runningPreview != null && options.plainRunningPreview ? textPreview(options.runningPreview) : textPreview(options.runningPreview ?? options.runningFallback, true),
+      body: { kind: "payloads", blocks: [{ label: "Arguments", value: args }] }
+    };
+  }
+  const { text: outText, isError } = unwrapMcpOutput(item.output);
+  if ((isError || item.status === "failed") && item.status !== "cancelled") {
+    const errorFallback = options.settledFallback === void 0 ? options.settledPreview : null;
+    return {
+      ...base,
+      iconTone: "failed",
+      chip: { tone: "bad", text: "error" },
+      preview: textPreview(truncatePreview(outText, 80) || errorFallback || "Error"),
+      body: {
+        kind: "payloads",
+        blocks: [
+          { label: "Arguments", value: args },
+          { label: "Error", value: outText, failed: true }
+        ]
+      }
+    };
+  }
+  const settled = item.status === "cancelled" ? null : options.settledPreview ?? options.settledFallback ?? null;
+  return {
+    ...base,
+    iconTone: "muted",
+    cancelled: item.status === "cancelled",
+    ...settled != null ? { preview: textPreview(settled) } : {},
+    body: {
+      kind: "payloads",
+      blocks: options.omitEmptyResult && !outText ? [{ label: "Arguments", value: args }] : [
+        { label: "Arguments", value: args },
+        { label: "Result", value: outText }
+      ]
+    }
+  };
+}
+function askPresentation(item) {
+  const preview = askToolPreview(parseToolArgs(item.arguments));
+  return mcpRowPresentation(item, {
+    tool: "ask",
+    icon: "question",
+    title: "Ask",
+    runningPreview: preview,
+    runningFallback: "Waiting\u2026",
+    settledPreview: preview,
+    omitEmptyResult: true
+  });
+}
+function runOnPresentation(item) {
+  const targetName = runOnTargetName(item.output);
+  const opPreview = runOnOpPreview(parseToolArgs(item.arguments));
+  return mcpRowPresentation(item, {
+    tool: "run_on",
+    icon: "server",
+    title: targetName ? `Run on ${targetName}` : "Run on",
+    runningPreview: opPreview,
+    runningFallback: "Running\u2026",
+    settledPreview: opPreview,
+    omitEmptyResult: true
+  });
+}
+function genericToolPresentation(item) {
+  const goalPreview = goalToolPreview(item.name, parseToolArgs(item.arguments));
+  if (item.status !== "running") {
+    const { text: outText, isError } = unwrapMcpOutput(item.output);
+    const base = {
+      tool: "generic",
+      icon: genericToolIconKind(item.name),
+      title: toolDisplayName(item.name, item.display)
+    };
+    const args = parseToolArgs(item.arguments);
+    if (isError && BLOCKED_OUTPUT.test(outText)) {
+      return {
+        ...base,
+        iconTone: "muted",
+        chip: { tone: "interrupted", text: "blocked" },
+        preview: textPreview("Blocked by your permission settings"),
+        body: {
+          kind: "payloads",
+          note: "Your permission settings block this action, so it did not run. You can change this in the integration's tool permissions.",
+          blocks: [{ label: "Arguments", value: args }]
+        }
+      };
+    }
+    if (isError && UNCERTAIN_OUTPUT.test(outText)) {
+      return {
+        ...base,
+        iconTone: "failed",
+        chip: { tone: "bad", text: "outcome unknown" },
+        preview: textPreview("It may have run"),
+        body: {
+          kind: "payloads",
+          note: "This action may have run. Check the result in the connected app before trying again.",
+          blocks: [{ label: "Arguments", value: args }]
+        }
+      };
+    }
+  }
+  return mcpRowPresentation(item, {
+    tool: "generic",
+    icon: genericToolIconKind(item.name),
+    title: toolDisplayName(item.name, item.display),
+    runningPreview: goalPreview,
+    runningFallback: "Running\u2026",
+    settledPreview: goalPreview,
+    settledFallback: "Done",
+    plainRunningPreview: true
+  });
+}
+var BLOCKED_OUTPUT = /Connector action was not executed: blocked\b/;
+var UNCERTAIN_OUTPUT = /Connector action outcome is uncertain\b/;
+function splitToolWireName(name) {
+  const boundary = name.indexOf("__");
+  if (boundary <= 0) {
+    return { name, source: null, leaf: name };
+  }
+  return {
+    name,
+    source: name.slice(0, boundary),
+    leaf: name.slice(boundary + 2)
+  };
+}
+function toolSearchQuery(item) {
+  const fromArgs = parseToolArgs(item.arguments);
+  if (typeof fromArgs.query === "string" && fromArgs.query.trim()) {
+    return fromArgs.query.trim();
+  }
+  const raw = item.raw;
+  if (raw && typeof raw === "object") {
+    const rawArgs = raw.arguments;
+    if (typeof rawArgs === "string" && rawArgs.trim()) {
+      const parsed = tryParseJson(rawArgs);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        const query = parsed.query;
+        if (typeof query === "string" && query.trim()) {
+          return query.trim();
+        }
+      }
+    } else if (rawArgs && typeof rawArgs === "object" && !Array.isArray(rawArgs)) {
+      const query = rawArgs.query;
+      if (typeof query === "string" && query.trim()) {
+        return query.trim();
+      }
+    }
+  }
+  return "";
+}
+function parseDisclosedTools(output) {
+  if (output && typeof output === "object" && !Array.isArray(output)) {
+    const tools = output.tools;
+    if (Array.isArray(tools)) {
+      return tools.map((tool) => {
+        if (typeof tool === "string" && tool.trim()) {
+          return splitToolWireName(tool.trim());
+        }
+        if (tool && typeof tool === "object" && typeof tool.name === "string") {
+          const name = tool.name.trim();
+          return name ? splitToolWireName(name) : null;
+        }
+        return null;
+      }).filter((tool) => tool != null);
+    }
+  }
+  const { text } = unwrapMcpOutput(output);
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return null;
+  }
+  if (/^no matching tools found\.?$/i.test(trimmed)) {
+    return [];
+  }
+  const disclosed = trimmed.match(/^disclosed tools:\s*(.+)$/i);
+  if (disclosed?.[1]) {
+    return disclosed[1].split(",").map((part) => part.trim()).filter(Boolean).map(splitToolWireName);
+  }
+  const parsed = tryParseJson(trimmed);
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    return parseDisclosedTools(parsed);
+  }
+  return null;
+}
+function toolSearchPreview(tools, cancelled) {
+  if (cancelled) {
+    return void 0;
+  }
+  if (!tools) {
+    return "Done";
+  }
+  if (tools.length === 0) {
+    return "No matches";
+  }
+  if (tools.length === 1) {
+    return tools[0].leaf;
+  }
+  const head = tools[0].leaf;
+  return `${tools.length} tools \xB7 ${truncatePreview(head, 28)}`;
+}
+function toolSearchPresentation(item) {
+  const query = toolSearchQuery(item);
+  const queryPreview = query ? truncatePreview(query, 64) : "";
+  const note = query ? `capability query: ${query}` : void 0;
+  const args = parseToolArgs(item.arguments);
+  const base = { tool: "tool_search", icon: "package-search" };
+  if (item.status === "running") {
+    return {
+      ...base,
+      iconTone: "running",
+      title: "Looking up tools",
+      running: true,
+      preview: textPreview(queryPreview || "Matching capabilities\u2026", true),
+      body: { kind: "listing", note, entries: [], blocks: [{ label: "Arguments", value: args }] }
+    };
+  }
+  const { text: outText, isError } = unwrapMcpOutput(item.output);
+  if ((isError || item.status === "failed") && item.status !== "cancelled") {
+    return {
+      ...base,
+      iconTone: "failed",
+      title: "Tool lookup failed",
+      failed: true,
+      preview: textPreview(truncatePreview(outText, 80) || queryPreview || "Lookup failed"),
+      body: {
+        kind: "listing",
+        note,
+        entries: [],
+        blocks: [
+          { label: "Arguments", value: args },
+          { label: "Error", value: outText, failed: true }
+        ]
+      }
+    };
+  }
+  const tools = parseDisclosedTools(item.output);
+  const preview = toolSearchPreview(tools, item.status === "cancelled");
+  return {
+    ...base,
+    iconTone: "muted",
+    title: "Looked up tools",
+    cancelled: item.status === "cancelled",
+    ...preview ? { preview: textPreview(preview) } : {},
+    body: {
+      kind: "listing",
+      note,
+      entries: (tools ?? []).slice(0, 12).map((tool) => ({
+        key: tool.name,
+        title: tool.leaf,
+        eyebrow: tool.source,
+        mono: true
+      })),
+      more: tools && tools.length > 12 ? tools.length - 12 : void 0,
+      empty: tools && tools.length === 0 ? "no deferred tools matched this capability query." : void 0,
+      blocks: tools == null && outText ? [
+        { label: "Arguments", value: args },
+        { label: "Result", value: outText }
+      ] : [{ label: "Arguments", value: args }]
+    }
+  };
+}
+function parseSearchHits(outText) {
+  const parsed = tryParseJson(outText);
+  if (parsed == null) {
+    return null;
+  }
+  const list = Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" && Array.isArray(parsed.results) ? parsed.results : parsed && typeof parsed === "object" && Array.isArray(parsed.hits) ? parsed.hits : null;
+  if (!list) {
+    return null;
+  }
+  return list.map((row) => {
+    const r = row && typeof row === "object" ? row : {};
+    const title = typeof r.title === "string" && r.title || typeof r.name === "string" && r.name || typeof r.documentTitle === "string" && r.documentTitle || typeof r.path === "string" && r.path || typeof r.id === "string" && r.id || "Result";
+    const snippet = typeof r.snippet === "string" && r.snippet || typeof r.text === "string" && r.text || typeof r.content === "string" && r.content || "";
+    return { title, snippet: truncatePreview(snippet, 160) };
+  });
+}
+function docsSearchPresentation(item) {
+  const args = parseToolArgs(item.arguments);
+  const query = typeof args.query === "string" ? args.query.trim() : "";
+  const base = {
+    tool: "docs_search",
+    icon: "file-search",
+    title: query ? `Search \u201C${truncatePreview(query, 48)}\u201D` : toolDisplayName(item.name, item.display)
+  };
+  if (item.status === "running") {
+    return {
+      ...base,
+      iconTone: "running",
+      running: true,
+      preview: textPreview("Searching\u2026", true),
+      body: { kind: "payloads", blocks: [{ label: "Arguments", value: args }] }
+    };
+  }
+  const { text: outText, isError } = unwrapMcpOutput(item.output);
+  if ((isError || item.status === "failed") && item.status !== "cancelled") {
+    return {
+      ...base,
+      iconTone: "failed",
+      failed: true,
+      preview: textPreview(truncatePreview(outText, 80) || "Search failed"),
+      body: {
+        kind: "payloads",
+        blocks: [
+          { label: "Arguments", value: args },
+          { label: "Error", value: outText, failed: true }
+        ]
+      }
+    };
+  }
+  const hits = parseSearchHits(outText);
+  const preview = item.status === "cancelled" ? void 0 : hits ? hits.length === 0 ? "No hits" : `${hits.length} hit${hits.length === 1 ? "" : "s"}` : "Done";
+  return {
+    ...base,
+    iconTone: "muted",
+    cancelled: item.status === "cancelled",
+    ...preview ? { preview: textPreview(preview) } : {},
+    body: {
+      kind: "listing",
+      entries: (hits ?? []).slice(0, 8).map((hit) => ({
+        key: `${hit.title}\0${hit.snippet}`,
+        title: hit.title,
+        snippet: hit.snippet || void 0
+      })),
+      blocks: [
+        { label: "Arguments", value: args },
+        { label: "Result", value: outText }
+      ]
+    }
+  };
+}
+function sessionTitlePresentation(item) {
+  const args = parseToolArgs(item.arguments);
+  const titleArg = typeof args.title === "string" ? args.title.trim() : "";
+  const previewTitle = titleArg ? truncatePreview(titleArg, 72) : "";
+  const base = {
+    tool: "session_title",
+    icon: "sessions",
+    title: toolDisplayName(item.name, item.display)
+  };
+  if (item.status === "running") {
+    return {
+      ...base,
+      iconTone: "running",
+      running: true,
+      preview: textPreview(previewTitle || "Setting title\u2026", true),
+      body: { kind: "payloads", blocks: [{ label: "Arguments", value: args }] }
+    };
+  }
+  const { text: outText, isError } = unwrapMcpOutput(item.output);
+  if ((isError || item.status === "failed") && item.status !== "cancelled") {
+    return {
+      ...base,
+      iconTone: "failed",
+      failed: true,
+      preview: textPreview(truncatePreview(outText, 80) || "Rename failed"),
+      body: {
+        kind: "payloads",
+        blocks: [
+          { label: "Arguments", value: args },
+          { label: "Error", value: outText, failed: true }
+        ]
+      }
+    };
+  }
+  let settledTitle = previewTitle;
+  if (!settledTitle) {
+    const parsed = tryParseJson(outText);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const fromResult = parsed.title;
+      if (typeof fromResult === "string" && fromResult.trim()) {
+        settledTitle = truncatePreview(fromResult.trim(), 72);
+      }
+    }
+  }
+  return {
+    ...base,
+    iconTone: "muted",
+    cancelled: item.status === "cancelled",
+    ...item.status !== "cancelled" && settledTitle ? { preview: textPreview(settledTitle) } : {},
+    body: {
+      kind: "payloads",
+      blocks: outText ? [
+        { label: "Arguments", value: args },
+        { label: "Result", value: outText }
+      ] : [{ label: "Arguments", value: args }]
+    }
+  };
+}
+var PRESENTERS_BY_RAW_TYPE = {
+  apply_patch_call: "apply_patch",
+  // Web renders these with richer media renderers; keep them off name matches.
+  computer_call: "generic",
+  tool_search_call: "tool_search"
+};
+var PRESENTERS_BY_NAME = {
+  exec_command: "exec",
+  request_human_input: "ask",
+  run_on: "run_on",
+  write_stdin: "write_stdin",
+  apply_patch_call: "apply_patch",
+  apply_patch: "apply_patch",
+  web_search_call: "web_search",
+  tool_search: "tool_search",
+  search_documents: "docs_search",
+  knowledge_search: "docs_search",
+  set_session_title: "session_title",
+  set_other_session_title: "session_title"
+};
+function presentedToolKind(item) {
+  const rawType = rawTypeOf(item);
+  if (rawType && PRESENTERS_BY_RAW_TYPE[rawType]) {
+    return PRESENTERS_BY_RAW_TYPE[rawType];
+  }
+  const exact = PRESENTERS_BY_NAME[item.name];
+  if (exact) {
+    return exact;
+  }
+  const leaf = mcpToolLeaf(item.name);
+  if (leaf !== item.name && PRESENTERS_BY_NAME[leaf]) {
+    return PRESENTERS_BY_NAME[leaf];
+  }
+  return "generic";
+}
+function toolRowPresentation(item, context = {}) {
+  switch (presentedToolKind(item)) {
+    case "exec":
+      return execPresentation(item, context);
+    case "write_stdin":
+      return writeStdinPresentation(item);
+    case "apply_patch":
+      return applyPatchPresentation(item) ?? genericToolPresentation(item);
+    case "web_search":
+      return webSearchPresentation(item);
+    case "ask":
+      return askPresentation(item);
+    case "run_on":
+      return runOnPresentation(item);
+    case "tool_search":
+      return toolSearchPresentation(item);
+    case "docs_search":
+      return docsSearchPresentation(item);
+    case "session_title":
+      return sessionTitlePresentation(item);
+    default:
+      return genericToolPresentation(item);
+  }
+}
+
+// src/timeline/genie-copy.ts
+var GENIE_PREPARING_PHRASES = [
+  "Polishing the lamp\u2026",
+  "Consulting the carpet\u2026",
+  "Untangling wishes\u2026",
+  "Summoning a little cleverness\u2026",
+  "Checking the fine print on infinity\u2026",
+  "Warming up the abracadabra\u2026",
+  "Rearranging the stars\u2026",
+  "Negotiating with the lamp\u2026",
+  "Dusting off a thousand years\u2026",
+  "Wishful thinking\u2026",
+  "Decanting a little magic\u2026",
+  "Finding the good stardust\u2026",
+  "Fluffing the magic carpet\u2026",
+  "Putting a wish into motion\u2026",
+  "A little hocus. A little pocus\u2026"
+];
+var GENIE_WAITING_PHRASES = ["Waiting for a response\u2026"];
+
+// src/human-input-model.ts
+var SAVE_TO_IN_SENTENCE = {
+  user: "Only me",
+  task: "this task",
+  workspace: "this workspace"
+};
+var defaultHumanInputFormMessages = {
+  title: "Input required",
+  /** Multi-question chrome has no default subtitle; hosts may still override. */
+  description: "",
+  submit: "Send answers",
+  skip: "Skip",
+  submitting: "Submitting\u2026",
+  other: "Other",
+  deadlineLabel: "Expires",
+  formatDeadline,
+  required: "This question is required.",
+  otherRequired: "Enter a value for Other.",
+  minSelections: (count) => `Choose at least ${count} option${count === 1 ? "" : "s"}.`,
+  maxSelections: (count) => `Choose no more than ${count} option${count === 1 ? "" : "s"}.`,
+  optional: "Optional",
+  moreBelow: "More below",
+  questionCount: (count) => `${count} questions`,
+  collapse: "Collapse",
+  expand: "Expand",
+  selectionHint: (min, max) => {
+    if (min != null && max != null) return `Choose ${min}\u2013${max}.`;
+    if (min != null) return `Choose at least ${min}.`;
+    if (max != null) return `Choose up to ${max}.`;
+    return null;
+  },
+  secretShow: "Show",
+  secretHide: "Hide",
+  secretGenerate: "Generate",
+  secretWillGenerate: "A strong password will be generated",
+  secretUndo: "Undo",
+  secretSaveTo: "Save to",
+  secretSaveToOptions: { user: "Only me", task: "This task", workspace: "This workspace" },
+  secretVaultHint: (saveTo, vault) => vault ? `Saves to the ${vault} vault` : saveTo === "user" ? "Saves to your private vault" : saveTo === "task" ? "Saves to this task" : "Saves to the workspace vault",
+  secretSaveToDowngraded: (requested, actual) => `You can't save to ${SAVE_TO_IN_SENTENCE[requested]}, so it will be saved to ${SAVE_TO_IN_SENTENCE[actual]}.`,
+  secretLooksLike: (example) => `Looks like ${example}`,
+  secretPatternWarning: (looksLike) => looksLike ? `This doesn't look like ${looksLike}. You can still send it.` : "This doesn't match the expected format. You can still send it.",
+  secretSaved: (vaultName, itemName) => `Saved to ${vaultName} \u203A ${itemName}`
+};
+function answersFromDrafts(questions, drafts, messageOverrides = {}) {
+  const messages = { ...defaultHumanInputFormMessages, ...messageOverrides };
+  const answers = [];
+  const errors = {};
+  for (const question of questions) {
+    if (question.kind === "secret") continue;
+    const draft = drafts[question.id] ?? emptyDraft();
+    const values = question.kind === "text" ? draft.values.filter(Boolean) : draft.values;
+    const other = draft.otherSelected ? draft.other : "";
+    const hasOther = Boolean(other.trim());
+    const supplied = values.length + (hasOther ? 1 : 0);
+    if (question.kind !== "text" && draft.otherSelected && !hasOther) {
+      errors[question.id] = messages.otherRequired;
+      continue;
+    }
+    if (question.required && supplied === 0) {
+      errors[question.id] = messages.required;
+      continue;
+    }
+    if (question.kind !== "text") {
+      const min = question.validation?.minSelections;
+      const max = question.kind === "single_select" ? 1 : question.validation?.maxSelections;
+      if (min != null && supplied < min) {
+        errors[question.id] = messages.minSelections(min);
+        continue;
+      }
+      if (max != null && supplied > max) {
+        errors[question.id] = messages.maxSelections(max);
+        continue;
+      }
+    }
+    if (supplied > 0) {
+      answers.push({
+        questionId: question.id,
+        values,
+        ...hasOther ? { other } : {}
+      });
+    }
+  }
+  return { answers, errors };
+}
+function initialDrafts(questions) {
+  return Object.fromEntries(questions.map((question) => [question.id, emptyDraft()]));
+}
+function emptyDraft() {
+  return { values: [], other: "", otherSelected: false };
+}
+function formatDeadline(value) {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  const ms = date.getTime() - Date.now();
+  if (ms <= 0) return "deadline passed";
+  const minutes = Math.round(ms / 6e4);
+  if (minutes < 1) return "in under a minute";
+  if (minutes < 60) return `in ${minutes}m`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 48) return `in ${hours}h`;
+  return date.toLocaleString();
+}
+function humanInputHeading(questions, messages) {
+  const single = questions.length === 1 ? questions[0] : null;
+  return {
+    title: single ? single.label ?? single.prompt : messages.title,
+    description: single ? single.label ? single.prompt : single.helpText ?? null : messages.description || null
+  };
+}
+var SECRET_SAVE_TO_ORDER = [
+  "user",
+  "task",
+  "workspace"
+];
+function secretAutocomplete(spec) {
+  if (spec.autocomplete && spec.autocomplete !== "current-password") return spec.autocomplete;
+  if (spec.fieldKind === "totp") return "one-time-code";
+  if (spec.allowGenerate || spec.generate) return "new-password";
+  return "current-password";
+}
+function secretInputMode(spec) {
+  return secretAutocomplete(spec) === "one-time-code" ? "numeric" : void 0;
+}
+function secretConcealed(spec) {
+  return spec.fieldKind !== "text";
+}
+function secretCanGenerate(spec) {
+  return Boolean(spec.allowGenerate || spec.generate) && spec.fieldKind !== "totp";
+}
+function secretFieldLabel(spec) {
+  const field = spec.field?.trim() || "password";
+  if (spec.fieldKind === "totp" && field.toLowerCase() === "password") return "One-time code";
+  if (spec.itemType === "api_key" && field.toLowerCase() === "password") return "API key";
+  if (spec.itemType === "note" && field.toLowerCase() === "password") return "Note";
+  const words = field.replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function resolveSecretSaveTo(spec, allowed = SECRET_SAVE_TO_ORDER) {
+  const requested = spec.saveTo ?? "user";
+  const options = SECRET_SAVE_TO_ORDER.filter((target) => allowed.includes(target));
+  if (options.includes(requested)) {
+    return { requested, initial: requested, downgraded: false, options };
+  }
+  if (options.length === 0) {
+    return { requested, initial: requested, downgraded: false, options: [requested] };
+  }
+  return { requested, initial: options[0], downgraded: true, options };
+}
+function secretVaultForTarget(spec, saveTo) {
+  return spec.vault && saveTo === (spec.saveTo ?? "user") ? spec.vault : null;
+}
+function secretPatternMismatch(pattern, value) {
+  if (!pattern || !value) return false;
+  let expression;
+  try {
+    expression = new RegExp(pattern, "u");
+  } catch {
+    try {
+      expression = new RegExp(pattern);
+    } catch {
+      return false;
+    }
+  }
+  return !expression.test(value);
+}
+function secretAnswerFromReading(question, reading, messageOverrides = {}) {
+  const messages = { ...defaultHumanInputFormMessages, ...messageOverrides };
+  const value = reading.generate ? null : reading.value || null;
+  if (!reading.generate && value === null) {
+    return question.required ? { error: messages.required } : null;
+  }
+  const username = reading.username?.trim() || null;
+  const secretAnswer = {
+    questionId: question.id,
+    ...reading.generate ? { generate: reading.generate } : { value },
+    ...username ? { username } : {},
+    saveTo: reading.saveTo
+  };
+  return { answer: { questionId: question.id, values: [] }, secretAnswer };
+}
+function secretAnswerLabel(result, messageOverrides = {}) {
+  const messages = { ...defaultHumanInputFormMessages, ...messageOverrides };
+  return messages.secretSaved(result.vaultName, result.itemName);
+}
+
+// src/timeline/notice-presentation.ts
+function noticeIsResolvedApproval(item) {
+  return Boolean(item.resolvedAt && item.text.startsWith("Approval needed"));
+}
+function noticeDisplayText(item) {
+  return noticeIsResolvedApproval(item) ? "You responded to this approval." : item.text;
+}
+function noticeTone(item) {
+  return item.tone === "failed" ? "failed" : item.tone === "waiting" && !item.resolvedAt ? "waiting" : "neutral";
+}
+function recordedWaitSummaryText(item, now = /* @__PURE__ */ new Date()) {
+  const agents = item.waitingAgents ?? 0;
+  const target = agents > 0 ? ` for ${agents} ${agents === 1 ? "agent" : "agents"}` : "";
+  const waitedMs = item.waitEndedAt ? durationBetween(item.occurredAt, item.waitEndedAt) : void 0;
+  if (waitedMs !== void 0) return `Waited${target} \xB7 ${formatElapsed(waitedMs)}`;
+  const started = new Date(item.occurredAt);
+  const since = started.toDateString() === now.toDateString() ? formatClockTime(item.occurredAt) : started.toLocaleString(void 0, { dateStyle: "medium", timeStyle: "short" });
+  return `${item.waitEndedAt ? "Waited" : "Waiting"}${target} \xB7 since ${since}`;
+}
+
+// src/timeline/question-nav-model.ts
+var QUESTION_NAV_HIDDEN_PX = 24;
+var QUESTION_NAV_MARGIN_PX = 12;
+function questionNavTarget(prompts, view) {
+  const middle = view.top + view.height / 2;
+  const prompt = [...prompts].reverse().find((candidate) => candidate.top <= middle);
+  if (!prompt) return null;
+  if (prompt.top >= view.top - QUESTION_NAV_HIDDEN_PX || prompt.bottom > view.top) return null;
+  return prompt.key;
+}
+
+// src/timeline/focus-sequence.ts
+function itemSequences(item) {
+  const sources = item.sourceEvents ?? ("annotationSource" in item && item.annotationSource ? [item.annotationSource] : []);
+  return sources.map((source) => source.sequence);
+}
+function timelineGroupSequences(group) {
+  if (group.kind === "item") return itemSequences(group.item);
+  if (group.kind === "turn") return group.groups.flatMap(timelineGroupSequences);
+  return [
+    ...group.items.flatMap((item) => itemSequences(item)),
+    ...group.work?.details.flatMap(timelineGroupSequences) ?? []
+  ];
+}
+function timelineGroupIndexAtSequence(groups, sequence) {
+  let landing = -1;
+  for (let index = 0; index < groups.length; index += 1) {
+    const sequences = timelineGroupSequences(groups[index]);
+    if (sequences.length === 0) continue;
+    if (sequences.includes(sequence)) return index;
+    if (Math.min(...sequences) <= sequence) landing = index;
+  }
+  return landing;
+}
+
+export {
+  sandboxCommandExitCode,
+  parseExecBannerSessionId,
+  stripExecBanner,
+  execTruncated,
+  isExecSessionLostBanner,
+  looksBinary,
+  controlCaret,
+  v4aToGitFileDiff,
+  parseFreeformApplyPatch,
+  applyPatchOps,
+  applyPatchOpsFromToolItem,
+  isApplyPatch,
+  parseToolArgs,
+  tailPeek,
+  unwrapMcpOutput,
+  screenshotDataUrl,
+  retainedScreenshotMetadata,
+  generatedImageReceipt,
+  retainedToolResultImages,
+  mediaPreviewFact,
+  rawTypeOf,
+  createToolRegistry,
+  BUILT_IN_TURN_SUMMARY_FACET_IDS,
+  formatElapsed,
+  createTurnSummaryContext,
+  BUILT_IN_TURN_SUMMARY_FACETS,
+  resolveTurnSummaryFacets,
+  formatDurationFacet,
+  selectTurnSummaryFacets,
+  durationBetween,
+  compactedLandmarkCount,
+  clusterIsSettled,
+  flattenActivityItems,
+  isPreparingWork,
+  readableWorkHasDetails,
+  readableWorkStatus,
+  readableWorkDefaultOpen,
+  readableWorkShowsPreview,
+  rollingActivityItem,
+  withComputePreview,
+  truncatePreview,
+  execPresentation,
+  writeStdinPresentation,
+  pathBasename,
+  pathDirname,
+  applyPatchPresentation,
+  webSearchPresentation,
+  genericToolIconKind,
+  askPresentation,
+  runOnPresentation,
+  genericToolPresentation,
+  toolSearchQuery,
+  parseDisclosedTools,
+  toolSearchPreview,
+  parseSearchHits,
+  presentedToolKind,
+  toolRowPresentation,
+  GENIE_PREPARING_PHRASES,
+  GENIE_WAITING_PHRASES,
+  defaultHumanInputFormMessages,
+  answersFromDrafts,
+  initialDrafts,
+  emptyDraft,
+  formatDeadline,
+  humanInputHeading,
+  SECRET_SAVE_TO_ORDER,
+  secretAutocomplete,
+  secretInputMode,
+  secretConcealed,
+  secretCanGenerate,
+  secretFieldLabel,
+  resolveSecretSaveTo,
+  secretVaultForTarget,
+  secretPatternMismatch,
+  secretAnswerFromReading,
+  secretAnswerLabel,
+  noticeIsResolvedApproval,
+  noticeDisplayText,
+  noticeTone,
+  recordedWaitSummaryText,
+  QUESTION_NAV_HIDDEN_PX,
+  QUESTION_NAV_MARGIN_PX,
+  questionNavTarget,
+  timelineGroupSequences,
+  timelineGroupIndexAtSequence
+};
+//# sourceMappingURL=chunk-ADWCLI4G.js.map