@heretek-ai/epistemic-swarm 0.4.7 → 0.4.8

package/runner/tests/test_opencode_ux.py

@@ -42,18 +42,47 @@ def last_json_object(stdout):
     return json.loads(lines[-1])
 
 
+# Shared V2 mock: captures the tool map produced by `tool.transform` without a
+# real host. The old tests drove `plugin.server()` — a V1 hook that no longer
+# exists — so every tool assertion has to go through the V2 domain instead.
+V2_TOOL_SETUP = """
+            import plugin from "./plugins/opencode/index.js";
+            const toolMap = {};
+            const host = {
+              options: {},
+              command: {
+                list: async () => ({data: []}),
+                transform: async () => ({dispose: () => {}}),
+                reload: async () => {}
+              },
+              tool: {
+                transform: async (fn) => {
+                  fn({add: (t) => { toolMap[t.name] = t; }});
+                  return {dispose: () => {}};
+                },
+                reload: async () => {}
+              },
+              session: { prompt: async () => ({}) }
+            };
+            await plugin.setup(host);
+"""
+
+
 class TestOpenCodeCommandCatalog(unittest.TestCase):
     def test_catalog_shape_and_registration(self):
+        # V2 only: the V1 `server()` config hook wrote the deprecated `command`
+        # key and registered nothing on a v2 host. The declarative catalog is
+        # now exposed as `commandCatalog()` (V2 key: `commands`); live hosts
+        # register through `command.transform` — covered in
+        # TestOpenCodeV2Transforms.
         res = run_node(
             """
-            import plugin, { OPENCODE_COMMANDS, registerOpenCodeCommands } from "./plugins/opencode/index.js";
-            const shell = await plugin.server();
-            const cfg = {};
-            shell.config(cfg);
+            import { OPENCODE_COMMANDS, commandCatalog } from "./plugins/opencode/index.js";
+            const catalog = commandCatalog();
             console.log(JSON.stringify({
               catalog: OPENCODE_COMMANDS.map(c => ({name: c.name, hasDesc: !!c.description, hasArgs: c.template.includes("$ARGUMENTS")})),
-              registered: Object.keys(cfg.command || {}),
-              templates: Object.fromEntries(Object.entries(cfg.command || {}).map(([k, v]) => [k, !!v.description && !!v.template]))
+              registered: Object.keys(catalog),
+              templates: Object.fromEntries(Object.entries(catalog).map(([k, v]) => [k, !!v.description && !!v.template]))
             }));
             """
         )
@@ -75,6 +104,25 @@ class TestOpenCodeCommandCatalog(unittest.TestCase):
             self.assertIn(c, data["registered"])
             self.assertTrue(data["templates"][c])
 
+    def test_catalog_uses_v2_commands_key(self):
+        """`command` is the deprecated V1 key and is ignored by a V2 host."""
+        res = run_node(
+            """
+            import plugin from "./plugins/opencode/index.js";
+            console.log(JSON.stringify({
+              hasServer: typeof plugin.server,
+              hasSetup: typeof plugin.setup,
+              hasConfigHook: false
+            }));
+            """
+        )
+        self.assertEqual(res.returncode, 0, f"entrypoint shape test failed: {res.stderr}")
+        data = last_json_object(res.stdout)
+        # V1 `server()` is gone: a v2 host never calls it, and keeping it meant
+        # the real registration path had to guess which host it was talking to.
+        self.assertNotEqual(data["hasServer"], "function")
+        self.assertEqual(data["hasSetup"], "function")
+
     def test_empty_arg_guards(self):
         res = run_node(
             """
@@ -91,43 +139,64 @@ class TestOpenCodeCommandCatalog(unittest.TestCase):
         self.assertEqual(len(data["withUsage"]), data["total"])
 
     def test_async_execute_resolves(self):
+        # V2 tool results are `{content}` only (the V1 map added a `status`
+        # field, which the V2 domain does not have).
         res = run_node(
-            """
-            import plugin from "./plugins/opencode/index.js";
-            const shell = await plugin.server();
+            V2_TOOL_SETUP
+            + """
             let ticked = false;
             const timer = setInterval(() => { ticked = true; }, 5);
-            const r = await shell.tool.iumbtems_config.execute({});
+            const r = await toolMap.iumbtems_config.execute({});
             clearInterval(timer);
-            console.log(JSON.stringify({status: r.status, hasContent: typeof r.content === "string" && r.content.length > 0, loopAlive: ticked}));
+            console.log(JSON.stringify({
+              hasContent: typeof r.content === "string" && r.content.length > 0,
+              shapeOk: Object.keys(r).sort().join(",") === "content",
+              loopAlive: ticked
+            }));
             """
         )
         self.assertEqual(res.returncode, 0, f"async execute test failed: {res.stderr}")
         data = last_json_object(res.stdout)
