@heretek-ai/epistemic-swarm 0.7.5 → 0.7.6

package/.claude-plugin/plugin.json

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

@@ -587,6 +587,7 @@ export const OPENCODE_COMMANDS = [
       '2. Per gate run iumbtems_brainstorm and iumbtems_darkharvest (mock_mode only for dry runs), then synthesize .roadmap/<phase>/ GOAL.md + dossier.json (goal/evidence/acceptance/brief/verdict/hashes; every claim needs a VERIFIED hash).',
       '3. Spawn the programmer subagent per phase with the phase dossier (cite phase hashes); run qa-a and qa-b (diverged prompts) per phase; track retries with the iumbtems_factory tool (command: phase-add / qa-record; 3 failures escalate to manager). Never invoke factory helper scripts by relative path.',
       '4. Manager tiebreaks QA disagreements; explicit user sign-off closes each phase.',
+      'Swarm agents use the host-native backend automatically (claude -p on Claude Code, opencode run on OpenCode). Do not debug backend selection, config pins, or binary availability as part of a gate — if a swarm call fails, report the error and continue.',
     ].join('\n'),
   },
   {
@@ -907,9 +908,19 @@ async function registerHostCommands(host) {
         execute: async (input) => {
           const args = input?.prompt?.text || '';
           const prompt = (typeof input?.prompt === 'object' && input?.prompt !== null) ? input.prompt : {};
+          // Pin the declared agent for this run: the template says "as the
+          // manager agent", so make that true rather than aspirational.
+          let switched = false;
+          if (cmd.agent) {
+            switched = await switchSessionAgent(host, input?.sessionID, cmd.agent);
+            log(host, 'debug', 'command agent switch', {
+              command: cmd.name, agent: cmd.agent, switched,
+            });
+          }
           await host.session.prompt({
             ...prompt,
             sessionID: input?.sessionID,
+            ...(cmd.agent ? { agent: cmd.agent } : {}),
             text: cmd.template.split('$ARGUMENTS').join(String(args).trim()),
             delivery: input?.delivery,
           });
@@ -1010,6 +1021,174 @@ async function registerCompactionHook(host, context) {
   }
 }
 
+async function registerHostAgents(host) {
+  // V2 Context exposes `agent.transform` (AgentDomain). Registering the IUMBTEMS
+  // role profiles here removes the config-snippet install dependency: without
+  // them the `/factory` command ran as the generic `build` agent (observed live:
+  // every step of a factory session executed as `build`, not `manager`).
+  if (typeof host?.agent?.transform !== 'function') return [];
+  const snippet = readPkgJson(path.join(PKG_ROOT, 'config', 'opencode-snippet.json'));
+  const agentDefs = (snippet && snippet.agent) || {};
+  if (Object.keys(agentDefs).length === 0) return [];
+
+  let existing = new Set();
+  try {
+    const listed = await host.agent.list();
+    existing = new Set((listed?.data || listed || []).map((a) => a?.id || a?.name));
+  } catch (err) {
+    log(host, 'warn', 'agent.list() failed; assuming an empty registry', errDetail(err));
+  }
+
+  const registration = await host.agent.transform((draft) => {
+    const claimed = new Set(existing);
+    const added = [];
+    for (const [name, def] of Object.entries(agentDefs)) {
+      if (claimed.has(name)) continue;
+      claimed.add(name);
+      added.push(name);
+      draft.add(toAgentInfo(name, def));
+    }
+    log(host, 'debug', 'agent.transform pass', { added });
+  });
+  try {
+    if (typeof host.agent.reload === 'function') await host.agent.reload();
+    log(host, 'info', 'agent profiles registered', { count: Object.keys(agentDefs).length });
+  } catch (err) {
+    log(host, 'warn', 'agent.reload() failed', errDetail(err));
+  }
+  return registration ? [registration] : [];
+}
+
+/** Short role system prompts for the factory seats (skills carry the long form). */
+const FACTORY_SYSTEM = {
+  manager:
+    'You are the IUMBTEMS Factory Manager. Own gate discipline: grill until the frontier is settled, run the brainstorm and darkharvest swarms, synthesize .roadmap phase dossiers, spawn the programmer per phase, run qa-a and qa-b, and tiebreak their disagreements. Never write implementation code. Use the iumbtems_factory tool for run state. Explicit user approval advances each gate.',
+  programmer:
+    'You are the IUMBTEMS Factory Programmer. Implement exactly one phase brief per spawn. Cite phase evidence hashes. Never invoke swarms or other programmers. If the brief is ambiguous or untestable, stop and ask the manager.',
+  'qa-a':
+    'You are the IUMBTEMS Factory functional QA. Verify each phase acceptance criterion on the real surface with tests and inspection. Read-only plus test execution; never edit code. Return pass|fail(reason)|conditional(note).',
+  'qa-b':
+    'You are the IUMBTEMS Factory adversarial QA. Attack the phase: edge cases, regressions, vacuous acceptance criteria, error paths, resource limits. Read-only plus test execution; never edit code. Return pass|fail(reason)|conditional(note) with reproductions.',
+};
+
+/** Map one snippet agent definition to an Agent.Info shape. */
+function toAgentInfo(name, def) {
+  const permissions = [];
+  for (const [tool, enabled] of Object.entries(def?.tools || {})) {
+    permissions.push({ action: tool, resource: '*', effect: enabled ? 'allow' : 'deny' });
+  }
+  for (const [key, value] of Object.entries(def?.permission || {})) {
+    if (typeof value === 'string') {
+      permissions.push({ action: key, resource: '*', effect: value });
+    } else if (value && typeof value === 'object') {
+      for (const [resource, effect] of Object.entries(value)) {
+        permissions.push({ action: key, resource, effect });
+      }
+    }
+  }
+  const info = {
+    id: name,
+    name,
+    description: def?.description || `IUMBTEMS ${name}`,
+    mode: def?.mode || 'all',
+    hidden: Boolean(def?.hidden),
+    request: { settings: {}, headers: {}, body: {} },
+    permissions,
+  };
+  if (def?.steps) info.steps = def.steps;
+  if (def?.color) info.color = def.color;
+  const system = FACTORY_SYSTEM[name];
+  if (system) info.system = system;
+  return info;
+}
+
+/** Canonical skills the plugin registers so agents never hunt the filesystem. */
+const BUNDLED_SKILLS = [
+  'factory',
+  'darkharvest',
+  'brainstorming',
+  'grilling',
+  'swarm_config',
+  'code_audit',
+  'oss_scout',
+  'research_cache',
+  'epistemic_search',
+];
+
+function parseSkillFrontmatter(text) {
+  const out = {};
+  if (!text.startsWith('---')) return out;
+  const end = text.indexOf('\n---', 3);
+  if (end < 0) return out;
+  for (const line of text.slice(3, end).split('\n')) {
+    const idx = line.indexOf(':');
+    if (idx > 0) out[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+  }
+  return out;
+}
+
+async function registerHostSkills(host) {
+  // V2 Context exposes `skill.transform` (SkillDomain). Live evidence: with no
+  // skills registered, a factory agent ran `find / -name factory.py` and read
+  // the skill prose out of the CLAUDE plugin cache to learn its own mechanics.
+  if (typeof host?.skill?.transform !== 'function') return [];
+  const skills = [];
+  for (const name of BUNDLED_SKILLS) {
+    const skillPath = path.join(PKG_ROOT, 'skills', name, 'SKILL.md');
+    let content;
+    try {
+      content = readFileSync(skillPath, 'utf-8');
+    } catch {
+      continue;
+    }
+    const fm = parseSkillFrontmatter(content);
+    skills.push({
+      id: name,
+      name,
+      description: fm.description || `IUMBTEMS ${name} skill`,
+      path: skillPath,
+      content,
+      autoinvoke: true,
+    });
+  }
+  if (skills.length === 0) return [];
+
+  let existing = new Set();
+  try {
+    const listed = await host.skill.list();
+    existing = new Set((listed?.data || listed || []).map((s) => s?.id || s?.name));
+  } catch (err) {
+    log(host, 'warn', 'skill.list() failed; assuming an empty registry', errDetail(err));
+  }
+
+  const registration = await host.skill.transform((draft) => {
+    const claimed = new Set(existing);
+    const added = [];
+    for (const skill of skills) {
+      if (claimed.has(skill.id)) continue;
+      claimed.add(skill.id);
+      added.push(skill.id);
+      draft.add(skill);
+    }
+    log(host, 'debug', 'skill.transform pass', { added });
+  });
+  try {
+    if (typeof host.skill.reload === 'function') await host.skill.reload();
+    log(host, 'info', 'skills registered', { count: skills.length });
+  } catch (err) {
+    log(host, 'warn', 'skill.reload() failed', errDetail(err));
+  }
+  return registration ? [registration] : [];
+}
+
+function readPkgJson(file) {
+  try {
+    return JSON.parse(readFileSync(file, 'utf-8'));
+  } catch {
+    return undefined;
+  }
+}
+
 async function applyConfigOptions(host, opts, context) {
   if (!opts || typeof opts !== 'object') return;
   const updates = {};
@@ -1043,6 +1222,36 @@ function startNudgeSubscription(host, opts, context, cleanups) {
   }
 }
 
+/**
+ * Best-effort session agent switch for commands that pin an agent.
+ *
+ * Live gap: `/factory` declared `agent: 'manager'` but the session kept running
+ * as `build`, so the manager playbook was never loaded. The V2 SessionDomain
+ * exposes `switchAgent`; its exact call shape is not pinned in the public types,
+ * so try the plausible shapes and never throw into the host.
+ */
+async function switchSessionAgent(host, sessionID, agentId) {
+  if (!agentId || !sessionID) return false;
+  const fn = host?.session?.switchAgent;
+  if (typeof fn !== 'function') return false;
+  const attempts = [
+    () => fn.call(host.session, { sessionID, agent: agentId }),
+    () => fn.call(host.session, { sessionID, agentID: agentId }),
+    () => fn.call(host.session, sessionID, agentId),
+    () => fn.call(host.session, agentId),
+  ];
+  for (const attempt of attempts) {
+    try {
+      const res = attempt();
+      if (res && typeof res.then === 'function') await res;
+      return true;
+    } catch {
+      /* try the next call shape */
+    }
+  }
+  return false;
+}
+
 export function createOpenCodePlugin(context = {}) {
   return {
     id: 'heretek.iumbtems.epistemic-swarm',
@@ -1075,6 +1284,16 @@ export function createOpenCodePlugin(context = {}) {
       } catch (err) {
         log(host, 'error', 'registering slash commands failed', errDetail(err));
       }
+      try {
+        adopt(await registerHostAgents(host));
+      } catch (err) {
+        log(host, 'error', 'registering agent profiles failed', errDetail(err));
+      }
+      try {
+        adopt(await registerHostSkills(host));
+      } catch (err) {
+        log(host, 'error', 'registering skills failed', errDetail(err));
+      }
       try {
         adopt(await registerHostTools(host));
       } catch (err) {

package/runner/tests/test_opencode_v2_registrars.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""Tests for OpenCode V2 agent/skill registration and command agent switching.
+
+Live gap (ses_f1b924bdaffe): the /factory command declared `agent: manager`,
+but no agent profiles existed (config snippet never installed) so every step
+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.
+"""
+
+import json
+import subprocess
+import unittest
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+
+V2_HOST = """
+const reg = {agents: [], skills: [], commands: [], tools: [], prompts: [], switches: []};
+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()=>{}},
+  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 {};}
+  }
+};
+"""
+
+
+def run_node(code):
+    return subprocess.run(
+        ["node", "--input-type=module", "-e", code],
+        capture_output=True,
+        text=True,
+        cwd=str(PROJECT_ROOT),
+    )
+
+
+def last_json_object(stdout):
+    lines = [l.strip() for l in stdout.strip().split("\n") if l.strip().startswith("{")]
+    return json.loads(lines[-1])
+
+
+class TestV2Registration(unittest.TestCase):
+    def test_agents_and_skills_registered(self):
+        res = run_node(
+            V2_HOST
+            + """
+            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 factory = reg.skills.find(s => s.id === 'factory');
+            console.log(JSON.stringify({
+              agentIds: reg.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,
+              skillIds: reg.skills.map(s => s.id).sort(),
+              factoryHasContent: Boolean(factory?.content?.includes('Factory')),
+              factoryPath: factory?.path,
+            }));
+            """
+        )
+        self.assertEqual(res.returncode, 0, res.stderr)
+        d = last_json_object(res.stdout)
+        for aid in (
+            "manager",
+            "programmer",
+            "qa-a",
+            "qa-b",
+            "brainstormer",
+            "darkharvester",
+        ):
+            self.assertIn(aid, d["agentIds"])
+        self.assertEqual(d["managerMode"], "primary")
+        self.assertTrue(d["managerSystem"])
+        self.assertTrue(d["managerDeniesEdit"], "manager must not edit code")
+        self.assertEqual(d["qaMode"], "subagent")
+        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_command_switches_session_agent(self):
+        res = run_node(
+            V2_HOST
+            + """
+            import plugin from "./plugins/opencode/index.js";
+            await plugin.setup(host);
+            const factory = reg.commands.find(c => c.name === 'factory');
+            await factory.execute({sessionID: 'ses_test', prompt: {text: 'Cockpit beta'}, delivery: 'steer'});
+            console.log(JSON.stringify({
+              switches: reg.switches,
+              promptAgent: reg.prompts[0]?.agent,
+              promptHasArena: reg.prompts[0]?.text?.includes('Cockpit beta'),
+            }));
+            """
+        )
+        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.assertTrue(d["promptHasArena"])
+
+    def test_preexisting_agent_and_skill_preserved(self):
+        res = run_node(
+            """
+            const agents = [], skills = [];
+            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:()=>{}};},
+                reload: async()=>{}
+              },
+              skill: {
+                list: async()=>({data:[{id:'factory'}]}),
+                transform: async(fn)=>{fn({add:(s)=>{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}));
+            """
+        )
+        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("factory", d["skills"], "user-defined factory skill must win")
+        self.assertIn("qa-a", d["agents"])
+
+    def test_graceful_without_agent_skill_domains(self):
+        res = run_node(
+            """
+            import plugin from "./plugins/opencode/index.js";
+            const host = {
+              options: {}, location: {directory: '/tmp'},
+              tool: {transform: async()=>({dispose:()=>{}}), reload: async()=>{}},
+              session: {prompt: async()=>({})}
+            };
+            const cleanup = await plugin.setup(host);
+            console.log(JSON.stringify({cleanupFn: typeof cleanup}));
+            """
+        )
+        self.assertEqual(res.returncode, 0, res.stderr)
+        self.assertEqual(last_json_object(res.stdout)["cleanupFn"], "function")
+
+
+if __name__ == "__main__":
+    unittest.main()