@heretek-ai/epistemic-swarm 0.7.4 → 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/README.md

@@ -75,19 +75,20 @@ pi install npm:@heretek-ai/epistemic-swarm
 - OMP (`omp.sh`, oh-my-pi) shares the same entry point: `omp install npm:@heretek-ai/epistemic-swarm`, project commands in `.omp/commands/` (`/swarm`, `/grill`, `/audit`, `/scout`, `/brainstorming`, `/swarm-config`), prompts in `.omp/prompts/`, hooks in `.omp/hooks/pre|post/`.
 - All commands automatically respect `.research/config.json`.
 
-### 3. OpenCode V2 (`opencode.ai`)
-Enable IUMBTEMS in your `~/.config/opencode/opencode.json` or project `opencode.jsonc`. You can configure settings declaratively:
-```json
+### 3. OpenCode V2 ([opencode.ai/v2/docs](https://opencode.ai/v2/docs))
+Enable IUMBTEMS in your `~/.config/opencode/opencode.jsonc` or project `opencode.jsonc`. You can configure settings declaratively using native OpenCode V2 syntax:
+```jsonc
 {
-  "plugin": [
-    [
-      "@heretek-ai/epistemic-swarm",
-      {
+  "$schema": "https://opencode.ai/config.json",
+  "plugins": [
+    {
+      "package": "@heretek-ai/epistemic-swarm",
+      "options": {
         "search_engine": "duckduckgo",
         "max_iterations": 2,
         "mode": "research"
       }
-    ]
+    }
   ]
 }
 ```
@@ -197,7 +198,7 @@ Every factual claim in IUMBTEMS carries an explicit evidentiary tag:
 1. **Discovery Tier**: SearXNG (unbiased metasearch) and Brave Search API.
 2. **Extraction Tier**: Firecrawl (headless JavaScript rendering, DOM cleaning, Markdown extraction).
 3. **Academic Tier**: Semantic Scholar / arXiv MCPs for DOI citation resolution.
-4. **Caching Tier**: Content-addressed SHA-256 storage (`skills/research-cache/hasher.py`).
+4. **Caching Tier**: Content-addressed SHA-256 storage (`skills/research_cache/hasher.py`).
 
 ### Local Infrastructure (Optional)
 Run local SearXNG and Firecrawl instances via Docker Compose:

package/config/opencode-snippet.json

@@ -7,15 +7,15 @@
       "enabled": true
     }
   },
-  "plugin": [
-    [
-      "@heretek-ai/epistemic-swarm",
-      {
+  "plugins": [
+    {
+      "package": "@heretek-ai/epistemic-swarm",
+      "options": {
         "search_engine": "duckduckgo",
         "max_iterations": 2,
         "mode": "research"
       }
-    ]
+    }
   ],
   "agent": {
     "code-auditor": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heretek-ai/epistemic-swarm",
-  "version": "0.7.4",
+  "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

@@ -577,6 +577,7 @@ export const OPENCODE_COMMANDS = [
     description: 'Coding-factory Manager loop: grill-gated phased build with programmer spawns and dual QA',
     usage: '/factory <product-arena>',
     agent: 'manager',
+    subagent: false,
     subtask: false,
     template: [
       'Run the IUMBTEMS coding-factory Manager loop as the manager agent.',
@@ -586,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'),
   },
   {
@@ -593,6 +595,7 @@ export const OPENCODE_COMMANDS = [
     description: 'Autonomous agent-guided self-improvement loop over the codebase (count-flagged)',
     usage: '/domainexpansion <n>',
     agent: 'manager',
+    subagent: false,
     subtask: false,
     template: [
       'Run the IUMBTEMS domain-expansion loop as the manager agent.',
@@ -619,7 +622,14 @@ export function commandCatalog() {
     if (!cmd?.name) continue;
     out[cmd.name] = { description: cmd.description, template: cmd.template };
     if (cmd.agent) out[cmd.name].agent = cmd.agent;
+    if (cmd.subagent !== undefined) out[cmd.name].subagent = cmd.subagent;
     if (cmd.subtask !== undefined) out[cmd.name].subtask = cmd.subtask;
+    if (out[cmd.name].subagent === undefined && out[cmd.name].subtask !== undefined) {
+      out[cmd.name].subagent = out[cmd.name].subtask;
+    }
+    if (out[cmd.name].subtask === undefined && out[cmd.name].subagent !== undefined) {
+      out[cmd.name].subtask = out[cmd.name].subagent;
+    }
   }
   return out;
 }
@@ -889,13 +899,28 @@ async function registerHostCommands(host) {
         name: cmd.name,
         description: cmd.description,
         ...(cmd.agent ? { agent: cmd.agent } : {}),
-        ...(cmd.subtask !== undefined ? { subtask: cmd.subtask } : {}),
+        ...(cmd.subagent !== undefined || cmd.subtask !== undefined
+          ? {
+              subagent: cmd.subagent !== undefined ? cmd.subagent : cmd.subtask,
+              subtask: cmd.subtask !== undefined ? cmd.subtask : cmd.subagent,
+            }
+          : {}),
         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,
           });
@@ -996,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 = {};
@@ -1029,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',
@@ -1061,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/prompts/antigravity_repo_factcheck.md

@@ -0,0 +1,143 @@
+# IUMBTEMS REPOSITORY FACT-CHECKING REVIEW PROMPT FOR ANTIGRAVITY
+
+> **Role & Protocol**: You are operating as the **Epistemic Swarm Auditor** within Google AntiGravity. Your mission is to conduct a rigorous, evidentiary, live web-search fact-checking review of the **IUMBTEMS** repository (`https://github.com/Heretek-AI/IUMBTEMS` / local workspace).
+>
+> You are governed by the **Epistemic Integrity Protocol** defined in this repository: your internal parametric memory is strictly quarantined as untrusted heuristic guidance. You are prohibited from presenting unverified parametric recollections as established empirical facts. Every factual assertion must be verified against live reality via web searching and URL extraction.
+
+---
+
+## 1. MANDATORY TAGGING TAXONOMY
+
+Every factual statement, version assertion, API specification claim, or benchmark metric MUST carry an explicit epistemic tag:
+
+- `[VERIFIED: <URL | "verbatim quote excerpt">]`
+  - Backed by live web content fetched during this session via `search_web` or `read_url_content`.
+  - Must include the exact URL and an exact verbatim quote substring from the retrieved page.
+- `[INFERRED: <Parent Tags> -> <Deductive Reasoning>]`
+  - Deductive conclusion derived directly from cited `[VERIFIED]` premises.
+- `[HYPOTHESIS: <Measurable Falsification Condition>]`
+  - Unverified projection or speculation; requires an empirical test that would disprove it.
+- `[NEGATIVE_KNOWLEDGE: <Search Query>]`
+  - Rigorous confirmation that an exhaustive live web search yielded zero supporting evidence.
+
+---
+
+## 2. REPOSITORY AUDIT TARGETS
+
+Inspect the local codebase (`README.md`, `AGENTS.md`, `MARKETPLACE.md`, `package.json`, `prompts/`, and `plugins/`) and fact-check the following four empirical domains using `search_web` and `read_url_content`:
+
+### Domain 1: Package Registry & Release Veracity
+- **Claims in Repo**: The project is published on npm as `@heretek-ai/epistemic-swarm` under Apache-2.0, providing binary `iumbtems`.
+- **Fact-Checking Action**:
+  - Search `https://registry.npmjs.org/@heretek-ai%2Fepistemic-swarm` or search the web for npm package `@heretek-ai/epistemic-swarm`.
+  - Verify: Does the package exist on npm? What is the latest published version? Does it match `package.json`? Does it expose the `iumbtems` binary?
+
+### Domain 2: Peer Agent Harness Compatibility Claims
+- **Claims in Repo**:
+  1. **OpenCode V2**: Claims plugin integration in `plugins/opencode/index.js`, using slash commands (`/swarm`, `/grill`, `/audit`), agent profiles (`config/opencode-snippet.json`), and notes that OpenCode lacks a pre-execution webfetch hook.
+  2. **Pi & OMP**: Claims native install via `pi install npm:@heretek-ai/epistemic-swarm` and `omp install npm:@heretek-ai/epistemic-swarm` with command blocks in `package.json`.
+  3. **Claude Code**: Claims marketplace support via `claude plugin marketplace add Heretek-AI/IUMBTEMS` and `.claude-plugin/marketplace.json`.
+- **Fact-Checking Action**:
+  - Search official documentation and repos for OpenCode (`opencode.ai`), Pi (`pi.dev`), and Claude Code plugin specs.
+  - Verify: Are the configuration formats, CLI command syntaxes, and plugin manifest schemas valid against current upstream specifications?
+
+### Domain 3: Cited Academic & Algorithmic Benchmarks
+- **Claims in Repo** (found in `prompts/base_epistemic_system.md`, `prompts/orchestrator.md`, etc.):
+  1. Llama-3-70B context window (131,072 tokens) and GQA across 8 KV heads (`arXiv:2407.21783`).
+  2. Tip5 hash vs. Poseidon hash SNARK witness generation benchmarks.
+  3. Zero-dependency Raft consensus and DuckDuckGo Lite HTML scraping behavior.
+- **Fact-Checking Action**:
+  - Search arXiv and web sources for the cited papers and benchmarks.
+  - Verify: Are the numbers, citations, and DOIs authentic, or were any placeholder/synthetic examples presented as real citations?
+
+### Domain 4: License, Security & Dependency Invariants
+- **Claims in Repo**: Apache-2.0 clean-room licensing, permissive-only vendoring, no AGPL/GPL contamination.
+- **Fact-Checking Action**:
+  - Inspect dependencies in `package.json` and python scripts.
+  - Verify license status of key referenced dependencies via web search.
+
+---
+
+## 3. SINGLE-SESSION AGENTIC EXECUTION WORKFLOW
+
+Execute the fact-checking mission autonomously in three sequential phases:
+
+```
+[Phase 1: Alpha (Affirmative)] ──> [Phase 2: Beta (Adversary)] ──> [Phase 3: Epistemic Auditor]
+```
+
+### Phase 1: Alpha (The Affirmative Grounding)
+1. Read the local claims in `README.md` and `package.json` using `view_file`.
+2. Formulate targeted search queries and execute them using `search_web`.
+3. Fetch full source pages using `read_url_content` for key results.
+4. Extract verbatim evidence excerpts corroborating the repository's claims.
+5. Tag all confirmed claims with `[VERIFIED: <URL | "quote">]`.
+
+### Phase 2: Beta (The Adversarial Red Team)
+1. Execute inverted and adversarial queries to hunt for discrepancies, breaking changes, and invalid claims:
+   - `"<package> deprecated"`, `"<command> error"`, `"<paper> critique"`
+   - Check if any upstream harness APIs (OpenCode, Pi, Claude Code) have deprecated or altered the interfaces IUMBTEMS relies on.
+   - Hunt for missing packages, unfulfilled promises, or exaggerated marketing statements.
+2. If claimed features or benchmarks cannot be found online, log them as `[NEGATIVE_KNOWLEDGE: <query>]`.
+3. If an assertion is disproven by current live documentation, document the exact contradiction.
+
+### Phase 3: Epistemic Auditor & Mathematical Synthesis
+1. Perform character-for-character verification between extracted quotes and source URLs.
+2. Compute the **Epistemic Score**:
+   $$\mathcal{E} = \frac{1.0 \times N_{\text{verified}} + 0.5 \times N_{\text{neg\_knowledge}} - 2.5 \times N_{\text{rejected}}}{N_{\text{verified}} + N_{\text{inferred}} + N_{\text{hypothesis}} + N_{\text{rejected}}}$$
+   *(Threshold: $\mathcal{E} \ge 0.65$ to certify empirical grounding).*
+3. Compute the **Divergence Score**:
+   $$D = \frac{|\text{Contradicted Claims}|}{|\text{Total Scope Claims}|}$$
+4. Output the final synthesis report as a Markdown Artifact or structured response.
+
+---
+
+## 4. OUTPUT FORMAT SPECIFICATION
+
+Your final output must follow this structure:
+
+```markdown
+# Epistemic Fact-Checking Audit: IUMBTEMS Repository
+
+## Executive Summary
+- **Overall Verdict**: [CERTIFIED (Score >= 0.65) | AUDIT_WARNING: LOW_EMPIRICAL_GROUNDING]
+- **Epistemic Score ($\mathcal{E}$)**: `<score>`
+- **Dialectic Divergence ($D$)**: `<score>`
+- **Total Claims Audited**: `<count>` (Verified: `<count>`, Rejected: `<count>`, Negative Knowledge: `<count>`)
+
+---
+
+## Evidentiary Audit Ledger
+
+### 1. Package & Distribution Veracity
+- Claim: ...
+- Status: [VERIFIED | REJECTED | NEGATIVE_KNOWLEDGE]
+- Evidence: [VERIFIED: https://... | "Verbatim quote..."]
+- Notes: ...
+
+### 2. Multi-Harness Compatibility (OpenCode, Pi, OMP, Claude Code)
+...
+
+### 3. Academic & Benchmark Integrity
+...
+
+### 4. License & Contamination Safety
+...
+
+---
+
+## Divergence & Contradiction Matrix
+| Dimension | Affirmative Claim (Alpha) | Adversarial Finding (Beta) | Adjudicated Truth |
+| :--- | :--- | :--- | :--- |
+| ... | ... | ... | ... |
+
+---
+
+## Actionable Remediations
+1. [P0/P1/P2] Specific changes required in `README.md`, `package.json`, or code to align with verified live reality.
+```
+
+---
+
+## 5. EXECUTION DIRECTIVE
+Begin Phase 1 immediately: inspect local claims, invoke `search_web` to verify npm and harness registries, then proceed through Phase 2 and Phase 3 without stopping.

package/runner/tests/test_factory.py

@@ -238,8 +238,12 @@ class TestFactoryHelper(unittest.TestCase):
         self.assertEqual(res.returncode, 0, res.stderr)
         data = last_json_object(res.stdout)
         self.assertEqual(data["factory"]["agent"], "manager")
+        self.assertEqual(data["factory"]["subagent"], False)
+        self.assertEqual(data["factory"]["subtask"], False)
         self.assertIn("$ARGUMENTS", data["factory"]["template"])
         self.assertEqual(data["expansion"]["agent"], "manager")
+        self.assertEqual(data["expansion"]["subagent"], False)
+        self.assertEqual(data["expansion"]["subtask"], False)
 
 
 if __name__ == "__main__":

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()