harness-everything 0.16.4 → 0.16.5

package/plugins/harness-everything/scripts/installer.js

@@ -0,0 +1,629 @@
+#!/usr/bin/env node
+/**
+ * Lightweight, non-intrusive installer for Harness OS.
+ * Detects the local project layout (Claude Code, Cursor, etc.)
+ * and merges the Harness hook definitions safely without destroying user configs.
+ *
+ * Placement rule: a platform's own native file/folder (`.claude/settings.json`,
+ * `.cursorrules`, `.cursor/skills/`, etc.) is never moved - it lives exactly
+ * where that platform expects it. Anything Harness itself needs that has no
+ * native home (install manifest, runtime hook state, and - only for Claude,
+ * which has no native project-skill directory - the installed skill copies)
+ * converges into one exclusively-owned subfolder per platform:
+ * `<platform-dir>/harness-everything/`. Nothing else ever creates a directory
+ * literally named "harness-everything", so it can be added or removed as a
+ * unit without touching anything else in that platform's directory.
+ *
+ * This file only orchestrates the install/uninstall flow (CLI parsing,
+ * interactive prompts, sequencing). Each concern it delegates to lives in
+ * scripts/lib/: skill discovery & manifest-tracked install/removal
+ * (lib/skills.js, lib/manifest.js), Claude Code hook merge/removal
+ * (lib/claude-hooks.js), advisory-file injection for hookless platforms
+ * (lib/advisory-text.js), .gitignore/empty-dir housekeeping (lib/gitignore.js),
+ * and the terminal picker widgets (lib/prompts.js).
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { getWorkspaceRoot, getWorkspaceStateDir, getUserPromptsDir } = require('./lib/workspace');
+const { interactiveSelect, interactiveSingleSelect, askQuestion } = require('./lib/prompts');
+const advisory = require('./lib/advisory-text');
+const claudeHooks = require('./lib/claude-hooks');
+const manifest = require('./lib/manifest');
+const skills = require('./lib/skills');
+const { ensureWorkspaceGitignorePatterns, removeWorkspaceExcludePatterns, cleanEmptyDirs } = require('./lib/gitignore');
+
+const userHome = require('os').homedir();
+const detectedWorkspaceRoot = getWorkspaceRoot();
+// Global installs are valid outside a repository, but the module still needs
+// a non-null path while it evaluates local-detection helpers. Keep this
+// fallback private to global mode; main() rejects non-global work from a
+// directory whose workspace identity cannot be resolved.
+const workspaceRoot = detectedWorkspaceRoot || path.resolve(process.cwd());
+const harnessPackageRoot = path.resolve(__dirname, '..');
+const harnessSourceDir = fs.existsSync(path.join(harnessPackageRoot, 'plugin.json')) &&
+  fs.existsSync(path.join(harnessPackageRoot, 'skills'))
+  ? path.join(harnessPackageRoot, 'skills')
+  : harnessPackageRoot;
+const packageManifestPath = fs.existsSync(path.join(harnessPackageRoot, 'package.json'))
+  ? path.join(harnessPackageRoot, 'package.json')
+  : path.join(harnessPackageRoot, 'plugin.json');
+const packageVersion = require(packageManifestPath).version;
+
+let platformModules = [];
+try {
+  platformModules = require(path.join(__dirname, '../hooks/scripts/lib/platforms'));
+} catch (e) {
+  platformModules = []; // Best-effort - gitignore hints and state cleanup degrade gracefully without it.
+}
+
+async function main() {
+  const args = process.argv;
+  const command = args[2] || 'install'; // 'install', 'add', 'skills', etc.
+
+  const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+  const hasClaudeFlag = args.includes('--claude');
+  const hasCursorFlag = args.includes('--cursor');
+  const hasCopilotFlag = args.includes('--copilot');
+  const hasCodexFlag = args.includes('--codex');
+  const hasContinueFlag = args.includes('--continue');
+  const hasHermesFlag = args.includes('--hermes');
+  const hasAllFlag = args.includes('--all');
+  const hasGlobalFlag = args.includes('--global') || args.includes('-g');
+  const hasYesFlag = args.includes('-y') || args.includes('--yes');
+  // Self-heal repair mode: configure the platform touchpoints (advisory text,
+  // hooks settings, gitignore patterns) WITHOUT copying any skills into the
+  // workspace - skill installation is an explicit user choice, never a
+  // side effect of a background repair.
+  const hasNoSkillsFlag = args.includes('--no-skills');
+  if (!detectedWorkspaceRoot && !hasGlobalFlag) {
+    throw new Error('cannot install locally outside a git workspace; pass --global for a user-wide install');
+  }
+  const hasAnyPlatformFlag = hasClaudeFlag || hasCursorFlag || hasCopilotFlag || hasCodexFlag || hasContinueFlag || hasHermesFlag || hasAllFlag;
+  // #49: default 'auto' tries a junction (Windows) / symlink (elsewhere) into
+  // one canonical per-scope copy and silently falls back to an independent
+  // physical copy per target if that fails. --copy/--symlink override the
+  // auto-detection explicitly - --symlink surfaces a link failure as an
+  // error instead of silently falling back, since the user asked for it.
+  const linkMode = args.includes('--copy') ? 'copy' : args.includes('--symlink') ? 'symlink' : 'auto';
+
+  let requestedSkills = ['add', 'skill', 'skills'].includes(command)
+    ? args.slice(3).filter(arg => !arg.startsWith('-'))
+    : [];
+
+  const skillFlagIdx = args.indexOf('--skill') !== -1 ? args.indexOf('--skill') : args.indexOf('--skills');
+  if (skillFlagIdx !== -1 && args[skillFlagIdx + 1] && !args[skillFlagIdx + 1].startsWith('-')) {
+    requestedSkills.push(args[skillFlagIdx + 1]);
+  }
+
+  const claudeExists = fs.existsSync(path.join(workspaceRoot, '.claude'));
+  const cursorExists = fs.existsSync(path.join(workspaceRoot, '.cursorrules'));
+  const copilotExists = fs.existsSync(path.join(workspaceRoot, '.github', 'copilot-instructions.md')) || fs.existsSync(path.join(workspaceRoot, '.github'));
+  const codexExists = fs.existsSync(path.join(workspaceRoot, 'AGENTS.md'));
+  const continueExists = fs.existsSync(path.join(workspaceRoot, '.continue'));
+  const hermesExists = fs.existsSync(path.join(workspaceRoot, '.hermes.md'));
+  const detectedAny = claudeExists || cursorExists || copilotExists || codexExists || continueExists || hermesExists;
+
+  if (command === 'uninstall') {
+    await runUninstall({ hasYesFlag, args, isInteractive });
+    return;
+  }
+
+  let targets = {
+    claude: false,
+    cursor: false,
+    copilot: false,
+    codex: false,
+    continue: false,
+    hermes: false
+  };
+  let chosenSkills = [];
+  let isGlobal = hasGlobalFlag;
+
+  const runInteractively = isInteractive && !hasYesFlag && !hasAnyPlatformFlag && (['install', 'add', 'skill', 'skills'].includes(command) && requestedSkills.length === 0);
+
+  if (runInteractively) {
+    console.log("=================================================");
+    console.log(`          Harness OS - Interactive Setup         `);
+    console.log("=================================================");
+
+    // Step 1: Choose platforms
+    console.log("\n[Step 1/3] Select target platforms to configure:");
+    const platformItems = [
+      { id: 'claude', name: `Claude Code (hook-enforced)  ${claudeExists ? '(Detected)' : ''}`, checked: claudeExists || !detectedAny },
+      { id: 'cursor', name: `Cursor (.cursorrules)          ${cursorExists ? '(Detected)' : ''}`, checked: cursorExists },
+      { id: 'copilot', name: `Copilot (.github/copilot-...)  ${copilotExists ? '(Detected)' : ''}`, checked: copilotExists },
+      { id: 'codex', name: `Codex (AGENTS.md)              ${codexExists ? '(Detected)' : ''}`, checked: codexExists },
+      { id: 'continue', name: `Continue.dev (.continue/rules) ${continueExists ? '(Detected)' : ''}`, checked: continueExists },
+      { id: 'hermes', name: `Hermes Agent (.hermes.md)      ${hermesExists ? '(Detected)' : ''}`, checked: hermesExists }
+    ];
+    const selectedPlatforms = await interactiveSelect(platformItems);
+    selectedPlatforms.forEach(p => {
+      targets[p.id] = p.checked;
+    });
+
+    // Step 2: Choose skills
+    const availableSkills = skills.getAvailableSkills(harnessSourceDir);
+    console.log("\n[Step 2/3] Select skills to install:");
+    const skillItems = availableSkills.map(s => {
+      const info = skills.getSkillInfo(harnessSourceDir, s);
+      // Pre-check all skills (install all by default)
+      const isHarnessEverything = s === 'harness-everything';
+      return {
+        id: s,
+        name: isHarnessEverything ? `${s} (Required)` : s,
+        description: info ? info.description : '',
+        checked: true
+      };
+    });
+    const selectedSkills = await interactiveSelect(skillItems, 8);
+    chosenSkills = selectedSkills.filter(s => s.checked).map(s => s.id);
+
+    // Step 3: Choose global vs local location
+    console.log("\n[Step 3/3] Select installation scope / location:");
+    const locationItems = [
+      { id: 'local', name: "Local Workspace (Install to current project directories)", checked: true },
+      { id: 'global', name: "Global (~/.agents - applies across all projects)", checked: false }
+    ];
+    const chosenLocationId = await interactiveSingleSelect(locationItems);
+    isGlobal = chosenLocationId === 'global';
+  } else {
+    // Non-interactive/bypass mode
+    isGlobal = hasGlobalFlag;
+
+    if (['add', 'skill', 'skills'].includes(command)) {
+      if (requestedSkills.length > 0) {
+        const availableSkills = skills.getAvailableSkills(harnessSourceDir);
+        for (const skillName of requestedSkills) {
+          if (availableSkills.includes(skillName)) {
+            chosenSkills.push(skillName);
+          } else {
+            console.error(`⚠️ Skill "${skillName}" not found. Skipping.`);
+          }
+        }
+      } else {
+        chosenSkills = skills.getAvailableSkills(harnessSourceDir);
+      }
+
+      if (!isGlobal) {
+        targets.claude = claudeExists;
+        targets.cursor = cursorExists;
+        targets.copilot = copilotExists;
+        targets.codex = codexExists;
+        targets.continue = continueExists;
+        targets.hermes = hermesExists;
+        if (!detectedAny) {
+          targets.claude = true;
+        }
+      }
+    } else {
+      if (hasAnyPlatformFlag) {
+        if (hasAllFlag) {
+          targets.claude = true;
+          targets.cursor = true;
+          targets.copilot = true;
+          targets.codex = true;
+          targets.continue = true;
+          targets.hermes = true;
+        } else {
+          targets.claude = hasClaudeFlag;
+          targets.cursor = hasCursorFlag;
+          targets.copilot = hasCopilotFlag;
+          targets.codex = hasCodexFlag;
+          targets.continue = hasContinueFlag;
+          targets.hermes = hasHermesFlag;
+        }
+      } else {
+        if (detectedAny) {
+          targets.claude = claudeExists;
+          targets.cursor = cursorExists;
+          targets.copilot = copilotExists;
+          targets.codex = codexExists;
+          targets.continue = continueExists;
+          targets.hermes = hermesExists;
+        } else {
+          targets.claude = true;
+        }
+      }
+      chosenSkills = hasNoSkillsFlag ? [] : skills.getAvailableSkills(harnessSourceDir);
+    }
+  }
+
+  // Ensure harness-everything is ALWAYS included in chosenSkills
+  if (!hasNoSkillsFlag && !chosenSkills.includes('harness-everything')) {
+    chosenSkills.push('harness-everything');
+  }
+
+  // If no targets selected at all, exit
+  if (!targets.claude && !targets.cursor && !targets.copilot && !targets.codex && !targets.continue && !targets.hermes && !isGlobal) {
+    console.log("\n❌ No platforms selected. Exiting.");
+    process.exit(0);
+  }
+
+  const targetWorkspaceRoot = isGlobal ? path.join(userHome, '.agents') : workspaceRoot;
+
+  console.log("\n-------------------------------------------------");
+  console.log(`Installing Harness OS to ${isGlobal ? 'Global Home' : 'Local Workspace'}`);
+  console.log("-------------------------------------------------");
+
+  for (const platform of platformModules) {
+    if (targets[platform.name] && typeof platform.install === 'function') {
+      platform.install({
+        isGlobal,
+        targetWorkspaceRoot,
+        harnessSourceDir,
+        harnessRuntimeRoot: harnessPackageRoot,
+        packageVersion,
+        getUserPromptsDir,
+        advisory,
+        claudeHooks,
+        manifest,
+        userHome,
+        workspaceRoot
+      });
+    }
+  }
+
+  // Install chosen skills. Every platform's skills stay at that platform's
+  // own native location (unchanged) EXCEPT Claude, which has its copy under
+  // .claude/skills/. Each platform's manifest.json tracks its own.
+  if (chosenSkills.length > 0) {
+    const targetDirs = [];
+    const addedPaths = new Set();
+    for (const platform of platformModules) {
+      // If it's a global install, gather all configured/selected platforms or defaults
+      if (targets[platform.name] || (isGlobal && (targets.claude || targets.cursor || targets.copilot || targets.codex || targets.continue || targets.hermes))) {
+        if (typeof platform.getSkillsTarget === 'function') {
+          const tgt = platform.getSkillsTarget({ workspaceRoot, userHome, isGlobal, manifest });
+          if (tgt && tgt.path && !addedPaths.has(tgt.path)) {
+            targetDirs.push(tgt);
+            addedPaths.add(tgt.path);
+          }
+        }
+      }
+    }
+
+    console.log(`\nInstalling Harness skills:`);
+    const canonicalDir = skills.getCanonicalSkillsDir({ isGlobal, workspaceRoot, userHome });
+    skills.installSkillsToTargets({ chosenSkills, targetDirs, harnessSourceDir, packageVersion, canonicalDir, linkMode });
+
+    // Claude Code discovers named agents from .claude/agents/, not from a
+    // nested skill directory. Keep the source copies in fable-mode for plugin
+    // distribution, and also install them into Claude's native agent folder.
+    if (chosenSkills.includes('fable-mode') && targets.claude) {
+      const claudePlatform = platformModules.find(platform => platform.name === 'claude');
+      if (claudePlatform && typeof claudePlatform.getAgentsTarget === 'function') {
+        const agentTarget = claudePlatform.getAgentsTarget({ workspaceRoot, userHome, isGlobal, manifest });
+        skills.installAgentsToTarget({ target: agentTarget, harnessSourceDir, packageVersion });
+      }
+    }
+  }
+
+  if (!isGlobal) {
+    const patternsToIgnore = [];
+    for (const platform of platformModules) {
+      if (targets[platform.name] && typeof platform.getIgnorePatterns === 'function') {
+        for (const pattern of platform.getIgnorePatterns(workspaceRoot)) {
+          if (!patternsToIgnore.includes(pattern)) {
+            patternsToIgnore.push(pattern);
+          }
+        }
+      }
+    }
+    if (patternsToIgnore.length === 0) {
+      // Fallback if platform modules failed to load entirely.
+      if (targets.claude) patternsToIgnore.push('.claude/harness-everything/');
+      if (targets.cursor) patternsToIgnore.push('.cursor/harness-everything/', '.cursor/skills/');
+      if (targets.copilot) patternsToIgnore.push('.github/harness-everything/', '.github/skills/');
+      if (targets.codex) patternsToIgnore.push('.codex/harness-everything/', '.codex/skills/');
+      if (targets.continue) patternsToIgnore.push('.continue/harness-everything/', '.continue/skills/');
+    }
+
+    // The local canonical skills store (#49) is new territory - .agents/
+    // wasn't previously a Harness-owned local directory - so it needs its
+    // own ignore pattern rather than relying on any platform's own list.
+    if (chosenSkills.length > 0 && linkMode !== 'copy') {
+      const canonicalDir = skills.getCanonicalSkillsDir({ isGlobal: false, workspaceRoot, userHome });
+      if (fs.existsSync(canonicalDir)) {
+        patternsToIgnore.push('.agents/skills/');
+      }
+    }
+
+    ensureWorkspaceGitignorePatterns(workspaceRoot, patternsToIgnore);
+  }
+
+  console.log("\n🎉 INSTALL SUCCESS! Harness OS is now protecting this project.");
+  console.log("Try your first AI interaction! The bootstrapped OS will auto-route your tier.");
+  console.log("=================================================");
+}
+
+async function runUninstall({ hasYesFlag, args, isInteractive }) {
+  const localHarnessDirs = platformModules
+    .filter(p => typeof p.getHarnessDir === 'function')
+    .map(p => p.getHarnessDir(workspaceRoot));
+
+  const localInstalled = fs.existsSync(path.join(workspaceRoot, '.harness')) || // legacy pre-reorg root
+                         localHarnessDirs.some(d => fs.existsSync(d)) ||
+                         fs.existsSync(path.join(workspaceRoot, '.claude', 'settings.json')) ||
+                         fs.existsSync(path.join(workspaceRoot, '.cursorrules')) ||
+                         fs.existsSync(path.join(workspaceRoot, '.github', 'copilot-instructions.md')) ||
+                         fs.existsSync(path.join(workspaceRoot, 'AGENTS.md')) ||
+                         fs.existsSync(path.join(workspaceRoot, '.continue', 'rules', 'harness.md')) ||
+                         fs.existsSync(path.join(workspaceRoot, '.hermes.md'));
+
+  const globalAgentsDir = path.join(userHome, '.agents');
+  const globalHarnessDir = manifest.getHarnessDir(globalAgentsDir);
+  const globalInstalled = fs.existsSync(globalHarnessDir) ||
+                          fs.existsSync(path.join(userHome, '.claude', 'settings.json')) ||
+                          fs.existsSync(path.join(userHome, '.cursorrules')) ||
+                          fs.existsSync(path.join(userHome, '.continue', 'rules', 'harness.md')) ||
+                          fs.existsSync(path.join(getUserPromptsDir(), 'harness.instructions.md')) ||
+                          fs.existsSync(path.join(getUserPromptsDir(), 'harness.agent.md'));
+
+  const installedSkills = skills.getInstalledSkills(workspaceRoot, userHome);
+  const installedAgents = skills.getInstalledAgents(workspaceRoot, userHome);
+
+  console.log("=================================================");
+  console.log(`          Harness OS - Uninstall Utility         `);
+  console.log("=================================================");
+
+  let removeLocal = false;
+  let removeGlobal = false;
+  let removeSkills = false;
+
+  const hasLocalFlag = args.includes('--local');
+  const hasGlobalUninstallFlag = args.includes('--global') || args.includes('-g');
+  const hasSkillsUninstallFlag = args.includes('--skills');
+  // #48: any explicit scope flag wins over the interactive menu, even with a
+  // TTY attached - so `uninstall --local --global --skills` actually does
+  // what it says instead of being silently swapped for the checkbox menu
+  // (where only -y previously had that effect). Only a truly bare `uninstall`
+  // (no flags at all) still goes interactive when a TTY is available.
+  const hasAnyScopeFlag = hasYesFlag || hasLocalFlag || hasGlobalUninstallFlag || hasSkillsUninstallFlag;
+  const runInteractively = isInteractive && !hasAnyScopeFlag;
+
+  if (!runInteractively && !hasAnyScopeFlag) {
+    // #48: no flags AND no interactive terminal to fall back on - this used
+    // to silently do nothing while still printing "UNINSTALL COMPLETE!".
+    // Fail loudly instead so a non-TTY invocation (npx in some shells/CI/
+    // piped input) never looks like a successful no-op.
+    console.error("\n❌ No scope specified and no interactive terminal detected.");
+    console.error("   Pass flags to say what to remove, e.g.:");
+    console.error("     uninstall --local --skills");
+    console.error("     uninstall --local --global --skills -y");
+    console.error("   ...or run this command in an interactive terminal to use the menu.");
+    process.exit(1);
+  }
+
+  if (runInteractively) {
+    const choices = [];
+    if (localInstalled) {
+      choices.push({ id: 'local', name: 'Uninstall Harness OS from Local Workspace (Hooks & Advisory files)', checked: true });
+    }
+    if (globalInstalled) {
+      choices.push({ id: 'global', name: 'Uninstall Harness OS from Global Home (~/.agents, VS Code Prompts, etc.)', checked: false });
+    }
+
+    if (choices.length > 0) {
+      console.log("\nSelect installation scopes to uninstall:");
+      const selectedScopes = await interactiveSelect(choices);
+      removeLocal = selectedScopes.some(s => s.id === 'local' && s.checked);
+      removeGlobal = selectedScopes.some(s => s.id === 'global' && s.checked);
+    } else {
+      console.log("\nNo Harness OS installation detected in local workspace or global home.");
+    }
+
+    if (installedSkills.length > 0) {
+      console.log(`\nDetected ${installedSkills.length} installed skill(s):`);
+      installedSkills.forEach(s => {
+        console.log(`  - ${s.id} (${s.scope})`);
+      });
+
+      console.log("\nWould you like to uninstall these skills?");
+      const skillChoiceItems = [
+        { id: 'all', name: 'Remove ALL detected skills', checked: true },
+        { id: 'select', name: 'Select specific skills to remove', checked: false },
+        { id: 'none', name: 'Keep all skills', checked: false }
+      ];
+      const skillAction = await interactiveSingleSelect(skillChoiceItems);
+
+      if (skillAction === 'all') {
+        removeSkills = true;
+      } else if (skillAction === 'select') {
+        const selectSkillItems = installedSkills.map(s => ({
+          id: s.dirPath,
+          name: `${s.id} (${s.scope})`,
+          checked: true,
+          _entry: s
+        }));
+        const chosenSkillsToRemove = await interactiveSelect(selectSkillItems);
+        for (const item of chosenSkillsToRemove) {
+          if (item.checked) {
+            skills.removeSkill(item._entry, { workspaceRoot, userHome });
+            console.log(`  ✅ Removed skill: ${item.name}`);
+            cleanEmptyDirs(item._entry.parentPath, [workspaceRoot, userHome]);
+          }
+        }
+      }
+    }
+  } else {
+    if (hasYesFlag) {
+      // -y auto-confirms local (cwd-scoped, obviously "this project") but
+      // must NEVER auto-confirm global (~/.agents, ~/.claude, etc.) just
+      // because something global happens to exist - home-directory state
+      // isn't implied by "yes" to the workspace you're standing in, and a
+      // bare `-y` run from any random project must not be able to wipe it.
+      removeLocal = localInstalled;
+      removeGlobal = globalInstalled && hasGlobalUninstallFlag;
+      removeSkills = installedSkills.length > 0;
+    } else {
+      removeLocal = hasLocalFlag;
+      removeGlobal = hasGlobalUninstallFlag;
+      removeSkills = hasSkillsUninstallFlag;
+    }
+  }
+
+  if (removeLocal) {
+    console.log("\n-------------------------------------------------");
+    console.log("Uninstalling Harness OS from Local Workspace...");
+    console.log("-------------------------------------------------");
+
+    for (const platform of platformModules) {
+      if (typeof platform.uninstall === 'function') {
+        platform.uninstall({
+          removeLocal: true,
+          removeGlobal: false,
+          workspaceRoot,
+          userHome,
+          getUserPromptsDir,
+          cleanEmptyDirs,
+          claudeHooks
+        });
+      }
+
+      if (typeof platform.getStateDir === 'function') {
+        // Legacy per-workspace state dir (pre-#42) - almost always already
+        // gone by the time uninstall runs, since the first hook invocation
+        // after the fix migrates it into the global home below. Kept as a
+        // no-op-in-the-common-case safety net for a workspace that was
+        // never actually used since upgrading.
+        const stateDir = platform.getStateDir(workspaceRoot);
+        if (fs.existsSync(stateDir)) {
+          fs.rmSync(stateDir, { recursive: true, force: true });
+          console.log(`  ✅ Removed local ${path.relative(workspaceRoot, stateDir).replace(/\\/g, '/')}/ directory`);
+        }
+      }
+    }
+
+    // Runtime state for this workspace now lives outside it entirely, under
+    // ~/.agents/harness-everything/workspaces/<key>/ (issue #42) - remove
+    // this workspace's slice of it too, so uninstalling doesn't leave an
+    // orphaned global state dir behind.
+    const globalWorkspaceStateDir = getWorkspaceStateDir(workspaceRoot);
+    if (fs.existsSync(globalWorkspaceStateDir)) {
+      fs.rmSync(globalWorkspaceStateDir, { recursive: true, force: true });
+      console.log(`  ✅ Removed global runtime state for this workspace (${globalWorkspaceStateDir})`);
+    }
+
+    // One-time migration cleanup: earlier versions used a self-invented
+    // top-level .harness/ directory for Claude's manifest + skill copies.
+    const legacyHarnessDir = path.join(workspaceRoot, '.harness');
+    if (fs.existsSync(legacyHarnessDir)) {
+      fs.rmSync(legacyHarnessDir, { recursive: true, force: true });
+      console.log(`  ✅ Removed legacy .harness/ directory (superseded by .claude/harness-everything/)`);
+    }
+
+    // Remove Harness's local-only ignore section (.git/info/exclude) and any
+    // legacy banner block older installers appended to the working-tree
+    // .gitignore. Only ever touches Harness-owned lines.
+    removeWorkspaceExcludePatterns(workspaceRoot);
+
+    for (const agent of installedAgents.filter(entry => entry.scope.startsWith('local'))) {
+      skills.removeAgent(agent);
+      console.log(`  ✅ Removed agent: ${agent.filePath}`);
+    }
+    cleanEmptyDirs(path.join(workspaceRoot, '.claude', 'agents'), [workspaceRoot, userHome]);
+  }
+
+  if (removeGlobal) {
+    console.log("\n-------------------------------------------------");
+    console.log("Uninstalling Harness OS from Global Home...");
+    console.log("-------------------------------------------------");
+
+    for (const platform of platformModules) {
+      if (typeof platform.uninstall === 'function') {
+        platform.uninstall({
+          removeLocal: false,
+          removeGlobal: true,
+          workspaceRoot,
+          userHome,
+          getUserPromptsDir,
+          cleanEmptyDirs,
+          claudeHooks
+        });
+      }
+    }
+
+    // ~/.agents is a shared directory - other tools or the user's own files
+    // may live there. Never touch it directly; only clean up the
+    // harness-everything/ subfolder (manifest bookkeeping) and the skills/
+    // subfolder this package exclusively owns, and only once each is
+    // actually empty (manifest.json is removed automatically by the
+    // skills-removal step below once no skills remain in it).
+    cleanEmptyDirs(path.join(globalAgentsDir, 'skills'), [userHome]);
+    cleanEmptyDirs(globalHarnessDir, [userHome]);
+
+    for (const agent of installedAgents.filter(entry => entry.scope.startsWith('global'))) {
+      skills.removeAgent(agent);
+      console.log(`  ✅ Removed agent: ${agent.filePath}`);
+    }
+    cleanEmptyDirs(path.join(userHome, '.claude', 'agents'), [workspaceRoot, userHome]);
+    cleanEmptyDirs(globalHarnessDir, [userHome]);
+  }
+
+  if (removeSkills && installedSkills.length > 0) {
+    // This block is only reached via a bulk "remove everything detected"
+    // path (interactive "all", or the non-interactive -y/--skills bypass) -
+    // never via the interactive per-item picker, which already removes
+    // exactly what the user checked. A bulk sweep must not reach into the
+    // real global home directory unless the user separately opted into
+    // global scope (same rule as the config removal above). Every entry in
+    // `installedSkills` is already manifest-tracked (or, for legacy
+    // installs, author-marker-verified) - see lib/skills.js - so this never
+    // touches a skill Harness didn't install.
+    const skillsToRemove = installedSkills.filter(s => s.scope !== 'global' || removeGlobal);
+    const skippedGlobalCount = installedSkills.length - skillsToRemove.length;
+
+    console.log("\n-------------------------------------------------");
+    console.log("Uninstalling all detected skills...");
+    console.log("-------------------------------------------------");
+    for (const skill of skillsToRemove) {
+      // pathPresent (not bare existsSync) so a dangling link - its canonical
+      // target already gone - still gets its manifest row cleaned up instead
+      // of being silently skipped forever.
+      if (skills.pathPresent(skill.dirPath)) {
+        skills.removeSkill(skill, { workspaceRoot, userHome });
+        console.log(`  ✅ Removed skill: ${skill.id} (${skill.scope})`);
+        cleanEmptyDirs(skill.parentPath, [workspaceRoot, userHome]);
+      }
+    }
+    if (skippedGlobalCount > 0) {
+      console.log(`  ℹ️  Skipped ${skippedGlobalCount} global-scoped skill(s) - pass --global (or select "Uninstall ... Global Home") to remove those too.`);
+    }
+  }
+
+  // Final sweep: a platform's harness-everything/ dir (manifest + Claude's
+  // skill copies) may have only just become empty above - either through the
+  // bulk removeSkills block or the interactive per-item picker, both of
+  // which clean up the skill's own parent dir but not necessarily this one.
+  // Always safe to run unconditionally: cleanEmptyDirs only ever removes a
+  // directory that's genuinely empty.
+  for (const platform of platformModules) {
+    if (typeof platform.getHarnessDir !== 'function') continue;
+    cleanEmptyDirs(platform.getHarnessDir(workspaceRoot), [workspaceRoot, userHome]);
+  }
+  cleanEmptyDirs(path.join(workspaceRoot, '.claude'), [workspaceRoot, userHome]);
+
+  // Canonical skills store (#49) - removeSkill() above already deletes each
+  // now-unreferenced canonical copy as its last link goes; this just tidies
+  // up the now-empty .agents/skills/ (and .agents/ itself, if nothing else
+  // put anything there). Runs here rather than inside the removeLocal/
+  // removeGlobal blocks above because skill removal itself happens later,
+  // in the removeSkills block below those - running any earlier would find
+  // the directory still populated.
+  if (removeLocal) {
+    cleanEmptyDirs(skills.getCanonicalSkillsDir({ isGlobal: false, workspaceRoot, userHome }), [workspaceRoot, userHome]);
+  }
+  if (removeGlobal) {
+    cleanEmptyDirs(skills.getCanonicalSkillsDir({ isGlobal: true, workspaceRoot, userHome }), [userHome]);
+  }
+
+  console.log("\n🎉 UNINSTALL COMPLETE! Harness OS has been removed.");
+  console.log("=================================================");
+}
+
+main().catch(err => {
+  console.error(`\n❌ Install failed: ${err.message}`);
+  process.exit(1);
+});