@exoscient/control-panel 0.1.0

package/dist/task-detail.browser.js

@@ -0,0 +1,2709 @@
+var require = function(name) { if (name === 'react') return window.React; if (name === 'react/jsx-runtime') { var jsx = function(type, props, key) { props = props || {}; if (key !== undefined) props.key = key; var children = props.children; var nextProps = Object.assign({}, props); delete nextProps.children; return Array.isArray(children) ? window.React.createElement.apply(window.React, [type, nextProps].concat(children)) : window.React.createElement(type, nextProps, children); }; return { jsx: jsx, jsxs: jsx, Fragment: window.React.Fragment }; } throw new Error('Unsupported external ' + name); };
+"use strict";
+var ExoscientCpLibBundle = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined") return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // src/TaskDetail.tsx
+  var import_react2 = __require("react");
+
+  // src/browser-icons.tsx
+  var import_react = __toESM(__require("react"), 1);
+  function icon(label, children) {
+    return function BrowserIcon(props) {
+      return import_react.default.createElement(
+        "svg",
+        {
+          viewBox: "0 0 24 24",
+          width: "1em",
+          height: "1em",
+          fill: "none",
+          stroke: "currentColor",
+          strokeWidth: "2",
+          strokeLinecap: "round",
+          strokeLinejoin: "round",
+          role: "img",
+          "aria-label": label,
+          ...props
+        },
+        children
+      );
+    };
+  }
+  var Check = icon("granted", [
+    import_react.default.createElement("path", { key: "a", d: "M20 6 9 17l-5-5" })
+  ]);
+  var CircleX = icon("denied", [
+    import_react.default.createElement("circle", { key: "a", cx: "12", cy: "12", r: "10" }),
+    import_react.default.createElement("path", { key: "b", d: "m15 9-6 6" }),
+    import_react.default.createElement("path", { key: "c", d: "m9 9 6 6" })
+  ]);
+  var Hourglass = icon("waiting", [
+    import_react.default.createElement("path", { key: "a", d: "M5 22h14" }),
+    import_react.default.createElement("path", { key: "b", d: "M5 2h14" }),
+    import_react.default.createElement("path", { key: "c", d: "M17 22v-4.2a4 4 0 0 0-1.2-2.8L13 12l2.8-3a4 4 0 0 0 1.2-2.8V2" }),
+    import_react.default.createElement("path", { key: "d", d: "M7 2v4.2A4 4 0 0 0 8.2 9L11 12l-2.8 3A4 4 0 0 0 7 17.8V22" })
+  ]);
+  var Maximize2 = icon("maximize", [
+    import_react.default.createElement("path", { key: "a", d: "M15 3h6v6" }),
+    import_react.default.createElement("path", { key: "b", d: "m21 3-7 7" }),
+    import_react.default.createElement("path", { key: "c", d: "M9 21H3v-6" }),
+    import_react.default.createElement("path", { key: "d", d: "m3 21 7-7" })
+  ]);
+  var Minimize2 = icon("minimize", [
+    import_react.default.createElement("path", { key: "a", d: "M4 14h6v6" }),
+    import_react.default.createElement("path", { key: "b", d: "m10 14-7 7" }),
+    import_react.default.createElement("path", { key: "c", d: "M20 10h-6V4" }),
+    import_react.default.createElement("path", { key: "d", d: "m14 10 7-7" })
+  ]);
+  var PanelBottomClose = icon("minimize panel", [
+    import_react.default.createElement("rect", { key: "a", x: "3", y: "3", width: "18", height: "18", rx: "2" }),
+    import_react.default.createElement("path", { key: "b", d: "M3 15h18" }),
+    import_react.default.createElement("path", { key: "c", d: "m9 10 3 3 3-3" })
+  ]);
+  var PanelBottomOpen = icon("restore panel", [
+    import_react.default.createElement("rect", { key: "a", x: "3", y: "3", width: "18", height: "18", rx: "2" }),
+    import_react.default.createElement("path", { key: "b", d: "M3 15h18" }),
+    import_react.default.createElement("path", { key: "c", d: "m9 13 3-3 3 3" })
+  ]);
+  var Paperclip = icon("attachment", [
+    import_react.default.createElement("path", { key: "a", d: "m21.44 11.05-9.19 9.19a6 6 0 0 1-8.49-8.49l9.19-9.19a4 4 0 0 1 5.66 5.66l-9.2 9.19a2 2 0 0 1-2.83-2.83l8.49-8.48" })
+  ]);
+  var RefreshCw = icon("refresh", [
+    import_react.default.createElement("path", { key: "a", d: "M3 12a9 9 0 0 1 15-6.7L21 8" }),
+    import_react.default.createElement("path", { key: "b", d: "M21 3v5h-5" }),
+    import_react.default.createElement("path", { key: "c", d: "M21 12a9 9 0 0 1-15 6.7L3 16" }),
+    import_react.default.createElement("path", { key: "d", d: "M3 21v-5h5" })
+  ]);
+  var Send = icon("send", [
+    import_react.default.createElement("path", { key: "a", d: "m22 2-7 20-4-9-9-4Z" }),
+    import_react.default.createElement("path", { key: "b", d: "M22 2 11 13" })
+  ]);
+  var Square = icon("stop", [
+    import_react.default.createElement("rect", { key: "a", x: "6", y: "6", width: "12", height: "12", rx: "1" })
+  ]);
+  var Waypoints = icon("trace", [
+    import_react.default.createElement("circle", { key: "a", cx: "12", cy: "4.5", r: "2.5" }),
+    import_react.default.createElement("path", { key: "b", d: "m10.2 6.3-3.9 3.9" }),
+    import_react.default.createElement("circle", { key: "c", cx: "4.5", cy: "12", r: "2.5" }),
+    import_react.default.createElement("path", { key: "d", d: "m6.3 13.8 3.9 3.9" }),
+    import_react.default.createElement("circle", { key: "e", cx: "12", cy: "19.5", r: "2.5" }),
+    import_react.default.createElement("path", { key: "f", d: "m13.8 17.7 3.9-3.9" }),
+    import_react.default.createElement("circle", { key: "g", cx: "19.5", cy: "12", r: "2.5" }),
+    import_react.default.createElement("path", { key: "h", d: "m17.7 10.2-3.9-3.9" })
+  ]);
+  var X = icon("close", [
+    import_react.default.createElement("path", { key: "a", d: "M18 6 6 18" }),
+    import_react.default.createElement("path", { key: "b", d: "m6 6 12 12" })
+  ]);
+  var Share2 = icon("share", [
+    import_react.default.createElement("circle", { key: "a", cx: "18", cy: "5", r: "3" }),
+    import_react.default.createElement("circle", { key: "b", cx: "6", cy: "12", r: "3" }),
+    import_react.default.createElement("circle", { key: "c", cx: "18", cy: "19", r: "3" }),
+    import_react.default.createElement("line", { key: "d", x1: "8.59", y1: "13.51", x2: "15.42", y2: "17.49" }),
+    import_react.default.createElement("line", { key: "e", x1: "15.41", y1: "6.51", x2: "8.59", y2: "10.49" })
+  ]);
+  var Trash2 = icon("delete", [
+    import_react.default.createElement("path", { key: "a", d: "M3 6h18" }),
+    import_react.default.createElement("path", { key: "b", d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6" }),
+    import_react.default.createElement("path", { key: "c", d: "M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2" }),
+    import_react.default.createElement("line", { key: "d", x1: "10", y1: "11", x2: "10", y2: "17" }),
+    import_react.default.createElement("line", { key: "e", x1: "14", y1: "11", x2: "14", y2: "17" })
+  ]);
+  var ChevronLeft = icon("previous", [
+    import_react.default.createElement("path", { key: "a", d: "m15 18-6-6 6-6" })
+  ]);
+  var ChevronRight = icon("next", [
+    import_react.default.createElement("path", { key: "a", d: "m9 18 6-6-6-6" })
+  ]);
+  var ClipboardList = icon("tasks", [
+    import_react.default.createElement("rect", { key: "a", x: "8", y: "2", width: "8", height: "4", rx: "1", ry: "1" }),
+    import_react.default.createElement("path", { key: "b", d: "M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2" }),
+    import_react.default.createElement("path", { key: "c", d: "M12 11h4" }),
+    import_react.default.createElement("path", { key: "d", d: "M12 16h4" }),
+    import_react.default.createElement("path", { key: "e", d: "M8 11h.01" }),
+    import_react.default.createElement("path", { key: "f", d: "M8 16h.01" })
+  ]);
+  var Filter = icon("filter", [
+    import_react.default.createElement("path", { key: "a", d: "M22 3H2l8 9.46V19l4 2v-8.54L22 3z" })
+  ]);
+  var Menu = icon("menu", [
+    import_react.default.createElement("line", { key: "a", x1: "4", y1: "6", x2: "20", y2: "6" }),
+    import_react.default.createElement("line", { key: "b", x1: "4", y1: "12", x2: "20", y2: "12" }),
+    import_react.default.createElement("line", { key: "c", x1: "4", y1: "18", x2: "20", y2: "18" })
+  ]);
+  var Plus = icon("add", [
+    import_react.default.createElement("path", { key: "a", d: "M5 12h14" }),
+    import_react.default.createElement("path", { key: "b", d: "M12 5v14" })
+  ]);
+
+  // src/client-actions.ts
+  function isReloadClientAppAction(action) {
+    return isObject(action) && action.type === "reloadClientApp" && typeof action.id === "string" && action.id.trim().length > 0;
+  }
+  function isUserDecisionAction(action) {
+    return isObject(action) && action.type === "userDecision" && typeof action.id === "string" && action.id.trim().length > 0 && typeof action.prompt === "string" && Array.isArray(action.options);
+  }
+  function userDecisionSelectionMode(action) {
+    return action.selectionMode === "multiple" ? "multiple" : "single";
+  }
+  function userDecisionAllowsOther(action) {
+    if (typeof action.other === "boolean") return action.other;
+    if (isObject(action.other)) return action.other.enabled !== false;
+    return false;
+  }
+  function userDecisionOtherLabel(action) {
+    return isObject(action.other) && typeof action.other.label === "string" && action.other.label.trim() ? action.other.label.trim() : "Other";
+  }
+  function userDecisionOtherPlaceholder(action) {
+    return isObject(action.other) && typeof action.other.placeholder === "string" ? action.other.placeholder : "";
+  }
+  function externalContinuation(action) {
+    return isObject(action.continuation) && action.continuation.kind === "externalContinuation" ? action.continuation : null;
+  }
+  function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+  }
+
+  // src/result.ts
+  var ownerHeadings = ["Owner Result", "Owner Message", "Owner Summary", "Result"];
+  var technicalHeadings = [
+    "Technical Change Summary",
+    "Technical Summary",
+    "Change Summary",
+    "What changed",
+    "Changed",
+    "Changes",
+    "Verification",
+    "Verified",
+    "Tests",
+    "Deployment",
+    "Known issues",
+    "Skipped checks"
+  ];
+  function splitAgentResult(text) {
+    const normalized = text.trim();
+    if (!normalized) return { owner: "", technical: "" };
+    const ownerHeading = findFirstResultHeading(normalized, ownerHeadings);
+    const technicalHeading = findFirstResultHeading(
+      normalized,
+      technicalHeadings,
+      ownerHeading ? ownerHeading.contentStart : 0
+    );
+    if (ownerHeading && technicalHeading && ownerHeading.index <= technicalHeading.index) {
+      return {
+        owner: normalized.slice(ownerHeading.contentStart, technicalHeading.index).trim(),
+        technical: normalized.slice(technicalHeading.contentStart).trim()
+      };
+    }
+    if (technicalHeading) {
+      return {
+        owner: normalized.slice(0, technicalHeading.index).trim(),
+        technical: normalized.slice(technicalHeading.contentStart).trim()
+      };
+    }
+    if (ownerHeading) {
+      return { owner: normalized.slice(ownerHeading.contentStart).trim(), technical: "" };
+    }
+    return { owner: normalized, technical: "" };
+  }
+  function findFirstResultHeading(text, headings, minIndex = 0) {
+    return headings.flatMap((heading) => findResultHeadings(text, heading)).filter((heading) => heading.index >= minIndex).sort((left, right) => left.index - right.index)[0] ?? null;
+  }
+  function findResultHeadings(text, heading) {
+    const escapedHeading = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const matches = [];
+    const blockPattern = new RegExp(`(^|\\n)\\s*(?:#{1,6}\\s*)?\\*{0,2}${escapedHeading}\\*{0,2}:?\\s*(?:\\n|$)`, "gi");
+    collectHeadingMatches(text, blockPattern, matches);
+    const lineInlinePattern = new RegExp(`(^|\\n)\\s*(?:#{1,6}\\s*)?\\*{0,2}${escapedHeading}\\*{0,2}:\\s*`, "gi");
+    collectHeadingMatches(text, lineInlinePattern, matches);
+    if (heading !== "Result") {
+      const markdownInlinePattern = new RegExp(`(^|\\s)(#{1,6}\\s+)\\*{0,2}${escapedHeading}\\*{0,2}:?\\s+`, "gi");
+      collectHeadingMatches(text, markdownInlinePattern, matches);
+    }
+    return dedupeHeadingMatches(matches);
+  }
+  function collectHeadingMatches(text, pattern, matches) {
+    for (const match of text.matchAll(pattern)) {
+      const prefix = match[1] ?? "";
+      matches.push({
+        index: match.index + prefix.length,
+        contentStart: match.index + match[0].length
+      });
+    }
+  }
+  function dedupeHeadingMatches(matches) {
+    const seen = /* @__PURE__ */ new Set();
+    return matches.filter((match) => {
+      const key = `${match.index}:${match.contentStart}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+
+  // src/trace.ts
+  function buildTraceItems(events) {
+    const items = [];
+    let assistantBuffer = "";
+    let assistantAt = "";
+    function flushAssistant() {
+      if (assistantBuffer) {
+        items.push({ kind: "assistant", at: assistantAt, text: assistantBuffer });
+        assistantBuffer = "";
+        assistantAt = "";
+      }
+    }
+    for (const rawEvent of events) {
+      const event = normalizeTraceEvent(rawEvent);
+      if (event.type === "assistant-delta") {
+        assistantAt ||= event.at;
+        assistantBuffer += event.message;
+        continue;
+      }
+      if (event.type === "assistant-message") {
+        if (!assistantBuffer) {
+          items.push({ kind: "assistant", at: event.at, text: event.message });
+        }
+        continue;
+      }
+      if (event.type === "assistant") {
+        flushAssistant();
+        items.push({ kind: "assistant", at: event.at, text: event.message });
+        continue;
+      }
+      flushAssistant();
+      if (event.type === "codex-event" || isCodexJsonEvent(event)) {
+        const item = parseCodexEvent(event);
+        if (item) items.push(item);
+        continue;
+      }
+      if (event.type === "turn-completed") {
+        items.push(parseTurnCompleted(event));
+        continue;
+      }
+      if (event.type === "thread") {
+        items.push({ kind: "status", at: event.at, text: "Conversation thread started.", raw: readableJson(event.message) });
+        continue;
+      }
+      if (event.type === "status") {
+        items.push({ kind: "status", at: event.at, text: event.message });
+        continue;
+      }
+      if (event.type === "output") {
+        items.push({ kind: "output", at: event.at, stream: event.stream, text: event.message });
+        continue;
+      }
+      if (event.type === "tokens") {
+        items.push({ kind: "tokens", at: event.at, text: tokenUsageText(parseJson(event.message)), raw: readableJson(event.message) });
+        continue;
+      }
+      if (event.type === "error") {
+        items.push({ kind: "error", at: event.at, text: plainError(event.message), raw: readableJson(event.message) });
+        continue;
+      }
+      if (event.type === "result") {
+        items.push({ kind: "result", at: event.at, text: event.message });
+        continue;
+      }
+      items.push({ kind: "raw", at: event.at, label: event.type, text: readableJson(event.message) });
+    }
+    flushAssistant();
+    return compactTraceItems(items);
+  }
+  function traceItemMatchesFilter(item, filters) {
+    if (filters.length === 0) return true;
+    return filters.includes(traceItemCategory(item));
+  }
+  function latestContextPressure(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+      const pressure = contextPressureFromUsage(tokenUsageFromEvent(normalizeTraceEvent(events[index])));
+      if (pressure) return pressure;
+    }
+    return null;
+  }
+  function traceItemCategory(item) {
+    if (item.kind === "assistant") return "narration";
+    if (item.kind === "file" || item.kind === "tool") return "coding";
+    if (item.kind === "command" || item.kind === "output") return "shell";
+    if (item.kind === "tokens") return "tokens";
+    if (item.kind === "status" || item.kind === "result") return "status";
+    if (item.kind === "error") return "errors";
+    return "raw";
+  }
+  function normalizeTraceEvent(event) {
+    const source = isObject2(event) ? event : {};
+    const messageValue = valueAtAny(source, ["message", "Message", "text", "Text", "payload", "Payload", "data", "Data"]);
+    const message = traceMessageFromValue(messageValue, source);
+    const traceLine = parseTraceLine(message);
+    const explicitTimestamp = firstString(
+      stringValue(source, "at"),
+      stringValue(source, "At"),
+      stringValue(source, "timestamp"),
+      stringValue(source, "Timestamp"),
+      stringValue(source, "time"),
+      stringValue(source, "Time"),
+      stringValue(source, "createdAt"),
+      stringValue(source, "CreatedAt")
+    );
+    const explicitType = firstString(
+      stringValue(source, "type"),
+      stringValue(source, "Type"),
+      stringValue(source, "kind"),
+      stringValue(source, "Kind")
+    );
+    const lineEvent = traceLine && (!explicitType || explicitType === "event") ? eventFromTraceLine(traceLine) : null;
+    return {
+      type: lineEvent?.type ?? explicitType ?? "event",
+      at: explicitTimestamp ?? traceLine?.at ?? "",
+      stream: lineEvent?.stream ?? firstString(stringValue(source, "stream"), stringValue(source, "Stream")),
+      message: lineEvent?.message ?? message
+    };
+  }
+  function parseTraceLine(message) {
+    const match = message.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2}))\s+#\d+\s+([A-Za-z0-9._/-]+)(?:\s+([\s\S]*))?$/);
+    if (!match) return null;
+    const payloadText = match[3]?.trim() ?? "";
+    const payload = parseJson(payloadText);
+    return { at: match[1], label: match[2], payloadText, payload };
+  }
+  function eventFromTraceLine(line) {
+    const payloadMessage = objectValue(line.payload, "message");
+    if (line.label === "agent.notification" && payloadMessage) {
+      return { type: "codex-event", at: line.at, message: stringifyCompact(payloadMessage) ?? line.payloadText };
+    }
+    if (line.payload && (stringValue(line.payload, "method") || stringValue(line.payload, "type"))) {
+      return { type: "codex-event", at: line.at, message: stringifyCompact(line.payload) ?? line.payloadText };
+    }
+    if (line.label === "agent.stderr" || line.label === "agent.stdout") {
+      return {
+        type: "output",
+        at: line.at,
+        stream: line.label === "agent.stderr" ? "stderr" : "stdout",
+        message: firstString(stringValue(line.payload, "line"), line.payloadText) ?? ""
+      };
+    }
+    if (line.label.includes("error") || line.label.includes("failed")) {
+      return { type: "error", at: line.at, message: firstString(stringValue(line.payload, "message"), line.payloadText, titleFromTraceLabel(line.label)) ?? titleFromTraceLabel(line.label) };
+    }
+    return {
+      type: "status",
+      at: line.at,
+      message: firstString(stringValue(line.payload, "message"), titleFromTraceLabel(line.label)) ?? titleFromTraceLabel(line.label)
+    };
+  }
+  function titleFromTraceLabel(label) {
+    const text = label.replace(/[._/-]+/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/\s+/g, " ").trim();
+    return text ? `${text.charAt(0).toLocaleUpperCase()}${text.slice(1)}.` : "Trace event.";
+  }
+  function traceMessageFromValue(value, source) {
+    if (typeof value === "string") return value;
+    if (value !== void 0) return stringifyCompact(value) ?? "";
+    return stringifyCompact(source) ?? "";
+  }
+  function valueAtAny(value, keys) {
+    if (!isObject2(value)) return void 0;
+    for (const key of keys) {
+      const child = value[key];
+      if (child !== void 0 && child !== null) return child;
+    }
+    return void 0;
+  }
+  function parseCodexEvent(event) {
+    const json = parseJson(event.message);
+    const cliType = stringValue(json, "type");
+    const method = stringValue(json, "method") || (cliType ? cliType.replace(/\./g, "/") : void 0) || event.stream || "AI agent event";
+    const params = objectValue(json, "params") ?? json;
+    const item = objectValue(params, "item") || objectValue(params, "entry") || objectValue(json, "item") || params || json;
+    const itemType = stringValue(item, "type") || stringValue(item, "kind") || "";
+    const title = titleFromMethod(method, itemType);
+    const raw = readableJson(event.message);
+    if (method === "item/completed" && itemType === "agent_message") {
+      return {
+        kind: "assistant",
+        at: event.at,
+        text: stringValue(item, "text") ?? stringValue(item, "message") ?? ""
+      };
+    }
+    if (method.includes("error")) {
+      return { kind: "error", at: event.at, text: plainError(event.message), raw };
+    }
+    if (method === "configWarning") {
+      return {
+        kind: "status",
+        at: event.at,
+        text: firstString(stringValue(params, "summary"), stringValue(params, "details"), "Configuration warning.") ?? "Configuration warning.",
+        raw
+      };
+    }
+    if (method === "thread/started") {
+      const thread = objectValue(params, "thread");
+      const cliVersion = stringValue(thread, "cliVersion");
+      return {
+        kind: "status",
+        at: event.at,
+        text: `Thread started${cliVersion ? ` with AI agent runtime ${cliVersion}` : ""}.`,
+        raw
+      };
+    }
+    if (method === "thread/status/changed") {
+      const status = objectValue(params, "status");
+      return {
+        kind: "status",
+        at: event.at,
+        text: `Thread status: ${stringValue(status, "type") ?? "updated"}.`,
+        raw
+      };
+    }
+    if (method === "thread/tokenUsage/updated") {
+      return {
+        kind: "tokens",
+        at: event.at,
+        text: tokenUsageText(objectValue(params, "tokenUsage")),
+        raw
+      };
+    }
+    if (method === "turn/started") {
+      const turn = objectValue(params, "turn");
+      return {
+        kind: "status",
+        at: event.at,
+        text: `Turn ${stringValue(turn, "status") ?? "started"}.`,
+        raw
+      };
+    }
+    if (method === "turn/diff/updated") {
+      return {
+        kind: "file",
+        at: event.at,
+        title: "Diff updated",
+        text: stringValue(params, "diff"),
+        raw
+      };
+    }
+    if (method === "item/commandExecution/outputDelta") {
+      return parseCommandOutputDelta(event.at, params, raw);
+    }
+    if (method === "item/fileChange/outputDelta") {
+      return {
+        kind: "file",
+        at: event.at,
+        title: "File change output",
+        text: stringValue(params, "delta"),
+        raw
+      };
+    }
+    if (method === "rawResponseItem/completed") {
+      return parseRawResponseItem(event.at, item, raw);
+    }
+    if (isCommandEvent(method, itemType, item)) {
+      return {
+        kind: "command",
+        at: event.at,
+        title: itemType === "commandExecution" ? "Command Execution" : title,
+        itemId: stringValue(item, "id") ?? stringValue(params, "itemId"),
+        command: firstString(
+          stringValue(item, "command"),
+          stringValue(item, "cmd"),
+          stringValue(item, "script"),
+          commandFromToolArguments(item),
+          stringValue(objectValue(item, "args"), "cmd"),
+          stringValue(objectValue(item, "arguments"), "cmd"),
+          stringValue(params, "command")
+        ),
+        output: firstString(
+          stringValue(item, "aggregatedOutput"),
+          stringValue(item, "aggregated_output"),
+          stringValue(item, "output"),
+          stringValue(item, "stdout"),
+          stringValue(item, "stderr"),
+          stringValue(params, "output"),
+          stringValue(params, "delta")
+        ),
+        status: commandStatus(item) ?? statusFromEvent(method, item),
+        raw
+      };
+    }
+    if (isFileEvent(method, itemType, item)) {
+      return {
+        kind: "file",
+        at: event.at,
+        title,
+        path: firstString(
+          stringValue(item, "path"),
+          stringValue(item, "file"),
+          stringValue(item, "filename"),
+          pathFromChanges(item),
+          stringValue(objectValue(item, "changes"), "path")
+        ),
+        text: firstString(fileChangesText(item), stringValue(item, "text"), stringValue(item, "summary"), stringValue(params, "delta")),
+        raw
+      };
+    }
+    if (isToolEvent(method, itemType, item)) {
+      return {
+        kind: "tool",
+        at: event.at,
+        title,
+        input: stringifyCompact(
+          valueAt(item, "input") ?? valueAt(item, "arguments") ?? valueAt(item, "args") ?? valueAt(params, "input") ?? valueAt(params, "arguments")
+        ),
+        output: firstString(stringValue(item, "output"), stringValue(item, "result"), stringValue(params, "delta")),
+        status: statusFromEvent(method, item),
+        raw
+      };
+    }
+    if (method.includes("started") || method.includes("completed") || method.includes("turn")) {
+      return { kind: "status", at: event.at, text: title, raw };
+    }
+    return { kind: "raw", at: event.at, label: title, text: raw };
+  }
+  function isCodexJsonEvent(event) {
+    const json = parseJson(event.message);
+    return Boolean(json && (stringValue(json, "type") || stringValue(json, "method")));
+  }
+  function parseRawResponseItem(at, item, raw) {
+    const itemType = stringValue(item, "type") ?? "response item";
+    const name = stringValue(item, "name");
+    if (itemType === "function_call") {
+      const args = parseJson(stringValue(item, "arguments") ?? "");
+      if (isCommandToolName(name) && !args) return null;
+      return {
+        kind: isCommandToolName(name) ? "command" : "tool",
+        at,
+        title: name ?? "Tool call",
+        command: isCommandToolName(name) ? commandFromArguments(args) : void 0,
+        input: !isCommandToolName(name) ? stringifyCompact(args ?? stringValue(item, "arguments")) : void 0,
+        status: stringValue(item, "status") ?? "called",
+        raw
+      };
+    }
+    if (itemType === "function_call_output") {
+      const output = stringValue(item, "output");
+      if (!output) return null;
+      return {
+        kind: "tool",
+        at,
+        title: "Tool output",
+        output,
+        status: outputStatus(output),
+        raw
+      };
+    }
+    if (itemType === "custom_tool_call") {
+      const toolName = name ?? "Custom tool";
+      return {
+        kind: toolName === "apply_patch" ? "file" : "tool",
+        at,
+        title: toolName,
+        text: toolName === "apply_patch" ? stringValue(item, "input") : void 0,
+        input: toolName === "apply_patch" ? void 0 : stringValue(item, "input"),
+        status: stringValue(item, "status") ?? "called",
+        raw
+      };
+    }
+    if (itemType === "custom_tool_call_output") {
+      return {
+        kind: "tool",
+        at,
+        title: "Custom tool output",
+        output: decodedToolOutput(stringValue(item, "output")),
+        status: outputStatus(stringValue(item, "output")),
+        raw
+      };
+    }
+    if (itemType === "message") {
+      const text = contentText(valueAt(item, "content"));
+      if (!text) return null;
+      return {
+        kind: stringValue(item, "role") === "assistant" ? "assistant" : "status",
+        at,
+        text,
+        raw
+      };
+    }
+    if (itemType === "reasoning") {
+      const summary = contentText(valueAt(item, "summary"));
+      return {
+        kind: "status",
+        at,
+        text: summary ? `Reasoning summary: ${summary}` : "Reasoning step completed.",
+        raw
+      };
+    }
+    return { kind: "raw", at, label: titleFromMethod("rawResponseItem/completed", itemType), text: raw };
+  }
+  function parseCommandOutputDelta(at, params, raw) {
+    const itemId = stringValue(params, "itemId");
+    const delta = stringValue(params, "delta") ?? "";
+    const parsedDelta = parseJson(delta);
+    if (parsedDelta) {
+      const stdout = stringValue(parsedDelta, "stdout");
+      const stderr = stringValue(parsedDelta, "stderr");
+      return {
+        kind: "command",
+        at,
+        title: "Command Execution",
+        itemId,
+        command: commandFromDelta(parsedDelta),
+        output: firstString(
+          stringValue(parsedDelta, "output"),
+          stdout || stderr ? `${stdout ?? ""}${stderr ?? ""}` : void 0
+        ),
+        status: commandDeltaStatus(parsedDelta),
+        raw
+      };
+    }
+    return {
+      kind: "command",
+      at,
+      title: "Command Execution",
+      itemId,
+      output: delta,
+      raw
+    };
+  }
+  function parseTurnCompleted(event) {
+    const json = parseJson(event.message);
+    const usage = objectValue(objectValue(json, "params"), "usage") || objectValue(json, "usage");
+    const usageText = usage ? ` Token use: ${stringifyCompact(usage)}.` : "";
+    return {
+      kind: usage ? "tokens" : "status",
+      at: event.at,
+      text: `Turn completed.${usageText}`,
+      raw: readableJson(event.message)
+    };
+  }
+  function compactTraceItems(items) {
+    const compacted = [];
+    for (const item of items) {
+      const previous = compacted[compacted.length - 1];
+      if (previous?.kind === "output" && item.kind === "output" && previous.stream === item.stream) {
+        previous.text += item.text;
+        continue;
+      }
+      if (item.kind === "command") {
+        const command = findCommandToMerge(compacted, item);
+        if (command) {
+          command.title = item.title || command.title;
+          command.command = item.command ?? command.command;
+          command.output = item.command ? item.output ?? command.output : `${command.output ?? ""}${item.output ?? ""}`;
+          command.status = item.status ?? command.status;
+          command.raw = item.raw ?? command.raw;
+          continue;
+        }
+      }
+      if (previous?.kind === "command" && item.kind === "command" && previous.title === item.title && !item.command) {
+        previous.output = `${previous.output ?? ""}${item.output ?? ""}`;
+        previous.status = item.status ?? previous.status;
+        previous.raw = item.raw ?? previous.raw;
+        continue;
+      }
+      if (previous?.kind === "file" && item.kind === "file" && previous.title === item.title && !item.path) {
+        if (previous.text === item.text) {
+          previous.raw = item.raw ?? previous.raw;
+          continue;
+        }
+        previous.text = `${previous.text ?? ""}${item.text ?? ""}`;
+        previous.raw = item.raw ?? previous.raw;
+        continue;
+      }
+      compacted.push(item);
+    }
+    return compacted;
+  }
+  function findCommandToMerge(items, item) {
+    if (item.itemId) {
+      for (let index = items.length - 1; index >= 0; index -= 1) {
+        const candidate = items[index];
+        if (candidate.kind === "command" && candidate.itemId === item.itemId) return candidate;
+      }
+    }
+    const previous = items[items.length - 1];
+    if (previous?.kind === "command" && !item.command && previous.title === item.title) return previous;
+    return null;
+  }
+  function isCommandEvent(method, itemType, item) {
+    const text = `${method} ${itemType} ${stringValue(item, "name") ?? ""}`.toLowerCase();
+    return text.includes("command") || text.includes("shell") || text.includes("exec");
+  }
+  function isFileEvent(method, itemType, item) {
+    const text = `${method} ${itemType} ${stringValue(item, "name") ?? ""}`.toLowerCase();
+    return text.includes("file") || text.includes("patch") || text.includes("apply_patch") || Boolean(stringValue(item, "path"));
+  }
+  function isToolEvent(method, itemType, item) {
+    const text = `${method} ${itemType} ${stringValue(item, "name") ?? ""}`.toLowerCase();
+    return text.includes("tool") || Boolean(stringValue(item, "name"));
+  }
+  function titleFromMethod(method, itemType) {
+    const base = itemType || method.split("/").filter(Boolean).pop() || method;
+    return base.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
+  }
+  function statusFromEvent(method, item) {
+    return firstString(
+      stringValue(item, "status"),
+      method.includes("completed") ? "completed" : void 0,
+      method.includes("started") ? "started" : void 0
+    );
+  }
+  function commandStatus(item) {
+    const status = stringValue(item, "status");
+    const exitCode = valueAt(item, "exitCode") ?? valueAt(item, "exit_code");
+    const durationMs = valueAt(item, "durationMs") ?? valueAt(item, "duration_ms");
+    const parts = [
+      status,
+      typeof exitCode === "number" ? `exit ${exitCode}` : void 0,
+      typeof durationMs === "number" ? `${durationMs} ms` : void 0
+    ].filter(Boolean);
+    return parts.length > 0 ? parts.join(" / ") : void 0;
+  }
+  function commandFromToolArguments(item) {
+    return commandFromArguments(parseJson(stringValue(item, "arguments") ?? ""));
+  }
+  function commandFromArguments(args) {
+    return firstString(
+      stringValue(args, "cmd"),
+      stringValue(args, "command"),
+      stringValue(args, "chars")
+    );
+  }
+  function commandFromDelta(delta) {
+    const command = valueAt(delta, "command");
+    if (Array.isArray(command)) return command.map((part) => typeof part === "string" ? part : String(part)).join(" ");
+    return firstString(stringValue(delta, "command"), stringValue(delta, "cmd"));
+  }
+  function commandDeltaStatus(delta) {
+    const exitCode = valueAt(delta, "exitCode") ?? valueAt(delta, "exit_code");
+    const status = stringValue(delta, "status");
+    const parts = [
+      status,
+      typeof exitCode === "number" ? `exit ${exitCode}` : void 0
+    ].filter(Boolean);
+    return parts.length > 0 ? parts.join(" / ") : void 0;
+  }
+  function fileChangesText(item) {
+    const changes = valueAt(item, "changes");
+    if (!Array.isArray(changes)) return void 0;
+    const seen = /* @__PURE__ */ new Set();
+    return changes.map((change) => {
+      if (!isObject2(change)) return "";
+      const path = stringValue(change, "path");
+      const kind = stringValue(change, "kind");
+      const diff = stringValue(change, "diff");
+      const text = [path, kind, diff].filter(Boolean).join("\n");
+      if (!text || seen.has(text)) return "";
+      seen.add(text);
+      return text;
+    }).filter(Boolean).join("\n\n");
+  }
+  function pathFromChanges(item) {
+    const changes = valueAt(item, "changes");
+    if (!Array.isArray(changes)) return void 0;
+    const paths = [...new Set(changes.map((change) => isObject2(change) ? stringValue(change, "path") : void 0).filter(Boolean))];
+    return paths.length === 1 ? paths[0] : void 0;
+  }
+  function tokenUsageFromEvent(event) {
+    const json = parseJson(event.message);
+    if (!json) return void 0;
+    if (event.type === "tokens") {
+      return normalizeTokenUsage(json);
+    }
+    if (event.type !== "codex-event" && !isCodexJsonEvent(event)) {
+      return void 0;
+    }
+    const cliType = stringValue(json, "type");
+    const method = stringValue(json, "method") || (cliType ? cliType.replace(/\./g, "/") : void 0) || event.stream;
+    if (method !== "thread/tokenUsage/updated") return void 0;
+    const params = objectValue(json, "params") ?? json;
+    return normalizeTokenUsage(params);
+  }
+  function normalizeTokenUsage(tokenUsage) {
+    return objectValue(tokenUsage, "tokenUsage") ?? tokenUsage;
+  }
+  function contextPressureFromUsage(tokenUsage) {
+    const usage = normalizeTokenUsage(tokenUsage);
+    const lastUsage = objectValue(usage, "last");
+    const last = lastUsage ?? usage;
+    const contextWindow = numberValue(usage, "modelContextWindow") ?? numberValue(usage, "model_context_window");
+    const lastInputTokens = numberValue(last, "inputTokens") ?? numberValue(last, "input_tokens");
+    const flatInputTokens = lastUsage ? void 0 : numberValue(usage, "inputTokens") ?? numberValue(usage, "input_tokens");
+    const usedTokens = lastInputTokens ?? flatInputTokens;
+    if (!usedTokens || !contextWindow || contextWindow <= 0) return null;
+    const ratio = usedTokens / contextWindow;
+    const percent = Math.round(ratio * 100);
+    const tone = ratio >= 0.9 ? "critical" : ratio >= 0.75 ? "high" : ratio >= 0.5 ? "medium" : "low";
+    const source = lastUsage ? "last-input" : "reported-input";
+    return {
+      usedTokens,
+      contextWindow,
+      ratio,
+      percent,
+      tone,
+      source,
+      label: `Latest request context: ${percent}% (${usedTokens.toLocaleString()} / ${contextWindow.toLocaleString()} input tokens).`
+    };
+  }
+  function tokenUsageText(tokenUsage) {
+    const usage = normalizeTokenUsage(tokenUsage);
+    const total = objectValue(usage, "total") ?? usage;
+    const last = objectValue(usage, "last") ?? usage;
+    const contextWindow = numberValue(usage, "modelContextWindow") ?? numberValue(usage, "model_context_window");
+    const totalTokens = numberValue(total, "totalTokens") ?? numberValue(total, "total_tokens");
+    const inputTokens = numberValue(last, "inputTokens") ?? numberValue(last, "input_tokens");
+    const cachedInputTokens = numberValue(last, "cachedInputTokens") ?? numberValue(last, "cached_input_tokens");
+    const outputTokens = numberValue(last, "outputTokens") ?? numberValue(last, "output_tokens");
+    const reasoningOutputTokens = numberValue(last, "reasoningOutputTokens") ?? numberValue(last, "reasoning_output_tokens");
+    const parts = [
+      totalTokens !== void 0 ? `${totalTokens.toLocaleString()} total tokens` : void 0,
+      inputTokens !== void 0 ? `${inputTokens.toLocaleString()} input` : void 0,
+      cachedInputTokens !== void 0 ? `${cachedInputTokens.toLocaleString()} cached input` : void 0,
+      outputTokens !== void 0 ? `${outputTokens.toLocaleString()} output` : void 0,
+      reasoningOutputTokens !== void 0 ? `${reasoningOutputTokens.toLocaleString()} reasoning` : void 0,
+      contextWindow !== void 0 ? `${contextWindow.toLocaleString()} context` : void 0
+    ].filter(Boolean);
+    return parts.length > 0 ? `Token usage: ${parts.join(" / ")}.` : "Token usage updated.";
+  }
+  function contentText(value) {
+    if (!Array.isArray(value)) return void 0;
+    return value.map((entry) => isObject2(entry) ? firstString(stringValue(entry, "text"), stringValue(entry, "summary")) : void 0).filter(Boolean).join("\n");
+  }
+  function decodedToolOutput(value) {
+    const json = parseJson(value ?? "");
+    return firstString(
+      stringValue(json, "output"),
+      stringValue(json, "message"),
+      value
+    );
+  }
+  function outputStatus(value) {
+    const metadata = objectValue(parseJson(value ?? ""), "metadata");
+    const exitCode = valueAt(metadata, "exit_code");
+    return typeof exitCode === "number" ? `exit ${exitCode}` : void 0;
+  }
+  function isCommandToolName(name) {
+    return name === "exec_command" || name === "write_stdin";
+  }
+  function readableJson(value) {
+    try {
+      return JSON.stringify(JSON.parse(value), null, 2);
+    } catch {
+      return value;
+    }
+  }
+  function plainError(value) {
+    const json = parseJson(value);
+    return firstString(
+      stringValue(json, "message"),
+      stringValue(json, "error"),
+      stringValue(objectValue(json, "error"), "message"),
+      value
+    ) ?? value;
+  }
+  function parseJson(value) {
+    try {
+      const parsed = JSON.parse(value);
+      return isObject2(parsed) ? parsed : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  function objectValue(value, key) {
+    if (!isObject2(value)) return void 0;
+    const child = value[key];
+    return isObject2(child) ? child : void 0;
+  }
+  function valueAt(value, key) {
+    return isObject2(value) ? value[key] : void 0;
+  }
+  function numberValue(value, key) {
+    const child = valueAt(value, key);
+    return typeof child === "number" && Number.isFinite(child) ? child : void 0;
+  }
+  function stringValue(value, key) {
+    if (!isObject2(value)) return void 0;
+    const child = value[key];
+    return typeof child === "string" && child.length > 0 ? child : void 0;
+  }
+  function firstString(...values) {
+    return values.find((value) => value && value.length > 0);
+  }
+  function stringifyCompact(value) {
+    if (value === void 0 || value === null) return void 0;
+    if (typeof value === "string") return value;
+    try {
+      return JSON.stringify(value, null, 2);
+    } catch {
+      return String(value);
+    }
+  }
+  function isObject2(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+
+  // src/TaskDetail.tsx
+  var import_jsx_runtime = __require("react/jsx-runtime");
+  function TaskDetail({
+    task,
+    maximized,
+    minimized,
+    platformStatus,
+    elapsedNow,
+    traceLoadingTurnId,
+    selectedTraceTurn,
+    selectedTraceTurnIndex,
+    turnRefs,
+    followUp,
+    followUpAttachments,
+    followUpSubmitting,
+    followUpError = null,
+    interruptMessage,
+    interruptSubmitting,
+    steerSubmitting,
+    taskCommandStatus = null,
+    refreshSubmitting = false,
+    onClose,
+    onMinimize,
+    onRestore,
+    onToggleMaximized,
+    onRefresh,
+    onOpenTrace,
+    onCloseTrace,
+    onSubmitFollowUp,
+    onSubmitSteer,
+    onFollowUpChange,
+    onFollowUpAttachmentsChange,
+    uploadAttachment,
+    onSubmitInterrupt,
+    onInterruptMessageChange,
+    onSubmitClientAction,
+    currentUserId,
+    shareTask,
+    unshareTask
+  }) {
+    const [followUpAttachmentsProcessing, setFollowUpAttachmentsProcessing] = (0, import_react2.useState)(false);
+    const [accessDetailsOpen, setAccessDetailsOpen] = (0, import_react2.useState)(false);
+    const [shareUser, setShareUser] = (0, import_react2.useState)("");
+    const [shareLevel, setShareLevel] = (0, import_react2.useState)("read");
+    const [shareSubmitting, setShareSubmitting] = (0, import_react2.useState)(false);
+    const [shareError, setShareError] = (0, import_react2.useState)(null);
+    const [clientActionSubmitting, setClientActionSubmitting] = (0, import_react2.useState)(false);
+    const [clientActionError, setClientActionError] = (0, import_react2.useState)(null);
+    const previousTaskStateRef = (0, import_react2.useRef)(null);
+    const taskInputPlaceholder = "Send instructions to the AI agent";
+    const taskQueued = task ? isTaskQueued(task) : false;
+    (0, import_react2.useEffect)(() => {
+      setAccessDetailsOpen(false);
+      setShareUser("");
+      setShareLevel("read");
+      setShareError(null);
+      setClientActionError(null);
+    }, [task?.id]);
+    const canManageSharing = Boolean(task && shareTask && unshareTask && (!currentUserId || task.createdByUserId === currentUserId));
+    async function submitShare(event) {
+      event.preventDefault();
+      if (!task || !shareTask || !shareUser.trim() || shareSubmitting) return;
+      setShareSubmitting(true);
+      setShareError(null);
+      try {
+        const updated = await shareTask(task.id, {
+          userId: shareUser.trim(),
+          email: shareUser.includes("@") ? shareUser.trim() : void 0,
+          accessLevel: shareLevel
+        });
+        if (updated) setShareUser("");
+        else setShareError("Task sharing failed.");
+      } catch (error) {
+        setShareError(error instanceof Error ? error.message : "Task sharing failed.");
+      } finally {
+        setShareSubmitting(false);
+      }
+    }
+    async function removeShare(userId) {
+      if (!task || !unshareTask || shareSubmitting) return;
+      setShareSubmitting(true);
+      setShareError(null);
+      try {
+        const updated = await unshareTask(task.id, userId);
+        if (!updated) setShareError("Task sharing failed.");
+      } catch (error) {
+        setShareError(error instanceof Error ? error.message : "Task sharing failed.");
+      } finally {
+        setShareSubmitting(false);
+      }
+    }
+    (0, import_react2.useEffect)(() => {
+      const previous = previousTaskStateRef.current;
+      if (!task) {
+        previousTaskStateRef.current = null;
+        return;
+      }
+      if (previous?.id === task.id && previous.busy && !isTaskBusy(task) && isTaskFinishedStatus(task.status)) {
+        notifyTaskFinished(task);
+      }
+      previousTaskStateRef.current = { id: task.id, busy: isTaskBusy(task), status: task.status };
+    }, [task]);
+    (0, import_react2.useEffect)(() => {
+      if (!task || !isReloadClientAppAction(task.clientAction)) return;
+      if (typeof window === "undefined") return;
+      const action = task.clientAction;
+      const key = `exo-client-action:${task.id}:${action.id}`;
+      try {
+        if (window.sessionStorage.getItem(key)) return;
+        window.sessionStorage.setItem(key, (/* @__PURE__ */ new Date()).toISOString());
+      } catch {
+      }
+      const delay = typeof action.delayMs === "number" && Number.isFinite(action.delayMs) ? Math.max(0, Math.min(3e4, action.delayMs)) : 0;
+      const timer = window.setTimeout(() => window.location.reload(), delay);
+      return () => window.clearTimeout(timer);
+    }, [task?.id, task?.clientAction]);
+    async function submitClientAction(action, message) {
+      const continuation = externalContinuation(action);
+      if (!task || !onSubmitClientAction || !continuation?.token || clientActionSubmitting) return;
+      setClientActionSubmitting(true);
+      setClientActionError(null);
+      try {
+        const updated = await onSubmitClientAction(task.id, { actionId: action.id, token: continuation.token, message });
+        if (!updated) setClientActionError("Decision could not be submitted.");
+      } catch (error) {
+        setClientActionError(error instanceof Error ? error.message : "Decision could not be submitted.");
+      } finally {
+        setClientActionSubmitting(false);
+      }
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+      task && minimized && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "task-detail-dock", role: "region", "aria-label": "Minimized task detail", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "task-detail-dock-main", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", { title: formatTaskFullTitle(task), children: formatTaskDetailTitle(task) }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: taskStatusContent(task, platformStatus) })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "task-detail-dock-actions", children: [
+          onRefresh && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { className: "icon-button", onClick: onRefresh, disabled: refreshSubmitting, "aria-label": "Refresh task detail", title: "Refresh", children: refreshSubmitting ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(InlineSpinner, {}) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RefreshCw, { "aria-hidden": "true" }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { className: "icon-button", onClick: onRestore, "aria-label": "Restore task detail", title: "Restore", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PanelBottomOpen, { "aria-hidden": "true" }) }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { className: "icon-button", onClick: onClose, "aria-label": "Close", title: "Close", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(X, { "aria-hidden": "true" }) })
+        ] })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("aside", { className: `drawer${task && !minimized ? " open" : ""}${maximized ? " maximized" : ""}`, "aria-hidden": !task || minimized, children: task && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("header", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "drawer-heading", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "drawer-status-row", children: [
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { children: taskStatusContent(task, platformStatus) }),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                TaskAccessSummary,
+                {
+                  task,
+                  detailsOpen: accessDetailsOpen,
+                  onToggle: () => setAccessDetailsOpen((open) => !open)
+                }
+              )
+            ] }),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "drawer-tools", children: [
+              onRefresh && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { className: "icon-button", onClick: onRefresh, disabled: refreshSubmitting, "aria-label": "Refresh task detail", title: "Refresh", children: refreshSubmitting ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(InlineSpinner, {}) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RefreshCw, { "aria-hidden": "true" }) }),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { className: "icon-button", onClick: onMinimize, "aria-label": "Minimize task detail", title: "Minimize", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PanelBottomClose, { "aria-hidden": "true" }) }),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                "button",
+                {
+                  className: "icon-button",
+                  onClick: onToggleMaximized,
+                  "aria-label": maximized ? "Restore task detail" : "Maximize task detail",
+                  title: maximized ? "Restore" : "Maximize",
+                  children: maximized ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Minimize2, { "aria-hidden": "true" }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Maximize2, { "aria-hidden": "true" })
+                }
+              ),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { className: "icon-button", onClick: onClose, "aria-label": "Close", title: "Close", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(X, { "aria-hidden": "true" }) })
+            ] })
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("h2", { title: formatTaskFullTitle(task), children: formatTaskDetailTitle(task) }),
+          accessDetailsOpen && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TaskDetailDetails, { task }),
+          canManageSharing && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            TaskSharingPanel,
+            {
+              task,
+              shareUser,
+              shareLevel,
+              submitting: shareSubmitting,
+              error: shareError,
+              onShareUserChange: setShareUser,
+              onShareLevelChange: setShareLevel,
+              onSubmit: submitShare,
+              onRemove: removeShare
+            }
+          )
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "drawer-content", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "drawer-body", children: [
+            task.updatePublicationFailures?.length ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TaskUpdatePublicationWarning, { failures: task.updatePublicationFailures }) : null,
+            task.turns.map((turn, index) => {
+              const result = taskTurnResult(task, turn, index);
+              return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+                "article",
+                {
+                  className: "turn",
+                  ref: (element) => {
+                    if (element) {
+                      turnRefs.current.set(turn.id, element);
+                    } else {
+                      turnRefs.current.delete(turn.id);
+                    }
+                  },
+                  children: [
+                    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("section", { className: "turn-panel request-panel", "aria-label": `Request ${index + 1}`, children: [
+                      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TurnTitle, { index, timestamp: turn.createdAt }),
+                      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { children: turn.content })
+                    ] }),
+                    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SteeringMessages, { messages: taskSteeringMessages(task, index) }),
+                    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("section", { className: "turn-panel output-panel", "aria-label": `AI agent output for request ${index + 1}`, children: [
+                      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "turn-title output-title", children: [
+                        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("h3", { children: formatAgentTitle(turn, elapsedNow) }),
+                        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("time", { children: formatCompletionTime(turn) })
+                      ] }),
+                      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "result", children: isTurnQueued(turn) ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "working-result-body", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: `status-text ${statusToneClass(turn.status)}`, children: "Queued" }) }) : isTurnWorking(turn) ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+                        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "working-result-body", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(WorkingIndicator, { label: platformStatus.available ? "Working" : "The platform is down. Wait until it is back up", animate: platformStatus.available }) }),
+                        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "output-panel-actions", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TraceButton, { loading: traceLoadingTurnId === turn.id, onClick: () => onOpenTrace(turn.id) }) })
+                      ] }) : /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+                        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FormattedText, { text: result.owner || "No output recorded." }),
+                        result.technical && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("details", { className: "technical-summary", children: [
+                          /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("summary", { children: [
+                            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "technical-summary-title", children: "Technical summary" }),
+                            /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                              TraceButton,
+                              {
+                                loading: traceLoadingTurnId === turn.id,
+                                onClick: () => onOpenTrace(turn.id),
+                                stopPropagation: true
+                              }
+                            )
+                          ] }),
+                          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "technical-summary-body", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FormattedText, { text: result.technical }) })
+                        ] }),
+                        !result.technical && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "output-panel-actions", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TraceButton, { loading: traceLoadingTurnId === turn.id, onClick: () => onOpenTrace(turn.id) }) }),
+                        index === task.turns.length - 1 && isUserDecisionAction(task.clientAction) && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                          ClientActionPanel,
+                          {
+                            action: task.clientAction,
+                            submitting: clientActionSubmitting,
+                            error: clientActionError,
+                            canSubmit: Boolean(onSubmitClientAction),
+                            onSubmit: (message) => void submitClientAction(task.clientAction, message)
+                          }
+                        )
+                      ] }) })
+                    ] })
+                  ]
+                },
+                turn.id
+              );
+            })
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("form", { className: "drawer-form", onSubmit: followUpAttachmentsProcessing ? (event) => event.preventDefault() : onSubmitFollowUp, children: task.busy ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "interrupt-panel", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "drawer-form-toolbar", children: [
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CommandStatus, { status: taskCommandStatus }),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "drawer-form-buttons", children: [
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { className: "primary icon-action-button", type: "button", disabled: taskQueued || interruptSubmitting || steerSubmitting || !interruptMessage.trim(), onClick: onSubmitSteer, "aria-label": "Send steering message", title: "Steer", children: steerSubmitting ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(InlineSpinner, {}) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Send, { "aria-hidden": "true" }) }),
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { className: "danger icon-action-button", type: "button", disabled: interruptSubmitting || steerSubmitting, onClick: onSubmitInterrupt, "aria-label": "Interrupt task", title: "Interrupt", children: interruptSubmitting ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(InlineSpinner, {}) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Square, { "aria-hidden": "true" }) })
+              ] })
+            ] }),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("textarea", { disabled: taskQueued || interruptSubmitting || steerSubmitting, value: interruptMessage, onChange: (event) => onInterruptMessageChange(event.target.value), placeholder: taskQueued ? "Task is queued" : taskInputPlaceholder })
+          ] }) : /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "drawer-form-toolbar", children: [
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                AttachmentPicker,
+                {
+                  attachments: followUpAttachments,
+                  disabled: followUpSubmitting,
+                  onChange: onFollowUpAttachmentsChange,
+                  onProcessingChange: setFollowUpAttachmentsProcessing,
+                  uploadAttachment,
+                  compact: true
+                }
+              ),
+              followUpError && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "command-status error", role: "alert", children: followUpError }),
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "drawer-form-buttons", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { className: "primary icon-action-button", disabled: followUpAttachmentsProcessing || followUpSubmitting || !followUp.trim(), "aria-label": "Continue task", title: "Continue", children: followUpAttachmentsProcessing || followUpSubmitting ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(InlineSpinner, {}) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Send, { "aria-hidden": "true" }) }) })
+            ] }),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("textarea", { disabled: followUpSubmitting, value: followUp, onChange: (event) => onFollowUpChange(event.target.value), placeholder: taskInputPlaceholder })
+          ] }) }),
+          selectedTraceTurn && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "task-trace-overlay", role: "dialog", "aria-modal": "false", "aria-label": `Trace for request ${selectedTraceTurnIndex + 1}`, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            TracePanel,
+            {
+              turn: selectedTraceTurn,
+              turnIndex: selectedTraceTurnIndex,
+              loading: traceLoadingTurnId === selectedTraceTurn.id && (selectedTraceTurn.trace?.events?.length ?? 0) === 0,
+              onCollapse: onCloseTrace
+            }
+          ) })
+        ] })
+      ] }) })
+    ] });
+  }
+  function TaskUpdatePublicationWarning({ failures }) {
+    const latest = failures[failures.length - 1];
+    const previousCount = failures.length - 1;
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("section", { className: "task-publication-warning", "aria-label": "Task update publication warning", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", { children: "Update publication degraded" }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { children: [
+        latest.updateType,
+        " could not be published. Retry status: ",
+        formatRetryStatus(latest.retryStatus, latest.retryAttempts),
+        ".",
+        previousCount > 0 ? ` ${previousCount} earlier update${previousCount === 1 ? "" : "s"} also failed.` : ""
+      ] })
+    ] });
+  }
+  function ClientActionPanel({
+    action,
+    submitting,
+    error,
+    canSubmit,
+    onSubmit
+  }) {
+    const mode = userDecisionSelectionMode(action);
+    const options = action.options.filter((option) => option && typeof option.id === "string" && typeof option.label === "string");
+    const [selectedIds, setSelectedIds] = (0, import_react2.useState)(() => options[0]?.id ? [options[0].id] : []);
+    const [otherText, setOtherText] = (0, import_react2.useState)("");
+    const allowsOther = userDecisionAllowsOther(action);
+    const continuation = externalContinuation(action);
+    const canContinue = canSubmit && Boolean(continuation?.token) && (selectedIds.length > 0 || allowsOther && Boolean(otherText.trim()));
+    (0, import_react2.useEffect)(() => {
+      setSelectedIds(options[0]?.id ? [options[0].id] : []);
+      setOtherText("");
+    }, [action.id]);
+    function toggleOption(optionId) {
+      if (mode === "single") {
+        setSelectedIds([optionId]);
+        return;
+      }
+      setSelectedIds((current) => current.includes(optionId) ? current.filter((id) => id !== optionId) : [...current, optionId]);
+    }
+    function submit(event) {
+      event.preventDefault();
+      if (!canContinue || submitting) return;
+      onSubmit(`User decision result:
+${JSON.stringify({
+        clientActionResult: {
+          type: "userDecision",
+          actionId: action.id,
+          selectedOptionIds: selectedIds,
+          otherText: allowsOther && otherText.trim() ? otherText.trim() : null,
+          submittedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      }, null, 2)}`);
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("form", { className: "client-action-panel", onSubmit: submit, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "client-action-heading", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", { children: action.prompt }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "client-action-options", children: options.map((option) => {
+        const checked = selectedIds.includes(option.id);
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("label", { className: "client-action-option", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            "input",
+            {
+              type: mode === "multiple" ? "checkbox" : "radio",
+              name: `client-action-${action.id}`,
+              checked,
+              onChange: () => toggleOption(option.id)
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", { children: option.label }),
+            option.description && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("small", { children: option.description })
+          ] })
+        ] }, option.id);
+      }) }),
+      allowsOther && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("label", { className: "client-action-other", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: userDecisionOtherLabel(action) }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "textarea",
+          {
+            value: otherText,
+            onChange: (event) => setOtherText(event.target.value),
+            placeholder: userDecisionOtherPlaceholder(action),
+            rows: 2
+          }
+        )
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "client-action-footer", children: [
+        error && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "command-status error", role: "alert", children: error }),
+        !continuation?.token && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "command-status muted", children: "Waiting for continuation access." }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { className: "primary icon-action-button", type: "submit", disabled: !canContinue || submitting, "aria-label": "Submit decision", title: "Submit decision", children: submitting ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(InlineSpinner, {}) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Check, { "aria-hidden": "true" }) })
+      ] })
+    ] });
+  }
+  function formatRetryStatus(status, attempts) {
+    const label = status.trim().replace(/[-_]+/g, " ") || "unknown";
+    return attempts > 0 ? `${label}, ${attempts} attempt${attempts === 1 ? "" : "s"}` : label;
+  }
+  function TaskSharingPanel({
+    task,
+    shareUser,
+    shareLevel,
+    submitting,
+    error,
+    onShareUserChange,
+    onShareLevelChange,
+    onSubmit,
+    onRemove
+  }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("section", { className: "task-sharing-panel", "aria-label": "Task sharing", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("form", { className: "task-sharing-form", onSubmit, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Share2, { "aria-hidden": "true" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "input",
+          {
+            value: shareUser,
+            onChange: (event) => onShareUserChange(event.target.value),
+            placeholder: "User ID or email",
+            disabled: submitting
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("select", { value: shareLevel, onChange: (event) => onShareLevelChange(event.target.value), disabled: submitting, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("option", { value: "read", children: "Read only" }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("option", { value: "full", children: "Full" })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "submit", disabled: submitting || !shareUser.trim(), children: submitting ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(InlineSpinner, {}) : "Share" })
+      ] }),
+      error && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "task-sharing-error", children: error }),
+      (task.shares?.length ?? 0) > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "task-share-list", children: task.shares.map((share) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "task-share-row", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: share.displayName || share.email || share.userId }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", { children: share.accessLevel === "full" ? "Full" : "Read only" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", onClick: () => onRemove(share.userId), disabled: submitting, "aria-label": `Remove ${share.displayName || share.email || share.userId}`, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Trash2, { "aria-hidden": "true" }) })
+      ] }, share.userId)) })
+    ] });
+  }
+  function TaskDetailDetails({ task }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "task-detail-details", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TaskDetailMeta, { task }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TaskAccessChips, { task })
+    ] });
+  }
+  function TaskDetailMeta({ task }) {
+    const startedAt = task.startedAt ?? task.createdAt;
+    const completedAt = task.completedAt ?? null;
+    const updatedAt = task.updatedAt ?? completedAt ?? startedAt;
+    const turnsCount = task.turns.length;
+    const codexModel = normalizeMetadataValue(task.codexModel);
+    const codexReasoningEffort = normalizeMetadataValue(task.codexReasoningEffort);
+    const creator = formatCreatorName(task);
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "drawer-meta", "aria-label": "Task metadata", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "muted", children: "ID" }),
+        "\xA0",
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("code", { children: task.id })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "muted", children: "Creator" }),
+        "\xA0",
+        creator
+      ] }),
+      codexModel && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "muted", children: "Model" }),
+        "\xA0",
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("code", { children: codexModel })
+      ] }),
+      codexReasoningEffort && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "muted", children: "Effort" }),
+        "\xA0",
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("code", { children: codexReasoningEffort })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "muted", children: "Started" }),
+        "\xA0",
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("time", { dateTime: startedAt, children: formatDateTime(startedAt) })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "muted", children: "Updated" }),
+        "\xA0",
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("time", { dateTime: updatedAt, children: formatDateTime(updatedAt) })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "muted", children: "Turns" }),
+        "\xA0",
+        turnsCount
+      ] })
+    ] });
+  }
+  function formatCreatorName(task) {
+    return normalizeMetadataValue(task.createdByUserDisplayName) ?? normalizeMetadataValue(task.createdByUserEmail) ?? normalizeMetadataValue(task.createdByUserId) ?? "Unknown";
+  }
+  function normalizeMetadataValue(value) {
+    const normalized = value?.trim();
+    return normalized ? normalized : null;
+  }
+  function TraceButton({
+    loading,
+    onClick,
+    stopPropagation = false
+  }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+      "button",
+      {
+        className: `trace-open-button${loading ? " loading" : ""}`,
+        type: "button",
+        onClick: (event) => {
+          if (stopPropagation) event.stopPropagation();
+          onClick();
+        },
+        disabled: loading,
+        "aria-busy": loading,
+        children: [
+          loading ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(InlineSpinner, {}) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Waypoints, { "aria-hidden": "true" }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: loading ? "Loading trace" : "Trace" })
+        ]
+      }
+    );
+  }
+  function TaskAccessSummary({
+    task,
+    detailsOpen,
+    onToggle
+  }) {
+    const counts = accessRequestCounts(groupedAccessRequests(task.accessRequests ?? []));
+    const total = counts.granted + counts.released + counts.waiting + counts.denied;
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "button",
+      {
+        className: `task-access-summary${total === 0 ? " task-details-summary" : ""}`,
+        type: "button",
+        onClick: onToggle,
+        "aria-expanded": detailsOpen,
+        "aria-label": accessSummaryLabel(counts, detailsOpen),
+        title: detailsOpen ? "Hide access details" : "Show access details",
+        children: total === 0 ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "task-details-summary-label", children: "Details" }) : /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+          counts.granted > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TaskAccessSummaryItem, { state: "granted", count: counts.granted }),
+          counts.released > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TaskAccessSummaryItem, { state: "released", count: counts.released }),
+          counts.waiting > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TaskAccessSummaryItem, { state: "waiting", count: counts.waiting }),
+          counts.denied > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TaskAccessSummaryItem, { state: "denied", count: counts.denied })
+        ] })
+      }
+    );
+  }
+  function TaskAccessSummaryItem({ state, count }) {
+    const Icon = accessRequestIcon(state);
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { className: `task-access-summary-item ${state}`, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Icon, { className: "task-access-summary-icon", "aria-hidden": "true" }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: count })
+    ] });
+  }
+  function TaskAccessChips({ task }) {
+    const requests = groupedAccessRequests(task.accessRequests ?? []);
+    if (requests.length === 0) {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "task-access-chips", "aria-label": "Agent access", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "task-access-chip muted", children: "No access requests" }) });
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "task-access-chips", "aria-label": "Agent access", children: requests.map((request, index) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TaskAccessChip, { request, index }, accessRequestKey(request, index))) });
+  }
+  function TaskAccessChip({ request, index }) {
+    const state = accessRequestState(request);
+    const label = accessRequestLabel(request);
+    const Icon = accessRequestIcon(state);
+    const occurrences = accessRequestOccurrences(request);
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+      "span",
+      {
+        className: `task-access-chip ${state}`,
+        title: `${label} ${request.level} access to ${request.target} at ${formatDateTime(accessRequestTime(request))}${occurrences > 1 ? ` (${occurrences} requests)` : ""}`,
+        "aria-label": `${label} ${request.target} ${request.level}`,
+        "data-access-index": index,
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Icon, { className: "task-access-icon", "aria-hidden": "true" }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { className: "task-access-text", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", { children: request.target }),
+            " ",
+            request.level,
+            occurrences > 1 ? ` x${occurrences}` : ""
+          ] })
+        ]
+      }
+    );
+  }
+  function groupedAccessRequests(requests) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const request of requests) {
+      const key = `${request.target.trim().toLowerCase()}\0${request.level.trim().toLowerCase()}`;
+      groups.set(key, [...groups.get(key) ?? [], request]);
+    }
+    return Array.from(groups.values()).map((group) => {
+      const ordered = [...group].sort((left, right) => Date.parse(left.requestedAt) - Date.parse(right.requestedAt));
+      const active = ordered.filter((request) => accessRequestState(request) !== "released");
+      const selected = latestAccessRequest(active.length > 0 ? active : ordered);
+      return {
+        ...selected,
+        occurrences: ordered.length,
+        firstRequestedAt: ordered[0]?.requestedAt,
+        lastRequestedAt: ordered[ordered.length - 1]?.requestedAt
+      };
+    }).sort((left, right) => Date.parse(accessRequestTime(right)) - Date.parse(accessRequestTime(left)));
+  }
+  function latestAccessRequest(requests) {
+    return requests.reduce((latest, request) => Date.parse(accessRequestTime(request)) >= Date.parse(accessRequestTime(latest)) ? request : latest, requests[0]);
+  }
+  function accessRequestState(request) {
+    if (request.status?.toLowerCase() === "released" || request.releasedAt) return "released";
+    if (request.granted) return "granted";
+    const status = `${request.status ?? ""} ${request.message ?? ""}`.toLowerCase();
+    if (status.includes("wait") || status.includes("queue")) return "waiting";
+    return "denied";
+  }
+  function accessRequestIcon(state) {
+    return state === "granted" || state === "released" ? Check : state === "waiting" ? Hourglass : Square;
+  }
+  function accessRequestCounts(requests) {
+    return requests.reduce(
+      (counts, request) => {
+        counts[accessRequestState(request)] += 1;
+        return counts;
+      },
+      { granted: 0, released: 0, waiting: 0, denied: 0 }
+    );
+  }
+  function accessSummaryLabel(counts, detailsOpen) {
+    const parts = [
+      counts.granted > 0 ? `${counts.granted} granted` : null,
+      counts.released > 0 ? `${counts.released} released` : null,
+      counts.waiting > 0 ? `${counts.waiting} waiting` : null,
+      counts.denied > 0 ? `${counts.denied} denied` : null
+    ].filter(Boolean);
+    if (parts.length === 0) return `${detailsOpen ? "Hide" : "Show"} task details`;
+    return `${detailsOpen ? "Hide" : "Show"} access details: ${parts.join(", ")}`;
+  }
+  function accessRequestLabel(request) {
+    const state = accessRequestState(request);
+    return state === "granted" ? "Granted" : state === "released" ? "Released" : state === "waiting" ? "Waiting" : "Denied";
+  }
+  function accessRequestTime(request) {
+    return request.releasedAt ?? request.requestedAt;
+  }
+  function accessRequestOccurrences(request) {
+    return request.occurrences ?? 1;
+  }
+  function accessRequestKey(request, index) {
+    return request.requestId || `${request.requestedAt}-${request.target}-${request.level}-${index}`;
+  }
+  function AttachmentPicker({
+    attachments,
+    disabled,
+    compact,
+    onChange,
+    onProcessingChange,
+    uploadAttachment
+  }) {
+    const inputRef = (0, import_react2.useRef)(null);
+    const [processingFiles, setProcessingFiles] = (0, import_react2.useState)([]);
+    const hasUploadingAttachments = attachments.some((attachment) => attachment.status === "uploading");
+    const hasFailedAttachments = attachments.some((attachment) => attachment.status === "failed");
+    const hasBlockingAttachments = hasUploadingAttachments || hasFailedAttachments;
+    const isProcessing = processingFiles.length > 0 || hasBlockingAttachments;
+    const preparingCount = Math.max(processingFiles.length, attachments.filter((attachment) => attachment.status === "uploading").length);
+    const statusLabel = hasFailedAttachments && !hasUploadingAttachments && processingFiles.length === 0 ? "Remove failed attachment before sending" : compact ? "Preparing attachments" : `Preparing ${preparingCount} attachment${preparingCount === 1 ? "" : "s"}`;
+    (0, import_react2.useEffect)(() => {
+      onProcessingChange?.(isProcessing);
+    }, [isProcessing, onProcessingChange]);
+    async function addFiles(files) {
+      if (!files || disabled || isProcessing) return;
+      const selectedFiles = Array.from(files).slice(0, 8);
+      const batchId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+      const pendingAttachments = selectedFiles.map((file) => ({
+        name: file.name,
+        contentType: file.type || "text/plain",
+        content: "",
+        uploadId: `pending-${batchId}-${file.name}-${file.size}-${file.lastModified}`,
+        status: "uploading",
+        progress: 0,
+        sizeBytes: file.size
+      }));
+      let nextAttachments = [...attachments, ...pendingAttachments];
+      onChange(nextAttachments);
+      setProcessingFiles(selectedFiles.map((file) => file.name));
+      try {
+        for (let index = 0; index < selectedFiles.length; index += 1) {
+          const file = selectedFiles[index];
+          const pending = pendingAttachments[index];
+          const pendingId = pending.uploadId;
+          const setProgress = (progress) => {
+            nextAttachments = nextAttachments.map((attachment) => attachment.uploadId === pendingId ? { ...attachment, progress } : attachment);
+            onChange(nextAttachments);
+          };
+          try {
+            const attachment = uploadAttachment ? await uploadAttachment(file, setProgress) : await readAttachment(file);
+            nextAttachments = nextAttachments.map((item) => item.uploadId === pendingId ? {
+              ...attachment,
+              name: file.name,
+              contentType: file.type || "text/plain",
+              sizeBytes: file.size,
+              status: "uploaded",
+              progress: 100
+            } : item);
+            onChange(nextAttachments);
+          } catch (error) {
+            nextAttachments = nextAttachments.map((item) => item.uploadId === pendingId ? {
+              ...item,
+              status: "failed",
+              progress: 0,
+              error: error instanceof Error ? error.message : "Upload failed."
+            } : item);
+            onChange(nextAttachments);
+          }
+          setProcessingFiles(selectedFiles.slice(index + 1).map((item) => item.name));
+        }
+      } finally {
+        setProcessingFiles([]);
+        if (inputRef.current) inputRef.current.value = "";
+      }
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: `attachment-picker${compact ? " compact" : ""}`, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("input", { ref: inputRef, type: "file", multiple: true, onChange: (event) => void addFiles(event.target.files), disabled: disabled || isProcessing }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("button", { type: "button", className: "attachment-button", disabled: disabled || isProcessing, onClick: () => inputRef.current?.click(), "aria-label": compact ? "Attach files" : void 0, title: compact ? "Attach files" : void 0, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Paperclip, { "aria-hidden": "true" }),
+        !compact && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: "Attach files" })
+      ] }),
+      isProcessing && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "attachment-status", role: "status", "aria-live": "polite", children: [
+        !hasFailedAttachments && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(InlineSpinner, {}),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: statusLabel })
+      ] }),
+      attachments.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "attachment-list", children: attachments.map((attachment, index) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { className: "attachment-chip", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: attachment.name }),
+        attachment.status === "uploading" && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("small", { children: [
+          Math.max(0, Math.min(100, Math.round(attachment.progress ?? 0))),
+          "%"
+        ] }),
+        attachment.status === "failed" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("small", { children: attachment.error ?? "Upload failed" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { type: "button", onClick: () => onChange(attachments.filter((_, itemIndex) => itemIndex !== index)), "aria-label": `Remove ${attachment.name}`, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(X, { "aria-hidden": "true" }) })
+      ] }, `${attachment.name}-${index}`)) })
+    ] });
+  }
+  function CommandStatus({ status }) {
+    if (!status) {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { "aria-hidden": "true" });
+    }
+    const label = {
+      interrupting: "Requesting interrupt",
+      "interrupt-accepted": "Interrupt accepted",
+      steering: "Sending steering",
+      "steer-accepted": "Steering accepted",
+      failed: "Command was not accepted"
+    }[status];
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: `command-status ${status === "failed" ? "error" : ""}`, role: "status", children: label });
+  }
+  async function readAttachment(file) {
+    const maxAttachmentBytes = 10 * 1024 * 1024;
+    if (file.size > maxAttachmentBytes) {
+      return { content: `[Attachment omitted: ${file.name} is larger than 10 MB.]` };
+    }
+    const dataUrl = await readFileAsDataUrl(file);
+    return { content: dataUrl.split(",", 2)[1] ?? "", contentEncoding: "base64" };
+  }
+  function readFileAsDataUrl(file) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => resolve(String(reader.result));
+      reader.onerror = () => reject(reader.error ?? Error("Unable to read attachment."));
+      reader.readAsDataURL(file);
+    });
+  }
+  function formatTaskDetailTitle(task) {
+    return truncateWords(taskTitleText(task), 15) || formatTaskLabel(task);
+  }
+  function formatTaskFullTitle(task) {
+    return taskTitleText(task) || formatTaskLabel(task);
+  }
+  function formatTaskLabel(task) {
+    return `Task: created: ${formatDateTime(task.createdAt)}, modified: ${formatDateTime(task.updatedAt ?? task.completedAt ?? task.startedAt ?? task.createdAt)}`;
+  }
+  function taskTitleText(task) {
+    return collapseWhitespace(task.turns[0]?.content || task.message);
+  }
+  function truncateWords(value, maxWords) {
+    const words = collapseWhitespace(value).split(" ").filter(Boolean);
+    if (words.length <= maxWords) return words.join(" ");
+    return `${words.slice(0, maxWords).join(" ")}...`;
+  }
+  function isTaskFinishedStatus(status) {
+    const normalized = status.toLocaleLowerCase();
+    return normalized === "closed" || normalized === "failed" || normalized === "error" || normalized === "cancelled" || normalized === "canceled";
+  }
+  function notifyTaskFinished(task) {
+    if (typeof window === "undefined" || !("Notification" in window)) return;
+    const title = taskTitleText(task) || "Task finished";
+    const body = `${capitalize(task.status)}.`;
+    const showNotification = () => {
+      try {
+        new Notification(title, { body, tag: `exoscient-task-${task.id}` });
+      } catch {
+      }
+    };
+    if (Notification.permission === "granted") {
+      showNotification();
+      return;
+    }
+    if (Notification.permission === "default") {
+      void Notification.requestPermission().then((permission) => {
+        if (permission === "granted") showNotification();
+      }).catch(() => {
+      });
+    }
+  }
+  function taskTurnResult(task, turn, index) {
+    const split = splitAgentResult(taskTurnResultText(task, turn, index));
+    const turnTechnical = turn.technicalMessage?.trim();
+    if (turnTechnical) {
+      return {
+        owner: split.owner,
+        technical: turnTechnical
+      };
+    }
+    if (index === task.turns.length - 1 && task.technicalMessage) {
+      return {
+        owner: split.owner || task.ownerMessage || "",
+        technical: task.technicalMessage
+      };
+    }
+    return split;
+  }
+  function taskTurnResultText(task, turn, index) {
+    if (turn.output || turn.error) return turn.output || turn.error || "";
+    if (index === task.turns.length - 1 && (task.ownerMessage || task.technicalMessage)) return task.ownerMessage || task.technicalMessage || "";
+    return index === task.turns.length - 1 ? task.latestResult || "" : "";
+  }
+  function taskSteeringMessages(task, index) {
+    if (index !== task.turns.length - 1) return [];
+    return (task.steeringMessages ?? []).filter((item) => item.message.trim().length > 0);
+  }
+  function collapseWhitespace(value) {
+    return value.trim().replace(/\s+/g, " ");
+  }
+  function SteeringMessages({ messages }) {
+    if (messages.length === 0) return null;
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("section", { className: "turn-panel steering-panel", "aria-label": "Steering messages", children: messages.map((item, index) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "steering-message", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Send, { "aria-hidden": "true" }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "steering-message-title", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: "Steering" }),
+          item.at && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("time", { children: formatDateTime(item.at) })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { children: item.message })
+      ] })
+    ] }, `${item.at ?? "steering"}-${index}`)) });
+  }
+  function TurnTitle({ index, timestamp }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "turn-title", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("h3", { children: [
+        "#",
+        index + 1
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("time", { children: formatDateTime(timestamp) })
+    ] });
+  }
+  function formatAgentTitle(turn, now) {
+    const duration = formatTurnDuration(turn, now);
+    return duration ? `AI agent, ${duration}` : "AI agent";
+  }
+  function taskStatusContent(task, platformStatus) {
+    if (isTaskQueued(task)) {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: `status-text ${statusToneClass(task.status)}`, children: "Queued" });
+    }
+    if (task.busy) {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(WorkingIndicator, { label: platformStatus.available ? "Working" : "The platform is down. Wait until it is back up", animate: platformStatus.available });
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: `status-text ${statusToneClass(task.status)}`, children: taskStatusLabel(task.status) });
+  }
+  function formatCompletionTime(turn) {
+    const completedAt = turn.completedAt ?? turn.trace?.completedAt;
+    return completedAt ? formatDateTime(completedAt) : "In progress";
+  }
+  function formatTurnDuration(turn, now = Date.now()) {
+    const completedAt = turn.completedAt ?? turn.trace?.completedAt;
+    if (!completedAt && !isTurnWorking(turn)) return "";
+    const startedAt = turn.startedAt ?? turn.trace?.startedAt ?? turn.createdAt;
+    const elapsedMs = (completedAt ? new Date(completedAt).getTime() : now) - new Date(startedAt).getTime();
+    if (!Number.isFinite(elapsedMs) || elapsedMs < 0) return "";
+    const totalSeconds = Math.max(1, Math.round(elapsedMs / 1e3));
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor(totalSeconds % 3600 / 60);
+    const seconds = totalSeconds % 60;
+    if (hours > 0) return `${hours}h ${minutes}m`;
+    if (minutes > 0) return `${minutes}m ${seconds}s`;
+    return `${seconds}s`;
+  }
+  function formatDateTime(value) {
+    if (!value) return "";
+    const date = new Date(value);
+    return Number.isFinite(date.getTime()) ? date.toLocaleString() : "";
+  }
+  function isTurnQueued(turn) {
+    return turn.status.trim().toLocaleLowerCase() === "queued";
+  }
+  function isTurnWorking(turn) {
+    const normalized = turn.status.trim().toLocaleLowerCase();
+    return normalized === "running" || normalized === "working" || isTurnQueued(turn);
+  }
+  function isTaskBusy(task) {
+    const normalized = task.status.trim().toLocaleLowerCase();
+    return task.busy || normalized === "running" || normalized === "working" || isTaskQueued(task);
+  }
+  function isTaskQueued(task) {
+    return task.status.trim().toLocaleLowerCase() === "queued";
+  }
+  function capitalize(value) {
+    return value ? `${value.charAt(0).toLocaleUpperCase()}${value.slice(1)}` : value;
+  }
+  function taskStatusLabel(status) {
+    const normalized = status.trim().toLocaleLowerCase();
+    if (normalized === "waiting_for_user_continuation") return "Waiting for user continuation";
+    if (normalized === "waiting_for_external_continuation") return "Waiting for external continuation";
+    if (normalized === "closed") return "Closed";
+    if (normalized === "working" || normalized === "running" || normalized === "in_progress") return "Working";
+    return capitalize(status.replace(/[_-]+/g, " "));
+  }
+  function statusToneClass(status) {
+    const normalized = status.trim().toLocaleLowerCase();
+    if (normalized === "closed") return "status-success";
+    if (normalized === "running" || normalized === "working" || normalized === "queued" || normalized === "in_progress") return "status-active";
+    if (normalized === "failed" || normalized === "error" || normalized === "cancelled" || normalized === "canceled") return "status-danger";
+    return "status-muted";
+  }
+  function WorkingIndicator({ label = "Working", animate = true }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { className: "working-indicator", role: "status", "aria-label": label, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: label }),
+      animate && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { className: "working-dots", "aria-hidden": "true", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {}),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {}),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {})
+      ] })
+    ] });
+  }
+  function InlineSpinner() {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "inline-spinner", "aria-hidden": "true" });
+  }
+  function LoadingState({ label }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "loading-state", role: "status", "aria-live": "polite", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(InlineSpinner, {}),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: label })
+    ] });
+  }
+  function TracePanel({
+    turn,
+    turnIndex,
+    loading,
+    onCollapse
+  }) {
+    const isWorking = isTurnWorking(turn);
+    const [follow, setFollow] = (0, import_react2.useState)(isWorking);
+    const [filters, setFilters] = (0, import_react2.useState)(["narration"]);
+    const scrollRef = (0, import_react2.useRef)(null);
+    const events = turn.trace?.events ?? [];
+    const items = (0, import_react2.useMemo)(() => buildTraceItems(events), [events]);
+    const contextPressure = (0, import_react2.useMemo)(() => latestContextPressure(events), [events]);
+    const visibleItems = (0, import_react2.useMemo)(() => items.filter((item) => traceItemMatchesFilter(item, filters)), [filters, items]);
+    (0, import_react2.useEffect)(() => {
+      if (follow && scrollRef.current) {
+        scrollRef.current.scrollTop = scrollRef.current.scrollHeight;
+      }
+    }, [follow, visibleItems.length, events.length]);
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "trace-shell", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "trace-toolbar", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "trace-toolbar-summary", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { children: [
+            "Request #",
+            turnIndex + 1,
+            " trace - ",
+            events.length,
+            " events"
+          ] }),
+          contextPressure && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: `context-pressure context-pressure-${contextPressure.tone}`, title: contextPressure.label, children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { children: [
+              "Context ",
+              contextPressure.percent,
+              "%"
+            ] }),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "context-pressure-meter", "aria-hidden": "true", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "context-pressure-fill", style: { width: `${Math.min(contextPressure.percent, 100)}%` } }) })
+          ] })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "trace-toolbar-actions", children: [
+          isWorking && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            "button",
+            {
+              className: `trace-toggle-button${follow ? " active" : ""}`,
+              type: "button",
+              onClick: () => setFollow((current) => !current),
+              "aria-pressed": follow,
+              children: "Follow"
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { className: "trace-collapse-button", type: "button", onClick: onCollapse, "aria-label": "Close trace", title: "Close trace", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(X, { "aria-hidden": "true" }) })
+        ] })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "trace-filter-bar", "aria-label": "Trace filters", children: traceFilterOptions.map((option) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        "button",
+        {
+          className: `trace-filter-button${filters.includes(option.value) ? " active" : ""}`,
+          type: "button",
+          onClick: () => setFilters((current) => current.includes(option.value) ? current.filter((item) => item !== option.value) : [...current, option.value]),
+          "aria-pressed": filters.includes(option.value),
+          children: option.label
+        },
+        option.value
+      )) }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "trace-list", ref: scrollRef, children: [
+        loading && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(LoadingState, { label: "Loading trace" }),
+        !loading && items.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { className: "muted", children: "No trace events yet" }),
+        !loading && items.length > 0 && visibleItems.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { className: "muted", children: "No events match this filter" }),
+        visibleItems.map((item, index) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TraceItemView, { item }, `${item.kind}-${item.at}-${index}`))
+      ] })
+    ] });
+  }
+  var traceFilterOptions = [
+    { value: "narration", label: "Assistant Remarks" },
+    { value: "coding", label: "Coding" },
+    { value: "shell", label: "Shell Commands" },
+    { value: "tokens", label: "Token Usage" },
+    { value: "status", label: "Status" },
+    { value: "errors", label: "Errors" },
+    { value: "raw", label: "Raw" }
+  ];
+  function TraceItemView({ item }) {
+    const label = item.kind === "output" ? item.stream ?? item.kind : item.kind === "raw" ? item.label : "title" in item ? item.title : item.kind;
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: `trace-event ${item.kind}`, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "trace-event-header", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: formatDateTime(item.at) || "Unknown time" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", { children: label })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TraceItemBody, { item })
+    ] });
+  }
+  function TraceItemBody({ item }) {
+    if (item.kind === "assistant" || item.kind === "result") {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FormattedText, { text: item.text });
+    }
+    if (item.kind === "command") {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "trace-body", children: [
+        item.status && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { className: "trace-meta", children: item.status }),
+        item.command && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("pre", { className: "trace-command", children: item.command }),
+        item.output && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("pre", { children: item.output }),
+        item.raw && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RawDetails, { text: item.raw })
+      ] });
+    }
+    if (item.kind === "tool") {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "trace-body", children: [
+        item.status && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { className: "trace-meta", children: item.status }),
+        item.input && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("pre", { children: item.input }),
+        item.output && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("pre", { children: item.output }),
+        item.raw && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RawDetails, { text: item.raw })
+      ] });
+    }
+    if (item.kind === "file") {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "trace-body", children: [
+        item.path && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { className: "trace-meta", children: item.path }),
+        item.text && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("pre", { children: item.text }),
+        item.raw && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RawDetails, { text: item.raw })
+      ] });
+    }
+    if (item.kind === "status" || item.kind === "error" || item.kind === "tokens") {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "trace-body", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TraceTextOrJson, { text: item.text }),
+        item.raw && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RawDetails, { text: item.raw })
+      ] });
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TraceTextOrJson, { text: item.text });
+  }
+  function RawDetails({ text }) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("details", { className: "raw-details", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("summary", { children: "Raw event" }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TraceTextOrJson, { text })
+    ] });
+  }
+  function TraceTextOrJson({ text }) {
+    const json = parseTraceJson(text);
+    if (json !== void 0) {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(JsonTree, { value: json });
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("pre", { children: text });
+  }
+  function JsonTree({ value }) {
+    if (Array.isArray(value)) {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("ol", { className: "json-tree json-array", children: value.map((entry, index) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("li", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "json-key", children: index }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(JsonTree, { value: entry })
+      ] }, index)) });
+    }
+    if (isJsonObject(value)) {
+      const entries = Object.entries(value);
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("ul", { className: "json-tree", children: entries.map(([key, entry]) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("li", { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "json-key", children: key }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(JsonTree, { value: entry })
+      ] }, key)) });
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: `json-value ${value === null ? "null" : typeof value}`, children: formatJsonScalar(value) });
+  }
+  function parseTraceJson(text) {
+    const trimmed = text.trim();
+    if (!trimmed || !trimmed.startsWith("{") && !trimmed.startsWith("[")) return void 0;
+    try {
+      return normalizeTraceJson(JSON.parse(trimmed));
+    } catch {
+      return void 0;
+    }
+  }
+  function normalizeTraceJson(value, depth = 0) {
+    if (depth > 6) return value;
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+        try {
+          return normalizeTraceJson(JSON.parse(trimmed), depth + 1);
+        } catch {
+          return value;
+        }
+      }
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return value.map((entry) => normalizeTraceJson(entry, depth + 1));
+    }
+    if (isJsonObject(value)) {
+      return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, normalizeTraceJson(entry, depth + 1)]));
+    }
+    return value;
+  }
+  function formatJsonScalar(value) {
+    if (value === null) return "null";
+    if (typeof value === "string") return value;
+    if (typeof value === "number" || typeof value === "boolean") return String(value);
+    return "";
+  }
+  function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  function FormattedText({ text }) {
+    const blocks = parseMarkdownBlocks(text);
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "formatted-text", children: blocks.map((block, index) => renderMarkdownBlock(block, index)) });
+  }
+  function parseMarkdownBlocks(text) {
+    const lines = text.replace(/\r\n?/g, "\n").split("\n");
+    const blocks = [];
+    let index = 0;
+    while (index < lines.length) {
+      const line = lines[index];
+      if (line.trim() === "") {
+        index += 1;
+        continue;
+      }
+      const fence = line.match(/^```([a-zA-Z0-9_-]+)?\s*$/);
+      if (fence) {
+        const codeLines = [];
+        index += 1;
+        while (index < lines.length && !/^```\s*$/.test(lines[index])) {
+          codeLines.push(lines[index]);
+          index += 1;
+        }
+        if (index < lines.length) index += 1;
+        blocks.push({ type: "code", text: codeLines.join("\n"), language: fence[1] });
+        continue;
+      }
+      const heading = line.match(/^(#{1,6})\s+(.+)$/);
+      if (heading) {
+        blocks.push({ type: "heading", depth: heading[1].length, text: heading[2].trim() });
+        index += 1;
+        continue;
+      }
+      const unordered = line.match(/^\s*[-*]\s+(.+)$/);
+      if (unordered) {
+        const items = [];
+        while (index < lines.length) {
+          const item = lines[index].match(/^\s*[-*]\s+(.+)$/);
+          if (!item) break;
+          items.push(item[1].trim());
+          index += 1;
+        }
+        blocks.push({ type: "unordered-list", items });
+        continue;
+      }
+      const ordered = line.match(/^\s*\d+[.)]\s+(.+)$/);
+      if (ordered) {
+        const items = [];
+        while (index < lines.length) {
+          const item = lines[index].match(/^\s*\d+[.)]\s+(.+)$/);
+          if (!item) break;
+          items.push(item[1].trim());
+          index += 1;
+        }
+        blocks.push({ type: "ordered-list", items });
+        continue;
+      }
+      const paragraphLines = [];
+      while (index < lines.length) {
+        const current = lines[index];
+        if (current.trim() === "" || /^```([a-zA-Z0-9_-]+)?\s*$/.test(current) || /^(#{1,6})\s+(.+)$/.test(current) || /^\s*[-*]\s+(.+)$/.test(current) || /^\s*\d+[.)]\s+(.+)$/.test(current)) {
+          break;
+        }
+        paragraphLines.push(current);
+        index += 1;
+      }
+      blocks.push({ type: "paragraph", text: paragraphLines.join("\n").trimEnd() });
+    }
+    return blocks.length === 0 ? [{ type: "paragraph", text }] : blocks;
+  }
+  function renderMarkdownBlock(block, index) {
+    switch (block.type) {
+      case "code":
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("pre", { className: "code-block", "data-language": block.language, children: block.text }, index);
+      case "heading":
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MarkdownHeading, { depth: block.depth, text: block.text }, index);
+      case "unordered-list":
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("ul", { children: block.items.map((item, itemIndex) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("li", { children: renderInlineMarkdown(item, `u-${index}-${itemIndex}`) }, itemIndex)) }, index);
+      case "ordered-list":
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("ol", { children: block.items.map((item, itemIndex) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("li", { children: renderInlineMarkdown(item, `o-${index}-${itemIndex}`) }, itemIndex)) }, index);
+      case "paragraph":
+        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { children: renderInlineMarkdown(block.text, `p-${index}`) }, index);
+    }
+  }
+  function MarkdownHeading({ depth, text }) {
+    const children = renderInlineMarkdown(text, `h-${depth}-${text}`);
+    if (depth <= 2) return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("h4", { children });
+    if (depth === 3) return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("h5", { children });
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("h6", { children });
+  }
+  function renderInlineMarkdown(text, keyPrefix) {
+    const nodes = [];
+    let index = 0;
+    let nodeIndex = 0;
+    const pushText = (value) => {
+      if (value) nodes.push(value);
+    };
+    while (index < text.length) {
+      if (text[index] === "`") {
+        const end = text.indexOf("`", index + 1);
+        if (end > index + 1) {
+          nodes.push(/* @__PURE__ */ (0, import_jsx_runtime.jsx)("code", { children: text.slice(index + 1, end) }, `${keyPrefix}-code-${nodeIndex++}`));
+          index = end + 1;
+          continue;
+        }
+      }
+      if (text.startsWith("**", index)) {
+        const end = text.indexOf("**", index + 2);
+        if (end > index + 2) {
+          nodes.push(/* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", { children: renderInlineMarkdown(text.slice(index + 2, end), `${keyPrefix}-strong-${nodeIndex}`) }, `${keyPrefix}-strong-${nodeIndex++}`));
+          index = end + 2;
+          continue;
+        }
+      }
+      if (text[index] === "*") {
+        const end = text.indexOf("*", index + 1);
+        if (end > index + 1) {
+          nodes.push(/* @__PURE__ */ (0, import_jsx_runtime.jsx)("em", { children: renderInlineMarkdown(text.slice(index + 1, end), `${keyPrefix}-em-${nodeIndex}`) }, `${keyPrefix}-em-${nodeIndex++}`));
+          index = end + 1;
+          continue;
+        }
+      }
+      if (text[index] === "[") {
+        const textEnd = text.indexOf("]", index + 1);
+        const hrefStart = textEnd >= 0 ? text.indexOf("(", textEnd) : -1;
+        const hrefEnd = hrefStart === textEnd + 1 ? text.indexOf(")", hrefStart + 1) : -1;
+        if (textEnd > index + 1 && hrefEnd > hrefStart + 1) {
+          const label = text.slice(index + 1, textEnd);
+          const href = text.slice(hrefStart + 1, hrefEnd).trim();
+          nodes.push(isSafeMarkdownHref(href) ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("a", { href, rel: "noreferrer", target: "_blank", children: renderInlineMarkdown(label, `${keyPrefix}-link-${nodeIndex}`) }, `${keyPrefix}-link-${nodeIndex++}`) : label);
+          index = hrefEnd + 1;
+          continue;
+        }
+      }
+      const nextSpecial = nextMarkdownSpecialIndex(text, index + 1);
+      pushText(text.slice(index, nextSpecial));
+      index = nextSpecial;
+    }
+    return nodes;
+  }
+  function nextMarkdownSpecialIndex(text, start) {
+    const indexes = ["`", "*", "["].map((character) => text.indexOf(character, start)).filter((value) => value >= 0);
+    return indexes.length > 0 ? Math.min(...indexes) : text.length;
+  }
+  function isSafeMarkdownHref(href) {
+    return /^(https?:|mailto:|tel:|\/|#)/i.test(href);
+  }
+
+  // src/updates.ts
+  var ClientUpdateService = class {
+    constructor(baseUrl, accessToken = () => null, eventSourceFactory = (url) => new EventSource(url)) {
+      this.baseUrl = baseUrl;
+      this.accessToken = accessToken;
+      this.eventSourceFactory = eventSourceFactory;
+      this.defaultCursor = 0;
+      this.streamCursor = 0;
+      this.source = null;
+      this.subscriptions = /* @__PURE__ */ new Map();
+      this.nextSubscriptionId = 1;
+      this.signature = "";
+    }
+    setCursor(cursor) {
+      this.defaultCursor = Math.max(this.defaultCursor, validCursor(cursor));
+    }
+    subscribe(subscription) {
+      const id = this.nextSubscriptionId++;
+      this.subscriptions.set(id, {
+        subscription,
+        cursor: validCursor(subscription.after ?? this.defaultCursor)
+      });
+      this.reconnectIfNeeded();
+      return () => {
+        this.subscriptions.delete(id);
+        this.reconnectIfNeeded();
+      };
+    }
+    reconnectIfNeeded() {
+      const nextSignature = this.buildSignature();
+      if (nextSignature === this.signature) {
+        return;
+      }
+      this.source?.close();
+      this.source = null;
+      this.signature = nextSignature;
+      if (this.subscriptions.size === 0) {
+        return;
+      }
+      const { filterType, filter } = combinedServerFilter(this.activeSubscriptions());
+      const after = this.minimumCursor();
+      this.streamCursor = after;
+      const url = this.withAccessToken(`${this.baseUrl}/api/updates?after=${after}&filterType=${encodeURIComponent(filterType)}&filter=${encodeURIComponent(JSON.stringify(filter))}`);
+      const source = this.eventSourceFactory(url);
+      this.source = source;
+      source.onmessage = (event) => {
+        if (this.source !== source) {
+          return;
+        }
+        const result = parseUpdateStreamItem(event.data);
+        if (!result.ok) {
+          this.resyncFromServer();
+          return;
+        }
+        const item = result.item;
+        const high = item.kind === "skip" ? item.to : item.update?.updateNumber;
+        const low = item.kind === "skip" ? item.from : item.update?.updateNumber;
+        if (high === void 0 || high <= this.streamCursor) {
+          return;
+        }
+        if (low === void 0 || low > this.streamCursor + 1) {
+          this.resyncFromServer();
+          return;
+        }
+        this.dispatchItem(item);
+        this.streamCursor = advanceCursor(this.streamCursor, item);
+      };
+      source.addEventListener("ephemeral", () => {
+      });
+      source.onerror = () => {
+        if (this.source !== source) {
+          return;
+        }
+      };
+    }
+    // Tear down the live connection and re-establish it from the lowest active cursor. Used to recover
+    // from stream corruption (malformed event, out-of-order gap) without surfacing an error: the server
+    // replays from the requested cursor and the onmessage replay-dedup ignores anything already seen.
+    resyncFromServer() {
+      this.signature = "";
+      this.reconnectIfNeeded();
+    }
+    buildSignature() {
+      if (this.subscriptions.size === 0) return "";
+      const { filterType, filter } = combinedServerFilter(this.activeSubscriptions());
+      return `${this.minimumCursor()}:${filterType}:${JSON.stringify(filter)}`;
+    }
+    withAccessToken(url) {
+      const token = this.accessToken();
+      if (!token) return url;
+      const separator = url.includes("?") ? "&" : "?";
+      return `${url}${separator}accessToken=${encodeURIComponent(token)}`;
+    }
+    dispatchItem(item) {
+      if (item.kind === "skip") {
+        this.dispatchSkip(item);
+        return;
+      }
+      const update = item.update;
+      if (!update) {
+        return;
+      }
+      for (const active of this.subscriptions.values()) {
+        const updateNumber = update.updateNumber;
+        if (updateNumber <= active.cursor) {
+          continue;
+        }
+        if (subscriptionMatches(active.subscription, item)) {
+          this.emitSkip(active, active.cursor + 1, updateNumber - 1);
+          active.subscription.onItem(item);
+          active.cursor = updateNumber;
+        } else {
+          this.emitSkip(active, active.cursor + 1, updateNumber);
+        }
+      }
+    }
+    dispatchSkip(item) {
+      if (item.to === void 0) {
+        return;
+      }
+      for (const active of this.subscriptions.values()) {
+        const from = active.cursor + 1;
+        const to = item.to;
+        if (to < from) {
+          continue;
+        }
+        active.subscription.onItem({ kind: "skip", from, to });
+        active.cursor = Math.max(active.cursor, to);
+      }
+    }
+    emitSkip(active, from, to) {
+      if (to < from) {
+        return;
+      }
+      active.subscription.onItem({ kind: "skip", from, to });
+      active.cursor = Math.max(active.cursor, to);
+    }
+    activeSubscriptions() {
+      return [...this.subscriptions.values()].map((active) => active.subscription);
+    }
+    minimumCursor() {
+      let cursor = null;
+      for (const active of this.subscriptions.values()) {
+        cursor = cursor === null ? active.cursor : Math.min(cursor, active.cursor);
+      }
+      return cursor ?? this.defaultCursor;
+    }
+  };
+  function combinedServerFilter(subscriptions) {
+    const filterTypes = new Set(subscriptions.map((subscription) => subscription.filterType));
+    return {
+      filterType: filterTypes.size === 1 ? subscriptions[0]?.filterType ?? "all" : "all",
+      filter: {
+        any: subscriptions.map((subscription) => normalizeFilter(subscription.filter))
+      }
+    };
+  }
+  function subscriptionMatches(subscription, item) {
+    const update = item.update;
+    if (!update) return false;
+    return filterValueMatches(subscription.filter.objectIds, update.objectId) && filterValueMatches(subscription.filter.objectTypes, update.objectType) && filterValueMatches(subscription.filter.updateTypes, update.type);
+  }
+  function parseUpdateStreamItem(data) {
+    let parsed;
+    try {
+      parsed = JSON.parse(data);
+    } catch {
+      return { ok: false, message: "The update stream sent an invalid event." };
+    }
+    if (!isRecord(parsed)) {
+      return { ok: false, message: "The update stream sent an invalid event." };
+    }
+    if (parsed.kind === "skip") {
+      return {
+        ok: true,
+        item: {
+          kind: "skip",
+          from: numberValue2(parsed.from),
+          to: numberValue2(parsed.to)
+        }
+      };
+    }
+    if (parsed.kind !== "update" || !isRecord(parsed.update)) {
+      return { ok: false, message: "The update stream sent an unsupported event." };
+    }
+    const updateNumber = numberValue2(parsed.update.updateNumber);
+    const type = stringValue2(parsed.update.type);
+    const objectType = stringValue2(parsed.update.objectType);
+    if (updateNumber === void 0 || !type || !objectType) {
+      return { ok: false, message: "The update stream sent an incomplete update." };
+    }
+    return {
+      ok: true,
+      item: {
+        kind: "update",
+        update: {
+          updateNumber,
+          type,
+          objectType,
+          objectId: stringValue2(parsed.update.objectId),
+          payload: isRecord(parsed.update.payload) ? parsed.update.payload : void 0
+        }
+      }
+    };
+  }
+  function advanceCursor(current, item) {
+    return Math.max(current, item.kind === "skip" ? item.to ?? current : item.update?.updateNumber ?? current);
+  }
+  function normalizeFilter(filter) {
+    return {
+      objectIds: filterValues(filter.objectIds),
+      objectTypes: filterValues(filter.objectTypes),
+      updateTypes: filterValues(filter.updateTypes)
+    };
+  }
+  function filterValueMatches(filter, value) {
+    const values = filterValues(filter);
+    return values.length === 0 || Boolean(value && values.some((item) => item.toLocaleLowerCase() === value.toLocaleLowerCase()));
+  }
+  function filterValues(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.length > 0) : [];
+  }
+  function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  function stringValue2(value) {
+    return typeof value === "string" && value.length > 0 ? value : void 0;
+  }
+  function numberValue2(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+  }
+  function validCursor(value) {
+    return Number.isFinite(value) && value > 0 ? value : 0;
+  }
+
+  // src/telemetry.ts
+  var ClientTelemetryService = class {
+    constructor(options = {}) {
+      this.queue = [];
+      this.flushTimer = null;
+      this.flushing = false;
+      this.baseUrl = options.baseUrl ?? "";
+      this.accessToken = options.accessToken ?? (() => null);
+      this.fetchImpl = options.fetch ?? fetch;
+      this.endpoint = options.endpoint ?? "/api/client-telemetry";
+      this.flushIntervalMs = options.flushIntervalMs ?? 5e3;
+      this.maxBatchSize = options.maxBatchSize ?? 20;
+      this.maxQueueSize = options.maxQueueSize ?? 200;
+      if (typeof window !== "undefined") {
+        window.addEventListener("pagehide", () => this.flushWithBeacon());
+      }
+    }
+    record(event) {
+      if (this.queue.length >= this.maxQueueSize) {
+        this.queue.shift();
+      }
+      this.queue.push({
+        ...event,
+        observedAt: event.observedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        route: event.route ?? currentRoute()
+      });
+      this.scheduleFlush();
+    }
+    async flush() {
+      if (this.flushing || this.queue.length === 0) {
+        return;
+      }
+      this.flushing = true;
+      if (this.flushTimer !== null) {
+        clearTimeout(this.flushTimer);
+        this.flushTimer = null;
+      }
+      const batch = this.queue.splice(0, this.maxBatchSize);
+      try {
+        const response = await this.fetchImpl(this.url(), {
+          method: "POST",
+          headers: this.headers({ "content-type": "application/json" }),
+          body: JSON.stringify({ events: batch })
+        });
+        if (!response.ok) {
+          this.requeue(batch);
+        }
+      } catch {
+        this.requeue(batch);
+      } finally {
+        this.flushing = false;
+        if (this.queue.length > 0) {
+          this.scheduleFlush();
+        }
+      }
+    }
+    scheduleFlush() {
+      if (this.flushTimer !== null) {
+        return;
+      }
+      this.flushTimer = setTimeout(() => {
+        void this.flush();
+      }, this.flushIntervalMs);
+    }
+    flushWithBeacon() {
+      if (this.queue.length === 0 || typeof navigator === "undefined" || !navigator.sendBeacon) {
+        return;
+      }
+      const batch = this.queue.splice(0, this.maxBatchSize);
+      const body = JSON.stringify({ events: batch });
+      if (!navigator.sendBeacon(this.beaconUrl(), new Blob([body], { type: "application/json" }))) {
+        this.requeue(batch);
+      }
+    }
+    requeue(events) {
+      this.queue.unshift(...events);
+      if (this.queue.length > this.maxQueueSize) {
+        this.queue.splice(0, this.queue.length - this.maxQueueSize);
+      }
+    }
+    headers(init = {}) {
+      const headers = new Headers(init);
+      const token = this.accessToken();
+      if (token) headers.set("authorization", `Bearer ${token}`);
+      return headers;
+    }
+    url() {
+      return `${this.baseUrl}${this.endpoint}`;
+    }
+    beaconUrl() {
+      const token = this.accessToken();
+      if (!token) return this.url();
+      const separator = this.endpoint.includes("?") ? "&" : "?";
+      return `${this.baseUrl}${this.endpoint}${separator}accessToken=${encodeURIComponent(token)}`;
+    }
+  };
+  function currentRoute() {
+    if (typeof window === "undefined") {
+      return void 0;
+    }
+    return `${window.location.pathname}${window.location.search}${window.location.hash}`;
+  }
+
+  // src/TaskListPage.tsx
+  var import_react3 = __require("react");
+  var import_jsx_runtime2 = __require("react/jsx-runtime");
+
+  // src/ai-plane.ts
+  var aiPlaneEndpoints = {
+    tasks: "/api/tasks",
+    task: (taskId) => `/api/tasks/${encodeURIComponent(taskId)}`,
+    taskMessages: (taskId) => `/api/tasks/${encodeURIComponent(taskId)}/messages`,
+    taskInterrupt: (taskId) => `/api/tasks/${encodeURIComponent(taskId)}/interrupt`,
+    taskSteer: (taskId) => `/api/tasks/${encodeURIComponent(taskId)}/steer`,
+    taskAttachments: "/api/task-attachments",
+    taskState: "/api/state/tasks",
+    taskStateDetail: (taskId) => `/api/state/tasks/${encodeURIComponent(taskId)}`,
+    taskTrace: (taskId, turnId) => `/api/state/tasks/${encodeURIComponent(taskId)}/turns/${encodeURIComponent(turnId)}/trace`,
+    updates: "/api/updates",
+    clientTelemetry: "/api/client-telemetry",
+    platformStatus: "/api/platform-status"
+  };
+  var AiPlaneClient = class {
+    constructor(options = {}) {
+      this.baseUrl = options.baseUrl ?? "";
+      this.accessToken = options.accessToken ?? (() => null);
+      this.fetchImpl = options.fetch ?? fetch;
+      this.updates = new ClientUpdateService(this.baseUrl, this.accessToken);
+      this.telemetry = new ClientTelemetryService({ baseUrl: this.baseUrl, accessToken: this.accessToken, fetch: this.fetchImpl });
+    }
+    async loadTaskState() {
+      return this.getJson(aiPlaneEndpoints.taskState);
+    }
+    async loadTask(taskId) {
+      return this.getJson(aiPlaneEndpoints.taskStateDetail(taskId));
+    }
+    async loadTrace(taskId, turnId) {
+      return this.getJson(aiPlaneEndpoints.taskTrace(taskId, turnId));
+    }
+    async loadPlatformStatus() {
+      return this.getJson(aiPlaneEndpoints.platformStatus);
+    }
+    async createTask(request) {
+      return this.postJson(aiPlaneEndpoints.tasks, request);
+    }
+    async continueTask(taskId, request) {
+      return this.postJson(aiPlaneEndpoints.taskMessages(taskId), request);
+    }
+    async interruptTask(taskId, message) {
+      return this.postJson(aiPlaneEndpoints.taskInterrupt(taskId), { message });
+    }
+    async steerTask(taskId, message) {
+      return this.postJson(aiPlaneEndpoints.taskSteer(taskId), { message });
+    }
+    async uploadAttachment(file, onProgress) {
+      return new Promise((resolve, reject) => {
+        const request = new XMLHttpRequest();
+        const body = new FormData();
+        body.append("file", file);
+        request.open("POST", this.url(aiPlaneEndpoints.taskAttachments));
+        const token = this.accessToken();
+        if (token) request.setRequestHeader("authorization", `Bearer ${token}`);
+        request.upload.onprogress = (event) => {
+          if (event.lengthComputable) onProgress?.(Math.round(event.loaded / event.total * 100));
+        };
+        request.onload = () => {
+          if (request.status >= 200 && request.status < 300) {
+            resolve(JSON.parse(request.responseText));
+          } else {
+            reject(new Error(request.responseText || `Upload failed: ${request.status}`));
+          }
+        };
+        request.onerror = () => reject(new Error("Upload failed."));
+        request.send(body);
+      });
+    }
+    async getJson(path) {
+      const response = await this.fetchImpl(this.url(path), { headers: this.headers() });
+      return this.readJson(response);
+    }
+    async postJson(path, body) {
+      const response = await this.fetchImpl(this.url(path), {
+        method: "POST",
+        headers: this.headers({ "content-type": "application/json" }),
+        body: JSON.stringify(body)
+      });
+      return this.readJson(response);
+    }
+    async readJson(response) {
+      const json = await response.json().catch(() => null);
+      if (!response.ok) {
+        throw new Error(errorMessage(json) ?? `Request failed: ${response.status}`);
+      }
+      return json;
+    }
+    headers(init = {}) {
+      const headers = new Headers(init);
+      const token = this.accessToken();
+      if (token) headers.set("authorization", `Bearer ${token}`);
+      return headers;
+    }
+    url(path) {
+      return `${this.baseUrl}${path}`;
+    }
+  };
+  function errorMessage(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+    const error = value.error;
+    if (typeof error === "string") return error;
+    if (typeof error === "object" && error !== null && !Array.isArray(error)) {
+      const message = error.message;
+      if (typeof message === "string") return message;
+    }
+    return null;
+  }
+
+  // browser-entry.tsx
+  globalThis.ExoscientCpLib = {
+    AiPlaneClient,
+    ClientUpdateService,
+    TaskDetail,
+    WorkingIndicator,
+    capitalize,
+    formatDateTime,
+    formatTaskLabel,
+    isTaskBusy,
+    statusToneClass,
+    taskTitleText
+  };
+})();