@heretek-ai/epistemic-swarm 0.1.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,14 @@
+{
+  "name": "heretek-official",
+  "owner": "Heretek AI",
+  "description": "Official plugins and agent harnesses from Heretek AI",
+  "plugins": {
+    "epistemic-swarm": {
+      "source": {
+        "source": "github",
+        "repo": "Heretek-AI/IUMBTEMS"
+      },
+      "description": "High-Integrity Dialectic Research Agent Harness for Claude Code"
+    }
+  }
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,58 @@
+{
+  "name": "epistemic-swarm",
+  "version": "0.1.0",
+  "description": "High-Integrity Dialectic Research Agent Harness for Claude Code enforcing empirical evidence over parametric hallucination.",
+  "author": "Heretek AI",
+  "license": "Apache-2.0",
+  "repository": "https://github.com/Heretek-AI/IUMBTEMS",
+  "mcpServers": {
+    "brave-search": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
+      "env": {
+        "BRAVE_SEARCH_API_KEY": "${BRAVE_SEARCH_API_KEY}"
+      }
+    },
+    "firecrawl": {
+      "command": "npx",
+      "args": ["-y", "firecrawl-mcp"],
+      "env": {
+        "FIRECRAWL_API_KEY": "${FIRECRAWL_API_KEY}",
+        "FIRECRAWL_API_URL": "${FIRECRAWL_API_URL:-http://localhost:3002}"
+      }
+    },
+    "searxng": {
+      "command": "python3",
+      "args": ["${PLUGIN_DIR}/config/searxng_mcp.py"],
+      "env": {
+        "SEARXNG_URL": "${SEARXNG_URL:-http://localhost:8080}"
+      }
+    }
+  },
+  "skills": [
+    "./skills/grilling",
+    "./skills/research-cache"
+  ],
+  "configuration": {
+    "SEARXNG_URL": {
+      "type": "string",
+      "description": "SearXNG metasearch instance URL",
+      "default": "http://localhost:8080"
+    },
+    "FIRECRAWL_API_URL": {
+      "type": "string",
+      "description": "Firecrawl API endpoint for JS/Markdown extraction",
+      "default": "http://localhost:3002"
+    },
+    "FIRECRAWL_API_KEY": {
+      "type": "string",
+      "description": "Firecrawl API Key (optional for self-hosted instances)",
+      "default": ""
+    },
+    "BRAVE_SEARCH_API_KEY": {
+      "type": "string",
+      "description": "Brave Search API Key for discovery",
+      "default": ""
+    }
+  }
+}

package/LICENSE

@@ -0,0 +1,126 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work.
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner.
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Heretek AI

package/README.md

