@heretek-ai/epistemic-swarm 0.7.25 → 1.0.2

package/src/server.ts

@@ -0,0 +1,311 @@
+// Epistemic Swarm for OpenCode v2 (server plugin). Additive: registers our
+// agents, tools, skills, commands, hooks and RPC through runtime transforms;
+// writes no config files and never touches built-in agents or defaults.
+import { readdir, readFile } from "node:fs/promises"
+import path from "node:path"
+import {
+  factoryLayout,
+  factorySummary,
+  formatReport,
+  git,
+  loadSkills,
+  readJson,
+  researchSourcesDir,
+  runGates,
+} from "@heretek-ai/es-core"
+import { Plugin } from "@opencode/plugin"
+import { compileAgents } from "./agents.ts"
+import { createFactoryContinuation } from "./continue.ts"
+import { createHookBridge } from "./hooks.ts"
+import { createPolicyHooks } from "./policy.ts"
+import { createWebfetchCache, registerWebsearch } from "./research.ts"
+import { createRpcHandlers } from "./rpc.ts"
+import { EsRpc } from "./rpc-def.ts"
+import { createRuntime, parseOptions } from "./runtime.ts"
+import { createSessionHooks, createSpendTracker } from "./session.ts"
+import { registerTools } from "./tools.ts"
+
+export const PLUGIN_ID = "epistemic-swarm"
+
+export default Plugin.define({
+  id: PLUGIN_ID,
+  async setup(ctx) {
+    const options = parseOptions(ctx.options as Record<string, unknown>)
+    const runtime = await createRuntime(ctx.location.directory, options)
+
+    // Agents: canonical registry → v2 agents with wildcard-deny scoping.
+    const servers = await ctx.mcp.list().then(
+      (page: any) => ((page?.data ?? page ?? []) as Array<{ name: string }>).map((server) => server.name),
+      () => [] as string[],
+    )
+    const agents = await compileAgents(runtime.options, servers)
+    await ctx.agent.transform((editor) => {
+      for (const compiled of agents)
+        editor.update(compiled.spec.id, (agent) => {
+          agent.mode = compiled.spec.mode
+          agent.hidden = compiled.spec.hidden
+          agent.description = compiled.spec.description
+          agent.system = compiled.system
+          agent.permissions = [...agent.permissions, ...compiled.permissions] as any
+          if (compiled.model) agent.model = compiled.model as any
+        })
+    })
+
+    // Skills: one shared SKILL.md tree, registered at runtime (no files written).
+    const skills = await loadSkills()
+    await ctx.skill.transform((editor) => {
+      for (const skill of skills)
+        editor.add({
+          id: skill.id,
+          name: skill.name,
+          description: skill.description,
+          path: skill.path,
+          content: skill.content,
+        } as any)
+    })
+
+    await ctx.tool.transform((editor) => registerTools(editor, runtime))
+    await ctx.websearch.transform((editor) => registerWebsearch(editor as any, runtime))
+
+    // Our policy runs first, so its denials win over any user hook.
+    const policy = createPolicyHooks(runtime)
+    const bridge = await createHookBridge(ctx as any, runtime, () => servers)
+    const sessionAgents = new Map<string, string | undefined>()
+    const agentOf = async (sessionID: string) => {
+      if (!sessionAgents.has(sessionID))
+        sessionAgents.set(
+          sessionID,
+          ((await ctx.session.get({ sessionID } as any).catch(() => undefined)) as any)?.agent,
+        )
+      return sessionAgents.get(sessionID)
+    }
+    await ctx.tool.hook("execute.before", policy.before as any)
+    await ctx.tool.hook("execute.before", bridge.before as any)
+    await ctx.tool.hook("execute.after", policy.after as any)
+    await ctx.tool.hook("execute.after", createWebfetchCache(runtime) as any)
+    await ctx.tool.hook("execute.after", bridge.after as any)
+    await ctx.permission.hook("evaluate", policy.evaluate as any)
+    await ctx.permission.hook("evaluate", bridge.evaluate as any)
+    await ctx.shell.hook("create.before", policy.shellEnv)
+    await ctx.shell.hook("create.before", bridge.shell as any)
+    await ctx.session.hook("prompt", (async (event: any) =>
+      bridge.prompt(event, await agentOf(event.sessionID))) as any)
+
+    const session = createSessionHooks(runtime)
+    await ctx.session.hook("context", session.context as any)
+    await ctx.session.hook("context", bridge.context as any)
+    await ctx.session.hook("compaction", session.compaction as any)
+    const continuation = createFactoryContinuation(ctx as any, runtime)
+
+    // Human-only channel for the TUI (approvals, trust, resume).
+    let registration: { events: { emit: (...args: any[]) => Promise<void> } } | undefined
+    const notify = async () => {
+      const state = await runtime.factory.read()
+      await registration?.events
+        .emit("changed", { stage: state?.stage ?? "NONE", summary: factorySummary(state) })
+        .catch(() => undefined)
+    }
+    registration = await ctx.rpc.register(EsRpc, createRpcHandlers(runtime, notify, bridge.engine) as any)
+
+    await ctx.command.transform((editor) => {
+      editor.add({
+        name: "grill",
+        description: "Grill an idea until the design and spend ceiling are settled (Epistemic Swarm)",
+        execute: async ({ sessionID, prompt, delivery }) => {
+          await ctx.session.switchAgent({ sessionID, agent: "grill" } as any)
+          await ctx.session.prompt({
+            ...prompt,
+            sessionID,
+            text: prompt.text?.trim() ? `Grill me on: ${prompt.text}` : "Start grilling me on my idea.",
+            delivery,
+          } as any)
+        },
+      })
+      editor.add({
+        name: "brainstorm",
+        description: "Fan out divergent lenses on an idea and return a diversified shortlist (Epistemic Swarm)",
+        execute: async ({ sessionID, prompt, delivery }) => {
+          await ctx.session.switchAgent({ sessionID, agent: "brainstormer" } as any)
+          await ctx.session.prompt({
+            ...prompt,
+            sessionID,
+            text: prompt.text?.trim()
+              ? `Brainstorm: ${prompt.text}`
+              : "Ask me for the idea to brainstorm (one sentence), then run the lens fan-out.",
+            delivery,
+          } as any)
+        },
+      })
+      editor.add({
+        name: "harvest",
+        description: "Tear down competitor projects: licences, feature matrix, clean-room specs (Epistemic Swarm)",
+        execute: async ({ sessionID, prompt, delivery }) => {
+          await ctx.session.switchAgent({ sessionID, agent: "harvester" } as any)
+          await ctx.session.prompt({
+            ...prompt,
+            sessionID,
+            text: prompt.text?.trim()
+              ? `Darkharvest: ${prompt.text}`
+              : "Ask me for the teardown objective and the candidate projects, then run the harvest.",
+            delivery,
+          } as any)
+        },
+      })
+      editor.add({
+        name: "design",
+        description: "Interview me into a design system: tokens, contrast gates, style guide (Epistemic Swarm)",
+        execute: async ({ sessionID, prompt, delivery }) => {
+          await ctx.session.switchAgent({ sessionID, agent: "designer" } as any)
+          await ctx.session.prompt({
+            ...prompt,
+            sessionID,
+            text: prompt.text?.trim()
+              ? `Run the design interview. Product: ${prompt.text}`
+              : "Ask me for the product name and start the design interview, one question at a time.",
+            delivery,
+          } as any)
+        },
+      })
+      editor.add({
+        name: "factory",
+        description: "Drive the build factory from its current stage (Epistemic Swarm)",
+        execute: async ({ sessionID, prompt, delivery }) => {
+          await ctx.session.switchAgent({ sessionID, agent: "factory" } as any)
+          const state = await runtime.factory.read()
+          await ctx.session.prompt({
+            ...prompt,
+            sessionID,
+            text: `${factorySummary(state)}\nContinue the factory run from its current stage.${prompt.text?.trim() ? `\nHuman note: ${prompt.text}` : ""}`,
+            delivery,
+          } as any)
+        },
+      })
+      editor.add({
+        name: "gates",
+        description: "Run the mechanical gates on changed files (Epistemic Swarm)",
+        execute: async ({ sessionID }) => {
+          const changed = (await git(runtime.root, ["status", "--porcelain=v1", "-uall"], { allowFail: true })).stdout
+            .split("\n")
+            .filter(Boolean)
+            .map((line) => line.slice(3).split(" -> ").at(-1)!)
+          const report = await runGates({
+            root: runtime.root,
+            scope: changed.length ? "touched" : "full",
+            touched: changed,
+            stateDir: runtime.stateDir,
+          })
+          await ctx.session.synthetic({ sessionID, text: formatReport(report) } as any)
+        },
+      })
+      editor.add({
+        name: "lsp",
+        description: "Language servers: configured, available and running (Epistemic Swarm)",
+        execute: async ({ sessionID }) => {
+          const status = await runtime.lsp.status()
+          const settings = await runtime.lsp.settings()
+          const lines = [status.enabled ? "LSP is on." : "LSP is disabled (lsp: false)."]
+          for (const server of settings.servers) {
+            const command = await runtime.lsp.command(server, runtime.root)
+            const running = status.running.filter((item) => item.id === server.id)
+            lines.push(
+              `${server.id} [${server.extensions.join(" ")}]: ${Array.isArray(command) ? `available (${command.join(" ")})` : command.unavailable}${running.length ? ` · running for ${running.length} root(s)` : ""}`,
+            )
+          }
+          lines.push(...status.diagnostics.map((item) => `! ${item}`))
+          await ctx.session.synthetic({ sessionID, text: lines.join("\n") } as any)
+        },
+      })
+      editor.add({
+        name: "hooks",
+        description: "Show the hook bridge: sources, handlers, trust and diagnostics (Epistemic Swarm)",
+        execute: async ({ sessionID }) => {
+          await bridge.engine.refresh()
+          const status = bridge.engine.status()
+          const trust =
+            status.projectHandlers === 0
+              ? "nothing to trust"
+              : status.trusted
+                ? "trusted"
+                : "NOT trusted: run /es-trust or `es trust`"
+          const lines = [
+            `Hook bridge: ${status.handlers} handler(s), ${status.projectHandlers} from the project (${trust}).`,
+            ...status.projectLines,
+            ...status.diagnostics.map((item) => `! ${item}`),
+            ...bridge.engine.recent.slice(-10).map((item) => `recent error: ${item}`),
+            "Stop hooks are emulated after the turn ends (advisory for plain chat).",
+          ]
+          await ctx.session.synthetic({ sessionID, text: lines.join("\n") } as any)
+        },
+      })
+      editor.add({
+        name: "status",
+        description: "Show the factory state (Epistemic Swarm)",
+        execute: async ({ sessionID }) => {
+          await ctx.session.synthetic({ sessionID, text: factorySummary(await runtime.factory.read()) } as any)
+        },
+      })
+      editor.add({
+        name: "config",
+        description: "Show the effective Epistemic Swarm config and where it came from (Epistemic Swarm)",
+        execute: async ({ sessionID }) => {
+          const lines = [
+            runtime.configSources.length
+              ? `Layers: ${runtime.configSources.join(" → ")} → plugin options`
+              : "Layers: defaults only (no config files)",
+            JSON.stringify(runtime.config, null, 2),
+          ]
+          await ctx.session.synthetic({ sessionID, text: lines.join("\n") } as any)
+        },
+      })
+      editor.add({
+        name: "research",
+        description: "Research stage: report, audit coverage and cached sources (Epistemic Swarm)",
+        execute: async ({ sessionID }) => {
+          const layout = factoryLayout(runtime.root)
+          const report = await readFile(layout.researchReport, "utf8").catch(() => undefined)
+          const coverage = await readJson<{
+            claims?: number
+            grounded?: number
+            untagged?: number
+            ungrounded?: number
+            malformed?: number
+            sources?: number
+            passed?: boolean
+          }>(path.join(layout.research, "coverage.json")).catch(() => undefined)
+          const sources = (await readdir(researchSourcesDir(runtime.root)).catch(() => [])).filter((file) =>
+            file.endsWith(".md"),
+          )
+          const lines = [
+            report === undefined
+              ? "No research report yet (.factory/research/REPORT.md)."
+              : `Report: ${report.length} characters in .factory/research/REPORT.md.`,
+            coverage
+              ? `Audit: ${coverage.grounded ?? 0}/${coverage.claims ?? 0} claims grounded (untagged ${coverage.untagged ?? 0}, ungrounded ${coverage.ungrounded ?? 0}, malformed ${coverage.malformed ?? 0}); cited sources ${coverage.sources ?? 0}; passed ${coverage.passed ? "yes" : "no"}.`
+              : "No coverage.json yet (es_research_complete writes it).",
+            `Cached sources: ${sources.length}.`,
+          ]
+          await ctx.session.synthetic({ sessionID, text: lines.join("\n") } as any)
+        },
+      })
+    })
+
+    // Spend: per-step host cost for factory-agent sessions (estimated from tokens when cost is 0).
+    const track = createSpendTracker(runtime, agentOf)
+    const abort = new AbortController()
+    void (async () => {
+      try {
+        for await (const event of ctx.event.subscribe({ signal: abort.signal }) as AsyncIterable<any>) {
+          await track(event).catch(() => undefined)
+          await bridge.onEvent(event, agentOf).catch(() => undefined)
+          await continuation(event, agentOf).catch(() => undefined)
+        }
+      } catch {
+        // stream closed on unload
+      }
+    })()
+    return async () => {
+      abort.abort()
+      await runtime.lsp.stopAll()
+    }
+  },
+})

