@agentdocumentformat/cli 0.7.2

package/dist/chunks/chunk-3M4ZPOA3.mjs

@@ -0,0 +1,1477 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  require_jsx_runtime
+} from "./chunk-7CV2SA3H.mjs";
+import {
+  DaemonError,
+  MAIN_LOOP
+} from "./chunk-XNPZBLYL.mjs";
+import {
+  cjs
+} from "./chunk-SGUTYISF.mjs";
+import {
+  loop_parser_exports
+} from "./chunk-5PO5PKRV.mjs";
+import {
+  require_react
+} from "./chunk-6GJ4QHRI.mjs";
+import {
+  __toESM
+} from "./chunk-M2RX3S2T.mjs";
+
+// src/main/tui/state/store.tsx
+var import_react = __toESM(require_react(), 1);
+
+// src/main/tui/state/tracked.ts
+var TRACKED_PREFIX = "file:";
+function trackedKey(filePath) {
+  return `${TRACKED_PREFIX}${filePath}`;
+}
+function isTrackedKey(id) {
+  return !!id && id.startsWith(TRACKED_PREFIX);
+}
+function trackedPath(key) {
+  return key.slice(TRACKED_PREFIX.length);
+}
+var FOLD_CASE = process.platform === "win32" || process.platform === "darwin";
+function normPath(p) {
+  let n = p.replace(/\\/g, "/").replace(/\/+$/, "");
+  return FOLD_CASE ? n.toLowerCase() : n;
+}
+function samePath(a, b) {
+  return !!a && !!b && normPath(a) === normPath(b);
+}
+function relativeTo(folder, file) {
+  let f = file.replace(/\\/g, "/"), root = folder.replace(/\\/g, "/").replace(/\/+$/, "");
+  return normPath(f).startsWith(`${normPath(root)}/`) ? f.slice(root.length + 1) : f.slice(f.lastIndexOf("/") + 1);
+}
+function folderName(folder) {
+  let parts = folder.replace(/\\/g, "/").replace(/\/+$/, "").split("/");
+  return parts[parts.length - 1] || folder;
+}
+function stoppedLabel(entry, errors = {}) {
+  let a = entry.agent;
+  if (a.status === "unreadable") return "unreadable";
+  if (a.error || errors[a.filePath]) return "load error";
+  switch (a.status) {
+    case "needs_review":
+      return "needs review";
+    case "password_protected":
+      return "locked";
+    default:
+      return "stopped";
+  }
+}
+function stoppedError(entry, errors = {}) {
+  return errors[entry.agent.filePath] ?? entry.agent.error;
+}
+function buildTracked(list, loaded, previous) {
+  let loadedPaths = new Set(loaded.map((a) => a.filePath).filter((p) => !!p).map(normPath)), seen = /* @__PURE__ */ new Set(), stopped = [];
+  for (let folder of list.folders) {
+    let rows = [];
+    for (let agent of folder.agents) {
+      let n = normPath(agent.filePath);
+      agent.status === "loaded" || loadedPaths.has(n) || seen.has(n) || (seen.add(n), rows.push({ key: trackedKey(agent.filePath), folder: folder.path, relPath: relativeTo(folder.path, agent.filePath), agent }));
+    }
+    rows.sort((a, b) => a.relPath.localeCompare(b.relPath)), stopped.push(...rows);
+  }
+  let errors = {};
+  for (let [path, error] of Object.entries(previous?.errors ?? {})) seen.has(normPath(path)) && (errors[path] = error);
+  return {
+    folders: list.folders.map((f) => ({ path: f.path, exists: f.exists, agentCount: f.agentCount ?? f.agents.length, loadedCount: f.agentCount !== void 0 ? f.loadedCount : f.agents.filter((a) => a.status === "loaded").length })),
+    stopped,
+    errors,
+    busy: previous?.busy ?? {},
+    at: Date.now()
+  };
+}
+function pruneLoaded(tracked, loaded) {
+  let loadedPaths = new Set(loaded.map((a) => a.filePath).filter((p) => !!p).map(normPath)), stopped = tracked.stopped.filter((t) => !loadedPaths.has(normPath(t.agent.filePath)));
+  if (stopped.length === tracked.stopped.length) return tracked;
+  let errors = { ...tracked.errors };
+  for (let t of tracked.stopped) loadedPaths.has(normPath(t.agent.filePath)) && delete errors[t.agent.filePath];
+  return { ...tracked, stopped, errors };
+}
+function underTrackedFolder(tracked, file) {
+  if (!tracked) return !1;
+  let f = normPath(file);
+  return tracked.folders.some((folder) => f.startsWith(`${normPath(folder.path)}/`));
+}
+function findTracked(state, key) {
+  if (!(!key || !state.tracked))
+    return state.tracked.stopped.find((t) => t.key === key) ?? state.tracked.stopped.find((t) => samePath(t.agent.filePath, trackedPath(key)));
+}
+function loadedIdForPath(state, filePath) {
+  return state.agentOrder.find((id) => samePath(state.agents[id]?.summary.filePath, filePath));
+}
+function reconcileSelection(state, previousSummaries = {}, trackedFresh = !1) {
+  let selected = state.selectedAgentId;
+  if (selected && !isTrackedKey(selected)) {
+    if (state.agents[selected]) return selected;
+    let file = previousSummaries[selected]?.filePath;
+    if (file) {
+      let t = findTracked(state, trackedKey(file));
+      if (t) return t.key;
+      if (underTrackedFolder(state.tracked, file)) return trackedKey(file);
+    }
+  } else if (selected) {
+    let loadedId = loadedIdForPath(state, trackedPath(selected));
+    if (loadedId) return loadedId;
+    let t = findTracked(state, selected);
+    if (t) return t.key;
+    if (!trackedFresh && (!state.tracked || underTrackedFolder(state.tracked, trackedPath(selected)))) return selected;
+  }
+  return state.agentOrder[0] ?? state.tracked?.stopped[0]?.key ?? null;
+}
+
+// src/main/tui/state/transcript.ts
+var MAX_TRANSCRIPT_ITEMS = 2e3, { parseLoopToDisplay } = cjs(loop_parser_exports), localCounter = 0;
+function localId(prefix = "l") {
+  return localCounter += 1, `${prefix}:${Date.now().toString(36)}:${localCounter}`;
+}
+function emptyTranscript() {
+  return { items: [], loaded: !1, loading: !1, total: 0, oldestOffset: 0, live: !1 };
+}
+function isAsyncInput(input) {
+  if (!input || typeof input != "object" || Array.isArray(input)) return !1;
+  let flag = input._async;
+  return flag === !0 || flag === "true";
+}
+function isTaskRef(text) {
+  if (!text || !text.startsWith("{") || !text.includes("task_id")) return !1;
+  try {
+    let value = JSON.parse(text);
+    return typeof value.task_id == "string" && (value.status === "running" || value.status === "pending_approval");
+  } catch {
+    return !1;
+  }
+}
+function askQuestion(input) {
+  let q = input && typeof input == "object" ? input.question : void 0;
+  return typeof q == "string" ? q : "";
+}
+function historyToItems(entries) {
+  let items = [], toolsById = /* @__PURE__ */ new Map();
+  for (let entry of parseLoopToDisplay(entries)) {
+    let meta = entry.metadata ?? {}, base = { id: `h:${entry.id}`, at: entry.timestamp, seq: typeof meta.seq == "number" ? meta.seq : void 0 };
+    switch (entry.type) {
+      case "user":
+        items.push({ ...base, kind: "user", text: entry.content, origin: "owner" });
+        break;
+      case "trigger":
+        items.push({ ...base, kind: "user", text: entry.content, origin: "runtime" });
+        break;
+      case "context":
+        meta.category === "loop" && typeof meta.fromLoop == "string" ? items.push({ ...base, kind: "user", text: entry.content, origin: "loop", from: meta.fromLoop }) : items.push({ ...base, kind: "context", category: String(meta.category ?? "context"), text: entry.content });
+        break;
+      case "compaction":
+        items.push({ ...base, kind: "context", category: "compaction", text: entry.content });
+        break;
+      case "error":
+        items.push({ ...base, kind: "error", text: entry.content });
+        break;
+      case "text":
+        items.push({ ...base, kind: "assistant", text: entry.content, streaming: !1, model: typeof meta.model == "string" ? meta.model : void 0 });
+        break;
+      case "thinking":
+        items.push({ ...base, kind: "thinking", text: entry.content, streaming: !1 });
+        break;
+      case "tool_call": {
+        let tool = {
+          ...base,
+          kind: "tool",
+          toolUseId: typeof meta.tool_id == "string" ? meta.tool_id : void 0,
+          name: typeof meta.name == "string" ? meta.name : "tool",
+          input: meta.input,
+          status: "running",
+          ...isAsyncInput(meta.input) ? { async: !0 } : {}
+        };
+        tool.toolUseId && toolsById.set(tool.toolUseId, tool), items.push(tool);
+        break;
+      }
+      case "tool_result": {
+        let useId = typeof meta.tool_use_id == "string" ? meta.tool_use_id : void 0, call = useId ? toolsById.get(useId) : void 0, status = meta.isError ? "error" : "ok";
+        call ? (call.status = status, call.result = entry.content, call.completedAt = entry.timestamp, !meta.isError && isTaskRef(entry.content) && (call.async = !0, call.taskRef = entry.content)) : items.push({ ...base, kind: "tool", toolUseId: useId, name: typeof meta.name == "string" ? meta.name : "tool", input: void 0, status, result: entry.content, completedAt: entry.timestamp });
+        break;
+      }
+    }
+  }
+  return items;
+}
+function mergeHistory(existing, incoming) {
+  let finished = /* @__PURE__ */ new Map();
+  for (let item of existing)
+    item.kind === "tool" && item.toolUseId && item.status !== "running" && item.result !== void 0 && finished.set(item.toolUseId, item);
+  let history = incoming.map((item) => {
+    if (item.kind !== "tool" || item.taskRef === void 0 || !item.toolUseId) return item;
+    let live = finished.get(item.toolUseId);
+    return !live || live.result === item.taskRef ? item : { ...item, status: live.status, result: live.result, completedAt: live.completedAt };
+  }), historyTools = /* @__PURE__ */ new Set(), historyTexts = /* @__PURE__ */ new Map(), countText = (key) => historyTexts.set(key, (historyTexts.get(key) ?? 0) + 1);
+  for (let item of history)
+    item.kind === "tool" && item.toolUseId && historyTools.add(item.toolUseId), (item.kind === "user" || item.kind === "assistant" || item.kind === "thinking") && countText(`${item.kind}:${item.text.trim()}`), item.kind === "tool" && item.name === "ask" && countText(`ask:${askQuestion(item.input).trim()}`);
+  let consume = (key) => {
+    let n = historyTexts.get(key) ?? 0;
+    return n <= 0 ? !1 : (historyTexts.set(key, n - 1), !0);
+  }, keep = existing.filter((item) => {
+    if (!item.local) return !1;
+    switch (item.kind) {
+      case "tool":
+        return !(item.toolUseId && historyTools.has(item.toolUseId));
+      case "user":
+      case "assistant":
+      case "thinking":
+        return !consume(`${item.kind}:${item.text.trim()}`);
+      case "context":
+        return !1;
+      case "ask":
+        return !consume(`ask:${item.question.trim()}`);
+      default:
+        return !0;
+    }
+  });
+  return sortByTime([...history, ...keep]);
+}
+function prependHistory(existing, older) {
+  let ids = new Set(existing.map((item) => item.id)), orphans = /* @__PURE__ */ new Map();
+  for (let item of existing)
+    item.kind === "tool" && !item.local && item.toolUseId && item.status !== "running" && orphans.set(item.toolUseId, item);
+  let merged = /* @__PURE__ */ new Set();
+  return [...older.filter((item) => !ids.has(item.id)).map((item) => {
+    if (item.kind !== "tool" || item.status !== "running" || !item.toolUseId) return item;
+    let result = orphans.get(item.toolUseId);
+    return result ? (merged.add(result), { ...item, status: result.status, result: result.result, completedAt: result.completedAt }) : item;
+  }), ...merged.size ? existing.filter((item) => !merged.has(item)) : existing];
+}
+function sortByTime(items) {
+  return items.map((item, index) => ({ item, index })).sort((a, b) => a.item.at - b.item.at || a.index - b.index).map((entry) => entry.item);
+}
+function finalizeStreaming(items) {
+  let changed = !1, next = items.map((item) => (item.kind === "assistant" || item.kind === "thinking") && item.streaming ? (changed = !0, { ...item, streaming: !1 }) : item);
+  return changed ? next : items;
+}
+function cap(items) {
+  return items.length > MAX_TRANSCRIPT_ITEMS ? items.slice(items.length - MAX_TRANSCRIPT_ITEMS) : items;
+}
+function str(value) {
+  return typeof value == "string" ? value : void 0;
+}
+function resultText(value) {
+  if (typeof value == "string") return value;
+  if (value && typeof value == "object" && "content" in value) {
+    let content = value.content;
+    return typeof content == "string" ? content : content === void 0 ? void 0 : JSON.stringify(content);
+  }
+  return value === void 0 ? void 0 : JSON.stringify(value);
+}
+function applyEventToItems(items, event) {
+  let p = event.payload ?? {}, at = event.timestamp || Date.now();
+  switch (event.event_type) {
+    case "turn.delta": {
+      let kind = p.kind === "thinking" ? "thinking" : "assistant", text = str(p.text) ?? "";
+      if (!text) return items;
+      let last = items[items.length - 1];
+      if (last && last.kind === kind && last.streaming) {
+        let next = items.slice();
+        return next[next.length - 1] = { ...last, text: last.text + text }, next;
+      }
+      let closed = finalizeStreaming(items), item = kind === "thinking" ? { id: localId(), at, local: !0, kind: "thinking", text, streaming: !0 } : { id: localId(), at, local: !0, kind: "assistant", text, streaming: !0 };
+      return cap([...closed, item]);
+    }
+    case "tool.started": {
+      let toolUseId = str(p.id);
+      if (toolUseId && items.some((item) => item.kind === "tool" && item.toolUseId === toolUseId)) return items;
+      let tool = { id: localId(), at, local: !0, kind: "tool", toolUseId, name: str(p.name) ?? "tool", input: p.input, status: "running" };
+      if (tool.name === "ask") {
+        let question = askQuestion(p.input).trim(), card = -1;
+        for (let i = items.length - 1; i >= 0; i--) {
+          let item = items[i];
+          if (item.kind === "ask" && item.question.trim() === question) {
+            card = i;
+            break;
+          }
+        }
+        if (card >= 0) {
+          let next = items.slice();
+          return next[card] = { ...tool, id: items[card].id, at: items[card].at }, next;
+        }
+      }
+      return cap([...finalizeStreaming(items), tool]);
+    }
+    case "tool.completed":
+    case "tool.failed": {
+      let toolUseId = str(p.id), name = str(p.name), index = -1;
+      for (let i = items.length - 1; i >= 0; i--) {
+        let item = items[i];
+        if (item.kind === "tool" && (toolUseId ? item.toolUseId === toolUseId : item.status === "running" && item.name === name)) {
+          index = i;
+          break;
+        }
+      }
+      let patch = { status: event.event_type === "tool.failed" || p.isError === !0 ? "error" : "ok", result: resultText(p.result), completedAt: at };
+      if (index < 0)
+        return cap([...items, { id: localId(), at, local: !0, kind: "tool", toolUseId, name: name ?? "tool", input: p.input, ...patch }]);
+      let next = items.slice();
+      return next[index] = { ...next[index], ...patch }, next;
+    }
+    case "turn.completed": {
+      let closed = finalizeStreaming(items), content = str(p.content)?.trim();
+      if (!content) return closed;
+      let lastUser = -1;
+      for (let i = closed.length - 1; i >= 0; i--) if (closed[i].kind === "user") {
+        lastUser = i;
+        break;
+      }
+      return closed.slice(lastUser + 1).some((item) => item.kind === "assistant") ? closed : cap([...closed, { id: localId(), at, local: !0, kind: "assistant", text: content, streaming: !1 }]);
+    }
+    case "hil.requested": {
+      let taskId = str(p.task_id) ?? str(p.request_id);
+      return !taskId || items.some((item) => item.kind === "hil" && item.taskId === taskId) ? items : cap([...finalizeStreaming(items), { id: localId(), at, local: !0, kind: "hil", taskId, tool: str(p.tool) ?? "tool", input: p.input, reason: str(p.reason), status: "pending" }]);
+    }
+    case "hil.resolved": {
+      let taskId = str(p.task_id) ?? str(p.request_id), index = items.findIndex((item) => item.kind === "hil" && item.taskId === taskId), status = p.approved === !0 ? "approved" : "denied";
+      if (index < 0)
+        return cap([...items, { id: localId(), at, local: !0, kind: "notice", level: "info", event: event.event_type, text: `Approval ${taskId ?? ""} ${status}${p.timed_out ? " (timed out)" : ""}` }]);
+      let next = items.slice();
+      return next[index] = { ...next[index], status, feedback: str(p.feedback) }, next;
+    }
+    case "ask.requested": {
+      let requestId = str(p.request_id);
+      return !requestId || items.some((item) => item.kind === "ask" && item.requestId === requestId) ? items : cap([...finalizeStreaming(items), { id: localId(), at, local: !0, kind: "ask", requestId, question: str(p.question) ?? "", status: "pending" }]);
+    }
+    case "ask.resolved": {
+      let requestId = str(p.request_id), index = items.findIndex((item) => item.kind === "ask" && item.requestId === requestId);
+      if (index < 0) return items;
+      let next = items.slice();
+      return next[index] = { ...next[index], status: "answered", answer: str(p.preview) }, next;
+    }
+    case "agent.error": {
+      let text = describeAgentError(p);
+      return cap([...finalizeStreaming(items), { id: localId(), at, local: !0, kind: "error", text }]);
+    }
+    default: {
+      let notice = noticeFor(event);
+      return notice ? cap([...items, { id: localId(), at, local: !0, kind: "notice", event: event.event_type, ...notice }]) : items;
+    }
+  }
+}
+function noticeFor(event) {
+  let p = event.payload ?? {};
+  switch (event.event_type) {
+    case "agent.state.changed": {
+      let state = str(p.state);
+      return state === "suspended" || state === "error" || state === "stopped" || state === "off" || state === "hibernate" ? { text: `State \u2192 ${state}`, level: state === "error" ? "warn" : "info" } : null;
+    }
+    case "loop.compacted":
+      return { text: `Compacted${p.reason ? ` (${String(p.reason)})` : ""}${typeof p.new_token_count == "number" ? ` \u2192 ${p.new_token_count} tokens` : ""}`, level: "info" };
+    case "loop.compaction_failed":
+      return { text: `Compaction failed${p.reason ? `: ${String(p.reason)}` : ""} \u2014 history kept`, level: "warn" };
+    case "loop.compaction_superseded":
+      return { text: "Compaction superseded by a newer one", level: "info" };
+    case "loop.cleared":
+      return { text: `Loop ${p.method === "replace" ? "rewritten" : "cleared"}`, level: "info" };
+    case "loop.recovered":
+      return { text: `Recovered: ${String(p.reason ?? "checkpoint")}`, level: "warn" };
+    case "suspend.requested":
+      return { text: `Suspended${p.reason ? `: ${String(p.reason)}` : ""} \u2014 resume or shut down`, level: "warn" };
+    case "suspend.resolved":
+      return { text: p.resumed ? "Resumed" : `Shut down${p.timed_out ? " (suspend timed out)" : ""}`, level: "info" };
+    case "provider.retry_scheduled":
+      return { text: `Provider error \u2014 retrying${typeof p.delay_ms == "number" ? ` in ${Math.round(p.delay_ms / 1e3)}s` : ""}`, level: "warn" };
+    case "provider.retry_cancelled":
+      return { text: "Provider retry cancelled", level: "info" };
+    case "llm.failed":
+      return { text: `Model call failed${p.model ? ` (${String(p.model)})` : ""}`, level: "warn" };
+    case "error.recovery_suppressed":
+      return { text: "Error recovery suppressed \u2014 triggers are being dropped", level: "warn" };
+    default:
+      return null;
+  }
+}
+function describeAgentError(p) {
+  let inner = p.event, detail = inner?.payload?.error ?? inner?.payload?.message;
+  return typeof detail == "string" && detail ? detail : "Agent error";
+}
+function summarizeEvent(event) {
+  let p = event.payload ?? {};
+  switch (event.event_type) {
+    case "tool.started":
+    case "tool.completed":
+    case "tool.failed":
+      return `${event.event_type.slice(5)} ${str(p.name) ?? ""}`.trim();
+    case "agent.state.changed":
+      return `state ${str(p.state) ?? "?"}`;
+    case "llm.completed":
+      return `${str(p.model) ?? "model"} in ${p.input_tokens ?? "?"} out ${p.output_tokens ?? "?"}`;
+    case "turn.completed":
+      return "turn completed";
+    case "hil.requested":
+      return `approval requested: ${str(p.tool) ?? ""}`;
+    case "ask.requested":
+      return `ask: ${(str(p.question) ?? "").slice(0, 60)}`;
+    case "message.received":
+      return `inbox from ${str(p.from) ?? "?"}`;
+    case "message.sent":
+      return "message sent";
+    case "timer.fired":
+      return `timer ${String(p.timer_id ?? "")} fired`;
+    case "trigger.fired":
+      return `trigger ${str(p.trigger_type) ?? ""}`;
+    case "config.changed":
+      return `config changed: ${Array.isArray(p.changed_keys) ? p.changed_keys.join(", ") : ""}`;
+    case "file.written":
+      return `wrote ${str(p.path) ?? ""}`;
+    case "file.deleted":
+      return `deleted ${str(p.path) ?? ""}`;
+    default:
+      return noticeFor(event)?.text ?? event.event_type;
+  }
+}
+
+// src/main/tui/state/types.ts
+function transcriptKey(agentId, loop) {
+  return `${agentId}\0${loop}`;
+}
+
+// src/main/tui/state/reducer.ts
+var MAX_ACTIVITY = 500, MAX_LAST_EVENTS = 5e3;
+function initialState(daemonUrl, activeView = "fleet") {
+  return {
+    daemonUrl,
+    connection: { state: "idle", attempt: 0 },
+    daemonReachable: null,
+    identity: null,
+    auth: null,
+    web: null,
+    tracked: null,
+    agents: {},
+    agentOrder: [],
+    selectedAgentId: null,
+    selectedLoop: {},
+    transcripts: {},
+    activeView,
+    // Launching into Chat starts in the composer.
+    focus: activeView === "chat" ? "input" : "main",
+    overlays: [],
+    toasts: [],
+    activity: [],
+    lastEvents: [],
+    viewState: {}
+  };
+}
+function newAgent(summary) {
+  return {
+    summary,
+    pendingTasks: [],
+    pendingAsks: [],
+    tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    unreadInbox: 0
+  };
+}
+function patchAgent(state, agentId, patch) {
+  let agent = state.agents[agentId];
+  if (!agent) return state;
+  let next = patch(agent);
+  return next === agent ? state : { ...state, agents: { ...state.agents, [agentId]: next } };
+}
+function patchTranscript(state, key, patch) {
+  let current = state.transcripts[key] ?? emptyTranscript(), next = patch(current);
+  return next === current ? state : { ...state, transcripts: { ...state.transcripts, [key]: next } };
+}
+var RUNNING_STATES = /* @__PURE__ */ new Set(["thinking", "tool_use", "awaiting_approval", "awaiting_ask"]);
+function isBusyState(state) {
+  return !!state && RUNNING_STATES.has(state);
+}
+function tuiReducer(state, action) {
+  switch (action.type) {
+    case "connection":
+      return { ...state, connection: action.info, daemonReachable: action.info.state === "open" ? !0 : state.daemonReachable };
+    case "daemon/switch":
+      return {
+        ...initialState(action.url, state.activeView),
+        focus: state.focus,
+        overlays: state.overlays,
+        toasts: state.toasts,
+        viewState: state.viewState
+      };
+    case "identity/set":
+      return { ...state, identity: action.identity };
+    case "auth/set":
+      return { ...state, auth: action.auth };
+    case "web/set":
+      return { ...state, web: action.web };
+    case "daemon/reachable":
+      return state.daemonReachable === action.reachable ? state : { ...state, daemonReachable: action.reachable };
+    case "agents/loaded": {
+      let agents = {};
+      for (let summary of action.agents) {
+        let existing = state.agents[summary.id];
+        agents[summary.id] = existing ? { ...existing, summary } : newAgent(summary);
+      }
+      let agentOrder = action.agents.map((agent) => agent.id), previous = Object.fromEntries(Object.entries(state.agents).map(([id, a]) => [id, a.summary])), tracked = state.tracked ? pruneLoaded(state.tracked, action.agents) : null, next = { ...state, agents, agentOrder, tracked };
+      return { ...next, selectedAgentId: reconcileSelection(next, previous) };
+    }
+    case "tracked/loaded": {
+      let summaries = state.agentOrder.map((id) => state.agents[id]?.summary).filter(Boolean), next = { ...state, tracked: buildTracked(action.list, summaries, state.tracked) };
+      return { ...next, selectedAgentId: reconcileSelection(next, {}, !0) };
+    }
+    case "tracked/error":
+      return state.tracked ? { ...state, tracked: { ...state.tracked, error: action.error } } : state;
+    case "tracked/file-error": {
+      let tracked = state.tracked;
+      if (!tracked) return state;
+      let errors = { ...tracked.errors };
+      return action.error === void 0 ? delete errors[action.filePath] : errors[action.filePath] = action.error, { ...state, tracked: { ...tracked, errors } };
+    }
+    case "tracked/busy": {
+      let tracked = state.tracked;
+      if (!tracked) return state;
+      let busy = { ...tracked.busy };
+      return action.busy === void 0 ? delete busy[action.filePath] : busy[action.filePath] = action.busy, { ...state, tracked: { ...tracked, busy } };
+    }
+    case "agent/status":
+      return patchAgent(state, action.agentId, (agent) => ({
+        ...agent,
+        status: action.status,
+        executorState: action.status.runtimeState,
+        error: void 0
+      }));
+    case "agent/config":
+      return patchAgent(state, action.agentId, (agent) => ({ ...agent, config: action.config }));
+    case "agent/error":
+      return patchAgent(state, action.agentId, (agent) => ({ ...agent, error: action.error }));
+    case "agent/removed": {
+      if (!state.agents[action.agentId]) return state;
+      let agents = { ...state.agents };
+      delete agents[action.agentId];
+      let agentOrder = state.agentOrder.filter((id) => id !== action.agentId);
+      return {
+        ...state,
+        agents,
+        agentOrder,
+        selectedAgentId: state.selectedAgentId === action.agentId ? agentOrder[0] ?? state.tracked?.stopped[0]?.key ?? null : state.selectedAgentId
+      };
+    }
+    case "loops/loaded": {
+      let next = patchAgent(state, action.agentId, (agent) => {
+        let previous = new Map((agent.loops ?? []).map((loop) => [loop.info.name, loop]));
+        return {
+          ...agent,
+          loopsError: void 0,
+          loops: action.loops.map((info) => ({ info, executorState: previous.get(info.name)?.executorState }))
+        };
+      }), selected = next.selectedLoop[action.agentId];
+      if (selected && !action.loops.some((loop) => loop.name === selected)) {
+        let selectedLoop = { ...next.selectedLoop };
+        return delete selectedLoop[action.agentId], { ...next, selectedLoop };
+      }
+      return next;
+    }
+    case "loops/error":
+      return patchAgent(state, action.agentId, (agent) => ({ ...agent, loopsError: action.error }));
+    case "hil/loaded":
+      return patchAgent(state, action.agentId, (agent) => ({
+        ...agent,
+        pendingTasks: action.tasks.filter((task) => task.status === "pending_approval"),
+        pendingAsks: action.asks
+      }));
+    case "select/agent":
+      return state.selectedAgentId === action.agentId ? state : { ...state, selectedAgentId: action.agentId };
+    case "select/loop": {
+      let selectedLoop = { ...state.selectedLoop };
+      return action.loop === MAIN_LOOP ? delete selectedLoop[action.agentId] : selectedLoop[action.agentId] = action.loop, { ...state, selectedLoop };
+    }
+    case "view/set":
+      return state.activeView === action.view ? state : { ...state, activeView: action.view };
+    case "focus/set":
+      return state.focus === action.focus ? state : { ...state, focus: action.focus };
+    case "overlay/push":
+      return { ...state, overlays: [...state.overlays.filter((o) => o.id !== action.overlay.id), action.overlay] };
+    case "overlay/pop": {
+      if (state.overlays.length === 0) return state;
+      let overlays = action.id ? state.overlays.filter((o) => o.id !== action.id) : state.overlays.slice(0, -1);
+      return { ...state, overlays };
+    }
+    case "toast/add":
+      return { ...state, toasts: [...state.toasts.slice(-4), action.toast] };
+    case "toast/dismiss":
+      return { ...state, toasts: state.toasts.filter((t) => t.id !== action.id) };
+    case "transcript/loading":
+      return patchTranscript(state, action.key, (t) => ({ ...t, loading: !0, error: void 0 }));
+    case "transcript/history":
+      return patchTranscript(state, action.key, (t) => {
+        let page = historyToItems(action.entries);
+        if (action.mode === "prepend")
+          return { ...t, loading: !1, loaded: !0, total: action.total, oldestOffset: action.offset, items: prependHistory(t.items, page) };
+        let firstSeq = action.entries[0]?.seq, older = firstSeq === void 0 ? [] : t.items.filter((item) => !item.local && item.seq !== void 0 && item.seq < firstSeq), oldestOffset = older.length > 0 ? Math.min(t.oldestOffset, action.offset) : action.offset;
+        return {
+          ...t,
+          loading: !1,
+          loaded: !0,
+          error: void 0,
+          total: action.total,
+          oldestOffset,
+          live: !1,
+          items: [...older, ...mergeHistory(t.items, page)]
+        };
+      });
+    case "transcript/error":
+      return patchTranscript(state, action.key, (t) => ({ ...t, loading: !1, error: action.error }));
+    case "transcript/append":
+      return patchTranscript(state, action.key, (t) => ({ ...t, items: [...t.items, action.item] }));
+    case "transcript/update":
+      return patchTranscript(state, action.key, (t) => {
+        let index = t.items.findIndex((item) => item.id === action.id);
+        if (index < 0) return t;
+        let items = t.items.slice();
+        return items[index] = { ...items[index], ...action.patch }, { ...t, items };
+      });
+    case "transcript/reset":
+      return patchTranscript(state, action.key, () => ({ ...emptyTranscript(), loaded: !0 }));
+    case "transcript/idle":
+      return patchTranscript(state, action.key, endLive);
+    case "event":
+      return applyEvent(state, action.frame.event);
+    case "events":
+      return action.frames.reduce((next, frame) => applyEvent(next, frame.event), state);
+    case "viewState/set":
+      return { ...state, viewState: { ...state.viewState, [action.view]: action.value } };
+    default:
+      return state;
+  }
+}
+function eventLoop(event) {
+  return typeof event.loop == "string" && event.loop ? event.loop : MAIN_LOOP;
+}
+var TRANSCRIPT_EVENTS = /* @__PURE__ */ new Set([
+  "turn.delta",
+  "tool.started",
+  "tool.completed",
+  "tool.failed",
+  "turn.completed",
+  "hil.requested",
+  "hil.resolved",
+  "ask.requested",
+  "ask.resolved",
+  "agent.error",
+  "agent.state.changed",
+  "loop.compacted",
+  "loop.compaction_failed",
+  "loop.compaction_superseded",
+  "loop.cleared",
+  "loop.recovered",
+  "suspend.requested",
+  "suspend.resolved",
+  "provider.retry_scheduled",
+  "provider.retry_cancelled",
+  "llm.failed",
+  "error.recovery_suppressed"
+]);
+function applyEvent(state, event) {
+  let agentId = event.agent_id ?? null, loop = eventLoop(event), next = {
+    ...state,
+    activity: pushBounded(state.activity, {
+      id: localId("a"),
+      at: event.timestamp || Date.now(),
+      agentId,
+      loop,
+      type: event.event_type,
+      summary: summarizeEvent(event)
+    }, MAX_ACTIVITY),
+    lastEvents: pushBounded(state.lastEvents, event, MAX_LAST_EVENTS)
+  };
+  if (!agentId || !next.agents[agentId]) return next;
+  let p = event.payload ?? {};
+  switch (event.event_type) {
+    case "agent.state.changed": {
+      let executorState = typeof p.state == "string" ? p.state : void 0;
+      loop === MAIN_LOOP ? next = patchAgent(next, agentId, (agent) => ({ ...agent, executorState })) : next = patchLoop(next, agentId, loop, (info) => ({
+        ...info,
+        executorState,
+        info: { ...info.info, status: isBusyState(executorState) ? "running" : "idle" }
+      }));
+      break;
+    }
+    case "turn.completed":
+      loop !== MAIN_LOOP && (next = patchLoop(next, agentId, loop, (l) => ({ ...l, info: { ...l.info, status: "idle" } })));
+      break;
+    case "llm.completed":
+      next = patchAgent(next, agentId, (agent) => ({
+        ...agent,
+        lastModel: typeof p.model == "string" ? p.model : agent.lastModel,
+        tokens: {
+          input: agent.tokens.input + num(p.input_tokens),
+          output: agent.tokens.output + num(p.output_tokens),
+          cacheRead: agent.tokens.cacheRead + num(p.cache_read_tokens),
+          cacheWrite: agent.tokens.cacheWrite + num(p.cache_write_tokens)
+        }
+      }));
+      break;
+    case "hil.requested": {
+      let taskId = typeof p.task_id == "string" ? p.task_id : void 0;
+      taskId && (next = patchAgent(next, agentId, (agent) => agent.pendingTasks.some((t) => t.id === taskId) ? agent : {
+        ...agent,
+        pendingTasks: [...agent.pendingTasks, {
+          id: taskId,
+          tool: typeof p.tool == "string" ? p.tool : "tool",
+          args: JSON.stringify(p.input ?? {}),
+          status: "pending_approval",
+          created_at: event.timestamp,
+          origin: loop === MAIN_LOOP ? void 0 : `loop:${loop}`,
+          // "Always approve" is offered only when the daemon says so (never for protection overrides).
+          ...typeof p.can_always_approve == "boolean" ? { canAlwaysApprove: p.can_always_approve } : {},
+          ...typeof p.always_approve_blocked_reason == "string" ? { alwaysApproveBlockedReason: p.always_approve_blocked_reason } : {}
+        }]
+      }));
+      break;
+    }
+    case "hil.resolved": {
+      let taskId = typeof p.task_id == "string" ? p.task_id : p.request_id;
+      next = patchAgent(next, agentId, (agent) => ({ ...agent, pendingTasks: agent.pendingTasks.filter((t) => t.id !== taskId) }));
+      break;
+    }
+    // Ask ids are per executor (main and an inner loop can both hold ask_1),
+    // so an ask is identified by (loop, requestId).
+    case "ask.requested": {
+      let requestId = typeof p.request_id == "string" ? p.request_id : void 0;
+      requestId && (next = patchAgent(next, agentId, (agent) => agent.pendingAsks.some((a) => sameAsk(a, loop, requestId)) ? agent : {
+        ...agent,
+        pendingAsks: [...agent.pendingAsks, { requestId, question: typeof p.question == "string" ? p.question : "", loop }]
+      }));
+      break;
+    }
+    case "ask.resolved":
+      next = patchAgent(next, agentId, (agent) => ({ ...agent, pendingAsks: agent.pendingAsks.filter((a) => !sameAsk(a, loop, p.request_id)) }));
+      break;
+    case "message.received":
+      next = patchAgent(next, agentId, (agent) => ({ ...agent, unreadInbox: agent.unreadInbox + 1 }));
+      break;
+  }
+  if (TRANSCRIPT_EVENTS.has(event.event_type)) {
+    let key = transcriptKey(agentId, loop);
+    next = patchTranscript(next, key, (t) => {
+      let items = applyEventToItems(t.items, event);
+      if (event.event_type === "agent.state.changed" && turnOver(p.state)) return endLive(items === t.items ? t : { ...t, items });
+      let live = event.event_type === "turn.completed" || event.event_type === "agent.error" ? !1 : event.event_type === "turn.delta" || event.event_type === "tool.started" ? !0 : t.live;
+      return items === t.items && live === t.live ? t : { ...t, items, live };
+    });
+  }
+  return next;
+}
+function turnOver(value) {
+  return typeof value == "string" && !RUNNING_STATES.has(value) && value !== "suspended";
+}
+function endLive(t) {
+  let items = finalizeStreaming(t.items);
+  return !t.live && items === t.items ? t : { ...t, live: !1, items };
+}
+function sameAsk(ask, loop, requestId) {
+  return ask.requestId === requestId && (ask.loop ?? MAIN_LOOP) === loop;
+}
+function patchLoop(state, agentId, loop, patch) {
+  return patchAgent(state, agentId, (agent) => {
+    if (!agent.loops) return agent;
+    let index = agent.loops.findIndex((l) => l.info.name === loop);
+    if (index < 0) return agent;
+    let loops = agent.loops.slice();
+    return loops[index] = patch(loops[index]), { ...agent, loops };
+  });
+}
+function pushBounded(list, item, max) {
+  let next = list.length >= max ? list.slice(list.length - max + 1) : list.slice();
+  return next.push(item), next;
+}
+function num(value) {
+  return typeof value == "number" && Number.isFinite(value) ? value : 0;
+}
+
+// src/main/tui/web/model.ts
+var isRecord = (v) => typeof v == "object" && v !== null && !Array.isArray(v);
+function parseServer(raw) {
+  if (!isRecord(raw) || typeof raw.running != "boolean") return null;
+  let port = typeof raw.port == "number" && Number.isFinite(raw.port) ? raw.port : 7295;
+  return { running: raw.running, port, host: typeof raw.host == "string" && raw.host ? raw.host : "127.0.0.1" };
+}
+function parseMeshAgents(raw) {
+  let out = {};
+  if (!Array.isArray(raw)) return out;
+  for (let a of raw)
+    !isRecord(a) || typeof a.agentId != "string" || (out[a.agentId] = {
+      handle: typeof a.handle == "string" ? a.handle : void 0,
+      publicEnabled: a.publicEnabled === !0,
+      apiRoutes: typeof a.apiRouteCount == "number" ? a.apiRouteCount : 0,
+      sharedCount: typeof a.sharedCount == "number" ? a.sharedCount : 0,
+      ...typeof a.status == "string" && a.status.trim() ? { status: a.status.trim() } : {}
+    });
+  return out;
+}
+function parseLan(raw) {
+  let outer = isRecord(raw) ? raw.addresses : void 0;
+  return (Array.isArray(outer) ? outer : isRecord(outer) && Array.isArray(outer.addresses) ? outer.addresses : []).filter((a) => isRecord(a) && typeof a.address == "string" && a.family !== "IPv6" && !String(a.address).includes(":")).map((a) => String(a.address));
+}
+function bindsAll(host) {
+  return host === "0.0.0.0" || host === "::" || host === "";
+}
+function isLoopback(host) {
+  return host === "127.0.0.1" || host === "localhost" || host === "::1" || host.startsWith("127.");
+}
+function linkHost(serverHost, daemonUrl) {
+  let host = serverHost;
+  if (bindsAll(serverHost)) {
+    let daemonHost = "127.0.0.1";
+    try {
+      daemonHost = new URL(daemonUrl).hostname.replace(/^\[|\]$/g, "");
+    } catch {
+    }
+    host = isLoopback(daemonHost) ? "127.0.0.1" : daemonHost;
+  }
+  return host.includes(":") ? `[${host}]` : host;
+}
+function siteUrl(host, port, handle) {
+  return `http://${host}:${port}/agents/${encodeURIComponent(handle)}/`;
+}
+function siteOf(state, agentId) {
+  if (!agentId) return null;
+  let agent = state.agents[agentId];
+  if (!agent) return null;
+  let serving = agent.config?.serving, mesh = state.web?.agents[agentId], api = Array.isArray(serving?.api) ? serving.api : [], publicEnabled = mesh ? mesh.publicEnabled : serving?.public?.enabled === !0, apiRoutes = mesh ? mesh.apiRoutes : api.length, sharedCount = mesh ? mesh.sharedCount : serving?.shared?.enabled ? serving.shared.patterns?.length ?? 0 : 0;
+  if (!publicEnabled && apiRoutes === 0 && sharedCount === 0) return null;
+  let handle = agent.summary.handle || mesh?.handle || agent.config?.handle || agent.summary.name || agentId, server = state.web?.server ?? null, url = server?.running ? siteUrl(linkHost(server.host, state.daemonUrl), server.port, handle) : null, lanUrls = server?.running && bindsAll(server.host) ? (state.web?.lan ?? []).map((ip) => siteUrl(ip, server.port, handle)) : [];
+  return {
+    agentId,
+    handle,
+    publicEnabled,
+    index: serving?.public?.index || "index.html",
+    apiRoutes,
+    wsRoutes: api.filter((r) => r.method === "WS").length,
+    sharedCount,
+    server,
+    url,
+    lanUrls
+  };
+}
+function servedText(site) {
+  let parts = [];
+  return site.publicEnabled && parts.push(`public/ (${site.index})`), site.apiRoutes > 0 && parts.push(`${site.apiRoutes} API route${site.apiRoutes === 1 ? "" : "s"}${site.wsRoutes > 0 ? ` incl. ${site.wsRoutes} WS` : ""}`), site.sharedCount > 0 && parts.push(`${site.sharedCount} shared pattern${site.sharedCount === 1 ? "" : "s"}`), parts.join(" \xB7 ");
+}
+function siteKind(site) {
+  return site.publicEnabled ? "site" : site.apiRoutes > 0 ? "api" : "files";
+}
+function shortUrl(url) {
+  return url.replace(/^https?:\/\//, "");
+}
+var SERVER_STOPPED_TEXT = "web server stopped \u2014 start it";
+function serverBadge(server) {
+  return server ? server.running ? { text: `web :${server.port}`, running: !0 } : { text: "web off", running: !1 } : null;
+}
+function serverText(server) {
+  return server ? server.running ? bindsAll(server.host) ? `running on all interfaces, port ${server.port} (LAN too)` : `running on ${server.host}:${server.port}${isLoopback(server.host) ? " (this machine only)" : ""}` : "stopped" : "unknown (the daemon does not report it)";
+}
+
+// src/main/tui/state/store.tsx
+var import_jsx_runtime = __toESM(require_jsx_runtime(), 1), REFRESH_DEBOUNCE_MS = 120, WEB_EVENT_DEBOUNCE_MS = 900, WEB_POLL_MS = 2e4, TRACKED_POLL_MS = 15e3, FOLDER_OVERLAY = "fleet.track", PROMPT_PREFILL_KEY = "shell.prompt.prefill", CHAT_VIEW_ID = "chat";
+function createTuiStore(options) {
+  let client = options.client, pageSize = options.pageSize ?? 100, state = initialState(client.baseUrl, options.initialView), listeners = /* @__PURE__ */ new Set(), confirmResolvers = /* @__PURE__ */ new Map(), toastTimers = /* @__PURE__ */ new Map(), debounced = /* @__PURE__ */ new Map(), stream = null, webTick = null, trackedTick = null, stopped = !1, needsResync = !1, getState = () => state, dispatch = (action) => {
+    let next = tuiReducer(state, action);
+    if (next !== state) {
+      state = next;
+      for (let listener of listeners) listener();
+    }
+  }, subscribe = (listener) => (listeners.add(listener), () => {
+    listeners.delete(listener);
+  }), debounce = (key, fn, ms = REFRESH_DEBOUNCE_MS) => {
+    let existing = debounced.get(key);
+    existing && clearTimeout(existing), debounced.set(key, setTimeout(() => {
+      debounced.delete(key), stopped || fn();
+    }, ms));
+  }, describe = (err) => err instanceof Error ? err.message : String(err), toast = (text, level = "info", ttlMs = level === "error" ? 8e3 : 4e3) => {
+    let id = localId("t");
+    dispatch({ type: "toast/add", toast: { id, level, text, at: Date.now(), ttlMs } }), ttlMs > 0 && toastTimers.set(id, setTimeout(() => {
+      toastTimers.delete(id), dispatch({ type: "toast/dismiss", id });
+    }, ttlMs));
+  }, run = async (label, fn) => {
+    try {
+      return await fn(client);
+    } catch (err) {
+      err instanceof DaemonError && err.unreachable && dispatch({ type: "daemon/reachable", reachable: !1 }), toast(`${label}: ${describe(err)}`, "error");
+      return;
+    }
+  }, selectedLoopOf = (agentId) => state.selectedLoop[agentId] ?? MAIN_LOOP, stale = (c) => c !== client, actions = {
+    async setDaemonUrl(url, token) {
+      let next = client.withBaseUrl(url, token);
+      if (next.baseUrl === client.baseUrl && token === void 0)
+        return toast(`Already connected to ${next.baseUrl}`, "info"), !0;
+      client.hasToken && !next.hasToken && toast(`Not sending this daemon's token to ${next.baseUrl}; use /url <url> --token <token> if it needs one`, "warn", 6e3), toast(`Checking ${next.baseUrl}\u2026`, "info", 2e3);
+      try {
+        await next.health();
+      } catch (err) {
+        return toast(`Not switching: ${next.baseUrl} is not answering (${describe(err)}). Still on ${client.baseUrl}.`, "error"), !1;
+      }
+      let previous = client.baseUrl;
+      stream?.close(), stream = null;
+      for (let timer of debounced.values()) clearTimeout(timer);
+      return debounced.clear(), client = next, dispatch({ type: "daemon/switch", url: next.baseUrl }), toast(`Switched from ${previous} to ${next.baseUrl} \u2014 agents on the old daemon keep running`, "success", 6e3), await start(), !0;
+    },
+    async refreshAgents() {
+      let c = client;
+      try {
+        let agents = await c.agents();
+        if (stale(c)) return;
+        dispatch({ type: "daemon/reachable", reachable: !0 }), dispatch({ type: "agents/loaded", agents }), await Promise.all(agents.map((agent) => actions.refreshAgent(agent.id)));
+        let selected = state.selectedAgentId;
+        selected && !isTrackedKey(selected) && await actions.ensureTranscript(selected, selectedLoopOf(selected));
+      } catch (err) {
+        if (stale(c)) return;
+        dispatch({ type: "daemon/reachable", reachable: !(err instanceof DaemonError && err.unreachable) }), toast(`Agents: ${describe(err)}`, "error");
+      }
+    },
+    async refreshAgent(agentId) {
+      let c = client;
+      await Promise.all([
+        c.status(agentId).then((status) => {
+          stale(c) || dispatch({ type: "agent/status", agentId, status });
+        }).catch((err) => {
+          stale(c) || dispatch({ type: "agent/error", agentId, error: describe(err) });
+        }),
+        actions.refreshLoops(agentId),
+        actions.refreshHil(agentId),
+        c.config(agentId).then((result) => {
+          stale(c) || dispatch({ type: "agent/config", agentId, config: result.config });
+        }).catch(() => {
+        })
+      ]);
+    },
+    async refreshLoops(agentId) {
+      let c = client;
+      try {
+        let result = await c.loops(agentId);
+        stale(c) || dispatch({ type: "loops/loaded", agentId, loops: result.loops });
+      } catch (err) {
+        stale(c) || dispatch({ type: "loops/error", agentId, error: describe(err) });
+      }
+    },
+    async refreshHil(agentId) {
+      let c = client;
+      try {
+        let [tasks, asks] = await Promise.all([
+          c.tasks(agentId, { status: "pending_approval" }),
+          c.asks(agentId)
+        ]);
+        if (stale(c)) return;
+        dispatch({ type: "hil/loaded", agentId, tasks: tasks.tasks, asks: asks.asks });
+      } catch {
+      }
+    },
+    async loadConfig(agentId) {
+      let c = client, result = await run("Config", (cl) => cl.config(agentId));
+      if (!stale(c))
+        return result && dispatch({ type: "agent/config", agentId, config: result.config }), result?.config;
+    },
+    async startAgent(agentId) {
+      let result = await run("Start", (c) => c.start(agentId));
+      result && toast(`Started ${agentLabel(agentId)}${result.startupTriggered ? " (startup turn running)" : ""}`, "success"), await actions.refreshAgent(agentId);
+    },
+    async stopAgent(agentId) {
+      await run("Stop", (c) => c.stop(agentId)) && toast(`Stopped ${agentLabel(agentId)}`, "success"), await actions.refreshAgents();
+    },
+    async interrupt(agentId, loop) {
+      let id = agentId ?? state.selectedAgentId;
+      if (!id) return;
+      let target = loop ?? selectedLoopOf(id), result = await run("Interrupt", (c) => c.interrupt(id, target));
+      if (!result) return;
+      let key = transcriptKey(id, target);
+      dispatch({ type: "transcript/idle", key }), result.interrupted === !1 ? toast(`Nothing running in ${target}`, "info", 2500) : dispatch({ type: "transcript/append", key, item: { id: localId(), at: Date.now(), local: !0, kind: "notice", level: "warn", text: "Turn interrupted by you \u2014 loop is idle" } }), debounce(`loops:${id}`, () => {
+        actions.refreshLoops(id);
+      });
+    },
+    async abort(agentId, loop) {
+      let id = agentId ?? state.selectedAgentId;
+      if (!id) return;
+      let target = loop ?? selectedLoopOf(id);
+      if (await run("Abort", (c) => c.abort(id, target))) {
+        let key = transcriptKey(id, target);
+        dispatch({ type: "transcript/idle", key }), dispatch({ type: "transcript/append", key, item: { id: localId(), at: Date.now(), local: !0, kind: "notice", level: "warn", text: "Turn aborted by you \u2014 loop stopped until the agent is reloaded" } });
+      }
+    },
+    async setDisplayState(agentId, displayState) {
+      await run("State", (c) => c.setState(agentId, displayState)) && toast(`${agentLabel(agentId)} \u2192 ${displayState}`, "success"), await actions.refreshAgent(agentId);
+    },
+    async loadAgentFile(filePath) {
+      let ref = await run("Load", (c) => c.load(filePath));
+      ref && (toast(`Loaded ${ref.config?.name ?? filePath}`, "success"), await actions.refreshAgents(), actions.selectAgent(ref.id));
+    },
+    async refreshTracked() {
+      let c = client;
+      try {
+        let list = await c.trackedAgents();
+        stale(c) || dispatch({ type: "tracked/loaded", list });
+      } catch (err) {
+        if (stale(c)) return;
+        if (err instanceof DaemonError && (err.status === 404 || err.status === 503)) {
+          state.tracked || dispatch({ type: "tracked/loaded", list: { maxDepth: 0, folders: [] } });
+          return;
+        }
+        dispatch({ type: "tracked/error", error: describe(err) });
+      }
+    },
+    async startTracked(key, options2 = {}) {
+      let entry = findTracked(state, key);
+      if (!entry) {
+        let loadedId = isTrackedKey(key) ? loadedIdForPath(state, trackedPath(key)) : key;
+        return loadedId && state.agents[loadedId] ? loadedId : (toast("That agent is no longer in a tracked folder (r refreshes)", "warn"), null);
+      }
+      let { agent, folder } = entry, filePath = agent.filePath;
+      if (state.tracked?.busy[filePath]) return null;
+      if (agent.status === "unreadable")
+        return toast(`${agent.name}: ${agent.error ?? "not a readable .adf"}`, "error", 6e3), null;
+      if (agent.status === "password_protected")
+        return toast(`${agent.name}: its identity is password-protected. Load it with /load ${filePath} and unlock it`, "warn", 8e3), null;
+      let review = () => (toast(`${agent.name} has not been reviewed on this daemon: review it first`, "warn", 5e3), actions.pushOverlay({ kind: FOLDER_OVERLAY, props: { folder, review: filePath } }), null);
+      if (agent.status === "needs_review") return review();
+      let start2 = options2.start ?? !0, c = client;
+      dispatch({ type: "tracked/busy", filePath, busy: "loading" }), dispatch({ type: "tracked/file-error", filePath, error: void 0 });
+      let ref;
+      try {
+        ref = await c.load(filePath, !0);
+      } catch (err) {
+        if (dispatch({ type: "tracked/busy", filePath, busy: void 0 }), err instanceof DaemonError && err.unreachable && dispatch({ type: "daemon/reachable", reachable: !1 }), err instanceof DaemonError && err.status === 403) return review();
+        let error = describe(err);
+        return dispatch({ type: "tracked/file-error", filePath, error }), toast(`Load ${agent.name}: ${error}`, "error", 8e3), null;
+      }
+      let name = ref.config?.handle || ref.config?.name || agent.name, started = "", level = "success";
+      if (start2 || agent.autostart) {
+        dispatch({ type: "tracked/busy", filePath, busy: "starting" });
+        try {
+          started = ` and started it${(await c.start(ref.id)).startupTriggered ? " (startup turn running)" : ""}`;
+        } catch (err) {
+          started = ` (start failed: ${describe(err)})`, level = "warn";
+        }
+      }
+      if (dispatch({ type: "tracked/busy", filePath, busy: void 0 }), stale(c)) return null;
+      let text = `Loaded ${name}${started}`;
+      toast(text, level, 5e3);
+      let wasSelected = state.selectedAgentId === key || state.selectedAgentId === entry.key;
+      return await actions.refreshAgents(), actions.refreshTracked(), (wasSelected || !state.selectedAgentId || isTrackedKey(state.selectedAgentId)) && state.agents[ref.id] && actions.selectAgent(ref.id), actions.notice(ref.id, MAIN_LOOP, text, level === "success" ? "info" : "warn"), ref.id;
+    },
+    selectAgent(agentId) {
+      dispatch({ type: "select/agent", agentId }), !isTrackedKey(agentId) && agentId && (actions.ensureTranscript(agentId, selectedLoopOf(agentId)), state.agents[agentId]?.config || actions.loadConfig(agentId));
+    },
+    selectLoop(agentId, loop) {
+      dispatch({ type: "select/loop", agentId, loop }), actions.ensureTranscript(agentId, loop);
+    },
+    setView(view) {
+      let changed = state.activeView !== view;
+      dispatch({ type: "view/set", view }), changed && dispatch({ type: "focus/set", focus: view === CHAT_VIEW_ID ? "input" : "main" });
+    },
+    setFocus(focus) {
+      dispatch({ type: "focus/set", focus });
+    },
+    pushOverlay(overlay) {
+      let id = overlay.id ?? localId("o");
+      return dispatch({ type: "overlay/push", overlay: { ...overlay, id } }), id;
+    },
+    popOverlay(id) {
+      dispatch({ type: "overlay/pop", id });
+    },
+    confirm(confirmOptions) {
+      return new Promise((resolve) => {
+        let id = localId("confirm");
+        confirmResolvers.set(id, resolve), dispatch({ type: "overlay/push", overlay: { id, kind: "confirm", props: { ...confirmOptions } } });
+      });
+    },
+    toast,
+    dismissToast(id) {
+      let timer = toastTimers.get(id);
+      timer && clearTimeout(timer), toastTimers.delete(id), dispatch({ type: "toast/dismiss", id });
+    },
+    setViewState(view, value) {
+      dispatch({ type: "viewState/set", view, value });
+    },
+    prefillPrompt(text) {
+      dispatch({ type: "viewState/set", view: PROMPT_PREFILL_KEY, value: { text, nonce: localId("p") } }), dispatch({ type: "focus/set", focus: "input" });
+    },
+    notice(agentId, loop, text, level = "info") {
+      dispatch({ type: "transcript/append", key: transcriptKey(agentId, loop), item: { id: localId("n"), at: Date.now(), local: !0, kind: "notice", level, text } });
+    },
+    async ensureTranscript(agentId, loop) {
+      if (isTrackedKey(agentId)) return;
+      let t = state.transcripts[transcriptKey(agentId, loop)];
+      t?.loaded || t?.loading || await actions.loadTranscript(agentId, loop);
+    },
+    async loadTranscript(agentId, loop) {
+      let key = transcriptKey(agentId, loop), c = client;
+      dispatch({ type: "transcript/loading", key });
+      try {
+        let page = await c.loopHistory(agentId, { loop, limit: pageSize });
+        stale(c) || dispatch({ type: "transcript/history", key, entries: page.entries, total: page.total, offset: page.offset, mode: "replace" });
+      } catch (err) {
+        stale(c) || dispatch({ type: "transcript/error", key, error: describe(err) });
+      }
+    },
+    async loadOlder(agentId, loop) {
+      let key = transcriptKey(agentId, loop), t = state.transcripts[key];
+      if (!t || t.loading || t.oldestOffset <= 0) return;
+      let offset = Math.max(0, t.oldestOffset - pageSize), limit = t.oldestOffset - offset, c = client;
+      dispatch({ type: "transcript/loading", key });
+      try {
+        let page = await c.loopHistory(agentId, { loop, limit, offset });
+        stale(c) || dispatch({ type: "transcript/history", key, entries: page.entries, total: page.total, offset: page.offset, mode: "prepend" });
+      } catch (err) {
+        stale(c) || dispatch({ type: "transcript/error", key, error: describe(err) });
+      }
+    },
+    async sendChat(text, target = {}) {
+      let agentId = target.agentId ?? state.selectedAgentId, trimmed = text.trim();
+      if (!agentId || !trimmed) return !1;
+      if (isTrackedKey(agentId)) {
+        let name = findTracked(state, agentId)?.agent.name ?? "the agent";
+        toast(`${name} is stopped: starting it to deliver your message`, "info", 3e3);
+        let started = await actions.startTracked(agentId);
+        if (!started)
+          return toast(`Not sent: ${name} did not start (Ctrl+Up recalls your message)`, "warn", 6e3), !1;
+        agentId = started;
+      }
+      let loop = target.loop ?? selectedLoopOf(agentId), key = transcriptKey(agentId, loop), item = { id: localId(), at: Date.now(), local: !0, kind: "user", text: trimmed, origin: "owner", pending: !0 };
+      dispatch({ type: "transcript/append", key, item });
+      try {
+        return await client.chat(agentId, trimmed, loop), dispatch({ type: "transcript/update", key, id: item.id, patch: { accepted: !0 } }), !0;
+      } catch (err) {
+        return dispatch({ type: "transcript/update", key, id: item.id, patch: { pending: !1 } }), dispatch({ type: "transcript/append", key, item: { id: localId(), at: Date.now(), local: !0, kind: "error", text: `Not sent: ${describe(err)}` } }), !1;
+      }
+    },
+    async clearLoopHistory(agentId, loop) {
+      await run("Clear", (c) => c.clearChat(agentId, loop)) && (dispatch({ type: "transcript/reset", key: transcriptKey(agentId, loop) }), toast(`Cleared ${loop} history`, "success"), await actions.refreshLoops(agentId));
+    },
+    async compactLoop(agentId, loop) {
+      return await run(`Compact ${loop}`, (c) => c.compact(agentId, loop)) ? (toast(`Compacted ${loop} of ${agentLabel(agentId)}`, "success"), actions.notice(agentId, loop, "History compacted by you"), !0) : !1;
+    },
+    async createLoop(agentId, input) {
+      let result = await run("Create loop", (c) => c.createLoop(agentId, input));
+      if (result) {
+        let excluded = result.excludedTools.length ? ` (not granted yet: ${result.excludedTools.join(", ")})` : "";
+        toast(`Loop ${input.name} created${result.kickoff?.woke ? ", running first turn" : ""}${excluded}`, "success"), await actions.refreshLoops(agentId);
+      }
+      return result;
+    },
+    async updateLoop(agentId, name, patch) {
+      let result = await run("Update loop", (c) => c.updateLoop(agentId, name, patch));
+      return result && (toast(`Loop ${name} updated: ${result.updated.join(", ")}`, "success"), await actions.refreshLoops(agentId)), result;
+    },
+    async setLoopEnabled(agentId, name, enabled) {
+      await run(enabled ? "Enable loop" : "Disable loop", (c) => c.setLoopEnabled(agentId, name, enabled)) && (toast(`Loop ${name} ${enabled ? "enabled" : "disabled"}`, "success"), await actions.refreshLoops(agentId));
+    },
+    async deleteLoop(agentId, name) {
+      let result = await run("Delete loop", (c) => c.deleteLoop(agentId, name));
+      return result && (toast(`Loop ${name} deleted \u2014 ${result.archivedEntries} entries archived${result.interruptedTurn ? ", running turn stopped" : ""}`, "success"), dispatch({ type: "transcript/reset", key: transcriptKey(agentId, name) }), selectedLoopOf(agentId) === name && dispatch({ type: "select/loop", agentId, loop: MAIN_LOOP }), await actions.refreshLoops(agentId)), result;
+    },
+    async scheduleLoop(agentId, input) {
+      let result = await run("Schedule", (c) => c.createTimer(agentId, input));
+      return result && toast(`Timer ${result.id} scheduled for ${input.loop ?? MAIN_LOOP}`, "success"), result?.id;
+    },
+    async resolveTask(agentId, taskId, action, reason) {
+      await run(action === "approve" ? "Approve" : "Deny", (c) => c.resolveTask(agentId, taskId, { action, ...reason ? { reason } : {} })) && toast(`${action === "approve" ? "Approved" : action === "deny" ? reason ? "Rejected with feedback" : "Rejected" : "Updated"} ${taskId}`, "success"), await actions.refreshHil(agentId);
+    },
+    async alwaysApproveTask(agentId, taskId) {
+      let result = await run("Always approve", (c) => c.alwaysApproveTask(agentId, taskId));
+      return result && toast(`Always approving ${result.tool}: it will not ask again (Inspect \u203A Config \u203A tools to undo)`, "success", 5e3), await actions.refreshHil(agentId), !!result;
+    },
+    async approveAllTasks(agentId, loop) {
+      let result = await run("Approve all", (c) => c.approveAllTasks(agentId, loop));
+      if (result) {
+        let skipped = result.skippedProtection ? ` \xB7 ${result.skippedProtection} protection override${result.skippedProtection === 1 ? "" : "s"} still need${result.skippedProtection === 1 ? "s" : ""} you one by one` : "";
+        toast(`Approved ${result.approved} call${result.approved === 1 ? "" : "s"}${skipped}`, result.skippedProtection ? "warn" : "success", 5e3);
+      }
+      await actions.refreshHil(agentId);
+    },
+    async answerAsk(agentId, requestId, answer, loop) {
+      let result = await run("Answer", (c) => c.answerAsk(agentId, requestId, answer, loop));
+      result && toast(result.answered ? "Answer sent" : "Ask was no longer pending", result.answered ? "success" : "warn"), await actions.refreshHil(agentId);
+    },
+    async respondSuspend(agentId, resume) {
+      await run("Suspend", (c) => c.respondSuspend(agentId, resume)) && toast(resume ? "Resumed" : "Shutting down", "success"), await actions.refreshAgent(agentId);
+    },
+    async refreshAuth() {
+      let c = client;
+      try {
+        let auth = await c.authStatus();
+        stale(c) || dispatch({ type: "auth/set", auth });
+      } catch {
+      }
+    },
+    async logoutSubscription(provider) {
+      let label = provider === "chatgpt" ? "ChatGPT" : "Grok", result = await run(`Sign out of ${label}`, (c) => c.logoutSubscription(provider));
+      return result && toast(`Signed the daemon out of ${label}`, "success"), await actions.refreshAuth(), !!result;
+    },
+    async refreshWeb() {
+      let c = client, server = null, agents = {}, error;
+      try {
+        let mesh = await c.meshStatus();
+        server = parseServer(mesh.meshServer), agents = parseMeshAgents(mesh.agents);
+      } catch (err) {
+        if (stale(c) || err instanceof DaemonError && err.unreachable) return state.web;
+        error = describe(err);
+      }
+      if (!server)
+        try {
+          server = parseServer(await c.meshServer());
+        } catch (err) {
+          if (stale(c) || err instanceof DaemonError && err.unreachable) return state.web;
+          error ??= describe(err);
+        }
+      let lan = [];
+      if (server?.running && bindsAll(server.host) && (lan = parseLan(await c.lanAddresses().catch(() => null))), stale(c)) return state.web;
+      let web = { server, lan, agents, ...server ? {} : { error }, at: Date.now() };
+      return dispatch({ type: "web/set", web }), web;
+    },
+    async setWebServer(on) {
+      let result = await run(on ? "Start web server" : "Stop web server", (c) => c.meshServerAction(on ? "start" : "stop")), web = await actions.refreshWeb();
+      if (!result) return !1;
+      let server = web?.server ?? parseServer(result), ok = !!server && server.running === on;
+      return on ? toast(ok ? `Web server ${serverText(server)} \u2014 agent sites are up` : `Web server did not start${typeof result.error == "string" ? `: ${result.error}` : ""}`, ok ? "success" : "error") : toast(ok ? "Web server stopped \u2014 agent sites, APIs and mesh delivery are offline" : "Web server is still running", ok ? "success" : "warn"), ok;
+    },
+    async refreshIdentity() {
+      let c = client;
+      try {
+        let identity = await c.identity();
+        return stale(c) ? state.identity : (dispatch({ type: "identity/set", identity }), identity);
+      } catch (err) {
+        return stale(c) || err instanceof DaemonError && err.unreachable ? state.identity : (dispatch({ type: "identity/set", identity: null }), null);
+      }
+    },
+    async createIdentity(passphrase) {
+      let result = await attempt((c) => c.createIdentity(passphrase));
+      return result.ok && (dispatch({ type: "identity/set", identity: result.value.identity }), toast("Owner identity created", "success")), result;
+    },
+    async restoreIdentity(mnemonic, passphrase) {
+      let result = await attempt((c) => c.restoreIdentity(mnemonic, passphrase));
+      return result.ok ? (dispatch({ type: "identity/set", identity: result.value.identity }), toast("Owner identity restored", "success"), { ok: !0, value: result.value.identity }) : result;
+    },
+    async unlockIdentity(passphrase) {
+      let result = await attempt((c) => c.unlockIdentity(passphrase));
+      return result.ok ? (dispatch({ type: "identity/set", identity: result.value.identity }), toast("Owner identity unlocked", "success"), { ok: !0, value: result.value.identity }) : result;
+    },
+    async lockIdentity() {
+      let result = await attempt((c) => c.lockIdentity());
+      return result.ok ? (dispatch({ type: "identity/set", identity: result.value.identity }), toast("Owner identity locked", "success"), { ok: !0, value: result.value.identity }) : (toast(`Lock: ${result.error}`, "error"), result);
+    },
+    async confirmIdentityBackup() {
+      let result = await attempt((c) => c.confirmIdentityBackup());
+      return result.ok ? (dispatch({ type: "identity/set", identity: result.value.identity }), toast("Seed phrase backup confirmed", "success"), { ok: !0, value: result.value.identity }) : (toast(`Backup: ${result.error}`, "error"), result);
+    },
+    async listTemplates() {
+      return attempt((c) => c.templates());
+    },
+    async createAgent(input) {
+      let result = await attempt((c) => c.createAgent(input));
+      if (!result.ok) return result;
+      let created = result.value;
+      return toast(`Created ${created.name}${created.started ? " and started it" : ""}`, "success"), await actions.refreshAgents(), state.agents[created.agentId] && actions.selectAgent(created.agentId), result;
+    },
+    run
+  };
+  async function attempt(fn) {
+    try {
+      return { ok: !0, value: await fn(client) };
+    } catch (err) {
+      if (err instanceof DaemonError) {
+        err.unreachable && dispatch({ type: "daemon/reachable", reachable: !1 });
+        let body = err.body;
+        return body && typeof body == "object" && body.identity && typeof body.identity == "object" && dispatch({ type: "identity/set", identity: body.identity }), { ok: !1, error: err.message, code: body && typeof body.code == "string" ? body.code : void 0, status: err.status, body: err.body };
+      }
+      return { ok: !1, error: describe(err), status: null };
+    }
+  }
+  function agentLabel(agentId) {
+    let agent = state.agents[agentId];
+    return agent?.summary.handle ?? agent?.summary.name ?? agentId;
+  }
+  let pendingFrames = [], flushScheduled = !1, flushFrames = () => {
+    flushScheduled = !1;
+    let frames = pendingFrames;
+    pendingFrames = [], frames.length === 1 ? dispatch({ type: "event", frame: frames[0] }) : frames.length > 1 && dispatch({ type: "events", frames });
+  };
+  function onFrame(frame) {
+    pendingFrames.push(frame), flushScheduled || (flushScheduled = !0, setImmediate(flushFrames));
+    let { event } = frame, agentId = event.agent_id;
+    switch (event.event_type) {
+      case "agent.loaded":
+      case "agent.unloaded":
+        debounce("agents", () => {
+          actions.refreshAgents().then(() => actions.refreshTracked());
+        }, 250), debounce("web", () => {
+          actions.refreshWeb();
+        }, WEB_EVENT_DEBOUNCE_MS);
+        return;
+    }
+    if (event.event_type.startsWith("mesh.") && debounce("web", () => {
+      actions.refreshWeb();
+    }, WEB_EVENT_DEBOUNCE_MS), !agentId || !state.agents[agentId]) return;
+    let loop = eventLoop(event), key = transcriptKey(agentId, loop);
+    switch (event.event_type) {
+      case "turn.completed":
+      case "loop.cleared":
+      case "loop.compacted":
+        state.transcripts[key]?.loaded && debounce(`t:${key}`, () => {
+          actions.loadTranscript(agentId, loop);
+        }), debounce(`loops:${agentId}`, () => {
+          actions.refreshLoops(agentId);
+        }), debounce(`status:${agentId}`, () => {
+          let c = client;
+          c.status(agentId).then((status) => {
+            stale(c) || dispatch({ type: "agent/status", agentId, status });
+          }).catch(() => {
+          });
+        });
+        break;
+      case "config.changed": {
+        let keys = Array.isArray(event.payload?.changed_keys) ? event.payload.changed_keys : [];
+        (keys.length === 0 || keys.includes("loops")) && debounce(`loops:${agentId}`, () => {
+          actions.refreshLoops(agentId);
+        }), state.agents[agentId]?.config && debounce(`config:${agentId}`, () => {
+          actions.loadConfig(agentId);
+        }), (keys.length === 0 || keys.includes("serving") || keys.includes("messaging")) && debounce("web", () => {
+          actions.refreshWeb();
+        }, WEB_EVENT_DEBOUNCE_MS);
+        break;
+      }
+      case "tool.completed":
+        typeof event.payload?.name == "string" && /^sys_(set|delete)_meta$/.test(event.payload.name) && debounce("web", () => {
+          actions.refreshWeb();
+        }, 300);
+        break;
+      case "llm.failed":
+      case "agent.error":
+        debounce("auth", () => {
+          actions.refreshAuth();
+        }, 500);
+        break;
+      case "hil.requested":
+      case "hil.resolved":
+      case "ask.requested":
+      case "ask.resolved":
+        debounce(`hil:${agentId}`, () => {
+          actions.refreshHil(agentId);
+        }, 300);
+        break;
+    }
+  }
+  async function start() {
+    stopped = !1;
+    try {
+      await client.health(), dispatch({ type: "daemon/reachable", reachable: !0 });
+    } catch {
+      dispatch({ type: "daemon/reachable", reachable: !1 });
+    }
+    options.live !== !1 && (stream = client.events({
+      onEvent: onFrame,
+      onState: (info) => {
+        dispatch({ type: "connection", info }), info.state === "reconnecting" && (needsResync = !0, info.error && dispatch({ type: "daemon/reachable", reachable: !1 })), info.state === "open" && (info.resumed || needsResync) && (needsResync = !1, toast(info.resumed ? "Reconnected to daemon \u2014 resyncing" : "Connected to daemon", "info", 2500), resync());
+      }
+    }).start(), webTick && clearInterval(webTick), webTick = setInterval(() => {
+      stopped || actions.refreshWeb();
+    }, WEB_POLL_MS), trackedTick && clearInterval(trackedTick), trackedTick = setInterval(() => {
+      !stopped && state.daemonReachable !== !1 && actions.refreshTracked();
+    }, TRACKED_POLL_MS)), await Promise.all([actions.refreshIdentity(), actions.refreshAuth(), actions.refreshAgents(), actions.refreshWeb()]), await actions.refreshTracked();
+  }
+  async function resync() {
+    await Promise.all([actions.refreshIdentity(), actions.refreshAuth(), actions.refreshAgents(), actions.refreshWeb()]), actions.refreshTracked();
+    for (let key of Object.keys(state.transcripts)) {
+      let at = key.indexOf("\0"), agentId = key.slice(0, at);
+      state.agents[agentId] && state.transcripts[key].loaded && actions.loadTranscript(agentId, key.slice(at + 1));
+    }
+  }
+  function stop() {
+    stopped = !0, stream?.close(), stream = null, webTick && (clearInterval(webTick), webTick = null), trackedTick && (clearInterval(trackedTick), trackedTick = null), pendingFrames = [];
+    for (let timer of toastTimers.values()) clearTimeout(timer);
+    for (let timer of debounced.values()) clearTimeout(timer);
+    toastTimers.clear(), debounced.clear();
+    for (let resolve of confirmResolvers.values()) resolve(!1);
+    confirmResolvers.clear();
+  }
+  function resolveConfirm(id, confirmed) {
+    let resolve = confirmResolvers.get(id);
+    confirmResolvers.delete(id), dispatch({ type: "overlay/pop", id }), resolve?.(confirmed);
+  }
+  return {
+    get client() {
+      return client;
+    },
+    actions,
+    getState,
+    dispatch,
+    subscribe,
+    start,
+    stop,
+    resolveConfirm
+  };
+}
+var StoreContext = (0, import_react.createContext)(null);
+function StoreProvider({ store, children }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(StoreContext.Provider, { value: store, children });
+}
+function useStore() {
+  let store = (0, import_react.useContext)(StoreContext);
+  if (!store) throw new Error("useStore must be used inside <StoreProvider>");
+  return store;
+}
+function useActions() {
+  return useStore().actions;
+}
+function useClient() {
+  return useStore().client;
+}
+function useTuiSelector(selector, isEqual = Object.is) {
+  let store = useStore(), cache = (0, import_react.useRef)(null), getSnapshot = () => {
+    let current = store.getState(), cached = cache.current;
+    if (cached && cached.state === current && cached.selector === selector) return cached.value;
+    let value = selector(current);
+    return cached && isEqual(cached.value, value) ? (cache.current = { state: current, selector, value: cached.value }, cached.value) : (cache.current = { state: current, selector, value }, value);
+  };
+  return (0, import_react.useSyncExternalStore)(store.subscribe, getSnapshot, getSnapshot);
+}
+function shallowEqual(a, b) {
+  if (Object.is(a, b)) return !0;
+  if (typeof a != "object" || typeof b != "object" || a === null || b === null) return !1;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length) return !1;
+    for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return !1;
+    return !0;
+  }
+  let ak = Object.keys(a), bk = Object.keys(b);
+  if (ak.length !== bk.length) return !1;
+  for (let k of ak) if (!Object.is(a[k], b[k])) return !1;
+  return !0;
+}
+
+export {
+  emptyTranscript,
+  isAsyncInput,
+  askQuestion,
+  isTrackedKey,
+  folderName,
+  stoppedLabel,
+  stoppedError,
+  findTracked,
+  transcriptKey,
+  isBusyState,
+  parseServer,
+  siteOf,
+  servedText,
+  siteKind,
+  shortUrl,
+  SERVER_STOPPED_TEXT,
+  serverBadge,
+  serverText,
+  PROMPT_PREFILL_KEY,
+  createTuiStore,
+  StoreProvider,
+  useStore,
+  useActions,
+  useClient,
+  useTuiSelector,
+  shallowEqual
+};