@@ -0,0 +1,130 @@
+# Epistemic Swarm 🌟
+
+[![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**  
+> *Enforcing verified empirical evidence over parametric hallucination.*
+
+---
+
+## 🎯 The Epistemic Mandate
+
+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.
+
+**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.
+
+---
+
+## 🏗️ 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)"]
+```
+
+---
+
+## ⚡ Quickstart
+
+### 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 Socratic decision tree framing
+npx @heretek-ai/epistemic-swarm 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
+```
+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 |
+| :--- | :--- | :--- |
+| `[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. |
+| `[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. |
+
+---
+
+## 🔍 Multi-Tier OSINT & Search Pipeline
+
+1. **Discovery Tier**: SearXNG (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.
+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:
+```bash
+docker compose -f config/docker-compose.infra.yml up -d
+```
+
+---
+
+## 🧪 Testing
+
+Epistemic Swarm comes with an automated test suite verifying source hashing, quote substring matching, IPC state transitions, and mock swarm dispatch:
+
+```bash
+npm test
+```
+
+---
+
+## 📦 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!
+
+---
+
+## 📄 License
+
+Licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE) for details.

package/bin/cli.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+/**
+ * Epistemic Swarm CLI
+ * Multi-agent dialectic research harness for Claude Code.
+ */
+
+const { spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const PKG_ROOT = path.resolve(__dirname, '..');
+const args = process.argv.slice(2);
+const command = args[0] || 'help';
+
+function printHelp() {
+  console.log(`
+🌟 Epistemic Swarm: High-Integrity Research Harness for Claude Code
+   Organization: @heretek-ai | Repository: Heretek-AI/IUMBTEMS
+
+Usage:
+  npx @heretek-ai/epistemic-swarm <command> [options]
+  iumbtems <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)
+  help                  Show this help message
+
+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
+`);
+}
+
+function runPython(scriptRelPath, extraArgs = []) {
+  let finalArgs = [];
+  if (scriptRelPath === '-m') {
+    finalArgs = ['-m', ...extraArgs];
+  } else {
+    const scriptPath = path.join(PKG_ROOT, scriptRelPath);
+    finalArgs = [scriptPath, ...extraArgs];
+  }
+  const result = spawnSync('python3', finalArgs, {
+    stdio: 'inherit',
+    cwd: process.cwd(),
+    env: { ...process.env, PYTHONPATH: PKG_ROOT }
+  });
+  process.exit(result.status !== null ? result.status : 1);
+}
+
+function runBash(scriptRelPath, extraArgs = []) {
+  const scriptPath = path.join(PKG_ROOT, scriptRelPath);
+  const result = spawnSync('bash', [scriptPath, ...extraArgs], {
+    stdio: 'inherit',
+    cwd: process.cwd()
+  });
+  process.exit(result.status !== null ? result.status : 1);
+}
+
+switch (command) {
+  case 'run': {
+    const objective = args[1];
+    if (!objective || objective.startsWith('--')) {
+      console.error('Error: Please provide a research objective string.');
+      console.error('Example: npx @heretek-ai/epistemic-swarm run "Evaluate FPGA prover latency"');
+      process.exit(1);
+    }
+    const forwardArgs = ['--objective', objective, ...args.slice(2)];
+    runPython('runner/research_swarm.py', forwardArgs);
+    break;
+  }
+
+  case 'grill': {
+    runPython('skills/grilling/socratic_tree.py', args.slice(1));
+    break;
+  }
+
+  case 'install': {
+    runBash('install.sh', args.slice(1));
+    break;
+  }
+
+  case 'test': {
+    runPython('-m', ['unittest', 'discover', '-s', 'runner/tests']);
+    break;
+  }
+
+  case 'doctor': {
+    console.log('🔍 Checking Epistemic Swarm Environment:\n');
+    const claudeCheck = spawnSync('claude', ['--version'], { encoding: 'utf-8' });
+    if (claudeCheck.status === 0) {
+      console.log(`✅ Claude Code: ${claudeCheck.stdout.trim()}`);
+    } else {
+      console.log('⚠️ Claude Code CLI not found in PATH (Install via npm i -g @anthropic-ai/claude-code)');
+    }
+
+    const pyCheck = spawnSync('python3', ['--version'], { encoding: 'utf-8' });
+    console.log(`✅ Python: ${pyCheck.stdout ? pyCheck.stdout.trim() : 'python3 missing'}`);
+
+    console.log(`✅ Node.js: ${process.version}`);
+    console.log(`📁 Package Root: ${PKG_ROOT}`);
+    break;
+  }
+
+  case 'help':
+  default:
+    printHelp();
+    break;
+}

package/config/claude-settings-patch.json

@@ -0,0 +1,10 @@
+{
+  "env": {
+    "SEARXNG_URL": "http://localhost:8080",
+    "FIRECRAWL_API_URL": "http://localhost:3002",
+    "FIRECRAWL_API_KEY": ""
+  },
+  "enabledPlugins": {
+    "epistemic-swarm@heretek-official": true
+  }
+}

package/config/docker-compose.infra.yml

@@ -0,0 +1,23 @@
+version: '3.8'
+
+services:
+  searxng:
+    image: docker.io/searxng/searxng:latest
+    container_name: epistemic-searxng
+    ports:
+      - "8080:8080"
+    volumes:
+      - ./searxng-data:/etc/searxng:rw
+    environment:
+      - SEARXNG_BASE_URL=http://localhost:8080/
+    restart: unless-stopped
+
+  firecrawl:
+    image: mendableai/firecrawl:latest
+    container_name: epistemic-firecrawl
+    ports:
+      - "3002:3002"
+    environment:
+      - PORT=3002
+      - NUM_WORKERS=4
+    restart: unless-stopped

package/config/mcp-research-servers.json

@@ -0,0 +1,26 @@
+{
+  "mcpServers": {
+    "brave-search": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
+      "env": {
+        "BRAVE_SEARCH_API_KEY": "${BRAVE_SEARCH_API_KEY}"
+      }
+    },
+    "searxng": {
+      "command": "python3",
+      "args": ["config/searxng_mcp.py"],
+      "env": {
+        "SEARXNG_URL": "${SEARXNG_URL:-http://localhost:8080}"
+      }
+    },
+    "firecrawl": {
+      "command": "npx",
+      "args": ["-y", "firecrawl-mcp"],
+      "env": {
+        "FIRECRAWL_API_KEY": "${FIRECRAWL_API_KEY}",
+        "FIRECRAWL_API_URL": "${FIRECRAWL_API_URL:-http://localhost:3002}"
+      }
+    }
+  }
+}

package/config/searxng_mcp.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""
+Lightweight MCP Server for SearXNG Metasearch.
+Provides unbiased search results directly to Claude Code agents.
+"""
+
+import os
+import sys
+import json
+import urllib.request
+import urllib.parse
+from typing import Dict, Any, List
+
+SEARXNG_URL = os.environ.get("SEARXNG_URL", "http://localhost:8080")
+
+def search_searxng(query: str, categories: str = "general", max_results: int = 10) -> List[Dict[str, Any]]:
+    """Query SearXNG JSON endpoint."""
+    params = {
+        "q": query,
+        "format": "json",
+        "categories": categories,
+        "language": "en"
+    }
+    url = f"{SEARXNG_URL.rstrip('/')}/search?{urllib.parse.urlencode(params)}"
+    req = urllib.request.Request(url, headers={"User-Agent": "EpistemicSwarm/1.0"})
+    
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+            results = data.get("results", [])[:max_results]
+            return [
+                {
+                    "title": r.get("title", ""),
+                    "url": r.get("url", ""),
+                    "snippet": r.get("content", ""),
+                    "engine": r.get("engine", "")
+                }
+                for r in results
+            ]
+    except Exception as e:
+        return [{"error": f"Failed to query SearXNG at {SEARXNG_URL}: {str(e)}"}]
+
+
+def handle_json_rpc(line: str):
+    """Minimal JSON-RPC 2.0 loop for MCP protocol."""
+    try:
+        msg = json.loads(line)
+    except Exception:
+        return
+
+    msg_id = msg.get("id")
+    method = msg.get("method")
+
+    if method == "initialize":
+        response = {
+            "jsonrpc": "2.0",
+            "id": msg_id,
+            "result": {
+                "protocolVersion": "2024-11-05",
+                "capabilities": {
+                    "tools": {}
+                },
+                "serverInfo": {
+                    "name": "searxng-mcp",
+                    "version": "1.0.0"
+                }
+            }
+        }
+        sys.stdout.write(json.dumps(response) + "\n")
+        sys.stdout.flush()
+
+    elif method == "tools/list":
+        response = {
+            "jsonrpc": "2.0",
+            "id": msg_id,
+            "result": {
+                "tools": [
+                    {
+                        "name": "searxng_search",
+                        "description": "Execute an unbiased multi-engine metasearch via SearXNG.",
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {
+                                "query": {"type": "string", "description": "Search query"},
+                                "categories": {
+                                    "type": "string",
+                                    "description": "Categories (general, science, it)",
+                                    "default": "general"
+                                },
+                                "max_results": {"type": "integer", "default": 10}
+                            },
+                            "required": ["query"]
+                        }
+                    }
+                ]
+            }
+        }
+        sys.stdout.write(json.dumps(response) + "\n")
+        sys.stdout.flush()
+
+    elif method == "tools/call":
+        params = msg.get("params", {})
+        tool_name = params.get("name")
+        args = params.get("arguments", {})
+
+        if tool_name == "searxng_search":
+            query = args.get("query", "")
+            cat = args.get("categories", "general")
+            limit = args.get("max_results", 10)
+            res = search_searxng(query, categories=cat, max_results=limit)
+            response = {
+                "jsonrpc": "2.0",
+                "id": msg_id,
+                "result": {
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": json.dumps(res, indent=2)
+                        }
+                    ]
+                }
+            }
+            sys.stdout.write(json.dumps(response) + "\n")
+            sys.stdout.flush()
+
+
+def main():
+    for line in sys.stdin:
+        if line.strip():
+            handle_json_rpc(line.strip())
+
+if __name__ == "__main__":
+    main()