@heretek-ai/epistemic-swarm 0.7.25 → 1.0.3

package/index.ts

@@ -0,0 +1 @@
+export { default } from "./src/server.ts"

package/package.json

@@ -1,154 +1,83 @@
 {
   "name": "@heretek-ai/epistemic-swarm",
-  "version": "0.7.25",
-  "description": "IUMBTEMS (Epistemic Swarm) \u2014 High-Integrity Dialectic Research Agent Harness for Claude Code, OpenCode V2, Pi (pi.dev), OMP (oh-my-pi), Gemini CLI, Codex CLI, and AntiGravity",
-  "main": "bin/cli.js",
-  "bin": {
-    "iumbtems": "bin/cli.js",
-    "epistemic-swarm": "bin/cli.js"
+  "version": "1.0.3",
+  "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",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Heretek-AI/IUMBTEMS.git",
+    "directory": "packages/opencode"
   },
   "exports": {
-    ".": "./bin/cli.js",
-    "./opencode": "./plugins/opencode/index.js",
-    "./server": "./plugins/opencode/index.js",
-    "./tui": "./plugins/opencode/tui.js",
-    "./pi": "./extensions/pi/index.js",
-    "./omp": "./extensions/pi/index.js"
+    ".": {
+      "types": "./index.ts",
+      "default": "./index.ts"
+    },
+    "./server": {
+      "types": "./server.ts",
+      "default": "./server.ts"
+    },
+    "./tui": {
+      "types": "./tui.tsx",
+      "default": "./dist/tui.js"
+    },
+    "./rpc": {
+      "types": "./rpc.ts",
+      "default": "./rpc.ts"
+    }
   },
-  "publishConfig": {
-    "access": "public"
+  "files": [
+    "index.ts",
+    "server.ts",
+    "tui.tsx",
+    "rpc.ts",
+    "src",
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun script/build-tui.ts",
+    "prepublishOnly": "bun run build",
+    "test": "bun test"
   },
   "dependencies": {
-    "solid-js": "1.9.12",
-    "@opentui/solid": ">=0.4.0 <0.6.0"
+    "@heretek-ai/es-core": "1.0.3",
+    "@opencode/plugin": "2.0.24"
   },
-  "overrides": {
-    "@babel/core": "^7.29.6"
+  "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"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Heretek-AI/IUMBTEMS.git"
+  "engines": {
+    "node": ">=22"
+  },
+  "peerDependencies": {
+    "@opentui/core": ">=0.5.14",
+    "@opentui/solid": ">=0.5.14",
+    "solid-js": ">=1.9.0"
   },
-  "bugs": {
-    "url": "https://github.com/Heretek-AI/IUMBTEMS/issues"
+  "peerDependenciesMeta": {
+    "@opentui/core": {
+      "optional": true
+    },
+    "@opentui/solid": {
+      "optional": true
+    },
+    "solid-js": {
+      "optional": true
+    }
   },
-  "homepage": "https://github.com/Heretek-AI/IUMBTEMS#readme",
   "keywords": [
-    "iumbtems",
-    "epistemic-swarm",
-    "i-use-my-brain-to-express-my-self",
-    "pi-package",
-    "omp-package",
     "opencode",
     "opencode-plugin",
-    "claude-code",
-    "gemini-cli",
-    "codex-cli",
-    "antigravity",
-    "oh-my-pi",
-    "omp",
-    "ai-agents",
-    "autonomous-agents",
-    "multi-agent-systems",
-    "dialectic-swarm",
-    "dialectic",
-    "epistemic-integrity",
-    "research-harness",
-    "research-agent",
-    "mcp",
-    "model-context-protocol",
-    "mcp-servers",
-    "deep-research",
-    "socratic-grilling",
-    "socratic-questioning",
-    "brainstorming",
-    "lateral-thinking",
-    "fact-checking",
-    "red-teaming",
-    "citation-validation",
-    "hallucination-prevention",
-    "swarm-intelligence",
-    "code-audit",
-    "oss-scout",
-    "clean-room-engineering",
-    "proof-carrying-briefs",
-    "living-dossiers"
-  ],
-  "pi": {
-    "extensions": [
-      "./extensions/pi/index.js"
-    ],
-    "skills": [
-      "./skills/grilling",
-      "./skills/research_cache",
-      "./skills/epistemic_search",
-      "./skills/swarm_config",
-      "./skills/code_audit",
-      "./skills/oss_scout",
-      "./skills/brainstorming",
-      "./skills/darkharvest",
-      "./skills/factory"
-    ],
-    "prompts": [
-      "./prompts/*.md"
-    ]
-  },
-  "omp": {
-    "extensions": [
-      "./extensions/pi/index.js"
-    ],
-    "skills": [
-      "./skills/grilling",
-      "./skills/research_cache",
-      "./skills/epistemic_search",
-      "./skills/swarm_config",
-      "./skills/code_audit",
-      "./skills/oss_scout",
-      "./skills/brainstorming",
-      "./skills/darkharvest",
-      "./skills/factory"
-    ],
-    "prompts": [
-      "./prompts/*.md"
-    ],
-    "commands": [
-      "./.omp/commands/*.md"
-    ]
-  },
-  "author": "Heretek AI",
-  "license": "Apache-2.0",
-  "files": [
-    "bin",
-    "prompts",
-    "skills",
-    "schemas",
-    "hooks",
-    "config",
-    "runner",
-    "extensions",
-    "plugins",
-    "scripts",
-    ".agents",
-    ".omp",
-    ".claude-plugin",
-    "install.sh",
-    "README.md",
-    "MARKETPLACE.md",
-    "LICENSE"
-  ],
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "scripts": {
-    "test": "python3 -m unittest discover -s runner/tests",
-    "build:adapters": "python3 scripts/build_adapters.py",
-    "check:adapters": "python3 scripts/build_adapters.py --check",
-    "validate:claude": "claude plugin validate --strict .claude-plugin/marketplace.json && claude plugin validate --strict .",
-    "prepack": "python3 scripts/build_adapters.py && python3 -m unittest discover -s runner/tests",
-    "install-local": "bash install.sh"
-  },
-  "devDependencies": {
-    "@biomejs/biome": "2.5.15",
-    "esbuild": "0.28.2"
-  }
+    "ai",
+    "agents",
+    "factory"
+  ]
 }

package/rpc.ts

@@ -0,0 +1 @@
+export { EsRpc } from "./src/rpc-def.ts"

package/server.ts

@@ -0,0 +1 @@
+export { default } from "./src/server.ts"

package/src/agents.ts

@@ -0,0 +1,69 @@
+// Compile the canonical agent registry into OpenCode v2 agents. Additive only:
+// we add our own agents and never edit built-ins, default_agent or models.
+// Per-agent tool/skill/MCP scoping is expressed as wildcard-deny permission
+// rules (proven in M0: denied tools, MCP tools and skills are not advertised).
+import { AGENTS, type AgentSpec, ALL_ES_TOOLS, loadPrompt } from "@heretek-ai/es-core"
+import type { PluginOptions } from "./runtime.ts"
+
+export interface CompiledAgent {
+  readonly spec: AgentSpec
+  readonly system: string
+  readonly permissions: Array<{ action: string; resource: string; effect: "allow" | "deny" | "ask" }>
+  readonly model?: { providerID: string; id: string }
+}
+
+export function permissionRules(spec: AgentSpec, mcpServers: readonly string[]): CompiledAgent["permissions"] {
+  const rules: CompiledAgent["permissions"] = [
+    { action: "es_*", resource: "*", effect: "deny" },
+    ...spec.tools.map((tool) => ({ action: tool, resource: "*", effect: "allow" as const })),
+    { action: "subagent", resource: "*", effect: "deny" },
+    ...spec.spawns.map((agent) => ({ action: "subagent", resource: agent, effect: "allow" as const })),
+    { action: "skill", resource: "*", effect: "deny" },
+    ...spec.skills.map((skill) => ({ action: "skill", resource: skill, effect: "allow" as const })),
+  ]
+  for (const server of mcpServers)
+    if (!spec.mcp.includes(server))
+      rules.push({ action: `${server.replace(/[^\w-]/g, "_")}_*`, resource: "*", effect: "deny" })
+  if (spec.mode === "subagent") {
+    // Autonomous seats never wait on a human: no questions, no paths outside the project except /tmp.
+    rules.push({ action: "question", resource: "*", effect: "deny" })
+    rules.push({ action: "external_directory", resource: "*", effect: "deny" })
+    // Sonar S5443 flags the /tmp literal; it governs creating temp files, while
+    // this only grants autonomous seats access to a scratch directory.
+    rules.push({ action: "external_directory", resource: "/tmp/*", effect: "allow" }) // NOSONAR
+  }
+  if (spec.writes.length === 0) rules.push({ action: "edit", resource: "*", effect: "deny" })
+  if (spec.lsp === "none") rules.push({ action: "lsp", resource: "*", effect: "deny" })
+  if (spec.lsp !== "full") rules.push({ action: "lsp_rename", resource: "*", effect: "deny" })
+  return rules
+}
+
+function modelFor(spec: AgentSpec, options: PluginOptions) {
+  const ref = options.models?.agents?.[spec.id] ?? options.models?.[spec.tier]
+  const slash = ref?.indexOf("/") ?? -1
+  if (!ref || slash <= 0) return undefined
+  return { providerID: ref.slice(0, slash), id: ref.slice(slash + 1) }
+}
+
+export async function compileAgents(options: PluginOptions, mcpServers: readonly string[]): Promise<CompiledAgent[]> {
+  return Promise.all(
+    AGENTS.map(async (spec) => {
+      const prompt = await loadPrompt(spec.prompt)
+      const model = modelFor(spec, options)
+      return {
+        spec,
+        system: `${prompt.body}\n\n<!-- epistemic-swarm prompt ${prompt.meta.id} v${prompt.meta.version} -->`,
+        permissions: permissionRules(spec, mcpServers),
+        ...(model ? { model } : {}),
+      }
+    }),
+  )
+}
+
+/** es_* tools an agent may see. Agents outside the registry get only the read-only ones. */
+export function visibleEsTools(agentId: string | undefined): readonly string[] {
+  const spec = AGENTS.find((agent) => agent.id === agentId)
+  return spec ? spec.tools : ["es_status", "es_gates_run"]
+}
+
+export { ALL_ES_TOOLS }

package/src/continue.ts

@@ -0,0 +1,40 @@
+// Factory continuation: when the factory's own session finishes a turn while
+// work remains (not halted, not waiting on a human approval or the grill), we
+// re-prompt it to continue. Progress-aware: three idle turns without any state
+// change stop the loop so a confused agent cannot spin on budget.
+import { factorySummary, pendingApprovals } from "@heretek-ai/es-core"
+import type { Runtime } from "./runtime.ts"
+
+const ACTIVE = new Set(["RESEARCH", "SPEC", "BUILD", "QA", "RELEASE"])
+const STALL_LIMIT = 3
+
+export function createFactoryContinuation(
+  ctx: { session: { prompt(input: any): Promise<unknown> } },
+  runtime: Runtime,
+) {
+  const stalls = new Map<string, { print: string; count: number }>()
+  return async (
+    event: { type: string; data?: { sessionID?: string } },
+    agentOf: (sessionID: string) => Promise<string | undefined>,
+  ) => {
+    const sessionID = event.data?.sessionID
+    if (event.type !== "session.execution.succeeded" || !sessionID) return
+    if ((await agentOf(sessionID)) !== "factory") return
+    const state = await runtime.factory.read()
+    if (!state || !ACTIVE.has(state.stage)) return
+    if ((await pendingApprovals(runtime.root)).length) return
+    const print = JSON.stringify([
+      state.stage,
+      state.activePhase,
+      state.phases.map((phase) => [phase.status, phase.failures, phase.history.length]),
+    ])
+    const previous = stalls.get(sessionID)
+    const count = previous?.print === print ? previous.count + 1 : 0
+    stalls.set(sessionID, { print, count })
+    if (count >= STALL_LIMIT) return
+    await ctx.session.prompt({
+      sessionID,
+      text: `${factorySummary(state)}\nThe factory run is not finished. Continue from the current stage (no human is needed unless an approval is due).`,
+    })
+  }
+}

package/src/hooks.ts

@@ -0,0 +1,283 @@
+// Hook bridge: Claude Code hooks (from .opencode/hooks.json and
+// .claude/settings*.json) running inside OpenCode v2.
+//
+//   PreToolUse          ← tool.execute.before (deny blocks; updatedInput rewrites;
+//                          "ask" defers to the host permission prompt)
+//   PostToolUse(Failure)← tool.execute.after (feedback/context appended, output replaced)
+//   UserPromptSubmit    ← session prompt admission (block rejects, context appended)
+//   SessionStart        ← first prompt of a session (startup) and after compaction
+//   PermissionRequest   ← permission.evaluate when the host would ask
+//   x-es.ShellPreExec   ← shell.create.before
+//   Stop (emulated)     ← session.execution.succeeded: a block re-prompts the
+//                          session (8-continuation cap). ADVISORY for plain chat:
+//                          the host has already ended the turn when we re-prompt.
+import {
+  bwrapAvailable,
+  fromOpenCode,
+  HookEngine,
+  permissionActionTool,
+  shellQuote,
+  toOpenCodeInput,
+} from "@heretek-ai/es-core"
+import { Error as ToolError } from "@opencode/plugin/promise/tool"
+import type { Runtime } from "./runtime.ts"
+
+const PERMISSION_CHECKED = new Set([
+  "read",
+  "write",
+  "edit",
+  "patch",
+  "shell",
+  "glob",
+  "grep",
+  "webfetch",
+  "websearch",
+  "skill",
+  "subagent",
+  "question",
+])
+const STOP_CAP = 8
+
+type Ctx = {
+  readonly generate: { text(input: any): Promise<{ text: string }> }
+  readonly session: {
+    prompt(input: any): Promise<unknown>
+    context(input: any): Promise<readonly any[]>
+    interrupt(input: any): Promise<unknown>
+  }
+}
+
+export interface HookBridge {
+  readonly engine: HookEngine
+  before(event: { tool: string; agent: string; id: string; sessionID: string; input: unknown }): Promise<void>
+  after(event: {
+    tool: string
+    agent: string
+    id: string
+    sessionID: string
+    input: unknown
+    status: string
+    result?: any
+    error?: any
+  }): Promise<void>
+  prompt(event: { sessionID: string; prompt: { text: string } }, agent?: string): Promise<void>
+  context(event: { sessionID: string; agent: string; system: any[] }): Promise<void>
+  evaluate(event: {
+    sessionID: string
+    agent?: string
+    action: string
+    resources: readonly string[]
+    effect: string
+    message?: string
+    source?: { id: string }
+  }): Promise<void>
+  shell(event: { command: string; cwd: string }): Promise<void>
+  onEvent(
+    event: { type: string; data?: any },
+    agentOf: (sessionID: string) => Promise<string | undefined>,
+  ): Promise<void>
+}
+
+function lastAssistantText(context: readonly any[]): string {
+  for (let i = context.length - 1; i >= 0; i--) {
+    const message = context[i]
+    if (message?.type !== "assistant") continue
+    const text = (message.content ?? [])
+      .filter((part: any) => part?.type === "text")
+      .map((part: any) => part.text ?? "")
+      .join("")
+    if (text) return text
+  }
+  return ""
+}
+
+export async function createHookBridge(
+  ctx: Ctx,
+  runtime: Runtime,
+  mcpServers: () => readonly string[],
+): Promise<HookBridge> {
+  const engine = await HookEngine.create({
+    root: runtime.root,
+    stateDir: runtime.stateDir,
+    generate: async (prompt, model) => {
+      const slash = model?.indexOf("/") ?? -1
+      const ref = model && slash > 0 ? { providerID: model.slice(0, slash), id: model.slice(slash + 1) } : undefined
+      return (await ctx.generate.text({ prompt, ...(ref ? { model: ref } : {}) })).text
+    },
+  })
+  const pendingContext = new Map<string, string[]>()
+  const pendingAsk = new Map<string, string>()
+  const sessionContext = new Map<string, string[]>()
+  const startedSessions = new Set<string>()
+  const continuations = new Map<string, number>()
+  const base = (sessionId: string, agent?: string) => ({ sessionId, ...(agent ? { agent } : {}) })
+
+  const stash = (map: Map<string, string[]>, key: string, texts: readonly string[]) => {
+    if (texts.length) map.set(key, [...(map.get(key) ?? []), ...texts])
+  }
+
+  return {
+    engine,
+
+    async before(event) {
+      await engine.refresh()
+      if (!engine.has("PreToolUse")) return
+      const tool = fromOpenCode(event.tool, event.input, runtime.root, mcpServers())
+      const decision = await engine.preToolUse(base(event.sessionID, event.agent), tool, event.id)
+      if (decision.stop) {
+        await ctx.session.interrupt({ sessionID: event.sessionID }).catch(() => undefined)
+        throw new ToolError({ message: `Stopped by a hook: ${decision.stop}` })
+      }
+      if (decision.decision === "deny") throw new ToolError({ message: decision.reason ?? "Denied by a hook" })
+      if (decision.decision === "defer")
+        throw new ToolError({ message: `Deferred by a hook${decision.reason ? `: ${decision.reason}` : ""}` })
+      if (decision.decision === "ask") {
+        const builtIn =
+          PERMISSION_CHECKED.has(event.tool) ||
+          mcpServers().some((server) => event.tool.startsWith(`${server.replace(/[^\w-]/g, "_")}_`))
+        if (!builtIn)
+          throw new ToolError({
+            message: `A hook asked for approval, but ${event.tool} has no permission prompt to ask with; denied.`,
+          })
+        pendingAsk.set(event.id, decision.reason ?? "A hook asked to confirm this call")
+      }
+      if (decision.updatedInput)
+        event.input = toOpenCodeInput(event.tool, decision.updatedInput, runtime.root, event.input)
+      stash(pendingContext, event.id, [
+        ...decision.additionalContext,
+        ...decision.systemMessages.map((text) => `Hook message: ${text}`),
+      ])
+    },
+
+    async after(event) {
+      continuations.delete(event.sessionID)
+      pendingAsk.delete(event.id)
+      const earlier = pendingContext.get(event.id) ?? []
+      pendingContext.delete(event.id)
+      const failed = event.status !== "completed"
+      const texts = [...earlier]
+      let replacement: unknown
+      if (engine.has(failed ? "PostToolUseFailure" : "PostToolUse")) {
+        const tool = fromOpenCode(event.tool, event.input, runtime.root, mcpServers())
+        const response = failed
+          ? (event.error?.message ?? "tool failed")
+          : (event.result?.output ?? event.result?.content)
+        const post = await engine.postToolUse(base(event.sessionID, event.agent), tool, event.id, response, failed)
+        texts.push(
+          ...post.feedback,
+          ...post.additionalContext,
+          ...post.systemMessages.map((text) => `Hook message: ${text}`),
+        )
+        replacement = post.updatedToolOutput
+        if (post.stop) await ctx.session.interrupt({ sessionID: event.sessionID }).catch(() => undefined)
+      }
+      if (failed || (!texts.length && replacement === undefined)) return
+      const original =
+        replacement === undefined
+          ? event.result?.content
+          : typeof replacement === "string"
+            ? replacement
+            : JSON.stringify(replacement)
+      const block = texts.length ? `<hook-feedback>\n${texts.join("\n")}\n</hook-feedback>` : ""
+      const content =
+        typeof original === "string" || original === undefined
+          ? [original ?? "", block].filter(Boolean).join("\n\n")
+          : [...original, ...(block ? [{ type: "text", text: block }] : [])]
+      event.result = { ...event.result, content }
+    },
+
+    async prompt(event, agent) {
+      await engine.refresh()
+      if (!startedSessions.has(event.sessionID)) {
+        startedSessions.add(event.sessionID)
+        if (engine.has("SessionStart"))
+          stash(
+            sessionContext,
+            event.sessionID,
+            (await engine.sessionStart(base(event.sessionID, agent), "startup")).additionalContext,
+          )
+      }
+      if (!engine.has("UserPromptSubmit")) return
+      const decision = await engine.userPromptSubmit(base(event.sessionID, agent), event.prompt.text)
+      if (decision.block) throw new Error(`Prompt blocked by a hook: ${decision.block}`)
+      const context = [...decision.additionalContext, ...decision.systemMessages.map((text) => `Hook message: ${text}`)]
+      if (context.length)
+        event.prompt.text = `${event.prompt.text}\n\n<system-reminder>\n${context.join("\n")}\n</system-reminder>`
+    },
+
+    context(event) {
+      const texts = sessionContext.get(event.sessionID)
+      if (texts?.length)
+        event.system.push({ type: "text", text: `<session-start-hooks>\n${texts.join("\n")}\n</session-start-hooks>` })
+      return Promise.resolve()
+    },
+
+    async evaluate(event) {
+      const asked = event.source ? pendingAsk.get(event.source.id) : undefined
+      if (event.effect === "deny") return
+      if (asked) {
+        event.effect = "ask"
+        event.message = asked
+      }
+      if (event.effect !== "ask" || !engine.has("PermissionRequest")) return
+      const tool = {
+        name: permissionActionTool(event.action),
+        aliases: [permissionActionTool(event.action), event.action],
+        input: { resources: [...event.resources] },
+      }
+      const decision = await engine.permissionRequest(base(event.sessionID, event.agent), tool)
+      if (decision.behavior === "deny") {
+        event.effect = "deny"
+        event.message = decision.message ?? "Denied by a hook"
+      } else if (decision.behavior === "allow" && !asked) event.effect = "allow"
+    },
+
+    async shell(event) {
+      if (!engine.has("x-es.ShellPreExec")) return
+      const decision = await engine.shellPreExec(base(""), { command: event.command, cwd: event.cwd })
+      if (decision.deny)
+        event.command = `printf '%s\\n' ${shellQuote(`Blocked by a hook: ${decision.deny}`)} >&2; exit 126`
+      else if (decision.command) event.command = decision.command
+    },
+
+    async onEvent(event, agentOf) {
+      const sessionID = event.data?.sessionID
+      if (!sessionID) return
+      if (event.type === "session.compaction.ended" && engine.has("SessionStart")) {
+        const agent = await agentOf(sessionID)
+        stash(
+          sessionContext,
+          sessionID,
+          (await engine.sessionStart(base(sessionID, agent), "compact")).additionalContext,
+        )
+        return
+      }
+      if (event.type !== "session.execution.succeeded" || !engine.has("Stop")) return
+      const count = continuations.get(sessionID) ?? 0
+      if (count >= STOP_CAP) {
+        continuations.delete(sessionID)
+        return
+      }
+      const agent = await agentOf(sessionID)
+      const context = await ctx.session.context({ sessionID }).catch(() => [] as any[])
+      const decision = await engine.stop(base(sessionID, agent), {
+        stopHookActive: count > 0,
+        lastAssistantMessage: lastAssistantText(context),
+      })
+      const feedback = [decision.block, ...decision.additionalContext].filter(Boolean)
+      if (!feedback.length) {
+        continuations.delete(sessionID)
+        return
+      }
+      continuations.set(sessionID, count + 1)
+      await ctx.session
+        .prompt({
+          sessionID,
+          text: `<system-reminder>\nStop hook feedback (continuing):\n${feedback.join("\n")}\n</system-reminder>`,
+        })
+        .catch(() => undefined)
+    },
+  }
+}
+
+export { bwrapAvailable }