@heretek-ai/epistemic-swarm 0.7.6 → 0.7.8

package/runner/mcp_server.py

@@ -84,12 +84,16 @@ def _handle_config(args: Dict[str, Any]) -> str:
     """Inspect or modify swarm parameters in .research/config.json."""
     from skills.swarm_config.configure import (
         display_config,
+        heal_config,
         load_config,
         save_config,
     )
 
     base_dir = str(_resolve_base_dir(args))
     cfg = load_config(base_dir)
+    # Persist a legacy ["claude", "-p"] agent pin migration so an OpenCode host
+    # stops silently spawning Claude on every run.
+    healed = heal_config(base_dir)
 
     updates = {}
     for key in (
@@ -99,6 +103,8 @@ def _handle_config(args: Dict[str, Any]) -> str:
         "depth",
         "mode",
         "divergence_threshold",
+        "backend",
+        "agents",
     ):
         if key in args and args[key] is not None:
             canon = {
@@ -119,7 +125,7 @@ def _handle_config(args: Dict[str, Any]) -> str:
             }
         )
 
-    return _tool_text({"status": "current", "config": cfg})
+    return _tool_text({"status": "current", "config": cfg, "migrated": healed})
 
 
 def _run_swarm_mode(mode: Optional[str], args: Dict[str, Any]) -> str:

package/runner/research_swarm.py

@@ -66,6 +66,23 @@ def _backend_family(backend: List[str]) -> str:
     return Path(backend[0]).name if backend else "claude"
 
 
+def _agent_cwd(project_root: Path) -> str:
+    """Working directory for spawned agent processes.
+
+    The canonical agent prompts name evidence paths RELATIVELY (`.research/...`)
+    and the runner reads dossiers from `<base_dir>/scratchpads/...`. Spawning in
+    the package root made those writes land inside node_modules (denied). Spawn
+    in the project root instead so `.research/` means the operator's evidence
+    tree. Override with IUMBTEMS_AGENT_CWD=package|project|<absolute path>.
+    """
+    override = os.environ.get("IUMBTEMS_AGENT_CWD", "").strip()
+    if override == "package":
+        return str(PROJECT_ROOT)
+    if override and override != "project":
+        return override
+    return str(project_root)
+
+
 def _build_opencode_cmd(
     backend: List[str],
     prompt: str,
@@ -190,6 +207,13 @@ class SwarmRunner:
         domain_pack: Optional[str] = None,
     ):
         self.base_dir = base_dir or Path(".research")
+        # Project root = the directory containing the evidence dir. Agents are
+        # spawned here so the relative `.research/...` paths named by the
+        # canonical prompts resolve to the RUNNER's evidence tree. Spawning in
+        # PROJECT_ROOT (the installed package) sent those writes into
+        # node_modules, where they were denied and no agent-authored dossier
+        # ever landed — runs survived only on the stdout-recovery fallback.
+        self.project_root = Path(os.path.realpath(str(self.base_dir))).parent
         self.mock_mode = mock_mode
         self.config = load_config(str(self.base_dir))
         cfg = self.config
@@ -233,8 +257,46 @@ class SwarmRunner:
             or _default_backend_cmd(self.config.get("backend"))
         )
         model = override.get("model") or env_model or role_cfg.get("model")
+        self._warn_backend_host_mismatch(role, backend)
         return list(backend), model
 
