@heretek-ai/epistemic-swarm 0.7.2 → 0.7.3

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "epistemic-swarm",
-  "version": "0.7.2",
+  "version": "0.7.3",
   "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.7.2",
+  "version": "0.7.3",
   "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/opencode/index.js

@@ -598,8 +598,14 @@ export function commandCatalog() {
   return out;
 }
 
-/** Tool map (object form) for the server hook; array catalog stays canonical. */
-function buildToolMap() {
+/** Tool map (object form) for the server hook; array catalog stays canonical.
+ *
+ * `hostRoot` is the host-reported project directory (host.location.directory).
+ * The tool context's own cwd is absent on some host builds — observed live:
+ * every dispatch fell back to process.cwd() (/home/john) and evidence escaped
+ * the project tree. Prefer toolContext.cwd, then hostRoot, then process.cwd().
+ */
+function buildToolMap(hostRoot = undefined) {
   return Object.fromEntries(
     TOOL_CATALOG.map((tool) => [
       tool.name,
@@ -607,7 +613,11 @@ function buildToolMap() {
         ...tool,
         options: { codemode: false },
         execute: async (args = {}, toolContext = undefined) =>
-          callMcp(tool.name, normalizeArgs(tool.name, args), toolContext?.cwd),
+          callMcp(
+            tool.name,
+            normalizeArgs(tool.name, args),
+            toolContext?.cwd || hostRoot
+          ),
       },
     ])
   );
@@ -892,15 +902,25 @@ async function registerHostTools(host) {
   // cannot be intercepted the way Claude Code's hooks/hooks.json does.
   // Steering lives in command templates (epistemic search first); a host API
   // for pre-execution guards would close this for real.
+  //
+  // hostRoot: the host's project directory. toolContext.cwd is absent on
+  // some host builds (observed live: dispatches fell back to process.cwd()
+  // = /home/john and evidence escaped the project tree), so capture the
+  // host-reported directory here as the fallback.
+  const hostRoot = host?.location?.directory || undefined;
   const registration = await host.tool.transform((draft) => {
-    for (const [name, spec] of Object.entries(buildToolMap())) {
+    for (const [name, spec] of Object.entries(buildToolMap(hostRoot))) {
       draft.add({
         name,
         description: spec.description,
         input: spec.input,
         options: { codemode: false },
         execute: async (args = {}, toolContext = undefined) => {
-          const r = await callMcp(name, normalizeArgs(name, args), toolContext?.cwd);
+          const r = await callMcp(
+            name,
+            normalizeArgs(name, args),
+            toolContext?.cwd || hostRoot
+          );
           return { content: r.content };
         },
       });

package/runner/research_swarm.py

@@ -43,17 +43,6 @@ OPENCODE_RUN_BASE = ["opencode", "run"]
 # Fenced JSON block marker shared by orchestrator/dossier stdout parsers.
 _JSON_FENCE = "```json"
 
-# Swarm mode -> OpenCode agent carrying the equivalent system prompt
-# (`opencode run` has no --system-prompt flag; the prompt rides on --agent).
-MODE_OPENCODE_AGENT = {
-    "research": "alpha-thesis",
-    "audit": "code-auditor",
-    "scout": "oss-scout",
-    "hybrid": "alpha-thesis",
-    "brainstorm": "brainstormer",
-    "darkharvest": "darkharvester",
-}
-
 
 def _default_backend_cmd(config_host: Optional[str] = None) -> List[str]:
     """Host-native default backend argv.
@@ -99,7 +88,17 @@ _TEXT_EVENT_MARKERS = ("message", "text", "result", "output", "content")
 
 
 def _event_text(obj: Dict[str, Any]) -> Optional[str]:
-    """Text payload of one parsed event line, or None."""
+    """Text payload of one parsed event line, or None.
+
+    Handles the real `opencode run --format json` shape
+    ({"type":"text", "part":{"type":"text","text":"..."}}) plus top-level
+    variants for tolerance.
+    """
+    part = obj.get("part")
+    if isinstance(part, dict):
+        val = part.get("text")
+        if isinstance(val, str) and val.strip():
+            return val
     kind = str(obj.get("type", "")).lower()
     if kind and not any(m in kind for m in _TEXT_EVENT_MARKERS):
         return None
@@ -237,14 +236,16 @@ class SwarmRunner:
         return list(backend), model
 
     def _resolve_opencode_agent(self, role: str) -> Optional[str]:
-        """OpenCode agent carrying the system prompt for this mode/role."""
-        agents_cfg = self.config.get("agents") or {}
-        role_cfg = agents_cfg.get(role) or {}
-        if role_cfg.get("opencode_agent"):
-            return role_cfg["opencode_agent"]
-        if self.mode == "research" and role == "beta":
-            return "beta-redteam"
-        return MODE_OPENCODE_AGENT.get(self.mode)
+        """Explicitly configured OpenCode agent for this role, else None.
+
+        Default is None: the system prompt is inlined into the message because
+        `--agent <name>` fails hard ("Agent not found") unless the user
+        installed the snippet agent profiles — observed live, so the backend
+        must not depend on them. Set `agents.<role>.opencode_agent` (or the
+        top-level `opencode_agent` config key) to opt in.
+        """
+        role_cfg = (self.config.get("agents") or {}).get(role) or {}
+        return role_cfg.get("opencode_agent") or self.config.get("opencode_agent")
 
     def build_agent_cmd(
         self,
@@ -270,9 +271,16 @@ class SwarmRunner:
                 "backend (CLI flag injection)"
             )
         if _backend_family(backend) == "opencode":
-            return _build_opencode_cmd(
-                backend, prompt, model, self._resolve_opencode_agent(role)
-            )
+            agent = self._resolve_opencode_agent(role)
+            # No --system-prompt flag exists on `opencode run`, and --agent
+            # only works when the user installed the profile. Inline the
+            # system prompt into the message so runs never depend on
+            # host-side agent configuration.
+            if system_prompt_file and system_prompt_file.exists():
+                prompt = (
+                    system_prompt_file.read_text(encoding="utf-8") + "\n\n" + prompt
+                )
+            return _build_opencode_cmd(backend, prompt, model, agent)
         cmd = list(backend) + [prompt, "--tools", tools]
         if model:
             cmd.extend(["--model", str(model)])
@@ -303,6 +311,11 @@ class SwarmRunner:
                 text=True,
                 check=True,
                 cwd=str(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
+                # (observed live: 10+ min, 1s CPU, no network I/O).
+                stdin=subprocess.DEVNULL,
                 shell=False,
             )
             if family == "opencode":

package/runner/tests/test_backends.py

@@ -103,13 +103,29 @@ class TestRunnerBackendWiring(unittest.TestCase):
             r = self._runner(mode="scout")
             cmd = r.build_agent_cmd("obj")
             self.assertEqual(cmd[:2], ["opencode", "run"])
-            self.assertIn("oss-scout", cmd)
+            # No --agent by default: named agents fail hard unless the user
+            # installed the profile ("Agent not found", observed live).
+            self.assertNotIn("--agent", cmd)
+            self.assertIn("--format", cmd)
+
+    def test_explicit_opencode_agent_config_opt_in(self):
+        with mock.patch.dict(os.environ, {"IUMBTEMS_HOST": "opencode"}):
+            r = self._runner(agent_overrides=None)
+            r.config["opencode_agent"] = "brainstormer"
+            cmd = r.build_agent_cmd("obj")
+            self.assertIn("--agent", cmd)
+            self.assertIn("brainstormer", cmd)
+
+    def test_system_prompt_inlined_for_opencode(self):
+        import tempfile as _tf
 
-    def test_research_beta_maps_to_beta_redteam(self):
         with mock.patch.dict(os.environ, {"IUMBTEMS_HOST": "opencode"}):
             r = self._runner(mode="research")
-            self.assertIn("beta-redteam", r.build_agent_cmd("obj", role="beta"))
-            self.assertIn("alpha-thesis", r.build_agent_cmd("obj", role="alpha"))
+            spf = Path(_tf.mkdtemp()) / "sys.md"
+            spf.write_text("SYSTEM PROMPT BODY", encoding="utf-8")
+            cmd = r.build_agent_cmd("obj", system_prompt_file=spf)
+            self.assertIn("SYSTEM PROMPT BODY", cmd[2])
+            self.assertNotIn("--system-prompt", cmd)
 
     def test_explicit_override_beats_host_env(self):
         with mock.patch.dict(os.environ, {"IUMBTEMS_HOST": "opencode"}):
@@ -119,6 +135,17 @@ class TestRunnerBackendWiring(unittest.TestCase):
 
 
 class TestOpencodeOutputParsing(unittest.TestCase):
+    def test_extracts_real_part_text_events(self):
+        """Live shape: {"type":"text","part":{"type":"text","text":"..."}}."""
+        raw = "\n".join(
+            [
+                '{"type":"step_start","timestamp":1,"sessionID":"s","part":{"type":"step-start"}}',
+                '{"type":"text","timestamp":2,"sessionID":"s","part":{"id":"p1","type":"text","text":"pong"}}',
+                '{"type":"text","timestamp":3,"sessionID":"s","part":{"id":"p2","type":"text","text":"second"}}',
+            ]
+        )
+        self.assertEqual(_extract_opencode_text(raw), "pong\nsecond")
+
     def test_extracts_text_events(self):
         raw = "\n".join(
             [
@@ -139,6 +166,24 @@ class TestOpencodeOutputParsing(unittest.TestCase):
         self.assertEqual(_extract_opencode_text(raw), "verdict: clean-room")
 
 
+class TestSpawnHardening(unittest.TestCase):
+    def test_stdin_is_devnull_for_backend_spawns(self):
+        """Regression: held-open stdin pipe made `opencode run` hang forever."""
+        import tempfile
+        from runner.research_swarm import SwarmRunner
+
+        r = SwarmRunner(
+            base_dir=Path(tempfile.mkdtemp()), mock_mode=False, mode="research"
+        )
+        fake = mock.Mock()
+        fake.stdout = "ok"
+        with mock.patch("subprocess.run", return_value=fake) as run_mock:
+            r.run_claude_process("objective text")
+        kwargs = run_mock.call_args.kwargs
+        self.assertEqual(kwargs.get("stdin"), subprocess.DEVNULL)
+        self.assertEqual(kwargs.get("shell"), False)
+
+
 class TestDossierStdoutFallback(unittest.TestCase):
     def _runner(self):
         import tempfile