opencouncil 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenCouncil Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,108 @@
+# OpenCouncil Plugin for OpenCode
+
+A multi-model council plugin for OpenCode that runs prompts across multiple LLMs and synthesizes their responses to identify consensus and discrepancies.
+
+## Installation
+
+Add the plugin to your `opencode.json`:
+
+```json
+{
+  "plugin": ["opencode-opencouncil"]
+}
+```
+
+Then restart OpenCode. The plugin will be automatically installed via Bun.
+
+## Configuration
+
+Add the configuration to your `opencode.json`:
+
+```json
+{
+  "plugin": ["opencode-opencouncil"],
+  "opencouncil": {
+    "defaultCouncil": "standard",
+    "councils": {
+      "standard": {
+        "members": [
+          { "name": "gemini", "model": "google/gemini-2.0-flash", "temperature": 0.2 },
+          { "name": "codex", "model": "openai/codex", "temperature": 0.2 },
+          { "name": "opus", "model": "anthropic/claude-opus-4", "temperature": 0.2 }
+        ]
+      }
+    }
+  }
+}
+```
+
+### Council Member Options
+
+Each member supports:
+- `name`: Identifier for the member
+- `model`: Provider/model ID (format: `provider/model`)
+- `temperature`: Sampling temperature (optional)
+- `system`: Custom system prompt (optional)
+- `options`: Additional model options (optional)
+
+## Usage
+
+### Tool: `opencouncil.run`
+
+Run a prompt through the configured council:
+
+```
+Use tool: opencouncil.run
+Prompt: "Explain the benefits of TypeScript"
+```
+
+Optional parameters:
+- `council`: Specify a council name (defaults to `defaultCouncil`)
+
+### Tool: `opencouncil.init`
+
+Initialize configuration and optionally create an agent file:
+
+```
+Use tool: opencouncil.init
+writeAgentFile: true
+```
+
+This will:
+1. Print the configuration block to add to your `opencode.json`
+2. If `writeAgentFile` is true, create `.opencode/agents/opencouncil.md`
+
+### Agent: `@opencouncil`
+
+If you ran `opencouncil.init` with `writeAgentFile: true`, you can use:
+
+```
+@opencouncil "What are the best practices for error handling?"
+```
+
+The agent will automatically call `opencouncil.run` and summarize the results.
+
+## Output Format
+
+The plugin returns:
+1. **Member responses** - Individual answers from each model
+2. **Consensus** - Claims endorsed by multiple members
+3. **Discrepancies** - Claims mentioned by only one member
+4. **Uncertainties** - Each member's expressed uncertainties
+
+## Troubleshooting
+
+### Plugin installation stuck
+
+Clear the cache and restart:
+```bash
+rm -rf ~/.cache/opencode
+```
+
+### Model not found
+
+Ensure the model IDs match those available in your OpenCode installation. Use OpenCode's CLI commands to discover available models.
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,11 @@
+import { makeRunTool } from "./tools/run.js";
+import { makeInitTool } from "./tools/init.js";
+const plugin = async (input) => {
+    return {
+        tool: {
+            "opencouncil.run": makeRunTool(input),
+            "opencouncil.init": makeInitTool(input)
+        }
+    };
+};
+export default plugin;

package/dist/lib/config.js

@@ -0,0 +1,13 @@
+export function getCouncil(cfg, requested) {
+    const oc = cfg.opencouncil ?? {};
+    const councilName = requested ?? oc.defaultCouncil ?? "standard";
+    const council = oc.councils?.[councilName];
+    const members = council?.members?.length
+        ? council.members
+        : [
+            { name: "gemini", model: "google/gemini-2.0-flash", temperature: 0.2 },
+            { name: "codex", model: "openai/codex", temperature: 0.2 },
+            { name: "opus", model: "anthropic/claude-opus-4", temperature: 0.2 }
+        ];
+    return { councilName, members, rubric: council?.rubric };
+}

package/dist/lib/models.js