+    @staticmethod
+    def _warn_backend_host_mismatch(role: str, backend: List[str]) -> None:
+        """Surface a config pin that silently defeats the host-native default.
+
+        Observed live: a pre-0.7.6 config pin of ["claude", "-p"] beat
+        IUMBTEMS_HOST=opencode, so an OpenCode host spawned Claude with no
+        signal. Warn loudly instead of failing silently.
+        """
+        host = os.environ.get("IUMBTEMS_HOST", "").strip().lower()
+        if host not in ("claude", "opencode"):
+            return
+        family = _backend_family(backend)
+        if family == host:
+            return
+        sys.stderr.write(
+            f"[swarm] WARNING: role={role} resolved backend={family!r} from an "
+            f"explicit pin/override, but IUMBTEMS_HOST={host!r}. The explicit pin "
+            f"wins. Set backend: {host!r}, agents.{role}.backend: null, or "
+            f"IUMBTEMS_BACKEND_{role.upper()}={host} to follow the host.\n"
+        )
+
+    def _scope_prompt(self, role: str, scope: Dict[str, Any], scope_id: str) -> str:
+        """Prompt for a dialectic agent, naming the absolute scratchpad dir.
+
+        The canonical prompts describe evidence paths RELATIVELY, so a bare
+        scope id left the agent guessing which `.research` tree to write to.
+        Naming the absolute directory removes the ambiguity even when the
+        spawn cwd is overridden.
+        """
+        return (
+            f"Run Agent {role} ({self.mode} mode) for scope: {json.dumps(scope)}. "
+            f"Engine: {self.engine}. Depth: {self.depth}. "
+            f"Save findings to the scratchpad directory "
+            f"{self.state_machine.get_scope_dir(scope_id)} (scope {scope_id}); "
+            f"write the dossier files there and nowhere else."
+        )
+
     def _resolve_opencode_agent(self, role: str) -> Optional[str]:
         """Explicitly configured OpenCode agent for this role, else None.
 
@@ -310,7 +372,7 @@ class SwarmRunner:
                 capture_output=True,
                 text=True,
                 check=True,
-                cwd=str(PROJECT_ROOT),
+                cwd=_agent_cwd(self.project_root),
                 # stdin MUST be DEVNULL: `opencode run` reads piped stdin to
                 # EOF before starting, and the MCP server's inherited stdin
                 # pipe is held open by the harness — every agent hung forever
@@ -619,7 +681,7 @@ Output ONLY valid JSON representing the scope decomposition conforming to prompt
                     "negative_knowledge": [],
                 }
         else:
-            prompt = f"Run Agent Alpha ({self.mode} mode) for scope: {json.dumps(scope)}. Engine: {self.engine}. Depth: {self.depth}. Save findings to {scope_id} scratchpad."
+            prompt = self._scope_prompt("Alpha", scope, scope_id)
             if self.mode == "audit":
                 system_prompt = self.prompts_dir / "agent_code_auditor.md"
             elif self.mode == "scout":
@@ -814,7 +876,7 @@ Output ONLY valid JSON representing the scope decomposition conforming to prompt
                     ],
                 }
         else:
-            prompt = f"Run Agent Beta ({self.mode} mode) for scope: {json.dumps(scope)}. Engine: {self.engine}. Depth: {self.depth}. Save findings to {scope_id} scratchpad."
+            prompt = self._scope_prompt("Beta", scope, scope_id)
             if self.mode == "audit":
                 system_prompt = self.prompts_dir / "agent_code_auditor.md"
             elif self.mode == "scout":

package/runner/tests/test_factory.py

@@ -214,16 +214,24 @@ class TestFactoryHelper(unittest.TestCase):
     def test_snippet_factory_roster(self):
         with open(PROJECT_ROOT / "config" / "opencode-snippet.json") as f:
             snippet = json.load(f)
+        # V2 config key is `agents` (plural) and rules are a `permissions` list.
         for agent in ("manager", "programmer", "qa-a", "qa-b"):
-            self.assertIn(agent, snippet["agent"])
-        manager = snippet["agent"]["manager"]
+            self.assertIn(agent, snippet["agents"])
+
+        def rule(agent, action, resource="*"):
+            return next(
+                r
+                for r in snippet["agents"][agent]["permissions"]
+                if r["action"] == action and r.get("resource", "*") == resource
+            )
+
+        manager = snippet["agents"]["manager"]
         self.assertEqual(manager["mode"], "primary")
-        task = manager["permission"]["task"]
-        self.assertEqual(task["*"], "deny")
+        self.assertEqual(rule("manager", "subagent")["effect"], "deny")
         for allowed in ("programmer", "qa-a", "qa-b", "brainstormer", "darkharvester"):
-            self.assertEqual(task[allowed], "allow")
-        self.assertEqual(snippet["agent"]["qa-a"]["permission"]["edit"], "deny")
-        self.assertEqual(snippet["agent"]["qa-b"]["permission"]["edit"], "deny")
+            self.assertEqual(rule("manager", "subagent", allowed)["effect"], "allow")
+        self.assertEqual(rule("qa-a", "edit")["effect"], "deny")
+        self.assertEqual(rule("qa-b", "edit")["effect"], "deny")
 
     def test_factory_commands_carry_agent_subtask(self):
         res = run_node(

package/runner/tests/test_opencode_ux.py

@@ -30,6 +30,20 @@ EXPECTED_COMMANDS = [
     "domainexpansion",
 ]
 
+EXPECTED_AGENTS = [
+    "code-auditor",
+    "oss-scout",
+    "alpha-thesis",
+    "beta-redteam",
+    "epistemic-auditor",
+    "brainstormer",
+    "darkharvester",
+    "manager",
+    "programmer",
+    "qa-a",
+    "qa-b",
+]
+
 
 def run_node(code):
     return subprocess.run(
@@ -259,48 +273,44 @@ class TestInstallOpenCode(unittest.TestCase):
             self.assertEqual(first.returncode, 0, f"install failed: {first.stderr}")
             oc_path = home / ".config" / "opencode" / "opencode.json"
             cfg = json.loads(oc_path.read_text(encoding="utf-8"))
-            # Bare object repaired into tuple form, preserving user options.
-            tuples = [
+            # V1 `plugin` migrated to V2 `plugins` in object form; the trailing
+            # bare options object is folded in and user options are preserved.
+            self.assertNotIn("plugin", cfg)
+            self.assertFalse(
+                any(isinstance(p, list) for p in cfg["plugins"]),
+                f"V2 plugins must not use tuple form: {cfg['plugins']}",
+            )
+            ours = [
                 p
-                for p in cfg["plugin"]
-                if isinstance(p, list) and p and p[0] == "@heretek-ai/epistemic-swarm"
+                for p in cfg["plugins"]
+                if isinstance(p, dict)
+                and p.get("package") == "@heretek-ai/epistemic-swarm"
             ]
-            self.assertEqual(len(tuples), 1)
+            self.assertEqual(len(ours), 1)
             self.assertEqual(
-                tuples[0][1],
+                ours[0]["options"],
                 {
                     "search_engine": "duckduckgo",
                     "max_iterations": 10,
                     "mode": "research",
                 },
             )
-            self.assertFalse(any(isinstance(p, dict) for p in cfg["plugin"]))
-            # Agents merged from the snippet, MCP server absolute.
-            for agent in [
-                "code-auditor",
-                "oss-scout",
-                "alpha-thesis",
-                "beta-redteam",
-                "epistemic-auditor",
-                "brainstormer",
-                "darkharvester",
-                "manager",
-                "programmer",
-                "qa-a",
-                "qa-b",
-            ]:
-                self.assertIn(agent, cfg.get("agent", {}))
-            self.assertIn("iumbtems", cfg.get("mcp", {}))
-            cmd = cfg["mcp"]["iumbtems"]["command"]
+            self.assertIn("@prevalentware/opencode-goal-plugin", cfg["plugins"])
+            # Agents merged from the snippet under the V2 plural key.
+            for agent in EXPECTED_AGENTS:
+                self.assertIn(agent, cfg.get("agents", {}))
+            # MCP server absolute under V2 mcp.servers (no legacy top-level key).
+            self.assertNotIn("iumbtems", cfg["mcp"])
+            cmd = cfg["mcp"]["servers"]["iumbtems"]["command"]
             self.assertTrue(Path(cmd[-1]).is_absolute())
             self.assertEqual(cmd[-1], str(PROJECT_ROOT / "runner" / "mcp_server.py"))
-            # Skills merged as absolute repo paths (relative entries repaired).
-            skill_paths = cfg.get("skills", {}).get("paths", [])
+            # Skills merged as a V2 list of absolute repo paths.
+            skill_paths = cfg.get("skills")
+            self.assertIsInstance(skill_paths, list)
             self.assertTrue(skill_paths)
             for sp in skill_paths:
                 self.assertTrue(Path(sp).is_absolute(), f"relative skill path: {sp}")
             self.assertIn(str(PROJECT_ROOT / "skills" / "grilling"), skill_paths)
-            self.assertFalse(any(not Path(sp).is_absolute() for sp in skill_paths))
             # Second run changes nothing.
             before = oc_path.read_bytes()
             second = self._run_install(home)

package/runner/tests/test_opencode_v2_registrars.py

@@ -7,6 +7,12 @@ ran as the generic `build` agent, and skills were undiscoverable — the agent
 ran `find / -name factory.py` to learn its own mechanics. These tests pin the
 plugin-side fix: profiles and skills are registered through the V2 domains, and
 the command switches the session agent.
+
+Regression (0.7.6, opencode v2.0.18): the mock below used to hand the plugin an
+`{add}` agent editor. The real V2 `AgentEditor` has NO `add()` — only
+`list/get/default/update/remove`, where `update()` upserts. The plugin's
+`draft.add(...)` threw `draft.add is not a function` and the host disabled the
+whole plugin. The mock now models the real editor so that defect cannot pass.
 """
 
 import json
