@nforma.ai/nforma 0.2.1

package/bin/install.js

@@ -0,0 +1,2424 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+const crypto = require('crypto');
+
+// Colors
+const cyan = '\x1b[36m';
+const salmon = '\x1b[38;5;209m';
+const green = '\x1b[32m';
+const yellow = '\x1b[33m';
+const dim = '\x1b[2m';
+const reset = '\x1b[0m';
+
+// Get version from package.json
+const pkg = require('../package.json');
+
+// Parse args
+const args = process.argv.slice(2);
+const hasGlobal = args.includes('--global') || args.includes('-g');
+const hasLocal = args.includes('--local') || args.includes('-l');
+const hasOpencode = args.includes('--opencode');
+const hasClaude = args.includes('--claude');
+const hasGemini = args.includes('--gemini');
+const hasBoth = args.includes('--both'); // Legacy flag, keeps working
+const hasAll = args.includes('--all');
+const hasUninstall = args.includes('--uninstall') || args.includes('-u');
+const hasRedetectMcps = args.includes('--redetect-mcps');
+const hasResetBreaker = args.includes('--reset-breaker');
+const hasDisableBreaker = args.includes('--disable-breaker');
+const hasEnableBreaker = args.includes('--enable-breaker');
+const hasMigrateSlots = args.includes('--migrate-slots');
+const hasFormal = args.includes('--formal');
+
+// Runtime selection - can be set by flags or interactive prompt
+let selectedRuntimes = [];
+if (hasAll) {
+  selectedRuntimes = ['claude', 'opencode', 'gemini'];
+} else if (hasBoth) {
+  selectedRuntimes = ['claude', 'opencode'];
+} else {
+  if (hasOpencode) selectedRuntimes.push('opencode');
+  if (hasClaude) selectedRuntimes.push('claude');
+  if (hasGemini) selectedRuntimes.push('gemini');
+}
+
+// Helper to get directory name for a runtime (used for local/project installs)
+function getDirName(runtime) {
+  if (runtime === 'opencode') return '.opencode';
+  if (runtime === 'gemini') return '.gemini';
+  return '.claude';
+}
+
+/**
+ * Get the config directory path relative to home directory for a runtime
+ * Used for templating hooks that use path.join(homeDir, '<configDir>', ...)
+ * @param {string} runtime - 'claude', 'opencode', or 'gemini'
+ * @param {boolean} isGlobal - Whether this is a global install
+ */
+function getConfigDirFromHome(runtime, isGlobal) {
+  if (!isGlobal) {
+    // Local installs use the same dir name pattern
+    return `'${getDirName(runtime)}'`;
+  }
+  // Global installs - OpenCode uses XDG path structure
+  if (runtime === 'opencode') {
+    // OpenCode: ~/.config/opencode -> '.config', 'opencode'
+    // Return as comma-separated for path.join() replacement
+    return "'.config', 'opencode'";
+  }
+  if (runtime === 'gemini') return "'.gemini'";
+  return "'.claude'";
+}
+
+/**
+ * Get the global config directory for OpenCode
+ * OpenCode follows XDG Base Directory spec and uses ~/.config/opencode/
+ * Priority: OPENCODE_CONFIG_DIR > dirname(OPENCODE_CONFIG) > XDG_CONFIG_HOME/opencode > ~/.config/opencode
+ */
+function getOpencodeGlobalDir() {
+  // 1. Explicit OPENCODE_CONFIG_DIR env var
+  if (process.env.OPENCODE_CONFIG_DIR) {
+    return expandTilde(process.env.OPENCODE_CONFIG_DIR);
+  }
+  
+  // 2. OPENCODE_CONFIG env var (use its directory)
+  if (process.env.OPENCODE_CONFIG) {
+    return path.dirname(expandTilde(process.env.OPENCODE_CONFIG));
+  }
+  
+  // 3. XDG_CONFIG_HOME/opencode
+  if (process.env.XDG_CONFIG_HOME) {
+    return path.join(expandTilde(process.env.XDG_CONFIG_HOME), 'opencode');
+  }
+  
+  // 4. Default: ~/.config/opencode (XDG default)
+  return path.join(os.homedir(), '.config', 'opencode');
+}
+
+/**
+ * Get the global config directory for a runtime
+ * @param {string} runtime - 'claude', 'opencode', or 'gemini'
+ * @param {string|null} explicitDir - Explicit directory from --config-dir flag
+ */
+function getGlobalDir(runtime, explicitDir = null) {
+  if (runtime === 'opencode') {
+    // For OpenCode, --config-dir overrides env vars
+    if (explicitDir) {
+      return expandTilde(explicitDir);
+    }
+    return getOpencodeGlobalDir();
+  }
+  
+  if (runtime === 'gemini') {
+    // Gemini: --config-dir > GEMINI_CONFIG_DIR > ~/.gemini
+    if (explicitDir) {
+      return expandTilde(explicitDir);
+    }
+    if (process.env.GEMINI_CONFIG_DIR) {
+      return expandTilde(process.env.GEMINI_CONFIG_DIR);
+    }
+    return path.join(os.homedir(), '.gemini');
+  }
+  
+  // Claude Code: --config-dir > CLAUDE_CONFIG_DIR > ~/.claude
+  if (explicitDir) {
+    return expandTilde(explicitDir);
+  }
+  if (process.env.CLAUDE_CONFIG_DIR) {
+    return expandTilde(process.env.CLAUDE_CONFIG_DIR);
+  }
+  return path.join(os.homedir(), '.claude');
+}
+
+const banner = '\n' +
+  salmon + ' ███╗   ██╗' + cyan + '███████╗ ██████╗ ██████╗ ███╗   ███╗ █████╗\n' +
+  salmon + ' ████╗  ██║' + cyan + '██╔════╝██╔═══██╗██╔══██╗████╗ ████║██╔══██╗\n' +
+  salmon + ' ██╔██╗ ██║' + cyan + '█████╗  ██║   ██║██████╔╝██╔████╔██║███████║\n' +
+  salmon + ' ██║╚██╗██║' + cyan + '██╔══╝  ██║   ██║██╔══██╗██║╚██╔╝██║██╔══██║\n' +
+  salmon + ' ██║ ╚████║' + cyan + '██║     ╚██████╔╝██║  ██║██║ ╚═╝ ██║██║  ██║\n' +
+  salmon + ' ╚═╝  ╚═══╝' + cyan + '╚═╝      ╚═════╝ ╚═╝  ╚═╝╚═╝     ╚═╝╚═╝  ╚═╝' + reset + '\n' +
+  '\n' +
+  '  nForma — Quorum Gets Shit Done ' + dim + 'v' + pkg.version + reset + '\n' +
+  '  Built on GSD-CC by TÂCHES.\n' +
+  '  Full automation through quorum of coding agents. By Jonathan Borduas.\n' +
+  '\n' +
+  cyan + '  The task of leadership is to create an alignment of strengths\n' +
+  '   so strong that it makes the system\u2019s weaknesses irrelevant.\n' +
+  dim + '  \u2014 Peter Drucker' + reset + '\n';
+
+// nForma: MCP auto-detection — keyword map for quorum model server matching
+const QGSD_KEYWORD_MAP = {
+  codex:    { keywords: ['codex'],    defaultPrefix: 'mcp__codex-cli-1__'  },
+  gemini:   { keywords: ['gemini'],   defaultPrefix: 'mcp__gemini-cli-1__' },
+  opencode: { keywords: ['opencode'], defaultPrefix: 'mcp__opencode-1__'   },
+  copilot:  { keywords: ['copilot'],  defaultPrefix: 'mcp__copilot-1__'    },
+};
+
+// Reads ~/.claude.json to find MCP server names, keyword-matches to identify quorum candidates,
+// and returns a required_models object with derived tool prefixes.
+// Falls back to hardcoded defaults if ~/.claude.json is missing, malformed, or has no matching servers.
+function buildRequiredModelsFromMcp() {
+  const claudeJsonPath = path.join(os.homedir(), '.claude.json');
+  let mcpServers = {};
+
+  try {
+    if (fs.existsSync(claudeJsonPath)) {
+      const d = JSON.parse(fs.readFileSync(claudeJsonPath, 'utf8'));
+      mcpServers = d.mcpServers || {};
+    }
+  } catch (e) {
+    console.warn(`  ${yellow}⚠${reset} Could not read ~/.claude.json: ${e.message}`);
+  }
+
+  const requiredModels = {};
+  let anyDetected = false;
+
+  for (const [modelKey, { keywords, defaultPrefix }] of Object.entries(QGSD_KEYWORD_MAP)) {
+    const matched = Object.keys(mcpServers).find(serverName =>
+      keywords.some(kw => serverName.toLowerCase().includes(kw))
+    );
+    if (matched) {
+      requiredModels[modelKey] = { tool_prefix: `mcp__${matched}__`, required: true };
+      anyDetected = true;
+      console.log(`  ${green}✓${reset} Detected ${modelKey} MCP server: ${matched} → prefix: mcp__${matched}__`);
+    } else {
+      requiredModels[modelKey] = { tool_prefix: defaultPrefix, required: true };
+      console.warn(`  ${yellow}⚠${reset} No ${modelKey} MCP server found in ~/.claude.json; using default prefix: ${defaultPrefix}`);
+    }
+  }
+
+  if (!anyDetected) {
+    console.warn(`  ${yellow}⚠${reset} No quorum MCP servers detected — using hardcoded defaults. Edit ~/.claude/qgsd.json to configure.`);
+  }
+
+  return requiredModels;
+}
+
+// Returns all mcpServer slot names from ~/.claude.json as the default quorum composition.
+// Used for COMP-04: fresh install writes quorum_active; reinstall backfills if absent/empty.
+function buildActiveSlots() {
+  const claudeJsonPath = path.join(os.homedir(), '.claude.json');
+  try {
+    if (fs.existsSync(claudeJsonPath)) {
+      const d = JSON.parse(fs.readFileSync(claudeJsonPath, 'utf8'));
+      return Object.keys(d.mcpServers || {});
+    }
+  } catch (e) {
+    console.warn(`  ${yellow}⚠${reset} Could not read ~/.claude.json for quorum_active: ${e.message}`);
+  }
+  return [];
+}
+
+// Generates quorum_instructions text from detected required_models.
+// Uses detected tool_prefix values so behavioral instructions (UserPromptSubmit injection)
+// name the same tools as the structural enforcement (Stop hook), preventing mismatch
+// when server names differ from defaults (e.g. renamed MCP servers).
+function buildQuorumInstructions(requiredModels) {
+  function toolName(key, prefix) {
+    if (key === 'codex')    return prefix + 'review';
+    if (key === 'gemini')   return prefix + 'gemini';
+    if (key === 'opencode') return prefix + 'opencode';
+    return prefix + key;
+  }
+  const required = Object.entries(requiredModels).filter(([, def]) => def.required);
+  const steps = required.map(([key, def], i) =>
+    `  ${i + 1}. Call ${toolName(key, def.tool_prefix)} with the full plan content`
+  ).join('\n');
+  return (
+    'QUORUM REQUIRED (structural enforcement — Stop hook will verify)\n\n' +
+    'Before presenting any planning output to the user, you MUST:\n' +
+    steps + '\n' +
+    `  ${required.length + 1}. Present all model responses, resolve any concerns, then deliver your final output\n` +
+    `  ${required.length + 2}. Include the token <!-- GSD_DECISION --> somewhere in your FINAL output (not in intermediate messages or status updates — only when you are delivering the completed plan, research, verification report, or filtered question list to the user)\n\n` +
+    'Fail-open: if a model is UNAVAILABLE (quota/error), note it and proceed with available models.\n' +
+    'The Stop hook reads the transcript — skipping quorum will block your response.'
+  );
+}
+
+// INST-05: Validate MCP availability and warn (yellow) per missing model.
+// Runs on every install/reinstall — not just first-time.
+// Does NOT abort installation (fail-open philosophy).
+function warnMissingMcpServers() {
+  const claudeJsonPath = path.join(os.homedir(), '.claude.json');
+  let mcpServers = {};
+  try {
+    if (fs.existsSync(claudeJsonPath)) {
+      const d = JSON.parse(fs.readFileSync(claudeJsonPath, 'utf8'));
+      mcpServers = d.mcpServers || {};
+    }
+  } catch (e) {
+    // If we can't read, skip silently — detection already warned in buildRequiredModelsFromMcp
+    return;
+  }
+
+  for (const [modelKey, { keywords }] of Object.entries(QGSD_KEYWORD_MAP)) {
+    const found = Object.keys(mcpServers).some(serverName =>
+      keywords.some(kw => serverName.toLowerCase().includes(kw))
+    );
+    if (!found) {
+      console.warn(
+        `  ${yellow}⚠${reset} No ${modelKey} MCP server found in ~/.claude.json — ` +
+        `quorum enforcement for ${modelKey} will be inactive until configured`
+      );
+    }
+  }
+}
+
+// INST-01: Detects whether any claude-mcp-server quorum agents are configured.
+// Used in finishInstall() to nudge new users to run /qgsd:mcp-setup.
+// Fail-open: returns false on read errors (never blocks install).
+function hasClaudeMcpAgents() {
+  const claudeJsonPath = path.join(os.homedir(), '.claude.json');
+  try {
+    if (!fs.existsSync(claudeJsonPath)) return false;
+    const d = JSON.parse(fs.readFileSync(claudeJsonPath, 'utf8'));
+    const mcpServers = d.mcpServers || {};
+    return Object.entries(mcpServers).some(([name, cfg]) => {
+      // Match slot pattern: claude-1 through claude-N
+      if (/^claude-\d+$/.test(name)) return true;
+      // Fallback: detect claude-mcp-server in args path (handles new installs before migration)
+      if ((cfg.args || []).some(a => String(a).includes('claude-mcp-server'))) return true;
+      return false;
+    });
+  } catch (e) {
+    return false;
+  }
+}
+
+// Parse --config-dir argument
+function parseConfigDirArg() {
+  const configDirIndex = args.findIndex(arg => arg === '--config-dir' || arg === '-c');
+  if (configDirIndex !== -1) {
+    const nextArg = args[configDirIndex + 1];
+    // Error if --config-dir is provided without a value or next arg is another flag
+    if (!nextArg || nextArg.startsWith('-')) {
+      console.error(`  ${yellow}--config-dir requires a path argument${reset}`);
+      process.exit(1);
+    }
+    return nextArg;
+  }
+  // Also handle --config-dir=value format
+  const configDirArg = args.find(arg => arg.startsWith('--config-dir=') || arg.startsWith('-c='));
+  if (configDirArg) {
+    const value = configDirArg.split('=')[1];
+    if (!value) {
+      console.error(`  ${yellow}--config-dir requires a non-empty path${reset}`);
+      process.exit(1);
+    }
+    return value;
+  }
+  return null;
+}
+const explicitConfigDir = parseConfigDirArg();
+const hasHelp = args.includes('--help') || args.includes('-h');
+const forceStatusline = args.includes('--force-statusline');
+
+console.log(banner);
+
+// Show help if requested
+if (hasHelp) {
+  console.log(`  ${yellow}Usage:${reset} npx get-shit-done-cc [options]\n\n  ${yellow}Options:${reset}\n    ${cyan}-g, --global${reset}              Install globally (to config directory)\n    ${cyan}-l, --local${reset}               Install locally (to current directory)\n    ${cyan}--claude${reset}                  Install for Claude Code only\n    ${cyan}--opencode${reset}                Install for OpenCode only\n    ${cyan}--gemini${reset}                  Install for Gemini only\n    ${cyan}--all${reset}                     Install for all runtimes\n    ${cyan}-u, --uninstall${reset}           Uninstall GSD (remove all GSD files)\n    ${cyan}-c, --config-dir <path>${reset}   Specify custom config directory\n    ${cyan}-h, --help${reset}                Show this help message\n    ${cyan}--force-statusline${reset}        Replace existing statusline config\n    ${cyan}--formal${reset}                  Install formal verification tools (TLA+, Alloy, PRISM)\n\n  ${yellow}Examples:${reset}\n    ${dim}# Interactive install (prompts for runtime and location)${reset}\n    npx get-shit-done-cc\n\n    ${dim}# Install for Claude Code globally${reset}\n    npx get-shit-done-cc --claude --global\n\n    ${dim}# Install for Gemini globally${reset}\n    npx get-shit-done-cc --gemini --global\n\n    ${dim}# Install for all runtimes globally${reset}\n    npx get-shit-done-cc --all --global\n\n    ${dim}# Install to custom config directory${reset}\n    npx get-shit-done-cc --claude --global --config-dir ~/.claude-bc\n\n    ${dim}# Install to current project only${reset}\n    npx get-shit-done-cc --claude --local\n\n    ${dim}# Uninstall GSD from Claude Code globally${reset}\n    npx get-shit-done-cc --claude --global --uninstall\n\n  ${yellow}Notes:${reset}\n    The --config-dir option is useful when you have multiple configurations.\n    It takes priority over CLAUDE_CONFIG_DIR / GEMINI_CONFIG_DIR environment variables.\n`);
+  process.exit(0);
+}
+
+/**
+ * Expand ~ to home directory (shell doesn't expand in env vars passed to node)
+ */
+function expandTilde(filePath) {
+  if (filePath && filePath.startsWith('~/')) {
+    return path.join(os.homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+
+/**
+ * Build a hook command path using forward slashes for cross-platform compatibility.
+ * On Windows, $HOME is not expanded by cmd.exe/PowerShell, so we use the actual path.
+ */
+function buildHookCommand(configDir, hookName) {
+  // Use forward slashes for Node.js compatibility on all platforms
+  const hooksPath = configDir.replace(/\\/g, '/') + '/hooks/' + hookName;
+  return `node "${hooksPath}"`;
+}
+
+/**
+ * Read and parse settings.json, returning empty object if it doesn't exist
+ */
+function readSettings(settingsPath) {
+  if (fs.existsSync(settingsPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    } catch (e) {
+      return {};
+    }
+  }
+  return {};
+}
+
+/**
+ * Write settings.json with proper formatting
+ */
+function writeSettings(settingsPath, settings) {
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+}
+
+// Cache for attribution settings (populated once per runtime during install)
+const attributionCache = new Map();
+
+/**
+ * Get commit attribution setting for a runtime
+ * @param {string} runtime - 'claude', 'opencode', or 'gemini'
+ * @returns {null|undefined|string} null = remove, undefined = keep default, string = custom
+ */
+function getCommitAttribution(runtime) {
+  // Return cached value if available
+  if (attributionCache.has(runtime)) {
+    return attributionCache.get(runtime);
+  }
+
+  let result;
+
+  if (runtime === 'opencode') {
+    const config = readSettings(path.join(getGlobalDir('opencode', null), 'opencode.json'));
+    result = config.disable_ai_attribution === true ? null : undefined;
+  } else if (runtime === 'gemini') {
+    // Gemini: check gemini settings.json for attribution config
+    const settings = readSettings(path.join(getGlobalDir('gemini', explicitConfigDir), 'settings.json'));
+    if (!settings.attribution || settings.attribution.commit === undefined) {
+      result = undefined;
+    } else if (settings.attribution.commit === '') {
+      result = null;
+    } else {
+      result = settings.attribution.commit;
+    }
+  } else {
+    // Claude Code
+    const settings = readSettings(path.join(getGlobalDir('claude', explicitConfigDir), 'settings.json'));
+    if (!settings.attribution || settings.attribution.commit === undefined) {
+      result = undefined;
+    } else if (settings.attribution.commit === '') {
+      result = null;
+    } else {
+      result = settings.attribution.commit;
+    }
+  }
+
+  // Cache and return
+  attributionCache.set(runtime, result);
+  return result;
+}
+
+/**
+ * Process Co-Authored-By lines based on attribution setting
+ * @param {string} content - File content to process
+ * @param {null|undefined|string} attribution - null=remove, undefined=keep, string=replace
+ * @returns {string} Processed content
+ */
+function processAttribution(content, attribution) {
+  if (attribution === null) {
+    // Remove Co-Authored-By lines and the preceding blank line
+    return content.replace(/(\r?\n){2}Co-Authored-By:.*$/gim, '');
+  }
+  if (attribution === undefined) {
+    return content;
+  }
+  // Replace with custom attribution (escape $ to prevent backreference injection)
+  const safeAttribution = attribution.replace(/\$/g, '$$$$');
+  return content.replace(/Co-Authored-By:.*$/gim, `Co-Authored-By: ${safeAttribution}`);
+}
+
+/**
+ * Convert Claude Code frontmatter to opencode format
+ * - Converts 'allowed-tools:' array to 'permission:' object
+ * @param {string} content - Markdown file content with YAML frontmatter
+ * @returns {string} - Content with converted frontmatter
+ */
+// Color name to hex mapping for opencode compatibility
+const colorNameToHex = {
+  cyan: '#00FFFF',
+  red: '#FF0000',
+  green: '#00FF00',
+  blue: '#0000FF',
+  yellow: '#FFFF00',
+  magenta: '#FF00FF',
+  orange: '#FFA500',
+  purple: '#800080',
+  pink: '#FFC0CB',
+  white: '#FFFFFF',
+  black: '#000000',
+  gray: '#808080',
+  grey: '#808080',
+};
+
+// Tool name mapping from Claude Code to OpenCode
+// OpenCode uses lowercase tool names; special mappings for renamed tools
+const claudeToOpencodeTools = {
+  AskUserQuestion: 'question',
+  SlashCommand: 'skill',
+  TodoWrite: 'todowrite',
+  WebFetch: 'webfetch',
+  WebSearch: 'websearch',  // Plugin/MCP - keep for compatibility
+};
+
+// Tool name mapping from Claude Code to Gemini CLI
+// Gemini CLI uses snake_case built-in tool names
+const claudeToGeminiTools = {
+  Read: 'read_file',
+  Write: 'write_file',
+  Edit: 'replace',
+  Bash: 'run_shell_command',
+  Glob: 'glob',
+  Grep: 'search_file_content',
+  WebSearch: 'google_web_search',
+  WebFetch: 'web_fetch',
+  TodoWrite: 'write_todos',
+  AskUserQuestion: 'ask_user',
+};
+
+/**
+ * Convert a Claude Code tool name to OpenCode format
+ * - Applies special mappings (AskUserQuestion -> question, etc.)
+ * - Converts to lowercase (except MCP tools which keep their format)
+ */
+function convertToolName(claudeTool) {
+  // Check for special mapping first
+  if (claudeToOpencodeTools[claudeTool]) {
+    return claudeToOpencodeTools[claudeTool];
+  }
+  // MCP tools (mcp__*) keep their format
+  if (claudeTool.startsWith('mcp__')) {
+    return claudeTool;
+  }
+  // Default: convert to lowercase
+  return claudeTool.toLowerCase();
+}
+
+/**
+ * Convert a Claude Code tool name to Gemini CLI format
+ * - Applies Claude→Gemini mapping (Read→read_file, Bash→run_shell_command, etc.)
+ * - Filters out MCP tools (mcp__*) — they are auto-discovered at runtime in Gemini
+ * - Filters out Task — agents are auto-registered as tools in Gemini
+ * @returns {string|null} Gemini tool name, or null if tool should be excluded
+ */
+function convertGeminiToolName(claudeTool) {
+  // MCP tools: exclude — auto-discovered from mcpServers config at runtime
+  if (claudeTool.startsWith('mcp__')) {
+    return null;
+  }
+  // Task: exclude — agents are auto-registered as callable tools
+  if (claudeTool === 'Task') {
+    return null;
+  }
+  // Check for explicit mapping
+  if (claudeToGeminiTools[claudeTool]) {
+    return claudeToGeminiTools[claudeTool];
+  }
+  // Default: lowercase
+  return claudeTool.toLowerCase();
+}
+
+/**
+ * Strip HTML <sub> tags for Gemini CLI output
+ * Terminals don't support subscript — Gemini renders these as raw HTML.
+ * Converts <sub>text</sub> to italic *(text)* for readable terminal output.
+ */
+function stripSubTags(content) {
+  return content.replace(/<sub>(.*?)<\/sub>/g, '*($1)*');
+}
+
+/**
+ * Convert Claude Code agent frontmatter to Gemini CLI format
+ * Gemini agents use .md files with YAML frontmatter, same as Claude,
+ * but with different field names and formats:
+ * - tools: must be a YAML array (not comma-separated string)
+ * - tool names: must use Gemini built-in names (read_file, not Read)
+ * - color: must be removed (causes validation error)
+ * - mcp__* tools: must be excluded (auto-discovered at runtime)
+ */
+function convertClaudeToGeminiAgent(content) {
+  if (!content.startsWith('---')) return content;
+
+  const endIndex = content.indexOf('---', 3);
+  if (endIndex === -1) return content;
+
+  const frontmatter = content.substring(3, endIndex).trim();
+  const body = content.substring(endIndex + 3);
+
+  const lines = frontmatter.split('\n');
+  const newLines = [];
+  let inAllowedTools = false;
+  const tools = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Convert allowed-tools YAML array to tools list
+    if (trimmed.startsWith('allowed-tools:')) {
+      inAllowedTools = true;
+      continue;
+    }
+
+    // Handle inline tools: field (comma-separated string)
+    if (trimmed.startsWith('tools:')) {
+      const toolsValue = trimmed.substring(6).trim();
+      if (toolsValue) {
+        const parsed = toolsValue.split(',').map(t => t.trim()).filter(t => t);
+        for (const t of parsed) {
+          const mapped = convertGeminiToolName(t);
+          if (mapped) tools.push(mapped);
+        }
+      } else {
+        // tools: with no value means YAML array follows
+        inAllowedTools = true;
+      }
+      continue;
+    }
+
+    // Strip color field (not supported by Gemini CLI, causes validation error)
+    if (trimmed.startsWith('color:')) continue;
+
+    // Collect allowed-tools/tools array items
+    if (inAllowedTools) {
+      if (trimmed.startsWith('- ')) {
+        const mapped = convertGeminiToolName(trimmed.substring(2).trim());
+        if (mapped) tools.push(mapped);
+        continue;
+      } else if (trimmed && !trimmed.startsWith('-')) {
+        inAllowedTools = false;
+      }
+    }
+
+    if (!inAllowedTools) {
+      newLines.push(line);
+    }
+  }
+
+  // Add tools as YAML array (Gemini requires array format)
+  if (tools.length > 0) {
+    newLines.push('tools:');
+    for (const tool of tools) {
+      newLines.push(`  - ${tool}`);
+    }
+  }
+
+  const newFrontmatter = newLines.join('\n').trim();
+
+  // Escape ${VAR} patterns in agent body for Gemini CLI compatibility.
+  // Gemini's templateString() treats all ${word} patterns as template variables
+  // and throws "Template validation failed: Missing required input parameters"
+  // when they can't be resolved. GSD agents use ${PHASE}, ${PLAN}, etc. as
+  // shell variables in bash code blocks — convert to $VAR (no braces) which
+  // is equivalent bash and invisible to Gemini's /\$\{(\w+)\}/g regex.
+  const escapedBody = body.replace(/\$\{(\w+)\}/g, '$$$1');
+
+  return `---\n${newFrontmatter}\n---${stripSubTags(escapedBody)}`;
+}
+
+function convertClaudeToOpencodeFrontmatter(content) {
+  // Replace tool name references in content (applies to all files)
+  let convertedContent = content;
+  convertedContent = convertedContent.replace(/\bAskUserQuestion\b/g, 'question');
+  convertedContent = convertedContent.replace(/\bSlashCommand\b/g, 'skill');
+  convertedContent = convertedContent.replace(/\bTodoWrite\b/g, 'todowrite');
+  // Replace /qgsd:command with /qgsd-command for opencode (flat command structure)
+  convertedContent = convertedContent.replace(/\/qgsd:/g, '/qgsd-');
+  // Replace ~/.claude with ~/.config/opencode (OpenCode's correct config location)
+  convertedContent = convertedContent.replace(/~\/\.claude\b/g, '~/.config/opencode');
+  // Replace general-purpose subagent type with OpenCode's equivalent "general"
+  convertedContent = convertedContent.replace(/subagent_type="general-purpose"/g, 'subagent_type="general"');
+
+  // Check if content has frontmatter
+  if (!convertedContent.startsWith('---')) {
+    return convertedContent;
+  }
+
+  // Find the end of frontmatter
+  const endIndex = convertedContent.indexOf('---', 3);
+  if (endIndex === -1) {
+    return convertedContent;
+  }
+
+  const frontmatter = convertedContent.substring(3, endIndex).trim();
+  const body = convertedContent.substring(endIndex + 3);
+
+  // Parse frontmatter line by line (simple YAML parsing)
+  const lines = frontmatter.split('\n');
+  const newLines = [];
+  let inAllowedTools = false;
+  const allowedTools = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Detect start of allowed-tools array
+    if (trimmed.startsWith('allowed-tools:')) {
+      inAllowedTools = true;
+      continue;
+    }
+
+    // Detect inline tools: field (comma-separated string)
+    if (trimmed.startsWith('tools:')) {
+      const toolsValue = trimmed.substring(6).trim();
+      if (toolsValue) {
+        // Parse comma-separated tools
+        const tools = toolsValue.split(',').map(t => t.trim()).filter(t => t);
+        allowedTools.push(...tools);
+      }
+      continue;
+    }
+
+    // Remove name: field - opencode uses filename for command name
+    if (trimmed.startsWith('name:')) {
+      continue;
+    }
+
+    // Convert color names to hex for opencode
+    if (trimmed.startsWith('color:')) {
+      const colorValue = trimmed.substring(6).trim().toLowerCase();
+      const hexColor = colorNameToHex[colorValue];
+      if (hexColor) {
+        newLines.push(`color: "${hexColor}"`);
+      } else if (colorValue.startsWith('#')) {
+        // Validate hex color format (#RGB or #RRGGBB)
+        if (/^#[0-9a-f]{3}$|^#[0-9a-f]{6}$/i.test(colorValue)) {
+          // Already hex and valid, keep as is
+          newLines.push(line);
+        }
+        // Skip invalid hex colors
+      }
+      // Skip unknown color names
+      continue;
+    }
+
+    // Collect allowed-tools items
+    if (inAllowedTools) {
+      if (trimmed.startsWith('- ')) {
+        allowedTools.push(trimmed.substring(2).trim());
+        continue;
+      } else if (trimmed && !trimmed.startsWith('-')) {
+        // End of array, new field started
+        inAllowedTools = false;
+      }
+    }
+
+    // Keep other fields (including name: which opencode ignores)
+    if (!inAllowedTools) {
+      newLines.push(line);
+    }
+  }
+
+  // Add tools object if we had allowed-tools or tools
+  if (allowedTools.length > 0) {
+    newLines.push('tools:');
+    for (const tool of allowedTools) {
+      newLines.push(`  ${convertToolName(tool)}: true`);
+    }
+  }
+
+  // Rebuild frontmatter (body already has tool names converted)
+  const newFrontmatter = newLines.join('\n').trim();
+  return `---\n${newFrontmatter}\n---${body}`;
+}
+
+/**
+ * Convert Claude Code markdown command to Gemini TOML format
+ * @param {string} content - Markdown file content with YAML frontmatter
+ * @returns {string} - TOML content
+ */
+function convertClaudeToGeminiToml(content) {
+  // Check if content has frontmatter
+  if (!content.startsWith('---')) {
+    return `prompt = ${JSON.stringify(content)}\n`;
+  }
+
+  const endIndex = content.indexOf('---', 3);
+  if (endIndex === -1) {
+    return `prompt = ${JSON.stringify(content)}\n`;
+  }
+
+  const frontmatter = content.substring(3, endIndex).trim();
+  const body = content.substring(endIndex + 3).trim();
+  
+  // Extract description from frontmatter
+  let description = '';
+  const lines = frontmatter.split('\n');
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('description:')) {
+      description = trimmed.substring(12).trim();
+      break;
+    }
+  }
+
+  // Construct TOML
+  let toml = '';
+  if (description) {
+    toml += `description = ${JSON.stringify(description)}\n`;
+  }
+  
+  toml += `prompt = ${JSON.stringify(body)}\n`;
+  
+  return toml;
+}
+
+/**
+ * Copy commands to a flat structure for OpenCode
+ * OpenCode expects: command/qgsd-help.md (invoked as /qgsd-help)
+ * Source structure: commands/qgsd/help.md
+ *
+ * @param {string} srcDir - Source directory (e.g., commands/qgsd/)
+ * @param {string} destDir - Destination directory (e.g., command/)
+ * @param {string} prefix - Prefix for filenames (e.g., 'qgsd')
+ * @param {string} pathPrefix - Path prefix for file references
+ * @param {string} runtime - Target runtime ('claude' or 'opencode')
+ */
+function copyFlattenedCommands(srcDir, destDir, prefix, pathPrefix, runtime) {
+  if (!fs.existsSync(srcDir)) {
+    return;
+  }
+  
+  // Remove old qgsd-*.md files before copying new ones
+  if (fs.existsSync(destDir)) {
+    for (const file of fs.readdirSync(destDir)) {
+      if (file.startsWith(`${prefix}-`) && file.endsWith('.md')) {
+        fs.unlinkSync(path.join(destDir, file));
+      }
+    }
+  } else {
+    fs.mkdirSync(destDir, { recursive: true });
+  }
+  
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name);
+    
+    if (entry.isDirectory()) {
+      // Recurse into subdirectories, adding to prefix
+      // e.g., commands/qgsd/debug/start.md -> command/qgsd-debug-start.md
+      copyFlattenedCommands(srcPath, destDir, `${prefix}-${entry.name}`, pathPrefix, runtime);
+    } else if (entry.name.endsWith('.md')) {
+      // Flatten: help.md -> qgsd-help.md
+      const baseName = entry.name.replace('.md', '');
+      const destName = `${prefix}-${baseName}.md`;
+      const destPath = path.join(destDir, destName);
+
+      let content = fs.readFileSync(srcPath, 'utf8');
+      const globalClaudeRegex = /~\/\.claude\//g;
+      const localClaudeRegex = /\.\/\.claude\//g;
+      const opencodeDirRegex = /~\/\.opencode\//g;
+      content = content.replace(globalClaudeRegex, pathPrefix);
+      content = content.replace(localClaudeRegex, `./${getDirName(runtime)}/`);
+      content = content.replace(opencodeDirRegex, pathPrefix);
+      content = processAttribution(content, getCommitAttribution(runtime));
+      content = convertClaudeToOpencodeFrontmatter(content);
+
+      fs.writeFileSync(destPath, content);
+    }
+  }
+}
+
+/**
+ * Recursively copy directory, replacing paths in .md files
+ * Deletes existing destDir first to remove orphaned files from previous versions
+ * @param {string} srcDir - Source directory
+ * @param {string} destDir - Destination directory
+ * @param {string} pathPrefix - Path prefix for file references
+ * @param {string} runtime - Target runtime ('claude', 'opencode', 'gemini')
+ */
+function copyWithPathReplacement(srcDir, destDir, pathPrefix, runtime) {
+  const isOpencode = runtime === 'opencode';
+  const dirName = getDirName(runtime);
+
+  // Clean install: remove existing destination to prevent orphaned files
+  if (fs.existsSync(destDir)) {
+    fs.rmSync(destDir, { recursive: true });
+  }
+  fs.mkdirSync(destDir, { recursive: true });
+
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+
+    if (entry.isDirectory()) {
+      copyWithPathReplacement(srcPath, destPath, pathPrefix, runtime);
+    } else if (entry.name.endsWith('.md')) {
+      // Replace ~/.claude/ and ./.claude/ with runtime-appropriate paths
+      let content = fs.readFileSync(srcPath, 'utf8');
+      const globalClaudeRegex = /~\/\.claude\//g;
+      const localClaudeRegex = /\.\/\.claude\//g;
+      content = content.replace(globalClaudeRegex, pathPrefix);
+      content = content.replace(localClaudeRegex, `./${dirName}/`);
+      content = processAttribution(content, getCommitAttribution(runtime));
+
+      // Convert frontmatter for opencode compatibility
+      if (isOpencode) {
+        content = convertClaudeToOpencodeFrontmatter(content);
+        fs.writeFileSync(destPath, content);
+      } else if (runtime === 'gemini') {
+        // Convert to TOML for Gemini (strip <sub> tags — terminals can't render subscript)
+        content = stripSubTags(content);
+        const tomlContent = convertClaudeToGeminiToml(content);
+        // Replace extension with .toml
+        const tomlPath = destPath.replace(/\.md$/, '.toml');
+        fs.writeFileSync(tomlPath, tomlContent);
+      } else {
+        fs.writeFileSync(destPath, content);
+      }
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Clean up orphaned files from previous GSD versions
+ */
+function cleanupOrphanedFiles(configDir) {
+  const orphanedFiles = [
+    'hooks/gsd-notify.sh',        // Removed in v1.6.x
+    'hooks/statusline.js',         // Renamed to gsd-statusline.js in v1.9.0
+    'hooks/gsd-statusline.js',     // Renamed to qgsd-statusline.js in v0.2
+    'hooks/gsd-check-update.js',   // Renamed to qgsd-check-update.js in v0.2
+  ];
+
+  for (const relPath of orphanedFiles) {
+    const fullPath = path.join(configDir, relPath);
+    if (fs.existsSync(fullPath)) {
+      fs.unlinkSync(fullPath);
+      console.log(`  ${green}✓${reset} Removed orphaned ${relPath}`);
+    }
+  }
+}
+
+/**
+ * Clean up orphaned hook registrations from settings.json
+ */
+function cleanupOrphanedHooks(settings) {
+  const orphanedHookPatterns = [
+    'gsd-notify.sh',  // Removed in v1.6.x
+    'hooks/statusline.js',  // Renamed to gsd-statusline.js in v1.9.0
+    'gsd-intel-index.js',  // Removed in v1.9.2
+    'gsd-intel-session.js',  // Removed in v1.9.2
+    'gsd-intel-prune.js',  // Removed in v1.9.2
+    'hooks/gsd-check-update.js',  // Renamed to qgsd-check-update.js in v0.2
+    'hooks/gsd-statusline.js',  // Renamed to qgsd-statusline.js in v0.2
+  ];
+
+  let cleanedHooks = false;
+
+  // Check all hook event types (Stop, SessionStart, etc.)
+  if (settings.hooks) {
+    for (const eventType of Object.keys(settings.hooks)) {
+      const hookEntries = settings.hooks[eventType];
+      if (Array.isArray(hookEntries)) {
+        // Filter out entries that contain orphaned hooks
+        const filtered = hookEntries.filter(entry => {
+          if (entry.hooks && Array.isArray(entry.hooks)) {
+            // Check if any hook in this entry matches orphaned patterns
+            const hasOrphaned = entry.hooks.some(h =>
+              h.command && orphanedHookPatterns.some(pattern => h.command.includes(pattern))
+            );
+            if (hasOrphaned) {
+              cleanedHooks = true;
+              return false;  // Remove this entry
+            }
+          }
+          return true;  // Keep this entry
+        });
+        settings.hooks[eventType] = filtered;
+      }
+    }
+  }
+
+  if (cleanedHooks) {
+    console.log(`  ${green}✓${reset} Removed orphaned hook registrations`);
+  }
+
+  // Fix #330 + qgsd migration: update statusLine if it points to old statusline path
+  if (settings.statusLine && settings.statusLine.command) {
+    const cmd = settings.statusLine.command;
+    if ((cmd.includes('statusline.js') || cmd.includes('gsd-statusline.js')) &&
+        !cmd.includes('qgsd-statusline.js')) {
+      settings.statusLine.command = cmd
+        .replace(/\bgsd-statusline\.js\b/, 'qgsd-statusline.js')
+        .replace(/\bstatusline\.js\b/, 'qgsd-statusline.js');
+      console.log(`  ${green}✓${reset} Updated statusline path → qgsd-statusline.js`);
+    }
+  }
+
+  return settings;
+}
+
+/**
+ * Uninstall GSD from the specified directory for a specific runtime
+ * Removes only GSD-specific files/directories, preserves user content
+ * @param {boolean} isGlobal - Whether to uninstall from global or local
+ * @param {string} runtime - Target runtime ('claude', 'opencode', 'gemini')
+ */
+function uninstall(isGlobal, runtime = 'claude') {
+  const isOpencode = runtime === 'opencode';
+  const dirName = getDirName(runtime);
+
+  // Get the target directory based on runtime and install type
+  const targetDir = isGlobal
+    ? getGlobalDir(runtime, explicitConfigDir)
+    : path.join(process.cwd(), dirName);
+
+  const locationLabel = isGlobal
+    ? targetDir.replace(os.homedir(), '~')
+    : targetDir.replace(process.cwd(), '.');
+
+  let runtimeLabel = 'Claude Code';
+  if (runtime === 'opencode') runtimeLabel = 'OpenCode';
+  if (runtime === 'gemini') runtimeLabel = 'Gemini';
+
+  console.log(`  Uninstalling GSD from ${cyan}${runtimeLabel}${reset} at ${cyan}${locationLabel}${reset}\n`);
+
+  // Check if target directory exists
+  if (!fs.existsSync(targetDir)) {
+    console.log(`  ${yellow}⚠${reset} Directory does not exist: ${locationLabel}`);
+    console.log(`  Nothing to uninstall.\n`);
+    return;
+  }
+
+  let removedCount = 0;
+
+  // 1. Remove GSD commands directory
+  if (isOpencode) {
+    // OpenCode: remove command/qgsd-*.md files
+    const commandDir = path.join(targetDir, 'command');
+    if (fs.existsSync(commandDir)) {
+      const files = fs.readdirSync(commandDir);
+      for (const file of files) {
+        if (file.startsWith('qgsd-') && file.endsWith('.md')) {
+          fs.unlinkSync(path.join(commandDir, file));
+          removedCount++;
+        }
+      }
+      console.log(`  ${green}✓${reset} Removed GSD commands from command/`);
+    }
+  } else {
+    // Claude Code & Gemini: remove commands/qgsd/ directory
+    const gsdCommandsDir = path.join(targetDir, 'commands', 'qgsd');
+    if (fs.existsSync(gsdCommandsDir)) {
+      fs.rmSync(gsdCommandsDir, { recursive: true });
+      removedCount++;
+      console.log(`  ${green}✓${reset} Removed commands/qgsd/`);
+    }
+  }
+
+  // 2. Remove qgsd directory
+  const gsdDir = path.join(targetDir, 'qgsd');
+  if (fs.existsSync(gsdDir)) {
+    fs.rmSync(gsdDir, { recursive: true });
+    removedCount++;
+    console.log(`  ${green}✓${reset} Removed qgsd/`);
+  }
+
+  // 2b. Migration: warn about old get-shit-done/ and commands/gsd/ paths from pre-v0.2 nForma installs
+  // REN-03: intentional legacy path reference for migration detection
+  const oldGsdDir = path.join(targetDir, 'get-shit-done');
+  const oldCommandsGsdDir = path.join(targetDir, 'commands', 'gsd');
+  if (fs.existsSync(oldGsdDir) || fs.existsSync(oldCommandsGsdDir)) {
+    console.log(`\n  ${yellow}⚠ Migration notice:${reset} Old nForma paths detected from a pre-v0.2 install:`);
+    if (fs.existsSync(oldGsdDir)) console.log(`    ${yellow}•${reset} ${oldGsdDir}`);
+    if (fs.existsSync(oldCommandsGsdDir)) console.log(`    ${yellow}•${reset} ${oldCommandsGsdDir}`);
+    console.log(`  ${yellow}  If you don't have upstream GSD installed, these can be safely removed:${reset}`);
+    if (fs.existsSync(oldGsdDir)) console.log(`    rm -rf ${oldGsdDir}`);
+    if (fs.existsSync(oldCommandsGsdDir)) console.log(`    rm -rf ${oldCommandsGsdDir}`);
+    console.log();
+  }
+
+  // 3. Remove GSD agents (qgsd-*.md files only)
+  const agentsDir = path.join(targetDir, 'agents');
+  if (fs.existsSync(agentsDir)) {
+    const files = fs.readdirSync(agentsDir);
+    let agentCount = 0;
+    for (const file of files) {
+      if (file.startsWith('qgsd-') && file.endsWith('.md')) {
+        fs.unlinkSync(path.join(agentsDir, file));
+        agentCount++;
+      }
+    }
+    if (agentCount > 0) {
+      removedCount++;
+      console.log(`  ${green}✓${reset} Removed ${agentCount} nForma agents`);
+    }
+
+    // Migration: warn about old gsd-*.md agents from pre-v0.2 nForma installs
+    const oldAgents = fs.readdirSync(agentsDir).filter(f => f.startsWith('gsd-') && f.endsWith('.md'));
+    if (oldAgents.length > 0) {
+      console.log(`\n  ${yellow}⚠ Migration notice:${reset} Old nForma agents (gsd-*.md) detected from a pre-v0.2 install:`);
+      oldAgents.forEach(f => console.log(`    ${yellow}•${reset} ${path.join(agentsDir, f)}`));
+      console.log(`  ${yellow}  If you don't use upstream GSD, these can be safely removed:${reset}`);
+      console.log(`    for f in ~/.claude/agents/gsd-*.md; do rm "$f"; done\n`);
+    }
+  }
+
+  // 4. Remove GSD hooks
+  const hooksDir = path.join(targetDir, 'hooks');
+  if (fs.existsSync(hooksDir)) {
+    const gsdHooks = ['qgsd-statusline.js', 'qgsd-check-update.js', 'gsd-check-update.sh'];
+    let hookCount = 0;
+    for (const hook of gsdHooks) {
+      const hookPath = path.join(hooksDir, hook);
+      if (fs.existsSync(hookPath)) {
+        fs.unlinkSync(hookPath);
+        hookCount++;
+      }
+    }
+    if (hookCount > 0) {
+      removedCount++;
+      console.log(`  ${green}✓${reset} Removed ${hookCount} GSD hooks`);
+    }
+  }
+
+  // 5. Remove GSD package.json (CommonJS mode marker)
+  const pkgJsonPath = path.join(targetDir, 'package.json');
+  if (fs.existsSync(pkgJsonPath)) {
+    try {
+      const content = fs.readFileSync(pkgJsonPath, 'utf8').trim();
+      // Only remove if it's our minimal CommonJS marker
+      if (content === '{"type":"commonjs"}') {
+        fs.unlinkSync(pkgJsonPath);
+        removedCount++;
+        console.log(`  ${green}✓${reset} Removed GSD package.json`);
+      }
+    } catch (e) {
+      // Ignore read errors
+    }
+  }
+
+  // 6. Clean up settings.json (remove GSD hooks and statusline)
+  const settingsPath = path.join(targetDir, 'settings.json');
+  if (fs.existsSync(settingsPath)) {
+    let settings = readSettings(settingsPath);
+    let settingsModified = false;
+
+    // Remove GSD statusline if it references our hook
+    if (settings.statusLine && settings.statusLine.command &&
+        settings.statusLine.command.includes('qgsd-statusline')) {
+      delete settings.statusLine;
+      settingsModified = true;
+      console.log(`  ${green}✓${reset} Removed GSD statusline from settings`);
+    }
+
+    // Remove GSD hooks from SessionStart
+    if (settings.hooks && settings.hooks.SessionStart) {
+      const before = settings.hooks.SessionStart.length;
+      settings.hooks.SessionStart = settings.hooks.SessionStart.filter(entry => {
+        if (entry.hooks && Array.isArray(entry.hooks)) {
+          // Filter out GSD hooks
+          const hasGsdHook = entry.hooks.some(h =>
+            h.command && (
+              h.command.includes('qgsd-check-update') ||
+              h.command.includes('qgsd-statusline') ||
+              h.command.includes('qgsd-session-start')
+            )
+          );
+          return !hasGsdHook;
+        }
+        return true;
+      });
+      if (settings.hooks.SessionStart.length < before) {
+        settingsModified = true;
+        console.log(`  ${green}✓${reset} Removed GSD hooks from settings`);
+      }
+      // Clean up empty array
+      if (settings.hooks.SessionStart.length === 0) {
+        delete settings.hooks.SessionStart;
+      }
+    }
+
+    if (settings.hooks && settings.hooks.UserPromptSubmit) {
+      const before = settings.hooks.UserPromptSubmit.length;
+      settings.hooks.UserPromptSubmit = settings.hooks.UserPromptSubmit.filter(entry =>
+        !(entry.hooks && entry.hooks.some(h => h.command && h.command.includes('qgsd-prompt')))
+      );
+      if (settings.hooks.UserPromptSubmit.length < before) {
+        settingsModified = true;
+        console.log(`  ${green}✓${reset} Removed nForma quorum injection hook`);
+      }
+      if (settings.hooks.UserPromptSubmit.length === 0) delete settings.hooks.UserPromptSubmit;
+    }
+    if (settings.hooks && settings.hooks.Stop) {
+      const before = settings.hooks.Stop.length;
+      settings.hooks.Stop = settings.hooks.Stop.filter(entry =>
+        !(entry.hooks && entry.hooks.some(h => h.command && h.command.includes('qgsd-stop')))
+      );
+      if (settings.hooks.Stop.length < before) {
+        settingsModified = true;
+        console.log(`  ${green}✓${reset} Removed nForma quorum gate hook`);
+      }
+      if (settings.hooks.Stop.length === 0) delete settings.hooks.Stop;
+    }
+    if (settings.hooks && settings.hooks.PreToolUse) {
+      const before = settings.hooks.PreToolUse.length;
+      settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(entry =>
+        !(entry.hooks && entry.hooks.some(h => h.command && h.command.includes('qgsd-circuit-breaker')))
+      );
+      if (settings.hooks.PreToolUse.length < before) {
+        settingsModified = true;
+        console.log(`  ${green}✓${reset} Removed nForma circuit breaker hook`);
+      }
+      if (settings.hooks.PreToolUse.length === 0) delete settings.hooks.PreToolUse;
+    }
+    if (settings.hooks && settings.hooks.PostToolUse) {
+      const before = settings.hooks.PostToolUse.length;
+      settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter(entry =>
+        !(entry.hooks && entry.hooks.some(h => h.command && h.command.includes('gsd-context-monitor')))
+      );
+      if (settings.hooks.PostToolUse.length < before) {
+        settingsModified = true;
+        console.log(`  ${green}✓${reset} Removed nForma context monitor hook`);
+      }
+      if (settings.hooks.PostToolUse.length === 0) delete settings.hooks.PostToolUse;
+    }
+    // Remove qgsd-spec-regen hook (uninstall path)
+    if (settings.hooks && settings.hooks.PostToolUse) {
+      const before = settings.hooks.PostToolUse.length;
+      settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter(entry =>
+        !(entry.hooks && entry.hooks.some(h => h.command && h.command.includes('qgsd-spec-regen')))
+      );
+      if (settings.hooks.PostToolUse.length < before) {
+        settingsModified = true;
+        console.log(`  ${green}✓${reset} Removed nForma spec-regen hook`);
+      }
+      if (settings.hooks.PostToolUse.length === 0) delete settings.hooks.PostToolUse;
+    }
+    if (settings.hooks && settings.hooks.PreCompact) {
+      const before = settings.hooks.PreCompact.length;
+      settings.hooks.PreCompact = settings.hooks.PreCompact.filter(entry =>
+        !(entry.hooks && entry.hooks.some(h => h.command && h.command.includes('qgsd-precompact')))
+      );
+      if (settings.hooks.PreCompact.length < before) {
+        settingsModified = true;
+        console.log(`  ${green}✓${reset} Removed nForma PreCompact hook`);
+      }
+      if (settings.hooks.PreCompact.length === 0) delete settings.hooks.PreCompact;
+    }
+
+    // Clean up empty hooks object
+    if (settings.hooks && Object.keys(settings.hooks).length === 0) {
+      delete settings.hooks;
+    }
+
+    if (settingsModified) {
+      writeSettings(settingsPath, settings);
+      removedCount++;
+    }
+  }
+
+  // 6. For OpenCode, clean up permissions from opencode.json
+  if (isOpencode) {
+    // For local uninstalls, clean up ./.opencode/opencode.json
+    // For global uninstalls, clean up ~/.config/opencode/opencode.json
+    const opencodeConfigDir = isGlobal
+      ? getOpencodeGlobalDir()
+      : path.join(process.cwd(), '.opencode');
+    const configPath = path.join(opencodeConfigDir, 'opencode.json');
+    if (fs.existsSync(configPath)) {
+      try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        let modified = false;
+
+        // Remove GSD permission entries
+        if (config.permission) {
+          for (const permType of ['read', 'external_directory']) {
+            if (config.permission[permType]) {
+              const keys = Object.keys(config.permission[permType]);
+              for (const key of keys) {
+                if (key.includes('qgsd')) {
+                  delete config.permission[permType][key];
+                  modified = true;
+                }
+              }
+              // Clean up empty objects
+              if (Object.keys(config.permission[permType]).length === 0) {
+                delete config.permission[permType];
+              }
+            }
+          }
+          if (Object.keys(config.permission).length === 0) {
+            delete config.permission;
+          }
+        }
+
+        if (modified) {
+          fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+          removedCount++;
+          console.log(`  ${green}✓${reset} Removed GSD permissions from opencode.json`);
+        }
+      } catch (e) {
+        // Ignore JSON parse errors
+      }
+    }
+  }
+
+  if (removedCount === 0) {
+    console.log(`  ${yellow}⚠${reset} No GSD files found to remove.`);
+  }
+
+  console.log(`
+  ${green}Done!${reset} GSD has been uninstalled from ${runtimeLabel}.
+  Your other files and settings have been preserved.
+`);
+}
+
+/**
+ * Parse JSONC (JSON with Comments) by stripping comments and trailing commas.
+ * OpenCode supports JSONC format via jsonc-parser, so users may have comments.
+ * This is a lightweight inline parser to avoid adding dependencies.
+ */
+function parseJsonc(content) {
+  // Strip BOM if present
+  if (content.charCodeAt(0) === 0xFEFF) {
+    content = content.slice(1);
+  }
+
+  // Remove single-line and block comments while preserving strings
+  let result = '';
+  let inString = false;
+  let i = 0;
+  while (i < content.length) {
+    const char = content[i];
+    const next = content[i + 1];
+
+    if (inString) {
+      result += char;
+      // Handle escape sequences
+      if (char === '\\' && i + 1 < content.length) {
+        result += next;
+        i += 2;
+        continue;
+      }
+      if (char === '"') {
+        inString = false;
+      }
+      i++;
+    } else {
+      if (char === '"') {
+        inString = true;
+        result += char;
+        i++;
+      } else if (char === '/' && next === '/') {
+        // Skip single-line comment until end of line
+        while (i < content.length && content[i] !== '\n') {
+          i++;
+        }
+      } else if (char === '/' && next === '*') {
+        // Skip block comment
+        i += 2;
+        while (i < content.length - 1 && !(content[i] === '*' && content[i + 1] === '/')) {
+          i++;
+        }
+        i += 2; // Skip closing */
+      } else {
+        result += char;
+        i++;
+      }
+    }
+  }
+
+  // Remove trailing commas before } or ]
+  result = result.replace(/,(\s*[}\]])/g, '$1');
+
+  return JSON.parse(result);
+}
+
+/**
+ * Configure OpenCode permissions to allow reading GSD reference docs
+ * This prevents permission prompts when GSD accesses the qgsd directory
+ * @param {boolean} isGlobal - Whether this is a global or local install
+ */
+function configureOpencodePermissions(isGlobal = true) {
+  // For local installs, use ./.opencode/opencode.json
+  // For global installs, use ~/.config/opencode/opencode.json
+  const opencodeConfigDir = isGlobal
+    ? getOpencodeGlobalDir()
+    : path.join(process.cwd(), '.opencode');
+  const configPath = path.join(opencodeConfigDir, 'opencode.json');
+
+  // Ensure config directory exists
+  fs.mkdirSync(opencodeConfigDir, { recursive: true });
+
+  // Read existing config or create empty object
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      const content = fs.readFileSync(configPath, 'utf8');
+      config = parseJsonc(content);
+    } catch (e) {
+      // Cannot parse - DO NOT overwrite user's config
+      console.log(`  ${yellow}⚠${reset} Could not parse opencode.json - skipping permission config`);
+      console.log(`    ${dim}Reason: ${e.message}${reset}`);
+      console.log(`    ${dim}Your config was NOT modified. Fix the syntax manually if needed.${reset}`);
+      return;
+    }
+  }
+
+  // Ensure permission structure exists
+  if (!config.permission) {
+    config.permission = {};
+  }
+
+  // Build the GSD path using the actual config directory
+  // Use ~ shorthand if it's in the default location, otherwise use full path
+  const defaultConfigDir = path.join(os.homedir(), '.config', 'opencode');
+  const gsdPath = opencodeConfigDir === defaultConfigDir
+    ? '~/.config/opencode/qgsd/*'
+    : `${opencodeConfigDir.replace(/\\/g, '/')}/qgsd/*`;
+  
+  let modified = false;
+
+  // Configure read permission
+  if (!config.permission.read || typeof config.permission.read !== 'object') {
+    config.permission.read = {};
+  }
+  if (config.permission.read[gsdPath] !== 'allow') {
+    config.permission.read[gsdPath] = 'allow';
+    modified = true;
+  }
+
+  // Configure external_directory permission (the safety guard for paths outside project)
+  if (!config.permission.external_directory || typeof config.permission.external_directory !== 'object') {
+    config.permission.external_directory = {};
+  }
+  if (config.permission.external_directory[gsdPath] !== 'allow') {
+    config.permission.external_directory[gsdPath] = 'allow';
+    modified = true;
+  }
+
+  if (!modified) {
+    return; // Already configured
+  }
+
+  // Write config back
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+  console.log(`  ${green}✓${reset} Configured read permission for GSD docs`);
+}
+
+/**
+ * Verify a directory exists and contains files
+ */
+function verifyInstalled(dirPath, description) {
+  if (!fs.existsSync(dirPath)) {
+    console.error(`  ${yellow}✗${reset} Failed to install ${description}: directory not created`);
+    return false;
+  }
+  try {
+    const entries = fs.readdirSync(dirPath);
+    if (entries.length === 0) {
+      console.error(`  ${yellow}✗${reset} Failed to install ${description}: directory is empty`);
+      return false;
+    }
+  } catch (e) {
+    console.error(`  ${yellow}✗${reset} Failed to install ${description}: ${e.message}`);
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Verify a file exists
+ */
+function verifyFileInstalled(filePath, description) {
+  if (!fs.existsSync(filePath)) {
+    console.error(`  ${yellow}✗${reset} Failed to install ${description}: file not created`);
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Install to the specified directory for a specific runtime
+ * @param {boolean} isGlobal - Whether to install globally or locally
+ * @param {string} runtime - Target runtime ('claude', 'opencode', 'gemini')
+ */
+
+// ──────────────────────────────────────────────────────
+// Local Patch Persistence
+// ──────────────────────────────────────────────────────
+
+const PATCHES_DIR_NAME = 'gsd-local-patches';
+const MANIFEST_NAME = 'qgsd-file-manifest.json';
+
+/**
+ * Compute SHA256 hash of file contents
+ */
+function fileHash(filePath) {
+  const content = fs.readFileSync(filePath);
+  return crypto.createHash('sha256').update(content).digest('hex');
+}
+
+/**
+ * Recursively collect all files in dir with their hashes
+ */
+function generateManifest(dir, baseDir) {
+  if (!baseDir) baseDir = dir;
+  const manifest = {};
+  if (!fs.existsSync(dir)) return manifest;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    const relPath = path.relative(baseDir, fullPath).replace(/\\/g, '/');
+    if (entry.isDirectory()) {
+      Object.assign(manifest, generateManifest(fullPath, baseDir));
+    } else {
+      manifest[relPath] = fileHash(fullPath);
+    }
+  }
+  return manifest;
+}
+
+/**
+ * Write file manifest after installation for future modification detection
+ */
+function writeManifest(configDir) {
+  const gsdDir = path.join(configDir, 'qgsd');
+  const commandsDir = path.join(configDir, 'commands', 'qgsd');
+  const agentsDir = path.join(configDir, 'agents');
+  const manifest = { version: pkg.version, timestamp: new Date().toISOString(), files: {} };
+
+  const gsdHashes = generateManifest(gsdDir);
+  for (const [rel, hash] of Object.entries(gsdHashes)) {
+    manifest.files['qgsd/' + rel] = hash;
+  }
+  if (fs.existsSync(commandsDir)) {
+    const cmdHashes = generateManifest(commandsDir);
+    for (const [rel, hash] of Object.entries(cmdHashes)) {
+      manifest.files['commands/qgsd/' + rel] = hash;
+    }
+  }
+  if (fs.existsSync(agentsDir)) {
+    for (const file of fs.readdirSync(agentsDir)) {
+      if (file.startsWith('qgsd-') && file.endsWith('.md')) {
+        manifest.files['agents/' + file] = fileHash(path.join(agentsDir, file));
+      }
+    }
+  }
+
+  fs.writeFileSync(path.join(configDir, MANIFEST_NAME), JSON.stringify(manifest, null, 2));
+  return manifest;
+}
+
+/**
+ * Detect user-modified GSD files by comparing against install manifest.
+ * Backs up modified files to gsd-local-patches/ for reapply after update.
+ */
+function saveLocalPatches(configDir) {
+  const manifestPath = path.join(configDir, MANIFEST_NAME);
+  if (!fs.existsSync(manifestPath)) return [];
+
+  let manifest;
+  try { manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8')); } catch { return []; }
+
+  const patchesDir = path.join(configDir, PATCHES_DIR_NAME);
+  const modified = [];
+
+  for (const [relPath, originalHash] of Object.entries(manifest.files || {})) {
+    const fullPath = path.join(configDir, relPath);
+    if (!fs.existsSync(fullPath)) continue;
+    const currentHash = fileHash(fullPath);
+    if (currentHash !== originalHash) {
+      const backupPath = path.join(patchesDir, relPath);
+      fs.mkdirSync(path.dirname(backupPath), { recursive: true });
+      fs.copyFileSync(fullPath, backupPath);
+      modified.push(relPath);
+    }
+  }
+
+  if (modified.length > 0) {
+    const meta = {
+      backed_up_at: new Date().toISOString(),
+      from_version: manifest.version,
+      files: modified
+    };
+    fs.writeFileSync(path.join(patchesDir, 'backup-meta.json'), JSON.stringify(meta, null, 2));
+    console.log('  ' + yellow + 'i' + reset + '  Found ' + modified.length + ' locally modified GSD file(s) — backed up to ' + PATCHES_DIR_NAME + '/');
+    for (const f of modified) {
+      console.log('     ' + dim + f + reset);
+    }
+  }
+  return modified;
+}
+
+/**
+ * After install, report backed-up patches for user to reapply.
+ */
+function reportLocalPatches(configDir) {
+  const patchesDir = path.join(configDir, PATCHES_DIR_NAME);
+  const metaPath = path.join(patchesDir, 'backup-meta.json');
+  if (!fs.existsSync(metaPath)) return [];
+
+  let meta;
+  try { meta = JSON.parse(fs.readFileSync(metaPath, 'utf8')); } catch { return []; }
+
+  if (meta.files && meta.files.length > 0) {
+    console.log('');
+    console.log('  ' + yellow + 'Local patches detected' + reset + ' (from v' + meta.from_version + '):');
+    for (const f of meta.files) {
+      console.log('     ' + cyan + f + reset);
+    }
+    console.log('');
+    console.log('  Your modifications are saved in ' + cyan + PATCHES_DIR_NAME + '/' + reset);
+    console.log('  Run ' + cyan + '/qgsd:reapply-patches' + reset + ' to merge them into the new version.');
+    console.log('  Or manually compare and merge the files.');
+    console.log('');
+  }
+  return meta.files || [];
+}
+
+function install(isGlobal, runtime = 'claude') {
+  const isOpencode = runtime === 'opencode';
+  const isGemini = runtime === 'gemini';
+  const dirName = getDirName(runtime);
+  const src = path.join(__dirname, '..');
+
+  // Get the target directory based on runtime and install type
+  const targetDir = isGlobal
+    ? getGlobalDir(runtime, explicitConfigDir)
+    : path.join(process.cwd(), dirName);
+
+  const locationLabel = isGlobal
+    ? targetDir.replace(os.homedir(), '~')
+    : targetDir.replace(process.cwd(), '.');
+
+  // Path prefix for file references in markdown content
+  // For global installs: use full path
+  // For local installs: use relative
+  const pathPrefix = isGlobal
+    ? `${targetDir.replace(/\\/g, '/')}/`
+    : `./${dirName}/`;
+
+  let runtimeLabel = 'Claude Code';
+  if (isOpencode) runtimeLabel = 'OpenCode';
+  if (isGemini) runtimeLabel = 'Gemini';
+
+  console.log(`  Installing for ${cyan}${runtimeLabel}${reset} to ${cyan}${locationLabel}${reset}\n`);
+
+  // Track installation failures
+  const failures = [];
+
+  // Save any locally modified GSD files before they get wiped
+  saveLocalPatches(targetDir);
+
+  // Clean up orphaned files from previous versions
+  cleanupOrphanedFiles(targetDir);
+
+  // OpenCode uses 'command/' (singular) with flat structure
+  // Claude Code & Gemini use 'commands/' (plural) with nested structure
+  if (isOpencode) {
+    // OpenCode: flat structure in command/ directory
+    const commandDir = path.join(targetDir, 'command');
+    fs.mkdirSync(commandDir, { recursive: true });
+    
+    // Copy commands/qgsd/*.md as command/qgsd-*.md (flatten structure)
+    const gsdSrc = path.join(src, 'commands', 'qgsd');
+    copyFlattenedCommands(gsdSrc, commandDir, 'qgsd', pathPrefix, runtime);
+    if (verifyInstalled(commandDir, 'command/qgsd-*')) {
+      const count = fs.readdirSync(commandDir).filter(f => f.startsWith('qgsd-')).length;
+      console.log(`  ${green}✓${reset} Installed ${count} commands to command/`);
+    } else {
+      failures.push('command/qgsd-*');
+    }
+  } else {
+    // Claude Code & Gemini: nested structure in commands/ directory
+    const commandsDir = path.join(targetDir, 'commands');
+    fs.mkdirSync(commandsDir, { recursive: true });
+    
+    const gsdSrc = path.join(src, 'commands', 'qgsd');
+    const gsdDest = path.join(commandsDir, 'qgsd');
+    copyWithPathReplacement(gsdSrc, gsdDest, pathPrefix, runtime);
+    if (verifyInstalled(gsdDest, 'commands/qgsd')) {
+      console.log(`  ${green}✓${reset} Installed commands/qgsd`);
+    } else {
+      failures.push('commands/qgsd');
+    }
+  }
+
+  // Copy qgsd skill with path replacement
+  const skillSrc = path.join(src, 'qgsd-core');
+  const skillDest = path.join(targetDir, 'qgsd');
+  copyWithPathReplacement(skillSrc, skillDest, pathPrefix, runtime);
+  if (verifyInstalled(skillDest, 'qgsd')) {
+    console.log(`  ${green}✓${reset} Installed qgsd`);
+  } else {
+    failures.push('qgsd');
+  }
+
+  // Copy agents to agents directory
+  const agentsSrc = path.join(src, 'agents');
+  if (fs.existsSync(agentsSrc)) {
+    const agentsDest = path.join(targetDir, 'agents');
+    fs.mkdirSync(agentsDest, { recursive: true });
+
+    // Remove old qgsd-*.md files before copying new ones
+    if (fs.existsSync(agentsDest)) {
+      for (const file of fs.readdirSync(agentsDest)) {
+        if (file.startsWith('qgsd-') && file.endsWith('.md')) {
+          fs.unlinkSync(path.join(agentsDest, file));
+        }
+      }
+    }
+
+    // Copy new agents
+    const agentEntries = fs.readdirSync(agentsSrc, { withFileTypes: true });
+    for (const entry of agentEntries) {
+      if (entry.isFile() && entry.name.endsWith('.md')) {
+        let content = fs.readFileSync(path.join(agentsSrc, entry.name), 'utf8');
+        // Always replace ~/.claude/ as it is the source of truth in the repo
+        const dirRegex = /~\/\.claude\//g;
+        content = content.replace(dirRegex, pathPrefix);
+        content = processAttribution(content, getCommitAttribution(runtime));
+        // Convert frontmatter for runtime compatibility
+        if (isOpencode) {
+          content = convertClaudeToOpencodeFrontmatter(content);
+        } else if (isGemini) {
+          content = convertClaudeToGeminiAgent(content);
+        }
+        fs.writeFileSync(path.join(agentsDest, entry.name), content);
+      }
+    }
+    if (verifyInstalled(agentsDest, 'agents')) {
+      console.log(`  ${green}✓${reset} Installed agents`);
+    } else {
+      failures.push('agents');
+    }
+  }
+
+  // Copy CHANGELOG.md
+  const changelogSrc = path.join(src, 'CHANGELOG.md');
+  const changelogDest = path.join(targetDir, 'qgsd', 'CHANGELOG.md');
+  if (fs.existsSync(changelogSrc)) {
+    fs.copyFileSync(changelogSrc, changelogDest);
+    if (verifyFileInstalled(changelogDest, 'CHANGELOG.md')) {
+      console.log(`  ${green}✓${reset} Installed CHANGELOG.md`);
+    } else {
+      failures.push('CHANGELOG.md');
+    }
+  }
+
+  // Write VERSION file
+  const versionDest = path.join(targetDir, 'qgsd', 'VERSION');
+  fs.writeFileSync(versionDest, pkg.version);
+  if (verifyFileInstalled(versionDest, 'VERSION')) {
+    console.log(`  ${green}✓${reset} Wrote VERSION (${pkg.version})`);
+  } else {
+    failures.push('VERSION');
+  }
+
+  // Write package.json to force CommonJS mode for GSD scripts
+  // Prevents "require is not defined" errors when project has "type": "module"
+  // Node.js walks up looking for package.json - this stops inheritance from project
+  const pkgJsonDest = path.join(targetDir, 'package.json');
+  fs.writeFileSync(pkgJsonDest, '{"type":"commonjs"}\n');
+  console.log(`  ${green}✓${reset} Wrote package.json (CommonJS mode)`);
+
+  // Copy hooks from dist/ (bundled with dependencies)
+  // Template paths for the target runtime (replaces '.claude' with correct config dir)
+  const hooksSrc = path.join(src, 'hooks', 'dist');
+  if (fs.existsSync(hooksSrc)) {
+    const hooksDest = path.join(targetDir, 'hooks');
+    fs.mkdirSync(hooksDest, { recursive: true });
+    const hookEntries = fs.readdirSync(hooksSrc);
+    const configDirReplacement = getConfigDirFromHome(runtime, isGlobal);
+    for (const entry of hookEntries) {
+      const srcFile = path.join(hooksSrc, entry);
+      if (fs.statSync(srcFile).isFile()) {
+        const destFile = path.join(hooksDest, entry);
+        // Template .js files to replace '.claude' with runtime-specific config dir
+        if (entry.endsWith('.js')) {
+          let content = fs.readFileSync(srcFile, 'utf8');
+          content = content.replace(/'\.claude'/g, configDirReplacement);
+          fs.writeFileSync(destFile, content);
+        } else {
+          fs.copyFileSync(srcFile, destFile);
+        }
+      }
+    }
+    if (verifyInstalled(hooksDest, 'hooks')) {
+      console.log(`  ${green}✓${reset} Installed hooks (bundled)`);
+    } else {
+      failures.push('hooks');
+    }
+  }
+
+  // Copy bin/*.cjs scripts to qgsd-bin/ (used by commands with absolute paths)
+  const binSrc = path.join(src, 'bin');
+  if (fs.existsSync(binSrc)) {
+    const binDest = path.join(targetDir, 'qgsd-bin');
+    fs.mkdirSync(binDest, { recursive: true });
+    const binEntries = fs.readdirSync(binSrc);
+    for (const entry of binEntries) {
+      if (entry.endsWith('.cjs') || entry === 'providers.json') {
+        fs.copyFileSync(path.join(binSrc, entry), path.join(binDest, entry));
+      }
+    }
+    console.log(`  ${green}✓${reset} Installed qgsd-bin scripts`);
+  }
+
+  if (failures.length > 0) {
+    console.error(`\n  ${yellow}Installation incomplete!${reset} Failed: ${failures.join(', ')}`);
+    process.exit(1);
+  }
+
+  // Configure statusline and hooks in settings.json
+  // Gemini shares same hook system as Claude Code for now
+  const settingsPath = path.join(targetDir, 'settings.json');
+  const settings = cleanupOrphanedHooks(readSettings(settingsPath));
+  const statuslineCommand = isGlobal
+    ? buildHookCommand(targetDir, 'qgsd-statusline.js')
+    : 'node ' + dirName + '/hooks/qgsd-statusline.js';
+  const updateCheckCommand = isGlobal
+    ? buildHookCommand(targetDir, 'qgsd-check-update.js')
+    : 'node ' + dirName + '/hooks/qgsd-check-update.js';
+
+  // Enable experimental agents for Gemini CLI (required for custom sub-agents)
+  if (isGemini) {
+    if (!settings.experimental) {
+      settings.experimental = {};
+    }
+    if (!settings.experimental.enableAgents) {
+      settings.experimental.enableAgents = true;
+      console.log(`  ${green}✓${reset} Enabled experimental agents`);
+    }
+  }
+
+  // Configure SessionStart hook for update checking (skip for opencode)
+  if (!isOpencode) {
+    if (!settings.hooks) {
+      settings.hooks = {};
+    }
+    if (!settings.hooks.SessionStart) {
+      settings.hooks.SessionStart = [];
+    }
+
+    const hasGsdUpdateHook = settings.hooks.SessionStart.some(entry =>
+      entry.hooks && entry.hooks.some(h => h.command && h.command.includes('qgsd-check-update'))
+    );
+
+    if (!hasGsdUpdateHook) {
+      settings.hooks.SessionStart.push({
+        hooks: [
+          {
+            type: 'command',
+            command: updateCheckCommand
+          }
+        ]
+      });
+      console.log(`  ${green}✓${reset} Configured update check hook`);
+    }
+
+    // Register nForma session-start secret sync hook
+    const hasGsdSessionStartHook = settings.hooks.SessionStart.some(entry =>
+      entry.hooks && entry.hooks.some(h => h.command && h.command.includes('qgsd-session-start'))
+    );
+    if (!hasGsdSessionStartHook) {
+      settings.hooks.SessionStart.push({
+        hooks: [
+          {
+            type: 'command',
+            command: buildHookCommand(targetDir, 'qgsd-session-start.js')
+          }
+        ]
+      });
+      console.log(`  ${green}✓${reset} Configured nForma secret sync hook (SessionStart)`);
+    }
+
+    // INST-05: Warn (yellow) if quorum MCP servers are absent — runs every install
+    warnMissingMcpServers();
+
+    // Register nForma UserPromptSubmit hook (quorum injection)
+    // MUST be in settings.json — plugin hooks.json silently discards UserPromptSubmit output (GitHub #10225)
+    if (!settings.hooks.UserPromptSubmit) settings.hooks.UserPromptSubmit = [];
+    const hasQgsdPromptHook = settings.hooks.UserPromptSubmit.some(entry =>
+      entry.hooks && entry.hooks.some(h => h.command && h.command.includes('qgsd-prompt'))
+    );
+    if (!hasQgsdPromptHook) {
+      settings.hooks.UserPromptSubmit.push({
+        hooks: [{ type: 'command', command: buildHookCommand(targetDir, 'qgsd-prompt.js') }]
+      });
+      console.log(`  ${green}✓${reset} Configured nForma quorum injection hook (UserPromptSubmit)`);
+    }
+
+    // Register nForma Stop hook (quorum gate — verifies quorum evidence before Claude delivers planning output)
+    if (!settings.hooks.Stop) settings.hooks.Stop = [];
+    const hasQgsdStopHook = settings.hooks.Stop.some(entry =>
+      entry.hooks && entry.hooks.some(h => h.command && h.command.includes('qgsd-stop'))
+    );
+    if (!hasQgsdStopHook) {
+      settings.hooks.Stop.push({
+        hooks: [{ type: 'command', command: buildHookCommand(targetDir, 'qgsd-stop.js'), timeout: 30 }]
+      });
+      console.log(`  ${green}✓${reset} Configured nForma quorum gate hook (Stop)`);
+    }
+
+    // INST-08: Register nForma circuit breaker hook (PreToolUse — Claude Code only)
+    if (!settings.hooks.PreToolUse) settings.hooks.PreToolUse = [];
+    const hasCircuitBreakerHook = settings.hooks.PreToolUse.some(entry =>
+      entry.hooks && entry.hooks.some(h => h.command && h.command.includes('qgsd-circuit-breaker'))
+    );
+    if (!hasCircuitBreakerHook) {
+      settings.hooks.PreToolUse.push({
+        hooks: [{ type: 'command', command: buildHookCommand(targetDir, 'qgsd-circuit-breaker.js'), timeout: 10 }]
+      });
+      console.log(`  ${green}✓${reset} Configured nForma circuit breaker hook (PreToolUse)`);
+    }
+
+    // Register nForma context monitor hook (PostToolUse — context window warnings)
+    if (!settings.hooks.PostToolUse) settings.hooks.PostToolUse = [];
+    const hasContextMonitorHook = settings.hooks.PostToolUse.some(entry =>
+      entry.hooks && entry.hooks.some(h => h.command && h.command.includes('gsd-context-monitor'))
+    );
+    if (!hasContextMonitorHook) {
+      settings.hooks.PostToolUse.push({
+        hooks: [{ type: 'command', command: buildHookCommand(targetDir, 'gsd-context-monitor.js') }]
+      });
+      console.log(`  ${green}✓${reset} Configured nForma context monitor hook (PostToolUse)`);
+    }
+
+    // Register nForma spec-regen hook (PostToolUse — auto-regenerate specs on machine file write)
+    if (!settings.hooks.PostToolUse) settings.hooks.PostToolUse = [];
+    const hasSpecRegenHook = settings.hooks.PostToolUse.some(entry =>
+      entry.hooks && entry.hooks.some(h => h.command && h.command.includes('qgsd-spec-regen'))
+    );
+    if (!hasSpecRegenHook) {
+      settings.hooks.PostToolUse.push({
+        hooks: [{ type: 'command', command: buildHookCommand(targetDir, 'qgsd-spec-regen.js') }]
+      });
+      console.log(`  ${green}✓${reset} Configured nForma spec-regen hook (PostToolUse)`);
+    }
+
+    // Register nForma PreCompact hook (phase state injection at compaction time)
+    if (!settings.hooks.PreCompact) settings.hooks.PreCompact = [];
+    const hasPreCompactHook = settings.hooks.PreCompact.some(entry =>
+      entry.hooks && entry.hooks.some(h => h.command && h.command.includes('qgsd-precompact'))
+    );
+    if (!hasPreCompactHook) {
+      settings.hooks.PreCompact.push({
+        hooks: [{ type: 'command', command: buildHookCommand(targetDir, 'qgsd-precompact.js') }]
+      });
+      console.log(`  ${green}✓${reset} Configured nForma PreCompact hook (phase state injection)`);
+    }
+
+    // Register nForma token collector hook (SubagentStop — logs per-slot token usage)
+    if (!settings.hooks.SubagentStop) settings.hooks.SubagentStop = [];
+    const hasTokenCollectorHook = settings.hooks.SubagentStop.some(entry =>
+      entry.hooks && entry.hooks.some(h => h.command && h.command.includes('qgsd-token-collector'))
+    );
+    if (!hasTokenCollectorHook) {
+      settings.hooks.SubagentStop.push({
+        matcher: 'qgsd-quorum-slot-worker',
+        hooks: [{ type: 'command', command: buildHookCommand(targetDir, 'qgsd-token-collector.js'), async: true }]
+      });
+      console.log(`  ${green}✓${reset} Configured nForma token collector hook (SubagentStop)`);
+    }
+
+    // Register nForma slot correlator hook (SubagentStart — writes agent_id correlation file)
+    if (!settings.hooks.SubagentStart) settings.hooks.SubagentStart = [];
+    const hasSlotCorrelatorHook = settings.hooks.SubagentStart.some(entry =>
+      entry.hooks && entry.hooks.some(h => h.command && h.command.includes('qgsd-slot-correlator'))
+    );
+    if (!hasSlotCorrelatorHook) {
+      settings.hooks.SubagentStart.push({
+        matcher: 'qgsd-quorum-slot-worker',
+        hooks: [{ type: 'command', command: buildHookCommand(targetDir, 'qgsd-slot-correlator.js'), async: true }]
+      });
+      console.log(`  ${green}✓${reset} Configured nForma slot correlator hook (SubagentStart)`);
+    }
+
+    // Write nForma config — skip if exists unless --redetect-mcps flag set
+    const qgsdConfigPath = path.join(targetDir, 'qgsd.json');
+
+    // --redetect-mcps: delete existing config so fresh detection runs below
+    if (hasRedetectMcps && fs.existsSync(qgsdConfigPath)) {
+      fs.unlinkSync(qgsdConfigPath);
+      console.log(`  ${cyan}◆${reset} Re-detecting MCP prefixes (--redetect-mcps)...`);
+    }
+
+    if (!fs.existsSync(qgsdConfigPath)) {
+      // Build config with auto-detected MCP prefixes
+      const detectedModels = buildRequiredModelsFromMcp();
+      const qgsdConfig = {
+        quorum_commands: [
+          'plan-phase', 'new-project', 'new-milestone',
+          'discuss-phase', 'verify-work', 'research-phase',
+        ],
+        fail_mode: 'open',
+        required_models: detectedModels,
+        quorum_active: buildActiveSlots(),   // COMP-04: populated from all discovered slots
+        // Generated from detected prefixes — behavioral instructions match structural enforcement
+        quorum_instructions: buildQuorumInstructions(detectedModels),
+        // INST-09: Must match DEFAULT_CONFIG.circuit_breaker in hooks/config-loader.js
+        circuit_breaker: {
+          oscillation_depth: 3,
+          commit_window: 6,
+        },
+      };
+
+      fs.writeFileSync(qgsdConfigPath, JSON.stringify(qgsdConfig, null, 2) + '\n', 'utf8');
+      console.log(`  ${green}✓${reset} Wrote nForma config with detected MCP prefixes (~/.claude/qgsd.json)`);
+      console.log(`  ${green}✓${reset} Wrote quorum_active (${qgsdConfig.quorum_active.length} slots) to qgsd.json`);
+    } else {
+      // INST-06: print active config summary on reinstall
+      try {
+        const existingConfig = JSON.parse(fs.readFileSync(qgsdConfigPath, 'utf8'));
+        const models = existingConfig.required_models || {};
+        const summary = Object.entries(models)
+          .map(([key, def]) => `${key} → ${def.tool_prefix || '(unset)'}`)
+          .join(', ');
+        console.log(`  ${dim}↳ ~/.claude/qgsd.json exists — active config: ${summary}${reset}`);
+        console.log(`  ${dim}  (run with --redetect-mcps to refresh MCP prefix detection)${reset}`);
+
+        // INST-10: Add missing circuit_breaker block or missing sub-keys without touching existing user values
+        if (!existingConfig.circuit_breaker) {
+          existingConfig.circuit_breaker = { oscillation_depth: 3, commit_window: 6 };
+          fs.writeFileSync(qgsdConfigPath, JSON.stringify(existingConfig, null, 2) + '\n', 'utf8');
+          console.log(`  ${green}✓${reset} Added circuit_breaker config block to qgsd.json`);
+        } else {
+          // Backfill individual missing sub-keys without touching values the user has set
+          let subKeyAdded = false;
+          if (existingConfig.circuit_breaker.oscillation_depth === undefined) {
+            existingConfig.circuit_breaker.oscillation_depth = 3;
+            subKeyAdded = true;
+          }
+          if (existingConfig.circuit_breaker.commit_window === undefined) {
+            existingConfig.circuit_breaker.commit_window = 6;
+            subKeyAdded = true;
+          }
+          if (subKeyAdded) {
+            fs.writeFileSync(qgsdConfigPath, JSON.stringify(existingConfig, null, 2) + '\n', 'utf8');
+            console.log(`  ${green}✓${reset} Added missing circuit_breaker sub-keys to qgsd.json`);
+          }
+        }
+
+        // COMP-04: Backfill quorum_active if absent or empty (same pattern as circuit_breaker backfill)
+        if (!existingConfig.quorum_active || existingConfig.quorum_active.length === 0) {
+          const discoveredSlots = buildActiveSlots();
+          if (discoveredSlots.length > 0) {
+            existingConfig.quorum_active = discoveredSlots;
+            fs.writeFileSync(qgsdConfigPath, JSON.stringify(existingConfig, null, 2) + '\n', 'utf8');
+            console.log(`  ${green}✓${reset} Backfilled quorum_active (${discoveredSlots.length} slots) in qgsd.json`);
+          }
+        }
+
+        // MULTI-03: Incremental quorum_active update — append new slots discovered since last install
+        // Only runs if quorum_active is already set (non-empty); new slots are appended, existing preserved
+        if (existingConfig.quorum_active && existingConfig.quorum_active.length > 0) {
+          const { addSlotToQuorumActive } = require('./migrate-to-slots.cjs');
+          const allCurrentSlots = buildActiveSlots();
+          const newSlots = allCurrentSlots.filter(s => !existingConfig.quorum_active.includes(s));
+          for (const newSlot of newSlots) {
+            const result = addSlotToQuorumActive(newSlot, qgsdConfigPath);
+            if (result.added) {
+              console.log(`  ${green}✓${reset} Added new slot to quorum_active: ${newSlot}`);
+              existingConfig.quorum_active.push(newSlot); // keep in-memory copy consistent
+            }
+          }
+        }
+        // If quorum_active is already set and non-empty: do NOT overwrite (user config preserved)
+      } catch {
+        console.log(`  ${dim}↳ ~/.claude/qgsd.json already exists — skipping (user config preserved)${reset}`);
+      }
+    }
+  }
+
+  // Write file manifest for future modification detection
+  writeManifest(targetDir);
+  console.log(`  ${green}✓${reset} Wrote file manifest (${MANIFEST_NAME})`);
+
+  // Report any backed-up local patches
+  reportLocalPatches(targetDir);
+
+  return { settingsPath, settings, statuslineCommand, runtime };
+}
+
+/**
+ * Apply statusline config, then print completion message
+ */
+function finishInstall(settingsPath, settings, statuslineCommand, shouldInstallStatusline, runtime = 'claude', isGlobal = true) {
+  const isOpencode = runtime === 'opencode';
+
+  if (shouldInstallStatusline && !isOpencode) {
+    settings.statusLine = {
+      type: 'command',
+      command: statuslineCommand
+    };
+    console.log(`  ${green}✓${reset} Configured statusline`);
+  }
+
+  // Always write settings
+  writeSettings(settingsPath, settings);
+
+  // Configure OpenCode permissions
+  if (isOpencode) {
+    configureOpencodePermissions(isGlobal);
+  }
+
+  let program = 'Claude Code';
+  if (runtime === 'opencode') program = 'OpenCode';
+  if (runtime === 'gemini') program = 'Gemini';
+
+  const command = isOpencode ? '/qgsd-help' : '/qgsd:help';
+
+  let nudge = '';
+  if (runtime === 'claude' && !hasClaudeMcpAgents()) {
+    nudge = `\n  ${yellow}⚠${reset} No quorum agents configured.\n    Run ${cyan}/qgsd:mcp-setup${reset} in Claude Code to set up your agents.\n`;
+  }
+
+  console.log(`
+  ${green}Done!${reset} Launch ${program} and run ${cyan}${command}${reset}.
+${nudge}
+  ${cyan}Join the community:${reset} https://discord.gg/5JJgD5svVS
+`);
+
+  // Best-effort formal tools — always runs after success banner, never blocks main install
+  if (!hasUninstall && !hasFormal) {
+    const { spawnSync: _formalSpawn } = require('child_process');
+    const formalScript = path.join(__dirname, 'install-formal-tools.cjs');
+    if (fs.existsSync(formalScript)) {
+      console.log('  Formal verification tools:');
+      _formalSpawn(process.execPath, [formalScript], { stdio: 'inherit' });
+      // exit code ignored — best-effort
+    }
+  }
+}
+
+/**
+ * Handle statusline configuration with optional prompt
+ */
+function handleStatusline(settings, isInteractive, callback) {
+  const hasExisting = settings.statusLine != null;
+
+  if (!hasExisting) {
+    callback(true);
+    return;
+  }
+
+  if (forceStatusline) {
+    callback(true);
+    return;
+  }
+
+  if (!isInteractive) {
+    console.log(`  ${yellow}⚠${reset} Skipping statusline (already configured)`);
+    console.log(`    Use ${cyan}--force-statusline${reset} to replace\n`);
+    callback(false);
+    return;
+  }
+
+  const existingCmd = settings.statusLine.command || settings.statusLine.url || '(custom)';
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  console.log(`
+  ${yellow}⚠${reset} Existing statusline detected\n
+  Your current statusline:
+    ${dim}command: ${existingCmd}${reset}
+
+  nForma includes a statusline showing:
+    • Model name
+    • Current task (from todo list)
+    • Context window usage (color-coded)
+
+  ${cyan}1${reset}) Keep existing
+  ${cyan}2${reset}) Replace with nForma statusline
+`);
+
+  rl.question(`  Choice ${dim}[1]${reset}: `, (answer) => {
+    rl.close();
+    const choice = answer.trim() || '1';
+    callback(choice === '2');
+  });
+}
+
+/**
+ * Prompt for runtime selection
+ */
+function promptRuntime(callback) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  let answered = false;
+
+  rl.on('close', () => {
+    if (!answered) {
+      answered = true;
+      console.log(`\n  ${yellow}Installation cancelled${reset}\n`);
+      process.exit(0);
+    }
+  });
+
+  console.log(`  ${yellow}Which runtime(s) would you like to install for?${reset}\n\n  ${cyan}1${reset}) Claude Code ${dim}(~/.claude)${reset}
+  ${cyan}2${reset}) OpenCode    ${dim}(~/.config/opencode)${reset} - open source, free models
+  ${cyan}3${reset}) Gemini      ${dim}(~/.gemini)${reset}
+  ${cyan}4${reset}) All
+`);
+
+  rl.question(`  Choice ${dim}[1]${reset}: `, (answer) => {
+    answered = true;
+    rl.close();
+    const choice = answer.trim() || '1';
+    if (choice === '4') {
+      callback(['claude', 'opencode', 'gemini']);
+    } else if (choice === '3') {
+      callback(['gemini']);
+    } else if (choice === '2') {
+      callback(['opencode']);
+    } else {
+      callback(['claude']);
+    }
+  });
+}
+
+/**
+ * Prompt for install location
+ */
+function promptLocation(runtimes) {
+  if (!process.stdin.isTTY) {
+    console.log(`  ${yellow}Non-interactive terminal detected, defaulting to global install${reset}\n`);
+    installAllRuntimes(runtimes, true, false);
+    return;
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  let answered = false;
+
+  rl.on('close', () => {
+    if (!answered) {
+      answered = true;
+      console.log(`\n  ${yellow}Installation cancelled${reset}\n`);
+      process.exit(0);
+    }
+  });
+
+  const pathExamples = runtimes.map(r => {
+    const globalPath = getGlobalDir(r, explicitConfigDir);
+    return globalPath.replace(os.homedir(), '~');
+  }).join(', ');
+
+  const localExamples = runtimes.map(r => `./${getDirName(r)}`).join(', ');
+
+  console.log(`  ${yellow}Where would you like to install?${reset}\n\n  ${cyan}1${reset}) Global ${dim}(${pathExamples})${reset} - available in all projects
+  ${cyan}2${reset}) Local  ${dim}(${localExamples})${reset} - this project only
+`);
+
+  rl.question(`  Choice ${dim}[1]${reset}: `, (answer) => {
+    answered = true;
+    rl.close();
+    const choice = answer.trim() || '1';
+    const isGlobal = choice !== '2';
+    installAllRuntimes(runtimes, isGlobal, true);
+  });
+}
+
+/**
+ * Install GSD for all selected runtimes
+ */
+function installAllRuntimes(runtimes, isGlobal, isInteractive) {
+  const results = [];
+
+  for (const runtime of runtimes) {
+    const result = install(isGlobal, runtime);
+    results.push(result);
+  }
+
+  // Handle statusline for Claude & Gemini (OpenCode uses themes)
+  const claudeResult = results.find(r => r.runtime === 'claude');
+  const geminiResult = results.find(r => r.runtime === 'gemini');
+
+  // Logic: if both are present, ask once if interactive? Or ask for each?
+  // Simpler: Ask once and apply to both if applicable.
+  
+  if (claudeResult || geminiResult) {
+    // Use whichever settings exist to check for existing statusline
+    const primaryResult = claudeResult || geminiResult;
+    
+    handleStatusline(primaryResult.settings, isInteractive, (shouldInstallStatusline) => {
+      if (claudeResult) {
+        finishInstall(claudeResult.settingsPath, claudeResult.settings, claudeResult.statuslineCommand, shouldInstallStatusline, 'claude', isGlobal);
+      }
+      if (geminiResult) {
+         finishInstall(geminiResult.settingsPath, geminiResult.settings, geminiResult.statuslineCommand, shouldInstallStatusline, 'gemini', isGlobal);
+      }
+
+      const opencodeResult = results.find(r => r.runtime === 'opencode');
+      if (opencodeResult) {
+        finishInstall(opencodeResult.settingsPath, opencodeResult.settings, opencodeResult.statuslineCommand, false, 'opencode', isGlobal);
+      }
+    });
+  } else {
+    // Only OpenCode
+    const opencodeResult = results[0];
+    finishInstall(opencodeResult.settingsPath, opencodeResult.settings, opencodeResult.statuslineCommand, false, 'opencode', isGlobal);
+  }
+}
+
+// RECV-01: --reset-breaker clears project-relative circuit breaker state and exits before any install logic
+if (hasResetBreaker) {
+  const { spawnSync } = require('child_process');
+  const gitResult = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+    cwd: process.cwd(),
+    encoding: 'utf8',
+    timeout: 5000,
+  });
+  const projectRoot = (gitResult.status === 0 && !gitResult.error)
+    ? gitResult.stdout.trim()
+    : process.cwd();
+  const stateFile = path.join(projectRoot, '.claude', 'circuit-breaker-state.json');
+  if (fs.existsSync(stateFile)) {
+    fs.rmSync(stateFile);
+    console.log(`  ${green}✓${reset} Circuit breaker state cleared. Claude can resume Bash execution.`);
+    console.log(`    Removed: ${stateFile.replace(os.homedir(), '~')}`);
+  } else {
+    console.log(`  ${dim}No active circuit breaker state found at ${stateFile.replace(os.homedir(), '~')}${reset}`);
+  }
+  // Stamp manualResetAt on all active oscillation-log.json entries
+  const oscLogFile = path.join(projectRoot, '.planning', 'oscillation-log.json');
+  if (fs.existsSync(oscLogFile)) {
+    try {
+      const oscLog = JSON.parse(fs.readFileSync(oscLogFile, 'utf8'));
+      const now = new Date().toISOString();
+      let touched = 0;
+      for (const key of Object.keys(oscLog)) {
+        if (!oscLog[key].resolvedAt) {
+          oscLog[key].manualResetAt = now;
+          touched++;
+        }
+      }
+      fs.writeFileSync(oscLogFile, JSON.stringify(oscLog, null, 2), 'utf8');
+      if (touched > 0) {
+        console.log(`  ${green}✓${reset} Stamped manualResetAt on ${touched} active oscillation log entr${touched === 1 ? 'y' : 'ies'}.`);
+      }
+    } catch (e) {
+      console.log(`  ${dim}Could not update oscillation log: ${e.message}${reset}`);
+    }
+  }
+  process.exit(0);
+}
+
+// DISABLE-01: --disable-breaker pauses circuit breaker enforcement without resetting detection
+if (hasDisableBreaker) {
+  const { spawnSync } = require('child_process');
+  const gitResult = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+    cwd: process.cwd(),
+    encoding: 'utf8',
+    timeout: 5000,
+  });
+  const projectRoot = (gitResult.status === 0 && !gitResult.error)
+    ? gitResult.stdout.trim()
+    : process.cwd();
+  const stateFile = path.join(projectRoot, '.claude', 'circuit-breaker-state.json');
+  fs.mkdirSync(path.dirname(stateFile), { recursive: true });
+  const existing = fs.existsSync(stateFile)
+    ? JSON.parse(fs.readFileSync(stateFile, 'utf8'))
+    : {};
+  fs.writeFileSync(stateFile, JSON.stringify({ ...existing, disabled: true, active: false }, null, 2), 'utf8');
+  console.log(`  ${yellow}⊘${reset} Circuit breaker ${yellow}disabled${reset}. Detection and enforcement paused.`);
+  console.log(`    Run ${cyan}npx qgsd --enable-breaker${reset} to resume.`);
+  process.exit(0);
+}
+
+// DISABLE-02: --enable-breaker resumes circuit breaker enforcement
+if (hasEnableBreaker) {
+  const { spawnSync } = require('child_process');
+  const gitResult = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+    cwd: process.cwd(),
+    encoding: 'utf8',
+    timeout: 5000,
+  });
+  const projectRoot = (gitResult.status === 0 && !gitResult.error)
+    ? gitResult.stdout.trim()
+    : process.cwd();
+  const stateFile = path.join(projectRoot, '.claude', 'circuit-breaker-state.json');
+  if (fs.existsSync(stateFile)) {
+    const existing = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+    fs.writeFileSync(stateFile, JSON.stringify({ ...existing, disabled: false, active: false }, null, 2), 'utf8');
+  }
+  // If no state file, nothing to do — circuit breaker is already effectively enabled
+  console.log(`  ${green}✓${reset} Circuit breaker ${green}enabled${reset}. Oscillation detection resumed.`);
+  process.exit(0);
+}
+
+// SLOT-02: --migrate-slots renames mcpServers keys and patches qgsd.json tool_prefix values
+if (hasMigrateSlots) {
+  const { migrateClaudeJson, migrateQgsdJson } = require('./migrate-to-slots.cjs');
+  const claudeJsonPath = path.join(os.homedir(), '.claude.json');
+  const qgsdJsonPath = path.join(os.homedir(), '.claude', 'qgsd.json');
+  const dryRun = args.includes('--dry-run');
+  const r1 = migrateClaudeJson(claudeJsonPath, dryRun);
+  const r2 = migrateQgsdJson(qgsdJsonPath, dryRun);
+  if (r1.changed === 0 && r2.changed === 0) {
+    console.log(`  ${green}✓${reset} Already migrated — no changes needed`);
+  } else {
+    if (r1.changed > 0) {
+      console.log(`  ${green}✓${reset} Migrated ${r1.changed} mcpServers entries:`);
+      r1.renamed.forEach(r => console.log(`      ${r.from} → ${r.to}`));
+    }
+    if (r2.changed > 0) {
+      console.log(`  ${green}✓${reset} Patched ${r2.changed} qgsd.json tool_prefix values`);
+    }
+  }
+  process.exit(0);
+}
+
+if (hasFormal) {
+  const { spawnSync } = require('child_process');
+  const formalScript = path.join(__dirname, 'install-formal-tools.cjs');
+  const result = spawnSync(process.execPath, [formalScript], { stdio: 'inherit' });
+  process.exit(result.status ?? 0);
+}
+
+// Main logic
+if (hasGlobal && hasLocal) {
+  console.error(`  ${yellow}Cannot specify both --global and --local${reset}`);
+  process.exit(1);
+} else if (explicitConfigDir && hasLocal) {
+  console.error(`  ${yellow}Cannot use --config-dir with --local${reset}`);
+  process.exit(1);
+} else if (hasUninstall) {
+  if (!hasGlobal && !hasLocal) {
+    console.error(`  ${yellow}--uninstall requires --global or --local${reset}`);
+    process.exit(1);
+  }
+  const runtimes = selectedRuntimes.length > 0 ? selectedRuntimes : ['claude'];
+  for (const runtime of runtimes) {
+    uninstall(hasGlobal, runtime);
+  }
+} else if (selectedRuntimes.length > 0) {
+  if (!hasGlobal && !hasLocal) {
+    promptLocation(selectedRuntimes);
+  } else {
+    installAllRuntimes(selectedRuntimes, hasGlobal, false);
+  }
+} else if (hasGlobal || hasLocal) {
+  // Default to Claude if no runtime specified but location is
+  installAllRuntimes(['claude'], hasGlobal, false);
+} else {
+  // Interactive
+  if (!process.stdin.isTTY) {
+    console.log(`  ${yellow}Non-interactive terminal detected, defaulting to Claude Code global install${reset}\n`);
+    installAllRuntimes(['claude'], true, false);
+  } else {
+    promptRuntime((runtimes) => {
+      promptLocation(runtimes);
+    });
+  }
+}