@heretek-ai/epistemic-swarm 0.7.25 → 1.0.2

package/src/panels.tsx

@@ -0,0 +1,220 @@
+// The four TUI panels: factory dashboard, LSP manager, hook inspector and
+// brainstorm board. Each is a session.panel slot contribution (the host
+// renders the one whose name is open) and reads structured state from the
+// server plugin over RPC — the same human-only channel the dialogs use. While
+// open, a panel refetches on every server `changed` event and every couple of
+// seconds, so it follows a running factory.
+import { createResource, createSignal, For, onCleanup, Show } from "solid-js"
+
+export type PanelCall = (method: string, input?: unknown) => Promise<any>
+/** Subscribe to server state changes; returns the unsubscribe function. */
+export type PanelSubscribe = (listener: () => void) => () => void
+
+export interface PanelProps {
+  readonly call: PanelCall
+  readonly subscribe: PanelSubscribe
+}
+
+export const PANEL_REFRESH_MS = 2_000
+
+/** Panel data, refetched on change events and on an interval while mounted. */
+function usePanelState(props: PanelProps, method: string): { data: () => any; error: () => string | undefined } {
+  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,
+    (): Promise<{ data?: any; error?: string }> =>
+      props.call(method).then(
+        (data) => ({ data }),
+        (error: any) => ({ error: String(error?.data?.reason ?? error?.message ?? error) }),
+      ),
+  )
+  return { data: () => state.latest?.data, error: () => state.latest?.error }
+}
+
+const Frame = (props: { title: string; children?: any }) => (
+  <box flexDirection="column" padding={1} gap={1}>
+    <text>{props.title}</text>
+    {props.children}
+  </box>
+)
+
+const Failed = (props: { error: () => string | undefined }) => (
+  <Show when={props.error()}>
+    <text>Could not load: {props.error()}</text>
+  </Show>
+)
+
+const FactoryPanel = (props: PanelProps) => {
+  const state = usePanelState(props, "factoryState")
+  return (
+    <Frame title="Factory dashboard">
+      <Failed error={state.error} />
+      <Show when={state.data()} fallback={<text>{state.error() ? "" : "Loading factory state…"}</text>}>
+        {(data: () => any) => (
+          <>
+            <text>
+              Stage: {data().stage}
+              {data().runId ? ` · ${data().runId}` : ""}
+            </text>
+            <text>
+              Spend: ${data().spend.usd.toFixed(2)}
+              {data().spend.ceilingUSD ? ` / $${data().spend.ceilingUSD}` : ""}
+              {data().spend.estimated ? " (estimated)" : ""}
+            </text>
+            <Show when={data().halt}>
+              <text>HALTED: {data().halt}</text>
+            </Show>
+            <Show when={data().release}>
+              <text>PR: {data().release}</text>
+            </Show>
+            <Show when={data().pending.length}>
+              <text>Waiting on human: {data().pending.join(", ")}</text>
+            </Show>
+            <text>Phases:</text>
+            <For each={data().phases}>
+              {(phase: any) => (
+                <text>
+                  {phase.id === data().activePhase ? "▶ " : "  "}
+                  {phase.id} · {phase.status} · failures {phase.failures}
+                </text>
+              )}
+            </For>
+          </>
+        )}
+      </Show>
+    </Frame>
+  )
+}
+
+const LspPanel = (props: PanelProps) => {
+  const state = usePanelState(props, "lspState")
+  return (
+    <Frame title="Language servers">
+      <Failed error={state.error} />
+      <Show when={state.data()} fallback={<text>{state.error() ? "" : "Loading language servers…"}</text>}>
+        {(data: () => any) => (
+          <>
+            <text>{data().enabled ? "LSP is on." : "LSP is disabled (lsp: false)."}</text>
+            <For each={data().servers}>
+              {(server: any) => (
+                <text>
+                  {server.available ? "●" : "○"} {server.id} [{server.extensions.join(" ")}]
+                  {server.running ? ` · ${server.running} running` : ""}
+                  {server.available ? "" : " — not installed"}
+                </text>
+              )}
+            </For>
+            <For each={data().diagnostics}>{(diagnostic: string) => <text>! {diagnostic}</text>}</For>
+          </>
+        )}
+      </Show>
+    </Frame>
+  )
+}
+
+const HooksPanel = (props: PanelProps) => {
+  const state = usePanelState(props, "hooksState")
+  return (
+    <Frame title="Hook bridge">
+      <Failed error={state.error} />
+      <Show when={state.data()} fallback={<text>{state.error() ? "" : "Loading hooks…"}</text>}>
+        {(data: () => any) => (
+          <>
+            <text>
+              {data().handlers} handler(s) · {data().projectHandlers} from the project ·{" "}
+              {data().projectHandlers === 0 ? "nothing to trust" : data().trusted ? "trusted" : "NOT trusted"}
+            </text>
+            <For each={data().projectLines}>{(line: string) => <text>{line}</text>}</For>
+            <Show when={data().loss.length}>
+              <text>Capability loss (advisory rows):</text>
+              <For each={data().loss}>
+                {(item: any) => (
+                  <text>
+                    ! {item.event} · {item.handler} — {item.support}: {item.reason}
+                  </text>
+                )}
+              </For>
+            </Show>
+            <For each={data().diagnostics}>{(item: string) => <text>! {item}</text>}</For>
+            <For each={data().recent}>{(item: string) => <text>recent error: {item}</text>}</For>
+          </>
+        )}
+      </Show>
+    </Frame>
+  )
+}
+
+const BrainstormPanel = (props: PanelProps) => {
+  const state = usePanelState(props, "brainstormState")
+  return (
+    <Frame title="Brainstorm board">
+      <Failed error={state.error} />
+      <Show when={state.data()} fallback={<text>{state.error() ? "" : "Loading brainstorm…"}</text>}>
+        {(data: () => any) => (
+          <Show when={data().active} fallback={<text>No brainstorm in .factory/brainstorm yet. Run /brainstorm.</text>}>
+            <text>Brief: {data().brief}</text>
+            <text>
+              {data().ideas} idea(s) · {data().duplicates} duplicate(s) · {data().scored} scored ·{" "}
+              {data().complete ? "complete" : "in progress"}
+            </text>
+            <text>
+              Coverage:{" "}
+              {data()
+                .lenses.map((lens: string) => `${lens} ${data().coverage[lens] ?? 0}`)
+                .join(" · ")}
+            </text>
+            <Show when={data().gaps.length}>
+              <text>Gaps: {data().gaps.join(", ")}</text>
+            </Show>
+            <Show when={data().shortlist.length}>
+              <text>Shortlist:</text>
+              <For each={data().shortlist}>
+                {(entry: any) => (
+                  <text>
+                    {entry.outlier ? "◇" : "◆"} {entry.id} ({entry.total}/20) — {entry.title}
+                    {entry.outlier ? " (forced outlier)" : ""}
+                  </text>
+                )}
+              </For>
+            </Show>
+          </Show>
+        )}
+      </Show>
+    </Frame>
+  )
+}
+
+/** The panel components by panel name (rendered headlessly in tests). */
+export const PANEL_COMPONENTS: Readonly<Record<string, (props: PanelProps) => any>> = {
+  factory: FactoryPanel,
+  lsp: LspPanel,
+  hooks: HooksPanel,
+  brainstorm: BrainstormPanel,
+}
+
+const PANELS = Object.entries(PANEL_COMPONENTS).map(([name, Panel]) => ({
+  name,
+  render: (props: PanelProps) => <Panel call={props.call} subscribe={props.subscribe} />,
+}))
+
+/** 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),
+    }),
+  )
+  return () => {
+    for (const dispose of disposers) dispose()
+  }
+}
+
+export const PANEL_NAMES = PANELS.map((panel) => panel.name)

package/src/policy.ts

@@ -0,0 +1,221 @@
+// Mechanical enforcement in the host: every write, edit, patch and shell call
+// from any agent passes through core's policy (canonical paths, control files,
+// seat scopes); factory seats additionally stop on STOP or a halted run, run
+// read-only shells under bubblewrap, and get fast gate feedback after edits.
+import path from "node:path"
+import {
+  bwrapAvailable,
+  checkStopFile,
+  evaluateRead,
+  evaluateShell,
+  evaluateWrite,
+  formatDiagnostics,
+  formatReport,
+  loadGatesConfig,
+  readonlyWrap,
+  runGates,
+  seatOf,
+  shellQuote,
+  treeFingerprint,
+} from "@heretek-ai/es-core"
+import { Error as ToolError } from "@opencode/plugin/promise/tool"
+import type { Runtime } from "./runtime.ts"
+
+const WRITE_TOOLS = new Set(["write", "edit"])
+
+const PATCH_HEADERS = ["*** Add File: ", "*** Update File: ", "*** Delete File: ", "*** Move to: "]
+
+/** Files a v2 `patch` touches (add, update, delete and move targets). */
+export function patchTargets(patchText: string): string[] {
+  const targets: string[] = []
+  for (const line of patchText.split("\n")) {
+    const header = PATCH_HEADERS.find((prefix) => line.startsWith(prefix))
+    const target = header ? line.slice(header.length).trimEnd() : ""
+    if (target) targets.push(target)
+  }
+  return targets
+}
+
+const deny = (message: string): never => {
+  throw new ToolError({ message })
+}
+
+const appendContent = (content: unknown, text: string) =>
+  typeof content === "string"
+    ? `${content}\n\n${text}`
+    : Array.isArray(content)
+      ? [...content, { type: "text", text }]
+      : text
+
+export function createPolicyHooks(runtime: Runtime) {
+  const fingerprints = new Map<string, { dir: string; print: string }>()
+
+  const before = async (event: { tool: string; agent: string; id: string; input: unknown }) => {
+    const seat = seatOf(event.agent)
+    const input = (event.input ?? {}) as Record<string, any>
+    if (seat || event.tool.startsWith("es_")) {
+      const stop = await checkStopFile(runtime.root)
+      if (stop.stopped)
+        deny(`The factory is stopped (.factory/STOP: ${stop.reason}). A human must remove it and resume.`)
+    }
+    if (seat && !event.tool.startsWith("es_")) {
+      const state = await runtime.factory.read().catch(() => undefined)
+      if (state?.stage === "HALTED")
+        deny(`The factory is halted: ${state.halt?.reason}. Stop and report; a human must resume.`)
+    }
+    const context = await runtime.policy()
+    if (WRITE_TOOLS.has(event.tool) && typeof input.path === "string") {
+      const decision = evaluateWrite(context, event.agent, input.path)
+      if (decision.effect === "deny") deny(decision.reason)
+    }
+    if (event.tool === "patch" && typeof input.patchText === "string")
+      for (const target of patchTargets(input.patchText)) {
+        const decision = evaluateWrite(context, event.agent, target)
+        if (decision.effect === "deny") deny(decision.reason)
+      }
+    if (event.tool === "read" && typeof input.path === "string") {
+      const decision = evaluateRead(context, event.agent, input.path)
+      if (decision.effect === "deny") deny(decision.reason)
+    }
+    if (event.tool === "shell" && typeof input.command === "string") {
+      const decision = evaluateShell(context, event.agent, input.command, { sandboxAvailable: bwrapAvailable() })
+      if (decision.effect === "deny") deny(decision.reason)
+      const cwd =
+        typeof input.workdir === "string"
+          ? path.resolve(runtime.root, input.workdir)
+          : (context.worktree ?? runtime.root)
+      if (decision.effect === "allow" && decision.mode === "readonly-sandbox") {
+        event.input = { ...input, command: readonlyWrap(["sh", "-c", input.command], cwd).map(shellQuote).join(" ") }
+      } else if (decision.effect === "allow" && decision.mode === "readonly-checked") {
+        fingerprints.set(event.id, { dir: cwd, print: await treeFingerprint(cwd) })
+      }
+    }
+  }
+
+  const after = async (event: {
+    tool: string
+    agent: string
+    id: string
+    input: unknown
+    status: string
+    result?: any
+  }) => {
+    const seat = seatOf(event.agent)
+    const checked = fingerprints.get(event.id)
+    if (checked) {
+      fingerprints.delete(event.id)
+      if ((await treeFingerprint(checked.dir)) !== checked.print) {
+        await runtime.factory
+          .halt(`agent:${event.agent}`, `read-only seat ${event.agent} changed files via the shell`)
+          .catch(() => undefined)
+        if (event.status === "completed")
+          event.result = {
+            ...event.result,
+            content: appendContent(
+              event.result?.content,
+              "VIOLATION: this read-only seat modified the checkout. The factory has been halted.",
+            ),
+          }
+      }
+    }
+    if (event.status !== "completed") return
+    const input = (event.input ?? {}) as Record<string, any>
+    const files =
+      WRITE_TOOLS.has(event.tool) && typeof input.path === "string"
+        ? [input.path]
+        : event.tool === "patch" && typeof input.patchText === "string"
+          ? patchTargets(input.patchText)
+          : []
+    if (!files.length) return
+    if (runtime.options.lspAfterEdit !== false) {
+      const lines: string[] = []
+      for (const file of files) {
+        const absolute = path.resolve(runtime.root, file)
+        const result = await runtime.lsp.diagnostics(absolute, { maxWaitMs: 4_000 }).catch(() => undefined)
+        if (Array.isArray(result)) lines.push(...formatDiagnostics(runtime.root, absolute, result, 1))
+      }
+      if (lines.length)
+        event.result = {
+          ...event.result,
+          content: appendContent(event.result?.content, `<diagnostics>\n${lines.join("\n")}\n</diagnostics>`),
+        }
+    }
+    if (seat !== "programmer" || runtime.options.afterEdit === "off") return
+    const worktree = (await runtime.policy()).worktree
+    if (!worktree) return
+    const { config } = await loadGatesConfig(runtime.root, worktree)
+    const touched = files
+      .map((file) => path.relative(worktree, path.resolve(runtime.root, file)))
+      .filter((file) => !file.startsWith(".."))
+    const report = await runGates({
+      root: runtime.root,
+      dir: worktree,
+      scope: "touched",
+      touched,
+      config: {
+        ...config,
+        commands: config.commands.filter((check) => check.kind === "format" || check.kind === "lint"),
+      },
+      stateDir: runtime.stateDir,
+    })
+    if (report.findings.length || !report.passed)
+      event.result = {
+        ...event.result,
+        content: appendContent(event.result?.content, `Gates after edit:\n${formatReport(report)}`),
+      }
+  }
+
+  const evaluate = async (event: {
+    agent?: string
+    action: string
+    resources: readonly string[]
+    effect: "allow" | "deny" | "ask"
+    message?: string
+  }) => {
+    const seat = seatOf(event.agent)
+    const context = await runtime.policy()
+    if (event.action === "edit" || event.action === "read") {
+      const decisions = event.resources.map((resource) =>
+        event.action === "edit"
+          ? evaluateWrite(context, event.agent, resource)
+          : evaluateRead(context, event.agent, resource),
+      )
+      const denied = decisions.find((decision) => decision.effect === "deny")
+      if (denied && "reason" in denied) {
+        event.effect = "deny"
+        event.message = denied.reason
+        return
+      }
+      const asked = decisions.find((decision) => decision.effect === "ask")
+      if (asked && "reason" in asked && event.effect === "allow") {
+        event.effect = "ask"
+        event.message = asked.reason
+        return
+      }
+      if (seat && event.effect === "ask") {
+        // Autonomous seats never wait on a human: our policy decides.
+        event.effect = event.action === "edit" ? "allow" : "deny"
+        if (event.effect === "deny")
+          event.message = "Autonomous factory seats may not read files the host guards (e.g. .env)."
+      }
+      return
+    }
+    if (seat && event.action === "external_directory") {
+      // Sonar S5443 flags the /tmp literal; this is an access check, not temp-file creation.
+      const tmp = event.resources.every((resource) => resource === "/tmp/*" || resource.startsWith("/tmp/")) // NOSONAR
+      event.effect = tmp ? "allow" : "deny"
+      if (!tmp) event.message = "Factory seats stay inside the project (and /tmp)."
+      return
+    }
+    if (seat && event.effect === "ask") {
+      event.effect = "deny"
+      event.message = `Autonomous factory seat "${event.agent}" cannot wait for a human approval of "${event.action}".`
+    }
+  }
+
+  const shellEnv = (event: { env: Record<string, string | undefined> }) => {
+    for (const key of Object.keys(event.env)) if (/^OPENCODE_(SERVER_)?PASSWORD$/.test(key)) delete event.env[key]
+  }
+
+  return { before, after, evaluate, shellEnv }
+}

