deliberate 1.0.3 → 1.0.4

package/README.md

@@ -111,7 +111,7 @@ npm install -g deliberate
 deliberate install
 ```
 
-The installer walks you through LLM provider setup (Claude, Anthropic API, or Ollama).
+The installer sets up Claude Code hooks and the OpenCode plugin, then walks you through LLM provider setup (Claude, Anthropic API, or Ollama). If OpenCode is installed, it registers two `file://` plugins (commands + changes) in `~/.config/opencode/opencode.json`.
 
 ### Dependencies
 
@@ -126,7 +126,7 @@ The CmdCaliper embedding model (~419MB) downloads on first use.
 ## CLI
 
 ```bash
-deliberate install          # Install hooks, configure LLM
+deliberate install          # Install Claude Code hooks + OpenCode plugin, configure LLM
 deliberate status           # Check installation
 deliberate classify "rm -rf /"   # Test classification → DANGEROUS
 deliberate serve            # Start classifier server (faster)
@@ -159,10 +159,19 @@ python training/build_classifier.py --model base  # Retrain
 
 - Node.js 18+
 - Python 3.9+
-- Claude Code (or any tool supporting Claude Code hooks)
+- Claude Code or OpenCode 1.0+
 
 Works on macOS, Linux, and Windows.
 
+## OpenCode
+
+OpenCode support is installed by `deliberate install`. It registers two plugins in `~/.config/opencode/opencode.json`:
+
+- `file://~/.config/opencode/plugins/deliberate.js` (command safety)
+- `file://~/.config/opencode/plugins/deliberate-changes.js` (edit/change summaries)
+
+After install, restart OpenCode to load the plugins. For edit/change summaries, OpenCode must be configured to allow edit tools (write/edit/patch/multiedit) so the plugin can read tool metadata. The plugins call the same Deliberate hook scripts, so LLM explanations behave the same as Claude Code.
+
 ## Uninstall
 
 ```bash

package/bin/cli.js

@@ -21,7 +21,7 @@ program
 
 program
   .command('install')
-  .description('Install hooks and configure Claude Code integration')
+  .description('Install hooks and configure Claude Code/OpenCode integration')
   .action(async () => {
     await install();
   });
@@ -49,7 +49,7 @@ program
   .action(async () => {
     console.log('Deliberate Status\n');
 
-    // Check hooks installation
+    // Check Claude Code hooks installation
     const claudeSettingsPath = join(homedir(), '.claude', 'settings.json');
     let hooksInstalled = false;
 
@@ -60,21 +60,20 @@ program
         const preToolUse = hooks.PreToolUse || [];
         const postToolUse = hooks.PostToolUse || [];
 
-        const hasCommandHook = preToolUse.some(h =>
-          h.command && h.command.includes('explain-command')
-        );
-        const hasChangesHook = postToolUse.some(h =>
-          h.command && h.command.includes('explain-changes')
-        );
+        const hasHookCommand = (entries, needle) =>
+          entries.some(entry => Array.isArray(entry.hooks) && entry.hooks.some(hook =>
+            hook.command && hook.command.includes(needle)
+          ));
 
-        if (hasCommandHook && hasChangesHook) {
+        const hasCommandHook = hasHookCommand(preToolUse, 'deliberate-commands');
+        const hasChangesHook = hasHookCommand(postToolUse, 'deliberate-changes');
+        const hasCommandPostHook = hasHookCommand(postToolUse, 'deliberate-commands-post');
+
+        if (hasCommandHook && hasChangesHook && hasCommandPostHook) {
           console.log('Hooks:      ✅ Installed (PreToolUse + PostToolUse)');
           hooksInstalled = true;
-        } else if (hasCommandHook) {
-          console.log('Hooks:      ⚠️  Partial (PreToolUse only)');
-          hooksInstalled = true;
-        } else if (hasChangesHook) {
-          console.log('Hooks:      ⚠️  Partial (PostToolUse only)');
+        } else if (hasCommandHook || hasChangesHook || hasCommandPostHook) {
+          console.log('Hooks:      ⚠️  Partial (missing some hooks)');
           hooksInstalled = true;
         } else {
           console.log('Hooks:      ❌ Not installed');
@@ -86,6 +85,41 @@ program
       console.log('Hooks:      ❌ Claude settings not found');
     }
 
+    // Check OpenCode plugin installation
+    const openCodeConfigDir = join(homedir(), '.config', 'opencode');
+    const openCodeConfigPaths = [join(openCodeConfigDir, 'opencode.json'), join(openCodeConfigDir, 'opencode.jsonc')];
+    const openCodePluginPaths = [
+      join(openCodeConfigDir, 'plugins', 'deliberate.js'),
+      join(openCodeConfigDir, 'plugins', 'deliberate-changes.js')
+    ];
+
+    let openCodeInstalled = false;
+    const configPath = openCodeConfigPaths.find(path => existsSync(path));
+
+    if (configPath) {
+      try {
+        const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+        const plugins = Array.isArray(config.plugin) ? config.plugin.map(String) : [];
+        const commandPlugin = plugins.some(entry => entry.includes('deliberate.js'));
+        const changesPlugin = plugins.some(entry => entry.includes('deliberate-changes.js'));
+        const filesPresent = openCodePluginPaths.every(path => existsSync(path));
+
+        if (commandPlugin && changesPlugin && filesPresent) {
+          console.log('OpenCode:   ✅ Installed (commands + changes)');
+          openCodeInstalled = true;
+        } else if (commandPlugin || changesPlugin || filesPresent) {
+          console.log('OpenCode:   ⚠️  Partial install');
+          openCodeInstalled = true;
+        } else {
+          console.log('OpenCode:   ❌ Not installed');
+        }
+      } catch (e) {
+        console.log('OpenCode:   ❌ Error reading opencode.json');
+      }
+    } else {
+      console.log('OpenCode:   ❌ Config not found');
+    }
+
     // Check classifier status
     const classifierStatus = getStatus();
 
@@ -103,8 +137,8 @@ program
 
     // Overall status
     console.log('');
-    if (hooksInstalled) {
-      console.log('Status: Ready to protect your Claude Code sessions');
+    if (hooksInstalled || openCodeInstalled) {
+      console.log('Status: Ready to protect your agent sessions');
     } else {
       console.log('Status: Run "deliberate install" to set up hooks');
     }

package/hooks/deliberate-commands.py

@@ -27,6 +27,7 @@ from pathlib import Path
 
 # Configuration
 CLASSIFIER_URL = "http://localhost:8765/classify/command"
+LLM_MODE = os.environ.get("DELIBERATE_LLM_MODE")
 
 # Support both plugin mode (CLAUDE_PLUGIN_ROOT) and npm install mode (~/.deliberate/)
 # Plugin mode: config in plugin directory
@@ -1057,6 +1058,9 @@ def get_token_from_keychain():
 
 def load_llm_config() -> dict | None:
     """Load LLM configuration from config file or keychain."""
+    if LLM_MODE == "manual":
+        return None
+
     llm = _load_config().get("llm", {})
     provider = llm.get("provider")
     if not provider:

package/opencode/deliberate-changes-plugin.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const PYTHON_CMD = process.platform === "win32" ? "python" : "python3";
+const HOME_DIR = os.homedir();
+const HOOK_SCRIPT_LOCAL = path.join(__dirname, "..", "hooks", "deliberate-changes.py");
+const HOOK_SCRIPT_GLOBAL = path.join(HOME_DIR, ".claude", "hooks", "deliberate-changes.py");
+const HOOK_SCRIPT = fs.existsSync(HOOK_SCRIPT_LOCAL) ? HOOK_SCRIPT_LOCAL : HOOK_SCRIPT_GLOBAL;
+const TIMEOUT_MS = 30000;
+
+function stripAnsi(input) {
+  return input.replace(/\u001b\[[0-9;]*m/g, "");
+}
+
+async function runChangeHook({ toolName, toolInput, sessionID }) {
+  if (!fs.existsSync(HOOK_SCRIPT)) {
+    return null;
+  }
+
+  const payload = {
+    tool_name: toolName,
+    tool_input: toolInput,
+    session_id: sessionID
+  };
+
+  return new Promise((resolve) => {
+    const child = spawn(PYTHON_CMD, [HOOK_SCRIPT], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env
+      }
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let finished = false;
+
+    const timer = setTimeout(() => {
+      if (!finished) {
+        finished = true;
+        child.kill("SIGKILL");
+        resolve({ code: 124, stdout: "", stderr: "Deliberate hook timed out" });
+      }
+    }, TIMEOUT_MS);
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    child.on("close", (code) => {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      resolve({ code: code ?? 0, stdout, stderr });
+    });
+
+    child.stdin.write(`${JSON.stringify(payload)}\n`);
+    child.stdin.end();
+  });
+}
+
+function parseHookOutput(stdout) {
+  if (!stdout) return null;
+
+  try {
+    const parsed = JSON.parse(stdout.trim());
+    const hookOutput = parsed?.hookSpecificOutput || {};
+    const context = hookOutput.additionalContext || "";
+    const systemMessage = parsed?.systemMessage || "";
+
+    return {
+      context: stripAnsi(context).trim(),
+      message: stripAnsi(systemMessage).trim()
+    };
+  } catch (err) {
+    return null;
+  }
+}
+
+export const DeliberateOpenCodeChangesPlugin = async ({ client }) => {
+  if (!client) {
+    throw new Error("Deliberate OpenCode plugin requires SDK client access");
+  }
+
+  return {
+    "tool.execute.after": async (input, output) => {
+      const tool = input.tool;
+      if (!tool || !["write", "edit", "multiedit", "patch"].includes(tool)) return;
+      if (!output) return;
+
+      const toolArgs = output?.metadata?.args || output?.args || {};
+      const filePath = toolArgs.filePath || toolArgs.file_path || output?.metadata?.filepath || output?.metadata?.filePath;
+
+      if (!filePath) return;
+
+      const edits = Array.isArray(toolArgs.edits)
+        ? toolArgs.edits.map((edit) => ({
+          old_string: edit.oldString || edit.old_string || "",
+          new_string: edit.newString || edit.new_string || ""
+        }))
+        : undefined;
+
+      const hookToolName = tool === "multiedit" ? "MultiEdit" : tool === "write" ? "Write" : "Edit";
+
+      const toolInput = {
+        file_path: filePath,
+        content: toolArgs.content || "",
+        old_string: toolArgs.oldString || toolArgs.old_string || "",
+        new_string: toolArgs.newString || toolArgs.new_string || "",
+        edits
+      };
+
+      if (hookToolName === "Edit" && output?.metadata?.filediff?.before && output?.metadata?.filediff?.after) {
+        toolInput.old_string = output.metadata.filediff.before;
+        toolInput.new_string = output.metadata.filediff.after;
+      }
+
+      if (hookToolName === "Edit" && !toolInput.old_string && output?.metadata?.diff) {
+        const diff = output.metadata.diff;
+        const lines = diff.split("\n");
+        let oldBlock = [];
+        let newBlock = [];
+        for (const line of lines) {
+          if (line.startsWith("---") || line.startsWith("+++")) continue;
+          if (line.startsWith("-")) {
+            oldBlock.push(line.slice(1));
+          } else if (line.startsWith("+")) {
+            newBlock.push(line.slice(1));
+          }
+        }
+        if (oldBlock.length) toolInput.old_string = oldBlock.join("\n");
+        if (newBlock.length) toolInput.new_string = newBlock.join("\n");
+      }
+
+      const result = await runChangeHook({
+        toolName: hookToolName,
+        toolInput,
+        sessionID: input.sessionID
+      });
+
+      if (!result) return;
+
+      const parsed = parseHookOutput(result.stdout);
+      const message = parsed?.message || parsed?.context;
+
+      if (message) {
+        await client.session.prompt({
+          path: { id: input.sessionID },
+          body: {
+            noReply: true,
+            parts: [{ type: "text", text: message }]
+          }
+        }).catch(() => {});
+      }
+    }
+  };
+};
+
+export default DeliberateOpenCodeChangesPlugin;

package/opencode/deliberate-plugin.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const PYTHON_CMD = process.platform === "win32" ? "python" : "python3";
+const HOME_DIR = os.homedir();
+const HOOK_SCRIPT_LOCAL = path.join(__dirname, "..", "hooks", "deliberate-commands.py");
+const HOOK_SCRIPT_GLOBAL = path.join(HOME_DIR, ".claude", "hooks", "deliberate-commands.py");
+const HOOK_SCRIPT = fs.existsSync(HOOK_SCRIPT_LOCAL) ? HOOK_SCRIPT_LOCAL : HOOK_SCRIPT_GLOBAL;
+const TIMEOUT_MS = 30000;
+const DANGEROUS_PREFIXES = [
+  "rm ",
+  "rm-",
+  "git ",
+  "sudo ",
+  "bash ",
+  "sh ",
+  "python ",
+  "python3 ",
+  "node ",
+  "perl ",
+  "ruby ",
+  "docker ",
+  "kubectl ",
+  "aws ",
+  "terraform ",
+  "gcloud ",
+  "az ",
+  "scp ",
+  "rsync ",
+  "dd ",
+  "mkfs ",
+  "chmod ",
+  "chown ",
+  "find ",
+  "xargs ",
+  "parallel ",
+  "base64 ",
+  "xxd "
+];
+
+function shouldAnalyze(command) {
+  const trimmed = command.trim();
+  if (!trimmed) return false;
+  if (trimmed.length < 4) return false;
+  const lower = trimmed.toLowerCase();
+  if (lower.includes("rm -rf") || lower.includes("git reset") || lower.includes("git clean")) {
+    return true;
+  }
+  return DANGEROUS_PREFIXES.some((prefix) => lower.startsWith(prefix));
+}
+
+function stripAnsi(input) {
+  return input.replace(/\u001b\[[0-9;]*m/g, "");
+}
+
+async function runCommandHook({ command, sessionID, cwd }) {
+  if (!fs.existsSync(HOOK_SCRIPT)) {
+    return null;
+  }
+
+  const payload = {
+    tool_name: "Bash",
+    tool_input: { command },
+    session_id: sessionID,
+    cwd: cwd || process.cwd()
+  };
+
+  return new Promise((resolve) => {
+    const child = spawn(PYTHON_CMD, [HOOK_SCRIPT], {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env
+      }
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let finished = false;
+
+    const timer = setTimeout(() => {
+      if (!finished) {
+        finished = true;
+        child.kill("SIGKILL");
+        resolve({ code: 124, stdout: "", stderr: "Deliberate hook timed out" });
+      }
+    }, TIMEOUT_MS);
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    child.on("close", (code) => {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      resolve({ code: code ?? 0, stdout, stderr });
+    });
+
+    child.stdin.write(`${JSON.stringify(payload)}\n`);
+    child.stdin.end();
+  });
+}
+
+function parseHookOutput(stdout) {
+  if (!stdout) return null;
+
+  try {
+    const parsed = JSON.parse(stdout.trim());
+    const hookOutput = parsed?.hookSpecificOutput || {};
+    const reason = hookOutput.permissionDecisionReason || "";
+    const context = hookOutput.additionalContext || "";
+
+    return {
+      reason: stripAnsi(reason).trim(),
+      context: stripAnsi(context).trim()
+    };
+  } catch (err) {
+    return null;
+  }
+}
+
+export const DeliberateOpenCodePlugin = async ({ client, directory }) => {
+  if (!client) {
+    throw new Error("Deliberate OpenCode plugin requires SDK client access");
+  }
+
+  return {
+    "tool.execute.before": async (input, output) => {
+      if (input.tool !== "bash") return;
+
+      const command = output?.args?.command;
+      if (!command) return;
+
+      if (!shouldAnalyze(command)) {
+        return;
+      }
+
+      const cwd = output?.args?.workdir || directory;
+      const result = await runCommandHook({ command, sessionID: input.sessionID, cwd });
+      if (!result) return;
+
+      const parsed = parseHookOutput(result.stdout);
+      const message = parsed?.context || parsed?.reason || "";
+
+      if (message) {
+        await client.session.prompt({
+          path: { id: input.sessionID },
+          body: {
+            noReply: true,
+            parts: [{ type: "text", text: message }]
+          }
+        }).catch(() => {});
+      }
+
+      if (result.code === 2 || (result.stderr && result.stderr.includes("BLOCKED by Deliberate"))) {
+        const blockedMessage = stripAnsi(result.stderr || message || "Blocked by Deliberate");
+        throw new Error(blockedMessage.trim() || "Blocked by Deliberate");
+      }
+    }
+  };
+};
+
+export default DeliberateOpenCodePlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deliberate",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Safety layer for agentic coding tools - classifies shell commands before execution",
   "type": "module",
   "bin": {
@@ -12,6 +12,7 @@
     "bin/",
     "src/",
     "hooks/",
+    "opencode/",
     "training/build_classifier.py",
     "training/expanded-command-safety.jsonl",
     "models/classifier_base.pkl",

package/src/install.js

@@ -3,6 +3,7 @@
  * Handles:
  * - Symlinking hooks to ~/.claude/hooks/
  * - Updating ~/.claude/settings.json
+ * - Installing OpenCode plugin (if available)
  * - Configuring Deliberate LLM provider
  * - Optionally starting the classifier server
  */
@@ -23,6 +24,8 @@ const IS_WINDOWS = process.platform === 'win32';
 const CLAUDE_DIR = path.join(HOME_DIR, '.claude');
 const HOOKS_DIR = path.join(CLAUDE_DIR, 'hooks');
 const SETTINGS_FILE = path.join(CLAUDE_DIR, 'settings.json');
+const OPENCODE_DIR = path.join(HOME_DIR, '.config', 'opencode');
+const OPENCODE_PLUGIN_DIR = path.join(OPENCODE_DIR, 'plugins');
 
 // Python command (python on Windows, python3 on Unix)
 const PYTHON_CMD = IS_WINDOWS ? 'python' : 'python3';
@@ -31,6 +34,8 @@ const PIP_CMD = IS_WINDOWS ? 'pip' : 'pip3';
 // Required Python packages
 const PYTHON_DEPS = ['sentence-transformers', 'scikit-learn', 'numpy', 'claude-agent-sdk'];
 
+const OPENCODE_CONFIG_FILES = ['opencode.json', 'opencode.jsonc'];
+
 // Model download configuration
 const MODELS_URL = 'https://github.com/the-radar/deliberate/releases/download/v1.0.0/deliberate-models.tar.gz';
 const MODELS_DIR = path.join(__dirname, '..', 'models');
@@ -184,6 +189,118 @@ function installHooks() {
   return installed;
 }
 
+function loadOpenCodeConfig() {
+  for (const filename of OPENCODE_CONFIG_FILES) {
+    const candidate = path.join(OPENCODE_DIR, filename);
+    if (fs.existsSync(candidate)) {
+      try {
+        const content = fs.readFileSync(candidate, 'utf-8');
+        return { path: candidate, config: JSON.parse(content) };
+      } catch (error) {
+        return { path: candidate, config: null, error: error.message };
+      }
+    }
+  }
+
+  return { path: path.join(OPENCODE_DIR, OPENCODE_CONFIG_FILES[0]), config: null };
+}
+
+function saveOpenCodeConfig(configPath, config) {
+  ensureDir(OPENCODE_DIR);
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+
+function ensureOpenCodePluginReference() {
+  const pluginPaths = [
+    path.join(OPENCODE_PLUGIN_DIR, 'deliberate.js'),
+    path.join(OPENCODE_PLUGIN_DIR, 'deliberate-changes.js')
+  ];
+  const targets = pluginPaths.map((pluginPath) => {
+    const normalized = pluginPath.split(path.sep).join('/');
+    return normalized.startsWith('/') ? `file://${normalized}` : `file:///${normalized}`;
+  });
+  const { path: configPath, config, error } = loadOpenCodeConfig();
+
+  if (error) {
+    console.warn(`Warning: Could not parse ${configPath}: ${error}`);
+    return { updated: false, configPath };
+  }
+
+  const nextConfig = config || { $schema: 'https://opencode.ai/config.json' };
+  const plugins = Array.isArray(nextConfig.plugin) ? nextConfig.plugin : [];
+  let updated = false;
+
+  for (const target of targets) {
+    if (!plugins.includes(target)) {
+      plugins.push(target);
+      updated = true;
+    }
+  }
+
+  if (updated) {
+    nextConfig.plugin = plugins;
+    saveOpenCodeConfig(configPath, nextConfig);
+  }
+
+  return { updated, configPath };
+}
+
+/**
+ * Install OpenCode plugin to ~/.config/opencode/plugins
+ * Uses symlink on Unix, copy on Windows
+ * @returns {string|null} Installed plugin path or null
+ */
+function installOpenCodePlugin() {
+  const pluginSource = path.join(__dirname, '..', 'opencode');
+
+  const primaryPluginSource = path.join(pluginSource, 'deliberate-plugin.js');
+  const changesPluginSource = path.join(pluginSource, 'deliberate-changes-plugin.js');
+
+  if (!fs.existsSync(primaryPluginSource) || !fs.existsSync(changesPluginSource)) {
+    console.warn('Warning: OpenCode plugin source not found, skipping');
+    return null;
+  }
+
+  ensureDir(OPENCODE_PLUGIN_DIR);
+
+  const primaryDest = path.join(OPENCODE_PLUGIN_DIR, 'deliberate.js');
+  const changesDest = path.join(OPENCODE_PLUGIN_DIR, 'deliberate-changes.js');
+
+  for (const dest of [primaryDest, changesDest]) {
+    try {
+      const stat = fs.lstatSync(dest);
+      if (stat.isFile() || stat.isSymbolicLink()) {
+        fs.unlinkSync(dest);
+      }
+    } catch (err) {
+      // File doesn't exist, that's fine
+    }
+  }
+
+  if (IS_WINDOWS) {
+    fs.copyFileSync(primaryPluginSource, primaryDest);
+    fs.copyFileSync(changesPluginSource, changesDest);
+    console.log(`Installed OpenCode plugin: ${primaryDest} (copied)`);
+    console.log(`Installed OpenCode plugin: ${changesDest} (copied)`);
+  } else {
+    fs.symlinkSync(primaryPluginSource, primaryDest);
+    fs.symlinkSync(changesPluginSource, changesDest);
+    fs.chmodSync(primaryPluginSource, 0o755);
+    fs.chmodSync(changesPluginSource, 0o755);
+    console.log(`Installed OpenCode plugin: ${primaryDest} -> ${primaryPluginSource}`);
+    console.log(`Installed OpenCode plugin: ${changesDest} -> ${changesPluginSource}`);
+  }
+
+  const configResult = ensureOpenCodePluginReference();
+  if (configResult.updated) {
+    console.log(`Updated OpenCode config: ${configResult.configPath}`);
+  } else {
+    console.log(`OpenCode config already references plugin: ${configResult.configPath}`);
+  }
+
+  return primaryDest;
+}
+
 /**
  * Update ~/.claude/settings.json with hook configuration
  * Preserves existing settings and hooks
@@ -715,6 +832,16 @@ export async function install() {
   console.log('Updating Claude Code settings...');
   updateSettings();
 
+  // Install OpenCode plugin
+  console.log('');
+  console.log('Installing OpenCode plugin...');
+  const opencodePlugin = installOpenCodePlugin();
+  if (!opencodePlugin) {
+    console.log('OpenCode plugin: ⚠️  Not installed');
+  } else {
+    console.log('OpenCode plugin: ✅ Installed (commands + changes)');
+  }
+
   // Configure LLM if not already configured
   if (!isLLMConfigured()) {
     await configureLLM();
@@ -734,14 +861,19 @@ export async function install() {
   for (const hookPath of installed) {
     console.log(`  - ${hookPath}`);
   }
+  if (opencodePlugin) {
+    console.log(`  - ${opencodePlugin} (OpenCode plugin: commands)`);
+    console.log(`  - ${path.join(OPENCODE_PLUGIN_DIR, 'deliberate-changes.js')} (OpenCode plugin: changes)`);
+  }
   console.log('');
   console.log('Next steps:');
   console.log('  1. Restart Claude Code to load the new hooks');
+  console.log('  2. Restart OpenCode to load the new plugin');
   console.log('');
-  console.log('  2. (Optional) Start the classifier server for faster ML detection:');
+  console.log('  3. (Optional) Start the classifier server for faster ML detection:');
   console.log('     deliberate serve');
   console.log('');
-  console.log('  3. Test classification:');
+  console.log('  4. Test classification:');
   console.log('     deliberate classify "rm -rf /"');
   console.log('');
 }

package/src/uninstall.js

@@ -15,11 +15,15 @@ const CLAUDE_DIR = path.join(HOME_DIR, '.claude');
 const HOOKS_DIR = path.join(CLAUDE_DIR, 'hooks');
 const SETTINGS_FILE = path.join(CLAUDE_DIR, 'settings.json');
 const CONFIG_FILE = path.join(HOME_DIR, '.deliberate', 'config.json');
+const OPENCODE_DIR = path.join(HOME_DIR, '.config', 'opencode');
+const OPENCODE_PLUGIN_DIR = path.join(OPENCODE_DIR, 'plugins');
+const OPENCODE_CONFIG_FILES = ['opencode.json', 'opencode.jsonc'];
 
 // Hook files to remove
 const HOOKS_TO_REMOVE = [
-  'deliberate-explain-command.py',
-  'deliberate-explain-changes.py'
+  'deliberate-commands.py',
+  'deliberate-commands-post.py',
+  'deliberate-changes.py'
 ];
 
 /**
@@ -45,6 +49,53 @@ function removeHooks() {
   return removed;
 }
 
+/**
+ * Remove OpenCode plugin from config and plugins dir
+ */
+function removeOpenCodePlugin() {
+  let removed = false;
+
+  const pluginPaths = [
+    path.join(OPENCODE_PLUGIN_DIR, 'deliberate.js'),
+    path.join(OPENCODE_PLUGIN_DIR, 'deliberate-changes.js')
+  ];
+
+  for (const pluginPath of pluginPaths) {
+    if (fs.existsSync(pluginPath)) {
+      fs.unlinkSync(pluginPath);
+      console.log(`  Removed OpenCode plugin: ${pluginPath}`);
+      removed = true;
+    }
+  }
+
+  for (const filename of OPENCODE_CONFIG_FILES) {
+    const configPath = path.join(OPENCODE_DIR, filename);
+    if (!fs.existsSync(configPath)) continue;
+
+    try {
+      const content = fs.readFileSync(configPath, 'utf-8');
+      const config = JSON.parse(content);
+      if (Array.isArray(config.plugin)) {
+        const nextPlugins = config.plugin.filter((entry) => !String(entry).includes('deliberate'));
+        if (nextPlugins.length !== config.plugin.length) {
+          config.plugin = nextPlugins;
+          fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+          console.log(`  Updated OpenCode config: ${configPath}`);
+          removed = true;
+        }
+      }
+    } catch (error) {
+      console.warn(`  Warning: Could not parse ${configPath}: ${error.message}`);
+    }
+  }
+
+  if (!removed) {
+    console.log('  No OpenCode plugin config found');
+  }
+
+  return removed;
+}
+
 /**
  * Remove Deliberate hooks from ~/.claude/settings.json
  */
