@heretek-ai/epistemic-swarm 0.4.4 → 0.4.6

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "epistemic-swarm",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "High-Integrity Dialectic Research Agent Harness for Claude Code enforcing empirical evidence over parametric hallucination.",
   "author": {
     "name": "Heretek AI",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heretek-ai/epistemic-swarm",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "IUMBTEMS: I Use My Brain To Express My Self — High-Integrity Dialectic Research Agent Harness for Claude Code, OpenCode V2, Pi, OMP (oh-my-pi), Gemini CLI, Codex CLI, and AntiGravity",
   "main": "bin/cli.js",
   "bin": {

package/plugins/antigravity/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://antigravity.google/schemas/v1/plugin.json",
   "name": "epistemic-swarm",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "IUMBTEMS Epistemic Swarm: dialectic research, code audit, OSS scout, and lateral brainstorming for AntiGravity.",
   "author": "Heretek AI",
   "license": "Apache-2.0",

package/plugins/gemini/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "epistemic-swarm",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "IUMBTEMS Epistemic Swarm: dialectic research, code audit, OSS scout, and lateral brainstorming for Gemini CLI.",
   "mcpServers": {
     "brave-search": {

package/plugins/opencode/index.js

@@ -563,6 +563,10 @@ export function buildCompactionContext(root) {
 
 const NUDGE_MIN_INTERVAL_MS = 5 * 60 * 1000;
 const activeNudges = new Map();
+// Cleanup functions for the setup() disposer (a setup that returns a plain
+// object crashes host reload: the host calls the return value as a cleanup
+// function). All setup-owned resources register here.
+const setupCleanups = new Set();
 
 /**
  * Handle one subscribed event: nudge once per ledger change when degraded
@@ -659,7 +663,8 @@ export function createOpenCodePlugin(context = {}) {
     }),
 
     setup: async (appContext) => {
-      const opts = context.options || appContext?.options;
+      const host = appContext || {};
+      const opts = context.options || host.options;
       if (opts && typeof opts === 'object') {
         const updates = {};
         if (opts.search_engine) updates.search_engine = opts.search_engine;
@@ -669,25 +674,97 @@ export function createOpenCodePlugin(context = {}) {
           updates.divergence_threshold = opts.divergence_threshold;
         }
         if (Object.keys(updates).length > 0) {
-          await callMcp('iumbtems_config', updates, appContext?.cwd);
+          await callMcp('iumbtems_config', updates, host.cwd);
         }
       }
       // Phase C: idle staleness nudge (opt out with {staleness_nudge: false}).
       // Subscribes only when the host exposes event/session; one per root.
       try {
         if ((opts?.staleness_nudge ?? true)) {
-          const host = {
-            event: appContext?.event || context.event,
-            session: appContext?.session || context.session,
+          const nudgeHost = {
+            event: host.event || context.event,
+            session: host.session || context.session,
           };
           const root =
-            appContext?.location?.directory || context.location?.directory;
-          if (root) startStalenessNudge(host, root);
+            host.location?.directory || context.location?.directory;
+          if (root) {
+            const stop = startStalenessNudge(nudgeHost, root);
+            if (typeof stop === 'function') setupCleanups.add(stop);
+          }
         }
       } catch {
         /* lifecycle hooks are best-effort */
       }
-      return { initialized: true, platform: 'opencode-v2' };
+      // V2 host transforms (official dual-package pattern: V1 calls server(),
+      // V2 calls setup()). Registers slash commands + tools via the owning
+      // domains; each guarded so V1 hosts and partial V2 hosts keep working.
+      try {
+        if (host.command && typeof host.command.transform === 'function') {
+          let existing = new Set();
+          try {
+            const listed = await host.command.list();
+            existing = new Set(((listed && listed.data) || []).map((c) => c && c.name));
+          } catch {
+            /* treat as empty */
+          }
+          await host.command.transform((draft) => {
+            for (const cmd of OPENCODE_COMMANDS) {
+              if (!cmd || !cmd.name || existing.has(cmd.name)) continue;
+              existing.add(cmd.name);
+              draft.add({
+                name: cmd.name,
+                description: cmd.description,
+                execute: async (input) => {
+                  const args = (input && input.prompt && input.prompt.text) || '';
+                  const prompt = (input && input.prompt && typeof input.prompt === 'object') ? input.prompt : {};
+                  await host.session.prompt({
+                    ...prompt,
+                    sessionID: input && input.sessionID,
+                    text: cmd.template.split('$ARGUMENTS').join(String(args).trim()),
+                    delivery: input && input.delivery,
+                  });
+                },
+              });
+            }
+          });
+        }
+      } catch {
+        /* command transform is best-effort */
+      }
+      try {
+        if (host.tool && typeof host.tool.transform === 'function') {
+          await host.tool.transform((draft) => {
+            for (const [name, spec] of Object.entries(buildToolMap())) {
+              draft.add({
+                name,
+                description: spec.description,
+                input: spec.input,
+                options: { codemode: false },
+                execute: async (args = {}, toolContext) => {
+                  const r = await callMcp(name, normalizeArgs(name, args), toolContext?.cwd);
+                  return { content: r.content };
+                },
+              });
+            }
+          });
+        }
+      } catch {
+        /* tool transform is best-effort */
+      }
+      // Disposer: the host calls setup's return value as a cleanup function
+      // on unload/reload. It MUST be a function (returning a plain object
+      // crashes host reload with "not a function"). Aborts nudge streams so
+      // reloads never stack duplicate subscriptions.
+      return () => {
+        for (const stop of [...setupCleanups]) {
+          setupCleanups.delete(stop);
+          try {
+            stop();
+          } catch {
+            /* cleanup is best-effort */
+          }
+        }
+      };
     },
   };
 }

package/runner/tests/test_opencode_ux.py

@@ -465,5 +465,129 @@ class TestOpenCodeLifecycle(unittest.TestCase):
             self.assertEqual(data["sid"], "ses_1")
 
 
+class TestOpenCodeV2Transforms(unittest.TestCase):
+    """V2 host (setup ctx transforms): commands + tools via owning domains."""
+
+    V2_SETUP = """
+            import plugin from "./plugins/opencode/index.js";
+            const addedCommands = [];
+            const addedTools = [];
+            const prompts = [];
+            const host = {
+              options: {},
+              command: {
+                list: async () => ({data: [{name: "goal"}]}),
+                transform: async (fn) => { fn({add: (d) => addedCommands.push(d)}); return () => {}; }
+              },
+              tool: {
+                transform: async (fn) => { fn({add: (t) => addedTools.push(t)}); return () => {}; }
+              },
+              session: { prompt: async (p) => { prompts.push(p); return {}; } }
+            };
+            const ret = await plugin.setup(host);
+            %s
+    """
+
+    def test_v2_registers_commands_and_tools(self):
+        res = run_node(
+            self.V2_SETUP
+            % """
+            console.log(JSON.stringify({
+              cleanupFn: typeof ret === "function",
+              commands: addedCommands.map(c => c.name),
+              cmdExec: typeof addedCommands.find(c => c.name === "swarm").execute,
+              tools: addedTools.map(t => t.name),
+              toolExec: typeof addedTools.find(t => t.name === "iumbtems_config").execute
+            }));
+            """
+        )
+        self.assertEqual(res.returncode, 0, f"v2 transform test failed: {res.stderr}")
+        data = last_json_object(res.stdout)
+        self.assertEqual(data["cleanupFn"], True)
+        for c in [
+            "swarm",
+            "grill",
+            "swarm-config",
+            "audit",
+            "scout",
+            "brainstorming",
+            "brainstorm",
+        ]:
+            self.assertIn(c, data["commands"])
+        self.assertNotIn("goal", data["commands"])
+        self.assertEqual(data["cmdExec"], "function")
+        self.assertEqual(len(data["tools"]), 13)
+        self.assertIn("iumbtems_brainstorm", data["tools"])
+        self.assertEqual(data["toolExec"], "function")
+
+    def test_v2_command_execute_forwards_prompt(self):
+        res = run_node(
+            self.V2_SETUP
+            % """
+            const swarm = addedCommands.find(c => c.name === "swarm");
+            await swarm.execute({sessionID: "ses_9", prompt: {text: "probe objective"}, delivery: "steer"});
+            console.log(JSON.stringify({prompts}));
+            """
+        )
+        self.assertEqual(res.returncode, 0, f"v2 execute test failed: {res.stderr}")
+        data = last_json_object(res.stdout)["prompts"]
+        self.assertEqual(len(data), 1)
+        self.assertEqual(data[0]["sessionID"], "ses_9")
+        self.assertIn("probe objective", data[0]["text"])
+        self.assertNotIn("$ARGUMENTS", data[0]["text"])
+        self.assertEqual(data[0]["delivery"], "steer")
+
+    def test_v2_tool_execute_returns_content(self):
+        res = run_node(
+            self.V2_SETUP
+            % """
+            const cfg = addedTools.find(t => t.name === "iumbtems_config");
+            const r = await cfg.execute({}, {});
+            console.log(JSON.stringify({keys: Object.keys(r), status: r.status, hasContent: typeof r.content === "string"}));
+            """
+        )
+        self.assertEqual(res.returncode, 0, f"v2 tool test failed: {res.stderr}")
+        data = last_json_object(res.stdout)
+        self.assertEqual(data["keys"], ["content"])
+        self.assertTrue(data["hasContent"])
+
+    def test_setup_without_v2_domains_still_works(self):
+        res = run_node(
+            """
+            import plugin from "./plugins/opencode/index.js";
+            const ret = await plugin.setup({});
+            ret();
+            ret();
+            console.log(JSON.stringify({cleanupFn: typeof ret === "function"}));
+            """
+        )
+        self.assertEqual(res.returncode, 0, f"bare setup test failed: {res.stderr}")
+        data = last_json_object(res.stdout)
+        self.assertEqual(data["cleanupFn"], True)
+
+    def test_setup_cleanup_aborts_nudge_streams(self):
+        res = run_node(
+            """
+            import plugin from "./plugins/opencode/index.js";
+            const seen = [];
+            const host = {
+              options: {},
+              location: {directory: "/tmp/oc-nudge-cleanup"},
+              event: {subscribe: (opts) => { seen.push(opts && opts.signal); return {[Symbol.asyncIterator]() { return {next: async () => ({done: true})}; }}; }},
+              session: {prompt: async () => ({})}
+            };
+            const cleanup = await plugin.setup(host);
+            const before = seen.length;
+            cleanup();
+            console.log(JSON.stringify({subscribed: before > 0, cleanupFn: typeof cleanup === "function", aborted: seen.length > 0 && seen[0].aborted === true}));
+            """
+        )
+        self.assertEqual(res.returncode, 0, f"cleanup test failed: {res.stderr}")
+        data = last_json_object(res.stdout)
+        self.assertTrue(data["subscribed"])
+        self.assertTrue(data["cleanupFn"])
+        self.assertTrue(data["aborted"])
+
+
 if __name__ == "__main__":
     unittest.main()