harness-everything 0.2.0 → 0.2.2

package/CHANGELOG.md

@@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+---
+## [0.2.1] - 2026-07-24
+
+### Fixed
+- **Global skill installs landed one directory too deep**: `--global`/`-g` installs (all platforms share this one code path) copied skills to `~/.agents/harness-everything/skills/` instead of the documented `~/.agents/skills/` (see `bin/cli.js`'s own `-g, --global` help text, and the legacy-fallback scan `scripts/lib/skills.js` already expected at that path). Corrected in `scripts/installer.js` to match the same convention already used locally: `harness-everything/` holds manifest bookkeeping only, skill content lives in the native/shared `skills/` folder next to it. `~/.agents/harness-everything/manifest.json` is unchanged; uninstall's final global sweep was updated to match.
+- **Duplicate lines could accumulate in `.gitignore`**: `ensureHarnessStateIgnored` (`hooks/scripts/lib/harness-state.js`) runs once per hook-invoked subprocess with no cross-process lock around its read-then-append, so two invocations firing close together could both decide the same ignore pattern was missing and both append it. It (and the installer's own `scripts/lib/gitignore.js` writer, which shares the identical shape) now collapses exact-duplicate non-comment/non-blank lines on every write, so a duplicate from a lost race self-heals on the next invocation instead of accumulating.
+
 ---
 ## [0.2.0] - 2026-07-23
 

package/README.md

@@ -118,7 +118,7 @@ Harness operates through five core cognitive concepts:
 
 | AI Agent Tool | Integration Method | Local Target Location | Enforcement |
 |---|---|---|---|
-| **Claude Code** | Native Lifecycle Hooks (`PreToolUse`, `PostToolUse`, `SessionStart`) | `.claude/settings.json` (project) / `~/.claude/settings.json` (user) | **Hard** — hooks can block a tool call (`exit(2)`) |
+| **Claude Code** | Native Lifecycle Hooks (`PreToolUse`, `PostToolUse`, `SessionStart`) | `.claude/settings.json` (project) / `~/.claude/settings.json` (user)<br>*.claude/skills/* (Project Skills) / *~/.claude/skills/* (Global Skills) | **Hard** — hooks can block a tool call (`exit(2)`) |
 | **Cursor** | Native Project Rules | `.cursorrules` | Advisory only |
 | **Copilot Chat** | Custom Instructions | `.github/copilot-instructions.md` | Advisory only |
 | **Codex** | Custom Instructions (`AGENTS.md`, not `.codex/config.toml` — that file controls CLI/sandbox behavior, not prompt content) | `AGENTS.md` | Advisory only |

package/docs/architecture.md

@@ -60,10 +60,10 @@ Harness is designed to align with the unique capabilities of various AI IDEs and
 
 **Placement rule:** a platform's own native file/folder (`.claude/settings.json`, `.cursorrules`, `.cursor/skills/`, …) is never moved — it lives exactly where that platform expects it. Anything Harness itself needs that has no native home converges into one exclusively-owned subfolder per platform: `<platform-dir>/harness-everything/`. Nothing else ever creates a directory literally named `harness-everything`, which is what lets the installer add or remove it as a unit — including on uninstall — without touching anything else already in that platform's directory (another tool's files, or skills the user installed by hand).
 
-**Runtime state vs. installed skill content:** `<platform-dir>/harness-everything/` holds two kinds of content, kept apart by subfolder. `skills/` — Claude only, since Claude has no native project-skill directory to piggyback on — is the installer's local skill-copy target (see `scripts/lib/skills.js`'s `getInstalledSkills`, which is manifest-tracked, not a blind directory scan) — real files, not cache. Every other platform's skills stay at that platform's own established location (`.cursor/skills`, `.github/skills`, `.codex/skills`, `.continue/skills`) and are never moved. `state/` is pure runtime state: hook JSON, circuit-breaker counters, handoff/verification timestamps. It's scoped per Claude Code `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 runs, tests) fall into a fixed `sessions/default/` bucket. Both are gitignored and safe to delete; `state/` regenerates itself from nothing but in-session state (losing it mid-session just clears breaker/verification history), while deleting `skills/` requires re-running the installer to restore the copied skill files. A `manifest.json` sibling at the `harness-everything/` root records exactly what the installer put where, per platform, so uninstall never has to guess.
+**Runtime state vs. installed skill content:** `<platform-dir>/harness-everything/` holds runtime state (pure runtime state: hook JSON, circuit-breaker counters, handoff/verification timestamps) kept apart in the `state/` subfolder. On the other hand, the actual installed skills go to each platform's native/expected skills directories (e.g., `.claude/skills/` for Claude, `.cursor/skills/` for Cursor, `.github/skills/` for Copilot, `.codex/skills/` for Codex, `.continue/skills/` for Continue, and `~/.agents/skills/` or `~/.claude/skills/` for Global scope) where they are dynamically discovered and processed. A `manifest.json` under `<platform-dir>/harness-everything/` (or global home) records exactly what the installer put where, per platform, so uninstall can match against the manifest files and perform precise cleanup without guessing. Both runtime state and skills directories are gitignored.
 
 ### 1. Claude Code (hook-enforced)
-Our installer configures native lifecycle hooks inside `.claude/settings.json`:
+Our installer configures native lifecycle hooks inside `.claude/settings.json`, and places project-level skills inside the native `.claude/skills/` directory where Claude Code natively auto-discovers and registers them.
 *   `SessionStart`: Runs `bootstrap.js` to restore previous handoffs, check environment variables, and initialize session state.
 *   `PreToolUse`: Triggers `rule-of-3.js`, `boundary-guard.js`, `depth-guard.js`, `context-compact.js`, and `subagent-scope-guard.js` to intercept tool invocations before they run, and can actually block one (`exit(2)`) — e.g. the Rule of 3 circuit breaker.
 *   `PostToolUse`: Records tool outcomes, updates the persistent transaction log (WAL) via `state-persist.js`, tracks repeat failures, and can only add advisory context back (the tool already ran; nothing here blocks it).

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

@@ -112,9 +112,35 @@ function ensureHarnessStateIgnored(rootPath) {
       }
     }
     
-    if (patternsToAdd.length > 0) {
-      const separator = content.length === 0 || content.endsWith('\n') ? '' : '\n';
-      fs.appendFileSync(gitignorePath, separator + patternsToAdd.join('\n') + '\n', 'utf8');
+    // 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

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

@@ -1,14 +1,8 @@
 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/.
+// Claude Code has native project-skill directory: .claude/skills/.
+// Runtime state converges into .claude/harness-everything/.
 module.exports = {
   name: 'claude',
   label: 'Claude Code',
@@ -19,10 +13,14 @@ module.exports = {
     return path.join(this.getHarnessDir(workspaceRoot), 'state');
   },
   getSkillsDir(workspaceRoot) {
-    return path.join(this.getHarnessDir(workspaceRoot), 'skills');
+    return path.join(workspaceRoot, '.claude', 'skills');
   },
   getIgnorePatterns(workspaceRoot) {
-    return ['.claude/harness-everything/'];
+    const patterns = ['.claude/harness-everything/'];
+    if (fs.existsSync(path.join(workspaceRoot, '.claude', 'skills'))) {
+      patterns.push('.claude/skills/');
+    }
+    return patterns;
   },
   isMatch(pattern, trimmedLine) {
     if (pattern === '.claude/harness-everything/') {
@@ -38,5 +36,97 @@ module.exports = {
       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)
+      };
+    }
+  },
+  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
+    const oldSkillsDir = path.join(claudeDir, 'harness-everything', 'skills');
+    if (fs.existsSync(oldSkillsDir)) {
+      try {
+        fs.rmSync(oldSkillsDir, { recursive: true, force: true });
+        console.log(`  🧹 Cleaned up legacy incorrect local skills folder at: .claude/harness-everything/skills/`);
+      } catch (e) {
+        console.warn(`  ⚠️ Failed to remove legacy skills folder: ${e.message}`);
+      }
+    }
+  },
+  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
+      const oldSkillsDir = path.join(workspaceRoot, '.claude', 'harness-everything', 'skills');
+      if (fs.existsSync(oldSkillsDir)) {
+        fs.rmSync(oldSkillsDir, { recursive: true, force: true });
+        console.log(`  🧹 Cleaned up legacy incorrect local skills folder at: .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]);
+    }
   }
 };

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

@@ -42,5 +42,55 @@ module.exports = {
       return false;
     }
     return fs.existsSync(path.join(workspaceRoot, 'AGENTS.md'));
+  },
+  getSkillsTarget({ workspaceRoot, userHome, isGlobal, manifest }) {
+    if (isGlobal) {
+      const globalAgentsDir = path.join(userHome, '.agents');
+      return {
+        path: path.join(globalAgentsDir, 'skills'),
+        label: '~/.agents/skills/',
+        manifestPath: manifest.getManifestPath(globalAgentsDir),
+      };
+    } else {
+      const codexDir = path.join(workspaceRoot, '.codex');
+      return {
+        path: path.join(codexDir, 'skills'),
+        label: '.codex/skills/',
+        manifestPath: manifest.getManifestPath(codexDir),
+      };
+    }
+  },
+  install({ isGlobal, targetWorkspaceRoot, getUserPromptsDir, advisory }) {
+    if (!isGlobal) {
+      const targetFile = path.join(targetWorkspaceRoot, 'AGENTS.md');
+      advisory.injectAdvisoryText(targetFile, '# AGENTS.md', 'AGENTS.md');
+    } else {
+      try {
+        const promptsDir = getUserPromptsDir();
+        if (!fs.existsSync(promptsDir)) {
+          fs.mkdirSync(promptsDir, { recursive: true });
+        }
+        const vscodeAgentFile = path.join(promptsDir, 'harness.agent.md');
+        fs.writeFileSync(vscodeAgentFile, advisory.buildCodexGlobalContent(), 'utf8');
+        console.log(`  ✅ Installed global Codex agent to VS Code: ${vscodeAgentFile}`);
+      } catch (err) {
+        console.warn(`  ⚠️ Failed to write VS Code user prompts folder: ${err.message}`);
+      }
+    }
+  },
+  uninstall({ removeLocal, removeGlobal, workspaceRoot, userHome, getUserPromptsDir, cleanEmptyDirs }) {
+    const advisory = require('../../../../scripts/lib/advisory-text');
+    if (removeLocal) {
+      advisory.removeAdvisoryText(path.join(workspaceRoot, 'AGENTS.md'));
+    }
+    if (removeGlobal) {
+      const promptsDir = getUserPromptsDir();
+      const vscodeAgentFile = path.join(promptsDir, 'harness.agent.md');
+      if (fs.existsSync(vscodeAgentFile)) {
+        fs.unlinkSync(vscodeAgentFile);
+        console.log(`  ✅ Removed global Codex agent: ${vscodeAgentFile}`);
+      }
+      cleanEmptyDirs(promptsDir, [userHome]);
+    }
   }
 };

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

@@ -37,5 +37,37 @@ module.exports = {
       return fs.existsSync(path.join(userHome, '.continue', 'rules', 'harness.md'));
     }
     return fs.existsSync(path.join(workspaceRoot, '.continue', 'rules', 'harness.md'));
+  },
+  getSkillsTarget({ workspaceRoot, userHome, isGlobal, manifest }) {
+    if (isGlobal) {
+      const globalAgentsDir = path.join(userHome, '.agents');
+      return {
+        path: path.join(globalAgentsDir, 'skills'),
+        label: '~/.agents/skills/',
+        manifestPath: manifest.getManifestPath(globalAgentsDir),
+      };
+    } else {
+      const continueDir = path.join(workspaceRoot, '.continue');
+      return {
+        path: path.join(continueDir, 'skills'),
+        label: '.continue/skills/',
+        manifestPath: manifest.getManifestPath(continueDir),
+      };
+    }
+  },
+  install({ isGlobal, targetWorkspaceRoot, userHome, advisory, workspaceRoot }) {
+    const targetFile = isGlobal ? path.join(userHome, '.continue', 'rules', 'harness.md') : path.join(targetWorkspaceRoot, '.continue', 'rules', 'harness.md');
+    advisory.installContinueRule(targetFile, isGlobal ? '~/.continue/rules/harness.md' : '.continue/rules/harness.md');
+  },
+  uninstall({ removeLocal, removeGlobal, workspaceRoot, userHome, cleanEmptyDirs }) {
+    const advisory = require('../../../../scripts/lib/advisory-text');
+    if (removeLocal) {
+      advisory.removeContinueRule(path.join(workspaceRoot, '.continue', 'rules', 'harness.md'));
+      cleanEmptyDirs(path.join(workspaceRoot, '.continue', 'rules'), [workspaceRoot, userHome]);
+    }
+    if (removeGlobal) {
+      advisory.removeContinueRule(path.join(userHome, '.continue', 'rules', 'harness.md'));
+      cleanEmptyDirs(path.join(userHome, '.continue', 'rules'), [userHome]);
+    }
   }
 };

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

@@ -37,5 +37,55 @@ module.exports = {
       return false; // Handled via global userPromptsDir check
     }
     return fs.existsSync(path.join(workspaceRoot, '.github', 'copilot-instructions.md'));
+  },
+  getSkillsTarget({ workspaceRoot, userHome, isGlobal, manifest }) {
+    if (isGlobal) {
+      const globalAgentsDir = path.join(userHome, '.agents');
+      return {
+        path: path.join(globalAgentsDir, 'skills'),
+        label: '~/.agents/skills/',
+        manifestPath: manifest.getManifestPath(globalAgentsDir),
+      };
+    } else {
+      const githubDir = path.join(workspaceRoot, '.github');
+      return {
+        path: path.join(githubDir, 'skills'),
+        label: '.github/skills/',
+        manifestPath: manifest.getManifestPath(githubDir),
+      };
+    }
+  },
+  install({ isGlobal, targetWorkspaceRoot, getUserPromptsDir, advisory }) {
+    if (!isGlobal) {
+      const targetFile = path.join(targetWorkspaceRoot, '.github', 'copilot-instructions.md');
+      advisory.injectAdvisoryText(targetFile, '# Copilot Instructions', '.github/copilot-instructions.md');
+    } else {
+      try {
+        const promptsDir = getUserPromptsDir();
+        if (!fs.existsSync(promptsDir)) {
+          fs.mkdirSync(promptsDir, { recursive: true });
+        }
+        const vscodeInstFile = path.join(promptsDir, 'harness.instructions.md');
+        fs.writeFileSync(vscodeInstFile, advisory.buildCopilotGlobalContent(), 'utf8');
+        console.log(`  ✅ Installed global Copilot instructions to VS Code: ${vscodeInstFile}`);
+      } catch (err) {
+        console.warn(`  ⚠️ Failed to write VS Code user prompts folder: ${err.message}`);
+      }
+    }
+  },
+  uninstall({ removeLocal, removeGlobal, workspaceRoot, userHome, getUserPromptsDir, cleanEmptyDirs }) {
+    const advisory = require('../../../../scripts/lib/advisory-text');
+    if (removeLocal) {
+      advisory.removeAdvisoryText(path.join(workspaceRoot, '.github', 'copilot-instructions.md'));
+    }
+    if (removeGlobal) {
+      const promptsDir = getUserPromptsDir();
+      const vscodeInstFile = path.join(promptsDir, 'harness.instructions.md');
+      if (fs.existsSync(vscodeInstFile)) {
+        fs.unlinkSync(vscodeInstFile);
+        console.log(`  ✅ Removed global Copilot instructions: ${vscodeInstFile}`);
+      }
+      cleanEmptyDirs(promptsDir, [userHome]);
+    }
   }
 };

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

@@ -37,5 +37,35 @@ module.exports = {
       return fs.existsSync(path.join(userHome, '.cursorrules'));
     }
     return fs.existsSync(path.join(workspaceRoot, '.cursorrules'));
+  },
+  getSkillsTarget({ workspaceRoot, userHome, isGlobal, manifest }) {
+    if (isGlobal) {
+      const globalAgentsDir = path.join(userHome, '.agents');
+      return {
+        path: path.join(globalAgentsDir, 'skills'),
+        label: '~/.agents/skills/',
+        manifestPath: manifest.getManifestPath(globalAgentsDir),
+      };
+    } else {
+      const cursorDir = path.join(workspaceRoot, '.cursor');
+      return {
+        path: path.join(cursorDir, 'skills'),
+        label: '.cursor/skills/',
+        manifestPath: manifest.getManifestPath(cursorDir),
+      };
+    }
+  },
+  install({ isGlobal, targetWorkspaceRoot, userHome, advisory }) {
+    const targetFile = isGlobal ? path.join(userHome, '.cursorrules') : path.join(targetWorkspaceRoot, '.cursorrules');
+    advisory.injectAdvisoryText(targetFile, '# Cursor Project Rules', isGlobal ? '~/.cursorrules' : '.cursorrules');
+  },
+  uninstall({ removeLocal, removeGlobal, workspaceRoot, userHome }) {
+    const advisory = require('../../../../scripts/lib/advisory-text');
+    if (removeLocal) {
+      advisory.removeAdvisoryText(path.join(workspaceRoot, '.cursorrules'));
+    }
+    if (removeGlobal) {
+      advisory.removeAdvisoryText(path.join(userHome, '.cursorrules'));
+    }
   }
 };

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

@@ -28,5 +28,30 @@ module.exports = {
       return false;
     }
     return fs.existsSync(path.join(workspaceRoot, '.hermes.md'));
+  },
+  getSkillsTarget({ workspaceRoot, userHome, isGlobal, manifest }) {
+    if (isGlobal) {
+      const globalAgentsDir = path.join(userHome, '.agents');
+      return {
+        path: path.join(globalAgentsDir, 'skills'),
+        label: '~/.agents/skills/',
+        manifestPath: manifest.getManifestPath(globalAgentsDir),
+      };
+    }
+    return null;
+  },
+  install({ isGlobal, targetWorkspaceRoot, advisory }) {
+    if (!isGlobal) {
+      const targetFile = path.join(targetWorkspaceRoot, '.hermes.md');
+      advisory.injectAdvisoryText(targetFile, '# .hermes.md', '.hermes.md');
+    } else {
+      console.log(`  ℹ️  Hermes Agent has no documented global instructions file (it reads .hermes.md from the current project directory only) - skipping global install for --hermes.`);
+    }
+  },
+  uninstall({ removeLocal, removeGlobal, workspaceRoot, userHome }) {
+    const advisory = require('../../../../scripts/lib/advisory-text');
+    if (removeLocal) {
+      advisory.removeAdvisoryText(path.join(workspaceRoot, '.hermes.md'));
+    }
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Harness OS: An Orchestrated Agent Operating System for AI-driven Development",
   "main": "harness-everything/scripts/bootstrap.js",
   "bin": {