@@ -71,8 +122,8 @@ function removeFromSettings() {
 
           const filteredHooks = matcher.hooks.filter(hook => {
             const isDeliberate = hook.command && (
-              hook.command.includes('deliberate-explain-command') ||
-              hook.command.includes('deliberate-explain-changes')
+              hook.command.includes('deliberate-commands') ||
+              hook.command.includes('deliberate-changes')
             );
             if (isDeliberate) modified = true;
             return !isDeliberate;
@@ -91,8 +142,8 @@ function removeFromSettings() {
 
           const filteredHooks = matcher.hooks.filter(hook => {
             const isDeliberate = hook.command && (
-              hook.command.includes('deliberate-explain-command') ||
-              hook.command.includes('deliberate-explain-changes')
+              hook.command.includes('deliberate-commands') ||
+              hook.command.includes('deliberate-changes')
             );
             if (isDeliberate) modified = true;
             return !isDeliberate;
@@ -153,6 +204,10 @@ export async function uninstall() {
   console.log('');
   removeFromSettings();
 
+  // Remove OpenCode plugin
+  console.log('');
+  removeOpenCodePlugin();
+
   // Ask about config
   console.log('');
   if (fs.existsSync(CONFIG_FILE)) {
@@ -186,7 +241,7 @@ export async function uninstall() {
   console.log('===========================================');
   console.log('');
   console.log('Next step:');
-  console.log('  Restart Claude Code to unload the hooks');
+  console.log('  Restart Claude Code and OpenCode to unload hooks/plugins');
   console.log('');
 }