harness-everything 0.2.1 → 0.3.6

package/hooks/scripts/lib/harness-state.js

@@ -1,228 +1,139 @@
-#!/usr/bin/env node
-// Shared path resolution for Harness runtime state (hook JSON, circuit-breaker
-// counters, handoff/verification timestamps, etc). Lives under the active
-// platform's own harness-everything/ subfolder (see each module's
-// getStateDir() in hooks/scripts/lib/platforms/) - a sibling of that same
-// platform's install manifest, and (for Claude only) its skill copies.
-//
-// For Claude Code that's `<repo root>/.claude/harness-everything/state/`,
-// keyed by session_id under `sessions/<id>/` so two sessions open on the same
-// repo never share (and stomp) each other's edit/verify timestamps or
-// breaker counts. Invocations with no session_id (manual terminal runs,
-// VERIFICATION.md recipes) fall into a fixed `sessions/default/` bucket
-// rather than a random one, so manual testing stays predictable.
-const fs = require('fs');
-const path = require('path');
-
-const CURRENT_SESSION_FILE = 'current-session';
-const DEFAULT_SESSION = 'default';
-
-function getWorkspaceRoot() {
-  let dir = path.resolve(process.cwd());
-  while (dir !== path.parse(dir).root) {
-    if (fs.existsSync(path.join(dir, '.git'))) return dir;
-    dir = path.dirname(dir);
-  }
-  return process.cwd();
-}
-
-function detectActivePlatform(wsRoot) {
-  const root = wsRoot || getWorkspaceRoot();
-  
-  // 1. Check explicit environment variables
-  if (process.env.CLAUDE === '1' || process.env.CLAUDE) return 'claude';
-  if (process.env.CURSOR === '1' || process.env.CURSOR) return 'cursor';
-  if (process.env.COPILOT === '1' || process.env.COPILOT) return 'copilot';
-  if (process.env.CONTINUE === '1' || process.env.CONTINUE) return 'continue';
-  
-  // 2. Check parent/environment standard indicators
-  if (process.env.TERM_PROGRAM === 'vscode') {
-    if (fs.existsSync(path.join(root, '.cursorrules'))) {
-      return 'cursor';
-    }
-    if (fs.existsSync(path.join(root, '.github', 'copilot-instructions.md'))) {
-      return 'copilot';
-    }
-    return 'copilot'; // Default fallback for standard VS Code terminal
-  }
-  
-  // 3. Fallback to detecting workspace configuration presence
-  if (fs.existsSync(path.join(root, '.claude', 'settings.json'))) return 'claude';
-  if (fs.existsSync(path.join(root, '.cursorrules'))) return 'cursor';
-  if (fs.existsSync(path.join(root, '.github', 'copilot-instructions.md'))) return 'copilot';
-  if (fs.existsSync(path.join(root, '.continue'))) return 'continue';
-  if (fs.existsSync(path.join(root, 'AGENTS.md'))) return 'codex';
-  if (fs.existsSync(path.join(root, '.hermes.md'))) return 'hermes';
-  
-  return 'claude'; // Default global fallback
-}
-
-function ensureHarnessStateIgnored(rootPath) {
-  const wsRoot = rootPath || getWorkspaceRoot();
-  const gitignorePath = path.join(wsRoot, '.gitignore');
-  
-  try {
-    let content = '';
-    if (fs.existsSync(gitignorePath)) {
-      content = fs.readFileSync(gitignorePath, 'utf8');
-    }
-    
-    const lines = content.split(/\r?\n/);
-    const patternsToAdd = [];
-    
-    // Load and collect patterns & matching rules dynamically from all platforms
-    const allPlatforms = require('./platforms');
-    const dynamicPatterns = [];
-    const patternToPlatformMap = new Map();
-    
-    // Forcefully ensure active platform's state directory pattern is included
-    const activePlatformName = detectActivePlatform(wsRoot);
-    const activePlatform = allPlatforms.find(p => p.name === activePlatformName) || allPlatforms.find(p => p.name === 'claude');
-    
-    if (activePlatform && typeof activePlatform.getStateDir === 'function') {
-      const activeStateDir = activePlatform.getStateDir(wsRoot);
-      const relativeStateDir = path.relative(wsRoot, activeStateDir).replace(/\\/g, '/') + '/';
-      dynamicPatterns.push(relativeStateDir);
-      patternToPlatformMap.set(relativeStateDir, activePlatform);
-    }
-    
-    for (const platform of allPlatforms) {
-      const patterns = platform.getIgnorePatterns(wsRoot);
-      for (const pattern of patterns) {
-        if (!dynamicPatterns.includes(pattern)) {
-          dynamicPatterns.push(pattern);
-        }
-        patternToPlatformMap.set(pattern, platform);
-      }
-    }
-    
-    for (const pattern of dynamicPatterns) {
-      const platform = patternToPlatformMap.get(pattern);
-      const isIgnored = lines.some(line => {
-        const trimmed = line.trim();
-        // Delegate matching logic to the specific platform module if available
-        if (platform && typeof platform.isMatch === 'function') {
-          return platform.isMatch(pattern, trimmed);
-        }
-        return trimmed === pattern || trimmed === pattern.slice(0, -1);
-      });
-      
-      if (!isIgnored) {
-        patternsToAdd.push(pattern);
-      }
-    }
-    
-    // This runs once per hook invocation - i.e. once per Claude Code
-    // subprocess - with no cross-process lock around the read-then-append
-    // below. Two hook invocations firing close together (e.g. two tool
-    // calls in the same turn) can each read the file before either has
-    // written, so both decide the same pattern is missing and both append
-    // it, leaving an exact duplicate line behind. Rather than add real
-    // cross-process locking for a housekeeping file that already fails
-    // silently by design, every call also collapses any exact-duplicate
-    // non-comment/non-blank line it finds - so a duplicate from a lost
-    // race self-heals on the very next invocation instead of accumulating.
-    const seen = new Set();
-    let sawDuplicate = false;
-    const dedupedLines = lines.filter(line => {
-      const trimmed = line.trim();
-      if (trimmed === '' || trimmed.startsWith('#')) return true;
-      if (seen.has(trimmed)) {
-        sawDuplicate = true;
-        return false;
-      }
-      seen.add(trimmed);
-      return true;
-    });
-
-    if (patternsToAdd.length > 0 || sawDuplicate) {
-      while (dedupedLines.length > 0 && dedupedLines[dedupedLines.length - 1] === '') {
-        dedupedLines.pop();
-      }
-      const finalLines = dedupedLines.concat(patternsToAdd);
-      fs.writeFileSync(gitignorePath, finalLines.join('\n') + '\n', 'utf8');
-    }
-  } catch (err) {
-    // Fail silently to avoid breaking execution if .gitignore is write-locked
-  }
-}
-
-function getStateRoot(root) {
-  const wsRoot = root || getWorkspaceRoot();
-  const activePlatformName = detectActivePlatform(wsRoot);
-  const allPlatforms = require('./platforms');
-  const activePlatform = allPlatforms.find(p => p.name === activePlatformName) || allPlatforms.find(p => p.name === 'claude');
-  
-  if (activePlatform && typeof activePlatform.getStateDir === 'function') {
-    return activePlatform.getStateDir(wsRoot);
-  }
-  return path.join(wsRoot, '.claude', 'harness-state');
-}
-
-function getSessionDir(root, sessionId) {
-  const resolvedRoot = root || getWorkspaceRoot();
-  ensureHarnessStateIgnored(resolvedRoot);
-  const dir = path.join(getStateRoot(resolvedRoot), 'sessions', sessionId || DEFAULT_SESSION);
-  fs.mkdirSync(dir, { recursive: true });
-  return dir;
-}
-
-function listSessionDirs(root) {
-  const sessionsRoot = path.join(getStateRoot(root), 'sessions');
-  try {
-    return fs.readdirSync(sessionsRoot, { withFileTypes: true })
-      .filter(e => e.isDirectory())
-      .map(e => path.join(sessionsRoot, e.name));
-  } catch (err) {
-    return [];
-  }
-}
-
-function writeCurrentSession(root, sessionId) {
-  if (!sessionId) return;
-  try {
-    const wsRoot = root || getWorkspaceRoot();
-    ensureHarnessStateIgnored(wsRoot);
-    const stateRoot = getStateRoot(wsRoot);
-    fs.mkdirSync(stateRoot, { recursive: true });
-    fs.writeFileSync(path.join(stateRoot, CURRENT_SESSION_FILE), sessionId, 'utf8');
-  } catch (err) {
-    // Best-effort - only the manual reset-circuit-breaker.js escape hatch
-    // depends on this, and it fails open too.
-  }
-}
-
-function readCurrentSession(root) {
-  try {
-    const id = fs.readFileSync(path.join(getStateRoot(root), CURRENT_SESSION_FILE), 'utf8').trim();
-    return id || null;
-  } catch (err) {
-    return null;
-  }
-}
-
-// Bootstrap-time housekeeping: nothing purges stale session directories the
-// way an OS temp dir would, so SessionStart drops ones untouched for a while.
-function pruneStaleSessions(root, maxAgeMs = 14 * 24 * 60 * 60 * 1000) {
-  const now = Date.now();
-  for (const dir of listSessionDirs(root)) {
-    try {
-      if (now - fs.statSync(dir).mtimeMs > maxAgeMs) {
-        fs.rmSync(dir, { recursive: true, force: true });
-      }
-    } catch (err) {
-      // Ignore - worst case a stale dir lingers until the next prune.
-    }
-  }
-}
-
-module.exports = {
-  DEFAULT_SESSION,
-  getWorkspaceRoot,
-  getStateRoot,
-  getSessionDir,
-  listSessionDirs,
-  writeCurrentSession,
-  readCurrentSession,
-  pruneStaleSessions,
-};
+#!/usr/bin/env node
+// Shared path resolution for Harness runtime state (hook JSON, circuit-breaker
+// counters, handoff/verification timestamps, etc). Lives under the active
+// platform's own harness-everything/ subfolder (see each module's
+// getStateDir() in hooks/scripts/lib/platforms/) - a sibling of that same
+// platform's install manifest, and (for Claude only) its skill copies.
+//
+// For Claude Code that's `<repo root>/.claude/harness-everything/state/`,
+// keyed by session_id under `sessions/<id>/` so two sessions open on the same
+// repo never share (and stomp) each other's edit/verify timestamps or
+// breaker counts. Invocations with no session_id (manual terminal runs,
+// VERIFICATION.md recipes) fall into a fixed `sessions/default/` bucket
+// rather than a random one, so manual testing stays predictable.
+const fs = require('fs');
+const path = require('path');
+
+const CURRENT_SESSION_FILE = 'current-session';
+const DEFAULT_SESSION = 'default';
+
+function getWorkspaceRoot() {
+  let dir = path.resolve(process.cwd());
+  while (dir !== path.parse(dir).root) {
+    if (fs.existsSync(path.join(dir, '.git'))) return dir;
+    dir = path.dirname(dir);
+  }
+  return process.cwd();
+}
+
+function detectActivePlatform(wsRoot) {
+  const root = wsRoot || getWorkspaceRoot();
+
+  // 1. Explicit environment variables - strongest signal. Claude Code sets
+  //    CLAUDECODE=1 / CLAUDE_CODE_ENTRYPOINT inside its own shell; a bare
+  //    TERM_PROGRAM=vscode does NOT mean Copilot, because Claude Code's
+  //    integrated terminal reports vscode too.
+  const env = process.env;
+  if (env.CLAUDE === '1' || env.CLAUDE || env.CLAUDECODE === '1' ||
+      env.CLAUDE_CODE === 'true' || env.CLAUDE_CODE_ENTRYPOINT) return 'claude';
+  if (env.CURSOR === '1' || env.CURSOR || env.CURSOR_AGENT) return 'cursor';
+  if (env.COPILOT === '1' || env.COPILOT || env.GITHUB_COPILOT_CHAT === 'true') return 'copilot';
+  if (env.CONTINUE === '1' || env.CONTINUE) return 'continue';
+
+  // 2. Workspace configuration presence - which platform's config actually
+  //    lives here beats inferring from the terminal program.
+  if (fs.existsSync(path.join(root, '.claude', 'settings.json'))) return 'claude';
+  if (fs.existsSync(path.join(root, '.cursorrules'))) return 'cursor';
+  if (fs.existsSync(path.join(root, '.github', 'copilot-instructions.md'))) return 'copilot';
+  if (fs.existsSync(path.join(root, '.continue'))) return 'continue';
+  if (fs.existsSync(path.join(root, 'AGENTS.md'))) return 'codex';
+  if (fs.existsSync(path.join(root, '.hermes.md'))) return 'hermes';
+
+  // 3. Weak terminal inference, last resort only.
+  if (env.TERM_PROGRAM === 'vscode') return 'copilot';
+
+  return 'claude'; // Default global fallback
+}
+
+// Runtime hooks must NEVER touch .gitignore - that file is install/uninstall
+// territory (scripts/installer.js -> lib/gitignore.js). Rewriting it on every
+// hook invocation caused repeated diffs and surprised users mid-session.
+
+function getStateRoot(root) {
+  const wsRoot = root || getWorkspaceRoot();
+  const activePlatformName = detectActivePlatform(wsRoot);
+  const allPlatforms = require('./platforms');
+  const activePlatform = allPlatforms.find(p => p.name === activePlatformName) || allPlatforms.find(p => p.name === 'claude');
+  
+  if (activePlatform && typeof activePlatform.getStateDir === 'function') {
+    return activePlatform.getStateDir(wsRoot);
+  }
+  return path.join(wsRoot, '.claude', 'harness-everything', 'state');
+}
+
+function getSessionDir(root, sessionId) {
+  const resolvedRoot = root || getWorkspaceRoot();
+  const dir = path.join(getStateRoot(resolvedRoot), 'sessions', sessionId || DEFAULT_SESSION);
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function listSessionDirs(root) {
+  const sessionsRoot = path.join(getStateRoot(root), 'sessions');
+  try {
+    return fs.readdirSync(sessionsRoot, { withFileTypes: true })
+      .filter(e => e.isDirectory())
+      .map(e => path.join(sessionsRoot, e.name));
+  } catch (err) {
+    return [];
+  }
+}
+
+function writeCurrentSession(root, sessionId) {
+  if (!sessionId) return;
+  try {
+    const wsRoot = root || getWorkspaceRoot();
+    const stateRoot = getStateRoot(wsRoot);
+    fs.mkdirSync(stateRoot, { recursive: true });
+    fs.writeFileSync(path.join(stateRoot, CURRENT_SESSION_FILE), sessionId, 'utf8');
+  } catch (err) {
+    // Best-effort - only the manual reset-circuit-breaker.js escape hatch
+    // depends on this, and it fails open too.
+  }
+}
+
+function readCurrentSession(root) {
+  try {
+    const id = fs.readFileSync(path.join(getStateRoot(root), CURRENT_SESSION_FILE), 'utf8').trim();
+    return id || null;
+  } catch (err) {
+    return null;
+  }
+}
+
+// Bootstrap-time housekeeping: nothing purges stale session directories the
+// way an OS temp dir would, so SessionStart drops ones untouched for a while.
+function pruneStaleSessions(root, maxAgeMs = 14 * 24 * 60 * 60 * 1000) {
+  const now = Date.now();
+  for (const dir of listSessionDirs(root)) {
+    try {
+      if (now - fs.statSync(dir).mtimeMs > maxAgeMs) {
+        fs.rmSync(dir, { recursive: true, force: true });
+      }
+    } catch (err) {
+      // Ignore - worst case a stale dir lingers until the next prune.
+    }
+  }
+}
+
+module.exports = {
+  DEFAULT_SESSION,
+  getWorkspaceRoot,
+  detectActivePlatform,
+  getStateRoot,
+  getSessionDir,
+  listSessionDirs,
+  writeCurrentSession,
+  readCurrentSession,
+  pruneStaleSessions,
+};

package/hooks/scripts/lib/platforms/claude.js

@@ -1,42 +1,185 @@
-const path = require('path');
-const fs = require('fs');
-
-// Claude Code has no native project-skill directory this package can piggy
-// back on, so everything Harness adds locally - runtime state AND the
-// installed skill copies - lives under one self-contained subfolder of the
-// platform's own directory: .claude/harness-everything/. That keeps it out
-// of a self-invented top-level folder (the old .harness/) while still being
-// exclusively ours - nothing else creates a directory literally named
-// "harness-everything" inside .claude/, so it's trivial to add/remove
-// without touching anything else Claude Code or the user put in .claude/.
-module.exports = {
-  name: 'claude',
-  label: 'Claude Code',
-  getHarnessDir(workspaceRoot) {
-    return path.join(workspaceRoot, '.claude', 'harness-everything');
-  },
-  getStateDir(workspaceRoot) {
-    return path.join(this.getHarnessDir(workspaceRoot), 'state');
-  },
-  getSkillsDir(workspaceRoot) {
-    return path.join(this.getHarnessDir(workspaceRoot), 'skills');
-  },
-  getIgnorePatterns(workspaceRoot) {
-    return ['.claude/harness-everything/'];
-  },
-  isMatch(pattern, trimmedLine) {
-    if (pattern === '.claude/harness-everything/') {
-      return trimmedLine === '.claude/' ||
-             trimmedLine === '.claude' ||
-             trimmedLine === '.claude/harness-everything' ||
-             trimmedLine === '.claude/harness-everything/';
-    }
-    return trimmedLine === pattern || trimmedLine === pattern.slice(0, -1);
-  },
-  isInstalled(workspaceRoot, userHome, isGlobal) {
-    if (isGlobal) {
-      return fs.existsSync(path.join(userHome, '.claude', 'settings.json'));
-    }
-    return fs.existsSync(path.join(workspaceRoot, '.claude', 'settings.json'));
-  }
-};
+const path = require('path');
+const fs = require('fs');
+
+// Removes legacy static-skill subfolders left behind by the pre-0.2.2 bug
+// that installed skills to .claude/harness-everything/skills/ instead of the
+// native .claude/skills/, WITHOUT touching skills/generated/ - self-evolve
+// stores the user's own dynamically-generated skills there (see
+// skill-creator/SKILL.md §4), and a blind recursive rmSync on the whole
+// skills/ folder would silently delete that accumulated learning.
+function cleanupLegacySkillsDir(oldSkillsDir) {
+  if (!fs.existsSync(oldSkillsDir)) return;
+  try {
+    const entries = fs.readdirSync(oldSkillsDir, { withFileTypes: true });
+    let removedAny = false;
+    for (const entry of entries) {
+      if (entry.name === 'generated') continue;
+      fs.rmSync(path.join(oldSkillsDir, entry.name), { recursive: true, force: true });
+      removedAny = true;
+    }
+    if (fs.readdirSync(oldSkillsDir).length === 0) {
+      fs.rmdirSync(oldSkillsDir);
+    }
+    if (removedAny) {
+      console.log(`  🧹 Cleaned up legacy incorrect local skills folder at: .claude/harness-everything/skills/ (preserved skills/generated/ - self-evolve's own dynamic skills)`);
+    }
+  } catch (e) {
+    console.warn(`  ⚠️ Failed to clean up legacy skills folder: ${e.message}`);
+  }
+}
+
+// Claude Code has native project-skill directory: .claude/skills/.
+// Runtime state converges into .claude/harness-everything/.
+module.exports = {
+  name: 'claude',
+  label: 'Claude Code',
+  getHarnessDir(workspaceRoot) {
+    return path.join(workspaceRoot, '.claude', 'harness-everything');
+  },
+  getStateDir(workspaceRoot) {
+    return path.join(this.getHarnessDir(workspaceRoot), 'state');
+  },
+  getSkillsDir(workspaceRoot) {
+    return path.join(workspaceRoot, '.claude', 'skills');
+  },
+  getIgnorePatterns(workspaceRoot) {
+    const patterns = ['.claude/harness-everything/'];
+    const skillsDir = path.join(workspaceRoot, '.claude', 'skills');
+    if (fs.existsSync(skillsDir)) {
+      try {
+        const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            const skillMdPath = path.join(skillsDir, entry.name, 'SKILL.md');
+            if (fs.existsSync(skillMdPath)) {
+              const content = fs.readFileSync(skillMdPath, 'utf8');
+              const authorLine = content.split('\n').find(line => line.trim().startsWith('author:'));
+              if (authorLine && (authorLine.includes('Miya Daniel'))) {
+                patterns.push(`.claude/skills/${entry.name}/`);
+              }
+            }
+          }
+        }
+      } catch (e) {
+        // Fallback or ignore to prevent breaking execution
+      }
+    }
+    const agentsDir = path.join(workspaceRoot, '.claude', 'agents');
+    if (fs.existsSync(agentsDir)) {
+      try {
+        for (const entry of fs.readdirSync(agentsDir, { withFileTypes: true })) {
+          if (!entry.isFile() || !/^fable-(?:orchestrator|verifier|worker-haiku|worker-sonnet)\.md$/i.test(entry.name)) continue;
+          const content = fs.readFileSync(path.join(agentsDir, entry.name), 'utf8');
+          if (/^name:\s*fable-/mi.test(content)) patterns.push(`.claude/agents/${entry.name}`);
+        }
+      } catch (e) {
+        // Fallback or ignore to prevent breaking installation.
+      }
+    }
+    return patterns;
+  },
+  isMatch(pattern, trimmedLine) {
+    if (trimmedLine === '.claude/' || trimmedLine === '.claude') {
+      return true;
+    }
+    if (pattern === '.claude/harness-everything/') {
+      return trimmedLine === '.claude/harness-everything' ||
+             trimmedLine === '.claude/harness-everything/';
+    }
+    return trimmedLine === pattern || trimmedLine === pattern.slice(0, -1);
+  },
+  isInstalled(workspaceRoot, userHome, isGlobal) {
+    if (isGlobal) {
+      return fs.existsSync(path.join(userHome, '.claude', 'settings.json'));
+    }
+    return fs.existsSync(path.join(workspaceRoot, '.claude', 'settings.json'));
+  },
+  getSkillsTarget({ workspaceRoot, userHome, isGlobal, manifest }) {
+    if (isGlobal) {
+      const claudeDir = path.join(userHome, '.claude');
+      return {
+        path: path.join(claudeDir, 'skills'),
+        label: '~/.claude/skills/',
+        manifestPath: manifest.getManifestPath(claudeDir)
+      };
+    } else {
+      const claudeDir = path.join(workspaceRoot, '.claude');
+      return {
+        path: path.join(claudeDir, 'skills'),
+        label: '.claude/skills/',
+        manifestPath: manifest.getManifestPath(claudeDir)
+      };
+    }
+  },
+  getAgentsTarget({ workspaceRoot, userHome, isGlobal, manifest }) {
+    const claudeDir = isGlobal ? path.join(userHome, '.claude') : path.join(workspaceRoot, '.claude');
+    return {
+      path: path.join(claudeDir, 'agents'),
+      label: isGlobal ? '~/.claude/agents/' : '.claude/agents/',
+      manifestPath: manifest.getManifestPath(claudeDir)
+    };
+  },
+  install({ isGlobal, targetWorkspaceRoot, harnessSourceDir, packageVersion, getUserPromptsDir, advisory, claudeHooks, manifest }) {
+    const userHome = require('os').homedir();
+    const claudeDir = isGlobal ? path.join(userHome, '.claude') : path.join(targetWorkspaceRoot, '.claude');
+    if (!fs.existsSync(claudeDir)) {
+      fs.mkdirSync(claudeDir, { recursive: true });
+      console.log(`  Created ${isGlobal ? '~/.claude' : '.claude'} directory`);
+    }
+    const claudeSettingsFile = path.join(claudeDir, 'settings.json');
+    let claudeConfig = {};
+    if (fs.existsSync(claudeSettingsFile)) {
+      try {
+        claudeConfig = JSON.parse(fs.readFileSync(claudeSettingsFile, 'utf8'));
+      } catch (e) {
+        console.warn(`  ⚠️ Existing ${isGlobal ? '~' : ''}/.claude/settings.json is malformed, creating fresh one.`);
+      }
+    }
+
+    const sourceHooksFile = path.join(harnessSourceDir, 'hooks', 'hooks.json');
+    if (fs.existsSync(sourceHooksFile)) {
+      const sourceHooksObj = JSON.parse(fs.readFileSync(sourceHooksFile, 'utf8'));
+      const resolvedHooks = {};
+      for (const [hookType, hookList] of Object.entries(sourceHooksObj.hooks || {})) {
+        resolvedHooks[hookType] = hookList.map(hookItem => {
+          const cloned = JSON.parse(JSON.stringify(hookItem));
+          if (cloned.hooks) {
+            cloned.hooks = cloned.hooks.map(h => {
+              if (h.type === 'command' && h.command) {
+                h.command = h.command.replace(/^node\s+"?([^"\s]+)"?/, (m, scriptPath) => {
+                  const abs = path.isAbsolute(scriptPath) ? scriptPath : path.join(harnessSourceDir, scriptPath);
+                  return `node "${abs}"`;
+                });
+              }
+              return h;
+            });
+          }
+          cloned.harness = { package: manifest.PACKAGE_NAME, version: packageVersion, author: manifest.HARNESS_AUTHOR };
+          return cloned;
+        });
+      }
+      claudeHooks.mergeHarnessHooks(claudeConfig, resolvedHooks);
+    }
+
+    fs.writeFileSync(claudeSettingsFile, JSON.stringify(claudeConfig, null, 2), 'utf8');
+    console.log(`  ✅ Configured Claude Code hooks safely in ${isGlobal ? '~' : ''}/.claude/settings.json`);
+
+    // DOWNWARD COMPATIBLE CLEANUP: Remove old wrong skill folder .claude/harness-everything/skills if it exists
+    cleanupLegacySkillsDir(path.join(claudeDir, 'harness-everything', 'skills'));
+  },
+  uninstall({ removeLocal, removeGlobal, workspaceRoot, userHome, getUserPromptsDir, advisory, claudeHooks, manifest, cleanEmptyDirs }) {
+    if (removeLocal) {
+      const localSettingsFile = path.join(workspaceRoot, '.claude', 'settings.json');
+      claudeHooks.removeHarnessHooks(localSettingsFile);
+      
+      // Clear old wrong skill folder .claude/harness-everything/skills if any remain
+      cleanupLegacySkillsDir(path.join(workspaceRoot, '.claude', 'harness-everything', 'skills'));
+    }
+    if (removeGlobal) {
+      const globalSettingsFile = path.join(userHome, '.claude', 'settings.json');
+      claudeHooks.removeHarnessHooks(globalSettingsFile);
+      const globalClaudeDir = path.join(userHome, '.claude');
+      cleanEmptyDirs(globalClaudeDir, [userHome]);
+    }
+  }
+};