@makinbakin/sdk 0.0.0-bootstrap.0

package/hooks/index.js

@@ -0,0 +1,1738 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// node_modules/.bun/use-sync-external-store@1.6.0+b1ab299f0a400331/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js
+import * as React2 from "react";
+var require_use_sync_external_store_shim_development = __commonJS((exports) => {
+  (function() {
+    function is(x, y) {
+      return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y;
+    }
+    function useSyncExternalStore$2(subscribe, getSnapshot) {
+      didWarnOld18Alpha || React2.startTransition === undefined || (didWarnOld18Alpha = true, console.error("You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."));
+      var value = getSnapshot();
+      if (!didWarnUncachedGetSnapshot) {
+        var cachedValue = getSnapshot();
+        objectIs(value, cachedValue) || (console.error("The result of getSnapshot should be cached to avoid an infinite loop"), didWarnUncachedGetSnapshot = true);
+      }
+      cachedValue = useState9({
+        inst: { value, getSnapshot }
+      });
+      var inst = cachedValue[0].inst, forceUpdate = cachedValue[1];
+      useLayoutEffect2(function() {
+        inst.value = value;
+        inst.getSnapshot = getSnapshot;
+        checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+      }, [subscribe, value, getSnapshot]);
+      useEffect11(function() {
+        checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+        return subscribe(function() {
+          checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+        });
+      }, [subscribe]);
+      useDebugValue2(value);
+      return value;
+    }
+    function checkIfSnapshotChanged(inst) {
+      var latestGetSnapshot = inst.getSnapshot;
+      inst = inst.value;
+      try {
+        var nextValue = latestGetSnapshot();
+        return !objectIs(inst, nextValue);
+      } catch (error) {
+        return true;
+      }
+    }
+    function useSyncExternalStore$1(subscribe, getSnapshot) {
+      return getSnapshot();
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var objectIs = typeof Object.is === "function" ? Object.is : is, useState9 = React2.useState, useEffect11 = React2.useEffect, useLayoutEffect2 = React2.useLayoutEffect, useDebugValue2 = React2.useDebugValue, didWarnOld18Alpha = false, didWarnUncachedGetSnapshot = false, shim = typeof window === "undefined" || typeof window.document === "undefined" || typeof window.document.createElement === "undefined" ? useSyncExternalStore$1 : useSyncExternalStore$2;
+    exports.useSyncExternalStore = React2.useSyncExternalStore !== undefined ? React2.useSyncExternalStore : shim;
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })();
+});
+
+// node_modules/.bun/use-sync-external-store@1.6.0+b1ab299f0a400331/node_modules/use-sync-external-store/shim/index.js
+var require_shim = __commonJS((exports, module) => {
+  if (false) {} else {
+    module.exports = require_use_sync_external_store_shim_development();
+  }
+});
+
+// node_modules/.bun/use-sync-external-store@1.6.0+b1ab299f0a400331/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js
+import * as React3 from "react";
+var require_with_selector_development = __commonJS((exports) => {
+  (function() {
+    function is(x, y) {
+      return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y;
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var shim = require_shim(), objectIs = typeof Object.is === "function" ? Object.is : is, useSyncExternalStore = shim.useSyncExternalStore, useRef8 = React3.useRef, useEffect11 = React3.useEffect, useMemo3 = React3.useMemo, useDebugValue2 = React3.useDebugValue;
+    exports.useSyncExternalStoreWithSelector = function(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+      var instRef = useRef8(null);
+      if (instRef.current === null) {
+        var inst = { hasValue: false, value: null };
+        instRef.current = inst;
+      } else
+        inst = instRef.current;
+      instRef = useMemo3(function() {
+        function memoizedSelector(nextSnapshot) {
+          if (!hasMemo) {
+            hasMemo = true;
+            memoizedSnapshot = nextSnapshot;
+            nextSnapshot = selector(nextSnapshot);
+            if (isEqual !== undefined && inst.hasValue) {
+              var currentSelection = inst.value;
+              if (isEqual(currentSelection, nextSnapshot))
+                return memoizedSelection = currentSelection;
+            }
+            return memoizedSelection = nextSnapshot;
+          }
+          currentSelection = memoizedSelection;
+          if (objectIs(memoizedSnapshot, nextSnapshot))
+            return currentSelection;
+          var nextSelection = selector(nextSnapshot);
+          if (isEqual !== undefined && isEqual(currentSelection, nextSelection))
+            return memoizedSnapshot = nextSnapshot, currentSelection;
+          memoizedSnapshot = nextSnapshot;
+          return memoizedSelection = nextSelection;
+        }
+        var hasMemo = false, memoizedSnapshot, memoizedSelection, maybeGetServerSnapshot = getServerSnapshot === undefined ? null : getServerSnapshot;
+        return [
+          function() {
+            return memoizedSelector(getSnapshot());
+          },
+          maybeGetServerSnapshot === null ? undefined : function() {
+            return memoizedSelector(maybeGetServerSnapshot());
+          }
+        ];
+      }, [getSnapshot, getServerSnapshot, selector, isEqual]);
+      var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+      useEffect11(function() {
+        inst.hasValue = true;
+        inst.value = value;
+      }, [value]);
+      useDebugValue2(value);
+      return value;
+    };
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })();
+});
+
+// node_modules/.bun/use-sync-external-store@1.6.0+b1ab299f0a400331/node_modules/use-sync-external-store/shim/with-selector.js
+var require_with_selector = __commonJS((exports, module) => {
+  if (false) {} else {
+    module.exports = require_with_selector_development();
+  }
+});
+
+// src/hooks/use-assets.ts
+import { useState, useEffect, useCallback, useRef } from "react";
+"use client";
+function useAssets(options = {}) {
+  const [assets, setAssets] = useState([]);
+  const [total, setTotal] = useState(0);
+  const [loading, setLoading] = useState(true);
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const fetchAssets = useCallback(async () => {
+    const params = new URLSearchParams;
+    const opts = optionsRef.current;
+    if (opts.type && opts.type !== "all")
+      params.set("type", opts.type);
+    if (opts.agent)
+      params.set("agent", opts.agent);
+    if (opts.taskId)
+      params.set("taskId", opts.taskId);
+    if (opts.tag)
+      params.set("tag", opts.tag);
+    if (opts.limit)
+      params.set("limit", String(opts.limit));
+    if (opts.offset)
+      params.set("offset", String(opts.offset));
+    try {
+      const res = await fetch(`/api/plugins/assets/?${params}`);
+      if (res.ok) {
+        const data = await res.json();
+        setAssets(data.assets || []);
+        setTotal(data.total ?? data.count ?? 0);
+      }
+    } catch {} finally {
+      setLoading(false);
+    }
+  }, []);
+  useEffect(() => {
+    fetchAssets();
+  }, [fetchAssets, options.type, options.agent, options.taskId, options.tag, options.limit, options.offset]);
+  useEffect(() => {
+    const es = new EventSource("/api/events");
+    const handler = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.file?.startsWith("assets/") || data.event?.startsWith("asset.")) {
+          fetchAssets();
+        }
+      } catch {}
+    };
+    es.addEventListener("message", handler);
+    return () => {
+      es.removeEventListener("message", handler);
+      es.close();
+    };
+  }, [fetchAssets]);
+  const deleteAsset = useCallback(async (filename) => {
+    try {
+      const res = await fetch(`/api/plugins/assets?filename=${encodeURIComponent(filename)}`, {
+        method: "DELETE"
+      });
+      if (res.ok) {
+        setAssets((prev) => prev.filter((a) => a.filename !== filename));
+        return true;
+      }
+    } catch {}
+    return false;
+  }, []);
+  return { assets, total, loading, refresh: fetchAssets, deleteAsset };
+}
+function useTrash() {
+  const [items, setItems] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const fetchTrash = useCallback(async () => {
+    try {
+      const res = await fetch("/api/plugins/assets/trash");
+      if (res.ok) {
+        const data = await res.json();
+        setItems(data.assets || []);
+      }
+    } catch {} finally {
+      setLoading(false);
+    }
+  }, []);
+  useEffect(() => {
+    fetchTrash();
+  }, [fetchTrash]);
+  useEffect(() => {
+    const es = new EventSource("/api/events");
+    const handler = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.file?.includes(".trash/") || data.event?.startsWith("asset.")) {
+          fetchTrash();
+        }
+      } catch {}
+    };
+    es.addEventListener("message", handler);
+    return () => {
+      es.removeEventListener("message", handler);
+      es.close();
+    };
+  }, [fetchTrash]);
+  const restoreAsset = useCallback(async (filename) => {
+    try {
+      const res = await fetch(`/api/plugins/assets/trash/${encodeURIComponent(filename)}/restore`, {
+        method: "POST"
+      });
+      if (res.ok) {
+        setItems((prev) => prev.filter((i) => i.filename !== filename));
+        return true;
+      }
+    } catch {}
+    return false;
+  }, []);
+  const permanentDeleteAsset = useCallback(async (filename) => {
+    try {
+      const res = await fetch(`/api/plugins/assets/trash/${encodeURIComponent(filename)}`, {
+        method: "DELETE"
+      });
+      if (res.ok) {
+        setItems((prev) => prev.filter((i) => i.filename !== filename));
+        return true;
+      }
+    } catch {}
+    return false;
+  }, []);
+  const emptyTrash = useCallback(async () => {
+    try {
+      const res = await fetch("/api/plugins/assets/trash", { method: "DELETE" });
+      if (res.ok) {
+        setItems([]);
+        return true;
+      }
+    } catch {}
+    return false;
+  }, []);
+  return { items, loading, refresh: fetchTrash, restoreAsset, permanentDeleteAsset, emptyTrash };
+}
+// node_modules/.bun/zustand@5.0.12+10f197a4cef36846/node_modules/zustand/esm/vanilla.mjs
+var createStoreImpl = (createState) => {
+  let state;
+  const listeners = /* @__PURE__ */ new Set;
+  const setState = (partial, replace) => {
+    const nextState = typeof partial === "function" ? partial(state) : partial;
+    if (!Object.is(nextState, state)) {
+      const previousState = state;
+      state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+      listeners.forEach((listener) => listener(state, previousState));
+    }
+  };
+  const getState = () => state;
+  const getInitialState = () => initialState;
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const api = { setState, getState, getInitialState, subscribe };
+  const initialState = state = createState(setState, getState, api);
+  return api;
+};
+var createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
+
+// node_modules/.bun/zustand@5.0.12+10f197a4cef36846/node_modules/zustand/esm/react.mjs
+import React from "react";
+var identity = (arg) => arg;
+function useStore(api, selector = identity) {
+  const slice = React.useSyncExternalStore(api.subscribe, React.useCallback(() => selector(api.getState()), [api, selector]), React.useCallback(() => selector(api.getInitialState()), [api, selector]));
+  React.useDebugValue(slice);
+  return slice;
+}
+var createImpl = (createState) => {
+  const api = createStore(createState);
+  const useBoundStore = (selector) => useStore(api, selector);
+  Object.assign(useBoundStore, api);
+  return useBoundStore;
+};
+var create = (createState) => createState ? createImpl(createState) : createImpl;
+
+// src/lib/map-audit-message.ts
+function mapAuditMessage(event, data) {
+  switch (event) {
+    case "task.dispatched":
+      return `Dispatched: ${data.title}`;
+    case "task.triaged":
+      return `Triaged: ${data.title}`;
+    case "task.created":
+      return `Created task: ${data.title}`;
+    case "task.deleted":
+      return `Deleted task: ${data.title}`;
+    case "task.moved":
+      return `Moved "${data.title}" \u2192 ${data.to}`;
+    case "task.assigned":
+      return `Assigned "${data.title}" to ${data.assignee}`;
+    case "task.blocked":
+      return `Blocked: ${data.title} \u2014 ${data.reason || "no reason"}`;
+    case "task.updated":
+      return `Updated: ${data.title}`;
+    case "system.init":
+      return "Bakin started";
+    case "system.dispatch_error":
+      return `Dispatch failed: ${data.error || "unknown error"}`;
+    case "workflow.step_dispatched":
+      return `Step "${data.label || "unknown"}" dispatched to ${data.agent || "agent"}`;
+    case "workflow.step_complete":
+      return `Step "${data.label || "unknown"}" completed`;
+    case "workflow.gate_reached":
+      return `Awaiting approval: ${data.label || "gate"}`;
+    case "workflow.gate_approved":
+      return `Approved: ${data.label || "gate"}`;
+    case "workflow.gate_rejected":
+      return `Rejected: ${data.label || "gate"}${data.reason ? ` \u2014 ${data.reason}` : ""}`;
+    case "workflow.complete":
+      return `Workflow complete${data.workflowId ? ` (${data.workflowId})` : ""}`;
+    default: {
+      if (event.startsWith("exec.")) {
+        const suffix = event.endsWith(".fail") ? " (failed)" : event.endsWith(".error") ? " (error)" : "";
+        if (data.label)
+          return `${data.label}${suffix}`;
+        const toolName = event.replace(/^exec\./, "").replace(/\.(ok|fail|error)$/, "");
+        return humanizeExecName(toolName) + suffix;
+      }
+      return event;
+    }
+  }
+}
+function humanizeExecName(name) {
+  const stripped = name.replace(/^bakin_exec_/, "");
+  const words = stripped.split("_");
+  if (words.length === 0)
+    return name;
+  words[0] = words[0].charAt(0).toUpperCase() + words[0].slice(1);
+  return words.join(" ");
+}
+function isNoisyEvent(evt) {
+  if (evt.agent === "system" && evt.message.startsWith("Dispatch failed"))
+    return true;
+  return false;
+}
+
+// src/hooks/use-content-store.ts
+var useContentStore = create((set, get) => ({
+  files: {},
+  heartbeats: {},
+  connected: false,
+  loading: true,
+  auditEntries: [],
+  activityEvents: [],
+  sseConnected: false,
+  taskboardVersion: 0,
+  debug: false,
+  reindexProgress: {},
+  setFiles: (files) => set({ files }),
+  updateFile: (key, content) => set((state) => ({ files: { ...state.files, [key]: content } })),
+  setHeartbeats: (heartbeats) => set({ heartbeats }),
+  setConnected: (connected) => set({ connected }),
+  appendAuditEntry: (entry) => set((state) => ({ auditEntries: [...state.auditEntries, entry] })),
+  appendActivityEvent: (event) => set((state) => {
+    if (isNoisyEvent(event))
+      return state;
+    if (state.activityEvents.some((e) => e.id === event.id))
+      return state;
+    return { activityEvents: [event, ...state.activityEvents].slice(0, 100) };
+  }),
+  setActivityEvents: (events) => set({ activityEvents: events.filter((e) => !isNoisyEvent(e)).slice(0, 100) }),
+  setSseConnected: (connected) => set({ sseConnected: connected }),
+  bumpTaskboard: () => set((state) => ({ taskboardVersion: state.taskboardVersion + 1 })),
+  setDebug: (debug) => {
+    set({ debug });
+    try {
+      localStorage.setItem("bakin-debug", String(debug));
+    } catch {}
+  },
+  toggleDebug: () => {
+    const next = !get().debug;
+    set({ debug: next });
+    try {
+      localStorage.setItem("bakin-debug", String(next));
+    } catch {}
+  },
+  setReindexProgress: (table, indexed, done) => set((state) => ({
+    reindexProgress: { ...state.reindexProgress, [table]: { indexed, done } }
+  })),
+  clearReindexProgress: () => set({ reindexProgress: {} }),
+  initialize: async () => {
+    try {
+      if (localStorage.getItem("bakin-debug") === "true")
+        set({ debug: true });
+    } catch {}
+    try {
+      const [stateRes, healthRes, activityRes] = await Promise.all([
+        fetch("/api/state"),
+        fetch("/api/agents/health"),
+        fetch("/api/activity")
+      ]);
+      if (stateRes.ok) {
+        const files = await stateRes.json();
+        set({ files });
+      }
+      if (healthRes.ok) {
+        const heartbeats = await healthRes.json();
+        set({ heartbeats });
+      }
+      if (activityRes.ok) {
+        const data = await activityRes.json();
+        if (data?.events) {
+          get().setActivityEvents(data.events);
+        }
+      }
+    } catch {} finally {
+      set({ loading: false });
+    }
+  }
+}));
+// src/hooks/use-debug.ts
+"use client";
+function useDebug() {
+  const debug = useContentStore((s) => s.debug);
+  const toggleDebug = useContentStore((s) => s.toggleDebug);
+  return [debug, toggleDebug];
+}
+// src/hooks/use-form-guard.ts
+import { useEffect as useEffect2 } from "react";
+"use client";
+function useFormGuard(isDirty) {
+  useEffect2(() => {
+    if (!isDirty)
+      return;
+    const handler = (e) => {
+      e.preventDefault();
+    };
+    window.addEventListener("beforeunload", handler);
+    return () => window.removeEventListener("beforeunload", handler);
+  }, [isDirty]);
+}
+// src/hooks/use-runtime-status.ts
+import { useState as useState2, useEffect as useEffect3, useCallback as useCallback2 } from "react";
+"use client";
+function useRuntimeStatus() {
+  const [restartNeeded, setRestartNeeded] = useState2(false);
+  const [restarting, setRestarting] = useState2(false);
+  useEffect3(() => {
+    fetch("/api/plugins/models/runtime/status").then((r) => {
+      if (!r.ok)
+        throw new Error(`Runtime status: ${r.status}`);
+      return r.json();
+    }).then((data) => {
+      if (data?.restartNeeded)
+        setRestartNeeded(true);
+    }).catch((e) => console.error("Failed to fetch runtime status:", e));
+  }, []);
+  const restart = useCallback2(async () => {
+    setRestarting(true);
+    try {
+      const res = await fetch("/api/plugins/models/runtime/restart", { method: "POST" });
+      if (res.ok)
+        setRestartNeeded(false);
+    } finally {
+      setRestarting(false);
+    }
+  }, []);
+  const markDirty = useCallback2(() => setRestartNeeded(true), []);
+  return { restartNeeded, restarting, restart, markDirty };
+}
+// src/hooks/use-query-state.ts
+import { useCallback as useCallback3, useMemo, useRef as useRef2 } from "react";
+"use client";
+function useQueryState(key, defaultValue = "") {
+  const searchParams = useSearchParams();
+  const router = useRouter();
+  const pathname = usePathname();
+  const paramsRef = useRef2(searchParams);
+  paramsRef.current = searchParams;
+  const pathnameRef = useRef2(pathname);
+  pathnameRef.current = pathname;
+  const value = searchParams.get(key) ?? defaultValue;
+  const buildUrl = useCallback3((v) => {
+    const params = new URLSearchParams(paramsRef.current.toString());
+    if (v === defaultValue) {
+      params.delete(key);
+    } else {
+      params.set(key, v);
+    }
+    const qs = params.toString();
+    return qs ? `${pathnameRef.current}?${qs}` : pathnameRef.current;
+  }, [key, defaultValue]);
+  const setValue = useCallback3((v) => {
+    router.replace(buildUrl(v), { scroll: false });
+  }, [router, buildUrl]);
+  const pushValue = useCallback3((v) => {
+    router.push(buildUrl(v), { scroll: false });
+  }, [router, buildUrl]);
+  return [value, setValue, pushValue];
+}
+function useQueryArrayState(key) {
+  const searchParams = useSearchParams();
+  const router = useRouter();
+  const pathname = usePathname();
+  const paramsRef = useRef2(searchParams);
+  paramsRef.current = searchParams;
+  const pathnameRef = useRef2(pathname);
+  pathnameRef.current = pathname;
+  const value = useMemo(() => {
+    const raw = searchParams.get(key);
+    if (!raw)
+      return [];
+    return raw.split(",").filter(Boolean);
+  }, [searchParams, key]);
+  const setValue = useCallback3((v) => {
+    const params = new URLSearchParams(paramsRef.current.toString());
+    if (v.length === 0) {
+      params.delete(key);
+    } else {
+      params.set(key, v.join(","));
+    }
+    const qs = params.toString();
+    router.replace(qs ? `${pathnameRef.current}?${qs}` : pathnameRef.current, { scroll: false });
+  }, [router, key]);
+  return [value, setValue];
+}
+// src/hooks/use-schedule.ts
+import { useState as useState3, useEffect as useEffect4, useCallback as useCallback4, useRef as useRef3 } from "react";
+"use client";
+function useScheduleJobs(options = {}) {
+  const [jobs, setJobs] = useState3([]);
+  const [loading, setLoading] = useState3(true);
+  const optionsRef = useRef3(options);
+  optionsRef.current = options;
+  const fetchJobs = useCallback4(async () => {
+    try {
+      const res = await fetch("/api/plugins/schedule/");
+      if (res.ok) {
+        const data = await res.json();
+        setJobs(data.jobs || []);
+      }
+    } catch {} finally {
+      setLoading(false);
+    }
+  }, []);
+  useEffect4(() => {
+    fetchJobs();
+  }, [fetchJobs]);
+  useEffect4(() => {
+    const es = new EventSource("/api/events");
+    const handler = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.type === "activity" && data.message?.includes("Schedule") || data.event?.startsWith("schedule.")) {
+          fetchJobs();
+        }
+      } catch {}
+    };
+    es.addEventListener("message", handler);
+    return () => {
+      es.removeEventListener("message", handler);
+      es.close();
+    };
+  }, [fetchJobs]);
+  const opts = options;
+  const filtered = jobs.filter((j) => {
+    if (opts.agent && j.agentId !== opts.agent)
+      return false;
+    return true;
+  });
+  const pauseJob = useCallback4(async (jobId, pauseUntil) => {
+    try {
+      const res = await fetch(`/api/plugins/schedule/${jobId}/pause`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ action: "pause", pauseUntil })
+      });
+      if (res.ok)
+        fetchJobs();
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }, [fetchJobs]);
+  const resumeJob = useCallback4(async (jobId) => {
+    try {
+      const res = await fetch(`/api/plugins/schedule/${jobId}/pause`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ action: "resume" })
+      });
+      if (res.ok)
+        fetchJobs();
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }, [fetchJobs]);
+  const deleteJob = useCallback4(async (jobId) => {
+    try {
+      const res = await fetch(`/api/plugins/schedule/${jobId}`, {
+        method: "DELETE",
+        headers: { "Content-Type": "application/json" }
+      });
+      if (res.ok) {
+        setJobs((prev) => prev.filter((j) => j.id !== jobId));
+      }
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }, []);
+  const runNow = useCallback4(async (jobId) => {
+    try {
+      const res = await fetch(`/api/plugins/schedule/${jobId}/run`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" }
+      });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }, []);
+  const updateJob = useCallback4(async (jobId, data) => {
+    try {
+      const res = await fetch(`/api/plugins/schedule/${jobId}`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(data)
+      });
+      if (res.ok)
+        fetchJobs();
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }, [fetchJobs]);
+  const adoptJob = useCallback4(async (jobId, data) => {
+    try {
+      const res = await fetch(`/api/plugins/schedule/${jobId}/adopt`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(data)
+      });
+      if (res.ok)
+        fetchJobs();
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }, [fetchJobs]);
+  const restoreNative = useCallback4(async (jobId) => {
+    try {
+      const res = await fetch(`/api/plugins/schedule/${jobId}/restore-native`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" }
+      });
+      if (res.ok)
+        fetchJobs();
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }, [fetchJobs]);
+  const skipNext = useCallback4(async (jobId, n = 1) => {
+    try {
+      const res = await fetch(`/api/plugins/schedule/${jobId}/pause`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ action: "skip", skipN: n })
+      });
+      if (res.ok)
+        fetchJobs();
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }, [fetchJobs]);
+  const duplicateJob = useCallback4(async (jobId, overrides = {}) => {
+    const source = jobs.find((j) => j.id === jobId);
+    if (!source)
+      return false;
+    try {
+      const res = await fetch("/api/plugins/schedule/", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          name: overrides.name ?? `${source.displayName} (copy)`,
+          schedule: overrides.schedule ?? source.humanSchedule,
+          agentId: overrides.agentId ?? source.agentId,
+          taskPrompt: overrides.taskPrompt ?? source.taskPrompt,
+          taskTitle: overrides.taskTitle ?? source.taskTitle,
+          workflowId: overrides.workflowId ?? source.workflowId,
+          owner: overrides.owner ?? source.owner,
+          requireTriage: overrides.requireTriage ?? source.requireTriage,
+          allowOverlap: overrides.allowOverlap ?? source.allowOverlap,
+          maxFailures: overrides.maxFailures ?? source.maxFailures,
+          ...overrides
+        })
+      });
+      if (res.ok)
+        fetchJobs();
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }, [jobs, fetchJobs]);
+  return {
+    jobs: filtered,
+    loading,
+    refresh: fetchJobs,
+    pauseJob,
+    resumeJob,
+    deleteJob,
+    runNow,
+    updateJob,
+    adoptJob,
+    restoreNative,
+    skipNext,
+    duplicateJob
+  };
+}
+function useRunHistory(jobId, limit = 20) {
+  const [runs, setRuns] = useState3([]);
+  const [loading, setLoading] = useState3(false);
+  useEffect4(() => {
+    if (!jobId) {
+      setRuns([]);
+      return;
+    }
+    setLoading(true);
+    fetch(`/api/plugins/schedule/${jobId}/runs?limit=${limit}`).then((res) => res.ok ? res.json() : null).then((data) => {
+      if (data)
+        setRuns(data.runs || []);
+    }).catch(() => {}).finally(() => setLoading(false));
+  }, [jobId, limit]);
+  return { runs, loading };
+}
+// src/hooks/use-search.ts
+import { useState as useState4, useEffect as useEffect5, useCallback as useCallback5, useRef as useRef4 } from "react";
+"use client";
+function reorderBySearchResults(items, searchResults) {
+  if (!searchResults.length)
+    return items;
+  const scoreMap = new Map;
+  for (const r of searchResults) {
+    scoreMap.set(r.id, r.score);
+  }
+  const matched = [];
+  const unmatched = [];
+  for (const item of items) {
+    if (scoreMap.has(item.id)) {
+      matched.push(item);
+    } else {
+      unmatched.push(item);
+    }
+  }
+  matched.sort((a, b) => (scoreMap.get(b.id) ?? 0) - (scoreMap.get(a.id) ?? 0));
+  return [...matched, ...unmatched];
+}
+function useSearch(options = {}) {
+  const {
+    plugin,
+    limit = 20,
+    facets,
+    debounce: debounceMs = 250,
+    fallback
+  } = options;
+  const [results, setResults] = useState4([]);
+  const [aggregations, setAggregations] = useState4({});
+  const [loading, setLoading] = useState4(false);
+  const [error, setError] = useState4(null);
+  const [meta, setMeta] = useState4(null);
+  const [, setQuery] = useState4("");
+  const abortRef = useRef4(null);
+  const timerRef = useRef4(null);
+  const mountedRef = useRef4(true);
+  useEffect5(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      abortRef.current?.abort();
+      if (timerRef.current)
+        clearTimeout(timerRef.current);
+    };
+  }, []);
+  const executeSearch = useCallback5(async (q) => {
+    if (!q.trim()) {
+      setResults([]);
+      setAggregations({});
+      setMeta(null);
+      setError(null);
+      setLoading(false);
+      return;
+    }
+    abortRef.current?.abort();
+    const controller = new AbortController;
+    abortRef.current = controller;
+    setLoading(true);
+    setError(null);
+    try {
+      const params = new URLSearchParams({ q });
+      if (limit)
+        params.set("limit", String(limit));
+      if (facets?.length)
+        params.set("facets", facets.join(","));
+      const url = plugin ? `/api/plugins/${plugin}/search?${params}` : `/api/search?${params}`;
+      const res = await fetch(url, { signal: controller.signal });
+      if (!mountedRef.current)
+        return;
+      if (!res.ok) {
+        throw new Error(`Search failed: ${res.status}`);
+      }
+      const data = await res.json();
+      if (!mountedRef.current)
+        return;
+      if (data.results.length === 0 && data.meta?.source === "fallback" && fallback) {
+        setResults(fallback(q));
+        setAggregations({});
+        setMeta(data.meta);
+      } else {
+        setResults(data.results);
+        setAggregations(data.aggregations || {});
+        setMeta(data.meta || null);
+      }
+    } catch (err) {
+      if (!mountedRef.current)
+        return;
+      if (err instanceof DOMException && err.name === "AbortError")
+        return;
+      const msg = err instanceof Error ? err.message : String(err);
+      setError(msg);
+      if (fallback) {
+        setResults(fallback(q));
+        setAggregations({});
+      } else {
+        setResults([]);
+        setAggregations({});
+      }
+    } finally {
+      if (mountedRef.current)
+        setLoading(false);
+    }
+  }, [plugin, limit, facets, fallback]);
+  const search = useCallback5((q) => {
+    setQuery(q);
+    if (timerRef.current)
+      clearTimeout(timerRef.current);
+    if (!q.trim()) {
+      setResults([]);
+      setAggregations({});
+      setMeta(null);
+      setError(null);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    timerRef.current = setTimeout(() => executeSearch(q), debounceMs);
+  }, [executeSearch, debounceMs]);
+  const clear = useCallback5(() => {
+    setQuery("");
+    setResults([]);
+    setAggregations({});
+    setMeta(null);
+    setError(null);
+    setLoading(false);
+    abortRef.current?.abort();
+    if (timerRef.current)
+      clearTimeout(timerRef.current);
+  }, []);
+  return { results, aggregations, loading, error, meta, search, clear };
+}
+// src/hooks/use-sidebar.ts
+import { useState as useState5, useEffect as useEffect6 } from "react";
+"use client";
+function useSidebar() {
+  const [collapsed, setCollapsed] = useState5(false);
+  useEffect6(() => {
+    const stored = localStorage.getItem("sidebar-collapsed");
+    if (stored === "true")
+      setCollapsed(true);
+  }, []);
+  const toggle = () => setCollapsed((c) => {
+    localStorage.setItem("sidebar-collapsed", String(!c));
+    return !c;
+  });
+  return { collapsed, toggle };
+}
+// src/hooks/use-sse.ts
+import { useEffect as useEffect7, useRef as useRef5 } from "react";
+
+// src/lib/browser-notify.ts
+var STORAGE_KEY = "bakin-notifications-enabled";
+function isNotificationsSupported() {
+  return typeof window !== "undefined" && "Notification" in window && window.isSecureContext;
+}
+function isNotificationsEnabled() {
+  if (!isNotificationsSupported())
+    return false;
+  return localStorage.getItem(STORAGE_KEY) === "true" && Notification.permission === "granted";
+}
+function sendBrowserNotification(title, body) {
+  if (!isNotificationsEnabled())
+    return;
+  if (document.hasFocus())
+    return;
+  new Notification(title, { body, icon: "/favicon.ico" });
+}
+
+// src/hooks/use-sse.ts
+"use client";
+var MAX_RETRIES = 20;
+var BASE_DELAY = 1000;
+var MAX_DELAY = 30000;
+function isDevPluginHotReloadActive() {
+  return typeof document !== "undefined" && !!document.querySelector('script[src="/__bakin-dev/client.js"]');
+}
+function useSSE() {
+  const updateFile = useContentStore((s) => s.updateFile);
+  const setConnected = useContentStore((s) => s.setConnected);
+  const setHeartbeats = useContentStore((s) => s.setHeartbeats);
+  const initialize = useContentStore((s) => s.initialize);
+  const appendAuditEntry = useContentStore((s) => s.appendAuditEntry);
+  const appendActivityEvent = useContentStore((s) => s.appendActivityEvent);
+  const setSseConnected = useContentStore((s) => s.setSseConnected);
+  const bumpTaskboard = useContentStore((s) => s.bumpTaskboard);
+  const setReindexProgress = useContentStore((s) => s.setReindexProgress);
+  const esRef = useRef5(null);
+  const retryRef = useRef5(0);
+  const timeoutRef = useRef5(null);
+  const hbTimerRef = useRef5(null);
+  useEffect7(() => {
+    initialize();
+    function connect() {
+      if (esRef.current) {
+        esRef.current.close();
+        esRef.current = null;
+      }
+      const es = new EventSource("/api/events");
+      esRef.current = es;
+      es.onopen = () => {
+        setConnected(true);
+        setSseConnected(true);
+        retryRef.current = 0;
+      };
+      es.onmessage = (e) => {
+        try {
+          const data = JSON.parse(e.data);
+          if (data.type === "taskboard") {
+            bumpTaskboard();
+            return;
+          }
+          if (data.type === "plugin:manifest-changed") {
+            if (!isDevPluginHotReloadActive()) {
+              window.location.reload();
+            }
+            return;
+          }
+          if (data.type === "activity") {
+            appendActivityEvent({
+              id: `${data.ts}-activity-${data.agent}`,
+              ts: data.ts,
+              type: "log",
+              agent: data.agent || "system",
+              message: data.message,
+              taskId: data.taskId
+            });
+            return;
+          }
+          if (data.type === "audit" && data.entry) {
+            const entry = data.entry;
+            const entryData = entry.data || {};
+            appendAuditEntry(entry);
+            appendActivityEvent({
+              id: `${entry.ts}-${entry.event}-${entry.agent}`,
+              ts: entry.ts,
+              type: "audit",
+              agent: entry.agent || "system",
+              message: mapAuditMessage(entry.event, entryData),
+              taskId: entryData.taskId,
+              taskTitle: entryData.title,
+              eventName: entry.event,
+              ...entryData.duplicate ? { duplicate: true } : {}
+            });
+          }
+          if (data.type === "plugin-event" && typeof data.event === "string" && data.event.startsWith("workflow.")) {
+            if (data.event.startsWith("workflow.gate") || data.event === "workflow.complete") {
+              initialize();
+            }
+            if (data.event === "workflow.gate_reached") {
+              sendBrowserNotification("Approval needed", data.label || "A workflow gate needs your review");
+            }
+            appendAuditEntry({
+              ts: data.timestamp || new Date().toISOString(),
+              event: data.event,
+              agent: "workflow",
+              data: { taskId: data.taskId, label: data.label, agent: data.agent, reason: data.reason, workflowId: data.workflowId }
+            });
+            appendActivityEvent({
+              id: `${data.timestamp || new Date().toISOString()}-${data.event}-workflow`,
+              ts: data.timestamp || new Date().toISOString(),
+              type: "audit",
+              agent: "workflow",
+              message: mapAuditMessage(data.event, data),
+              taskId: data.taskId,
+              eventName: data.event
+            });
+          }
+          if (data.type === "alert") {
+            appendActivityEvent({
+              id: `${data.timestamp || new Date().toISOString()}-alert-system`,
+              ts: data.timestamp || new Date().toISOString(),
+              type: "alert",
+              agent: "system",
+              message: data.message || "Watchdog alert"
+            });
+          }
+          if (data.type === "reindex.start") {
+            setReindexProgress(data.table, 0, false);
+          }
+          if (data.type === "reindex.progress") {
+            setReindexProgress(data.table, data.indexed ?? 0, false);
+          }
+          if (data.type === "reindex.complete") {
+            setReindexProgress(data.table, data.indexed ?? 0, true);
+          }
+          if (data.type === "reindex.batch_start") {
+            appendActivityEvent({
+              id: `${Date.now()}-reindex-batch-start`,
+              ts: new Date().toISOString(),
+              type: "log",
+              agent: "system",
+              message: `Starting full re-index (${data.tables} table${data.tables === 1 ? "" : "s"})`
+            });
+          }
+          if (data.type === "reindex.batch_pulse") {
+            const pct = data.tables_total ? Math.floor(data.tables_done / data.tables_total * 100) : 0;
+            appendActivityEvent({
+              id: `${Date.now()}-reindex-batch-pulse`,
+              ts: new Date().toISOString(),
+              type: "log",
+              agent: "system",
+              message: `Re-indexing\u2026 ${data.tables_done}/${data.tables_total} tables (${pct}%), ${data.indexed} documents so far`
+            });
+          }
+          if (data.type === "reindex.batch_complete") {
+            const seconds = Math.max(1, Math.round((data.elapsed_ms ?? 0) / 1000));
+            appendActivityEvent({
+              id: `${Date.now()}-reindex-batch-complete`,
+              ts: new Date().toISOString(),
+              type: "log",
+              agent: "system",
+              message: `Completed full re-index \u2014 ${data.indexed} documents across ${data.tables} table${data.tables === 1 ? "" : "s"} in ${seconds}s`
+            });
+          }
+          if (data.file && data.content !== undefined) {
+            updateFile(data.file, data.content);
+            if (data.file.startsWith("heartbeats/") && data.file.endsWith(".json")) {
+              if (hbTimerRef.current)
+                clearTimeout(hbTimerRef.current);
+              hbTimerRef.current = setTimeout(() => {
+                fetch("/api/agents/health").then((r) => r.ok ? r.json() : null).then((hb) => {
+                  if (hb)
+                    setHeartbeats(hb);
+                }).catch(() => {});
+              }, 500);
+            }
+          }
+        } catch {}
+      };
+      es.onerror = () => {
+        setConnected(false);
+        setSseConnected(false);
+        es.close();
+        esRef.current = null;
+        if (retryRef.current < MAX_RETRIES) {
+          const delay = Math.min(BASE_DELAY * Math.pow(2, retryRef.current), MAX_DELAY);
+          retryRef.current++;
+          timeoutRef.current = setTimeout(connect, delay);
+        }
+      };
+    }
+    connect();
+    return () => {
+      if (timeoutRef.current)
+        clearTimeout(timeoutRef.current);
+      if (hbTimerRef.current)
+        clearTimeout(hbTimerRef.current);
+      esRef.current?.close();
+      esRef.current = null;
+    };
+  }, [updateFile, setConnected, setHeartbeats, initialize, appendAuditEntry, appendActivityEvent, setSseConnected, bumpTaskboard, setReindexProgress]);
+}
+// src/hooks/use-toast.ts
+var DEFAULT_DURATION = {
+  success: 4000,
+  info: 4000,
+  error: 1e4
+};
+var counter = 0;
+var useToastStore = create((set) => ({
+  toasts: [],
+  add: (toast) => {
+    const id = String(++counter);
+    set((s) => ({ toasts: [...s.toasts, { ...toast, id }] }));
+    setTimeout(() => {
+      set((s) => ({ toasts: s.toasts.filter((t) => t.id !== id) }));
+    }, toast.duration ?? DEFAULT_DURATION[toast.type]);
+  },
+  dismiss: (id) => set((s) => ({ toasts: s.toasts.filter((t) => t.id !== id) }))
+}));
+function toast(message, type = "info", duration) {
+  useToastStore.getState().add({ message, type, ...duration ? { duration } : {} });
+}
+// src/hooks/use-vertical-resize.ts
+import { useCallback as useCallback6, useEffect as useEffect8, useRef as useRef6, useState as useState6 } from "react";
+"use client";
+var STORAGE_PREFIX = "bakin-vresize:";
+function clamp(n, min, max) {
+  return Math.min(max, Math.max(min, n));
+}
+function readStored(defaultHeight, min, max, storageKey) {
+  if (!storageKey || typeof window === "undefined")
+    return clamp(defaultHeight, min, max);
+  try {
+    const raw = window.localStorage.getItem(STORAGE_PREFIX + storageKey);
+    if (!raw)
+      return clamp(defaultHeight, min, max);
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) ? clamp(parsed, min, max) : clamp(defaultHeight, min, max);
+  } catch {
+    return clamp(defaultHeight, min, max);
+  }
+}
+function useVerticalResize({ defaultHeight, minHeight, maxHeight, storageKey }) {
+  const [height, setHeightState] = useState6(() => readStored(defaultHeight, minHeight, maxHeight, storageKey));
+  const heightRef = useRef6(height);
+  const dragging = useRef6(false);
+  const startY = useRef6(0);
+  const startHeight = useRef6(0);
+  useEffect8(() => {
+    heightRef.current = height;
+  }, [height]);
+  const persist = useCallback6((h) => {
+    if (!storageKey || typeof window === "undefined")
+      return;
+    try {
+      window.localStorage.setItem(STORAGE_PREFIX + storageKey, String(clamp(h, minHeight, maxHeight)));
+    } catch {}
+  }, [storageKey, minHeight, maxHeight]);
+  const setHeight = useCallback6((h) => {
+    const next = clamp(h, minHeight, maxHeight);
+    heightRef.current = next;
+    setHeightState(next);
+    persist(next);
+  }, [minHeight, maxHeight, persist]);
+  const beginDrag = useCallback6((clientY) => {
+    dragging.current = true;
+    startY.current = clientY;
+    startHeight.current = heightRef.current;
+  }, []);
+  const onMove = useCallback6((clientY) => {
+    if (!dragging.current)
+      return;
+    const delta = startY.current - clientY;
+    const next = clamp(startHeight.current + delta, minHeight, maxHeight);
+    heightRef.current = next;
+    setHeightState(next);
+  }, [minHeight, maxHeight]);
+  const endDrag = useCallback6(() => {
+    if (!dragging.current)
+      return;
+    dragging.current = false;
+    persist(heightRef.current);
+    document.body.style.cursor = "";
+    document.body.style.userSelect = "";
+  }, [persist]);
+  const onMouseDown = useCallback6((e) => {
+    e.preventDefault();
+    beginDrag(e.clientY);
+    const move = (ev) => onMove(ev.clientY);
+    const up = () => {
+      document.removeEventListener("mousemove", move);
+      document.removeEventListener("mouseup", up);
+      endDrag();
+    };
+    document.addEventListener("mousemove", move);
+    document.addEventListener("mouseup", up);
+    document.body.style.cursor = "row-resize";
+    document.body.style.userSelect = "none";
+  }, [beginDrag, onMove, endDrag]);
+  const onTouchStart = useCallback6((e) => {
+    const touch = e.touches[0];
+    if (!touch)
+      return;
+    beginDrag(touch.clientY);
+    const move = (ev) => {
+      const t = ev.touches[0];
+      if (t)
+        onMove(t.clientY);
+    };
+    const up = () => {
+      document.removeEventListener("touchmove", move);
+      document.removeEventListener("touchend", up);
+      document.removeEventListener("touchcancel", up);
+      endDrag();
+    };
+    document.addEventListener("touchmove", move);
+    document.addEventListener("touchend", up);
+    document.addEventListener("touchcancel", up);
+  }, [beginDrag, onMove, endDrag]);
+  return {
+    height,
+    setHeight,
+    handleProps: { onMouseDown, onTouchStart }
+  };
+}
+// plugins/team/hooks/use-agent-store.ts
+"use client";
+async function parsePackageStatesResponse(res) {
+  if (!res || !res.ok)
+    return {};
+  try {
+    const body = await res.json();
+    if (!body.ok || !Array.isArray(body.agents))
+      return {};
+    const map = {};
+    for (const row of body.agents) {
+      map[row.agentId] = row;
+    }
+    return map;
+  } catch {
+    return {};
+  }
+}
+var useAgentStore = create((set, get) => ({
+  agents: [],
+  agentIds: [],
+  agentMap: {},
+  agentsWithStatus: [],
+  displaySettings: {},
+  teams: [],
+  packageStates: {},
+  mainAgentId: null,
+  loaded: false,
+  load: async () => {
+    try {
+      const [rosterRes, pkgRes] = await Promise.all([
+        fetch("/api/plugins/team/"),
+        fetch("/api/agent-packages").catch(() => null)
+      ]);
+      if (!rosterRes.ok) {
+        set({ loaded: true });
+        return;
+      }
+      const data = await rosterRes.json();
+      const agents = data.agents.map(({
+        status: _status,
+        heartbeat: _heartbeat,
+        heartbeatAge: _heartbeatAge,
+        model: _model,
+        ...meta
+      }) => meta);
+      const agentMap = {};
+      for (const a of agents) {
+        agentMap[a.id] = a;
+      }
+      const packageStates = await parsePackageStatesResponse(pkgRes);
+      set({
+        agents,
+        agentIds: agents.map((a) => a.id),
+        agentMap,
+        agentsWithStatus: data.agents,
+        displaySettings: data.displaySettings,
+        teams: data.teams ?? [],
+        packageStates,
+        mainAgentId: data.mainAgentId ?? null,
+        loaded: true
+      });
+    } catch {
+      set({ loaded: true });
+    }
+  },
+  refreshPackageStates: async () => {
+    const res = await fetch("/api/agent-packages").catch(() => null);
+    const packageStates = await parsePackageStatesResponse(res);
+    set({ packageStates });
+  },
+  updateDisplay: async (agentId, patch) => {
+    const current = get().displaySettings;
+    const updated = {
+      ...current,
+      [agentId]: { ...current[agentId], ...patch }
+    };
+    set({ displaySettings: updated });
+    await fetch("/api/plugins/team/settings", {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(updated)
+    });
+  }
+}));
+function useAgent(agentId) {
+  return useAgentStore((s) => s.agentMap[agentId]);
+}
+function useAgentList() {
+  return useAgentStore((s) => s.agents);
+}
+function useAgentColor(agentId) {
+  return useAgentStore((s) => s.displaySettings[agentId]?.accentColor ?? "#a1a1aa");
+}
+function usePackageState(agentId) {
+  return useAgentStore((s) => s.packageStates?.[agentId]);
+}
+function useAgentDisplayName(agentId) {
+  return useAgentStore((s) => s.displaySettings[agentId]?.displayName);
+}
+function useAgentIds() {
+  return useAgentStore((s) => s.agentIds);
+}
+function useMainAgentId() {
+  return useAgentStore((s) => s.mainAgentId);
+}
+function hexToMuted(hex, opacity = 0.2) {
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  return `rgba(${r}, ${g}, ${b}, ${opacity})`;
+}
+// plugins/workflows/hooks/use-notification-channels.ts
+import { useEffect as useEffect9, useState as useState7 } from "react";
+"use client";
+var cached = null;
+var inFlight = null;
+function fetchChannels() {
+  if (cached)
+    return Promise.resolve(cached);
+  if (inFlight)
+    return inFlight;
+  inFlight = fetch("/api/plugins/workflows/notification-channels").then((r) => r.ok ? r.json() : null).then((data) => {
+    const list = data && Array.isArray(data.channels) ? data.channels : [];
+    cached = list;
+    return list;
+  }).catch(() => {
+    cached = [];
+    return [];
+  }).finally(() => {
+    inFlight = null;
+  });
+  return inFlight;
+}
+function useNotificationChannels() {
+  const [channels, setChannels] = useState7(() => cached ?? []);
+  useEffect9(() => {
+    if (cached)
+      return;
+    let cancelled = false;
+    fetchChannels().then((list) => {
+      if (!cancelled)
+        setChannels(list);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  return channels;
+}
+function getChannelLabel(id, channels) {
+  return channels.find((c) => c.id === id)?.label ?? id;
+}
+function getChannelInitials(id, channels) {
+  const match = channels.find((c) => c.id === id);
+  if (match?.initials)
+    return match.initials;
+  return id.slice(0, 2).toUpperCase();
+}
+// node_modules/.bun/@tanstack+react-router@1.168.23+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/matchContext.js
+import * as React$1 from "react";
+"use client";
+var matchContext = React$1.createContext(undefined);
+var dummyMatchContext = React$1.createContext(undefined);
+
+// node_modules/.bun/@tanstack+react-router@1.168.23+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/routerContext.js
+import * as React$12 from "react";
+"use client";
+var routerContext = React$12.createContext(null);
+
+// node_modules/.bun/@tanstack+react-router@1.168.23+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/useRouter.js
+import * as React$13 from "react";
+"use client";
+function useRouter2(opts) {
+  const value = React$13.useContext(routerContext);
+  if (true) {
+    if ((opts?.warn ?? true) && !value)
+      console.warn("Warning: useRouter must be used inside a <RouterProvider> component!");
+  }
+  return value;
+}
+
+// node_modules/.bun/@tanstack+router-core@1.168.15/node_modules/@tanstack/router-core/dist/esm/isServer/development.js
+var isServer = undefined;
+
+// node_modules/.bun/@tanstack+router-core@1.168.15/node_modules/@tanstack/router-core/dist/esm/utils.js
+var hasOwn = Object.prototype.hasOwnProperty;
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+function replaceEqualDeep(prev, _next, _makeObj = () => ({}), _depth = 0) {
+  if (isServer)
+    return _next;
+  if (prev === _next)
+    return prev;
+  if (_depth > 500)
+    return _next;
+  const next = _next;
+  const array = isPlainArray(prev) && isPlainArray(next);
+  if (!array && !(isPlainObject(prev) && isPlainObject(next)))
+    return next;
+  const prevItems = array ? prev : getEnumerableOwnKeys(prev);
+  if (!prevItems)
+    return next;
+  const nextItems = array ? next : getEnumerableOwnKeys(next);
+  if (!nextItems)
+    return next;
+  const prevSize = prevItems.length;
+  const nextSize = nextItems.length;
+  const copy = array ? new Array(nextSize) : _makeObj();
+  let equalItems = 0;
+  for (let i = 0;i < nextSize; i++) {
+    const key = array ? i : nextItems[i];
+    const p = prev[key];
+    const n = next[key];
+    if (p === n) {
+      copy[key] = p;
+      if (array ? i < prevSize : hasOwn.call(prev, key))
+        equalItems++;
+      continue;
+    }
+    if (p === null || n === null || typeof p !== "object" || typeof n !== "object") {
+      copy[key] = n;
+      continue;
+    }
+    const v = replaceEqualDeep(p, n, _makeObj, _depth + 1);
+    copy[key] = v;
+    if (v === p)
+      equalItems++;
+  }
+  return prevSize === nextSize && equalItems === prevSize ? prev : copy;
+}
+function getEnumerableOwnKeys(o) {
+  const names = Object.getOwnPropertyNames(o);
+  for (const name of names)
+    if (!isEnumerable.call(o, name))
+      return false;
+  const symbols = Object.getOwnPropertySymbols(o);
+  if (symbols.length === 0)
+    return names;
+  const keys = names;
+  for (const symbol of symbols) {
+    if (!isEnumerable.call(o, symbol))
+      return false;
+    keys.push(symbol);
+  }
+  return keys;
+}
+function isPlainObject(o) {
+  if (!hasObjectPrototype(o))
+    return false;
+  const ctor = o.constructor;
+  if (typeof ctor === "undefined")
+    return true;
+  const prot = ctor.prototype;
+  if (!hasObjectPrototype(prot))
+    return false;
+  if (!prot.hasOwnProperty("isPrototypeOf"))
+    return false;
+  return true;
+}
+function hasObjectPrototype(o) {
+  return Object.prototype.toString.call(o) === "[object Object]";
+}
+function isPlainArray(value) {
+  return Array.isArray(value) && value.length === Object.keys(value).length;
+}
+
+// node_modules/.bun/@tanstack+router-core@1.168.15/node_modules/@tanstack/router-core/dist/esm/invariant.js
+function invariant() {
+  throw new Error("Invariant failed");
+}
+// node_modules/.bun/@tanstack+react-router@1.168.23+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/useMatch.js
+import * as React$14 from "react";
+// node_modules/.bun/@tanstack+react-store@0.9.3+bf16f8eded5e12ee/node_modules/@tanstack/react-store/dist/esm/useStore.js
+var import_with_selector = __toESM(require_with_selector(), 1);
+import { useCallback as useCallback7 } from "react";
+function defaultCompare(a, b) {
+  return a === b;
+}
+function useStore2(atom, selector, compare = defaultCompare) {
+  const subscribe = useCallback7((handleStoreChange) => {
+    if (!atom) {
+      return () => {};
+    }
+    const { unsubscribe } = atom.subscribe(handleStoreChange);
+    return unsubscribe;
+  }, [atom]);
+  const boundGetSnapshot = useCallback7(() => atom?.get(), [atom]);
+  const selectedSnapshot = import_with_selector.useSyncExternalStoreWithSelector(subscribe, boundGetSnapshot, boundGetSnapshot, selector, compare);
+  return selectedSnapshot;
+}
+
+// node_modules/.bun/@tanstack+react-router@1.168.23+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/useMatch.js
+"use client";
+var dummyStore = {
+  get: () => {
+    return;
+  },
+  subscribe: () => ({ unsubscribe: () => {} })
+};
+function useMatch(opts) {
+  const router = useRouter2();
+  const nearestMatchId = React$14.useContext(opts.from ? dummyMatchContext : matchContext);
+  const key = opts.from ?? nearestMatchId;
+  const matchStore = key ? opts.from ? router.stores.getRouteMatchStore(key) : router.stores.matchStores.get(key) : undefined;
+  if (isServer ?? router.isServer) {
+    const match = matchStore?.get();
+    if ((opts.shouldThrow ?? true) && !match) {
+      if (true)
+        throw new Error(`Invariant failed: Could not find ${opts.from ? `an active match from "${opts.from}"` : "a nearest match!"}`);
+      invariant();
+    }
+    if (match === undefined)
+      return;
+    return opts.select ? opts.select(match) : match;
+  }
+  const previousResult = React$14.useRef(undefined);
+  return useStore2(matchStore ?? dummyStore, (match) => {
+    if ((opts.shouldThrow ?? true) && !match) {
+      if (true)
+        throw new Error(`Invariant failed: Could not find ${opts.from ? `an active match from "${opts.from}"` : "a nearest match!"}`);
+      invariant();
+    }
+    if (match === undefined)
+      return;
+    const selected = opts.select ? opts.select(match) : match;
+    if (opts.structuralSharing ?? router.options.defaultStructuralSharing) {
+      const shared = replaceEqualDeep(previousResult.current, selected);
+      previousResult.current = shared;
+      return shared;
+    }
+    return selected;
+  });
+}
+
+// node_modules/.bun/@tanstack+react-router@1.168.23+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/useParams.js
+function useParams(opts) {
+  return useMatch({
+    from: opts.from,
+    shouldThrow: opts.shouldThrow,
+    structuralSharing: opts.structuralSharing,
+    strict: opts.strict,
+    select: (match) => {
+      const params = opts.strict === false ? match.params : match._strictParams;
+      return opts.select ? opts.select(params) : params;
+    }
+  });
+}
+// node_modules/.bun/@tanstack+react-router@1.168.23+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/useNavigate.js
+import * as React$15 from "react";
+"use client";
+function useNavigate(_defaultOpts) {
+  const router = useRouter2();
+  return React$15.useCallback((options) => {
+    return router.navigate({
+      ...options,
+      from: options.from ?? _defaultOpts?.from
+    });
+  }, [_defaultOpts?.from, router]);
+}
+// node_modules/.bun/@tanstack+react-router@1.168.23+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/useLocation.js
+import { useRef as useRef9 } from "react";
+function useLocation(opts) {
+  const router = useRouter2();
+  if (isServer ?? router.isServer) {
+    const location = router.stores.location.get();
+    return opts?.select ? opts.select(location) : location;
+  }
+  const previousResult = useRef9(undefined);
+  return useStore2(router.stores.location, (location) => {
+    const selected = opts?.select ? opts.select(location) : location;
+    if (opts?.structuralSharing ?? router.options.defaultStructuralSharing) {
+      const shared = replaceEqualDeep(previousResult.current, selected);
+      previousResult.current = shared;
+      return shared;
+    }
+    return selected;
+  });
+}
+
+// node_modules/.bun/@tanstack+react-router@1.168.23+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/index.dev.js
+"use client";
+
+// packages/sdk/src/hooks/router.ts
+import { useMemo as useMemo2 } from "react";
+function useRouter() {
+  const navigate = useNavigate();
+  return useMemo2(() => ({
+    push: (url) => {
+      navigate({ to: url });
+    },
+    replace: (url) => {
+      navigate({ to: url, replace: true });
+    },
+    back: () => {
+      if (typeof window !== "undefined")
+        window.history.back();
+    },
+    forward: () => {
+      if (typeof window !== "undefined")
+        window.history.forward();
+    },
+    refresh: () => {
+      if (typeof window !== "undefined")
+        window.location.reload();
+    },
+    prefetch: () => {}
+  }), [navigate]);
+}
+function usePathname() {
+  const location = useLocation();
+  return location.pathname;
+}
+function useSearchParams() {
+  const location = useLocation();
+  return useMemo2(() => {
+    const search = location.searchStr;
+    if (typeof search === "string") {
+      return new URLSearchParams(search.startsWith("?") ? search.slice(1) : search);
+    }
+    const parsed = location.search;
+    if (parsed && typeof parsed === "object") {
+      const params = new URLSearchParams;
+      for (const [k, v] of Object.entries(parsed)) {
+        if (v === undefined || v === null)
+          continue;
+        params.set(k, String(v));
+      }
+      return params;
+    }
+    return new URLSearchParams;
+  }, [location]);
+}
+function useParams2() {
+  return useParams({ strict: false });
+}
+export {
+  useVerticalResize,
+  useTrash,
+  useToastStore,
+  useSidebar,
+  useSearchParams,
+  useSearch,
+  useScheduleJobs,
+  useSSE,
+  useRuntimeStatus,
+  useRunHistory,
+  useRouter,
+  useQueryState,
+  useQueryArrayState,
+  usePathname,
+  useParams2 as useParams,
+  usePackageState,
+  useNotificationChannels,
+  useMainAgentId,
+  useFormGuard,
+  useDebug,
+  useContentStore,
+  useAssets,
+  useAgentStore,
+  useAgentList,
+  useAgentIds,
+  useAgentDisplayName,
+  useAgentColor,
+  useAgent,
+  toast,
+  reorderBySearchResults,
+  hexToMuted,
+  getChannelLabel,
+  getChannelInitials
+};