@@ -16,21 +22,71 @@ from pathlib import Path
 
 PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
 
-V2_HOST = """
-const reg = {agents: [], skills: [], commands: [], tools: [], prompts: [], switches: []};
+# Faithful V2 AgentEditor: `update(id, fn)` upserts, seeding a new entry from
+# Agent.Info.default(id) (mode primary, allow-list) + global rules, exactly as
+# the opencode v2.0.18 agent registry does. No `add`.
+AGENT_EDITOR_JS = """
+function makeAgentEditor(reg) {
+  const store = new Map();
+  return {
+    store,
+    editor: {
+      list: () => [...store.values()],
+      get: (id) => store.get(id),
+      default: (id) => { reg.defaultAgent = id; },
+      update: (id, fn) => {
+        reg.agentUpdates.push(id);
+        let agent = store.get(id);
+        if (!agent) {
+          agent = {
+            id, name: id,
+            request: {settings: {}, headers: {}, body: {}},
+            mode: 'primary', hidden: false,
+            permissions: [{action: '*', resource: '*', effect: 'allow'}],
+          };
+          store.set(id, agent);
+        }
+        fn(agent);
+        agent.id = id;
+      },
+      remove: (id) => { store.delete(id); },
+    },
+  };
+}
+function seedAgent(box, id) {
+  box.store.set(id, {
+    id, name: id,
+    request: {settings: {}, headers: {}, body: {}},
+    mode: 'primary', hidden: false,
+    permissions: [{action: '*', resource: '*', effect: 'allow'}],
+  });
+}
+"""
+
+V2_HOST = (
+    AGENT_EDITOR_JS
+    + """
+const reg = {skills: [], commands: [], tools: [], prompts: [], switches: [], agentUpdates: [], defaultAgent: undefined};
+const agentBox = makeAgentEditor(reg);
 const host = {
   options: {},
   location: {directory: '/home/john/Projects/STC'},
   command: {list: async()=>({data:[]}), transform: async(fn)=>{fn({add:(x)=>{reg.commands.push(x);}}); return {dispose:()=>{}};}, reload: async()=>{}},
   tool: {transform: async(fn)=>{fn({add:(t)=>{reg.tools.push(t);}}); return {dispose:()=>{}};}, reload: async()=>{}},
-  agent: {list: async()=>({data:[]}), transform: async(fn)=>{fn({add:(a)=>{reg.agents.push(a);}}); return {dispose:()=>{}};}, reload: async()=>{}},
+  agent: {
+    list: async()=>({data: [...agentBox.store.values()].map((a)=>({id: a.id, name: a.name}))}),
+    transform: async(fn)=>{fn(agentBox.editor); return {dispose:()=>{}};},
+    reload: async()=>{}
+  },
   skill: {list: async()=>({data:[]}), transform: async(fn)=>{fn({add:(s)=>{reg.skills.push(s);}}); return {dispose:()=>{}};}, reload: async()=>{}},
   session: {
     prompt: async(p)=>{reg.prompts.push(p); return {};},
     switchAgent: async(a)=>{reg.switches.push(a); return {};}
   }
 };
