@opengeni/react 0.1.0

package/dist/index.js

@@ -0,0 +1,3013 @@
+// src/provider.tsx
+import { createContext, useContext, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+var OpenGeniContext = createContext(null);
+function OpenGeniProvider({ client, workspaceId, children }) {
+  const value = useMemo(() => ({ client, workspaceId }), [client, workspaceId]);
+  return /* @__PURE__ */ jsx(OpenGeniContext.Provider, { value, children });
+}
+function useOpenGeni(override = {}) {
+  const context = useContext(OpenGeniContext);
+  const client = override.client ?? context?.client;
+  const workspaceId = override.workspaceId ?? context?.workspaceId;
+  if (!client || !workspaceId) {
+    throw new Error(
+      "@opengeni/react: no OpenGeni client/workspace available. Wrap the tree in <OpenGeniProvider> or pass { client, workspaceId } to the hook."
+    );
+  }
+  return { client, workspaceId };
+}
+function useOpenGeniClient(override = {}) {
+  const context = useContext(OpenGeniContext);
+  const client = override.client ?? context?.client;
+  if (!client) {
+    throw new Error(
+      "@opengeni/react: no OpenGeni client available. Wrap the tree in <OpenGeniProvider> or pass { client } to the hook."
+    );
+  }
+  return client;
+}
+
+// src/hooks/use-session.ts
+import { useCallback as useCallback2 } from "react";
+
+// src/hooks/internal.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+function usePolledValue(load, options = {}) {
+  const enabled = options.enabled ?? true;
+  const pollIntervalMs = options.pollIntervalMs;
+  const [data, setData] = useState(null);
+  const [loading, setLoading] = useState(enabled);
+  const [error, setError] = useState(null);
+  const generation = useRef(0);
+  const loadRef = useRef(load);
+  useEffect(() => {
+    if (loadRef.current !== load) {
+      loadRef.current = load;
+      setData(null);
+      setError(null);
+    }
+  }, [load]);
+  const run = useCallback(async () => {
+    const ticket = ++generation.current;
+    try {
+      const result = await load();
+      if (ticket === generation.current) {
+        setData(result);
+        setError(null);
+        setLoading(false);
+      }
+    } catch (cause) {
+      if (ticket === generation.current) {
+        setError(cause instanceof Error ? cause : new Error(String(cause)));
+        setLoading(false);
+      }
+    }
+  }, [load]);
+  useEffect(() => {
+    if (!enabled) {
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    void run();
+    if (pollIntervalMs === void 0 || pollIntervalMs <= 0) {
+      return () => {
+        generation.current += 1;
+      };
+    }
+    const timer = setInterval(() => void run(), pollIntervalMs);
+    return () => {
+      clearInterval(timer);
+      generation.current += 1;
+    };
+  }, [run, enabled, pollIntervalMs]);
+  return { data, loading, error, refresh: run };
+}
+function useMutationRunner() {
+  const [mutating, setMutating] = useState(false);
+  const [mutationError, setMutationError] = useState(null);
+  const inFlight = useRef(0);
+  const mounted = useRef(true);
+  useEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+  const run = useCallback(async (operation) => {
+    inFlight.current += 1;
+    if (mounted.current) {
+      setMutating(true);
+      setMutationError(null);
+    }
+    try {
+      return await operation();
+    } catch (cause) {
+      if (mounted.current) {
+        setMutationError(cause instanceof Error ? cause : new Error(String(cause)));
+      }
+      return null;
+    } finally {
+      inFlight.current -= 1;
+      if (mounted.current && inFlight.current === 0) {
+        setMutating(false);
+      }
+    }
+  }, []);
+  return {
+    mutating,
+    mutationError,
+    clearMutationError: useCallback(() => setMutationError(null), []),
+    run
+  };
+}
+function useSessionEventTrigger(client, workspaceId, sessionId, match, onEvent, options = {}) {
+  const enabled = options.enabled ?? true;
+  const events = options.events;
+  const sharedFeed = events !== void 0;
+  const matchRef = useRef(match);
+  matchRef.current = match;
+  const onEventRef = useRef(onEvent);
+  onEventRef.current = onEvent;
+  const consumedRef = useRef(0);
+  const feedKeyRef = useRef(null);
+  useEffect(() => {
+    if (!sharedFeed || !enabled || !sessionId) {
+      return;
+    }
+    const feedKey = `${workspaceId}\0${sessionId}`;
+    const firstSequence = events[0]?.sequence ?? 0;
+    if (feedKeyRef.current !== feedKey || firstSequence > consumedRef.current + 1) {
+      feedKeyRef.current = feedKey;
+      consumedRef.current = 0;
+    }
+    for (const event of events) {
+      if (event.sequence <= consumedRef.current) {
+        continue;
+      }
+      consumedRef.current = event.sequence;
+      if (matchRef.current(event)) {
+        onEventRef.current(event);
+      }
+    }
+  }, [sharedFeed, enabled, events, workspaceId, sessionId]);
+  useEffect(() => {
+    if (sharedFeed || !enabled || !sessionId) {
+      return;
+    }
+    const controller = new AbortController();
+    void (async () => {
+      try {
+        const session = await client.getSession(workspaceId, sessionId);
+        if (controller.signal.aborted) {
+          return;
+        }
+        const stream = client.streamEvents(workspaceId, sessionId, {
+          after: session.lastSequence,
+          signal: controller.signal
+        });
+        for await (const event of stream) {
+          if (matchRef.current(event)) {
+            onEventRef.current(event);
+          }
+        }
+      } catch {
+      }
+    })();
+    return () => {
+      controller.abort();
+    };
+  }, [sharedFeed, enabled, client, workspaceId, sessionId]);
+}
+function useDebouncedCallback(callback, delayMs = 150) {
+  const callbackRef = useRef(callback);
+  callbackRef.current = callback;
+  const timerRef = useRef(null);
+  useEffect(() => {
+    return () => {
+      if (timerRef.current !== null) {
+        clearTimeout(timerRef.current);
+      }
+    };
+  }, []);
+  return useCallback(() => {
+    if (timerRef.current !== null) {
+      clearTimeout(timerRef.current);
+    }
+    timerRef.current = setTimeout(() => {
+      timerRef.current = null;
+      callbackRef.current();
+    }, delayMs);
+  }, [delayMs]);
+}
+
+// src/hooks/use-session.ts
+function useSession(sessionId, options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const load = useCallback2(async () => {
+    if (!sessionId) {
+      return null;
+    }
+    return await client.getSession(workspaceId, sessionId);
+  }, [client, workspaceId, sessionId]);
+  const state = usePolledValue(load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled: (options.enabled ?? true) && Boolean(sessionId)
+  });
+  return { session: state.data ?? null, loading: state.loading, error: state.error, refresh: state.refresh };
+}
+
+// src/hooks/use-session-events.ts
+import { useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+
+// src/lib/format.ts
+function formatRelativeTime(iso, now = /* @__PURE__ */ new Date()) {
+  const then = new Date(iso).getTime();
+  if (Number.isNaN(then)) {
+    return "";
+  }
+  const seconds = Math.max(0, Math.floor((now.getTime() - then) / 1e3));
+  if (seconds < 10) {
+    return "now";
+  }
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) {
+    return `${minutes}m`;
+  }
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) {
+    return `${hours}h`;
+  }
+  const days = Math.floor(hours / 24);
+  if (days < 14) {
+    return `${days}d`;
+  }
+  return new Date(iso).toLocaleDateString();
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  }
+  const units = ["KB", "MB", "GB"];
+  let value = bytes / 1024;
+  for (const unit of units) {
+    if (value < 1024 || unit === "GB") {
+      return `${value.toFixed(value < 10 ? 1 : 0)} ${unit}`;
+    }
+    value /= 1024;
+  }
+  return `${bytes} B`;
+}
+function truncate(text, maxLength) {
+  const collapsed = text.replace(/\s+/g, " ").trim();
+  if (collapsed.length <= maxLength) {
+    return collapsed;
+  }
+  return `${collapsed.slice(0, Math.max(0, maxLength - 1)).trimEnd()}\u2026`;
+}
+function stringifyPayload(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "string") {
+    const parsed = tryParseJson(value);
+    if (parsed !== void 0 && typeof parsed === "object") {
+      return stringifyPayload(parsed);
+    }
+    return value;
+  }
+  try {
+    return JSON.stringify(value, null, 2) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function tryParseJson(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[") && !trimmed.startsWith('"')) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/timeline.ts
+var WORKER_SPAWN_TOOL = "session_create";
+var WORKER_MESSAGE_TOOL = "session_send_message";
+function buildTimeline(events) {
+  const items = [];
+  const ordered = [...events].sort((a, b) => a.sequence - b.sequence);
+  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) => {
+    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 = "complete";
+      }
+      if (item.kind === "sandbox" && item.status === "running") {
+        item.status = "complete";
+      }
+    }
+  };
+  for (const event of ordered) {
+    const payload = asRecord(event.payload);
+    const turnId = event.turnId ?? null;
+    switch (event.type) {
+      case "user.message": {
+        closeStreamingTail();
+        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,
+          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 = "complete";
+          target.workerSessionId = target.workerSessionId ?? extractSessionRef(payload.output);
+          break;
+        }
+        target.status = "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";
+        const existing = findOpenSandbox(items, name);
+        if (existing && status !== "running") {
+          existing.status = status;
+          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) ?? "",
+            status,
+            occurredAt: event.occurredAt
+          });
+        }
+        break;
+      }
+      case "sandbox.command.output.delta": {
+        const text = 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;
+        }
+        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 "turn.completed": {
+        finalizeOpen(turnId);
+        break;
+      }
+      case "turn.failed": {
+        finalizeOpen(turnId);
+        items.push({
+          kind: "notice",
+          id: event.id,
+          tone: "failed",
+          text: failureMessage(payload) ?? "The turn failed.",
+          occurredAt: event.occurredAt
+        });
+        break;
+      }
+      case "turn.cancelled": {
+        finalizeOpen(turnId);
+        items.push({
+          kind: "notice",
+          id: event.id,
+          tone: "cancelled",
+          text: "Interrupted.",
+          occurredAt: event.occurredAt
+        });
+        break;
+      }
+      case "goal.set":
+      case "goal.updated":
+      case "goal.completed":
+      case "goal.paused":
+      case "goal.resumed":
+      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 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;
+}
+var ACTIVITY_KINDS = /* @__PURE__ */ new Set(["reasoning", "tool-call", "worker", "sandbox"]);
+function groupTimeline(items) {
+  const groups = [];
+  for (const item of items) {
+    if (ACTIVITY_KINDS.has(item.kind)) {
+      const open = groups[groups.length - 1];
+      const activity = item;
+      if (open?.kind === "activity") {
+        open.items.push(activity);
+      } else {
+        groups.push({ kind: "activity", id: `activity-${item.id}`, items: [activity] });
+      }
+      continue;
+    }
+    groups.push({ kind: "item", item });
+  }
+  return groups;
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" ? value : {};
+}
+var SESSION_STATUSES = ["queued", "running", "idle", "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 isSessionStatus(value) {
+  return typeof value === "string" && SESSION_STATUSES.includes(value);
+}
+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");
+}
+function failureMessage(payload) {
+  for (const key of ["error", "message"]) {
+    const value = payload[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return 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 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) {
+  return name.replace(/[_-]+/g, " ").trim();
+}
+function compactPayloadPreview(value, maxLength = 120) {
+  const text = stringifyPayload(value).replace(/\s+/g, " ").trim();
+  return text.length > maxLength ? `${text.slice(0, maxLength - 1)}\u2026` : text;
+}
+
+// src/hooks/use-session-events.ts
+function useSessionEvents(sessionId, options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const enabled = options.enabled ?? true;
+  const after = options.after ?? 0;
+  const [events, setEvents] = useState2([]);
+  const [connectionState, setConnectionState] = useState2("idle");
+  const [error, setError] = useState2(null);
+  const lastSequenceRef = useRef2(after);
+  const streamKeyRef = useRef2(null);
+  useEffect2(() => {
+    const streamKey = `${workspaceId}\0${sessionId ?? ""}\0${after}`;
+    if (streamKeyRef.current !== streamKey) {
+      streamKeyRef.current = streamKey;
+      setEvents([]);
+      setError(null);
+      lastSequenceRef.current = after;
+    }
+    if (!sessionId || !enabled) {
+      setConnectionState("idle");
+      return;
+    }
+    const controller = new AbortController();
+    let pending = [];
+    let flushTimer = null;
+    const flush = () => {
+      flushTimer = null;
+      if (pending.length === 0) {
+        return;
+      }
+      const batch = pending;
+      pending = [];
+      const lastInBatch = batch[batch.length - 1];
+      if (lastInBatch) {
+        lastSequenceRef.current = lastInBatch.sequence;
+      }
+      setEvents((existing) => [...existing, ...batch]);
+    };
+    const scheduleFlush = () => {
+      flushTimer ??= setTimeout(flush, 16);
+    };
+    void (async () => {
+      try {
+        const stream = client.streamEvents(workspaceId, sessionId, {
+          after: lastSequenceRef.current,
+          signal: controller.signal,
+          onStateChange: (state) => {
+            if (!controller.signal.aborted) {
+              setConnectionState(state);
+            }
+          }
+        });
+        for await (const event of stream) {
+          pending.push(event);
+          scheduleFlush();
+        }
+        if (!controller.signal.aborted) {
+          flush();
+          setConnectionState("ended");
+        }
+      } catch (cause) {
+        if (!controller.signal.aborted) {
+          flush();
+          setError(cause instanceof Error ? cause : new Error(String(cause)));
+          setConnectionState("error");
+        }
+      }
+    })();
+    return () => {
+      controller.abort();
+      if (flushTimer !== null) {
+        clearTimeout(flushTimer);
+      }
+    };
+  }, [client, workspaceId, sessionId, after, enabled]);
+  const timeline = useMemo2(() => buildTimeline(events), [events]);
+  const sessionStatus = useMemo2(() => sessionStatusFromEvents(events), [events]);
+  return {
+    events,
+    timeline,
+    sessionStatus,
+    connectionState,
+    lastSequence: lastSequenceRef.current,
+    error
+  };
+}
+
+// src/hooks/use-composer.ts
+import { useCallback as useCallback3, useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
+function useComposer(sessionId, options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const defaultMode = options.defaultMode ?? "queue";
+  const [value, setValue] = useState3("");
+  const [mode, setMode] = useState3(defaultMode);
+  const [sending, setSending] = useState3(false);
+  const [interrupting, setInterrupting] = useState3(false);
+  const [error, setError] = useState3(null);
+  const pendingClientEventId = useRef3(null);
+  const onSent = options.onSent;
+  const modeRef = useRef3(mode);
+  modeRef.current = mode;
+  const sendExtrasRef = useRef3(options.sendExtras);
+  sendExtrasRef.current = options.sendExtras;
+  const targetKey = `${workspaceId}\0${sessionId ?? ""}`;
+  const targetKeyRef = useRef3(targetKey);
+  useEffect3(() => {
+    if (targetKeyRef.current !== targetKey) {
+      targetKeyRef.current = targetKey;
+      pendingClientEventId.current = null;
+      setValue("");
+      setError(null);
+      setMode(defaultMode);
+    }
+  }, [targetKey, defaultMode]);
+  const send = useCallback3(
+    async (explicit) => {
+      const draftAtSend = value;
+      const text = (explicit ?? draftAtSend).trim();
+      const extras = resolveSendExtras(sendExtrasRef.current);
+      const hasResources = (extras.resources?.length ?? 0) > 0;
+      if (!text && !hasResources || !sessionId || sending) {
+        return false;
+      }
+      pendingClientEventId.current ??= generateClientEventId();
+      setSending(true);
+      setError(null);
+      try {
+        const sendText = text || FILE_ONLY_MESSAGE_TEXT;
+        const input = composeSendInput(sendText, pendingClientEventId.current, extras);
+        if (modeRef.current === "steer") {
+          await client.steerMessage(workspaceId, sessionId, input);
+        } else {
+          await client.sendMessage(workspaceId, sessionId, input);
+        }
+        pendingClientEventId.current = null;
+        if (explicit === void 0) {
+          setValue((current) => current === draftAtSend ? "" : current);
+        }
+        onSent?.(sendText);
+        return true;
+      } catch (cause) {
+        setError(cause instanceof Error ? cause : new Error(String(cause)));
+        return false;
+      } finally {
+        setSending(false);
+      }
+    },
+    [client, workspaceId, sessionId, value, sending, onSent]
+  );
+  const hasReadyResources = (resolveSendExtras(sendExtrasRef.current).resources?.length ?? 0) > 0;
+  const interrupt = useCallback3(
+    async (reason) => {
+      if (!sessionId || interrupting) {
+        return;
+      }
+      setInterrupting(true);
+      setError(null);
+      try {
+        await client.interrupt(workspaceId, sessionId, reason !== void 0 ? { reason } : {});
+      } catch (cause) {
+        setError(cause instanceof Error ? cause : new Error(String(cause)));
+      } finally {
+        setInterrupting(false);
+      }
+    },
+    [client, workspaceId, sessionId, interrupting]
+  );
+  const updateValue = useCallback3((next) => {
+    pendingClientEventId.current = null;
+    setValue(next);
+  }, []);
+  return {
+    value,
+    setValue: updateValue,
+    send,
+    sending,
+    canSend: Boolean(sessionId) && !sending && (value.trim().length > 0 || hasReadyResources),
+    mode,
+    setMode,
+    interrupt,
+    interrupting,
+    error,
+    clearError: useCallback3(() => setError(null), [])
+  };
+}
+var FILE_ONLY_MESSAGE_TEXT = "(see attached files)";
+function resolveSendExtras(extras) {
+  return (typeof extras === "function" ? extras() : extras) ?? {};
+}
+function composeSendInput(text, clientEventId, extras) {
+  return { ...resolveSendExtras(extras), text, clientEventId };
+}
+function shouldSubmitOnKey(event) {
+  if (event.key !== "Enter" || event.shiftKey) {
+    return false;
+  }
+  return event.nativeEvent?.isComposing !== true;
+}
+function generateClientEventId() {
+  const cryptoApi = globalThis.crypto;
+  if (cryptoApi && "randomUUID" in cryptoApi) {
+    return cryptoApi.randomUUID();
+  }
+  return `ce-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+// src/hooks/use-file-attachments.ts
+import { useCallback as useCallback4, useState as useState4 } 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] = useState4([]);
+  const addFiles = useCallback4((files) => {
+    for (const file of files) {
+      const id = crypto.randomUUID();
+      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 } : {}
+      }]);
+      void client.uploadFile(workspaceId, {
+        filename: file.name || "file",
+        contentType: file.type || "application/octet-stream",
+        data: file
+      }).then((asset) => {
+        setAttachments((current) => current.map((attachment) => attachment.id === id ? { ...attachment, status: "ready", file: asset, name: asset.filename, contentType: asset.contentType, sizeBytes: asset.sizeBytes } : 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 addFromPaste = useCallback4((event) => {
+    const clipboardFiles = event.clipboardData?.files;
+    if (!clipboardFiles) {
+      return;
+    }
+    const files = [...clipboardFiles].filter(pasteFilter);
+    if (files.length > 0) {
+      addFiles(files);
+    }
+  }, [addFiles, pasteFilter]);
+  const remove = useCallback4((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 clear = useCallback4(() => {
+    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"),
+    addFiles,
+    addFromPaste,
+    remove,
+    clear
+  };
+}
+
+// src/hooks/use-turn-queue.ts
+import { useCallback as useCallback5, useEffect as useEffect4, useRef as useRef4, useState as useState5 } from "react";
+function isTurnQueueEvent(event) {
+  return event.type.startsWith("turn.");
+}
+function queueFromTurns(turns) {
+  return turns.filter((turn) => turn.status === "queued").sort((a, b) => a.position - b.position || a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
+}
+function activeTurnFromTurns(turns) {
+  return turns.find((turn) => turn.status === "running" || turn.status === "requires_action") ?? null;
+}
+function applyTurnEdit(turns, turnId, update) {
+  return turns.map((turn) => {
+    if (turn.id !== turnId || turn.status !== "queued") {
+      return turn;
+    }
+    return {
+      ...turn,
+      ...update.prompt !== void 0 ? { prompt: update.prompt } : {},
+      ...update.resources !== void 0 ? { resources: update.resources } : {},
+      ...update.tools !== void 0 ? { tools: update.tools } : {},
+      ...update.model !== void 0 ? { model: update.model } : {},
+      ...update.reasoningEffort !== void 0 ? { reasoningEffort: update.reasoningEffort } : {},
+      ...update.sandboxBackend !== void 0 ? { sandboxBackend: update.sandboxBackend } : {},
+      ...update.metadata !== void 0 ? { metadata: update.metadata } : {}
+    };
+  });
+}
+function applyTurnReorder(turns, turnIds) {
+  const positions = new Map(turnIds.map((turnId, index) => [turnId, index + 1]));
+  return turns.map((turn) => {
+    const position = positions.get(turn.id);
+    return position !== void 0 && turn.status === "queued" ? { ...turn, position } : turn;
+  });
+}
+function applyTurnRemoval(turns, turnId) {
+  return turns.map((turn) => turn.id === turnId && turn.status === "queued" ? { ...turn, status: "cancelled" } : turn);
+}
+function useTurnQueue(sessionId, options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const [turns, setTurns] = useState5([]);
+  const [loading, setLoading] = useState5(enabled);
+  const [error, setError] = useState5(null);
+  const mutation = 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.listTurns(workspaceId, sessionId);
+      if (ticket === generation.current) {
+        setTurns(fetched);
+        setError(null);
+        setLoading(false);
+      }
+    } catch (cause) {
+      if (ticket === generation.current) {
+        setError(cause instanceof Error ? cause : new Error(String(cause)));
+        setLoading(false);
+      }
+    }
+  }, [client, workspaceId, sessionId]);
+  useEffect4(() => {
+    const targetKey = `${workspaceId}\0${sessionId ?? ""}`;
+    if (targetKeyRef.current !== targetKey) {
+      targetKeyRef.current = targetKey;
+      setTurns([]);
+      setError(null);
+    }
+    if (!enabled) {
+      setLoading(false);
+      return;
+    }
+    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]);
+  const scheduleRefresh = useDebouncedCallback(() => void load());
+  useSessionEventTrigger(client, workspaceId, sessionId, isTurnQueueEvent, scheduleRefresh, {
+    enabled,
+    ...options.events !== void 0 ? { events: options.events } : {}
+  });
+  const editTurn = useCallback5(
+    async (turnId, update) => {
+      if (!sessionId) {
+        return null;
+      }
+      setTurns((current) => applyTurnEdit(current, turnId, update));
+      const result = await mutation.run(() => client.updateQueuedTurn(workspaceId, sessionId, turnId, update));
+      if (result) {
+        setTurns((current) => current.map((turn) => turn.id === result.id ? result : turn));
+      } else {
+        void load();
+      }
+      return result;
+    },
+    [client, workspaceId, sessionId, mutation.run, load]
+  );
+  const reorderTurns = useCallback5(
+    async (turnIds) => {
+      if (!sessionId || turnIds.length === 0) {
+        return null;
+      }
+      setTurns((current) => applyTurnReorder(current, turnIds));
+      const result = await mutation.run(() => client.reorderQueuedTurns(workspaceId, sessionId, turnIds));
+      if (result) {
+        setTurns((current) => {
+          const bySId = new Map(result.map((turn) => [turn.id, turn]));
+          return current.map((turn) => bySId.get(turn.id) ?? turn);
+        });
+      } else {
+        void load();
+      }
+      return result;
+    },
+    [client, workspaceId, sessionId, mutation.run, load]
+  );
+  const removeTurn = useCallback5(
+    async (turnId) => {
+      if (!sessionId) {
+        return null;
+      }
+      setTurns((current) => applyTurnRemoval(current, turnId));
+      const result = await mutation.run(() => client.deleteQueuedTurn(workspaceId, sessionId, turnId));
+      if (result) {
+        setTurns((current) => current.map((turn) => turn.id === result.id ? result : turn));
+      } else {
+        void load();
+      }
+      return result;
+    },
+    [client, workspaceId, sessionId, mutation.run, load]
+  );
+  return {
+    turns,
+    queue: queueFromTurns(turns),
+    activeTurn: activeTurnFromTurns(turns),
+    loading,
+    error,
+    refresh: load,
+    editTurn,
+    reorderTurns,
+    removeTurn,
+    mutating: mutation.mutating,
+    mutationError: mutation.mutationError,
+    clearMutationError: mutation.clearMutationError
+  };
+}
+
+// src/hooks/use-goal.ts
+import { OpenGeniApiError } from "@opengeni/sdk";
+import { useCallback as useCallback6, useEffect as useEffect5, useRef as useRef5, useState as useState6 } from "react";
+function isGoalEvent(event) {
+  return event.type.startsWith("goal.");
+}
+function useGoal(sessionId, options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const [goal, setGoal] = useState6(null);
+  const [loading, setLoading] = useState6(enabled);
+  const [error, setError] = useState6(null);
+  const mutation = useMutationRunner();
+  const generation = useRef5(0);
+  const targetKeyRef = useRef5(null);
+  const load = useCallback6(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]);
+  useEffect5(() => {
+    const targetKey = `${workspaceId} ${sessionId ?? ""}`;
+    if (targetKeyRef.current !== targetKey) {
+      targetKeyRef.current = targetKey;
+      setGoal(null);
+      setError(null);
+    }
+    if (!enabled) {
+      setLoading(false);
+      return;
+    }
+    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]);
+  const scheduleRefresh = useDebouncedCallback(() => void load());
+  useSessionEventTrigger(client, workspaceId, sessionId, isGoalEvent, scheduleRefresh, {
+    enabled,
+    ...options.events !== void 0 ? { events: options.events } : {}
+  });
+  const pause = useCallback6(
+    async (rationale) => {
+      if (!sessionId) {
+        return null;
+      }
+      const result = await mutation.run(() => client.updateGoal(workspaceId, sessionId, {
+        status: "paused",
+        ...rationale !== void 0 ? { rationale } : {}
+      }));
+      if (result) {
+        setGoal(result);
+      }
+      return result;
+    },
+    [client, workspaceId, sessionId, mutation.run]
+  );
+  const resume = useCallback6(async () => {
+    if (!sessionId) {
+      return null;
+    }
+    const result = await mutation.run(() => client.updateGoal(workspaceId, sessionId, { status: "active" }));
+    if (result) {
+      setGoal(result);
+    }
+    return result;
+  }, [client, workspaceId, sessionId, mutation.run]);
+  return {
+    goal,
+    isActive: goal?.status === "active",
+    isPaused: goal?.status === "paused",
+    isCompleted: goal?.status === "completed",
+    loading,
+    error,
+    refresh: load,
+    pause,
+    resume,
+    updating: mutation.mutating,
+    mutationError: mutation.mutationError,
+    clearMutationError: mutation.clearMutationError
+  };
+}
+
+// src/hooks/use-session-control.ts
+import { useCallback as useCallback7 } from "react";
+function useSessionControl(sessionId, options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const interruptMutation = useMutationRunner();
+  const approvalMutation = useMutationRunner();
+  const interrupt = useCallback7(
+    async (reason) => {
+      if (!sessionId) {
+        return null;
+      }
+      return await interruptMutation.run(() => client.interrupt(workspaceId, sessionId, reason !== void 0 ? { reason } : {}));
+    },
+    [client, workspaceId, sessionId, interruptMutation.run]
+  );
+  const decide = useCallback7(
+    async (approvalId, decision, message) => {
+      if (!sessionId) {
+        return null;
+      }
+      return await approvalMutation.run(() => client.sendApprovalDecision(workspaceId, sessionId, {
+        approvalId,
+        decision,
+        ...message !== void 0 ? { message } : {}
+      }));
+    },
+    [client, workspaceId, sessionId, approvalMutation.run]
+  );
+  const approve = useCallback7(
+    async (approvalId, message) => await decide(approvalId, "approve", message),
+    [decide]
+  );
+  const reject = useCallback7(
+    async (approvalId, message) => await decide(approvalId, "reject", message),
+    [decide]
+  );
+  const error = approvalMutation.mutationError ?? interruptMutation.mutationError;
+  const clearError = useCallback7(() => {
+    interruptMutation.clearMutationError();
+    approvalMutation.clearMutationError();
+  }, [interruptMutation.clearMutationError, approvalMutation.clearMutationError]);
+  return {
+    interrupt,
+    interrupting: interruptMutation.mutating,
+    approve,
+    reject,
+    responding: approvalMutation.mutating,
+    error,
+    clearError
+  };
+}
+
+// src/hooks/use-scheduled-tasks.ts
+import { useCallback as useCallback8 } from "react";
+function useScheduledTasks(options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const limit = options.limit;
+  const load = useCallback8(
+    async () => await client.listScheduledTasks(workspaceId, limit !== void 0 ? { limit } : {}),
+    [client, workspaceId, limit]
+  );
+  const state = usePolledValue(load, { pollIntervalMs: options.pollIntervalMs, enabled: options.enabled });
+  return { tasks: state.data ?? [], loading: state.loading, error: state.error, refresh: state.refresh };
+}
+
+// src/hooks/use-workspace-sessions.ts
+import { useCallback as useCallback9 } from "react";
+function useWorkspaceSessions(options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const limit = options.limit;
+  const load = useCallback9(
+    async () => await client.listSessions(workspaceId, limit !== void 0 ? { limit } : {}),
+    [client, workspaceId, limit]
+  );
+  const state = usePolledValue(load, { pollIntervalMs: options.pollIntervalMs, enabled: options.enabled });
+  return { sessions: state.data ?? [], loading: state.loading, error: state.error, refresh: state.refresh };
+}
+
+// src/hooks/use-environments.ts
+import { useCallback as useCallback10 } from "react";
+function useEnvironments(options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const load = useCallback10(async () => await client.listEnvironments(workspaceId), [client, workspaceId]);
+  const state = usePolledValue(load, { pollIntervalMs: options.pollIntervalMs, enabled: options.enabled });
+  const mutation = useMutationRunner();
+  const create = useCallback10(
+    async (request) => {
+      const result = await mutation.run(() => client.createEnvironment(workspaceId, request));
+      if (result) {
+        await state.refresh();
+      }
+      return result;
+    },
+    [client, workspaceId, mutation.run, state.refresh]
+  );
+  const update = useCallback10(
+    async (environmentId, request) => {
+      const result = await mutation.run(() => client.updateEnvironment(workspaceId, environmentId, request));
+      if (result) {
+        await state.refresh();
+      }
+      return result;
+    },
+    [client, workspaceId, mutation.run, state.refresh]
+  );
+  const remove = useCallback10(
+    async (environmentId) => {
+      const result = await mutation.run(async () => {
+        await client.deleteEnvironment(workspaceId, environmentId);
+        return true;
+      });
+      if (result) {
+        await state.refresh();
+      }
+      return result === true;
+    },
+    [client, workspaceId, mutation.run, state.refresh]
+  );
+  const setVariable = useCallback10(
+    async (environmentId, name, value) => {
+      const result = await mutation.run(() => client.setEnvironmentVariable(workspaceId, environmentId, name, value));
+      if (result) {
+        await state.refresh();
+      }
+      return result;
+    },
+    [client, workspaceId, mutation.run, state.refresh]
+  );
+  const deleteVariable = useCallback10(
+    async (environmentId, name) => {
+      const result = await mutation.run(async () => {
+        await client.deleteEnvironmentVariable(workspaceId, environmentId, name);
+        return true;
+      });
+      if (result) {
+        await state.refresh();
+      }
+      return result === true;
+    },
+    [client, workspaceId, mutation.run, state.refresh]
+  );
+  return {
+    environments: state.data ?? [],
+    loading: state.loading,
+    error: state.error,
+    refresh: state.refresh,
+    create,
+    update,
+    remove,
+    setVariable,
+    deleteVariable,
+    mutating: mutation.mutating,
+    mutationError: mutation.mutationError,
+    clearMutationError: mutation.clearMutationError
+  };
+}
+
+// src/hooks/use-packs.ts
+import { useCallback as useCallback11 } from "react";
+function usePacks(options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const load = useCallback11(async () => await client.listPacks(workspaceId), [client, workspaceId]);
+  const state = usePolledValue(load, { pollIntervalMs: options.pollIntervalMs, enabled: options.enabled });
+  const mutation = useMutationRunner();
+  const register = useCallback11(
+    async (manifest) => {
+      const result = await mutation.run(() => client.registerPack(workspaceId, manifest));
+      if (result) {
+        await state.refresh();
+      }
+      return result;
+    },
+    [client, workspaceId, mutation.run, state.refresh]
+  );
+  const enable = useCallback11(
+    async (packId, request = {}) => {
+      const result = await mutation.run(() => client.enablePack(workspaceId, packId, request));
+      if (result) {
+        await state.refresh();
+      }
+      return result;
+    },
+    [client, workspaceId, mutation.run, state.refresh]
+  );
+  const remove = useCallback11(
+    async (packId) => {
+      const result = await mutation.run(async () => {
+        await client.deletePack(workspaceId, packId);
+        return true;
+      });
+      if (result) {
+        await state.refresh();
+      }
+      return result === true;
+    },
+    [client, workspaceId, mutation.run, state.refresh]
+  );
+  const installations = state.data?.installations ?? [];
+  const installationFor = useCallback11(
+    (packId) => installations.find((installation) => installation.packId === packId) ?? null,
+    [installations]
+  );
+  return {
+    packs: state.data?.packs ?? [],
+    installations,
+    installationFor,
+    loading: state.loading,
+    error: state.error,
+    refresh: state.refresh,
+    register,
+    enable,
+    remove,
+    mutating: mutation.mutating,
+    mutationError: mutation.mutationError,
+    clearMutationError: mutation.clearMutationError
+  };
+}
+
+// src/hooks/use-workspaces.ts
+import { useCallback as useCallback12 } from "react";
+function useWorkspaces(options = {}) {
+  const client = useOpenGeniClient(options);
+  const load = useCallback12(async () => await client.listWorkspaces(), [client]);
+  const state = usePolledValue(load, { pollIntervalMs: options.pollIntervalMs, enabled: options.enabled });
+  const mutation = useMutationRunner();
+  const create = useCallback12(
+    async (request) => {
+      const result = await mutation.run(() => client.createWorkspace(request));
+      if (result) {
+        await state.refresh();
+      }
+      return result;
+    },
+    [client, mutation.run, state.refresh]
+  );
+  const update = useCallback12(
+    async (workspaceId, request) => {
+      const result = await mutation.run(() => client.updateWorkspace(workspaceId, request));
+      if (result) {
+        await state.refresh();
+      }
+      return result;
+    },
+    [client, mutation.run, state.refresh]
+  );
+  return {
+    workspaces: state.data ?? [],
+    loading: state.loading,
+    error: state.error,
+    refresh: state.refresh,
+    create,
+    update,
+    mutating: mutation.mutating,
+    mutationError: mutation.mutationError,
+    clearMutationError: mutation.clearMutationError
+  };
+}
+
+// src/hooks/use-billing-usage.ts
+import { useCallback as useCallback13 } from "react";
+function useBillingUsage(options = {}) {
+  const client = useOpenGeniClient(options);
+  const accountId = options.accountId;
+  const workspaceId = options.workspaceId;
+  const load = useCallback13(
+    async () => await client.getBillingUsage({
+      ...accountId !== void 0 ? { accountId } : {},
+      ...workspaceId !== void 0 ? { workspaceId } : {}
+    }),
+    [client, accountId, workspaceId]
+  );
+  const state = usePolledValue(load, { pollIntervalMs: options.pollIntervalMs, enabled: options.enabled });
+  return {
+    balance: state.data?.balance ?? null,
+    usage: state.data?.usage ?? [],
+    loading: state.loading,
+    error: state.error,
+    refresh: state.refresh
+  };
+}
+
+// src/approvals.ts
+function approvalsFromRequiresAction(payload) {
+  const approvals = payload && typeof payload === "object" ? payload.approvals : void 0;
+  if (!Array.isArray(approvals)) {
+    return [];
+  }
+  return approvals.map((approval, index) => {
+    const raw = approval && typeof approval === "object" ? approval : {};
+    const rawItem = raw.rawItem && typeof raw.rawItem === "object" ? raw.rawItem : {};
+    return {
+      id: String(raw.id ?? raw.callId ?? rawItem.callId ?? index),
+      name: String(raw.name ?? "approval"),
+      arguments: raw.arguments,
+      raw: approval
+    };
+  });
+}
+function projectPendingApprovals(events) {
+  let pending = [];
+  let owningTurnId = null;
+  for (const event of events) {
+    switch (event.type) {
+      case "session.requiresAction": {
+        pending = approvalsFromRequiresAction(event.payload);
+        owningTurnId = event.turnId ?? null;
+        break;
+      }
+      case "user.approvalDecision": {
+        const payload = event.payload && typeof event.payload === "object" ? event.payload : {};
+        if (typeof payload.approvalId === "string") {
+          pending = pending.filter((approval) => approval.id !== payload.approvalId);
+        }
+        break;
+      }
+      case "turn.completed":
+      case "turn.failed":
+      case "turn.cancelled": {
+        if (owningTurnId === null || event.turnId == null || event.turnId === owningTurnId) {
+          pending = [];
+          owningTurnId = null;
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return pending;
+}
+
+// src/commands/registry.ts
+function parseCommandLine(value) {
+  if (value[0] !== "/") {
+    return null;
+  }
+  const body = value.slice(1);
+  const firstSpace = body.indexOf(" ");
+  if (firstSpace === -1) {
+    return { name: body, rest: "", hasTrailingSpace: false, args: [] };
+  }
+  const name = body.slice(0, firstSpace);
+  const rest = body.slice(firstSpace + 1);
+  return {
+    name,
+    rest,
+    hasTrailingSpace: true,
+    args: rest.split(/\s+/).filter((token) => token.length > 0)
+  };
+}
+var PERMISSION_SUPERUSER = "workspace:admin";
+function hasPermission(required, permissions) {
+  if (!required) {
+    return true;
+  }
+  return permissions.includes(required) || permissions.includes(PERMISSION_SUPERUSER);
+}
+function matchCommand(commands, value) {
+  const parsed = parseCommandLine(value);
+  if (!parsed) {
+    return null;
+  }
+  const token = parsed.name.toLowerCase();
+  return commands.find((command) => command.name === token || command.aliases?.includes(token)) ?? null;
+}
+function filterCommands(commands, token, ctx) {
+  const needle = token.toLowerCase();
+  return commands.filter((command) => {
+    if (!hasPermission(command.permission, ctx.permissions)) {
+      return false;
+    }
+    if (command.available && !command.available(ctx)) {
+      return false;
+    }
+    if (needle.length === 0) {
+      return true;
+    }
+    return command.name.startsWith(needle) || (command.aliases?.some((alias) => alias.startsWith(needle)) ?? false);
+  });
+}
+function argHint(args) {
+  if (!args || args.length === 0) {
+    return "";
+  }
+  return args.map((arg) => {
+    const label = arg.oneOf ? arg.oneOf.join("|") : arg.name;
+    return arg.required ? `<${label}>` : `[${label}]`;
+  }).join(" ");
+}
+function firstMissingRequiredArg(command, args) {
+  const required = (command.args ?? []).filter((arg) => arg.required);
+  for (let i = 0; i < required.length; i += 1) {
+    const value = args[i];
+    if (value === void 0 || value.length === 0) {
+      return required[i] ?? null;
+    }
+  }
+  return null;
+}
+function requireSession(ctx) {
+  if (!ctx.sessionId) {
+    throw new Error("No active session yet \u2014 start a session first.");
+  }
+  return ctx.sessionId;
+}
+var hasSession = (ctx) => ctx.sessionId !== null;
+var defaultCommands = [
+  {
+    name: "help",
+    aliases: ["?"],
+    description: "Show available commands.",
+    run: (_args, ctx) => {
+      ctx.openHelp();
+      return { status: "ok" };
+    }
+  },
+  {
+    name: "clear-view",
+    description: "Clear the local timeline view (this device only; no server change).",
+    run: (_args, ctx) => {
+      const cleared = ctx.clearView();
+      if (!cleared) {
+        return { status: "error", message: "This view can't be cleared here (no local timeline to reset)." };
+      }
+      return { status: "ok", message: "Local view cleared." };
+    }
+  },
+  {
+    name: "goal",
+    description: "Pause or resume the session's goal loop.",
+    permission: "sessions:control",
+    available: hasSession,
+    args: [{ name: "action", required: true, oneOf: ["pause", "resume"], description: "pause | resume" }],
+    run: async (args, ctx) => {
+      const sessionId = requireSession(ctx);
+      const action = args[0];
+      if (action !== "pause" && action !== "resume") {
+        return { status: "error", message: "Usage: /goal pause | /goal resume" };
+      }
+      try {
+        await ctx.client.updateGoal(ctx.workspaceId, sessionId, { status: action === "pause" ? "paused" : "active" });
+        return { status: "ok", message: action === "pause" ? "Goal paused." : "Goal resumed." };
+      } catch (cause) {
+        return { status: "error", message: goalErrorMessage(cause, action) };
+      }
+    }
+  },
+  {
+    name: "compact",
+    description: "Compact the conversation context now.",
+    permission: "sessions:control",
+    available: hasSession,
+    run: async (_args, ctx) => {
+      const sessionId = requireSession(ctx);
+      try {
+        const result = await ctx.client.compactSessionContext(ctx.workspaceId, sessionId);
+        return { status: "ok", message: result.message };
+      } catch (cause) {
+        return { status: "error", message: errorMessage(cause) ?? "Could not compact context." };
+      }
+    }
+  },
+  {
+    name: "clear",
+    description: "Clear the conversation context (destructive; audit-preserved).",
+    permission: "sessions:control",
+    danger: true,
+    available: hasSession,
+    run: async (_args, ctx) => {
+      const sessionId = requireSession(ctx);
+      const confirmed = await ctx.confirm();
+      if (!confirmed) {
+        return { status: "ok", keepDraft: true };
+      }
+      try {
+        await ctx.client.clearSessionContext(ctx.workspaceId, sessionId);
+        return { status: "ok", message: "Context cleared." };
+      } catch (cause) {
+        return { status: "error", message: clearErrorMessage(cause) };
+      }
+    }
+  }
+];
+function errorMessage(cause) {
+  if (cause && typeof cause === "object" && "message" in cause && typeof cause.message === "string") {
+    return cause.message;
+  }
+  return void 0;
+}
+function statusCode(cause) {
+  if (cause && typeof cause === "object" && "status" in cause && typeof cause.status === "number") {
+    return cause.status;
+  }
+  return void 0;
+}
+function goalErrorMessage(cause, action) {
+  const code = statusCode(cause);
+  if (code === 404) {
+    return "This session has no goal to control.";
+  }
+  if (code === 409) {
+    return action === "resume" ? "Only a paused goal can be resumed." : "Goal is already in a terminal state.";
+  }
+  return errorMessage(cause) ?? `Could not ${action} the goal.`;
+}
+function clearErrorMessage(cause) {
+  if (statusCode(cause) === 409) {
+    return "Can't clear context mid-turn \u2014 stop the current turn first.";
+  }
+  return errorMessage(cause) ?? "Could not clear context.";
+}
+
+// src/hooks/use-slash-commands.ts
+import { useCallback as useCallback14, useMemo as useMemo3, useRef as useRef6, useState as useState7 } from "react";
+function useSlashCommands(options) {
+  const { commands, context, handlers, value, setValue } = options;
+  const [highlight, setHighlight] = useState7(0);
+  const [dismissedValue, setDismissedValue] = useState7(null);
+  const dismissed = dismissedValue !== null && dismissedValue === value;
+  const navigatedRef = useRef6(false);
+  const navTokenRef = useRef6(value);
+  if (navTokenRef.current !== value) {
+    navTokenRef.current = value;
+    navigatedRef.current = false;
+  }
+  const parsed = useMemo3(() => parseCommandLine(value), [value]);
+  const filterCtx = useMemo3(
+    () => ({
+      sessionId: context?.sessionId ?? null,
+      status: context?.status ?? null,
+      permissions: context?.permissions ?? []
+    }),
+    [context?.sessionId, context?.status, context?.permissions]
+  );
+  const activeCommand = useMemo3(() => {
+    if (!parsed || !parsed.hasTrailingSpace) {
+      return null;
+    }
+    return matchCommand(commands, value);
+  }, [commands, value, parsed]);
+  const items = useMemo3(() => {
+    if (!parsed) {
+      return [];
+    }
+    if (activeCommand) {
+      return [activeCommand];
+    }
+    return filterCommands(commands, parsed.name, filterCtx);
+  }, [commands, parsed, activeCommand, filterCtx]);
+  const open = parsed !== null && items.length > 0 && !dismissed;
+  const isCommandDraft = parsed !== null && items.length > 0;
+  const clampedHighlight = items.length === 0 ? 0 : Math.min(highlight, items.length - 1);
+  const activeArgHint = activeCommand ? argHint(activeCommand.args) : "";
+  const buildContext = useCallback14(
+    (command) => {
+      if (!context) {
+        return null;
+      }
+      return { ...context, ...handlers, confirm: () => handlers.confirm(command) };
+    },
+    [context, handlers]
+  );
+  const execute = useCallback14(
+    async (command, args) => {
+      const ctx = buildContext(command);
+      if (!ctx) {
+        return;
+      }
+      try {
+        const result = await command.run(args, ctx);
+        if (result.message) {
+          ctx.notice({ tone: result.status === "ok" ? "ok" : "error", message: result.message });
+        }
+        if (result.status === "ok" && !result.keepDraft) {
+          setValue("");
+        }
+      } catch (cause) {
+        ctx.notice({ tone: "error", message: errorMessage2(cause) });
+      }
+    },
+    [buildContext, setValue]
+  );
+  const autocomplete = useCallback14(
+    (command) => {
+      setValue(`/${command.name} `);
+      setHighlight(0);
+    },
+    [setValue]
+  );
+  const autocompleteHighlighted = useCallback14(() => {
+    const command = items[clampedHighlight];
+    if (command) {
+      autocomplete(command);
+    }
+  }, [items, clampedHighlight, autocomplete]);
+  const runResolved = useCallback14(
+    async (command, options2) => {
+      if (!parsed) {
+        return;
+      }
+      const explicit = options2?.explicit ?? false;
+      const nameMatchesToken = command.name === parsed.name.toLowerCase() || (command.aliases?.includes(parsed.name.toLowerCase()) ?? false);
+      if (!explicit && !activeCommand && !nameMatchesToken && !parsed.hasTrailingSpace) {
+        autocomplete(command);
+        return;
+      }
+      const args = nameMatchesToken || parsed.hasTrailingSpace ? parsed.args : [];
+      const missing = firstMissingRequiredArg(command, args);
+      if (missing) {
+        if (!parsed.hasTrailingSpace) {
+          autocomplete(command);
+        }
+        return;
+      }
+      await execute(command, args);
+    },
+    [parsed, activeCommand, autocomplete, execute]
+  );
+  const runHighlighted = useCallback14(async () => {
+    if (!parsed) {
+      return;
+    }
+    if (navigatedRef.current && !activeCommand) {
+      const highlighted = items[clampedHighlight];
+      if (highlighted) {
+        await runResolved(highlighted, { explicit: true });
+      }
+      return;
+    }
+    const token = parsed.name.toLowerCase();
+    const exact = items.find((item) => item.name === token || item.aliases?.includes(token));
+    const command = activeCommand ?? exact ?? items[clampedHighlight];
+    if (!command) {
+      return;
+    }
+    await runResolved(command);
+  }, [parsed, activeCommand, items, clampedHighlight, runResolved]);
+  const runAt = useCallback14(
+    async (index) => {
+      const command = items[index];
+      if (!command) {
+        return;
+      }
+      await runResolved(command, { explicit: true });
+    },
+    [items, runResolved]
+  );
+  const runningRef = useRef6(false);
+  const onKeyDown = useCallback14(
+    (event) => {
+      if (!open) {
+        return false;
+      }
+      switch (event.key) {
+        case "ArrowDown": {
+          event.preventDefault();
+          navigatedRef.current = true;
+          setHighlight((current) => items.length === 0 ? 0 : (Math.min(current, items.length - 1) + 1) % items.length);
+          return true;
+        }
+        case "ArrowUp": {
+          event.preventDefault();
+          navigatedRef.current = true;
+          setHighlight((current) => {
+            const base = Math.min(current, items.length - 1);
+            return items.length === 0 ? 0 : (base - 1 + items.length) % items.length;
+          });
+          return true;
+        }
+        case "Tab": {
+          event.preventDefault();
+          autocompleteHighlighted();
+          return true;
+        }
+        case "Enter": {
+          if (event.shiftKey || event.nativeEvent?.isComposing) {
+            return false;
+          }
+          event.preventDefault();
+          if (runningRef.current) {
+            return true;
+          }
+          runningRef.current = true;
+          void runHighlighted().finally(() => {
+            runningRef.current = false;
+          });
+          return true;
+        }
+        case "Escape": {
+          event.preventDefault();
+          setDismissedValue(value);
+          return true;
+        }
+        default:
+          return false;
+      }
+    },
+    [open, items, autocompleteHighlighted, runHighlighted, value]
+  );
+  return {
+    open,
+    isCommandDraft,
+    items,
+    highlight: clampedHighlight,
+    setHighlight,
+    activeCommand,
+    activeArgHint,
+    onKeyDown,
+    runHighlighted,
+    runAt,
+    autocompleteHighlighted
+  };
+}
+function errorMessage2(cause) {
+  if (cause instanceof Error) {
+    return cause.message;
+  }
+  return String(cause);
+}
+
+// src/components/command-palette.tsx
+import { AnimatePresence, motion } from "motion/react";
+
+// src/lib/cn.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// src/components/command-palette.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function CommandPalette({ open, items, highlight, onHighlight, onRun, argHintText, listboxId }) {
+  return /* @__PURE__ */ jsx2(AnimatePresence, { children: open ? /* @__PURE__ */ jsxs(
+    motion.div,
+    {
+      initial: { opacity: 0, y: 6, scale: 0.99 },
+      animate: { opacity: 1, y: 0, scale: 1 },
+      exit: { opacity: 0, y: 6, scale: 0.99 },
+      transition: { duration: 0.13, ease: "easeOut" },
+      className: cn(
+        "absolute bottom-full left-0 right-0 z-20 mb-2 overflow-hidden",
+        "rounded-og-lg border border-og-border bg-og-surface-2 shadow-og-sm"
+      ),
+      children: [
+        /* @__PURE__ */ jsx2(
+          "ul",
+          {
+            id: listboxId,
+            role: "listbox",
+            "aria-label": "Slash commands",
+            className: "max-h-72 overflow-y-auto py-1",
+            children: items.map((command, index) => {
+              const selected = index === highlight;
+              const hint = argHint(command.args);
+              return /* @__PURE__ */ jsxs(
+                "li",
+                {
+                  id: `${listboxId}-option-${index}`,
+                  role: "option",
+                  "aria-selected": selected,
+                  onMouseEnter: () => onHighlight(index),
+                  onMouseDown: (event) => {
+                    event.preventDefault();
+                    onRun(index);
+                  },
+                  className: cn(
+                    "mx-1 flex cursor-pointer items-center gap-2 rounded-og-md px-2.5 py-1.5",
+                    "transition-colors duration-100",
+                    selected ? "bg-og-accent/15 text-og-fg" : "text-og-fg-muted hover:bg-og-surface-3"
+                  ),
+                  children: [
+                    /* @__PURE__ */ jsxs("span", { className: "flex min-w-0 items-baseline gap-1.5", children: [
+                      /* @__PURE__ */ jsxs("span", { className: cn("font-mono text-[13px]", selected ? "text-og-accent" : "text-og-fg"), children: [
+                        "/",
+                        command.name
+                      ] }),
+                      hint ? /* @__PURE__ */ jsx2("span", { className: "truncate font-mono text-[11px] text-og-fg-subtle", children: hint }) : null
+                    ] }),
+                    /* @__PURE__ */ jsxs("span", { className: "ml-auto flex items-center gap-1.5", children: [
+                      command.danger ? /* @__PURE__ */ jsx2("span", { className: "rounded-og-xs bg-og-status-failed/15 px-1 text-[10px] uppercase tracking-wide text-og-status-failed", children: "danger" }) : null,
+                      /* @__PURE__ */ jsx2("span", { className: "truncate text-[12px] text-og-fg-subtle max-sm:hidden", children: command.description })
+                    ] })
+                  ]
+                },
+                command.name
+              );
+            })
+          }
+        ),
+        argHintText ? /* @__PURE__ */ jsx2("div", { className: "border-t border-og-border px-3 py-1.5 font-mono text-[11px] text-og-fg-subtle", children: argHintText }) : null
+      ]
+    }
+  ) : null });
+}
+
+// src/components/chat-composer.tsx
+import { ArrowUpIcon, FileIcon, ImageIcon, LoaderCircleIcon, PaperclipIcon, SquareIcon, XIcon } from "lucide-react";
+import { AnimatePresence as AnimatePresence2, motion as motion2 } from "motion/react";
+import { useCallback as useCallback15, useEffect as useEffect6, useId, useMemo as useMemo4, useRef as useRef7, useState as useState8 } from "react";
+import { Fragment, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["queued", "running"]);
+function ChatComposer({
+  composer,
+  status,
+  placeholder,
+  disabled,
+  autoFocus,
+  hint,
+  controlsStart,
+  header,
+  onPaste,
+  attachments,
+  className,
+  commands = defaultCommands,
+  commandContext,
+  onClearView
+}) {
+  const textareaRef = useRef7(null);
+  const fileInputRef = useRef7(null);
+  const active = status != null && ACTIVE_STATUSES.has(status);
+  const blockedByUpload = attachments?.uploading === true;
+  const hasReadyAttachment = (attachments?.readyResources.length ?? 0) > 0;
+  const canSend = (composer.canSend || hasReadyAttachment) && !blockedByUpload && !composer.sending;
+  const [dragging, setDragging] = useState8(false);
+  const dragCarriesFiles = (event) => event.dataTransfer != null && [...event.dataTransfer.types].includes("Files");
+  const handleDragOver = useCallback15(
+    (event) => {
+      if (!attachments || !dragCarriesFiles(event)) {
+        return;
+      }
+      event.preventDefault();
+      setDragging(true);
+    },
+    [attachments]
+  );
+  const handleDragLeave = useCallback15(
+    (event) => {
+      if (!attachments) {
+        return;
+      }
+      if (event.currentTarget.contains(event.relatedTarget)) {
+        return;
+      }
+      setDragging(false);
+    },
+    [attachments]
+  );
+  const handleDrop = useCallback15(
+    (event) => {
+      if (!attachments || !dragCarriesFiles(event)) {
+        return;
+      }
+      event.preventDefault();
+      setDragging(false);
+      if (event.dataTransfer.files.length > 0) {
+        attachments.addFiles(event.dataTransfer.files);
+      }
+    },
+    [attachments]
+  );
+  const [notice, setNotice] = useState8(null);
+  const [helpOpen, setHelpOpen] = useState8(false);
+  const [confirmState, setConfirmState] = useState8(null);
+  const listboxId = useId();
+  const resize = useCallback15(() => {
+    const textarea = textareaRef.current;
+    if (!textarea) {
+      return;
+    }
+    textarea.style.height = "0px";
+    textarea.style.height = `${Math.min(textarea.scrollHeight, 220)}px`;
+  }, []);
+  useEffect6(() => {
+    resize();
+  }, [composer.value, resize]);
+  const handlers = useMemo4(
+    () => ({
+      notice: (next) => {
+        setNotice(next);
+        composer.clearError();
+      },
+      openHelp: () => setHelpOpen(true),
+      // Report whether a view-reset was actually wired by the host: with no
+      // onClearView the command is a no-op and must say so (not a false success).
+      clearView: () => {
+        if (!onClearView) {
+          return false;
+        }
+        onClearView();
+        return true;
+      },
+      // The hook binds the command actually being run into confirm() (see
+      // use-slash-commands buildContext), so the confirm bar renders from THAT
+      // command — never a near-match highlighted in the palette. This is what
+      // keeps the destructive /clear from being mislabeled as /clear-view.
+      confirm: (command) => new Promise((resolve) => {
+        setConfirmState({
+          command,
+          resolve: (confirmed) => {
+            setConfirmState(null);
+            resolve(confirmed);
+          }
+        });
+      })
+    }),
+    [composer, onClearView]
+  );
+  const palette = useSlashCommands({
+    commands,
+    context: commandContext,
+    handlers,
+    value: composer.value,
+    setValue: composer.setValue
+  });
+  const pendingDangerCommand = confirmState ? confirmState.command : null;
+  const paletteEnabled = commandContext !== void 0;
+  const commandDraftBlocked = paletteEnabled && palette.isCommandDraft;
+  const onKeyDown = (event) => {
+    if (paletteEnabled && palette.onKeyDown(event)) {
+      return;
+    }
+    if (shouldSubmitOnKey(event)) {
+      event.preventDefault();
+      if (commandDraftBlocked) {
+        setNotice({ tone: "error", message: "That's a slash command \u2014 press Enter in the command list to run it, or edit the line to send a message." });
+        return;
+      }
+      if (blockedByUpload) {
+        return;
+      }
+      void composer.send();
+    }
+  };
+  const handlePaste = useCallback15(
+    (event) => {
+      onPaste?.(event);
+      attachments?.addFromPaste(event);
+    },
+    [onPaste, attachments]
+  );
+  const handleFileChange = useCallback15(
+    (event) => {
+      if (event.target.files) {
+        attachments?.addFiles(event.target.files);
+      }
+      event.target.value = "";
+    },
+    [attachments]
+  );
+  const helpCommands = useMemo4(
+    () => commands.filter((command) => {
+      if (command.permission && commandContext) {
+        const perms = commandContext.permissions;
+        return perms.includes(command.permission) || perms.includes("workspace:admin");
+      }
+      return true;
+    }),
+    [commands, commandContext]
+  );
+  const activeNotice = notice ?? (composer.error ? { tone: "error", message: composer.error.message || "Sending failed \u2014 your draft is still here. Try again." } : null);
+  return /* @__PURE__ */ jsxs2("div", { className: cn("og-root", className), children: [
+    /* @__PURE__ */ jsxs2("div", { className: "relative", children: [
+      paletteEnabled ? /* @__PURE__ */ jsx3(
+        CommandPalette,
+        {
+          open: palette.open && confirmState === null,
+          items: palette.items,
+          highlight: palette.highlight,
+          onHighlight: palette.setHighlight,
+          onRun: (index) => {
+            palette.setHighlight(index);
+            void palette.runAt(index);
+          },
+          argHintText: palette.activeArgHint,
+          listboxId
+        }
+      ) : null,
+      /* @__PURE__ */ jsxs2(
+        "div",
+        {
+          onDragOver: attachments ? handleDragOver : void 0,
+          onDragLeave: attachments ? handleDragLeave : void 0,
+          onDrop: attachments ? handleDrop : void 0,
+          className: cn(
+            "relative rounded-og-lg border border-og-border bg-og-surface-1 shadow-og-sm",
+            "transition-[border-color,box-shadow] duration-200",
+            "focus-within:border-og-accent/60 focus-within:shadow-og-glow",
+            // While files are dragged over, swap to a dashed accent border to
+            // signal a live drop target (the overlay carries the label).
+            dragging && "border-dashed border-og-accent"
+          ),
+          children: [
+            dragging ? /* @__PURE__ */ jsx3(
+              "div",
+              {
+                "aria-hidden": true,
+                className: cn(
+                  "pointer-events-none absolute inset-0 z-10 flex items-center justify-center",
+                  "rounded-og-lg bg-og-surface-1/85 text-sm font-medium text-og-accent backdrop-blur-[1px]"
+                ),
+                children: /* @__PURE__ */ jsxs2("span", { className: "inline-flex items-center gap-2", children: [
+                  /* @__PURE__ */ jsx3(PaperclipIcon, { className: "size-4" }),
+                  "Drop files to attach"
+                ] })
+              }
+            ) : null,
+            attachments && attachments.attachments.length > 0 ? /* @__PURE__ */ jsx3(AttachmentChips, { attachments: attachments.attachments, onRemove: attachments.remove }) : null,
+            header,
+            /* @__PURE__ */ jsx3(
+              "textarea",
+              {
+                ref: textareaRef,
+                rows: 1,
+                value: composer.value,
+                onChange: (event) => composer.setValue(event.target.value),
+                onKeyDown,
+                onPaste: handlePaste,
+                placeholder: placeholder ?? "Message the agent\u2026",
+                disabled,
+                autoFocus,
+                "aria-label": "Message the agent",
+                role: paletteEnabled && palette.open ? "combobox" : void 0,
+                "aria-expanded": paletteEnabled ? palette.open : void 0,
+                "aria-controls": paletteEnabled && palette.open ? listboxId : void 0,
+                "aria-activedescendant": paletteEnabled && palette.open ? `${listboxId}-option-${palette.highlight}` : void 0,
+                className: cn(
+                  "block w-full resize-none bg-transparent px-4 pt-3.5 pb-1 text-[15px] leading-6",
+                  // The wrapper owns the whole-composer focus affordance (focus-within
+                  // border + soft glow). Suppress any self-scoped focus outline on the
+                  // textarea itself: `focus:outline-none` alone only sets outline-style
+                  // on `:focus`, which a host app's zero-specificity
+                  // `:where(...):focus-visible { outline: ... }` base rule re-applies as
+                  // the full shorthand. `focus-visible:outline-none` matches the same
+                  // state at class specificity and wins, so no second highlight (the
+                  // top-half rectangle bounded to the textarea box) ever paints.
+                  "text-og-fg placeholder:text-og-fg-subtle focus:outline-none focus-visible:outline-none",
+                  "disabled:cursor-not-allowed disabled:opacity-60"
+                )
+              }
+            ),
+            confirmState && pendingDangerCommand ? /* @__PURE__ */ jsx3(
+              ConfirmBar,
+              {
+                command: pendingDangerCommand,
+                onCancel: () => confirmState.resolve(false),
+                onConfirm: () => confirmState.resolve(true)
+              }
+            ) : /* @__PURE__ */ jsxs2("div", { className: "flex items-center justify-between gap-2 px-2.5 pb-2.5 pt-1", children: [
+              attachments || controlsStart ? /* @__PURE__ */ jsxs2("span", { className: "flex min-w-0 items-center gap-1.5", children: [
+                attachments ? /* @__PURE__ */ jsxs2(Fragment, { children: [
+                  /* @__PURE__ */ jsx3(
+                    "input",
+                    {
+                      ref: fileInputRef,
+                      type: "file",
+                      multiple: true,
+                      className: "hidden",
+                      onChange: handleFileChange
+                    }
+                  ),
+                  /* @__PURE__ */ jsx3(
+                    "button",
+                    {
+                      type: "button",
+                      disabled: disabled === true,
+                      onClick: () => fileInputRef.current?.click(),
+                      "aria-label": "Attach files",
+                      title: "Attach files",
+                      className: cn(
+                        "inline-flex size-8 items-center justify-center rounded-og-md",
+                        "text-og-fg-muted transition-colors duration-150 hover:bg-og-surface-2 hover:text-og-fg",
+                        "disabled:cursor-not-allowed disabled:opacity-50"
+                      ),
+                      children: /* @__PURE__ */ jsx3(PaperclipIcon, { className: "size-4" })
+                    }
+                  )
+                ] }) : null,
+                controlsStart
+              ] }) : /* @__PURE__ */ jsx3("span", { className: "px-1.5 text-[11px] text-og-fg-subtle max-sm:hidden", children: hint ?? "Enter to send \xB7 Shift+Enter for a new line \xB7 / for commands" }),
+              /* @__PURE__ */ jsxs2("span", { className: "flex items-center gap-1.5", children: [
+                /* @__PURE__ */ jsx3(AnimatePresence2, { initial: false, children: active ? /* @__PURE__ */ jsx3(
+                  motion2.button,
+                  {
+                    type: "button",
+                    initial: { opacity: 0, scale: 0.8 },
+                    animate: { opacity: 1, scale: 1 },
+                    exit: { opacity: 0, scale: 0.8 },
+                    transition: { duration: 0.15, ease: "easeOut" },
+                    onClick: () => void composer.interrupt(),
+                    disabled: composer.interrupting,
+                    "aria-label": "Stop the current turn",
+                    title: "Stop the current turn",
+                    className: cn(
+                      "inline-flex size-8 items-center justify-center rounded-og-md border border-og-border",
+                      "bg-og-surface-2 text-og-fg-muted transition-colors duration-150",
+                      "hover:border-og-status-failed/50 hover:text-og-status-failed",
+                      "disabled:opacity-50"
+                    ),
+                    children: composer.interrupting ? /* @__PURE__ */ jsx3(LoaderCircleIcon, { className: "size-3.5 animate-og-spin" }) : /* @__PURE__ */ jsx3(SquareIcon, { className: "size-3 fill-current" })
+                  },
+                  "stop"
+                ) : null }),
+                /* @__PURE__ */ jsx3(
+                  "button",
+                  {
+                    type: "button",
+                    onClick: () => {
+                      if (blockedByUpload) {
+                        return;
+                      }
+                      void composer.send();
+                    },
+                    disabled: !canSend || disabled === true || commandDraftBlocked,
+                    "aria-label": "Send message",
+                    className: cn(
+                      "inline-flex size-8 items-center justify-center rounded-og-md",
+                      "bg-og-accent text-og-accent-fg shadow-og-sm",
+                      "transition-[background-color,transform,opacity] duration-150 ease-og-spring",
+                      "hover:bg-og-accent-strong active:scale-95",
+                      "disabled:cursor-not-allowed disabled:bg-og-surface-3 disabled:text-og-fg-subtle disabled:shadow-none"
+                    ),
+                    children: composer.sending ? /* @__PURE__ */ jsx3(LoaderCircleIcon, { className: "size-4 animate-og-spin" }) : /* @__PURE__ */ jsx3(ArrowUpIcon, { className: "size-4" })
+                  }
+                )
+              ] })
+            ] })
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx3(AnimatePresence2, { children: helpOpen ? /* @__PURE__ */ jsx3(HelpPanel, { commands: helpCommands, onClose: () => setHelpOpen(false) }) : null }),
+    /* @__PURE__ */ jsx3(AnimatePresence2, { children: activeNotice ? /* @__PURE__ */ jsx3(
+      motion2.p,
+      {
+        initial: { opacity: 0, height: 0 },
+        animate: { opacity: 1, height: "auto" },
+        exit: { opacity: 0, height: 0 },
+        className: cn(
+          "overflow-hidden px-1 pt-1.5 text-xs",
+          activeNotice.tone === "ok" ? "text-og-fg-muted" : "text-og-status-failed"
+        ),
+        role: activeNotice.tone === "error" ? "alert" : "status",
+        onAnimationComplete: () => {
+          if (activeNotice.tone === "ok") {
+            window.setTimeout(() => setNotice((current) => current === activeNotice ? null : current), 2400);
+          }
+        },
+        children: activeNotice.message
+      }
+    ) : null })
+  ] });
+}
+function ConfirmBar({ command, onCancel, onConfirm }) {
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      role: "alertdialog",
+      "aria-label": `Confirm /${command.name}`,
+      "data-testid": "danger-confirm",
+      className: "flex items-center justify-between gap-2 px-2.5 pb-2.5 pt-1",
+      children: [
+        /* @__PURE__ */ jsxs2("span", { className: "px-1.5 text-[12px] text-og-status-failed", children: [
+          "Run ",
+          /* @__PURE__ */ jsxs2("span", { className: "font-mono", children: [
+            "/",
+            command.name
+          ] }),
+          "? ",
+          command.description
+        ] }),
+        /* @__PURE__ */ jsxs2("span", { className: "flex items-center gap-1.5", children: [
+          /* @__PURE__ */ jsx3(
+            "button",
+            {
+              type: "button",
+              onClick: onCancel,
+              className: "rounded-og-md border border-og-border bg-og-surface-2 px-2.5 py-1 text-[12px] text-og-fg-muted hover:bg-og-surface-3",
+              children: "Cancel"
+            }
+          ),
+          /* @__PURE__ */ jsx3(
+            "button",
+            {
+              type: "button",
+              autoFocus: true,
+              onClick: onConfirm,
+              className: "rounded-og-md border border-og-status-failed/50 bg-og-status-failed/15 px-2.5 py-1 text-[12px] text-og-status-failed hover:bg-og-status-failed/25",
+              children: "Confirm"
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+function AttachmentChips({ attachments, onRemove }) {
+  return /* @__PURE__ */ jsx3("div", { className: "flex flex-wrap gap-2 border-b border-og-border px-3 py-2", children: attachments.map((attachment) => /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      className: cn(
+        "flex min-w-0 max-w-[240px] items-center gap-2 rounded-og-md border px-2 py-1.5",
+        "border-og-border bg-og-surface-2 text-xs"
+      ),
+      children: [
+        attachment.previewUrl ? /* @__PURE__ */ jsx3("img", { src: attachment.previewUrl, alt: "", className: "size-8 shrink-0 rounded object-cover" }) : attachment.contentType.startsWith("image/") ? /* @__PURE__ */ jsx3(ImageIcon, { className: "size-4 shrink-0 text-og-fg-muted" }) : /* @__PURE__ */ jsx3(FileIcon, { className: "size-4 shrink-0 text-og-fg-muted" }),
+        /* @__PURE__ */ jsxs2("div", { className: "min-w-0 flex-1", children: [
+          /* @__PURE__ */ jsx3("div", { className: "truncate font-medium text-og-fg", children: attachment.name }),
+          /* @__PURE__ */ jsx3(
+            "div",
+            {
+              className: cn(
+                "truncate text-[11px]",
+                attachment.status === "failed" ? "text-og-status-failed" : "text-og-fg-subtle"
+              ),
+              children: attachment.status === "uploading" ? "Uploading" : attachment.status === "failed" ? "Upload failed" : formatBytes(attachment.sizeBytes)
+            }
+          )
+        ] }),
+        attachment.status === "uploading" ? /* @__PURE__ */ jsx3(LoaderCircleIcon, { className: "size-3.5 shrink-0 animate-og-spin" }) : null,
+        /* @__PURE__ */ jsx3(
+          "button",
+          {
+            type: "button",
+            onClick: () => onRemove(attachment.id),
+            className: "shrink-0 rounded-og-xs p-1 text-og-fg-muted hover:bg-og-surface-1 hover:text-og-fg",
+            "aria-label": `Remove ${attachment.name}`,
+            children: /* @__PURE__ */ jsx3(XIcon, { className: "size-3.5" })
+          }
+        )
+      ]
+    },
+    attachment.id
+  )) });
+}
+function HelpPanel({ commands, onClose }) {
+  return /* @__PURE__ */ jsxs2(
+    motion2.div,
+    {
+      initial: { opacity: 0, height: 0 },
+      animate: { opacity: 1, height: "auto" },
+      exit: { opacity: 0, height: 0 },
+      className: "mt-2 overflow-hidden rounded-og-lg border border-og-border bg-og-surface-2",
+      children: [
+        /* @__PURE__ */ jsxs2("div", { className: "flex items-center justify-between border-b border-og-border px-3 py-1.5", children: [
+          /* @__PURE__ */ jsx3("span", { className: "text-[12px] font-medium text-og-fg", children: "Commands" }),
+          /* @__PURE__ */ jsx3("button", { type: "button", onClick: onClose, className: "text-[11px] text-og-fg-subtle hover:text-og-fg", children: "Close" })
+        ] }),
+        /* @__PURE__ */ jsx3("ul", { className: "py-1", children: commands.map((command) => {
+          const hint = argHint(command.args);
+          return /* @__PURE__ */ jsxs2("li", { className: "flex items-baseline gap-2 px-3 py-1", children: [
+            /* @__PURE__ */ jsxs2("span", { className: "font-mono text-[12px] text-og-accent", children: [
+              "/",
+              command.name,
+              hint ? /* @__PURE__ */ jsx3("span", { className: "ml-1 text-og-fg-subtle", children: hint }) : null
+            ] }),
+            /* @__PURE__ */ jsx3("span", { className: "text-[12px] text-og-fg-muted", children: command.description }),
+            command.danger ? /* @__PURE__ */ jsx3("span", { className: "ml-auto rounded-og-xs bg-og-status-failed/15 px-1 text-[10px] uppercase tracking-wide text-og-status-failed", children: "danger" }) : null
+          ] }, command.name);
+        }) })
+      ]
+    }
+  );
+}
+
+// src/components/message-timeline.tsx
+import {
+  ArrowDownIcon,
+  BotIcon,
+  BrainIcon,
+  ChevronRightIcon,
+  SquareTerminalIcon,
+  TargetIcon,
+  TriangleAlertIcon,
+  WrenchIcon
+} from "lucide-react";
+import { AnimatePresence as AnimatePresence3, motion as motion3 } from "motion/react";
+import { useEffect as useEffect7, useMemo as useMemo5, useRef as useRef8, useState as useState9 } from "react";
+import { Collapsible } from "radix-ui";
+
+// src/components/session-status.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var SESSION_STATUS_META = {
+  queued: {
+    label: "Queued",
+    dotClassName: "bg-og-status-queued",
+    badgeClassName: "text-og-fg-muted border-og-border bg-og-status-queued/10",
+    pulse: true
+  },
+  running: {
+    label: "Running",
+    dotClassName: "bg-og-status-running",
+    badgeClassName: "text-og-status-running border-og-status-running/30 bg-og-status-running/10",
+    pulse: true
+  },
+  idle: {
+    label: "Idle",
+    dotClassName: "bg-og-status-idle",
+    badgeClassName: "text-og-status-idle border-og-status-idle/30 bg-og-status-idle/10",
+    pulse: false
+  },
+  requires_action: {
+    label: "Needs you",
+    dotClassName: "bg-og-status-waiting",
+    badgeClassName: "text-og-status-waiting border-og-status-waiting/35 bg-og-status-waiting/10",
+    pulse: true
+  },
+  failed: {
+    label: "Failed",
+    dotClassName: "bg-og-status-failed",
+    badgeClassName: "text-og-status-failed border-og-status-failed/35 bg-og-status-failed/10",
+    pulse: false
+  },
+  cancelled: {
+    label: "Cancelled",
+    dotClassName: "bg-og-status-cancelled",
+    badgeClassName: "text-og-fg-subtle border-og-border bg-og-status-cancelled/10",
+    pulse: false
+  }
+};
+function SessionStatus({ status, label, size = "md", className }) {
+  const meta = SESSION_STATUS_META[status];
+  return /* @__PURE__ */ jsxs3(
+    "span",
+    {
+      "data-status": status,
+      className: cn(
+        "og-root inline-flex shrink-0 items-center rounded-full border font-medium",
+        size === "sm" ? "gap-1 px-1.5 py-px text-[10px]" : "gap-1.5 px-2 py-0.5 text-xs",
+        meta.badgeClassName,
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsx4(StatusDot, { status, className: size === "sm" ? "size-1" : "size-1.5" }),
+        label ?? meta.label
+      ]
+    }
+  );
+}
+function StatusDot({ status, className }) {
+  const meta = SESSION_STATUS_META[status];
+  return /* @__PURE__ */ jsx4("span", { className: cn("relative inline-flex size-1.5 shrink-0 rounded-full", meta.dotClassName, className), children: meta.pulse ? /* @__PURE__ */ jsx4("span", { className: cn("absolute inset-0 animate-og-pulse rounded-full", meta.dotClassName) }) : null });
+}
+
+// src/components/message-timeline.tsx
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function MessageTimeline({
+  events,
+  items,
+  status,
+  renderMessageText,
+  onOpenSession,
+  autoFollow = true,
+  emptyState,
+  className
+}) {
+  const resolvedItems = useMemo5(() => items ?? buildTimeline(events ?? []), [items, events]);
+  const groups = useMemo5(() => groupTimeline(resolvedItems), [resolvedItems]);
+  const scrollRef = useRef8(null);
+  const [pinned, setPinned] = useState9(true);
+  const lastItem = resolvedItems[resolvedItems.length - 1];
+  const streaming = lastItem !== void 0 && (lastItem.kind === "agent-message" || lastItem.kind === "reasoning") && lastItem.streaming;
+  const working = status === "running" && !streaming;
+  useEffect7(() => {
+    const node = scrollRef.current;
+    if (node && autoFollow && pinned) {
+      node.scrollTop = node.scrollHeight;
+    }
+  }, [resolvedItems, working, autoFollow, pinned]);
+  const onScroll = () => {
+    const node = scrollRef.current;
+    if (!node) {
+      return;
+    }
+    setPinned(node.scrollHeight - node.scrollTop - node.clientHeight < 48);
+  };
+  return /* @__PURE__ */ jsxs4("div", { className: cn("og-root relative min-h-0", className), children: [
+    /* @__PURE__ */ jsx5("div", { ref: scrollRef, onScroll, className: "h-full overflow-y-auto overscroll-contain px-4 py-6 sm:px-6", children: /* @__PURE__ */ jsxs4("div", { className: "mx-auto flex w-full max-w-3xl flex-col gap-5", children: [
+      groups.length === 0 && !working ? emptyState ?? /* @__PURE__ */ jsx5("p", { className: "py-10 text-center text-sm text-og-fg-subtle", children: "No activity yet." }) : null,
+      groups.map(
+        (group) => group.kind === "activity" ? /* @__PURE__ */ jsx5(ActivityCluster, { items: group.items, onOpenSession }, group.id) : /* @__PURE__ */ jsx5(TimelineRow, { item: group.item, renderMessageText }, group.item.id)
+      ),
+      working ? /* @__PURE__ */ jsx5("div", { className: "animate-og-enter flex items-center gap-2 text-sm", children: /* @__PURE__ */ jsx5("span", { className: "og-shimmer-text font-medium", children: "Working\u2026" }) }) : null
+    ] }) }),
+    /* @__PURE__ */ jsx5(AnimatePresence3, { children: !pinned && autoFollow ? /* @__PURE__ */ jsxs4(
+      motion3.button,
+      {
+        type: "button",
+        initial: { opacity: 0, y: 8 },
+        animate: { opacity: 1, y: 0 },
+        exit: { opacity: 0, y: 8 },
+        transition: { duration: 0.15, ease: "easeOut" },
+        onClick: () => {
+          const node = scrollRef.current;
+          if (node) {
+            node.scrollTo({ top: node.scrollHeight, behavior: "smooth" });
+          }
+          setPinned(true);
+        },
+        className: cn(
+          "absolute bottom-4 left-1/2 -translate-x-1/2",
+          "inline-flex items-center gap-1.5 rounded-full border border-og-border bg-og-surface-3/90 px-3 py-1.5",
+          "text-xs font-medium text-og-fg shadow-og-md backdrop-blur",
+          "hover:border-og-border-strong"
+        ),
+        children: [
+          /* @__PURE__ */ jsx5(ArrowDownIcon, { className: "size-3.5" }),
+          "Jump to latest"
+        ]
+      }
+    ) : null })
+  ] });
+}
+function TimelineRow({
+  item,
+  renderMessageText
+}) {
+  switch (item.kind) {
+    case "user-message":
+      return /* @__PURE__ */ jsx5(UserMessageRow, { item, renderMessageText });
+    case "agent-message":
+      return /* @__PURE__ */ jsx5(AgentMessageRow, { item, renderMessageText });
+    case "session-status":
+      return /* @__PURE__ */ jsx5(SessionStatusRow, { item });
+    case "goal":
+      return /* @__PURE__ */ jsx5(GoalRow, { item });
+    case "notice":
+      return /* @__PURE__ */ jsx5(NoticeRow, { item });
+    default:
+      return null;
+  }
+}
+function UserMessageRow({
+  item,
+  renderMessageText
+}) {
+  return /* @__PURE__ */ jsx5("div", { className: "animate-og-enter flex justify-end", children: /* @__PURE__ */ jsx5("div", { className: "max-w-[85%] rounded-og-lg rounded-br-og-xs border border-og-border bg-og-surface-2 px-4 py-2.5 text-[15px] leading-6 text-og-fg", children: renderMessageText ? renderMessageText(item.text, item) : /* @__PURE__ */ jsx5("span", { className: "whitespace-pre-wrap", children: item.text }) }) });
+}
+function AgentMessageRow({
+  item,
+  renderMessageText
+}) {
+  return /* @__PURE__ */ jsxs4("div", { className: "animate-og-enter text-[15px] leading-7 text-og-fg", children: [
+    renderMessageText ? renderMessageText(item.text, item) : /* @__PURE__ */ jsx5("span", { className: "whitespace-pre-wrap", children: item.text }),
+    item.streaming ? /* @__PURE__ */ jsx5("span", { className: "ml-0.5 inline-block h-[1.1em] w-[2px] translate-y-[3px] animate-og-blink rounded-full bg-og-accent", "aria-hidden": true }) : null
+  ] });
+}
+function SessionStatusRow({ item }) {
+  const meta = SESSION_STATUS_META[item.status];
+  return /* @__PURE__ */ jsxs4("div", { className: "animate-og-enter flex items-center gap-3 text-[11px] text-og-fg-subtle", role: "status", children: [
+    /* @__PURE__ */ jsx5("span", { className: "h-px flex-1 bg-og-border" }),
+    /* @__PURE__ */ jsxs4("span", { className: "inline-flex items-center gap-1.5", children: [
+      /* @__PURE__ */ jsx5(StatusDot, { status: item.status, className: "size-1" }),
+      meta.label.toLowerCase(),
+      " \xB7 ",
+      formatRelativeTime(item.occurredAt)
+    ] }),
+    /* @__PURE__ */ jsx5("span", { className: "h-px flex-1 bg-og-border" })
+  ] });
+}
+function GoalRow({ item }) {
+  const label = item.action === "set" ? "Goal set" : item.action === "updated" ? "Goal updated" : item.action === "completed" ? "Goal completed" : item.action === "paused" ? "Goal paused" : item.action === "resumed" ? "Goal resumed" : "Continuing toward the goal";
+  return /* @__PURE__ */ jsx5("div", { className: "animate-og-enter flex justify-center", children: /* @__PURE__ */ jsxs4("span", { className: "inline-flex max-w-full items-center gap-1.5 rounded-full border border-og-border bg-og-surface-1 px-3 py-1 text-xs text-og-fg-muted", children: [
+    /* @__PURE__ */ jsx5(TargetIcon, { className: "size-3.5 shrink-0 text-og-accent" }),
+    /* @__PURE__ */ jsxs4("span", { className: "truncate", children: [
+      label,
+      item.text ? `: ${truncate(item.text, 90)}` : ""
+    ] })
+  ] }) });
+}
+function NoticeRow({ item }) {
+  const tone = item.tone === "failed" ? "border-og-status-failed/35 bg-og-status-failed/10 text-og-status-failed" : item.tone === "waiting" ? "border-og-status-waiting/35 bg-og-status-waiting/10 text-og-status-waiting" : "border-og-border bg-og-surface-1 text-og-fg-muted";
+  return /* @__PURE__ */ jsxs4("div", { className: cn("animate-og-enter flex items-start gap-2.5 rounded-og-md border px-3.5 py-2.5 text-sm", tone), role: "status", children: [
+    /* @__PURE__ */ jsx5(TriangleAlertIcon, { className: cn("mt-0.5 size-4 shrink-0", item.tone === "cancelled" && "opacity-60") }),
+    /* @__PURE__ */ jsx5("span", { className: "min-w-0 whitespace-pre-wrap break-words", children: item.text })
+  ] });
+}
+function ActivityCluster({
+  items,
+  onOpenSession
+}) {
+  return /* @__PURE__ */ jsx5("div", { className: "animate-og-enter flex flex-col gap-1.5 border-l-2 border-og-border pl-3 sm:pl-4", children: items.map((item) => {
+    switch (item.kind) {
+      case "reasoning":
+        return /* @__PURE__ */ jsx5(ReasoningRow, { item }, item.id);
+      case "tool-call":
+        return /* @__PURE__ */ jsx5(ToolCallRow, { item }, item.id);
+      case "worker":
+        return /* @__PURE__ */ jsx5(WorkerRow, { item, onOpenSession }, item.id);
+      case "sandbox":
+        return /* @__PURE__ */ jsx5(SandboxRow, { item }, item.id);
+    }
+  }) });
+}
+function ActivityDisclosure({
+  icon,
+  title,
+  running,
+  failed,
+  preview,
+  children
+}) {
+  const [open, setOpen] = useState9(false);
+  return /* @__PURE__ */ jsxs4(Collapsible.Root, { open, onOpenChange: setOpen, children: [
+    /* @__PURE__ */ jsxs4(
+      Collapsible.Trigger,
+      {
+        className: cn(
+          "group flex w-full min-w-0 items-center gap-2 rounded-og-sm px-1.5 py-1 text-left text-[13px]",
+          "text-og-fg-muted transition-colors duration-150 hover:bg-og-surface-1 hover:text-og-fg"
+        ),
+        children: [
+          /* @__PURE__ */ jsx5(ChevronRightIcon, { className: "size-3.5 shrink-0 text-og-fg-subtle transition-transform duration-150 group-data-[state=open]:rotate-90" }),
+          /* @__PURE__ */ jsx5("span", { className: cn("shrink-0", failed ? "text-og-status-failed" : running ? "text-og-status-running" : "text-og-fg-subtle"), children: icon }),
+          /* @__PURE__ */ jsx5("span", { className: cn("shrink-0 font-medium", running && "og-shimmer-text", failed && "text-og-status-failed"), children: title }),
+          preview ? /* @__PURE__ */ jsx5("span", { className: "min-w-0 flex-1 truncate font-og-mono text-xs text-og-fg-subtle", children: preview }) : null,
+          running ? /* @__PURE__ */ jsx5("span", { className: "ml-auto size-1.5 shrink-0 animate-og-pulse rounded-full bg-og-status-running" }) : null
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx5(Collapsible.Content, { className: "overflow-hidden", children: /* @__PURE__ */ jsx5("div", { className: "mt-1 mb-1.5 ml-7 flex flex-col gap-2", children }) })
+  ] });
+}
+function PayloadBlock({ label, value }) {
+  const text = stringifyPayload(value);
+  if (!text) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs4("div", { className: "min-w-0", children: [
+    /* @__PURE__ */ jsx5("p", { className: "mb-1 text-[10px] font-medium uppercase tracking-[0.08em] text-og-fg-subtle", children: label }),
+    /* @__PURE__ */ jsx5("pre", { className: "max-h-64 overflow-auto rounded-og-sm border border-og-border bg-og-bg/60 p-2.5 font-og-mono text-xs leading-5 text-og-fg-muted", children: text })
+  ] });
+}
+function ReasoningRow({ item }) {
+  return /* @__PURE__ */ jsx5(
+    ActivityDisclosure,
+    {
+      icon: /* @__PURE__ */ jsx5(BrainIcon, { className: "size-3.5" }),
+      title: item.streaming ? "Thinking" : "Thought",
+      running: item.streaming,
+      preview: truncate(item.text, 110),
+      children: /* @__PURE__ */ jsx5("p", { className: "whitespace-pre-wrap text-[13px] leading-6 text-og-fg-muted", children: item.text })
+    }
+  );
+}
+function ToolCallRow({ item }) {
+  return /* @__PURE__ */ jsxs4(
+    ActivityDisclosure,
+    {
+      icon: /* @__PURE__ */ jsx5(WrenchIcon, { className: "size-3.5" }),
+      title: toolDisplayName(item.name),
+      running: item.status === "running",
+      preview: compactPayloadPreview(item.arguments),
+      children: [
+        /* @__PURE__ */ jsx5(PayloadBlock, { label: "Arguments", value: item.arguments }),
+        item.status === "complete" ? /* @__PURE__ */ jsx5(PayloadBlock, { label: "Output", value: item.output }) : null
+      ]
+    }
+  );
+}
+function SandboxRow({ item }) {
+  return /* @__PURE__ */ jsxs4(
+    ActivityDisclosure,
+    {
+      icon: /* @__PURE__ */ jsx5(SquareTerminalIcon, { className: "size-3.5" }),
+      title: toolDisplayName(item.name),
+      running: item.status === "running",
+      failed: item.status === "failed",
+      preview: item.command ?? void 0,
+      children: [
+        item.command ? /* @__PURE__ */ jsx5(PayloadBlock, { label: "Command", value: item.command }) : null,
+        item.output ? /* @__PURE__ */ jsx5(PayloadBlock, { label: "Output", value: item.output }) : null
+      ]
+    }
+  );
+}
+function WorkerRow({ item, onOpenSession }) {
+  const running = item.status === "running";
+  const title = item.action === "spawn" ? running ? "Spawning worker" : "Worker spawned" : running ? "Messaging worker" : "Worker messaged";
+  return /* @__PURE__ */ jsxs4("div", { className: "my-0.5 flex items-start gap-3 rounded-og-md border border-og-border bg-og-surface-1 p-3 shadow-og-sm", children: [
+    /* @__PURE__ */ jsx5(
+      "span",
+      {
+        className: cn(
+          "mt-0.5 inline-flex size-7 shrink-0 items-center justify-center rounded-og-sm",
+          "bg-og-accent-soft text-og-accent"
+        ),
+        children: /* @__PURE__ */ jsx5(BotIcon, { className: "size-4" })
+      }
+    ),
+    /* @__PURE__ */ jsxs4("div", { className: "min-w-0 flex-1", children: [
+      /* @__PURE__ */ jsxs4("div", { className: "flex items-center gap-2", children: [
+        /* @__PURE__ */ jsx5("span", { className: cn("text-[13px] font-medium", running ? "og-shimmer-text" : "text-og-fg"), children: title }),
+        running ? /* @__PURE__ */ jsx5("span", { className: "size-1.5 animate-og-pulse rounded-full bg-og-status-running" }) : null
+      ] }),
+      item.prompt ? /* @__PURE__ */ jsx5("p", { className: "mt-0.5 truncate text-xs text-og-fg-muted", children: truncate(item.prompt, 140) }) : null,
+      item.workerSessionId ? /* @__PURE__ */ jsx5("p", { className: "mt-1 font-og-mono text-[11px] text-og-fg-subtle", children: item.workerSessionId.slice(0, 8) }) : null
+    ] }),
+    item.workerSessionId && onOpenSession ? /* @__PURE__ */ jsx5(
+      "button",
+      {
+        type: "button",
+        onClick: () => item.workerSessionId && onOpenSession(item.workerSessionId),
+        className: cn(
+          "shrink-0 self-center rounded-og-sm border border-og-border px-2.5 py-1 text-xs font-medium text-og-fg-muted",
+          "transition-colors duration-150 hover:border-og-border-strong hover:text-og-fg"
+        ),
+        children: "Open session"
+      }
+    ) : null
+  ] });
+}
+
+// src/components/fleet-tile.tsx
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function sessionDisplayTitle(session) {
+  for (const key of ["title", "name"]) {
+    const value = session.metadata[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value;
+    }
+  }
+  return truncate(session.initialMessage, 100) || session.id.slice(0, 8);
+}
+function FleetTile({ session, title, subtitle, onOpen, className }) {
+  const running = session.status === "running" || session.status === "queued";
+  const needsYou = session.status === "requires_action";
+  return /* @__PURE__ */ jsxs5(
+    "button",
+    {
+      type: "button",
+      "data-status": session.status,
+      onClick: onOpen ? () => onOpen(session) : void 0,
+      disabled: !onOpen,
+      className: cn(
+        "og-root group relative flex w-full flex-col gap-2.5 overflow-hidden rounded-og-lg border border-og-border",
+        "bg-og-surface-1 p-4 text-left shadow-og-sm",
+        "transition-[border-color,background-color,box-shadow,transform] duration-200 ease-og-out",
+        onOpen && "hover:-translate-y-px hover:border-og-border-strong hover:bg-og-surface-2 hover:shadow-og-md",
+        "disabled:cursor-default",
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsx6(
+          "span",
+          {
+            "aria-hidden": true,
+            className: cn(
+              "absolute inset-y-0 left-0 w-0.5 transition-opacity duration-300",
+              running ? "bg-og-accent opacity-100" : needsYou ? "bg-og-status-waiting opacity-100" : "opacity-0"
+            )
+          }
+        ),
+        /* @__PURE__ */ jsxs5("span", { className: "flex w-full items-start justify-between gap-3", children: [
+          /* @__PURE__ */ jsx6("span", { className: "line-clamp-2 min-w-0 text-sm font-medium leading-snug text-og-fg", children: title ?? sessionDisplayTitle(session) }),
+          /* @__PURE__ */ jsx6(SessionStatus, { status: session.status, size: "sm", className: "mt-px" })
+        ] }),
+        subtitle ? /* @__PURE__ */ jsx6("span", { className: "line-clamp-1 text-xs text-og-fg-muted", children: subtitle }) : null,
+        /* @__PURE__ */ jsxs5("span", { className: "mt-auto flex w-full items-center gap-2 text-[11px] text-og-fg-subtle", children: [
+          /* @__PURE__ */ jsx6("span", { className: "font-og-mono", children: session.id.slice(0, 8) }),
+          /* @__PURE__ */ jsx6("span", { "aria-hidden": true, children: "\xB7" }),
+          /* @__PURE__ */ jsx6("span", { className: "truncate", children: session.model }),
+          /* @__PURE__ */ jsx6("span", { className: "ml-auto shrink-0", title: session.updatedAt, children: formatRelativeTime(session.updatedAt) })
+        ] })
+      ]
+    }
+  );
+}
+export {
+  ChatComposer,
+  CommandPalette,
+  FleetTile,
+  MessageTimeline,
+  OpenGeniProvider,
+  SESSION_STATUS_META,
+  SessionStatus,
+  StatusDot,
+  activeTurnFromTurns,
+  applyTurnEdit,
+  applyTurnRemoval,
+  applyTurnReorder,
+  approvalsFromRequiresAction,
+  argHint,
+  buildTimeline,
+  cn,
+  compactPayloadPreview,
+  composeSendInput,
+  defaultCommands,
+  extractSessionRef,
+  filterCommands,
+  firstMissingRequiredArg,
+  formatBytes,
+  formatRelativeTime,
+  groupTimeline,
+  hasPermission,
+  isGoalEvent,
+  isTurnQueueEvent,
+  matchCommand,
+  parseCommandLine,
+  projectPendingApprovals,
+  queueFromTurns,
+  sessionDisplayTitle,
+  sessionStatusFromEvents,
+  shouldSubmitOnKey,
+  stringifyPayload,
+  toolDisplayName,
+  truncate,
+  tryParseJson,
+  useBillingUsage,
+  useComposer,
+  useEnvironments,
+  useFileAttachments,
+  useGoal,
+  useOpenGeni,
+  useOpenGeniClient,
+  usePacks,
+  useScheduledTasks,
+  useSession,
+  useSessionControl,
+  useSessionEvents,
+  useSlashCommands,
+  useTurnQueue,
+  useWorkspaceSessions,
+  useWorkspaces
+};
+//# sourceMappingURL=index.js.map