@heretek-ai/epistemic-swarm 0.7.5 → 0.7.7

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,20 @@ 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,
+            // No `agent` field here: V2's SessionPromptInput has none (agent
+            // mentions only). Pinning happens via switchAgent above.
             text: cmd.template.split('$ARGUMENTS').join(String(args).trim()),
             delivery: input?.delivery,
           });
@@ -1010,6 +1022,237 @@ 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'));
+  // V2 config key is `agents` (plural); accept the legacy `agent` key for one
+  // release so older snippet copies keep working.
+  const agentDefs = (snippet && (snippet.agents || 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);
+      registerAgent(draft, 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.',
+};
+
+/** V1 permission/tool action names -> V2 permission action names. */
+const ACTION_ALIASES = { bash: 'shell', task: 'subagent', patch: 'edit', write: 'edit' };
+
+function normalizeAction(action) {
+  const key = String(action || '').trim();
+  return ACTION_ALIASES[key] || key;
+}
+
+function normalizeEffect(effect) {
+  return effect === 'deny' || effect === 'ask' ? effect : 'allow';
+}
+
+/**
+ * Map one snippet agent definition to an Agent.Info shape.
+ *
+ * Accepts the V2 config form (`permissions: [{action,resource,effect}]`) and
+ * still understands the legacy V1 form (`tools` map + `permission` map) so an
+ * older snippet copy is not silently dropped.
+ */
+function toAgentInfo(name, def) {
+  const permissions = [];
+  for (const rule of def?.permissions || []) {
+    if (rule && typeof rule === 'object' && typeof rule.action === 'string') {
+      permissions.push({
+        action: normalizeAction(rule.action),
+        resource: typeof rule.resource === 'string' ? rule.resource : '*',
+        effect: normalizeEffect(rule.effect),
+      });
+    }
+  }
+  for (const [tool, enabled] of Object.entries(def?.tools || {})) {
+    permissions.push({
+      action: normalizeAction(tool),
+      resource: '*',
+      effect: enabled ? 'allow' : 'deny',
+    });
+  }
+  for (const [key, value] of Object.entries(def?.permission || {})) {
+    if (typeof value === 'string') {
+      permissions.push({ action: normalizeAction(key), resource: '*', effect: normalizeEffect(value) });
+    } else if (value && typeof value === 'object') {
+      for (const [resource, effect] of Object.entries(value)) {
+        permissions.push({ action: normalizeAction(key), resource, effect: normalizeEffect(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;
+  // The canonical short role prompt wins; fall back to a snippet-provided one.
+  const system = FACTORY_SYSTEM[name] || def?.system;
+  if (system) info.system = system;
+  return info;
+}
+
+/**
+ * Register one agent profile through a V2 `AgentEditor`.
+ *
+ * V2's AgentEditor has NO `add()` — only `list/get/default/update/remove`
+ * (verified against @opencode/plugin@2.0.18 dist/promise/agent.d.ts). Calling
+ * `draft.add(...)` threw `draft.add is not a function` and the host disabled
+ * the whole plugin ("disabled plugin after transform failure", state=agent).
+ *
+ * `update(id, mutate)` upserts: when the id is new the host seeds the draft
+ * from `Agent.Info.default(id)` plus global permission rules, then hands it to
+ * the callback (opencode v2.0.18 agent registry:
+ * `c = agents.get(d) ?? {...default(d), permissions:[...default.permissions, ...I]}`).
+ * The first-party `opencode.config.agent` plugin registers config agents the
+ * same way, so this is the supported path for creating profile agents.
+ *
+ * Seeded permissions are kept and ours appended: rule matching is
+ * last-match-wins, so an explicit `edit: deny` still beats the default allow.
+ */
+function registerAgent(editor, name, def) {
+  const info = toAgentInfo(name, def);
+  const rules = info.permissions || [];
+  const profile = { ...info };
+  delete profile.permissions;
+  editor.update(name, (agent) => {
+    Object.assign(agent, profile);
+    agent.permissions = [...(agent.permissions || []), ...rules];
+  });
+}
+
+/** 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 +1286,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 +1348,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_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)