package/src/pr.ts

@@ -0,0 +1,37 @@
+// Release PR opener backed by the GitHub CLI. It pushes only the run's
+// integration branch (never the base branch) and opens a draft PR for a human
+// to review and merge.
+import type { PrOpener } from "@heretek-ai/es-core"
+import { git, run } from "@heretek-ai/es-core"
+
+export const ghPrOpener: PrOpener = {
+  id: "gh",
+  async available(root) {
+    const gh = await run(["gh", "auth", "status"], {
+      cwd: root,
+      timeoutMs: 15_000,
+      passEnv: ["GH_TOKEN", "GITHUB_TOKEN", "GH_HOST"],
+    }).catch(() => undefined)
+    if (gh?.code !== 0) return false
+    const remote = await git(root, ["remote", "get-url", "origin"], { allowFail: true })
+    return remote.code === 0
+  },
+  async open({ root, branch, base, title, body }) {
+    if (branch === base || !branch.startsWith("factory/")) throw new Error(`refusing to push "${branch}"`)
+    await git(root, ["push", "--set-upstream", "origin", `${branch}:${branch}`])
+    const created = await run(
+      ["gh", "pr", "create", "--draft", "--head", branch, "--base", base, "--title", title, "--body", body],
+      {
+        cwd: root,
+        timeoutMs: 60_000,
+        passEnv: ["GH_TOKEN", "GITHUB_TOKEN", "GH_HOST"],
+      },
+    )
+    const url = created.stdout
+      .trim()
+      .split("\n")
+      .find((line) => /^https?:\/\//.test(line))
+    if (created.code !== 0 || !url) throw new Error(`gh pr create failed: ${(created.stderr || created.stdout).trim()}`)
+    return { url }
+  },
+}

package/src/research.ts

@@ -0,0 +1,63 @@
+// Research integration: the configured search provider becomes the host's
+// websearch (results cached content-addressed, so they can be cited), and the
+// host's own webfetch results are cached too.
+import { researchCache, selectProvider } from "@heretek-ai/es-core"
+import type { Runtime } from "./runtime.ts"
+
+export function registerWebsearch(
+  editor: { add(definition: any): void; default: { get(): unknown; set(id: string): void } },
+  runtime: Runtime,
+) {
+  const provider = selectProvider(runtime.options.searchProvider)
+  if (!provider) return
+  const cache = researchCache(runtime.root)
+  editor.add({
+    id: "epistemic-swarm",
+    name: `Epistemic Swarm (${provider.id}, cached)`,
+    execute: async (input: { query: string; limit?: number }, context: { signal: AbortSignal }) => {
+      const results = await provider.search(input.query, { limit: input.limit ?? 8, signal: context.signal })
+      const out = []
+      for (const result of results) {
+        const cached = await cache.put({
+          url: result.url,
+          title: result.title,
+          text: result.content ?? result.snippet,
+          provider: provider.id,
+          query: input.query,
+        })
+        out.push({
+          url: result.url,
+          title: result.title,
+          content: `[cached sha256:${cached.meta.sha256}]\n${result.content ?? result.snippet}`,
+          time: {},
+        })
+      }
+      return out
+    },
+  })
+  // Additive: become the default only when nothing else is selected.
+  if (editor.default.get() === undefined) editor.default.set("epistemic-swarm")
+}
+
+/** Cache host webfetch results so they can be cited as [VERIFIED: sha256:… "quote"]. */
+export function createWebfetchCache(runtime: Runtime) {
+  const cache = researchCache(runtime.root)
+  return async (event: { tool: string; status: string; input: unknown; result?: any }) => {
+    if (event.tool !== "webfetch" || event.status !== "completed") return
+    const url = (event.input as { url?: string } | undefined)?.url
+    const content = event.result?.content
+    const text =
+      typeof content === "string"
+        ? content
+        : Array.isArray(content)
+          ? content.map((part: any) => part?.text ?? "").join("\n")
+          : ""
+    if (!url || text.trim().length < 40) return
+    const cached = await cache.put({ url, text, provider: "webfetch" })
+    const note = `[cached as sha256:${cached.meta.sha256}; cite with [VERIFIED: sha256:${cached.meta.sha256} "exact words"]]`
+    event.result = {
+      ...event.result,
+      content: typeof content === "string" ? `${note}\n${content}` : [{ type: "text", text: note }, ...(content ?? [])],
+    }
+  }
+}

package/src/rpc-def.ts

@@ -0,0 +1,136 @@
+// RPC contract between the server plugin and the TUI. These methods are the
+// TUI half of the human-only channel: no agent tool reaches them, and the TUI
+// only calls them after a human confirms a dialog showing what is approved.
+import { Rpc } from "@opencode/plugin/rpc"
+
+const obj = (properties: Record<string, unknown>, required: string[] = []) => ({
+  type: "object" as const,
+  properties,
+  required,
+  additionalProperties: false,
+})
+const str = { type: "string" }
+const strArray = { type: "array", items: str }
+
+const Preview = obj({ ok: { type: "boolean" }, title: str, lines: strArray, problems: strArray, token: str }, [
+  "ok",
+  "title",
+  "lines",
+  "problems",
+])
+
+export const EsRpc = Rpc.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"]) },
+  },
+})