+const agents = () => [...agentBox.store.values()];
 """
+)
 
 
 def run_node(code):
@@ -54,16 +110,17 @@ class TestV2Registration(unittest.TestCase):
             + """
             import plugin from "./plugins/opencode/index.js";
             await plugin.setup(host);
-            const manager = reg.agents.find(a => a.id === 'manager');
-            const qa = reg.agents.find(a => a.id === 'qa-a');
+            const manager = agents().find(a => a.id === 'manager');
+            const qa = agents().find(a => a.id === 'qa-a');
             const factory = reg.skills.find(s => s.id === 'factory');
             console.log(JSON.stringify({
-              agentIds: reg.agents.map(a => a.id).sort(),
+              agentIds: agents().map(a => a.id).sort(),
               managerMode: manager?.mode,
               managerSystem: Boolean(manager?.system),
               managerPermissions: manager?.permissions?.length || 0,
               managerDeniesEdit: (manager?.permissions || []).some(p => p.action === 'edit' && p.effect === 'deny'),
               qaMode: qa?.mode,
+              qaDeniesEdit: (qa?.permissions || []).some(p => p.action === 'edit' && p.effect === 'deny'),
               skillIds: reg.skills.map(s => s.id).sort(),
               factoryHasContent: Boolean(factory?.content?.includes('Factory')),
               factoryPath: factory?.path,
@@ -85,11 +142,46 @@ class TestV2Registration(unittest.TestCase):
         self.assertTrue(d["managerSystem"])
         self.assertTrue(d["managerDeniesEdit"], "manager must not edit code")
         self.assertEqual(d["qaMode"], "subagent")
+        self.assertTrue(d["qaDeniesEdit"], "qa must not edit code")
         self.assertIn("factory", d["skillIds"])
         self.assertIn("darkharvest", d["skillIds"])
         self.assertTrue(d["factoryHasContent"])
         self.assertTrue(d["factoryPath"].endswith("skills/factory/SKILL.md"))
 
+    def test_agent_editor_never_calls_add(self):
+        """Pin the exact 0.7.6 failure: AgentEditor has no `add`."""
+        res = run_node(
+            """
+            const reg = {agentUpdates: []};
+            const editor = {
+              list: () => [],
+              get: () => undefined,
+              default: () => {},
+              update: (id, fn) => {
+                reg.agentUpdates.push(id);
+                fn({id, permissions: []});
+              },
+              remove: () => {},
+              // intentionally NO add
+            };
+            const host = {
+              options: {}, location: {directory: '/tmp'},
+              command: {list: async()=>({data:[]}), transform: async(fn)=>{fn({add:()=>{}}); return {dispose:()=>{}};}, reload: async()=>{}},
+              tool: {transform: async()=>({dispose:()=>{}}), reload: async()=>{}},
+              agent: {list: async()=>({data:[]}), transform: async(fn)=>{fn(editor); return {dispose:()=>{}};}, reload: async()=>{}},
+              skill: {list: async()=>({data:[]}), transform: async(fn)=>{fn({add:()=>{}}); return {dispose:()=>{}};}, reload: async()=>{}},
+              session: {prompt: async()=>({})}
+            };
+            import plugin from "./plugins/opencode/index.js";
+            await plugin.setup(host);
+            console.log(JSON.stringify({agentUpdates: reg.agentUpdates}));
+            """
+        )
+        self.assertEqual(res.returncode, 0, res.stderr)
+        d = last_json_object(res.stdout)
+        self.assertIn("manager", d["agentUpdates"])
+        self.assertIn("qa-b", d["agentUpdates"])
+
     def test_command_switches_session_agent(self):
         res = run_node(
             V2_HOST
@@ -100,7 +192,7 @@ class TestV2Registration(unittest.TestCase):
             await factory.execute({sessionID: 'ses_test', prompt: {text: 'Cockpit beta'}, delivery: 'steer'});
             console.log(JSON.stringify({
               switches: reg.switches,
-              promptAgent: reg.prompts[0]?.agent,
+              promptAgentKey: Object.prototype.hasOwnProperty.call(reg.prompts[0] || {}, 'agent'),
               promptHasArena: reg.prompts[0]?.text?.includes('Cockpit beta'),
             }));
             """
@@ -108,39 +200,44 @@ class TestV2Registration(unittest.TestCase):
         self.assertEqual(res.returncode, 0, res.stderr)
         d = last_json_object(res.stdout)
         self.assertTrue(d["switches"], "switchAgent was never called")
-        self.assertEqual(d["promptAgent"], "manager")
+        self.assertEqual(d["switches"][0]["agent"], "manager")
+        # V2 SessionPromptInput has no `agent` field; pinning is switchAgent's job.
+        self.assertFalse(d["promptAgentKey"])
         self.assertTrue(d["promptHasArena"])
 
     def test_preexisting_agent_and_skill_preserved(self):
         res = run_node(
-            """
-            const agents = [], skills = [];
+            AGENT_EDITOR_JS
+            + """
+            const reg = {agentUpdates: [], skills: []};
+            const agentBox = makeAgentEditor(reg);
+            seedAgent(agentBox, 'manager'); // user-defined manager wins
             const host = {
               options: {}, location: {directory: '/tmp'},
               command: {list: async()=>({data:[]}), transform: async(fn)=>{fn({add:()=>{}}); return {dispose:()=>{}};}, reload: async()=>{}},
               tool: {transform: async()=>({dispose:()=>{}}), reload: async()=>{}},
               agent: {
-                list: async()=>({data:[{id:'manager'}]}),
-                transform: async(fn)=>{fn({add:(a)=>{agents.push(a.id);}}); return {dispose:()=>{}};},
+                list: async()=>({data: [...agentBox.store.values()].map((a)=>({id: a.id}))}),
+                transform: async(fn)=>{fn(agentBox.editor); return {dispose:()=>{}};},
                 reload: async()=>{}
               },
               skill: {
                 list: async()=>({data:[{id:'factory'}]}),
-                transform: async(fn)=>{fn({add:(s)=>{skills.push(s.id);}}); return {dispose:()=>{}};},
+                transform: async(fn)=>{fn({add:(s)=>{reg.skills.push(s.id);}}); return {dispose:()=>{}};},
                 reload: async()=>{}
               },
               session: {prompt: async()=>({})}
             };
             import plugin from "./plugins/opencode/index.js";
             await plugin.setup(host);
-            console.log(JSON.stringify({agents, skills}));
+            console.log(JSON.stringify({agentUpdates: reg.agentUpdates, skills: reg.skills}));
             """
         )
         self.assertEqual(res.returncode, 0, res.stderr)
         d = last_json_object(res.stdout)
-        self.assertNotIn("manager", d["agents"], "user-defined manager must win")
+        self.assertNotIn("manager", d["agentUpdates"], "user-defined manager must win")
         self.assertNotIn("factory", d["skills"], "user-defined factory skill must win")
-        self.assertIn("qa-a", d["agents"])
+        self.assertIn("qa-a", d["agentUpdates"])
 
     def test_graceful_without_agent_skill_domains(self):
         res = run_node(