@heretek-ai/epistemic-swarm 1.0.2 → 1.0.4

package/dist/tui.js

@@ -0,0 +1,802 @@
+// @bun
+// src/tui.tsx
+import { userInfo } from "os";
+import { Plugin } from "@opencode/plugin/tui";
+
+// src/panels.tsx
+import { memo as _$memo } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { createTextNode as _$createTextNode } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+import { createResource, createSignal, For, onCleanup, Show } from "solid-js";
+var PANEL_REFRESH_MS = 2000;
+function usePanelState(props, method) {
+  const [version, setVersion] = createSignal(0);
+  const bump = () => setVersion((value) => value + 1);
+  const unsubscribe = props.subscribe(bump);
+  const timer = setInterval(bump, PANEL_REFRESH_MS);
+  onCleanup(() => {
+    unsubscribe();
+    clearInterval(timer);
+  });
+  const [state] = createResource(version, () => props.call(method).then((data) => ({
+    data
+  }), (error) => ({
+    error: String(error?.data?.reason ?? error?.message ?? error)
+  })));
+  return {
+    data: () => state.latest?.data,
+    error: () => state.latest?.error
+  };
+}
+var Frame = (props) => (() => {
+  var _el$ = _$createElement("box"), _el$2 = _$createElement("text");
+  _$insertNode(_el$, _el$2);
+  _$setProp(_el$, "flexDirection", "column");
+  _$setProp(_el$, "padding", 1);
+  _$setProp(_el$, "gap", 1);
+  _$insert(_el$2, () => props.title);
+  _$insert(_el$, () => props.children, null);
+  return _el$;
+})();
+var Failed = (props) => _$createComponent(Show, {
+  get when() {
+    return props.error();
+  },
+  get children() {
+    var _el$3 = _$createElement("text"), _el$4 = _$createTextNode(`Could not load: `);
+    _$insertNode(_el$3, _el$4);
+    _$insert(_el$3, () => props.error(), null);
+    return _el$3;
+  }
+});
+var FactoryPanel = (props) => {
+  const state = usePanelState(props, "factoryState");
+  return _$createComponent(Frame, {
+    title: "Factory dashboard",
+    get children() {
+      return [_$createComponent(Failed, {
+        get error() {
+          return state.error;
+        }
+      }), _$createComponent(Show, {
+        get when() {
+          return state.data();
+        },
+        get fallback() {
+          return (() => {
+            var _el$5 = _$createElement("text");
+            _$insert(_el$5, () => state.error() ? "" : "Loading factory state\u2026");
+            return _el$5;
+          })();
+        },
+        children: (data) => [(() => {
+          var _el$6 = _$createElement("text"), _el$7 = _$createTextNode(`Stage: `);
+          _$insertNode(_el$6, _el$7);
+          _$insert(_el$6, () => data().stage, null);
+          _$insert(_el$6, (() => {
+            var _c$ = _$memo(() => !!data().runId);
+            return () => _c$() ? ` \xB7 ${data().runId}` : "";
+          })(), null);
+          return _el$6;
+        })(), (() => {
+          var _el$8 = _$createElement("text"), _el$9 = _$createTextNode(`Spend: $`);
+          _$insertNode(_el$8, _el$9);
+          _$insert(_el$8, () => data().spend.usd.toFixed(2), null);
+          _$insert(_el$8, (() => {
+            var _c$2 = _$memo(() => !!data().spend.ceilingUSD);
+            return () => _c$2() ? ` / $${data().spend.ceilingUSD}` : "";
+          })(), null);
+          _$insert(_el$8, () => data().spend.estimated ? " (estimated)" : "", null);
+          return _el$8;
+        })(), _$createComponent(Show, {
+          get when() {
+            return data().halt;
+          },
+          get children() {
+            var _el$0 = _$createElement("text"), _el$1 = _$createTextNode(`HALTED: `);
+            _$insertNode(_el$0, _el$1);
+            _$insert(_el$0, () => data().halt, null);
+            return _el$0;
+          }
+        }), _$createComponent(Show, {
+          get when() {
+            return data().release;
+          },
+          get children() {
+            var _el$10 = _$createElement("text"), _el$11 = _$createTextNode(`PR: `);
+            _$insertNode(_el$10, _el$11);
+            _$insert(_el$10, () => data().release, null);
+            return _el$10;
+          }
+        }), _$createComponent(Show, {
+          get when() {
+            return data().pending.length;
+          },
+          get children() {
+            var _el$12 = _$createElement("text"), _el$13 = _$createTextNode(`Waiting on human: `);
+            _$insertNode(_el$12, _el$13);
+            _$insert(_el$12, () => data().pending.join(", "), null);
+            return _el$12;
+          }
+        }), (() => {
+          var _el$14 = _$createElement("text");
+          _$insertNode(_el$14, _$createTextNode(`Phases:`));
+          return _el$14;
+        })(), _$createComponent(For, {
+          get each() {
+            return data().phases;
+          },
+          children: (phase) => (() => {
+            var _el$16 = _$createElement("text"), _el$17 = _$createTextNode(` \xB7 `), _el$18 = _$createTextNode(` \xB7 failures `);
+            _$insertNode(_el$16, _el$17);
+            _$insertNode(_el$16, _el$18);
+            _$insert(_el$16, () => phase.id === data().activePhase ? "\u25B6 " : "  ", _el$17);
+            _$insert(_el$16, () => phase.id, _el$17);
+            _$insert(_el$16, () => phase.status, _el$18);
+            _$insert(_el$16, () => phase.failures, null);
+            return _el$16;
+          })()
+        })]
+      })];
+    }
+  });
+};
+var LspPanel = (props) => {
+  const state = usePanelState(props, "lspState");
+  return _$createComponent(Frame, {
+    title: "Language servers",
+    get children() {
+      return [_$createComponent(Failed, {
+        get error() {
+          return state.error;
+        }
+      }), _$createComponent(Show, {
+        get when() {
+          return state.data();
+        },
+        get fallback() {
+          return (() => {
+            var _el$19 = _$createElement("text");
+            _$insert(_el$19, () => state.error() ? "" : "Loading language servers\u2026");
+            return _el$19;
+          })();
+        },
+        children: (data) => [(() => {
+          var _el$20 = _$createElement("text");
+          _$insert(_el$20, () => data().enabled ? "LSP is on." : "LSP is disabled (lsp: false).");
+          return _el$20;
+        })(), _$createComponent(For, {
+          get each() {
+            return data().servers;
+          },
+          children: (server) => (() => {
+            var _el$21 = _$createElement("text"), _el$22 = _$createTextNode(` `), _el$23 = _$createTextNode(` [`), _el$24 = _$createTextNode(`]`);
+            _$insertNode(_el$21, _el$22);
+            _$insertNode(_el$21, _el$23);
+            _$insertNode(_el$21, _el$24);
+            _$insert(_el$21, () => server.available ? "\u25CF" : "\u25CB", _el$22);
+            _$insert(_el$21, () => server.id, _el$23);
+            _$insert(_el$21, () => server.extensions.join(" "), _el$24);
+            _$insert(_el$21, (() => {
+              var _c$3 = _$memo(() => !!server.running);
+              return () => _c$3() ? ` \xB7 ${server.running} running` : "";
+            })(), null);
+            _$insert(_el$21, () => server.available ? "" : " \u2014 not installed", null);
+            return _el$21;
+          })()
+        }), _$createComponent(For, {
+          get each() {
+            return data().diagnostics;
+          },
+          children: (diagnostic) => (() => {
+            var _el$25 = _$createElement("text"), _el$26 = _$createTextNode(`! `);
+            _$insertNode(_el$25, _el$26);
+            _$insert(_el$25, diagnostic, null);
+            return _el$25;
+          })()
+        })]
+      })];
+    }
+  });
+};
+var HooksPanel = (props) => {
+  const state = usePanelState(props, "hooksState");
+  return _$createComponent(Frame, {
+    title: "Hook bridge",
+    get children() {
+      return [_$createComponent(Failed, {
+        get error() {
+          return state.error;
+        }
+      }), _$createComponent(Show, {
+        get when() {
+          return state.data();
+        },
+        get fallback() {
+          return (() => {
+            var _el$27 = _$createElement("text");
+            _$insert(_el$27, () => state.error() ? "" : "Loading hooks\u2026");
+            return _el$27;
+          })();
+        },
+        children: (data) => [(() => {
+          var _el$28 = _$createElement("text"), _el$29 = _$createTextNode(` handler(s) \xB7 `), _el$30 = _$createTextNode(` from the project \xB7 `);
+          _$insertNode(_el$28, _el$29);
+          _$insertNode(_el$28, _el$30);
+          _$insert(_el$28, () => data().handlers, _el$29);
+          _$insert(_el$28, () => data().projectHandlers, _el$30);
+          _$insert(_el$28, (() => {
+            var _c$4 = _$memo(() => data().projectHandlers === 0);
+            return () => _c$4() ? "nothing to trust" : data().trusted ? "trusted" : "NOT trusted";
+          })(), null);
+          return _el$28;
+        })(), _$createComponent(For, {
+          get each() {
+            return data().projectLines;
+          },
+          children: (line) => (() => {
+            var _el$34 = _$createElement("text");
+            _$insert(_el$34, line);
+            return _el$34;
+          })()
+        }), _$createComponent(Show, {
+          get when() {
+            return data().loss.length;
+          },
+          get children() {
+            return [(() => {
+              var _el$32 = _$createElement("text");
+              _$insertNode(_el$32, _$createTextNode(`Capability loss (advisory rows):`));
+              return _el$32;
+            })(), _$createComponent(For, {
+              get each() {
+                return data().loss;
+              },
+              children: (item) => (() => {
+                var _el$35 = _$createElement("text"), _el$36 = _$createTextNode(`! `), _el$37 = _$createTextNode(` \xB7 `), _el$38 = _$createTextNode(` \u2014 `), _el$39 = _$createTextNode(`: `);
+                _$insertNode(_el$35, _el$36);
+                _$insertNode(_el$35, _el$37);
+                _$insertNode(_el$35, _el$38);
+                _$insertNode(_el$35, _el$39);
+                _$insert(_el$35, () => item.event, _el$37);
+                _$insert(_el$35, () => item.handler, _el$38);
+                _$insert(_el$35, () => item.support, _el$39);
+                _$insert(_el$35, () => item.reason, null);
+                return _el$35;
+              })()
+            })];
+          }
+        }), _$createComponent(For, {
+          get each() {
+            return data().diagnostics;
+          },
+          children: (item) => (() => {
+            var _el$40 = _$createElement("text"), _el$41 = _$createTextNode(`! `);
+            _$insertNode(_el$40, _el$41);
+            _$insert(_el$40, item, null);
+            return _el$40;
+          })()
+        }), _$createComponent(For, {
+          get each() {
+            return data().recent;
+          },
+          children: (item) => (() => {
+            var _el$42 = _$createElement("text"), _el$43 = _$createTextNode(`recent error: `);
+            _$insertNode(_el$42, _el$43);
+            _$insert(_el$42, item, null);
+            return _el$42;
+          })()
+        })]
+      })];
+    }
+  });
+};
+var BrainstormPanel = (props) => {
+  const state = usePanelState(props, "brainstormState");
+  return _$createComponent(Frame, {
+    title: "Brainstorm board",
+    get children() {
+      return [_$createComponent(Failed, {
+        get error() {
+          return state.error;
+        }
+      }), _$createComponent(Show, {
+        get when() {
+          return state.data();
+        },
+        get fallback() {
+          return (() => {
+            var _el$44 = _$createElement("text");
+            _$insert(_el$44, () => state.error() ? "" : "Loading brainstorm\u2026");
+            return _el$44;
+          })();
+        },
+        children: (data) => _$createComponent(Show, {
+          get when() {
+            return data().active;
+          },
+          get fallback() {
+            return (() => {
+              var _el$59 = _$createElement("text");
+              _$insertNode(_el$59, _$createTextNode(`No brainstorm in .factory/brainstorm yet. Run /brainstorm.`));
+              return _el$59;
+            })();
+          },
+          get children() {
+            return [(() => {
+              var _el$45 = _$createElement("text"), _el$46 = _$createTextNode(`Brief: `);
+              _$insertNode(_el$45, _el$46);
+              _$insert(_el$45, () => data().brief, null);
+              return _el$45;
+            })(), (() => {
+              var _el$47 = _$createElement("text"), _el$48 = _$createTextNode(` idea(s) \xB7 `), _el$49 = _$createTextNode(` duplicate(s) \xB7 `), _el$50 = _$createTextNode(` scored \xB7 `);
+              _$insertNode(_el$47, _el$48);
+              _$insertNode(_el$47, _el$49);
+              _$insertNode(_el$47, _el$50);
+              _$insert(_el$47, () => data().ideas, _el$48);
+              _$insert(_el$47, () => data().duplicates, _el$49);
+              _$insert(_el$47, () => data().scored, _el$50);
+              _$insert(_el$47, () => data().complete ? "complete" : "in progress", null);
+              return _el$47;
+            })(), (() => {
+              var _el$52 = _$createElement("text"), _el$53 = _$createTextNode(`Coverage: `);
+              _$insertNode(_el$52, _el$53);
+              _$insert(_el$52, () => data().lenses.map((lens) => `${lens} ${data().coverage[lens] ?? 0}`).join(" \xB7 "), null);
+              return _el$52;
+            })(), _$createComponent(Show, {
+              get when() {
+                return data().gaps.length;
+              },
+              get children() {
+                var _el$55 = _$createElement("text"), _el$56 = _$createTextNode(`Gaps: `);
+                _$insertNode(_el$55, _el$56);
+                _$insert(_el$55, () => data().gaps.join(", "), null);
+                return _el$55;
+              }
+            }), _$createComponent(Show, {
+              get when() {
+                return data().shortlist.length;
+              },
+              get children() {
+                return [(() => {
+                  var _el$57 = _$createElement("text");
+                  _$insertNode(_el$57, _$createTextNode(`Shortlist:`));
+                  return _el$57;
+                })(), _$createComponent(For, {
+                  get each() {
+                    return data().shortlist;
+                  },
+                  children: (entry) => (() => {
+                    var _el$61 = _$createElement("text"), _el$62 = _$createTextNode(` `), _el$63 = _$createTextNode(` (`), _el$64 = _$createTextNode(`/20) \u2014 `);
+                    _$insertNode(_el$61, _el$62);
+                    _$insertNode(_el$61, _el$63);
+                    _$insertNode(_el$61, _el$64);
+                    _$insert(_el$61, () => entry.outlier ? "\u25C7" : "\u25C6", _el$62);
+                    _$insert(_el$61, () => entry.id, _el$63);
+                    _$insert(_el$61, () => entry.total, _el$64);
+                    _$insert(_el$61, () => entry.title, null);
+                    _$insert(_el$61, () => entry.outlier ? " (forced outlier)" : "", null);
+                    return _el$61;
+                  })()
+                })];
+              }
+            })];
+          }
+        })
+      })];
+    }
+  });
+};
+var PANEL_COMPONENTS = {
+  factory: FactoryPanel,
+  lsp: LspPanel,
+  hooks: HooksPanel,
+  brainstorm: BrainstormPanel
+};
+var PANELS = Object.entries(PANEL_COMPONENTS).map(([name, Panel]) => ({
+  name,
+  render: (props) => _$createComponent(Panel, {
+    get call() {
+      return props.call;
+    },
+    get subscribe() {
+      return props.subscribe;
+    }
+  })
+}));
+function registerPanels(context, call, subscribe) {
+  const slotFn = typeof context.slot === "function" ? context.slot : context.ui?.slot;
+  if (typeof slotFn !== "function")
+    return () => {};
+  const disposers = [];
+  for (const panel of PANELS) {
+    const render = (input) => input.name === panel.name ? panel.render({
+      call,
+      subscribe
+    }) : null;
+    const dispose = slotFn.length <= 1 ? slotFn({
+      append: "session.panel",
+      render
+    }) : slotFn("session.panel", render);
+    if (typeof dispose === "function")
+      disposers.push(dispose);
+  }
+  return () => {
+    for (const dispose of disposers)
+      dispose();
+  };
+}
+var PANEL_NAMES = PANELS.map((panel) => panel.name);
+
+// ../../node_modules/.bun/@opencode+schema@2.0.24/node_modules/@opencode/schema/dist/rpc.js
+function define(definition) {
+  const reserved = Object.values(definition.methods).flatMap((method) => Object.keys(method.errors ?? {})).find((name) => name.startsWith("rpc."));
+  if (reserved)
+    throw new Error(`RPC error names starting with "rpc." are reserved: ${reserved}`);
+  return definition;
+}
+// src/rpc-def.ts
+var obj = (properties, required = []) => ({
+  type: "object",
+  properties,
+  required,
+  additionalProperties: false
+});
+var str = { type: "string" };
+var strArray = { type: "array", items: str };
+var Preview = obj({ ok: { type: "boolean" }, title: str, lines: strArray, problems: strArray, token: str }, [
+  "ok",
+  "title",
+  "lines",
+  "problems"
+]);
+var EsRpc = define({
+  id: "epistemic-swarm",
+  methods: {
+    status: {
+      input: obj({}),
+      output: obj({ summary: str, stage: str, pending: strArray }, ["summary", "stage", "pending"])
+    },
+    previewApproval: {
+      input: obj({ stage: { type: "string", enum: ["frontier", "spec"] } }, ["stage"]),
+      output: Preview
+    },
+    approve: {
+      input: obj({ stage: { type: "string", enum: ["frontier", "spec"] }, user: str, token: str }, [
+        "stage",
+        "user",
+        "token"
+      ]),
+      output: obj({ message: str }, ["message"]),
+      errors: { refused: obj({ reason: str }, ["reason"]) }
+    },
+    previewTrust: { input: obj({}), output: Preview },
+    trust: {
+      input: obj({ user: str, token: str }, ["user", "token"]),
+      output: obj({ message: str }, ["message"]),
+      errors: { refused: obj({ reason: str }, ["reason"]) }
+    },
+    previewResume: { input: obj({}), output: Preview },
+    previewLspInstall: { input: obj({ id: str }, ["id"]), output: Preview },
+    lspInstall: {
+      input: obj({ id: str, user: str, token: str }, ["id", "user", "token"]),
+      output: obj({ message: str }, ["message"]),
+      errors: { refused: obj({ reason: str }, ["reason"]) }
+    },
+    resume: {
+      input: obj({
+        user: str,
+        token: str,
+        acceptControlDrift: { type: "boolean" },
+        raiseCeilingUSD: { type: "number" },
+        extendRuntime: { type: "boolean" }
+      }, ["user", "token"]),
+      output: obj({ message: str }, ["message"]),
+      errors: { refused: obj({ reason: str }, ["reason"]) }
+    },
+    factoryState: {
+      input: obj({}),
+      output: obj({
+        stage: str,
+        runId: str,
+        halt: str,
+        release: str,
+        activePhase: str,
+        spend: obj({ usd: { type: "number" }, estimated: { type: "boolean" }, ceilingUSD: { type: "number" } }, [
+          "usd",
+          "estimated"
+        ]),
+        phases: { type: "array" },
+        pending: strArray
+      }, ["stage", "spend", "phases", "pending"])
+    },
+    lspState: {
+      input: obj({}),
+      output: obj({
+        enabled: { type: "boolean" },
+        servers: { type: "array" },
+        diagnostics: strArray
+      }, ["enabled", "servers", "diagnostics"])
+    },
+    hooksState: {
+      input: obj({}),
+      output: obj({
+        handlers: { type: "number" },
+        projectHandlers: { type: "number" },
+        trusted: { type: "boolean" },
+        projectLines: strArray,
+        diagnostics: strArray,
+        recent: strArray,
+        loss: { type: "array" }
+      }, ["handlers", "projectHandlers", "trusted", "projectLines", "diagnostics", "recent", "loss"])
+    },
+    brainstormState: {
+      input: obj({}),
+      output: obj({
+        active: { type: "boolean" },
+        brief: str,
+        lenses: strArray,
+        ideas: { type: "number" },
+        duplicates: { type: "number" },
+        scored: { type: "number" },
+        coverage: { type: "object" },
+        shortlist: { type: "array" },
+        gaps: strArray,
+        complete: { type: "boolean" }
+      }, ["active"])
+    }
+  },
+  events: {
+    changed: { schema: obj({ stage: str, summary: str }, ["stage", "summary"]) }
+  }
+});
+
+// src/tui.tsx
+var tui_default = Plugin.define({
+  id: "epistemic-swarm.tui",
+  setup(context) {
+    const rpc = context.client.rpc(EsRpc);
+    const location = () => context.location ?? context.data.location.default();
+    const call = (method, input = {}) => rpc[method](input, {
+      location: location()
+    });
+    const stopPanels = registerPanels(context, call, (listener) => rpc.events.on("changed", () => listener()));
+    const user = userInfo().username;
+    const toast = (message, variant = "info") => context.ui.toast.show({
+      title: "Epistemic Swarm",
+      message,
+      variant
+    });
+    const confirm = async (preview, label) => {
+      if (!preview.ok || !preview.token) {
+        await context.ui.dialog.alert({
+          title: preview.title,
+          message: [...preview.problems, ...preview.lines].join(`
+`)
+        });
+        return;
+      }
+      const ok = await context.ui.dialog.confirm({
+        title: preview.title,
+        message: preview.lines.join(`
+`),
+        label: {
+          confirm: label,
+          cancel: "Cancel"
+        }
+      });
+      return ok ? preview.token : undefined;
+    };
+    const guarded = (fn) => async (input) => {
+      try {
+        await fn(input);
+      } catch (error) {
+        toast(error?.data?.reason ?? error?.message ?? String(error), "error");
+      }
+    };
+    const approve = guarded(async (input) => {
+      const status = await call("status");
+      const stage = input?.trim() || (status.pending.length === 1 ? status.pending[0] : await context.ui.dialog.select({
+        title: "Approve which checkpoint?",
+        options: [{
+          title: "Frontier (design tree + spend ceiling)",
+          value: "frontier"
+        }, {
+          title: "Spec (roadmap + every GOAL.md)",
+          value: "spec"
+        }]
+      }));
+      if (stage !== "frontier" && stage !== "spec")
+        return;
+      const token = await confirm(await call("previewApproval", {
+        stage
+      }), "Approve");
+      if (!token)
+        return;
+      toast((await call("approve", {
+        stage,
+        user,
+        token
+      })).message, "success");
+    });
+    const trust = guarded(async () => {
+      const token = await confirm(await call("previewTrust"), "Trust");
+      if (!token)
+        return;
+      toast((await call("trust", {
+        user,
+        token
+      })).message, "success");
+    });
+    const resume = guarded(async () => {
+      const preview = await call("previewResume");
+      const token = await confirm(preview, "Resume");
+      if (!token)
+        return;
+      const drift = preview.lines.some((line) => line.startsWith("Control-file drift"));
+      let raiseCeilingUSD;
+      if (/spend ceiling/i.test(preview.lines[0] ?? "")) {
+        const raised = await context.ui.dialog.prompt({
+          title: "New spend ceiling (USD)",
+          placeholder: "e.g. 50"
+        });
+        raiseCeilingUSD = raised ? Number(raised) : undefined;
+      }
+      const extendRuntime = /runtime cap/i.test(preview.lines[0] ?? "");
+      const result = await call("resume", {
+        user,
+        token,
+        ...drift ? {
+          acceptControlDrift: true
+        } : {},
+        ...raiseCeilingUSD ? {
+          raiseCeilingUSD
+        } : {},
+        ...extendRuntime ? {
+          extendRuntime: true
+        } : {}
+      });
+      toast(result.message, "success");
+    });
+    const lspInstall = guarded(async (input) => {
+      const id = input?.trim() || await context.ui.dialog.prompt({
+        title: "Install which language server?",
+        placeholder: "typescript, pyright"
+      });
+      if (!id)
+        return;
+      const token = await confirm(await call("previewLspInstall", {
+        id
+      }), "Install");
+      if (!token)
+        return;
+      toast((await call("lspInstall", {
+        id,
+        user,
+        token
+      })).message, "success");
+    });
+    const status = guarded(async () => {
+      const result = await call("status");
+      await context.ui.dialog.alert({
+        title: "Factory",
+        message: result.summary.replace(/<\/?factory-state>/g, "").trim()
+      });
+    });
+    context.keymap.layer(() => ({
+      mode: "global",
+      commands: [{
+        id: "es.approve",
+        title: "Epistemic Swarm: approve a checkpoint",
+        group: "Epistemic Swarm",
+        palette: true,
+        slash: {
+          name: "es-approve",
+          arguments: true
+        },
+        run: approve
+      }, {
+        id: "es.trust",
+        title: "Epistemic Swarm: trust gate commands",
+        group: "Epistemic Swarm",
+        palette: true,
+        slash: {
+          name: "es-trust"
+        },
+        run: trust
+      }, {
+        id: "es.resume",
+        title: "Epistemic Swarm: resume a halted factory",
+        group: "Epistemic Swarm",
+        palette: true,
+        slash: {
+          name: "es-resume"
+        },
+        run: resume
+      }, {
+        id: "es.status",
+        title: "Epistemic Swarm: factory status",
+        group: "Epistemic Swarm",
+        palette: true,
+        slash: {
+          name: "es-status"
+        },
+        run: status
+      }, {
+        id: "es.lsp.install",
+        title: "Epistemic Swarm: install a language server",
+        group: "Epistemic Swarm",
+        palette: true,
+        slash: {
+          name: "es-lsp-install",
+          arguments: true
+        },
+        run: lspInstall
+      }, {
+        id: "es.panel.factory",
+        title: "Epistemic Swarm: factory dashboard",
+        group: "Epistemic Swarm",
+        palette: true,
+        slash: {
+          name: "es-factory"
+        },
+        run: () => {
+          context.ui.panel.open("factory", {
+            presentation: "fullscreen"
+          });
+        }
+      }, {
+        id: "es.panel.lsp",
+        title: "Epistemic Swarm: language server panel",
+        group: "Epistemic Swarm",
+        palette: true,
+        slash: {
+          name: "es-lsp-panel"
+        },
+        run: () => {
+          context.ui.panel.open("lsp", {
+            presentation: "fullscreen"
+          });
+        }
+      }, {
+        id: "es.panel.hooks",
+        title: "Epistemic Swarm: hook inspector",
+        group: "Epistemic Swarm",
+        palette: true,
+        slash: {
+          name: "es-hooks"
+        },
+        run: () => {
+          context.ui.panel.open("hooks", {
+            presentation: "fullscreen"
+          });
+        }
+      }, {
+        id: "es.panel.brainstorm",
+        title: "Epistemic Swarm: brainstorm board",
+        group: "Epistemic Swarm",
+        palette: true,
+        slash: {
+          name: "es-brainstorm"
+        },
+        run: () => {
+          context.ui.panel.open("brainstorm", {
+            presentation: "fullscreen"
+          });
+        }
+      }]
+    }));
+    const stop = rpc.events.on("changed", (event) => toast(`Factory \u2192 ${event.data.stage}`));
+    return () => {
+      stopPanels();
+      stop();
+    };
+  }
+});
+export {
+  tui_default as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heretek-ai/epistemic-swarm",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Epistemic Swarm: an AI build factory for OpenCode v2 — grill, research, spec, build, QA and release, gated mechanically.",
   "type": "module",
   "license": "Apache-2.0",
@@ -20,7 +20,7 @@
     },
     "./tui": {
       "types": "./tui.tsx",
-      "default": "./tui.tsx"
+      "default": "./dist/tui.js"
     },
     "./rpc": {
       "types": "./rpc.ts",
@@ -32,21 +32,26 @@
     "server.ts",
     "tui.tsx",
     "rpc.ts",
-    "src"
+    "src",
+    "dist"
   ],
   "scripts": {
-    "build": "tsc -b",
+    "build": "bun script/build-tui.ts",
+    "prepublishOnly": "bun run build",
     "test": "bun test"
   },
   "dependencies": {
-    "@heretek-ai/es-core": "1.0.2",
+    "@heretek-ai/es-core": "1.0.4",
     "@opencode/plugin": "2.0.24"
   },
   "devDependencies": {
+    "@babel/core": "7.28.0",
+    "@babel/preset-typescript": "7.27.1",
     "@heretek-ai/es-testkit": "1.0.0",
     "@opencode/sdk": "2.0.24",
     "@opentui/core": "0.5.14",
     "@opentui/solid": "0.5.14",
+    "babel-preset-solid": "1.9.12",
     "solid-js": "1.9.15"
   },
   "engines": {

package/src/panels.tsx

@@ -206,12 +206,18 @@ const PANELS = Object.entries(PANEL_COMPONENTS).map(([name, Panel]) => ({
 
 /** Claim the session.panel slot once per panel; each claim filters by name. */
 export function registerPanels(context: any, call: PanelCall, subscribe: PanelSubscribe): () => void {
-  const disposers = PANELS.map((panel) =>
-    context.slot({
-      append: "session.panel",
-      render: (input: { name: string }) => (input.name === panel.name ? panel.render({ call, subscribe }) : null),
-    }),
-  )
+  // Slot entry point moved across host releases: opencode 2.0.x exposes it
+  // as context.ui.slot (arity 1 object form or arity 2 name/render form),
+  // later hosts as bare context.slot. Without either, panels stay
+  // unregistered but setup must not throw (commands keep working).
+  const slotFn = typeof context.slot === "function" ? context.slot : context.ui?.slot
+  if (typeof slotFn !== "function") return () => {}
+  const disposers: Array<() => void> = []
+  for (const panel of PANELS) {
+    const render = (input: { name: string }) => (input.name === panel.name ? panel.render({ call, subscribe }) : null)
+    const dispose = slotFn.length <= 1 ? slotFn({ append: "session.panel", render }) : slotFn("session.panel", render)
+    if (typeof dispose === "function") disposers.push(dispose)
+  }
   return () => {
     for (const dispose of disposers) dispose()
   }