package/src/session.ts

@@ -0,0 +1,61 @@
+// Session-level integration: factory-state injection for factory agents,
+// per-agent es_* tool visibility (without touching built-in agents' config),
+// compaction that preserves the factory state, and spend accounting from
+// the host's per-step cost.
+import { AGENTS, ALL_ES_TOOLS, factorySummary } from "@heretek-ai/es-core"
+import { visibleEsTools } from "./agents.ts"
+import type { Runtime } from "./runtime.ts"
+
+const FACTORY_AGENTS = new Set(AGENTS.map((agent) => agent.id))
+
+export function createSessionHooks(runtime: Runtime) {
+  const context = async (event: { agent: string; system: any[]; tools: Record<string, unknown> }) => {
+    const visible = new Set(visibleEsTools(event.agent))
+    for (const name of ALL_ES_TOOLS) if (!visible.has(name)) delete event.tools[name]
+    if (!FACTORY_AGENTS.has(event.agent)) return
+    const state = await runtime.factory.read().catch(() => undefined)
+    event.system.push({ type: "text", text: factorySummary(state) })
+  }
+
+  const compaction = async (event: { agent: string; system: any[] }) => {
+    if (!FACTORY_AGENTS.has(event.agent)) return
+    const state = await runtime.factory.read().catch(() => undefined)
+    event.system.push({
+      type: "text",
+      text: `Preserve this factory state verbatim at the top of your summary; the run continues from it:\n${factorySummary(state)}`,
+    })
+  }
+
+  return { context, compaction }
+}
+
+interface StepEnded {
+  readonly type: string
+  readonly data?: {
+    sessionID?: string
+    cost?: number
+    tokens?: { input?: number; output?: number; reasoning?: number }
+  }
+}
+
+/** Accumulate factory spend from session.step.ended events of factory-agent sessions. */
+export function createSpendTracker(runtime: Runtime, lookupAgent: (sessionID: string) => Promise<string | undefined>) {
+  const agents = new Map<string, string | undefined>()
+  const inputPerM = runtime.options.estimate?.inputPerM ?? 3
+  const outputPerM = runtime.options.estimate?.outputPerM ?? 15
+  return async (event: StepEnded) => {
+    if (event.type !== "session.step.ended" || !event.data?.sessionID) return
+    const sessionID = event.data.sessionID
+    if (!agents.has(sessionID)) agents.set(sessionID, await lookupAgent(sessionID).catch(() => undefined))
+    if (!FACTORY_AGENTS.has(agents.get(sessionID) ?? "")) return
+    const cost = Number(event.data.cost ?? 0)
+    if (cost > 0) {
+      await runtime.factory.recordSpend(cost, false)
+      return
+    }
+    const tokens = event.data.tokens ?? {}
+    const estimate =
+      ((tokens.input ?? 0) * inputPerM + ((tokens.output ?? 0) + (tokens.reasoning ?? 0)) * outputPerM) / 1_000_000
+    if (estimate > 0) await runtime.factory.recordSpend(estimate, true)
+  }
+}

