@opengeni/react 0.23.0 → 0.25.5

package/dist/{chunk-UAHPKLB6.js → chunk-MP6237JB.js}

@@ -1,930 +1,102 @@
 import {
-  CREDIT_EXHAUSTION_MESSAGE,
-  humanizeFailureReason,
-  isCreditExhaustion,
-  tryParseJson,
   useDebouncedCallback,
   useEmbeddedHumanInputSession,
   useEmbeddedSession,
   useEmbeddedSessionMcpApprovalPolicy,
   useMutationRunner,
+  useOpenGeni,
   usePolledValue,
   useSessionEventTrigger
-} from "./chunk-I3BJZIG5.js";
+} from "./chunk-HIWPQYWI.js";
+import {
+  buildTimeline,
+  groupTimeline,
+  sessionStatusFromEvents
+} from "./chunk-OZDLELJQ.js";
 
-// src/timeline/projection.ts
-var WORKER_SPAWN_TOOL = "session_create";
-var WORKER_MESSAGE_TOOL = "session_send_message";
-function buildTimeline(events) {
-  const items = [];
-  const prescan = prescanTurnAnchors(events);
-  const ordered = orderTimelineEvents(events, prescan);
-  const last = () => items[items.length - 1];
-  const closeStreamingTail = () => {
-    const open = last();
-    if ((open?.kind === "agent-message" || open?.kind === "reasoning") && open.streaming) {
-      open.streaming = false;
-    }
-  };
-  const finalizeOpen = (turnId, disposition = "complete") => {
-    for (const item of items) {
-      if (turnId !== void 0 && "turnId" in item && item.turnId && turnId && item.turnId !== turnId) {
-        continue;
-      }
-      if ((item.kind === "agent-message" || item.kind === "reasoning") && item.streaming) {
-        item.streaming = false;
-      }
-      if ((item.kind === "tool-call" || item.kind === "worker") && item.status === "running") {
-        item.status = disposition;
-      }
-      if (item.kind === "sandbox" && item.status === "running") {
-        item.status = disposition;
-      }
+// src/hooks/use-session.ts
+import { useCallback, useEffect, useMemo, useState } from "react";
+function isTitleEvent(event) {
+  return event.type === "session.title_set";
+}
+function useSession(sessionId, options = {}) {
+  const { client, workspaceId, workspaceControlEvent, registerSessionReconciler } = useOpenGeni(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const [override, setOverride] = useState(null);
+  const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
+  const load = useCallback(async () => {
+    if (!sessionId) {
+      return null;
     }
-  };
-  for (const event of ordered) {
-    const payload = asRecord(event.payload);
-    const turnId = event.turnId ?? null;
-    switch (event.type) {
-      case "user.message": {
-        closeStreamingTail();
-        const childCompletion = workerCompletionPayload(payload.childCompletion);
-        if (childCompletion) {
-          items.push({
-            kind: "worker-completion",
-            id: event.id,
-            turnId,
-            occurredAt: event.occurredAt,
-            childSessionId: childCompletion.childSessionId,
-            childStatus: childCompletion.childStatus,
-            goalStatus: childCompletion.goalStatus,
-            goalText: childCompletion.goalText,
-            evidence: childCompletion.evidence,
-            pausedReason: childCompletion.pausedReason,
-            text: typeof payload.text === "string" ? payload.text : ""
-          });
-          break;
-        }
-        items.push({
-          kind: "user-message",
-          id: event.id,
-          text: typeof payload.text === "string" ? payload.text : "",
-          resources: resourceRefs(payload.resources),
-          tools: toolRefs(payload.tools),
-          occurredAt: event.occurredAt
-        });
-        break;
-      }
-      case "agent.message.delta": {
-        const text = typeof payload.text === "string" ? payload.text : "";
-        if (!text) {
-          break;
-        }
-        const open = last();
-        if (open?.kind === "agent-message" && open.streaming && open.turnId === turnId) {
-          open.text += text;
-          break;
-        }
-        closeStreamingTail();
-        items.push({
-          kind: "agent-message",
-          id: event.id,
-          turnId,
-          text,
-          streaming: true,
-          occurredAt: event.occurredAt
-        });
-        break;
-      }
-      case "agent.message.completed": {
-        const text = typeof payload.text === "string" ? payload.text : "";
-        const open = [...items].reverse().find(
-          (item) => item.kind === "agent-message" && item.turnId === turnId
-        );
-        if (open && (open.streaming || !open.text || text === open.text || text.startsWith(open.text))) {
-          if (!open.text || text && text.startsWith(open.text)) {
-            open.text = text || open.text;
-          }
-          open.streaming = false;
-          break;
-        }
-        if (text) {
-          items.push({
-            kind: "agent-message",
-            id: event.id,
-            turnId,
-            text,
-            streaming: false,
-            occurredAt: event.occurredAt
-          });
-        }
-        break;
-      }
-      case "agent.reasoning.delta": {
-        const text = reasoningText(event.payload);
-        if (!text) {
-          break;
-        }
-        const open = last();
-        if (open?.kind === "reasoning" && open.streaming && open.turnId === turnId) {
-          open.text += text;
-          break;
-        }
-        closeStreamingTail();
-        items.push({
-          kind: "reasoning",
-          id: event.id,
-          turnId,
-          text,
-          streaming: true,
-          occurredAt: event.occurredAt
-        });
-        break;
-      }
-      case "agent.toolCall.created": {
-        const name = typeof payload.name === "string" ? payload.name : "tool";
-        const callId = typeof payload.id === "string" ? payload.id : null;
-        const args = payload.arguments ?? null;
-        closeStreamingTail();
-        if (name === WORKER_SPAWN_TOOL || name === WORKER_MESSAGE_TOOL) {
-          items.push({
-            kind: "worker",
-            id: event.id,
-            turnId,
-            callId,
-            action: name === WORKER_SPAWN_TOOL ? "spawn" : "message",
-            prompt: workerPrompt(args),
-            workerSessionId: extractSessionRef(args),
-            status: "running",
-            occurredAt: event.occurredAt
-          });
-          break;
-        }
-        items.push({
-          kind: "tool-call",
-          id: event.id,
-          turnId,
-          callId,
-          name,
-          arguments: args,
-          output: void 0,
-          // The provider-native item drives the per-tool renderers (apply_patch
-          // operation, computer_call action, web_search providerData, …).
-          raw: payload.raw,
-          status: "running",
-          occurredAt: event.occurredAt
-        });
-        break;
-      }
-      case "agent.toolCall.output": {
-        const callId = typeof payload.id === "string" ? payload.id : null;
-        const target = findOpenCall(items, callId);
-        if (!target) {
-          break;
-        }
-        if (target.kind === "worker") {
-          target.status = isErrorOutput(payload) ? "failed" : "complete";
-          target.workerSessionId = target.workerSessionId ?? extractSessionRef(payload.output);
-          break;
-        }
-        target.status = isErrorOutput(payload) ? "failed" : "complete";
-        target.output = payload.output;
-        break;
-      }
-      case "sandbox.operation.started":
-      case "sandbox.operation.completed":
-      case "sandbox.operation.failed": {
-        const name = typeof payload.name === "string" ? payload.name : "sandbox";
-        const status = event.type.endsWith(".failed") ? "failed" : event.type.endsWith(".completed") ? "complete" : "running";
-        if ((name === "repository-clone" || name === "file-resource-download") && status !== "failed") {
-          break;
-        }
-        const existing = findOpenSandbox(items, name);
-        if (existing && status !== "running") {
-          existing.status = status;
-          if (payload.origin === "created" || payload.origin === "restored" || payload.origin === "resumed") {
-            existing.origin = payload.origin;
-          }
-          const message = failureMessage(payload);
-          if (message) {
-            existing.output = existing.output ? `${existing.output}
-${message}` : message;
-          }
-          break;
-        }
-        if (!existing) {
-          closeStreamingTail();
-          items.push({
-            kind: "sandbox",
-            id: event.id,
-            turnId,
-            name,
-            command: typeof payload.command === "string" ? payload.command : null,
-            output: failureMessage(payload) ?? "",
-            origin: payload.origin === "created" || payload.origin === "restored" || payload.origin === "resumed" ? payload.origin : null,
-            status,
-            occurredAt: event.occurredAt
-          });
-        }
-        break;
-      }
-      case "sandbox.command.output.delta": {
-        const text = typeof payload.chunk === "string" ? payload.chunk : typeof payload.text === "string" ? payload.text : typeof payload.output === "string" ? payload.output : "";
-        if (!text) {
-          break;
-        }
-        const open = (typeof payload.name === "string" ? findOpenSandbox(items, payload.name) : void 0) ?? [...items].reverse().find(
-          (item) => item.kind === "sandbox" && item.status === "running"
-        );
-        if (open) {
-          open.output += text;
-        }
-        break;
-      }
-      case "session.status.changed": {
-        const status = payload.status;
-        if (!isSessionStatus(status)) {
-          break;
-        }
-        if (!ATTENTION_STATUSES.has(status)) {
-          break;
-        }
-        const previous = [...items].reverse().find((item) => item.kind === "session-status");
-        if (previous?.status === status) {
-          break;
-        }
-        items.push({ kind: "session-status", id: event.id, status, occurredAt: event.occurredAt });
-        break;
-      }
-      case "session.requiresAction": {
-        finalizeOpen(turnId);
-        items.push({
-          kind: "notice",
-          id: event.id,
-          tone: "waiting",
-          text: "Approval needed \u2014 the turn is paused until someone decides.",
-          occurredAt: event.occurredAt
-        });
-        break;
-      }
-      case "session.context.compacted": {
-        closeStreamingTail();
-        const before = typeof payload.estimatedTokensBefore === "number" ? Math.round(payload.estimatedTokensBefore).toLocaleString("en-US") : null;
-        const after = typeof payload.estimatedTokensAfter === "number" ? Math.round(payload.estimatedTokensAfter).toLocaleString("en-US") : null;
-        items.push({
-          kind: "notice",
-          id: event.id,
-          tone: "waiting",
-          text: before && after ? `Active conversation history compacted from approximately ${before} to ${after} tokens.` : "Context compacted so the turn could continue.",
-          occurredAt: event.occurredAt
-        });
-        break;
-      }
-      case "session.context.compaction.skipped": {
-        closeStreamingTail();
-        const reason = typeof payload.reason === "string" ? payload.reason : null;
-        items.push({
-          kind: "notice",
-          id: event.id,
-          tone: reason === "summarization_failed" ? "failed" : "waiting",
-          text: reason === "no_history" ? "Context compaction skipped because there is no active history to compact." : reason === "replacement_not_smaller" ? "Context compaction skipped because the generated checkpoint would not reduce the context." : reason === "replacement_unchanged" ? "Context compaction stopped because it reproduced the same checkpoint without making progress." : reason === "summarization_failed" ? "Context compaction failed without replacing the active conversation history. Request it again to retry." : "Context compaction was not needed.",
-          occurredAt: event.occurredAt
-        });
-        break;
-      }
-      case "turn.recovery.requested": {
-        break;
-      }
-      case "turn.event.rejected_late": {
-        break;
-      }
-      case "tool.auth_needed":
-      case "credential.auth_needed": {
-        closeStreamingTail();
-        items.push({
-          kind: "auth-needed",
-          id: event.id,
-          turnId,
-          providerDomain: typeof payload.providerDomain === "string" ? payload.providerDomain : "",
-          connectionId: typeof payload.connectionId === "string" ? payload.connectionId : null,
-          reason: authNeededReason(payload.reason),
-          scopes: stringList(payload.scopes),
-          resource: typeof payload.resource === "string" ? payload.resource : null,
-          toolName: typeof payload.toolName === "string" ? payload.toolName : null,
-          authorizationUrl: typeof payload.authorizationUrl === "string" ? payload.authorizationUrl : null,
-          occurredAt: event.occurredAt
-        });
-        break;
-      }
-      case "turn.completed": {
-        if (payload.maintenance === "context_compaction") {
-          finalizeOpen(turnId);
-          break;
-        }
-        if (isCreditExhaustionPayload(payload)) {
-          finalizeOpen(turnId);
-          items.push(turnEndItem(event, "failed", CREDIT_EXHAUSTION_MESSAGE));
-          items.push({
-            kind: "notice",
-            id: event.id,
-            tone: "failed",
-            text: CREDIT_EXHAUSTION_MESSAGE,
-            occurredAt: event.occurredAt
-          });
-          break;
-        }
-        finalizeOpen(turnId);
-        items.push(turnEndItem(event, "complete", null));
-        break;
-      }
-      case "turn.failed": {
-        const hadActivity = hasTurnActivity(items, turnId);
-        const failureText = isCreditExhaustionPayload(payload) ? CREDIT_EXHAUSTION_MESSAGE : failureMessage(payload);
-        finalizeOpen(turnId, "cancelled");
-        items.push(turnEndItem(event, "failed", failureText));
-        if (!hadActivity) {
-          items.push({
-            kind: "notice",
-            id: event.id,
-            tone: "failed",
-            text: failureText ?? "The turn failed.",
-            occurredAt: event.occurredAt
-          });
-        }
-        break;
-      }
-      case "turn.cancelled": {
-        if (turnId && !prescan.startedTurnIds.has(turnId)) {
-          break;
-        }
-        const hadActivity = hasTurnActivity(items, turnId);
-        finalizeOpen(turnId, "cancelled");
-        items.push(turnEndItem(event, "cancelled", null));
-        if (!hadActivity) {
-          items.push({
-            kind: "notice",
-            id: event.id,
-            tone: "cancelled",
-            text: "Interrupted.",
-            occurredAt: event.occurredAt
-          });
-        }
-        break;
+    const fetched = await client.getSession(workspaceId, sessionId);
+    setOverride(null);
+    return fetched;
+  }, [client, workspaceId, sessionId]);
+  const { data, loading, error, refresh } = usePolledValue(load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled
+  });
+  useEffect(() => {
+    if (enabled && workspaceControlEvent) void refresh();
+  }, [enabled, refresh, workspaceControlEvent]);
+  useEffect(() => {
+    if (!sessionId || !enabled) return;
+    return registerSessionReconciler(sessionId, "session", refresh);
+  }, [enabled, refresh, registerSessionReconciler, sessionId]);
+  const base = data ?? null;
+  const session = useMemo(
+    () => base && override && override.id === base.id ? { ...base, title: override.title, titleSource: override.titleSource } : base,
+    [base, override]
+  );
+  const onTitleEvent = useCallback(
+    (event) => {
+      const payload = event.payload ?? {};
+      const title = payload.title;
+      if (typeof title !== "string") {
+        return;
       }
-      case "memory.saved":
-      case "memory.corrected": {
-        const memory = memoryItem(event.id, event.type, turnId, payload, event.occurredAt);
-        if (memory) {
-          closeStreamingTail();
-          items.push(memory);
+      const source = payload.source === "user" || payload.source === "agent" ? payload.source : null;
+      setOverride((current) => {
+        const next = current ?? base;
+        if (!next) {
+          return current;
         }
-        break;
-      }
-      case "goal.set":
-      case "goal.updated":
-      case "goal.completed":
-      case "goal.paused":
-      case "goal.resumed":
-      case "goal.cleared":
-      case "goal.continuation": {
-        items.push({
-          kind: "goal",
-          id: event.id,
-          action: event.type.slice("goal.".length),
-          text: goalText(payload),
-          occurredAt: event.occurredAt
-        });
-        break;
-      }
-      default:
-        break;
-    }
-  }
-  return items;
-}
-function isCreditExhaustionPayload(payload) {
-  return isCreditExhaustion({
-    error: typeof payload.error === "string" ? payload.error : null,
-    detail: typeof payload.detail === "string" ? payload.detail : null,
-    segmentLimit: typeof payload.segmentLimit === "string" ? payload.segmentLimit : null
+        return { ...next, title, titleSource: source };
+      });
+    },
+    [base]
+  );
+  useSessionEventTrigger(client, workspaceId, sessionId, isTitleEvent, onTitleEvent, {
+    enabled,
+    ...options.events !== void 0 ? { events: options.events } : {}
   });
-}
-function creditExhaustedFromEvents(events) {
-  const ordered = [...events].sort((a, b) => a.sequence - b.sequence);
-  for (let index = ordered.length - 1; index >= 0; index -= 1) {
-    const event = ordered[index];
-    if (event?.type !== "turn.completed" && event?.type !== "turn.failed" && event?.type !== "turn.cancelled") {
-      continue;
-    }
-    return isCreditExhaustionPayload(asRecord(event.payload));
-  }
-  return false;
-}
-function sessionStatusFromEvents(events) {
-  for (let index = events.length - 1; index >= 0; index -= 1) {
-    const event = events[index];
-    if (event?.type !== "session.status.changed") {
-      continue;
-    }
-    const status = asRecord(event.payload).status;
-    if (isSessionStatus(status)) {
-      return status;
-    }
-  }
-  return null;
-}
-function isActivityItem(item) {
-  switch (item.kind) {
-    case "reasoning":
-    case "tool-call":
-    case "worker":
-    case "sandbox":
-    case "memory":
-      return true;
-    default:
-      return false;
-  }
-}
-function groupTimeline(items) {
-  const groups = [];
-  for (const item of items) {
-    if (isActivityItem(item)) {
-      const open = groups[groups.length - 1];
-      if (open?.kind === "activity" && open.outcome === void 0) {
-        open.items.push(item);
-      } else {
-        groups.push({ kind: "activity", id: `activity-${item.id}`, items: [item] });
-      }
-      continue;
-    }
-    if (item.kind === "turn-end") {
-      stampTurnOutcome(groups, item);
-      foldSettledTurn(groups, item);
-      continue;
-    }
-    groups.push({ kind: "item", item });
-  }
-  return groups;
-}
-function prescanTurnAnchors(events) {
-  const ordered = [...events].sort((a, b) => a.sequence - b.sequence);
-  const queuedTurnByTrigger = /* @__PURE__ */ new Map();
-  const startSeqByTrigger = /* @__PURE__ */ new Map();
-  const cancelledTurnIds = /* @__PURE__ */ new Set();
-  const fallbackSeqByTurn = /* @__PURE__ */ new Map();
-  const startedTurnIds = /* @__PURE__ */ new Set();
-  for (const event of ordered) {
-    const payload = asRecord(event.payload);
-    const turnId = event.turnId ?? null;
-    if (event.type === "turn.queued") {
-      const triggerEventId = typeof payload.triggerEventId === "string" ? payload.triggerEventId : null;
-      const queuedTurnId = typeof payload.turnId === "string" ? payload.turnId : turnId;
-      if (triggerEventId && queuedTurnId) {
-        queuedTurnByTrigger.set(triggerEventId, queuedTurnId);
-      }
-      continue;
-    }
-    if (event.type === "turn.started") {
-      const triggerEventId = typeof payload.triggerEventId === "string" ? payload.triggerEventId : null;
-      if (triggerEventId && !startSeqByTrigger.has(triggerEventId)) {
-        startSeqByTrigger.set(triggerEventId, event.sequence);
-      }
-      if (turnId) {
-        startedTurnIds.add(turnId);
-      }
-    } else if (event.type === "turn.cancelled" && turnId) {
-      cancelledTurnIds.add(turnId);
-    }
-    if (turnId && isTurnExecutionEvidence(event.type)) {
-      const previous = fallbackSeqByTurn.get(turnId);
-      if (previous === void 0 || event.sequence < previous) {
-        fallbackSeqByTurn.set(turnId, event.sequence);
+  const updateTitle = useCallback(
+    async (title) => {
+      if (!sessionId) {
+        return null;
       }
-    }
-    if (turnId && isTurnExecutionEvidence(event.type)) {
-      startedTurnIds.add(turnId);
-    }
-  }
-  for (const [triggerEventId, turnId] of queuedTurnByTrigger) {
-    if (!startSeqByTrigger.has(triggerEventId)) {
-      const fallbackSeq = fallbackSeqByTurn.get(turnId);
-      if (fallbackSeq !== void 0) {
-        startSeqByTrigger.set(triggerEventId, fallbackSeq);
+      const result = await run(() => client.updateSession(workspaceId, sessionId, { title }));
+      if (result) {
+        setOverride(result);
       }
-    }
-  }
-  const cancelledBeforeStartTriggers = /* @__PURE__ */ new Set();
-  for (const [triggerEventId, turnId] of queuedTurnByTrigger) {
-    if (cancelledTurnIds.has(turnId) && !startSeqByTrigger.has(triggerEventId) && !fallbackSeqByTurn.has(turnId)) {
-      cancelledBeforeStartTriggers.add(triggerEventId);
-    }
-  }
-  return { queuedTurnByTrigger, startSeqByTrigger, cancelledBeforeStartTriggers, startedTurnIds };
-}
-function orderTimelineEvents(events, prescan) {
-  const ordered = [...events].sort((a, b) => a.sequence - b.sequence);
-  const insertions = /* @__PURE__ */ new Map();
-  for (const event of ordered) {
-    if (event.type !== "user.message") {
-      continue;
-    }
-    const queuedTurnId = prescan.queuedTurnByTrigger.get(event.id);
-    if (!queuedTurnId) {
-      pushInsertion(insertions, event.sequence, event);
-      continue;
-    }
-    if (prescan.cancelledBeforeStartTriggers.has(event.id)) {
-      continue;
-    }
-    const startSeq = prescan.startSeqByTrigger.get(event.id);
-    if (startSeq !== void 0) {
-      pushInsertion(insertions, startSeq, event);
-      continue;
-    }
-  }
-  const projected = [];
-  for (const event of ordered) {
-    const before = insertions.get(event.sequence);
-    if (before) {
-      projected.push(...before);
-    }
-    if (event.type !== "user.message") {
-      projected.push(event);
-    }
-  }
-  return projected;
-}
-function pushInsertion(insertions, sequence, event) {
-  const bucket = insertions.get(sequence);
-  if (bucket) {
-    bucket.push(event);
-  } else {
-    insertions.set(sequence, [event]);
-  }
-}
-function isAgentActivityEvent(type) {
-  return type.startsWith("agent.") || type.startsWith("sandbox.");
-}
-function isTurnExecutionEvidence(type) {
-  return isAgentActivityEvent(type) || type === "turn.completed" || type === "turn.failed" || type === "turn.recovery.requested" || type === "turn.capacity_waiting" || type === "session.requiresAction" || type === "tool.auth_needed" || type === "credential.auth_needed" || type.startsWith("rig.setup.") || type === "codex.capacity.waiting" || type === "codex.capacity.resumed";
-}
-function turnEndItem(event, outcome, failureText) {
-  return {
-    kind: "turn-end",
-    id: `${event.id}-turn-end`,
-    turnId: event.turnId ?? null,
-    outcome,
-    failureText,
-    occurredAt: event.occurredAt
-  };
-}
-function hasTurnActivity(items, turnId) {
-  if (turnId) {
-    return items.some((item) => isActivityItem(item) && item.turnId === turnId);
-  }
-  for (let index = items.length - 1; index >= 0; index -= 1) {
-    const item = items[index];
-    if (!item || item.kind === "turn-end" || item.kind === "user-message") {
-      return false;
-    }
-    if (isActivityItem(item)) {
-      return true;
-    }
-  }
-  return false;
-}
-function stampTurnOutcome(groups, turnEnd) {
-  if (turnEnd.turnId === null) {
-    const trailing = groups[groups.length - 1];
-    if (trailing?.kind === "activity" && trailing.outcome === void 0) {
-      applyTurnOutcome(trailing, turnEnd);
-    }
-    return;
-  }
-  for (const group of groups) {
-    if (group.kind !== "activity" || group.outcome !== void 0) {
-      continue;
-    }
-    if (group.items.some((activity) => activity.turnId === turnEnd.turnId)) {
-      applyTurnOutcome(group, turnEnd);
-    }
-  }
-}
-function applyTurnOutcome(group, turnEnd) {
-  if (turnEnd.outcome === "complete") {
-    group.outcome = "complete";
-    return;
-  }
-  const hasFailed = group.items.some((item) => "status" in item && item.status === "failed");
-  const hasInterrupted = group.items.some(
-    (item) => "status" in item && item.status === "cancelled"
-  );
-  group.outcome = hasFailed ? "failed" : hasInterrupted ? "cancelled" : "complete";
-  if (turnEnd.failureText && hasFailed) {
-    group.failureText = turnEnd.failureText;
-  }
-}
-function foldSettledTurn(groups, turnEnd) {
-  let startIndex = groups.length;
-  let stoppedAtForeignTurn = false;
-  while (startIndex > 0) {
-    const previous = groups[startIndex - 1];
-    if (isTurnBoundary(previous)) {
-      break;
-    }
-    if (belongsToDifferentTurn(previous, turnEnd.turnId)) {
-      stoppedAtForeignTurn = true;
-      break;
-    }
-    startIndex -= 1;
-  }
-  if (stoppedAtForeignTurn) {
-    while (startIndex < groups.length && isBetweenTurnDivider(groups[startIndex])) {
-      startIndex += 1;
-    }
-  }
-  const collected = groups.slice(startIndex);
-  if (collected.length === 0) {
-    return;
-  }
-  const finalMessage = extractFinalAgentMessage(collected, turnEnd);
-  const body = finalMessage ? collected.slice(0, -1) : collected;
-  if (body.length === 0) {
-    return;
-  }
-  const firstOccurredAt = groupStartedAt(body[0]) ?? turnEnd.occurredAt;
-  const turnGroup = {
-    kind: "turn",
-    id: `turn-${turnEnd.turnId ?? turnEnd.id}`,
-    outcome: turnEnd.outcome,
-    startedAt: firstOccurredAt,
-    endedAt: turnEnd.occurredAt,
-    groups: body
-  };
-  if (turnEnd.failureText) {
-    turnGroup.failureText = turnEnd.failureText;
-  }
-  groups.splice(
-    startIndex,
-    collected.length,
-    ...finalMessage ? [turnGroup, finalMessage] : [turnGroup]
-  );
-}
-function isTurnBoundary(group) {
-  return group?.kind === "turn" || group?.kind === "item" && group.item.kind === "user-message";
-}
-function belongsToDifferentTurn(group, turnId) {
-  if (!group || !turnId) {
-    return false;
-  }
-  if (group.kind === "activity") {
-    return group.items.length > 0 && group.items.every((item) => item.turnId !== null && item.turnId !== turnId);
-  }
-  return group.kind === "item" && group.item.kind === "agent-message" && group.item.turnId !== null && group.item.turnId !== turnId;
-}
-function isBetweenTurnDivider(group) {
-  return group?.kind === "item" && group.item.kind === "session-status" && group.item.status !== "running";
-}
-function extractFinalAgentMessage(groups, turnEnd) {
-  const tail = groups[groups.length - 1];
-  if (tail?.kind !== "item" || tail.item.kind !== "agent-message" || tail.item.streaming) {
-    return null;
-  }
-  if (tail.item.turnId && turnEnd.turnId && tail.item.turnId !== turnEnd.turnId) {
-    return null;
-  }
-  return tail;
-}
-function groupStartedAt(group) {
-  if (!group) {
-    return void 0;
-  }
-  switch (group.kind) {
-    case "item":
-      return group.item.occurredAt;
-    case "activity":
-      return group.items[0]?.occurredAt;
-    case "turn":
-      return group.startedAt;
-  }
-}
-function asRecord(value) {
-  return value !== null && typeof value === "object" ? value : {};
-}
-var SESSION_STATUSES = [
-  "queued",
-  "running",
-  "idle",
-  "requires_action",
-  "failed",
-  "cancelled"
-];
-var ATTENTION_STATUSES = /* @__PURE__ */ new Set([
-  "requires_action",
-  "failed",
-  "cancelled"
-]);
-function resourceRefs(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  return value.filter((entry) => {
-    const record = asRecord(entry);
-    if (record.kind === "repository") {
-      return typeof record.uri === "string" && typeof record.ref === "string";
-    }
-    return record.kind === "file" && typeof record.fileId === "string";
-  });
-}
-function toolRefs(value) {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  return value.filter((entry) => {
-    const record = asRecord(entry);
-    return record.kind === "mcp" && typeof record.id === "string";
-  });
-}
-function workerCompletionPayload(value) {
-  const payload = asRecord(value);
-  const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-  if (typeof payload.childSessionId !== "string" || !uuidPattern.test(payload.childSessionId) || typeof payload.status !== "string" || payload.status.trim() === "") {
-    return null;
-  }
-  const goal = asRecord(payload.goal);
-  return {
-    childSessionId: payload.childSessionId,
-    childStatus: payload.status,
-    goalStatus: typeof goal.status === "string" ? goal.status : null,
-    goalText: typeof goal.text === "string" ? goal.text : null,
-    evidence: typeof goal.evidence === "string" ? goal.evidence : null,
-    // Console pauses and several server paths put the human explanation on
-    // `rationale`, not `pausedReason` — same fallback the goal pill uses, so a
-    // paused worker card never shows "Worker paused" with the reason missing.
-    pausedReason: typeof goal.pausedReason === "string" ? goal.pausedReason : typeof goal.rationale === "string" ? goal.rationale : null
-  };
-}
-function isSessionStatus(value) {
-  return typeof value === "string" && SESSION_STATUSES.includes(value);
-}
-function isErrorOutput(payload) {
-  if (payload.error === true || payload.failed === true) {
-    return true;
-  }
-  const output = payload.output;
-  return !!output && typeof output === "object" && output.isError === true;
-}
-function findOpenCall(items, callId) {
-  const reversed = [...items].reverse();
-  const isCall = (item) => item.kind === "tool-call" || item.kind === "worker";
-  if (callId) {
-    const byId = reversed.find((item) => isCall(item) && item.callId === callId);
-    if (byId) {
-      return byId;
-    }
-  }
-  return reversed.find(
-    (item) => isCall(item) && item.status === "running"
-  );
-}
-function findOpenSandbox(items, name) {
-  return [...items].reverse().find(
-    (item) => item.kind === "sandbox" && item.name === name && item.status === "running"
+      return result;
+    },
+    [client, workspaceId, sessionId, run]
   );
-}
-function failureMessage(payload) {
-  for (const key of ["error", "message"]) {
-    const value = payload[key];
-    if (typeof value === "string" && value.trim().length > 0) {
-      return humanizeFailureReason(value);
-    }
-  }
-  return null;
-}
-function goalText(payload) {
-  if (typeof payload.text === "string" && payload.text) {
-    return payload.text;
-  }
-  const goal = asRecord(payload.goal);
-  if (typeof goal.text === "string" && goal.text) {
-    return goal.text;
-  }
-  if (typeof payload.prompt === "string" && payload.prompt) {
-    return payload.prompt;
-  }
-  return null;
-}
-function memoryItem(id, type, turnId, payload, occurredAt) {
-  const memoryId = typeof payload.memoryId === "string" && payload.memoryId ? payload.memoryId : null;
-  if (!memoryId) {
-    return null;
-  }
-  const replacementPreview = typeof payload.replacementPreview === "string" ? payload.replacementPreview : void 0;
-  const replacementMemoryId = typeof payload.replacementMemoryId === "string" ? payload.replacementMemoryId : void 0;
-  const action = typeof payload.action === "string" ? payload.action : void 0;
   return {
-    kind: "memory",
-    id,
-    turnId,
-    variant: type === "memory.corrected" ? "corrected" : "saved",
-    memoryKind: typeof payload.kind === "string" ? payload.kind : "",
-    preview: typeof payload.preview === "string" ? payload.preview : "",
-    ...payload.deduped === true ? { deduped: true } : {},
-    ...replacementPreview ? { replacementPreview } : {},
-    ...action ? { action } : {},
-    memoryId,
-    ...replacementMemoryId ? { replacementMemoryId } : {},
-    occurredAt
+    session,
+    loading,
+    error,
+    refresh,
+    updateTitle,
+    updating: mutating,
+    mutationError,
+    clearMutationError
   };
 }
-var AUTH_NEEDED_REASONS = /* @__PURE__ */ new Set([
-  "missing_connection",
-  "expired",
-  "insufficient_scope",
-  "refresh_failed",
-  "unsupported_auth",
-  "resource_scope_unavailable"
-]);
-function authNeededReason(value) {
-  return typeof value === "string" && AUTH_NEEDED_REASONS.has(value) ? value : null;
-}
-function stringList(value) {
-  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
-}
-function reasoningText(payload) {
-  const record = asRecord(payload);
-  if (typeof record.text === "string") {
-    return record.text;
-  }
-  const content = asRecord(asRecord(record.item).rawItem).content;
-  if (!Array.isArray(content)) {
-    return "";
-  }
-  return content.map((part) => {
-    const text = asRecord(part).text;
-    return typeof text === "string" ? text : "";
-  }).join("");
-}
-function workerPrompt(args) {
-  const record = asRecord(typeof args === "string" ? tryParseJson(args) : args);
-  for (const key of ["initialMessage", "message", "text", "prompt"]) {
-    const value = record[key];
-    if (typeof value === "string" && value.trim().length > 0) {
-      return value;
-    }
-  }
-  return null;
-}
-function extractSessionRef(value, depth = 0) {
-  if (depth > 6 || value === null || value === void 0) {
-    return null;
-  }
-  if (typeof value === "string") {
-    return extractSessionRef(tryParseJson(value), depth + 1);
-  }
-  if (Array.isArray(value)) {
-    for (const entry of value) {
-      const found = extractSessionRef(entry, depth + 1);
-      if (found) {
-        return found;
-      }
-    }
-    return null;
-  }
-  if (typeof value !== "object") {
-    return null;
-  }
-  const record = value;
-  if (typeof record.sessionId === "string" && looksLikeId(record.sessionId)) {
-    return record.sessionId;
-  }
-  if (typeof record.id === "string" && looksLikeId(record.id) && ("status" in record || "workspaceId" in record || "initialMessage" in record)) {
-    return record.id;
-  }
-  for (const key of ["structuredContent", "session", "result", "content"]) {
-    if (key in record) {
-      const found = extractSessionRef(record[key], depth + 1);
-      if (found) {
-        return found;
-      }
-    }
-  }
-  if (typeof record.text === "string") {
-    return extractSessionRef(tryParseJson(record.text), depth + 1);
-  }
-  return null;
-}
-function looksLikeId(value) {
-  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
-}
-function toolDisplayName(name) {
-  const boundary = name.indexOf("__");
-  const toolPart = boundary >= 0 ? name.slice(boundary + 2) : name;
-  return toolPart.replace(/[_-]+/g, " ").trim();
-}
 
 // src/hooks/use-session-events.ts
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2, useRef, useState as useState2 } from "react";
 var INITIAL_TAIL_PAGE_SIZE = 1e3;
 var OLDER_PAGE_SIZE = 5e3;
 var INITIAL_FETCH_CAP = 1;
@@ -973,16 +145,16 @@ function useSessionEvents(sessionId, options = {}) {
   const replay = options.replay ?? "windowed";
   const fullReplay = replay === "full" || after !== 0;
   const streamKey = `${workspaceId}\0${sessionId ?? ""}\0${after}\0${fullReplay ? "full" : "windowed"}`;
-  const [eventWindow, setEventWindow] = useState(EMPTY_EVENT_WINDOW);
-  const [connectionState, setConnectionState] = useState("idle");
-  const [error, setError] = useState(null);
-  const [hasOlder, setHasOlder] = useState(false);
-  const [sessionStatusProjection, setSessionStatusProjection] = useState(
+  const [eventWindow, setEventWindow] = useState2(EMPTY_EVENT_WINDOW);
+  const [connectionState, setConnectionState] = useState2("idle");
+  const [error, setError] = useState2(null);
+  const [hasOlder, setHasOlder] = useState2(false);
+  const [sessionStatusProjection, setSessionStatusProjection] = useState2(
     null
   );
-  const [initialLoading, setInitialLoading] = useState(true);
-  const [loadingOlder, setLoadingOlder] = useState(false);
-  const [streamEpoch, setStreamEpoch] = useState(0);
+  const [initialLoading, setInitialLoading] = useState2(true);
+  const [loadingOlder, setLoadingOlder] = useState2(false);
+  const [streamEpoch, setStreamEpoch] = useState2(0);
   const lastSequenceRef = useRef(after);
   const streamResumeSequenceRef = useRef(after);
   const oldestSequenceRef = useRef(null);
@@ -997,8 +169,8 @@ function useSessionEvents(sessionId, options = {}) {
     sequence: after,
     status: null
   });
-  const [stateStreamKey, setStateStreamKey] = useState(streamKey);
-  useEffect(() => {
+  const [stateStreamKey, setStateStreamKey] = useState2(streamKey);
+  useEffect2(() => {
     if (streamKeyRef.current !== streamKey) {
       streamKeyRef.current = streamKey;
       setStateStreamKey(streamKey);
@@ -1167,7 +339,7 @@ function useSessionEvents(sessionId, options = {}) {
     streamEpoch,
     reconcileSession
   ]);
-  const loadOlder = useCallback(async () => {
+  const loadOlder = useCallback2(async () => {
     if (!sessionId || loadingOlderRef.current || !hasOlderRef.current) {
       return false;
     }
@@ -1229,7 +401,7 @@ function useSessionEvents(sessionId, options = {}) {
   }, [client, workspaceId, sessionId]);
   const identityMatches = stateStreamKey === streamKey;
   const visibleEvents = identityMatches ? eventWindow.events : EMPTY_EVENTS;
-  const timeline = useMemo(() => buildTimeline(visibleEvents), [visibleEvents]);
+  const timeline = useMemo2(() => buildTimeline(visibleEvents), [visibleEvents]);
   return {
     events: visibleEvents,
     timeline,
@@ -1540,7 +712,12 @@ async function loadPreviousPage(client, workspaceId, sessionId, before, options)
   const page = await client.listEvents(workspaceId, sessionId, {
     before,
     limit: requested,
-    compact: true
+    compact: true,
+    // Monitoring summaries omit correlation fields once a bounded durable
+    // payload exceeds their preview threshold. The browser timeline needs the
+    // sanitized stored payload so persisted tool outputs still match their
+    // calls and expose truthful truncation telemetry after a reload.
+    payloadMode: "full"
   });
   if (options.signal?.aborted) {
     throw abortError();
@@ -1560,11 +737,11 @@ function maxResumeSequence(events) {
   return events.reduce((max, event) => Math.max(max, eventResumeSequence(event)), 0);
 }
 function eventResumeSequence(event) {
-  const payload = asRecord2(event.payload);
+  const payload = asRecord(event.payload);
   const coalescedUntil = Number(payload.coalescedUntil);
   return Math.max(event.sequence, Number.isFinite(coalescedUntil) ? Math.floor(coalescedUntil) : 0);
 }
-function asRecord2(value) {
+function asRecord(value) {
   return value && typeof value === "object" ? value : {};
 }
 function assertAscending(events) {
@@ -1592,8 +769,199 @@ function abortError() {
   return error;
 }
 
+// src/hooks/use-file-attachments.ts
+import { useCallback as useCallback3, useRef as useRef2, useState as useState3 } from "react";
+var isImage = (file) => file.type.startsWith("image/");
+function useFileAttachments(options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const pasteFilter = options.pasteFilter ?? isImage;
+  const [attachments, setAttachments] = useState3([]);
+  const sources = useRef2(/* @__PURE__ */ new Map());
+  const startUpload = useCallback3(
+    (id, file) => {
+      void client.uploadFile(workspaceId, {
+        filename: file.name || "file",
+        contentType: file.type || "application/octet-stream",
+        data: file
+      }).then((asset) => {
+        sources.current.delete(id);
+        setAttachments(
+          (current) => current.map(
+            (attachment) => attachment.id === id ? {
+              ...attachment,
+              status: "ready",
+              file: asset,
+              name: asset.filename,
+              contentType: asset.contentType,
+              sizeBytes: asset.sizeBytes,
+              error: void 0
+            } : attachment
+          )
+        );
+      }).catch((error) => {
+        setAttachments(
+          (current) => current.map(
+            (attachment) => attachment.id === id ? {
+              ...attachment,
+              status: "failed",
+              error: error instanceof Error ? error.message : String(error)
+            } : attachment
+          )
+        );
+      });
+    },
+    [client, workspaceId]
+  );
+  const addFiles = useCallback3(
+    (files) => {
+      for (const file of files) {
+        const id = crypto.randomUUID();
+        sources.current.set(id, file);
+        const previewUrl = isImage(file) ? URL.createObjectURL(file) : void 0;
+        setAttachments((current) => [
+          ...current,
+          {
+            id,
+            name: file.name || "image",
+            contentType: file.type || "application/octet-stream",
+            sizeBytes: file.size,
+            status: "uploading",
+            ...previewUrl ? { previewUrl } : {}
+          }
+        ]);
+        startUpload(id, file);
+      }
+    },
+    [startUpload]
+  );
+  const retry = useCallback3(
+    (id) => {
+      const file = sources.current.get(id);
+      if (!file) {
+        return;
+      }
+      setAttachments(
+        (current) => current.map(
+          (attachment) => attachment.id === id ? { ...attachment, status: "uploading", error: void 0 } : attachment
+        )
+      );
+      startUpload(id, file);
+    },
+    [startUpload]
+  );
+  const addFromPaste = useCallback3(
+    (event) => {
+      const clipboardFiles = event.clipboardData?.files;
+      if (!clipboardFiles) {
+        return;
+      }
+      const files = [...clipboardFiles].filter(pasteFilter);
+      if (files.length > 0) {
+        addFiles(files);
+      }
+    },
+    [addFiles, pasteFilter]
+  );
+  const restoreReadyFiles = useCallback3(
+    (files) => {
+      const incoming = /* @__PURE__ */ new Map();
+      for (const file of files) {
+        if (file.status === "ready" && file.workspaceId === workspaceId) {
+          incoming.set(file.id, file);
+        }
+      }
+      setAttachments((current) => {
+        const unresolved = current.filter((attachment) => attachment.status !== "ready");
+        const existingReady = new Map(
+          current.flatMap(
+            (attachment) => attachment.status === "ready" && attachment.file ? [[attachment.file.id, attachment]] : []
+          )
+        );
+        const restored = [...incoming.values()].map((file) => {
+          const existing = existingReady.get(file.id);
+          return existing ? {
+            ...existing,
+            name: file.filename,
+            contentType: file.contentType,
+            sizeBytes: file.sizeBytes,
+            status: "ready",
+            file,
+            error: void 0
+          } : {
+            id: `restored:${file.id}`,
+            name: file.filename,
+            contentType: file.contentType,
+            sizeBytes: file.sizeBytes,
+            status: "ready",
+            file
+            // No source File and no object URL: server metadata is the
+            // only authority restored across page/device boundaries.
+          };
+        });
+        for (const [fileId, attachment] of existingReady) {
+          if (!incoming.has(fileId) && attachment.previewUrl) {
+            URL.revokeObjectURL(attachment.previewUrl);
+          }
+        }
+        return [...unresolved, ...restored];
+      });
+    },
+    [workspaceId]
+  );
+  const remove = useCallback3((id) => {
+    sources.current.delete(id);
+    setAttachments((current) => {
+      const removed = current.find((attachment) => attachment.id === id);
+      if (removed?.previewUrl) {
+        URL.revokeObjectURL(removed.previewUrl);
+      }
+      return current.filter((attachment) => attachment.id !== id);
+    });
+  }, []);
+  const removeReadyFiles = useCallback3((fileIds) => {
+    const accepted = new Set(fileIds);
+    if (accepted.size === 0) return;
+    setAttachments(
+      (current) => current.filter((attachment) => {
+        const removeAccepted = attachment.status === "ready" && attachment.file !== void 0 && accepted.has(attachment.file.id);
+        if (removeAccepted) {
+          sources.current.delete(attachment.id);
+          if (attachment.previewUrl) URL.revokeObjectURL(attachment.previewUrl);
+        }
+        return !removeAccepted;
+      })
+    );
+  }, []);
+  const clear = useCallback3(() => {
+    sources.current.clear();
+    setAttachments((current) => {
+      for (const attachment of current) {
+        if (attachment.previewUrl) {
+          URL.revokeObjectURL(attachment.previewUrl);
+        }
+      }
+      return [];
+    });
+  }, []);
+  return {
+    attachments,
+    readyResources: attachments.flatMap(
+      (attachment) => attachment.status === "ready" && attachment.file ? [{ kind: "file", fileId: attachment.file.id }] : []
+    ),
+    uploading: attachments.some((attachment) => attachment.status === "uploading"),
+    hasUnresolved: attachments.some((attachment) => attachment.status !== "ready"),
+    addFiles,
+    addFromPaste,
+    restoreReadyFiles,
+    retry,
+    remove,
+    removeReadyFiles,
+    clear
+  };
+}
+
 // src/hooks/use-turn-queue.ts
-import { useCallback as useCallback2, useEffect as useEffect2, useLayoutEffect, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect3, useLayoutEffect, useMemo as useMemo3, useRef as useRef3, useState as useState4 } from "react";
 function isTurnQueueEvent(event) {
   return event.type.startsWith("turn.") || event.type.startsWith("session.queue.") || event.type.startsWith("session.control.") || event.type.startsWith("workspace.inference.");
 }
@@ -1607,16 +975,16 @@ function useTurnQueue(sessionId, options = {}) {
   const { client, workspaceId, workspaceControlEvent, registerSessionReconciler } = useEmbeddedSession(options);
   const enabled = (options.enabled ?? true) && Boolean(sessionId);
   const targetKey = `${workspaceId}\0${sessionId ?? ""}`;
-  const [snapshot, setSnapshot] = useState2(null);
-  const [stateTargetKey, setStateTargetKey] = useState2(targetKey);
-  const [loading, setLoading] = useState2(enabled);
-  const [error, setError] = useState2(null);
-  const [mutationError, setMutationError] = useState2(null);
-  const [pendingByTurn, setPendingByTurn] = useState2({});
-  const pendingRef = useRef2({});
-  const readGeneration = useRef2(0);
-  const targetKeyRef = useRef2(targetKey);
-  const snapshotRef = useRef2(null);
+  const [snapshot, setSnapshot] = useState4(null);
+  const [stateTargetKey, setStateTargetKey] = useState4(targetKey);
+  const [loading, setLoading] = useState4(enabled);
+  const [error, setError] = useState4(null);
+  const [mutationError, setMutationError] = useState4(null);
+  const [pendingByTurn, setPendingByTurn] = useState4({});
+  const pendingRef = useRef3({});
+  const readGeneration = useRef3(0);
+  const targetKeyRef = useRef3(targetKey);
+  const snapshotRef = useRef3(null);
   useLayoutEffect(() => {
     if (targetKeyRef.current === targetKey) return;
     targetKeyRef.current = targetKey;
@@ -1630,7 +998,7 @@ function useTurnQueue(sessionId, options = {}) {
     setMutationError(null);
     setPendingByTurn({});
   }, [enabled, targetKey]);
-  const acceptSnapshot = useCallback2(
+  const acceptSnapshot = useCallback4(
     (ownedTargetKey, next) => {
       if (targetKeyRef.current !== ownedTargetKey) return false;
       const current = snapshotRef.current;
@@ -1644,7 +1012,7 @@ function useTurnQueue(sessionId, options = {}) {
     },
     []
   );
-  const load = useCallback2(
+  const load = useCallback4(
     async (rejectOnFailure = false) => {
       if (!sessionId) return;
       const ownedTargetKey = `${workspaceId}\0${sessionId}`;
@@ -1675,7 +1043,7 @@ function useTurnQueue(sessionId, options = {}) {
     },
     [client, workspaceId, sessionId, acceptSnapshot]
   );
-  useEffect2(() => {
+  useEffect3(() => {
     if (!enabled) {
       setLoading(false);
       return;
@@ -1694,10 +1062,10 @@ function useTurnQueue(sessionId, options = {}) {
       readGeneration.current += 1;
     };
   }, [load, enabled, options.pollIntervalMs]);
-  useEffect2(() => {
+  useEffect3(() => {
     if (enabled && workspaceControlEvent) void load();
   }, [enabled, load, workspaceControlEvent]);
-  useEffect2(() => {
+  useEffect3(() => {
     if (!sessionId || !enabled) return;
     return registerSessionReconciler(sessionId, "queue", load);
   }, [enabled, load, registerSessionReconciler, sessionId]);
@@ -1714,7 +1082,7 @@ function useTurnQueue(sessionId, options = {}) {
     },
     async () => await load(true)
   );
-  const mutate = useCallback2(
+  const mutate = useCallback4(
     async (turnId, kind, command) => {
       const ownedTargetKey = targetKey;
       if (!sessionId || targetKeyRef.current !== ownedTargetKey || pendingRef.current[turnId]) {
@@ -1749,7 +1117,7 @@ function useTurnQueue(sessionId, options = {}) {
     },
     [acceptSnapshot, load, sessionId, targetKey]
   );
-  const moveTurn = useCallback2(
+  const moveTurn = useCallback4(
     async (turnId, beforeTurnId) => {
       const result = await mutate(
         turnId,
@@ -1764,7 +1132,7 @@ function useTurnQueue(sessionId, options = {}) {
     },
     [client, mutate, sessionId, workspaceId]
   );
-  const editTurn = useCallback2(
+  const editTurn = useCallback4(
     async (turnId, edit) => {
       const result = await mutate(
         turnId,
@@ -1780,7 +1148,7 @@ function useTurnQueue(sessionId, options = {}) {
     },
     [client, mutate, sessionId, workspaceId]
   );
-  const steerTurn = useCallback2(
+  const steerTurn = useCallback4(
     async (turnId) => {
       const result = await mutate(
         turnId,
@@ -1795,7 +1163,7 @@ function useTurnQueue(sessionId, options = {}) {
     },
     [client, mutate, sessionId, workspaceId]
   );
-  const removeTurn = useCallback2(
+  const removeTurn = useCallback4(
     async (turnId) => {
       const result = await mutate(
         turnId,
@@ -1813,11 +1181,11 @@ function useTurnQueue(sessionId, options = {}) {
   const identityMatches = stateTargetKey === targetKey;
   const visibleSnapshot = identityMatches ? snapshot : null;
   const visiblePendingByTurn = identityMatches ? pendingByTurn : EMPTY_PENDING_BY_TURN;
-  const mutating = useMemo2(
+  const mutating = useMemo3(
     () => Object.keys(visiblePendingByTurn).length > 0,
     [visiblePendingByTurn]
   );
-  const mutationFor = useCallback2(
+  const mutationFor = useCallback4(
     (turnId) => visiblePendingByTurn[turnId] ?? null,
     [visiblePendingByTurn]
   );
@@ -1837,7 +1205,7 @@ function useTurnQueue(sessionId, options = {}) {
     mutationFor,
     mutating,
     mutationError: identityMatches ? mutationError : null,
-    clearMutationError: useCallback2(() => {
+    clearMutationError: useCallback4(() => {
       if (targetKeyRef.current === targetKey) setMutationError(null);
     }, [targetKey])
   };
@@ -1849,12 +1217,154 @@ function asError(cause) {
   return cause instanceof Error ? cause : new Error(String(cause));
 }
 
+// src/hooks/use-goal.ts
+import { OpenGeniApiError } from "@opengeni/sdk";
+import { useCallback as useCallback5, useEffect as useEffect4, useRef as useRef4, useState as useState5 } from "react";
+function isGoalEvent(event) {
+  return event.type.startsWith("goal.");
+}
+function isGoalRefreshEvent(event) {
+  const type = event.type;
+  return isGoalEvent(event) || type.startsWith("turn.") || type.startsWith("session.") || type.startsWith("system.update.") || type.startsWith("workspace.inference.") || type.startsWith("user.");
+}
+function useGoal(sessionId, options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const sharedEvents = options.events;
+  const sharedFeed = sharedEvents !== void 0;
+  const [goal, setGoal] = useState5(null);
+  const [loading, setLoading] = useState5(enabled);
+  const [error, setError] = useState5(null);
+  const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
+  const generation = useRef4(0);
+  const targetKeyRef = useRef4(null);
+  const load = useCallback5(async () => {
+    if (!sessionId) {
+      return;
+    }
+    const ticket = ++generation.current;
+    try {
+      const fetched = await client.getGoal(workspaceId, sessionId);
+      if (ticket === generation.current) {
+        setGoal(fetched);
+        setError(null);
+        setLoading(false);
+      }
+    } catch (cause) {
+      if (ticket !== generation.current) {
+        return;
+      }
+      if (cause instanceof OpenGeniApiError && cause.status === 404) {
+        setGoal(null);
+        setError(null);
+      } else {
+        setError(cause instanceof Error ? cause : new Error(String(cause)));
+      }
+      setLoading(false);
+    }
+  }, [client, workspaceId, sessionId]);
+  useEffect4(() => {
+    const targetKey = `${workspaceId} ${sessionId ?? ""}`;
+    if (targetKeyRef.current !== targetKey) {
+      targetKeyRef.current = targetKey;
+      setGoal(null);
+      setError(null);
+    }
+    if (!enabled) {
+      setLoading(false);
+      return;
+    }
+    if (sharedFeed) {
+      setLoading(false);
+      return () => {
+        generation.current += 1;
+      };
+    }
+    setLoading(true);
+    void load();
+    const pollIntervalMs = options.pollIntervalMs;
+    if (pollIntervalMs === void 0 || pollIntervalMs <= 0) {
+      return () => {
+        generation.current += 1;
+      };
+    }
+    const timer = setInterval(() => void load(), pollIntervalMs);
+    return () => {
+      clearInterval(timer);
+      generation.current += 1;
+    };
+  }, [load, enabled, workspaceId, sessionId, options.pollIntervalMs, sharedFeed]);
+  const scheduleRefresh = useDebouncedCallback(() => void load());
+  useSessionEventTrigger(client, workspaceId, sessionId, isGoalRefreshEvent, scheduleRefresh, {
+    enabled,
+    ...sharedEvents !== void 0 ? { events: sharedEvents } : {}
+  });
+  const pause = useCallback5(
+    async (rationale) => {
+      if (!sessionId) {
+        return null;
+      }
+      const result = await run(
+        () => client.updateGoal(workspaceId, sessionId, {
+          status: "paused",
+          ...rationale !== void 0 ? { rationale } : {}
+        })
+      );
+      if (result) {
+        setGoal(result);
+      }
+      return result;
+    },
+    [client, workspaceId, sessionId, run]
+  );
+  const resume = useCallback5(async () => {
+    if (!sessionId) {
+      return null;
+    }
+    const result = await run(() => client.updateGoal(workspaceId, sessionId, { status: "active" }));
+    if (result) {
+      setGoal(result);
+    }
+    return result;
+  }, [client, workspaceId, sessionId, run]);
+  const clearGoal = useCallback5(async () => {
+    if (!sessionId) {
+      return;
+    }
+    const ok = await run(async () => {
+      await client.deleteGoal(workspaceId, sessionId);
+      return true;
+    });
+    if (ok) {
+      generation.current += 1;
+      setGoal(null);
+      setError(null);
+    }
+  }, [client, workspaceId, sessionId, run]);
+  return {
+    goal,
+    isActive: goal?.status === "active",
+    isPaused: goal?.status === "paused",
+    isCompleted: goal?.status === "completed",
+    loading,
+    error,
+    refresh: load,
+    pause,
+    resume,
+    clearGoal,
+    deleteGoal: clearGoal,
+    updating: mutating,
+    mutationError,
+    clearMutationError
+  };
+}
+
 // src/hooks/use-session-control.ts
-import { useCallback as useCallback3, useLayoutEffect as useLayoutEffect2, useRef as useRef3 } from "react";
+import { useCallback as useCallback6, useLayoutEffect as useLayoutEffect2, useRef as useRef5 } from "react";
 function useSessionControl(sessionId, options = {}) {
   const { client, workspaceId } = useEmbeddedSession(options);
   const approvalTargetKey = `${workspaceId}\0${sessionId ?? ""}`;
-  const pendingApproval = useRef3(null);
+  const pendingApproval = useRef5(null);
   useLayoutEffect2(() => {
     if (pendingApproval.current?.targetKey !== approvalTargetKey) {
       pendingApproval.current = null;
@@ -1872,7 +1382,7 @@ function useSessionControl(sessionId, options = {}) {
     mutationError: approvalError,
     clearMutationError: clearApprovalError
   } = useMutationRunner(approvalTargetKey);
-  const pause = useCallback3(
+  const pause = useCallback6(
     async (reason) => {
       if (!sessionId) {
         return null;
@@ -1883,7 +1393,7 @@ function useSessionControl(sessionId, options = {}) {
     },
     [client, workspaceId, sessionId, runControl]
   );
-  const resume = useCallback3(
+  const resume = useCallback6(
     async (reason) => {
       if (!sessionId) return null;
       return await runControl(
@@ -1892,7 +1402,7 @@ function useSessionControl(sessionId, options = {}) {
     },
     [client, workspaceId, sessionId, runControl]
   );
-  const decide = useCallback3(
+  const decide = useCallback6(
     async (approvalId, decision, message) => {
       if (!sessionId) {
         return null;
@@ -1921,16 +1431,16 @@ function useSessionControl(sessionId, options = {}) {
     },
     [approvalTargetKey, client, workspaceId, sessionId, runApproval]
   );
-  const approve = useCallback3(
+  const approve = useCallback6(
     async (approvalId, message) => await decide(approvalId, "approve", message),
     [decide]
   );
-  const reject = useCallback3(
+  const reject = useCallback6(
     async (approvalId, message) => await decide(approvalId, "reject", message),
     [decide]
   );
   const error = approvalError ?? controlError;
-  const clearError = useCallback3(() => {
+  const clearError = useCallback6(() => {
     clearControlError();
     clearApprovalError();
   }, [clearControlError, clearApprovalError]);
@@ -1947,7 +1457,7 @@ function useSessionControl(sessionId, options = {}) {
 }
 
 // src/hooks/use-session-mcp-approval-policy.ts
-import { useCallback as useCallback4, useEffect as useEffect3, useLayoutEffect as useLayoutEffect3, useMemo as useMemo3, useRef as useRef4, useState as useState3 } from "react";
+import { useCallback as useCallback7, useEffect as useEffect5, useLayoutEffect as useLayoutEffect3, useMemo as useMemo4, useRef as useRef6, useState as useState6 } from "react";
 function isSessionMcpApprovalPolicyEvent(event, serverId) {
   if (event.type !== "session.mcp.approval_policy.updated") {
     return false;
@@ -1961,16 +1471,16 @@ function isSessionMcpApprovalPolicyEvent(event, serverId) {
 function useSessionMcpApprovalPolicy(sessionId, serverId, options = {}) {
   const { client, workspaceId } = useEmbeddedSessionMcpApprovalPolicy(options);
   const enabled = (options.enabled ?? true) && Boolean(sessionId && serverId);
-  const [override, setOverride] = useState3(null);
+  const [override, setOverride] = useState6(null);
   const targetKey = `${workspaceId}\0${sessionId ?? ""}\0${serverId ?? ""}`;
-  const authoritativeGeneration = useRef4(0);
-  const mutationIdentity = useMemo3(() => ({ client, targetKey }), [client, targetKey]);
+  const authoritativeGeneration = useRef6(0);
+  const mutationIdentity = useMemo4(() => ({ client, targetKey }), [client, targetKey]);
   const { run, mutating, mutationError, clearMutationError } = useMutationRunner(mutationIdentity);
   useLayoutEffect3(() => {
     authoritativeGeneration.current += 1;
     setOverride(null);
   }, [client, targetKey]);
-  const load = useCallback4(async () => {
+  const load = useCallback7(async () => {
     const generation = authoritativeGeneration.current;
     if (!sessionId || !serverId) {
       return { targetKey, generation, server: null };
@@ -1991,13 +1501,13 @@ function useSessionMcpApprovalPolicy(sessionId, serverId, options = {}) {
     enabled,
     pollIntervalMs: options.pollIntervalMs
   });
-  useEffect3(() => {
+  useEffect5(() => {
     if (data?.targetKey === targetKey && data.generation === authoritativeGeneration.current) {
       setOverride(null);
     }
   }, [data, targetKey]);
   const scheduleRefresh = useDebouncedCallback(() => void refresh());
-  const matchesPolicyEvent = useCallback4(
+  const matchesPolicyEvent = useCallback7(
     (event) => isSessionMcpApprovalPolicyEvent(event, serverId ?? void 0),
     [serverId]
   );
@@ -2013,7 +1523,7 @@ function useSessionMcpApprovalPolicy(sessionId, serverId, options = {}) {
     },
     async () => await refresh()
   );
-  const update = useCallback4(
+  const update = useCallback7(
     async (policy) => {
       if (!sessionId || !serverId) {
         return null;
@@ -2047,6 +1557,91 @@ function useSessionMcpApprovalPolicy(sessionId, serverId, options = {}) {
   };
 }
 
+// src/hooks/use-session-lineage.ts
+import { useCallback as useCallback8, useEffect as useEffect6, useRef as useRef7 } from "react";
+function isLineageRefreshEvent(event) {
+  if (event.type === "session.status.changed" || event.type === "session.created") {
+    return true;
+  }
+  if (event.type === "agent.toolCall.output") {
+    const payload = event.payload;
+    const name = typeof payload?.name === "string" ? payload.name : typeof payload?.toolName === "string" ? payload.toolName : "";
+    return name === "session_create" || name.endsWith("__session_create");
+  }
+  return false;
+}
+function isSessionCreateToolCallCreated(event) {
+  if (event.type !== "agent.toolCall.created") {
+    return false;
+  }
+  const payload = event.payload;
+  const name = typeof payload?.name === "string" ? payload.name : typeof payload?.toolName === "string" ? payload.toolName : "";
+  return name === "session_create" || name.endsWith("__session_create");
+}
+function useSessionLineage(sessionId, options = {}) {
+  const { client, workspaceId, workspaceControlEvent, registerSessionReconciler } = useOpenGeni(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const load = useCallback8(
+    async () => sessionId ? await client.getSessionLineage(workspaceId, sessionId) : { ancestors: [], children: [], truncated: false },
+    [client, workspaceId, sessionId]
+  );
+  const state = usePolledValue(load, { pollIntervalMs: options.pollIntervalMs, enabled });
+  const refresh = state.refresh;
+  useEffect6(() => {
+    if (enabled && workspaceControlEvent) void refresh();
+  }, [enabled, refresh, workspaceControlEvent]);
+  useEffect6(() => {
+    if (!sessionId || !enabled) return;
+    return registerSessionReconciler(sessionId, "lineage", refresh);
+  }, [enabled, refresh, registerSessionReconciler, sessionId]);
+  const refreshSoon = useDebouncedCallback(() => void refresh(), 150);
+  const delayedChildRefreshRef = useRef7(null);
+  useEffect6(() => {
+    return () => {
+      if (delayedChildRefreshRef.current !== null) {
+        clearTimeout(delayedChildRefreshRef.current);
+        delayedChildRefreshRef.current = null;
+      }
+    };
+  }, [sessionId, workspaceId]);
+  const refreshAfterChildCreate = useCallback8(() => {
+    void refresh();
+    if (delayedChildRefreshRef.current !== null) {
+      clearTimeout(delayedChildRefreshRef.current);
+    }
+    delayedChildRefreshRef.current = setTimeout(() => {
+      delayedChildRefreshRef.current = null;
+      void refresh();
+    }, 2500);
+  }, [refresh]);
+  useSessionEventTrigger(
+    client,
+    workspaceId,
+    sessionId,
+    isLineageRefreshEvent,
+    refreshSoon,
+    // SHARED-FEED ONLY: without a caller-provided events log the trigger would
+    // open its OWN streamEvents tail — a second live SSE connection next to the
+    // session route's useSessionEvents. A caller with no feed opts into polling
+    // (pollIntervalMs), never a duplicate stream.
+    { events: options.events, enabled: enabled && options.events !== void 0 }
+  );
+  useSessionEventTrigger(
+    client,
+    workspaceId,
+    sessionId,
+    isSessionCreateToolCallCreated,
+    refreshAfterChildCreate,
+    { events: options.events, enabled: enabled && options.events !== void 0 }
+  );
+  return {
+    lineage: state.data,
+    loading: state.loading,
+    error: state.error,
+    refresh
+  };
+}
+
 // src/approvals.ts
 function approvalsFromRequiresAction(payload) {
   const approvals = payload && typeof payload === "object" ? payload.approvals : void 0;
@@ -2141,14 +1736,14 @@ function isRecord(value) {
 }
 
 // src/hooks/use-human-input.ts
-import { useCallback as useCallback5, useEffect as useEffect4, useRef as useRef5, useState as useState4 } from "react";
+import { useCallback as useCallback9, useEffect as useEffect7, useRef as useRef8, useState as useState7 } from "react";
 function isHumanInputEvent(event) {
   return event.type === "session.humanInput.requested" || event.type === "user.humanInputResponse" || event.type === "turn.completed" || event.type === "turn.failed" || event.type === "turn.cancelled";
 }
 function useHumanInputRequests(sessionId, options = {}) {
   const { client, workspaceId, registerSessionReconciler } = useEmbeddedHumanInputSession(options);
   const enabled = (options.enabled ?? true) && Boolean(sessionId);
-  const load = useCallback5(
+  const load = useCallback9(
     async () => sessionId ? await client.listHumanInputRequests(workspaceId, sessionId, { status: "pending" }) : [],
     [client, sessionId, workspaceId]
   );
@@ -2157,13 +1752,13 @@ function useHumanInputRequests(sessionId, options = {}) {
     pollIntervalMs: options.pollIntervalMs
   });
   const mutation = useMutationRunner(`${workspaceId}\0${sessionId ?? ""}`);
-  const [respondingRequestId, setRespondingRequestId] = useState4(null);
-  const respondingRequestRef = useRef5(null);
-  useEffect4(() => {
+  const [respondingRequestId, setRespondingRequestId] = useState7(null);
+  const respondingRequestRef = useRef8(null);
+  useEffect7(() => {
     respondingRequestRef.current = null;
     setRespondingRequestId(null);
   }, [sessionId, workspaceId]);
-  useEffect4(() => {
+  useEffect7(() => {
     if (!sessionId || !enabled) return;
     return registerSessionReconciler(sessionId, "human-input", state.refresh);
   }, [enabled, registerSessionReconciler, sessionId, state.refresh]);
@@ -2172,7 +1767,7 @@ function useHumanInputRequests(sessionId, options = {}) {
     enabled,
     ...options.events !== void 0 ? { events: options.events } : {}
   });
-  const respond = useCallback5(
+  const respond = useCallback9(
     async (requestId, response) => {
       if (!sessionId || respondingRequestRef.current !== null) return null;
       respondingRequestRef.current = requestId;
@@ -2209,12 +1804,8 @@ function useHumanInputRequests(sessionId, options = {}) {
 }
 
 export {
-  buildTimeline,
-  creditExhaustedFromEvents,
-  sessionStatusFromEvents,
-  groupTimeline,
-  extractSessionRef,
-  toolDisplayName,
+  isTitleEvent,
+  useSession,
   SESSION_EVENT_BROWSER_MAX_BYTES,
   SESSION_EVENT_BROWSER_MAX_COUNT,
   SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES,
@@ -2222,11 +1813,16 @@ export {
   SESSION_EVENT_BROWSER_PENDING_MAX_COUNT,
   useSessionEvents,
   boundBrowserSessionEventWindow,
+  useFileAttachments,
   isTurnQueueEvent,
   useTurnQueue,
+  isGoalEvent,
+  useGoal,
   useSessionControl,
   isSessionMcpApprovalPolicyEvent,
   useSessionMcpApprovalPolicy,
+  isLineageRefreshEvent,
+  useSessionLineage,
   approvalsFromRequiresAction,
   projectPendingApprovals,
   humanInputRequestFromEvent,
@@ -2234,4 +1830,4 @@ export {
   isHumanInputEvent,
   useHumanInputRequests
 };
-//# sourceMappingURL=chunk-UAHPKLB6.js.map
+//# sourceMappingURL=chunk-MP6237JB.js.map