@@ -0,0 +1,4 @@
+export function splitModel(model) {
+    const [providerID, ...rest] = model.split("/");
+    return { providerID, modelID: rest.join("/") };
+}

package/dist/lib/schema.js

@@ -0,0 +1,14 @@
+export const memberOutputFormat = {
+    type: "json_schema",
+    name: "member_response",
+    schema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            answer: { type: "string" },
+            claims: { type: "array", items: { type: "string" } },
+            uncertainties: { type: "array", items: { type: "string" } }
+        },
+        required: ["answer", "claims", "uncertainties"]
+    }
+};

package/dist/lib/synthesize.js

@@ -0,0 +1,20 @@
+function normalize(s) {
+    return s.trim().toLowerCase();
+}
+export function synthesize(results) {
+    const claimIndex = new Map();
+    for (const r of results) {
+        for (const c of r.claims) {
+            const key = normalize(c);
+            const entry = claimIndex.get(key) ?? { claim: c, by: [] };
+            entry.by.push({ member: r.member, model: r.model });
+            claimIndex.set(key, entry);
+        }
+    }
+    const allClaims = [...claimIndex.values()].sort((a, b) => b.by.length - a.by.length);
+    const agreed = allClaims.filter(x => x.by.length > 1);
+    const disputedCandidates = allClaims.filter(x => x.by.length === 1);
+    // Youll improve this with semantic clustering / contradiction detection later.
+    const discrepancies = disputedCandidates.slice(0, 10);
+    return { agreed, discrepancies };
+}

package/dist/tools/init.js

@@ -0,0 +1,51 @@
+import { tool } from "@opencode-ai/plugin";
+export function makeInitTool(pluginInput) {
+    return tool({
+        description: "Prints (and optionally writes) starter config + agent file for OpenCouncil.",
+        args: {
+            writeAgentFile: tool.schema.boolean().optional().describe("If true, writes .opencode/agents/opencouncil.md")
+        },
+        async execute(args, ctx) {
+            const { $, directory } = pluginInput;
+            if (args.writeAgentFile) {
+                await $ `mkdir -p ${directory}/.opencode/agents`;
+                await $ `cat > ${directory}/.opencode/agents/opencouncil.md << 'EOF'
+---
+description: Runs a multi-model council and synthesizes discrepancies
+mode: primary
+tools:
+  write: false
+  edit: false
+  bash: false
+---
+
+When asked a question, call the tool opencouncil.run with the users prompt.
+Then summarize consensus and list key discrepancies.
+EOF`;
+            }
+            return [
+                "Add this to your opencode.json (top-level):",
+                "",
+                "```jsonc",
+                "{",
+                '  "plugin": ["opencode-opencouncil"],',
+                '  "opencouncil": {',
+                '    "defaultCouncil": "standard",',
+                '    "councils": {',
+                '      "standard": {',
+                '        "members": [',
+                '          { "name": "gemini", "model": "google/<your-gemini-model>", "temperature": 0.2 },',
+                '          { "name": "codex",  "model": "openai/<your-codex-model>",  "temperature": 0.2 },',
+                '          { "name": "opus",   "model": "anthropic/<your-opus-model>", "temperature": 0.2 }',
+                "        ]",
+                "      }",
+                "    }",
+                "  }",
+                "}",
+                "```",
+                "",
+                "Then restart OpenCode (it will auto-install npm plugins)."
+            ].join("\n");
+        }
+    });
+}

package/dist/tools/run.js