package/src/tools.ts

@@ -0,0 +1,61 @@
+// Epistemic Swarm tools for OpenCode v2: the harness-neutral core operations,
+// registered as direct (codemode:false) tools, each under its own permission
+// action so per-agent rules can hide it. Refusals become model-facing tool errors.
+import {
+  brainstormTools,
+  designTools,
+  esTools,
+  harvestTools,
+  lspTools,
+  pendingApprovals,
+  researchTools,
+} from "@heretek-ai/es-core"
+import { Error as ToolError } from "@opencode/plugin/promise/tool"
+import type { Runtime } from "./runtime.ts"
+
+export function registerTools(editor: { add(tool: any): void }, runtime: Runtime) {
+  const lsp = lspTools({ root: runtime.root, manager: runtime.lsp, policy: () => runtime.policy() })
+  const research = researchTools({
+    root: runtime.root,
+    policy: () => runtime.policy(),
+    ...(runtime.options.searchProvider ? { provider: runtime.options.searchProvider } : {}),
+  })
+  const brainstorm = brainstormTools({
+    root: runtime.root,
+    ...(runtime.config.embeddings ? { embeddings: runtime.config.embeddings } : {}),
+  })
+  const harvest = harvestTools({
+    root: runtime.root,
+    whitelist: runtime.config.licenseWhitelist,
+    stateDir: runtime.stateDir,
+  })
+  const design = designTools({ root: runtime.root })
+  for (const def of [
+    ...esTools({ ...runtime, lsp: runtime.lsp }),
+    ...lsp,
+    ...research,
+    ...brainstorm,
+    ...harvest,
+    ...design,
+  ])
+    editor.add({
+      name: def.name,
+      description: def.description,
+      input: def.input,
+      // es_* tools each get their own action; LSP tools share "lsp" (navigation) and "lsp_rename" (writes).
+      options: {
+        codemode: false,
+        permission: def.name.startsWith("lsp_") ? (def.name === "lsp_rename" ? "lsp_rename" : "lsp") : def.name,
+      },
+      execute: async (input: unknown, context: { agent: string; sessionID: string; signal: AbortSignal }) => {
+        try {
+          return { content: await def.execute(input ?? {}, context) }
+        } catch (error) {
+          if (error instanceof ToolError) throw error
+          throw new ToolError({ message: error instanceof Error ? error.message : String(error) })
+        }
+      },
+    })
+}
+
+export { pendingApprovals }