-        self.assertEqual(data["status"], "success")
         self.assertTrue(data["hasContent"])
+        self.assertTrue(data["shapeOk"])
         self.assertTrue(data["loopAlive"])
 
-    def test_registration_never_overwrites(self):
+    def test_v2_skips_preexisting_command_names(self):
+        """Names already present at setup time are respected, not overwritten.
+
+        This is the dedupe half of the replay fix: the skip set must be a
+        snapshot taken at setup, not a set that grows across transform replays.
+        """
         res = run_node(
             """
-            import { registerOpenCodeCommands } from "./plugins/opencode/index.js";
-            const cfg = {command: {swarm: {description: "mine", template: "mine"}}};
-            registerOpenCodeCommands(cfg);
-            console.log(JSON.stringify({swarm: cfg.command.swarm, count: Object.keys(cfg.command).length}));
+            import plugin from "./plugins/opencode/index.js";
+            const added = [];
+            const host = {
+              options: {},
+              command: {
+                list: async () => ({data: [{name: "swarm"}]}),
+                transform: async (fn) => { fn({add: (d) => added.push(d)}); return {dispose: () => {}}; },
+                reload: async () => {}
+              },
+              tool: { transform: async () => ({dispose: () => {}}) },
+              session: { prompt: async () => ({}) }
+            };
+            await plugin.setup(host);
+            console.log(JSON.stringify({names: added.map(c => c.name)}));
             """
         )
-        self.assertEqual(res.returncode, 0, f"no-overwrite test failed: {res.stderr}")
+        self.assertEqual(res.returncode, 0, f"preexisting-name test failed: {res.stderr}")
         data = last_json_object(res.stdout)
