@heretek-ai/epistemic-swarm 0.1.0 → 0.2.0

package/README.md

@@ -1,127 +1,133 @@
-# Epistemic Swarm 🌟
+# IUMBTEMS: I Use My Brain To Express My Self 🧠
 
 [![npm version](https://img.shields.io/npm/v/@heretek-ai/epistemic-swarm.svg)](https://www.npmjs.com/package/@heretek-ai/epistemic-swarm)
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![CI/CD](https://github.com/Heretek-AI/IUMBTEMS/actions/workflows/publish.yml/badge.svg)](https://github.com/Heretek-AI/IUMBTEMS/actions)
 
-> **High-Integrity Dialectic Research Agent Harness for Claude Code**  
+> **High-Integrity Dialectic Research Agent Harness**  
+> *Universal support for Claude Code, Pi (pi.dev), and OpenCode V2.*  
 > *Enforcing verified empirical evidence over parametric hallucination.*
 
 ---
 
-## 🎯 The Epistemic Mandate
+## 💡 The Philosophy of IUMBTEMS
 
-Current AI research assistants suffer from parametric hallucination, sycophancy, and premature narrative consensus. They invent citations, smooth over technical contradictions, and extrapolate beyond empirical bounds.
+**IUMBTEMS** (**I Use My Brain To Express My Self**) is grounded in a singular design mandate: **Epistemic Sovereignty**.
 
-**Epistemic Swarm** is an autonomous, dialectic research harness built on top of [Claude Code](https://claude.ai/code) (`~/.claude/` and `~/.claude.json`). It enforces **evidentiary primacy** through:
-1. **Mathematical Evidentiary Tags**: Every factual claim is tagged `[VERIFIED: <hash>]`, `[INFERRED: ...]`, `[HYPOTHESIS: ...]`, or `[NEGATIVE_KNOWLEDGE: ...]`.
-2. **Dialectic Swarm Architecture**: Competitively dispatches **Agent Alpha** (The Thesis / Primary Literature Proponent) and **Agent Beta** (The Antithesis / Hostile Red Team / Active Falsifier).
-3. **Content-Addressed Source Caching**: Web pages and papers are hashed to SHA-256 (`.research/sources/<sha256>.md`).
-4. **Algorithmic Epistemic Auditor**: Verifies cited quotes verbatim against the raw source cache, downgrades fabricated claims, scores divergence, and synthesizes the unvarnished empirical truth.
-5. **Socratic Grilling & Divergent Ideation**: Matt Pocock-style design tree traversal that explores assumption inversions and clarifies constraints *before* committing to search queries.
+Modern LLMs suffer from parametric hallucination, sycophancy, and premature narrative consensus. They invent citations, smooth over technical contradictions, and extrapolate beyond empirical bounds.
+
+**IUMBTEMS** restores rigorous empirical grounding by pairing an unconstrained divergent exploration phase (Matt Pocock-style Socratic grilling and assumption inversion) with a multi-agent dialectic swarm:
+1. **Agent Alpha (The Proponent / Thesis)**: Gathers corroborating primary sources, empirical proofs, and implementation benchmarks.
+2. **Agent Beta (The Adversary / Antithesis / Red Team)**: Hunts for counter-arguments, retracted data, methodology flaws, and edge-case failures.
+3. **Epistemic Auditor**: Verifies cited quotes verbatim against content-addressed raw markdown caches (`.research/sources/<sha256>.md`), prunes ungrounded assertions, and scores dialectic divergence.
 
 ---
 
-## 🏗️ System Architecture
-
-```mermaid
-flowchart TD
-    User([Research Objective]) --> Grilling["Phase 1: Socratic Grilling (/grilling)\n(Assumption Inversion & Frontier Resolution)"]
-    Grilling --> SettledFrontier[Settled Problem Frontier & Constraints]
-    SettledFrontier --> Orchestrator["Phase 2: Swarm Orchestrator\n(Scope Decomposition & DAG Planner)"]
-    
-    Orchestrator --> Scope1[Scope 1: Technical Mechanisms]
-    Orchestrator --> Scope2[Scope 2: Scalability & Economics]
-    
-    subgraph DialecticLoop [Parallel Dialectic Execution per Scope]
-        Scope1 --> Alpha["Agent Alpha: The Proponent\n(Empirical Evidence, Primary Literature)"]
-        Scope1 --> Beta["Agent Beta: The Adversary\n(Active Falsification, Red-Teaming)"]
-        
-        Alpha -->|Writes| AlphaDossier[alpha_dossier.json + Cached Sources]
-        Beta -->|Writes| BetaDossier[beta_dossier.json + Cached Sources]
-        
-        AlphaDossier --> Auditor["Phase 3: Epistemic Auditor\n(Verbatim Quote Hash Verification & Divergence Scoring)"]
-        BetaDossier --> Auditor
-        Auditor --> ScopeSynth[Scope Synthesis & Audit Report]
-    end
-    
-    ScopeSynth --> MasterSynth["Phase 4: Master Synthesis (.research/final_synthesis.md)"]
+## 🌐 Universal Multi-Platform Support
+
+IUMBTEMS is packaged as a single universal npm package (`@heretek-ai/epistemic-swarm` with `iumbtems` binary) that runs across the three major autonomous agent platforms:
+
+### 1. Claude Code
+Install skills and MCP servers into `~/.claude/` and `~/.claude.json`:
+```bash
+npx @heretek-ai/epistemic-swarm install
+# or from local repo:
+npm run install-local
+```
+- Run `/grilling` inside any interactive Claude Code session.
+- Run headless dialectic research:
+  ```bash
+  iumbtems run "Evaluate FPGA Poseidon prover latency bounds"
+  ```
+
+### 2. Pi (`pi.dev`)
+Install directly into Pi via its native package manager:
+```bash
+pi install npm:@heretek-ai/epistemic-swarm
+```
+- Exposes native `/swarm <objective>` and `/grill` slash commands in the Pi interactive terminal.
+- Discovers skills (`skills/grilling`, `skills/research-cache`) and prompts automatically via the `pi` manifest block.
+
+### 3. OpenCode V2 (`opencode.ai`)
+Enable IUMBTEMS in your `~/.config/opencode/opencode.json` or project `opencode.jsonc`:
+```json
+{
+  "plugin": [
+    "@heretek-ai/epistemic-swarm"
+  ]
+}
 ```
+OpenCode V2 automatically registers:
+- `iumbtems_swarm_research`: Dispatches dialectic researcher pairs.
+- `iumbtems_verify_quote`: Audits verbatim citations against the SHA-256 source cache.
+- `iumbtems_socratic_frontier`: Advances the Socratic decision tree frontier.
+
+*(See [config/opencode-snippet.json](config/opencode-snippet.json) for custom agent definitions).*
 
 ---
 
-## ⚡ Quickstart
+## ⚡ CLI Command Reference
 
-### Option 1: Run via NPX (Zero Setup)
 ```bash
-# Execute deep research swarm directly
-npx @heretek-ai/epistemic-swarm run "Evaluate FPGA Poseidon prover latency bounds"
+# Run the autonomous dialectic research swarm
+iumbtems run "Sub-millisecond ZK state updates on L1 rollups"
 
-# Run Socratic decision tree framing
-npx @heretek-ai/epistemic-swarm grill --objective "L1 vs L2 state verification trade-offs"
-```
+# Run Socratic grilling and decision frontier calculation
+iumbtems grill --objective "L1 vs L2 state verification trade-offs"
 
-### Option 2: Install into Claude Code Environment
-```bash
-git clone https://github.com/Heretek-AI/IUMBTEMS.git
-cd IUMBTEMS
-npm run install-local
+# Environment diagnostics (Claude Code, Node, Python)
+iumbtems doctor
+
+# Run automated test suite
+iumbtems test
 ```
-This automatically symlinks the `/grilling` and `/research-cache` skills into `~/.claude/skills/` and configures MCP servers in `~/.claude.json`.
 
 ---
 
 ## 🏷️ Epistemic Tagging Taxonomy
 
-| Tag | Meaning | Requirement |
+Every factual claim in IUMBTEMS carries an explicit evidentiary tag:
+
+| Tag | Formal Definition | Verification Standard |
 | :--- | :--- | :--- |
-| `[VERIFIED: <hash>]` | Direct empirical fact backed by primary source. | Verbatim quote must exist in `.research/sources/<hash>.md`. |
-| `[INFERRED: <reasoning>]` | Deductive conclusion from verified facts. | Must list parent verified claims and deductive step. |
+| `[VERIFIED: <hash>]` | Direct empirical fact from primary source. | Verbatim quote must exist in `.research/sources/<hash>.md`. |
+| `[INFERRED: <reasoning>]` | Deductive conclusion from verified facts. | Explicit list of parent verified premises and bridging logic. |
 | `[HYPOTHESIS: <test>]` | Speculative assertion or projection. | Must define a measurable falsification criterion. |
-| `[NEGATIVE_KNOWLEDGE: <query>]` | Verified absence of empirical evidence. | Records exact search query and confirmed literature gap. |
+| `[NEGATIVE_KNOWLEDGE: <query>]` | Verified absence of empirical evidence. | Records exact search query and literature gap. |
 
 ---
 
 ## 🔍 Multi-Tier OSINT & Search Pipeline
 
-1. **Discovery Tier**: SearXNG (metasearch) and Brave Search API.
+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 resolution.
+3. **Academic Tier**: Semantic Scholar / arXiv MCPs for DOI citation resolution.
 4. **Caching Tier**: Content-addressed SHA-256 storage (`skills/research-cache/hasher.py`).
 
-### Optional Turnkey Infrastructure (SearXNG + Firecrawl)
-To run your own unbiased metasearch and headless extractor locally:
+### Local Infrastructure (Optional)
+Run local SearXNG and Firecrawl instances via Docker Compose:
 ```bash
 docker compose -f config/docker-compose.infra.yml up -d
 ```
 
 ---
 
-## 🧪 Testing
+## 📦 CI/CD & Trusted Publishing
 
-Epistemic Swarm comes with an automated test suite verifying source hashing, quote substring matching, IPC state transitions, and mock swarm dispatch:
+This package is distributed on npm under `@heretek-ai` with [npm Trusted Publishing (OIDC)](https://docs.npmjs.com/trusted-publishers) and GitHub Actions.
 
+### First-Time CLI Bootstrap
 ```bash
-npm test
+git pull origin main
+npm publish --access public
 ```
 
----
-
-## 📦 Deployment & CI/CD
-
-This package is distributed via npm under `@heretek-ai` with [npm Trusted Publishing (OIDC)](https://docs.npmjs.com/trusted-publishers) and GitHub Actions.
-
-### First-Time Publication (One-Time Bootstrap)
-1. Authenticate locally:
-   ```bash
-   npm login
-   ```
-2. Publish initial version:
-   ```bash
-   npm publish --access public
-   ```
-3. In `npmjs.com/package/@heretek-ai/epistemic-swarm/access`, add **GitHub Actions** as a Trusted Publisher for repository `Heretek-AI/IUMBTEMS` and workflow `.github/workflows/publish.yml`.
-4. Subsequent releases publish automatically upon pushing a GitHub Release or git tag!
+### GitHub Actions OIDC Setup
+1. In `npmjs.com/package/@heretek-ai/epistemic-swarm/access`, add **GitHub Actions** as a Trusted Publisher:
+   - **Repository Owner**: `Heretek-AI`
+   - **Repository Name**: `IUMBTEMS`
+   - **Workflow Pattern**: `.github/workflows/publish.yml`
+2. Future releases publish automatically upon pushing a GitHub Release or version tag (`v*.*.*`)!
 
 ---
 

package/bin/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 /**
- * Epistemic Swarm CLI
- * Multi-agent dialectic research harness for Claude Code.
+ * IUMBTEMS CLI: I Use My Brain To Express My Self
+ * High-Integrity Dialectic Research Harness for Claude Code, Pi, and OpenCode V2.
  */
 
 const { spawnSync } = require('child_process');
@@ -15,30 +15,37 @@ const command = args[0] || 'help';
 
 function printHelp() {
   console.log(`
-🌟 Epistemic Swarm: High-Integrity Research Harness for Claude Code
+🧠 IUMBTEMS: I Use My Brain To Express My Self
+🌟 Epistemic Swarm: High-Integrity Research Harness
+   Platforms: Claude Code | Pi (pi.dev) | OpenCode V2
    Organization: @heretek-ai | Repository: Heretek-AI/IUMBTEMS
 
 Usage:
-  npx @heretek-ai/epistemic-swarm <command> [options]
   iumbtems <command> [options]
+  npx @heretek-ai/epistemic-swarm <command> [options]
 
 Commands:
   run "<objective>"     Run the dialectic multi-agent research swarm
   grill                 Launch interactive Socratic decision tree framing
   install               Install skills & MCP servers into ~/.claude/
   test                  Run test suite for hashing, state machine & auditor
-  doctor                Check environment requirements (Claude Code, Python, Node)
+  doctor                Check environment requirements (Claude Code, Pi, OpenCode)
   help                  Show this help message
 
+Platform Extensions:
+  Pi (pi.dev):          pi install npm:@heretek-ai/epistemic-swarm
+  OpenCode V2:          add "@heretek-ai/epistemic-swarm" to opencode.json plugins
+  Claude Code:          npx @heretek-ai/epistemic-swarm install
+
 Options:
   --mock-claude         Run swarm with synthetic mock responses (zero API cost)
   --frontier <file>     Path to settled frontier.json from Socratic grilling
   --dir <path>          Path to .research workspace directory (default: .research)
 
 Examples:
-  npx @heretek-ai/epistemic-swarm run "Verify sub-millisecond ZK prover latency"
-  npx @heretek-ai/epistemic-swarm grill --objective "Rollup architecture trade-offs"
-  npx @heretek-ai/epistemic-swarm install
+  iumbtems run "Verify sub-millisecond ZK prover latency"
+  iumbtems grill --objective "Rollup architecture trade-offs"
+  iumbtems doctor
 `);
 }
 

package/config/opencode-snippet.json

@@ -0,0 +1,48 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    "@heretek-ai/epistemic-swarm"
+  ],
+  "agent": {
+    "alpha-thesis": {
+      "description": "IUMBTEMS Proponent Agent: Gathers corroborating primary sources, benchmark results, and empirical proofs.",
+      "tools": {
+        "bash": true,
+        "read": true,
+        "write": true,
+        "grep": true,
+        "glob": true,
+        "task": true,
+        "iumbtems_verify_quote": true
+      }
+    },
+    "beta-redteam": {
+      "description": "IUMBTEMS Adversary Agent: Active falsification, red-teaming, hunting for counter-benchmarks, and edge-case failure modes.",
+      "tools": {
+        "bash": true,
+        "read": true,
+        "write": true,
+        "grep": true,
+        "glob": true,
+        "task": true,
+        "iumbtems_verify_quote": true
+      }
+    },
+    "epistemic-auditor": {
+      "description": "IUMBTEMS Synthesizer & Auditor: Verifies verbatim source quotes, downgrades unverified claims, and calculates divergence.",
+      "tools": {
+        "read": true,
+        "write": true,
+        "grep": true,
+        "glob": true,
+        "iumbtems_verify_quote": true
+      }
+    }
+  },
+  "skills": {
+    "paths": [
+      "./skills/grilling",
+      "./skills/research-cache"
+    ]
+  }
+}

package/extensions/pi/index.js

@@ -0,0 +1,90 @@
+/**
+ * IUMBTEMS: I Use My Brain To Express My Self
+ * Native Extension for Pi (pi.dev)
+ * 
+ * Exposes /grill and /swarm slash commands and epistemic verification tools in Pi.
+ */
+
+import { spawnSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PKG_ROOT = path.resolve(__dirname, '../..');
+
+export default function initPiExtension(pi) {
+  // Check if Pi extension API is available
+  if (!pi) return;
+
+  // 1. Register /swarm slash command
+  if (typeof pi.registerCommand === 'function') {
+    pi.registerCommand('swarm', {
+      description: 'Run IUMBTEMS dialectic research swarm on an objective',
+      usage: '/swarm <objective>',
+      handler: async (args, ctx) => {
+        const objective = args.trim();
+        if (!objective) {
+          ctx.output?.('⚠️ Please provide a research objective. Example: /swarm "ZK prover latency bounds"');
+          return;
+        }
+
+        ctx.output?.(`🌟 [IUMBTEMS] Dispatching Dialectic Swarm: "${objective}"...`);
+        const runnerPath = path.join(PKG_ROOT, 'runner/research_swarm.py');
+        const res = spawnSync('python3', [runnerPath, '--objective', objective], {
+          encoding: 'utf-8',
+          cwd: ctx.cwd || process.cwd(),
+          env: { ...process.env, PYTHONPATH: PKG_ROOT }
+        });
+
+        if (res.status === 0) {
+          ctx.output?.(res.stdout);
+          ctx.output?.('\n✅ Research complete! Summary written to .research/final_synthesis.md');
+        } else {
+          ctx.output?.(`❌ Swarm failed:\n${res.stderr || res.stdout}`);
+        }
+      }
+    });
+
+    // 2. Register /grill slash command
+    pi.registerCommand('grill', {
+      description: 'Launch Socratic grilling and decision tree frontier exploration',
+      usage: '/grill [--objective <text>]',
+      handler: async (args, ctx) => {
+        ctx.output?.('🧠 [IUMBTEMS] Launching Socratic Grilling decision tree...');
+        const treePath = path.join(PKG_ROOT, 'skills/grilling/socratic_tree.py');
+        const forwardArgs = args.trim() ? ['--objective', args.trim()] : ['--show-frontier'];
+        const res = spawnSync('python3', [treePath, ...forwardArgs], {
+          encoding: 'utf-8',
+          cwd: ctx.cwd || process.cwd()
+        });
+        ctx.output?.(res.stdout || res.stderr);
+      }
+    });
+  }
+
+  // 3. Register tool for epistemic quote verification
+  if (typeof pi.registerTool === 'function') {
+    pi.registerTool({
+      name: 'iumbtems_verify_quote',
+      description: 'Verify that an empirical claim quote matches verbatim text in the source cache',
+      parameters: {
+        type: 'object',
+        properties: {
+          hash: { type: 'string', description: 'SHA-256 hash of cached source' },
+          quote: { type: 'string', description: 'Verbatim quote string to verify' }
+        },
+        required: ['hash', 'quote']
+      },
+      execute: async ({ hash, quote }) => {
+        const hasherPath = path.join(PKG_ROOT, 'skills/research-cache/hasher.py');
+        const res = spawnSync('python3', [hasherPath, 'verify', '--hash', hash, '--quote', quote], {
+          encoding: 'utf-8'
+        });
+        return {
+          content: [{ type: 'text', text: res.stdout || res.stderr }]
+        };
+      }
+    });
+  }
+}

package/package.json

@@ -1,11 +1,17 @@
 {
   "name": "@heretek-ai/epistemic-swarm",
-  "version": "0.1.0",
-  "description": "Epistemic Swarm: High-Integrity Dialectic Research Agent Harness for Claude Code",
+  "version": "0.2.0",
+  "description": "IUMBTEMS: I Use My Brain To Express My Self — High-Integrity Dialectic Research Agent Harness for Claude Code, Pi (pi.dev), and OpenCode V2",
   "main": "bin/cli.js",
   "bin": {
-    "epistemic-swarm": "bin/cli.js",
-    "iumbtems": "bin/cli.js"
+    "iumbtems": "bin/cli.js",
+    "epistemic-swarm": "bin/cli.js"
+  },
+  "exports": {
+    ".": "./bin/cli.js",
+    "./opencode": "./plugins/opencode/index.js",
+    "./server": "./plugins/opencode/index.js",
+    "./pi": "./extensions/pi/index.js"
   },
   "publishConfig": {
     "access": "public"
@@ -19,6 +25,10 @@
   },
   "homepage": "https://github.com/Heretek-AI/IUMBTEMS#readme",
   "keywords": [
+    "iumbtems",
+    "pi-package",
+    "opencode",
+    "opencode-plugin",
     "claude-code",
     "ai-agents",
     "dialectic-swarm",
@@ -28,6 +38,18 @@
     "deep-research",
     "socratic-grilling"
   ],
+  "pi": {
+    "extensions": [
+      "./extensions/pi/index.js"
+    ],
+    "skills": [
+      "./skills/grilling",
+      "./skills/research-cache"
+    ],
+    "prompts": [
+      "./prompts/*.md"
+    ]
+  },
   "author": "Heretek AI",
   "license": "Apache-2.0",
   "files": [
@@ -36,6 +58,8 @@
     "skills",
     "config",
     "runner",
+    "extensions",
+    "plugins",
     ".claude-plugin",
     "install.sh",
     "README.md",

package/plugins/opencode/index.js

@@ -0,0 +1,149 @@
+/**
+ * IUMBTEMS: I Use My Brain To Express My Self
+ * Native Plugin for OpenCode V2 (opencode.ai)
+ * 
+ * Exposes dialectic swarm research tools, Socratic decision frontier calculation,
+ * and content-addressed quote verification directly into OpenCode V2 agents.
+ */
+
+import { spawnSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PKG_ROOT = path.resolve(__dirname, '../..');
+
+export function createOpenCodePlugin(context = {}) {
+  return {
+    id: "heretek.iumbtems.epistemic-swarm",
+    name: "IUMBTEMS Epistemic Swarm",
+    version: "0.1.0",
+    description: "I Use My Brain To Express My Self: Dialectic research swarm enforcing empirical verification",
+
+    server: (toolContext) => [
+      {
+        name: "iumbtems_swarm_research",
+        description: "Execute an autonomous dialectic research swarm on an objective using Agent Alpha (Thesis) and Agent Beta (Red Team).",
+        input: {
+          type: "object",
+          properties: {
+            objective: {
+              type: "string",
+              description: "The research question or hypothesis to investigate"
+            },
+            mock_mode: {
+              type: "boolean",
+              description: "Run in mock/dry-run mode without external API charges",
+              default: false
+            }
+          },
+          required: ["objective"]
+        },
+        options: { codemode: false },
+        execute: async (args) => {
+          const runnerPath = path.join(PKG_ROOT, "runner/research_swarm.py");
+          const cmdArgs = [runnerPath, "--objective", args.objective];
+          if (args.mock_mode) {
+            cmdArgs.push("--mock-claude");
+          }
+
+          const res = spawnSync("python3", cmdArgs, {
+            encoding: "utf-8",
+            cwd: toolContext?.cwd || process.cwd(),
+            env: { ...process.env, PYTHONPATH: PKG_ROOT }
+          });
+
+          return {
+            content: res.stdout || res.stderr,
+            status: res.status === 0 ? "success" : "error"
+          };
+        }
+      },
+
+      {
+        name: "iumbtems_verify_quote",
+        description: "Cryptographically verify whether a cited quote matches verbatim text inside the content-addressed source cache.",
+        input: {
+          type: "object",
+          properties: {
+            hash: {
+              type: "string",
+              description: "SHA-256 hash or prefix of the cached source"
+            },
+            quote: {
+              type: "string",
+              description: "The verbatim excerpt to verify"
+            }
+          },
+          required: ["hash", "quote"]
+        },
+        options: { codemode: false },
+        execute: async (args) => {
+          const hasherPath = path.join(PKG_ROOT, "skills/research-cache/hasher.py");
+          const res = spawnSync("python3", [hasherPath, "verify", "--hash", args.hash, "--quote", args.quote], {
+            encoding: "utf-8",
+            cwd: toolContext?.cwd || process.cwd()
+          });
+
+          return {
+            content: res.stdout || res.stderr,
+            status: res.status === 0 ? "verified" : "failed"
+          };
+        }
+      },
+
+      {
+        name: "iumbtems_socratic_frontier",
+        description: "Inspect or advance the Socratic grilling decision frontier for research framing.",
+        input: {
+          type: "object",
+          properties: {
+            objective: {
+              type: "string",
+              description: "Research objective to inspect"
+            },
+            settle_node: {
+              type: "string",
+              description: "Optional node ID to settle with an answer"
+            },
+            settle_answer: {
+              type: "string",
+              description: "Answer for the settled node"
+            }
+          }
+        },
+        options: { codemode: false },
+        execute: async (args) => {
+          const treePath = path.join(PKG_ROOT, "skills/grilling/socratic_tree.py");
+          const cmdArgs = [treePath];
+
+          if (args.settle_node && args.settle_answer) {
+            cmdArgs.push("--settle", args.settle_node, args.settle_answer);
+          } else if (args.objective) {
+            cmdArgs.push("--objective", args.objective, "--show-frontier");
+          } else {
+            cmdArgs.push("--show-frontier");
+          }
+
+          const res = spawnSync("python3", cmdArgs, {
+            encoding: "utf-8",
+            cwd: toolContext?.cwd || process.cwd()
+          });
+
+          return {
+            content: res.stdout || res.stderr
+          };
+        }
+      }
+    ],
+
+    setup: async (appContext) => {
+      // OpenCode V2 lifecycle hook
+      return { initialized: true, platform: "opencode-v2" };
+    }
+  };
+}
+
+const defaultPlugin = createOpenCodePlugin();
+export default defaultPlugin;

package/runner/tests/test_swarm.py

@@ -5,6 +5,7 @@ Tests source hashing, state machine IPC transitions, auditor engine, and swarm m
 """
 
 import sys
+import json
 import shutil
 import tempfile
 import unittest
@@ -173,6 +174,34 @@ In our experiments, the 70B parameter model was trained on 15.0 trillion tokens.
             self.assertIn("Master Epistemic Research Report", report_text)
             self.assertIn("Swarm Epistemic Audit Totals", report_text)
 
+    def test_pi_and_opencode_manifest_integrity(self):
+        pkg_json_path = PROJECT_ROOT / "package.json"
+        self.assertTrue(pkg_json_path.exists())
+        with open(pkg_json_path, "r", encoding="utf-8") as f:
+            pkg = json.load(f)
+
+        # 1. Pi manifest validation
+        self.assertIn("pi", pkg)
+        self.assertIn("pi-package", pkg.get("keywords", []))
+        for skill_path in pkg["pi"].get("skills", []):
+            resolved = (PROJECT_ROOT / skill_path).resolve()
+            self.assertTrue(resolved.exists(), f"Pi skill path not found: {skill_path}")
+
+        for ext_path in pkg["pi"].get("extensions", []):
+            resolved = (PROJECT_ROOT / ext_path).resolve()
+            self.assertTrue(resolved.exists(), f"Pi extension path not found: {ext_path}")
+
+        # 2. OpenCode plugin validation
+        self.assertIn("opencode", pkg.get("keywords", []))
+        self.assertIn("./opencode", pkg.get("exports", {}))
+        opencode_entry = PROJECT_ROOT / "plugins/opencode/index.js"
+        self.assertTrue(opencode_entry.exists())
+
+        # 3. IUMBTEMS binary alias
+        self.assertIn("iumbtems", pkg.get("bin", {}))
+        self.assertTrue((PROJECT_ROOT / pkg["bin"]["iumbtems"]).exists())
+
 
 if __name__ == "__main__":
     unittest.main()
+