package/src/tui.tsx

@@ -0,0 +1,206 @@
+// Epistemic Swarm TUI plugin: the human-only dialogs. Approvals, trust and
+// resume happen here (or in the `es` CLI), never through an agent tool. Each
+// dialog shows a server-computed preview; confirming redeems that preview's
+// token, so what the human saw is exactly what gets signed.
+import { userInfo } from "node:os"
+import { Plugin } from "@opencode/plugin/tui"
+import { registerPanels } from "./panels.tsx"
+import { EsRpc } from "./rpc-def.ts"
+
+type Preview = { ok: boolean; title: string; lines: string[]; problems: string[]; token?: string }
+
+export default Plugin.define({
+  id: "epistemic-swarm.tui",
+  setup(context) {
+    const rpc = context.client.rpc(EsRpc) as any
+    const location = () => context.location ?? context.data.location.default()
+    const call = (method: string, input: unknown = {}) => rpc[method](input, { location: location() })
+    const stopPanels = registerPanels(context, call, (listener) => rpc.events.on("changed", () => listener()))
+    const user = userInfo().username
+    const toast = (message: string, variant: "success" | "error" | "info" = "info") =>
+      context.ui.toast.show({ title: "Epistemic Swarm", message, variant })
+
+    const confirm = async (preview: Preview, label: string) => {
+      if (!preview.ok || !preview.token) {
+        await context.ui.dialog.alert({
+          title: preview.title,
+          message: [...preview.problems, ...preview.lines].join("\n"),
+        })
+        return undefined
+      }
+      const ok = await context.ui.dialog.confirm({
+        title: preview.title,
+        message: preview.lines.join("\n"),
+        label: { confirm: label, cancel: "Cancel" },
+      })
+      return ok ? preview.token : undefined
+    }
+
+    const guarded = (fn: (input?: string) => Promise<void>) => async (input?: string) => {
+      try {
+        await fn(input)
+      } catch (error: any) {
+        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: 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: number | undefined
+      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: any) => toast(`Factory → ${event.data.stage}`))
+    return () => {
+      stopPanels()
+      stop()
+    }
+  },
+})

