wtf-p 0.4.0 → 0.5.0

package/bin/uninstall.js

@@ -17,6 +17,7 @@ const {
   prompt,
   VERSION_FILE
 } = require('./lib/utils');
+const MANIFEST = require('./lib/manifest');
 
 // Get version from package.json
 let version = 'unknown';
@@ -32,6 +33,10 @@ try {
 const args = process.argv.slice(2);
 const hasGlobal = args.includes('--global') || args.includes('-g');
 const hasLocal = args.includes('--local') || args.includes('-l');
+const hasClaude = args.includes('--claude');
+const hasGemini = args.includes('--gemini');
+const hasOpenCode = args.includes('--opencode');
+const hasAll = args.includes('--all');
 const hasForce = args.includes('--force') || args.includes('-f');
 const hasBackup = args.includes('--backup') || args.includes('-b');
 const hasDryRun = args.includes('--dry-run') || args.includes('-n');
@@ -86,54 +91,82 @@ if (!hasQuiet) {
 // ============ Help Text ============
 
 if (hasHelp) {
-  console.log(`  ${c.yellow('Usage:')} npx wtf-p-uninstall [options]
+  console.log(`  ${c.yellow('Usage:')} npx wtf-p uninstall [options]
 
   ${c.yellow('Options:')}
-    ${c.cyan('-g, --global')}              Uninstall from Claude config directory
-    ${c.cyan('-l, --local')}               Uninstall from ./.claude in current directory
-    ${c.cyan('-c, --config-dir <path>')}   Specify custom Claude config directory
+    ${c.cyan('-g, --global')}              Uninstall from home directory
+    ${c.cyan('-l, --local')}               Uninstall from current project
+    ${c.cyan('--claude')}                  Uninstall from Claude Code
+    ${c.cyan('--gemini')}                  Uninstall from Gemini CLI
+    ${c.cyan('--opencode')}                Uninstall from OpenCode
+    ${c.cyan('--all')}                     Uninstall from all tools
+    ${c.cyan('-c, --config-dir <path>')}   Uninstall from a custom directory
     ${c.cyan('-f, --force')}               Skip confirmation prompts
     ${c.cyan('-b, --backup')}              Backup files before removing
-    ${c.cyan('-n, --dry-run')}             Show what would be removed without removing
-    ${c.cyan('--clean-backups')}           Also remove .backup-* files from prior installs
+    ${c.cyan('-n, --dry-run')}             Preview what would be removed
+    ${c.cyan('--clean-backups')}           Also remove backup files from prior installs
     ${c.cyan('--no-color')}                Disable colored output
     ${c.cyan('-q, --quiet')}               Suppress non-essential output
-    ${c.cyan('-h, --help')}                Show this help message
+    ${c.cyan('-h, --help')}                Show this help
 
   ${c.yellow('What gets removed:')}
-    ${c.dim('commands/wtfp/')}         - WTF-P slash commands
-    ${c.dim('write-the-f-paper/')}     - WTF-P workflows
-    ${c.dim('skills/wtfp/')}           - WTF-P skills
-    ${c.dim('.claude-plugin/')}        - Plugin manifest
-    ${c.dim('.wtfp-version')}          - Version tracking file
+    ${c.dim('commands/wtfp/')}         Slash commands (/wtfp:*)
+    ${c.dim('write-the-f-paper/')}     Writing system files
+    ${c.dim('agents/wtfp/')}           Agent definitions
+    ${c.dim('skills/wtfp/')}           Skill definitions
+    ${c.dim('.claude-plugin/')}        Plugin manifest
+    ${c.dim('.wtfp-version')}          Version tracking file
 
   ${c.yellow('What stays intact:')}
-    ${c.dim('CLAUDE.md')}               - Your personal instructions (never touched)
-    ${c.dim('commands/')}               - Other slash commands you may have
-    ${c.dim('settings.json')}           - Your Claude settings
-    ${c.dim('Other directories')}       - Any other config or plugins
+    ${c.dim('CLAUDE.md')}               Your personal instructions (never touched)
+    ${c.dim('commands/')}               Other slash commands you added
+    ${c.dim('settings.json')}           Your tool settings
+    ${c.dim('Everything else')}         Nothing outside WTF-P is modified
 
   ${c.yellow('Examples:')}
-    ${c.dim('# Interactive uninstall from ~/.claude')}
-    npx wtf-p-uninstall --global
-
     ${c.dim('# Preview what would be removed')}
-    npx wtf-p-uninstall --global --dry-run
+    npx wtf-p uninstall --global --dry-run
 
-    ${c.dim('# Backup before removing')}
-    npx wtf-p-uninstall --global --backup
+    ${c.dim('# Backup then remove')}
+    npx wtf-p uninstall --global --backup
 
-    ${c.dim('# Also clean up backup files from prior installs')}
-    npx wtf-p-uninstall --global --clean-backups
+    ${c.dim('# Remove from all tools at once')}
+    npx wtf-p uninstall --all
 
-    ${c.dim('# Uninstall from custom location')}
-    npx wtf-p-uninstall --global --config-dir ~/.claude-research
+    ${c.dim('# Also clean up leftover backup files')}
+    npx wtf-p uninstall --global --clean-backups
 `);
   process.exit(0);
 }
 
 // ============ Utilities ============
 
+/**
+ * Get vendor-specific config directory
+ */
+function getVendorDir(runtime, explicitConfigDir) {
+  // Handle 'claude-local' special case
+  if (runtime === 'claude-local') {
+    return path.join(process.cwd(), '.claude');
+  }
+
+  const vendorConfig = MANIFEST[runtime];
+  if (!vendorConfig) {
+    return null;
+  }
+
+  if (explicitConfigDir) {
+    return expandTilde(explicitConfigDir);
+  }
+
+  const envDir = process.env[vendorConfig.configDirEnv];
+  if (envDir) {
+    return expandTilde(envDir);
+  }
+
+  return path.join(os.homedir(), vendorConfig.defaultDir);
+}
+
 /**
  * Generate backup directory path with timestamp
  */
@@ -192,28 +225,39 @@ function findBackupFiles(dir, backups = []) {
 // ============ Uninstall Logic ============
 
 /**
- * Uninstall from the specified directory
+ * Uninstall from the specified runtime
+ * @param {string} runtime - 'claude' | 'gemini' | 'opencode' | 'claude-local'
  */
-async function uninstall(isGlobal) {
-  const claudeDir = getClaudeDir(explicitConfigDir, isGlobal);
-  const locationLabel = getPathLabel(claudeDir, isGlobal);
+async function uninstall(runtime) {
+  const isLocal = runtime === 'claude-local';
+  const vendorKey = isLocal ? 'claude' : runtime;
+  const vendorConfig = MANIFEST[vendorKey];
+
+  if (!vendorConfig) {
+    out.error(`Unknown runtime: ${runtime}`);
+    return;
+  }
+
+  const targetDir = getVendorDir(runtime, explicitConfigDir);
+  const locationLabel = getPathLabel(targetDir, !isLocal);
 
   out.log(`  Checking ${c.cyan(locationLabel)} for WTF-P installation...\n`);
 
   // Detect installation
-  const installed = detectInstallation(claudeDir);
-  const totalFiles = installed.commandFiles.length + installed.workflowFiles.length + installed.skillFiles.length;
+  const installed = detectInstallation(targetDir);
+  const totalFiles = installed.commandFiles.length + installed.workflowFiles.length + installed.skillFiles.length
+    + (installed.agentFiles || []).length + (installed.mcpFiles || []).length + (installed.binFiles || []).length;
 
   if (!installed.hasCommands && !installed.hasWorkflows && !installed.hasSkills) {
     out.log(`  ${c.yellow('No WTF-P installation found in ' + locationLabel)}\n`);
 
     // Check for backups if requested
     if (hasCleanBackups) {
-      const backups = findBackupFiles(claudeDir);
+      const backups = findBackupFiles(targetDir);
       if (backups.length > 0) {
         out.log(`  Found ${backups.length} backup file(s)/folder(s) to clean:\n`);
         for (const b of backups.slice(0, 10)) {
-          out.log(`    ${c.dim(b.replace(claudeDir, '.'))}`);
+          out.log(`    ${c.dim(b.replace(targetDir, '.'))}`);
         }
         if (backups.length > 10) {
           out.log(`    ${c.dim('... and ' + (backups.length - 10) + ' more')}`);
@@ -237,7 +281,7 @@ async function uninstall(isGlobal) {
             } else {
               fs.unlinkSync(b);
             }
-            out.log(`  ${c.red('-')} ${c.dim(b.replace(claudeDir, '.'))}`);
+            out.log(`  ${c.red('-')} ${c.dim(b.replace(targetDir, '.'))}`);
           }
           out.log(`\n  ${c.green('Cleaned ' + backups.length + ' backup file(s).')}\n`);
         } else {
@@ -253,10 +297,14 @@ async function uninstall(isGlobal) {
   // Show what will be removed
   out.log(`  ${c.yellow('Found WTF-P installation:')}\n`);
 
-  const commandsDir = path.join(claudeDir, 'commands', 'wtfp');
-  const workflowsDir = path.join(claudeDir, 'write-the-f-paper');
-  const skillsDir = path.join(claudeDir, 'skills', 'wtfp');
-  const pluginDir = path.join(claudeDir, '.claude-plugin');
+  const commandsDir = path.join(targetDir, 'commands', 'wtfp');
+  const workflowsDir = path.join(targetDir, 'write-the-f-paper');
+  const skillsDir = path.join(targetDir, 'skills', 'wtfp');
+  const agentsDir = path.join(targetDir, 'agents', 'wtfp');
+  const mcpDir = path.join(targetDir, 'mcp');
+  const binDir = path.join(targetDir, 'bin');
+  const pluginDir = path.join(targetDir, '.claude-plugin');
+  const wtfpPluginFile = path.join(pluginDir, 'plugin.json');
 
   if (installed.hasCommands) {
     out.log(`    ${c.cyan('commands/wtfp/')} (${installed.commandFiles.length} files)`);
@@ -267,8 +315,17 @@ async function uninstall(isGlobal) {
   if (installed.hasSkills) {
     out.log(`    ${c.cyan('skills/wtfp/')} (${installed.skillFiles.length} files)`);
   }
-  if (fs.existsSync(pluginDir)) {
-    out.log(`    ${c.cyan('.claude-plugin/')} (manifest)`);
+  if (fs.existsSync(agentsDir)) {
+    out.log(`    ${c.cyan('agents/wtfp/')} (agent definitions)`);
+  }
+  if (fs.existsSync(mcpDir)) {
+    out.log(`    ${c.cyan('mcp/')} (MCP server)`);
+  }
+  if (fs.existsSync(binDir)) {
+    out.log(`    ${c.cyan('bin/')} (scripts)`);
+  }
+  if (fs.existsSync(wtfpPluginFile)) {
+    out.log(`    ${c.cyan('.claude-plugin/plugin.json')} (WTF-P plugin manifest)`);
   }
   if (installed.version) {
     out.log(`    ${c.cyan(VERSION_FILE)} (version tracking)`);
@@ -278,10 +335,10 @@ async function uninstall(isGlobal) {
   // Check for backups to clean
   let backups = [];
   if (hasCleanBackups) {
-    const allBackups = findBackupFiles(claudeDir);
+    const allBackups = findBackupFiles(targetDir);
     backups = allBackups.filter(b => {
       if (installed.hasCommands && b.startsWith(commandsDir)) return false;
-      if (installed.hasSkill && b.startsWith(skillDir)) return false;
+      if (installed.hasSkills && b.startsWith(skillsDir)) return false;
       return true;
     });
     if (backups.length > 0) {
@@ -310,69 +367,111 @@ async function uninstall(isGlobal) {
 
   // Backup if requested
   if (hasBackup) {
-    const backupDir = getBackupDir(claudeDir);
-    fs.mkdirSync(backupDir, { recursive: true });
+    const backupDirPath = getBackupDir(targetDir);
+    fs.mkdirSync(backupDirPath, { recursive: true });
 
     if (installed.hasCommands) {
-      copyDir(commandsDir, path.join(backupDir, 'commands', 'wtfp'));
+      copyDir(commandsDir, path.join(backupDirPath, 'commands', 'wtfp'));
     }
     if (installed.hasWorkflows) {
-      copyDir(workflowsDir, path.join(backupDir, 'write-the-f-paper'));
+      copyDir(workflowsDir, path.join(backupDirPath, 'write-the-f-paper'));
     }
     if (installed.hasSkills) {
-      copyDir(skillsDir, path.join(backupDir, 'skills', 'wtfp'));
+      copyDir(skillsDir, path.join(backupDirPath, 'skills', 'wtfp'));
     }
-    if (fs.existsSync(pluginDir)) {
-      copyDir(pluginDir, path.join(backupDir, '.claude-plugin'));
+    if (fs.existsSync(agentsDir)) {
+      copyDir(agentsDir, path.join(backupDirPath, 'agents', 'wtfp'));
+    }
+    if (fs.existsSync(mcpDir)) {
+      copyDir(mcpDir, path.join(backupDirPath, 'mcp'));
+    }
+    if (fs.existsSync(binDir)) {
+      copyDir(binDir, path.join(backupDirPath, 'bin'));
+    }
+    if (fs.existsSync(wtfpPluginFile)) {
+      fs.mkdirSync(path.join(backupDirPath, '.claude-plugin'), { recursive: true });
+      fs.copyFileSync(wtfpPluginFile, path.join(backupDirPath, '.claude-plugin', 'plugin.json'));
     }
 
-    const backupLabel = backupDir.replace(os.homedir(), '~').replace(process.cwd(), '.');
+    const backupLabel = backupDirPath.replace(os.homedir(), '~').replace(process.cwd(), '.');
     out.log(`  ${c.cyan('↻')} Backed up to ${c.dim(backupLabel)}\n`);
   }
 
-  // Remove directories
-  if (installed.hasCommands) {
-    removeDir(commandsDir);
-    out.log(`  ${c.red('-')} ${c.dim('commands/wtfp/')}`);
-
-    // Clean up empty commands dir
-    const parentCommandsDir = path.join(claudeDir, 'commands');
-    if (fs.existsSync(parentCommandsDir)) {
-      const remaining = fs.readdirSync(parentCommandsDir);
-      if (remaining.length === 0) {
-        fs.rmdirSync(parentCommandsDir);
-        out.log(`  ${c.red('-')} ${c.dim('commands/')} ${c.dim('(empty)')}`);
-      }
+  // Remove directories — only WTF-P subdirectories, never parent dirs with user content
+
+  // Helper: remove a wtfp subdir and clean up empty parent
+  function removeWtfpSubdir(subdir, parentDir, label) {
+    if (!fs.existsSync(subdir)) return;
+    removeDir(subdir);
+    out.log(`  ${c.red('-')} ${c.dim(label)}`);
+
+    // Clean up parent only if empty (no user content remains)
+    if (parentDir && fs.existsSync(parentDir)) {
+      try {
+        const remaining = fs.readdirSync(parentDir);
+        if (remaining.length === 0) {
+          fs.rmdirSync(parentDir);
+          out.log(`  ${c.red('-')} ${c.dim(path.basename(parentDir) + '/')} ${c.dim('(empty)')}`);
+        }
+      } catch { /* ignore */ }
     }
   }
 
+  if (installed.hasCommands) {
+    removeWtfpSubdir(commandsDir, path.join(targetDir, 'commands'), 'commands/wtfp/');
+  }
+
   if (installed.hasWorkflows) {
     removeDir(workflowsDir);
     out.log(`  ${c.red('-')} ${c.dim('write-the-f-paper/')}`);
   }
 
   if (installed.hasSkills) {
-    removeDir(skillsDir);
-    out.log(`  ${c.red('-')} ${c.dim('skills/wtfp/')}`);
-    
-    // Clean up empty skills dir
-    const parentSkillsDir = path.join(claudeDir, 'skills');
-    if (fs.existsSync(parentSkillsDir)) {
-      const remaining = fs.readdirSync(parentSkillsDir);
-      if (remaining.length === 0) {
-        fs.rmdirSync(parentSkillsDir);
-        out.log(`  ${c.red('-')} ${c.dim('skills/')} ${c.dim('(empty)')}`);
-      }
-    }
+    removeWtfpSubdir(skillsDir, path.join(targetDir, 'skills'), 'skills/wtfp/');
   }
 
-  if (fs.existsSync(pluginDir)) {
-    removeDir(pluginDir);
-    out.log(`  ${c.red('-')} ${c.dim('.claude-plugin/')}`);
+  // Remove agents/wtfp/ (added in v0.5.0)
+  if (fs.existsSync(agentsDir)) {
+    removeWtfpSubdir(agentsDir, path.join(targetDir, 'agents'), 'agents/wtfp/');
+  }
+
+  // Remove mcp/ (WTF-P research server)
+  if (fs.existsSync(mcpDir)) {
+    removeDir(mcpDir);
+    out.log(`  ${c.red('-')} ${c.dim('mcp/')}`);
+  }
+
+  // Remove bin/ (WTF-P scripts installed to config dir)
+  if (fs.existsSync(binDir)) {
+    removeDir(binDir);
+    out.log(`  ${c.red('-')} ${c.dim('bin/')}`);
+  }
+
+  // Remove only WTF-P's plugin.json, not the entire .claude-plugin/ dir
+  // (user may have their own plugin configs there)
+  if (fs.existsSync(wtfpPluginFile)) {
+    try {
+      const pluginData = JSON.parse(fs.readFileSync(wtfpPluginFile, 'utf8'));
+      if (pluginData.name === 'wtf-p' || pluginData.name === 'write-the-f-paper') {
+        fs.unlinkSync(wtfpPluginFile);
+        out.log(`  ${c.red('-')} ${c.dim('.claude-plugin/plugin.json')}`);
+
+        // Only remove .claude-plugin/ if empty after our file is gone
+        try {
+          const remaining = fs.readdirSync(pluginDir);
+          if (remaining.length === 0) {
+            fs.rmdirSync(pluginDir);
+            out.log(`  ${c.red('-')} ${c.dim('.claude-plugin/')} ${c.dim('(empty)')}`);
+          }
+        } catch { /* ignore */ }
+      }
+    } catch {
+      // Can't parse plugin.json — leave it alone for safety
+    }
   }
 
   // Remove version file
-  const versionFile = path.join(claudeDir, VERSION_FILE);
+  const versionFile = path.join(targetDir, VERSION_FILE);
   if (fs.existsSync(versionFile)) {
     fs.unlinkSync(versionFile);
     out.log(`  ${c.red('-')} ${c.dim(VERSION_FILE)}`);
@@ -391,35 +490,48 @@ async function uninstall(isGlobal) {
   }
 
   out.log(`
-  ${c.green('Done!')} WTF-P has been uninstalled.
+  ${c.green('Done!')} WTF-P has been removed from ${vendorConfig.name}.
 
-  ${c.dim('Your CLAUDE.md and other configs remain untouched.')}
+  ${c.dim('Your personal config files were not touched.')}
 
-  To reinstall: ${c.cyan('npx wtf-p --global')}
+  To reinstall later: ${c.cyan('npx wtf-p')}
 `);
 }
 
 /**
- * Prompt for uninstall location
+ * Prompt for uninstall location - shows all runtimes with installation status
  */
 async function promptLocation() {
   const rl = createRL();
 
-  const globalPath = getClaudeDir(explicitConfigDir, true);
-  const globalLabel = getPathLabel(globalPath, true);
-  const localPath = getClaudeDir(null, false);
+  // Check installations for all runtimes
+  const runtimes = Object.keys(MANIFEST);
+  const installations = {};
+  let anyInstalled = false;
+
+  for (const runtime of runtimes) {
+    const targetDir = getVendorDir(runtime, null);
+    const installed = detectInstallation(targetDir);
+    const hasInstall = installed.hasCommands || installed.hasWorkflows || installed.hasSkills;
+    const count = installed.commandFiles.length + installed.workflowFiles.length + installed.skillFiles.length;
+    installations[runtime] = { installed, hasInstall, count, targetDir };
+    if (hasInstall) anyInstalled = true;
+  }
 
-  // Check what's installed where
-  const globalInstalled = detectInstallation(globalPath);
+  // Also check local .claude
+  const localPath = path.join(process.cwd(), '.claude');
   const localInstalled = detectInstallation(localPath);
-
-  const hasGlobalInstall = globalInstalled.hasCommands || globalInstalled.hasWorkflows || globalInstalled.hasSkills;
   const hasLocalInstall = localInstalled.hasCommands || localInstalled.hasWorkflows || localInstalled.hasSkills;
+  const localCount = localInstalled.commandFiles.length + localInstalled.workflowFiles.length + localInstalled.skillFiles.length;
+  if (hasLocalInstall) anyInstalled = true;
 
-  if (!hasGlobalInstall && !hasLocalInstall) {
+  if (!anyInstalled) {
     out.log(`  ${c.yellow('No WTF-P installation found.')}\n`);
     out.log(`  Checked:`);
-    out.log(`    ${c.dim(globalLabel)}`);
+    for (const runtime of runtimes) {
+      const label = getPathLabel(installations[runtime].targetDir, true);
+      out.log(`    ${c.dim(label)}`);
+    }
     out.log(`    ${c.dim('./.claude')}\n`);
     rl.close();
     return;
@@ -427,38 +539,71 @@ async function promptLocation() {
 
   out.log(`  ${c.yellow('Where would you like to uninstall from?')}\n`);
 
-  if (hasGlobalInstall) {
-    const count = globalInstalled.commandFiles.length + globalInstalled.workflowFiles.length + globalInstalled.skillFiles.length;
-    out.log(`  ${c.cyan('1)')} Global ${c.dim('(' + globalLabel + ')')} - ${count} files`);
-  } else {
-    out.log(`  ${c.dim('1) Global (' + globalLabel + ') - not installed')}`);
+  let optionNum = 1;
+  const options = [];
+
+  // Show runtime options
+  for (const runtime of runtimes) {
+    const { hasInstall, count, targetDir } = installations[runtime];
+    const label = getPathLabel(targetDir, true);
+    const vendorName = MANIFEST[runtime].name;
+
+    if (hasInstall) {
+      out.log(`  ${c.cyan(optionNum + ')')} ${vendorName} ${c.dim('(' + label + ')')} - ${count} files`);
+      options.push({ num: optionNum, runtime });
+    } else {
+      out.log(`  ${c.dim(optionNum + ') ' + vendorName + ' (' + label + ') - not installed')}`);
+    }
+    optionNum++;
   }
 
+  // Show local option
   if (hasLocalInstall) {
-    const count = localInstalled.commandFiles.length + localInstalled.workflowFiles.length + localInstalled.skillFiles.length;
-    out.log(`  ${c.cyan('2)')} Local  ${c.dim('(./.claude)')} - ${count} files`);
+    out.log(`  ${c.cyan(optionNum + ')')} Local ${c.dim('(./.claude)')} - ${localCount} files`);
+    options.push({ num: optionNum, runtime: 'claude-local' });
   } else {
-    out.log(`  ${c.dim('2) Local (./.claude) - not installed')}`);
+    out.log(`  ${c.dim(optionNum + ') Local (./.claude) - not installed')}`);
   }
+  optionNum++;
+
+  // Show "all" option if multiple installations
+  const installedCount = options.length;
+  if (installedCount > 1) {
+    out.log(`  ${c.cyan(optionNum + ')')} All installed runtimes`);
+    options.push({ num: optionNum, runtime: 'all-installed' });
+  }
+
   out.log('');
 
   const answer = await prompt(rl, `  Choice: `);
   rl.close();
 
-  if (answer === '1' && hasGlobalInstall) {
-    await uninstall(true);
-  } else if (answer === '2' && hasLocalInstall) {
-    await uninstall(false);
-  } else {
+  const selected = options.find(o => o.num === parseInt(answer, 10));
+
+  if (!selected) {
     out.log(`\n  ${c.yellow('Invalid choice or no installation at that location.')}\n`);
+    return;
+  }
+
+  if (selected.runtime === 'all-installed') {
+    // Uninstall from all installed runtimes
+    for (const opt of options) {
+      if (opt.runtime !== 'all-installed') {
+        await uninstall(opt.runtime);
+      }
+    }
+  } else {
+    await uninstall(selected.runtime);
   }
 }
 
 // ============ Main ============
 
 async function main() {
-  if (hasGlobal && hasLocal) {
-    out.error('Cannot specify both --global and --local');
+  // Validate conflicting flags
+  const runtimeFlags = [hasGlobal, hasLocal, hasClaude, hasGemini, hasOpenCode, hasAll].filter(Boolean).length;
+  if (runtimeFlags > 1 && !hasAll) {
+    out.error('Pick one tool at a time, or use --all to uninstall from everything');
     process.exit(1);
   }
   if (explicitConfigDir && hasLocal) {
@@ -466,11 +611,25 @@ async function main() {
     process.exit(1);
   }
 
-  if (hasGlobal) {
-    await uninstall(true);
+  // Handle --all first
+  if (hasAll) {
+    for (const runtime of Object.keys(MANIFEST)) {
+      await uninstall(runtime);
+    }
+    return;
+  }
+
+  // Handle specific runtime flags
+  if (hasClaude || hasGlobal) {
+    await uninstall('claude');
+  } else if (hasGemini) {
+    await uninstall('gemini');
+  } else if (hasOpenCode) {
+    await uninstall('opencode');
   } else if (hasLocal) {
-    await uninstall(false);
+    await uninstall('claude-local');
   } else {
+    // Interactive mode
     await promptLocation();
   }
 }

package/core/write-the-f-paper/references/agent-model-matrix.md

@@ -0,0 +1,62 @@
+# Agent Model Matrix
+
+Model assignments per agent across quality/balanced/budget profiles. Resolved at runtime from `.planning/config.json` `model_profile` field.
+
+## Lookup Table
+
+| Agent | Role | quality | balanced | budget |
+|-------|------|---------|----------|--------|
+| section-planner | Creates PLAN.md with argument decomposition, word budgets, citation planning | opus | opus | sonnet |
+| plan-checker | Pre-write validation of plans (7 dimensions) | sonnet | sonnet | haiku |
+| section-writer | Executes PLAN.md, writes prose, atomic commits | opus | sonnet | sonnet |
+| argument-verifier | Goal-backward verification of written sections | sonnet | sonnet | haiku |
+| section-reviewer | 3-layer verification with reviewer personas | opus | sonnet | haiku |
+| prose-polisher | De-robotize text, voice adjustment, sentence variety | opus | sonnet | haiku |
+| research-synthesizer | Literature discovery, gap analysis, positioning | opus | sonnet | haiku |
+| citation-expert | Search papers, manage BibTeX, identify gaps | sonnet | sonnet | haiku |
+| citation-formatter | BibTeX validation, formatting, deduplication | sonnet | haiku | haiku |
+| citation-retriever | Literature discovery, BibTeX generation | sonnet | haiku | haiku |
+| coherence-checker | Cross-section coherence, argument flow, terminology consistency | sonnet | sonnet | haiku |
+| outliner | Generates outline.md, argument-map.md, narrative-arc.md from PROJECT.md | opus | sonnet | sonnet |
+
+## Resolution Pattern
+
+```bash
+MODEL_PROFILE=$(cat .planning/config.json 2>/dev/null | \
+  grep -o '"model_profile"[[:space:]]*:[[:space:]]*"[^"]*"' | \
+  grep -o '"[^"]*"$' | tr -d '"' || echo "balanced")
+```
+
+Default: `balanced` when config missing or field absent.
+
+## Orchestrator → Agent Mapping
+
+| Orchestrator Command | Primary Agent | Quality Agent |
+|---------------------|---------------|---------------|
+| /wtfp:plan-section | section-planner | plan-checker |
+| /wtfp:write-section | section-writer | argument-verifier |
+| /wtfp:review-section | section-reviewer | — |
+| /wtfp:polish-prose | prose-polisher | — |
+| /wtfp:research-gap | research-synthesizer | — |
+| /wtfp:analyze-bib | citation-expert | — |
+| /wtfp:check-refs | citation-formatter | — |
+| /wtfp:execute-outline | outliner | coherence-checker |
+| /wtfp:create-outline | outliner | — |
+
+## Profile Selection Guide
+
+**quality** — Use for final drafts, critical sections (introduction, discussion), submission-ready work. Higher token cost, maximum reasoning depth.
+
+**balanced** — Default. Good for most drafting, planning, and revision work. Planner stays at opus for argument quality; writer uses sonnet for cost efficiency.
+
+**budget** — Use for iterative rough drafts, boilerplate sections (acknowledgments, author contributions), or when iterating rapidly. Significantly lower cost.
+
+## Setting Profile
+
+```bash
+# Via config.json
+cat .planning/config.json | jq '.model_profile = "quality"' > tmp && mv tmp .planning/config.json
+
+# Via command
+/wtfp:settings → model_profile → quality|balanced|budget
+```