@heretek-ai/epistemic-swarm 1.1.4 → 2.3.0

package/src/rpc.ts

@@ -1,7 +1,9 @@
-// Server side of the TUI previews. Human-only mutations (approve, trust,
-// resume) happen at a terminal with the passphrase-sealed key, never via RPC:
-// the TUI previews, then points at `es approve`, `es trust`, `es factory
-// resume`. Only lspInstall still mutates via a preview token.
+// Server side of the TUI previews. Approvals complete in the TUI process
+// (masked dialog, in-process signing, ADR 0002); trust and resume sign at a
+// terminal with the passphrase-sealed key. The TUI previews, then either
+// signs itself or points at `es trust` / `es factory resume`. No approve,
+// trust or resume call ever crosses RPC: only lspInstall still mutates via
+// a preview token.
 import { randomBytes } from "node:crypto"
 import {
   type ApprovalStage,
@@ -19,6 +21,7 @@ import {
   headline,
   installServer,
   isTrusted,
+  listBrainstormRuns,
   loadGatesConfig,
   readFrontier,
   readIdeas,
@@ -54,14 +57,14 @@ export function createRpcHandlers(
     tickets.set(token, { kind, subject: hashJson(subject), expires: Date.now() + TTL_MS })
     return token
   }
-  const redeem = (token: string, kind: string, subject: unknown) => {
+  const redeemHash = (token: string, kind: string, subjectHash: string) => {
     const ticket = tickets.get(token)
     tickets.delete(token)
     if (!ticket || ticket.kind !== kind || ticket.expires < Date.now())
       throw new Error("The confirmation expired or does not match; preview again.")
-    if (ticket.subject !== hashJson(subject))
-      throw new Error("What you confirmed changed since the preview; preview again.")
+    if (ticket.subject !== subjectHash) throw new Error("What you confirmed changed since the preview; preview again.")
   }
+  const redeem = (token: string, kind: string, subject: unknown) => redeemHash(token, kind, hashJson(subject))
   const refused = (context: any, error: unknown) =>
     context.error("refused", error instanceof Error ? error.message : String(error), {
       reason: error instanceof Error ? error.message : String(error),
@@ -181,14 +184,19 @@ export function createRpcHandlers(
       }
     },
     brainstormState: async () => {
-      const plan = await readPlan(runtime.root).catch(() => undefined)
-      if (!plan) return { active: false }
-      const ideas = await readIdeas(runtime.root).catch(() => [])
-      const scores = await readScores(runtime.root).catch(() => [])
-      const result = await readResult(runtime.root).catch(() => undefined)
+      const runs = await listBrainstormRuns(runtime.root).catch(() => [] as string[])
+      // The panel shows the default run, else the latest; every run stays one CLI call away.
+      const run = runs.includes("default") ? "default" : runs[runs.length - 1]
+      const plan = run ? await readPlan(runtime.root, run).catch(() => undefined) : undefined
+      if (!plan || !run) return { active: false, runs }
+      const ideas = await readIdeas(runtime.root, run).catch(() => [])
+      const scores = await readScores(runtime.root, run).catch(() => [])
+      const result = await readResult(runtime.root, run).catch(() => undefined)
       const survivors = ideas.filter((idea) => !idea.duplicateOf)
       return {
         active: true,
+        run,
+        runs,
         brief: plan.brief.idea,
         lenses: plan.lenses,
         ideas: survivors.length,
@@ -221,6 +229,9 @@ export function createRpcHandlers(
           ],
           problems: [],
           token: issue(`approve:${stage}`, subject.subject),
+          // ADR 0002 I3: the TUI signs only this subject; approveStage refuses a mismatch.
+          subjectHash: hashJson(subject.subject),
+          issuedAt: Date.now(),
         }
       } catch (error) {
         return {
@@ -231,6 +242,23 @@ export function createRpcHandlers(
         }
       }
     },
+    /**
+     * Validate-only redeem of an approval preview ticket (ADR 0002 I3): the
+     * TUI calls this exactly once before signing in-process. It enforces the
+     * 120 s TTL and single-use and checks the subject hash, but signs
+     * nothing — there is still no approve RPC (#49).
+     */
+    redeemApproval: async (input: unknown, context: any) => {
+      const { stage, token, subjectHash } = input as { stage: ApprovalStage; token: unknown; subjectHash: unknown }
+      try {
+        if (typeof token !== "string" || typeof subjectHash !== "string")
+          throw new Error("The confirmation expired or does not match; preview again.")
+        redeemHash(token, `approve:${stage}`, subjectHash)
+        return { ok: true }
+      } catch (error) {
+        return refused(context, error)
+      }
+    },
     previewTrust: async () => {
       const subject = await trustSubject()
       const trusted =

package/src/runtime.ts

@@ -1,8 +1,9 @@
 // Per-location runtime shared by the plugin's hooks, tools, commands and RPC.
-// Options are layered: the canonical config (global file → project file) with
-// plugin options as the most specific override. Plugin options are config
-// keys validated by the same strict schema; unknown keys are ignored with a
-// warning the TUI shows once.
+// The server only wires option layering (parseOptions → createRuntime); the
+// merge itself lives in core (loadEsConfig/mergeConfig): the canonical config
+// (global file → project file) with plugin options as the most specific
+// override. Plugin options are config keys validated by the same strict
+// schema; unknown keys are ignored with a warning the TUI shows once.
 import {
   stateDir as defaultStateDir,
   type EsConfig,
@@ -13,6 +14,7 @@ import {
   loadEsConfig,
   type PolicyContext,
 } from "@heretek-ai/es-core"
+import type { ModelProblem } from "./agents.ts"
 import { ghPrOpener } from "./pr.ts"
 
 /** Plugin options from opencode.json, split into config keys and the rest. */
@@ -47,6 +49,8 @@ export interface Runtime {
   readonly stateDir: string
   readonly factory: Factory
   readonly lsp: LspManager
+  /** Seats whose configured model is missing on the host (fail-closed, #96). */
+  readonly modelProblems: Map<string, ModelProblem>
   policy(): Promise<PolicyContext>
 }
 
@@ -65,6 +69,9 @@ export async function createRuntime(root: string, parsed: ParsedOptions): Promis
     ...(config.searchProvider ? { searchProvider: config.searchProvider } : {}),
   }
   const stateDir = options.stateDir ?? defaultStateDir()
+  // One manager per project (#275.1): servers start lazily per (server, root)
+  // and are reaped by the idle sweeper between sessions, stopping only on
+  // plugin unload (see server.ts) — long-lived servers outlive sessions.
   const lsp = new LspManager({ root, stateDir })
   const factory = new Factory(root, {
     gates: gateRunner({ stateDir }),
@@ -73,6 +80,7 @@ export async function createRuntime(root: string, parsed: ParsedOptions): Promis
     researchDepth: config.research.depth,
     ...(config.domainPack ? { domainPack: config.domainPack } : {}),
     ...(config.audit.phase === "required" ? { auditPhase: "required" as const } : {}),
+    ...(config.models ? { models: config.models } : {}),
   })
   return {
     root,
@@ -83,9 +91,18 @@ export async function createRuntime(root: string, parsed: ParsedOptions): Promis
     stateDir,
     factory,
     lsp,
+    modelProblems: new Map(),
     async policy() {
       const worktree = await factory.activeWorktree().catch(() => undefined)
-      return { root, stateDir, ...(worktree ? { worktree } : {}) }
+      // S1.7: the mode-aware REPORT.md grant needs the sealed run mode. Read
+      // it from the sealed run state; when it cannot be read (no run, a
+      // missing or forged seal) leave it absent so both writers stay denied
+      // (fail closed, trust/policy.ts).
+      const runMode = await factory
+        .read()
+        .then((state) => state?.mode)
+        .catch(() => undefined)
+      return { root, stateDir, ...(worktree ? { worktree } : {}), ...(runMode ? { runMode } : {}) }
     },
   }
 }

package/src/seats.ts

@@ -3,7 +3,14 @@
 // tool and last activity in .factory/runtime/seats.json. es_status, `es
 // status`, the dashboard and the headless driver read it; the foreground guard
 // and the continuation ask it what is running right now.
-import { agentSpec, type SeatRecord, updateSeats } from "@heretek-ai/es-core"
+import {
+  agentSpec,
+  assertModelDiversity,
+  ModelDiversityError,
+  type SeatModelMap,
+  type SeatRecord,
+  updateSeats,
+} from "@heretek-ai/es-core"
 import type { Runtime } from "./runtime.ts"
 
 /** Activity-only updates (tool calls, steps) are persisted at most this often per seat. */
@@ -29,6 +36,26 @@ export interface SeatTracker {
   hasRunningChildren(parentID: string): boolean
 }
 
+/** Seats covered by the heterogeneous-model policy (#170): the programmer and both QA seats. */
+const DIVERSE_SEATS: ReadonlySet<string> = new Set(["es-programmer", "es-qa-functional", "es-qa-adversarial"])
+
+/**
+ * Refusal text when launching `target` would run the programmer and QA on the
+ * same model provider (shared weights share blind spots); undefined when the
+ * target is not a build seat or diversity holds. Unverified configs (unset
+ * seats) launch unless models.requireDiversity is set.
+ */
+export function seatModelRefusal(target: string, models: SeatModelMap | undefined): string | undefined {
+  if (!DIVERSE_SEATS.has(target)) return undefined
+  try {
+    assertModelDiversity(models)
+    return undefined
+  } catch (error) {
+    if (error instanceof ModelDiversityError) return error.message
+    throw error
+  }
+}
+
 /** Factory seats are the registry's subagents; primary agents (factory, grill) are drivers, not seats. */
 const isSeat = (agent: string | undefined): agent is string => agentSpec(agent)?.mode === "subagent"