package/tui.tsx

@@ -0,0 +1 @@
+export { default } from "./src/tui.tsx"

package/.agents/skills/brainstorming/SKILL.md

@@ -1,19 +0,0 @@
----
-name: brainstorming
-description: >-
-  Lateral creative brainstorming and divergent ideation skill. Use when exploring what-if features, lateral architectures, speculative product directions, or when user invokes /brainstorming. Generates novel feature vectors, paradigm inversions, and falsifiable spike hypotheses instead of bug fixes.
----
-
-# Brainstorming (thin adapter stub)
-
-This file is a POINTER, not the implementation. It exists so harness skill
-discovery finds an entry; the real skill lives in the IUMBTEMS repo.
-
-- Canonical prose & scripts: `skills/brainstorming/`
-- Canonical programmatic surface: `python3 runner/mcp_server.py` (stdio MCP),
-  or one-shot: `python3 runner/mcp_server.py call <tool> '{...json...}'`
-- MCP tools for this skill: `iumbtems_brainstorm`
-
-Epistemic rules apply regardless of harness: tag claims as
-`[VERIFIED: <hash>]`, `[INFERRED: <reasoning>]`, `[HYPOTHESIS: <test>]`, or
-`[NEGATIVE_KNOWLEDGE: <query>]`. Writes go only to `.research/`.

package/.agents/skills/code_audit/SKILL.md

@@ -1,19 +0,0 @@
----
-name: code-audit
-description: >-
-  Deep dialectic codebase auditing skill. Deploys architectural thesis vs adversarial red-team antithesis to discover security vulnerabilities, race conditions, resource leaks, and architectural flaws with exact line-level proof.
----
-
-# Code Audit (thin adapter stub)
-
-This file is a POINTER, not the implementation. It exists so harness skill
-discovery finds an entry; the real skill lives in the IUMBTEMS repo.
-
-- Canonical prose & scripts: `skills/code_audit/`
-- Canonical programmatic surface: `python3 runner/mcp_server.py` (stdio MCP),
-  or one-shot: `python3 runner/mcp_server.py call <tool> '{...json...}'`
-- MCP tools for this skill: `iumbtems_code_audit`
-
-Epistemic rules apply regardless of harness: tag claims as
-`[VERIFIED: <hash>]`, `[INFERRED: <reasoning>]`, `[HYPOTHESIS: <test>]`, or
-`[NEGATIVE_KNOWLEDGE: <query>]`. Writes go only to `.research/`.