@@ -0,0 +1,116 @@
+import { tool } from "@opencode-ai/plugin";
+import { getCouncil } from "../lib/config.js";
+import { splitModel } from "../lib/models.js";
+import { synthesize } from "../lib/synthesize.js";
+function isTextPart(part) {
+    return (typeof part === "object" &&
+        part !== null &&
+        "type" in part &&
+        part.type === "text" &&
+        "text" in part &&
+        typeof part.text === "string");
+}
+const MEMBER_SYSTEM_PROMPT = `You are a council member evaluating a prompt. Respond with a JSON object containing:
+- answer: your detailed response to the prompt
+- claims: an array of key factual claims you make (as strings)
+- uncertainties: an array of anything you're uncertain about (as strings)
+
+Format your response as valid JSON only, no markdown code blocks.`;
+export function makeRunTool(pluginInput) {
+    return tool({
+        description: "Runs multiple configured models on a prompt, then summarizes and identifies discrepancies.",
+        args: {
+            prompt: tool.schema.string().describe("The prompt to evaluate"),
+            council: tool.schema.string().optional().describe("Council name (defaults to configured defaultCouncil)")
+        },
+        async execute(args, ctx) {
+            const { client } = pluginInput;
+            const configResp = await client.config.get();
+            const cfg = configResp.data;
+            const { councilName, members } = getCouncil(cfg, args.council);
+            const results = await Promise.all(members.map(async (m) => {
+                const { providerID, modelID } = splitModel(m.model);
+                const systemPrompt = m.system?.trim()
+                    ? `${m.system.trim()}\n\n${MEMBER_SYSTEM_PROMPT}`
+                    : MEMBER_SYSTEM_PROMPT;
+                const res = await client.session.prompt({
+                    path: { id: cfg.session?.id ?? "current" },
+                    body: {
+                        model: { providerID, modelID },
+                        system: systemPrompt,
+                        parts: [{ type: "text", text: args.prompt }]
+                    }
+                });
+                const data = res.data;
+                if (!data) {
+                    return {
+                        member: m.name,
+                        model: m.model,
+                        answer: "",
+                        claims: [],
+                        uncertainties: []
+                    };
+                }
+                // Use unknown to bypass TypeScript's strict Part union type checking
+                const parts = data.parts;
+                const textPart = parts.find((p) => isTextPart(p));
+                const text = textPart?.text ?? "{}";
+                let parsed;
+                try {
+                    // Try to extract JSON from markdown code blocks if present
+                    const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/)
+                        || text.match(/\{[\s\S]*\}/);
+                    const jsonText = jsonMatch ? jsonMatch[1] || jsonMatch[0] : text;
+                    parsed = JSON.parse(jsonText);
+                }
+                catch {
+                    parsed = {
+                        answer: text,
+                        claims: [],
+                        uncertainties: ["Failed to parse structured response"]
+                    };
+                }
+                return {
+                    member: m.name,
+                    model: m.model,
+                    answer: parsed.answer ?? text ?? "",
+                    claims: parsed.claims ?? [],
+                    uncertainties: parsed.uncertainties ?? []
+                };
+            }));
+            const { agreed, discrepancies } = synthesize(results);
+            const lines = [];
+            lines.push(`# OpenCouncil (${councilName})`);
+            lines.push("");
+            lines.push("## Member responses");
+            for (const r of results) {
+                lines.push(`### ${r.member} (${r.model})`);
+                lines.push(r.answer || "_(no answer)_");
+                if (r.uncertainties?.length) {
+                    lines.push("");
+                    lines.push("**Uncertainties:**");
+                    for (const u of r.uncertainties)
+                        lines.push(`- ${u}`);
+                }
+                lines.push("");
+            }
+            lines.push("## Consensus (claims repeated by >1 member)");
+            if (!agreed.length)
+                lines.push("- _(none detected)_");
+            for (const a of agreed) {
+                lines.push(`- ${a.claim}  _(endorsed by: ${a.by.map(x => x.member).join(", ")})_`);
+            }
+            lines.push("");
+            lines.push("## Discrepancies (claims only mentioned by one member)");
+            if (!discrepancies.length)
+                lines.push("- _(none detected)_");
+            for (const d of discrepancies) {
+                lines.push(`- ${d.claim}  _(only: ${d.by[0].member})_`);
+            }
+            lines.push("");
+            lines.push("## Next improvement");
+            lines.push("- For higher quality discrepancy detection, add a second-pass judge prompt that clusters claims semantically and flags contradictions.");
+            return lines.join("\n");
+        }
+    });
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "opencouncil",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": "./dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.1.65"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.0"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "agents",
+    "llm"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  }
+}