-        self.assertEqual(data["swarm"], {"description": "mine", "template": "mine"})
-        self.assertEqual(data["count"], len(EXPECTED_COMMANDS))
+        # `swarm` was already registered by the user, so we add the other six.
+        self.assertNotIn("swarm", data["names"])
+        self.assertEqual(len(data["names"]), len(EXPECTED_COMMANDS) - 1)
 
     def test_tool_map_shape(self):
         res = run_node(
-            """
-            import plugin, { IUMBTEMS_TOOL_NAMES } from "./plugins/opencode/index.js";
-            const shell = await plugin.server();
-            const entries = Object.entries(shell.tool);
+            V2_TOOL_SETUP
+            + """
+            import { IUMBTEMS_TOOL_NAMES } from "./plugins/opencode/index.js";
+            const entries = Object.entries(toolMap);
             console.log(JSON.stringify({
               keys: entries.map(([k]) => k),
               canonical: IUMBTEMS_TOOL_NAMES,
@@ -416,18 +485,36 @@ class TestOpenCodeLifecycle(unittest.TestCase):
         self.assertFalse(data["empty"])
 
     def test_compaction_hook_pushes_state(self):
+        # V2 shape: `session.hook("compaction", fn)` pushes a text part onto
+        # `event.system`. The old `experimental.session.compacting` hook lived
+        # in the V1 `server()` factory and was dead code on a V2 host.
         with tempfile.TemporaryDirectory() as tmp:
             root = self._fixture(tmp)
             res = run_node(
                 f"""
                 import plugin from "./plugins/opencode/index.js";
-                const shell = await plugin.server();
-                const hook = shell["experimental.session.compacting"];
-                const out = {{context: []}};
-                await hook({{directory: {root!r}}}, out);
-                const empty = {{context: []}};
-                await hook({{directory: "/tmp/oc-lifecycle-empty"}}, empty);
-                console.log(JSON.stringify({{hook: typeof hook, pushed: out.context.length, text: out.context[0] || "", skipped: empty.context.length}}));
+                let handler = null;
+                const host = {{
+                  options: {{}},
+                  location: {{directory: {root!r}}},
+                  command: {{list: async () => ({{data: []}}), transform: async () => ({{dispose: async () => {{}}}}), reload: async () => {{}}}},
+                  tool: {{transform: async () => ({{dispose: async () => {{}}}}), reload: async () => {{}}}},
+                  session: {{
+                    prompt: async () => ({{}}),
+                    hook: async (name, fn) => {{ if (name === "compaction") handler = fn; return {{dispose: async () => {{}}}}; }}
+                  }}
+                }};
+                await plugin.setup(host);
+                const out = {{system: [], directory: {root!r}}};
+                if (handler) await handler(out);
+                const empty = {{system: [], directory: "/tmp/oc-lifecycle-empty-nonexistent"}};
+                if (handler) await handler(empty);
+                console.log(JSON.stringify({{
+                  hook: typeof handler,
+                  pushed: out.system.length,
+                  text: (out.system[0] && out.system[0].text) || "",
+                  skipped: empty.system.length
+                }}));
                 """
             )
             self.assertEqual(res.returncode, 0, f"compaction test failed: {res.stderr}")
@@ -503,7 +590,7 @@ class TestOpenCodeV2Transforms(unittest.TestCase):
         )
         self.assertEqual(res.returncode, 0, f"v2 transform test failed: {res.stderr}")
         data = last_json_object(res.stdout)
-        self.assertEqual(data["cleanupFn"], True)
+        self.assertTrue(data["cleanupFn"])
         for c in [
             "swarm",
             "grill",
@@ -563,7 +650,7 @@ class TestOpenCodeV2Transforms(unittest.TestCase):
         )
         self.assertEqual(res.returncode, 0, f"bare setup test failed: {res.stderr}")
         data = last_json_object(res.stdout)
-        self.assertEqual(data["cleanupFn"], True)
+        self.assertTrue(data["cleanupFn"])
 
     def test_options_applied_to_location_dir_after_transforms(self):
         import tempfile
@@ -618,6 +705,254 @@ class TestOpenCodeV2Transforms(unittest.TestCase):
         self.assertTrue(data["cleanupFn"])
         self.assertTrue(data["aborted"])
 
+    # ------------------------------------------------------------------
+    # Regression tests for the vanishing-slash-commands defect.
+    #
+    # The host REPLAYS a command transform callback on every registry rebuild.
+    # The old code kept one `existing` Set closed over from setup and mutated it
+    # inside the callback, so replay 2 saw every name as "already added" and
+    # registered nothing — commands appeared at startup and vanished seconds
+    # later. The mock used to invoke the callback exactly once, so the suite was
+    # structurally blind to it.
+    # ------------------------------------------------------------------
+
+    REPLAY_SETUP = """
+            import plugin from "./plugins/opencode/index.js";
+            const passes = [];
+            let captured = null;
+            const host = {
+              options: {},
+              command: {
+                // Emulate a host whose registry is rebuilt from base config on
+                // each pass: our commands are NOT pre-existing at setup time,
+                // and are wiped before every replay.
+                list: async () => ({data: [{name: "goal"}]}),
+                transform: async (fn) => { captured = fn; return {dispose: () => {}}; },
+                reload: async () => {}
+              },
+              tool: {
+                transform: async () => ({dispose: () => {}}),
+                reload: async () => {}
+              },
+              session: { prompt: async () => ({}) }
+            };
+            const cleanup = await plugin.setup(host);
+            for (let i = 0; i < 3; i++) {
+              const draftAdds = [];
+              captured({add: (d) => draftAdds.push(d)});
+              passes.push(draftAdds.map((d) => d.name));
+            }
+"""
+
+    def test_v2_command_transform_is_replay_safe(self):
+        """Every replay must re-add all commands. This is the vanish bug."""
+        res = run_node(
+            self.REPLAY_SETUP
+            + """
+            console.log(JSON.stringify({passes}));
+            """
+        )
+        self.assertEqual(res.returncode, 0, f"replay test failed: {res.stderr}")
+        passes = last_json_object(res.stdout)["passes"]
+        self.assertEqual(len(passes), 3)
+        for i, added in enumerate(passes):
+            self.assertEqual(
+                len(added),
+                len(EXPECTED_COMMANDS),
+                f"transform pass {i} added {len(added)} commands, expected "
+                f"{len(EXPECTED_COMMANDS)} — a replay must not skip our names "
+                f"({added})",
+            )
+            for c in EXPECTED_COMMANDS:
+                self.assertIn(c, added)
+
+    def test_v2_setup_return_is_a_function(self):
+        """Returning a plain object aborts host reload: `de is not a function`."""
+        res = run_node(
+            REPLAY_SINGLE
+            + """
+            console.log(JSON.stringify({type: typeof cleanup}));
+            """
+        )
+        self.assertEqual(res.returncode, 0, f"setup-return test failed: {res.stderr}")
+        self.assertEqual(last_json_object(res.stdout)["type"], "function")
+
+    def test_v2_cleanup_disposes_registrations(self):
+        res = run_node(
+            """
+            import plugin from "./plugins/opencode/index.js";
+            const disposed = [];
+            const mk = (label) => ({dispose: async () => { disposed.push(label); }});
+            const host = {
+              options: {},
+              command: {
+                list: async () => ({data: []}),
+                transform: async () => mk("command"),
+                reload: async () => {}
+              },
+              tool: {
+                transform: async () => mk("tool"),
+                reload: async () => {}
+              },
+              session: {
+                prompt: async () => ({}),
+                hook: async () => mk("compaction")
+              }
+            };
+            const cleanup = await plugin.setup(host);
+            await cleanup();
+            console.log(JSON.stringify({disposed}));
+            """
+        )
+        self.assertEqual(res.returncode, 0, f"dispose test failed: {res.stderr}")
+        disposed = last_json_object(res.stdout)["disposed"]
+        # Every transform/hook handle must be disposed on teardown, otherwise a
+        # stale registration can make command.list() report names with no live
+        # handler — which is what makes the skip-check fire on the next setup.
+        self.assertIn("command", disposed)
+        self.assertIn("tool", disposed)
+        self.assertIn("compaction", disposed)
+
+    def test_v2_repeated_setup_cycles_register_both_times(self):
+        """setup -> cleanup -> setup must re-register (the reload path)."""
+        res = run_node(
+            """
+            import plugin from "./plugins/opencode/index.js";
+            const perSetup = [];
+            for (let cycle = 0; cycle < 2; cycle++) {
+              const added = [];
+              let captured = null;
+              const host = {
+                options: {},
+                command: {
+                  list: async () => ({data: []}),
+                  transform: async (fn) => { captured = fn; return {dispose: async () => {}}; },
+                  reload: async () => {}
+                },
+                tool: { transform: async () => ({dispose: async () => {}}), reload: async () => {} },
+                session: { prompt: async () => ({}) }
+              };
+              const cleanup = await plugin.setup(host);
+              captured({add: (d) => added.push(d.name)});
+              perSetup.push(added);
+              await cleanup();
+            }
+            console.log(JSON.stringify({perSetup}));
+            """
+        )
+        self.assertEqual(res.returncode, 0, f"setup-cycle test failed: {res.stderr}")
+        per_setup = last_json_object(res.stdout)["perSetup"]
+        self.assertEqual(len(per_setup), 2)
+        for i, added in enumerate(per_setup):
+            self.assertEqual(
+                len(added), len(EXPECTED_COMMANDS),
+                f"setup cycle {i} registered {len(added)} commands",
+            )
+
+    def test_v2_compaction_hook_preserves_state(self):
+        """The V1 `experimental.session.compacting` hook was dead code on V2.
+
+        Uses a real fixture workspace: `buildCompactionContext` returns null
+        without `.research/config.json`, and pointing at `process.cwd()` made
+        this pass only where a developer happened to have one.
+        """
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            rd = root / ".research"
+            rd.mkdir()
+            (rd / "config.json").write_text(
+                json.dumps({"mode": "audit", "search_engine": "duckduckgo", "max_iterations": 2}),
+                encoding="utf-8",
+            )
+            res = run_node(
+                f"""
+                import plugin from "./plugins/opencode/index.js";
+                let hookName = null;
+                let handler = null;
+                const host = {{
+                  options: {{}},
+                  location: {{directory: {str(root)!r}}},
+                  command: {{list: async () => ({{data: []}}), transform: async () => ({{dispose: async () => {{}}}}), reload: async () => {{}}}},
+                  tool: {{transform: async () => ({{dispose: async () => {{}}}}), reload: async () => {{}}}},
+                  session: {{
+                    prompt: async () => ({{}}),
+                    hook: async (name, fn) => {{ hookName = name; handler = fn; return {{dispose: async () => {{}}}}; }}
+                  }}
+                }};
+                await plugin.setup(host);
+                const event = {{system: [], directory: {str(root)!r}}};
+                if (handler) await handler(event);
+                const emptyEvent = {{system: [], directory: "/tmp/oc-v2-compaction-empty-nonexistent"}};
+                if (handler) await handler(emptyEvent);
+                console.log(JSON.stringify({{
+                  hookName,
+                  parts: event.system.map((p) => ({{type: p.type, text: p.text || ""}})),
+                  emptySkipped: emptyEvent.system.length
+                }}));
+                """
+            )
+            self.assertEqual(res.returncode, 0, f"compaction hook test failed: {res.stderr}")
+            data = last_json_object(res.stdout)
+            self.assertEqual(data["hookName"], "compaction")
+            self.assertEqual(data["emptySkipped"], 0, "empty workspace must not push state")
+            self.assertTrue(
+                data["parts"]
+                and data["parts"][0]["type"] == "text"
+                and "mode=audit" in data["parts"][0]["text"],
+                f"compaction hook did not push state onto event.system: {data}",
+            )
+
+    def test_v2_logs_never_throw_and_surface_errors(self):
+        """Bare `catch {}` made failures invisible under --log-level all."""
+        res = run_node(
+            """
+            import plugin from "./plugins/opencode/index.js";
+            const logged = [];
+            const origError = console.error;
+            console.error = (...a) => { logged.push(a.join(" ")); };
+            const host = {
+              options: {},
+              command: {
+                list: async () => { throw new Error("registry unavailable"); },
+                transform: async (fn) => { fn({add: () => {}}); return {dispose: async () => {}}; },
+                reload: async () => {}
+              },
+              tool: {transform: async () => ({dispose: async () => {}}), reload: async () => {}},
+              session: {prompt: async () => ({})}
+            };
+            const cleanup = await plugin.setup(host);
+            await cleanup();
+            console.error = origError;
+            console.log(JSON.stringify({
+              logged,
+              mentionsFailure: logged.some((l) => /command\\.list|registry unavailable/.test(l))
+            }));
+            """
+        )
+        self.assertEqual(res.returncode, 0, f"logging test failed: {res.stderr}")
+        data = last_json_object(res.stdout)
+        self.assertTrue(
+            data["mentionsFailure"],
+            f"a swallowed error must be logged, not dropped: {data['logged']}",
+        )
+
+
+# One-shot REPLAY_SETUP equivalent that also yields the cleanup function.
+REPLAY_SINGLE = """
+            import plugin from "./plugins/opencode/index.js";
+            const host = {
+              options: {},
+              command: {
+                list: async () => ({data: []}),
+                transform: async () => ({dispose: async () => {}}),
+                reload: async () => {}
+              },
+              tool: {transform: async () => ({dispose: async () => {}}), reload: async () => {}},
+              session: {prompt: async () => ({})}
+            };
+            const cleanup = await plugin.setup(host);
+"""
+
 
 if __name__ == "__main__":
     unittest.main()

package/runner/tests/test_swarm.py

@@ -41,7 +41,7 @@ In our experiments, the 70B parameter model was trained on 15.0 trillion tokens.
             content=content,
             title="Chinchilla Scaling Laws",
         )
-        self.assertTrue(len(shash) == 64)
+        self.assertEqual(len(shash), 64)
 
         # 1. Exact quote match
         verified, conf, msg = self.hasher.verify_quote(
@@ -319,19 +319,30 @@ In our experiments, the 70B parameter model was trained on 15.0 trillion tokens.
         # 1. Test OpenCode Plugin registration (A2b: thin forwarders + both
         #    name exports — canonical IUMBTEMS_TOOL_NAMES and the deprecated
         #    IUMBEMS_TOOL_NAMES alias). Object form: server() resolves to
-        #    {config, tool} with the tool map keyed by name.
+        #    V2 shape: tools + commands are registered through the owning
+        #    domains inside setup(); the declarative catalog is commandCatalog().
+        #    (The V1 `server()` config hook is gone — it wrote the deprecated
+        #    `command` key and registered nothing on a v2 host.)
         node_code_oc = """
-        import plugin, { IUMBTEMS_TOOL_NAMES, IUMBEMS_TOOL_NAMES } from "./plugins/opencode/index.js";
-        const shell = await plugin.server();
-        const tools = Object.values(shell.tool);
+        import plugin, { IUMBTEMS_TOOL_NAMES, IUMBEMS_TOOL_NAMES, commandCatalog } from "./plugins/opencode/index.js";
+        const toolMap = {};
+        const host = {
+          options: {},
+          command: {list: async () => ({data: []}), transform: async () => ({dispose: async () => {}}), reload: async () => {}},
+          tool: {
+            transform: async (fn) => { fn({add: (t) => { toolMap[t.name] = t; }}); return {dispose: async () => {}}; },
+            reload: async () => {}
+          },
+          session: {prompt: async () => ({})}
+        };
+        await plugin.setup(host);
+        const tools = Object.values(toolMap);
         const names = tools.map(t => t.name);
-        const cfg = {};
-        shell.config(cfg);
         console.log(JSON.stringify({
           names,
           canonical: IUMBTEMS_TOOL_NAMES,
           alias: IUMBEMS_TOOL_NAMES,
-          commands: Object.keys(cfg.command || {})
+          commands: Object.keys(commandCatalog())
         }));
         """
         res_oc = subprocess.run(
@@ -370,7 +381,7 @@ In our experiments, the 70B parameter model was trained on 15.0 trillion tokens.
         ]
         for t in expected_tools:
             self.assertIn(t, tools)
-        # Slash-command catalog registered via the server config hook.
+        # Slash-command catalog (V2 `commands` shape).
         for c in [
             "swarm",
             "grill",