harness-everything 0.2.0

package/hooks/scripts/boundary-guard.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+/**
+ * Boundary Guard (PreToolUse: Grep|Glob|Read)
+ * Hard-blocks two concrete sources of context bloat / hallucination risk:
+ *   1. Reading a large file whole instead of a scoped chunk (offset/limit).
+ *   2. Searching inside known noise directories (node_modules, .git, build
+ *      output, etc.) that produce huge, low-signal result sets.
+ * Fails open on any parse/lookup error - never blocks due to a bug here.
+ */
+const fs = require('fs');
+
+const MAX_BYTES_WITHOUT_LIMIT = 512 * 1024; // 512KB
+const NOISE_DIRS = ['node_modules', '.git', 'dist', 'build', 'out', '.next', 'target', 'vendor', '__pycache__', '.venv', 'coverage'];
+
+let inputData = '';
+process.stdin.on('data', chunk => { inputData += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const payload = JSON.parse(inputData);
+    const toolName = payload.tool_name;
+    const input = payload.tool_input || {};
+
+    if (toolName === 'Read') {
+      const filePath = input.file_path;
+      if (filePath && !input.limit && fs.existsSync(filePath)) {
+        const stat = fs.statSync(filePath);
+        if (stat.isFile() && stat.size > MAX_BYTES_WITHOUT_LIMIT) {
+          console.error(`[Boundary Guard] BLOCKED: "${filePath}" is ${(stat.size / 1024).toFixed(0)}KB.`);
+          console.error(`Reading a file this large in one call risks context bloat and "lost in the middle" degradation.`);
+          console.error(`Re-issue the Read with an explicit "offset"/"limit" to pull a targeted slice, or use Grep to locate the relevant section first.`);
+          process.exit(2);
+        }
+      }
+    }
+
+    if (toolName === 'Grep' || toolName === 'Glob') {
+      const searchPath = input.path || '';
+      const pattern = input.pattern || '';
+      const hitsNoiseDir = NOISE_DIRS.some(dir => {
+        const asPathSegment = new RegExp(`(^|[\\\\/])${dir}($|[\\\\/])`);
+        return asPathSegment.test(searchPath) || asPathSegment.test(pattern);
+      });
+      if (hitsNoiseDir) {
+        console.error(`[Boundary Guard] BLOCKED: search targets a noise directory (${NOISE_DIRS.join(', ')}).`);
+        console.error(`These produce huge, low-signal result sets and rarely contain what you're actually looking for.`);
+        console.error(`Scope the search to source directories instead, or state explicitly why this directory must be searched.`);
+        process.exit(2);
+      }
+    }
+
+    process.exit(0);
+  } catch (err) {
+    process.exit(0);
+  }
+});

package/hooks/scripts/context-compact.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const { getWorkspaceRoot, getSessionDir } = require('./lib/harness-state');
+
+function main(payload) {
+  try {
+    // Let's run a quick Git check to estimate context size from modified files
+    const statusRaw = execSync('git status --porcelain', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    if (!statusRaw) {
+      process.exit(0);
+    }
+
+    const lines = statusRaw.split('\n').filter(Boolean);
+    const modifiedCount = lines.length;
+
+    let totalDiffLines = 0;
+    try {
+      const diffStat = execSync('git diff --numstat', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+      if (diffStat) {
+        diffStat.split('\n').forEach(line => {
+          const [added, deleted] = line.split('\t');
+          if (added && added !== '-' && deleted && deleted !== '-') {
+            totalDiffLines += parseInt(added) + parseInt(deleted);
+          }
+        });
+      }
+    } catch (err) {
+      // Ignore git errors
+    }
+
+    // Thresholds for warning
+    const HIGH_FILE_LIMIT = 6;
+    const HIGH_LINE_LIMIT = 400;
+
+    const overThreshold = modifiedCount >= HIGH_FILE_LIMIT || totalDiffLines >= HIGH_LINE_LIMIT;
+
+    // Throttle: this hook fires on EVERY Bash/Edit/Write call, and a warning
+    // about context bloat that repeats on every call becomes context bloat
+    // itself (and trains the model to ignore hook output). Warn on the first
+    // crossing, then only every 10th call while still over - or when the diff
+    // has grown another 50% since the last warning.
+    const stateFile = path.join(getSessionDir(getWorkspaceRoot(), payload && payload.session_id), 'context-compact-state.json');
+    let state = { overCount: 0, lastWarnedLines: 0 };
+    try {
+      if (fs.existsSync(stateFile)) state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+    } catch (err) { /* use default */ }
+
+    if (!overThreshold) {
+      if (state.overCount > 0) {
+        try {
+          fs.writeFileSync(stateFile, JSON.stringify({ overCount: 0, lastWarnedLines: 0 }), 'utf8');
+        } catch (err) { /* ignore */ }
+      }
+      process.exit(0);
+    }
+
+    state.overCount += 1;
+    const onBeat = state.overCount === 1 || state.overCount % 10 === 0;
+    const grewALot = totalDiffLines >= (state.lastWarnedLines || 0) * 1.5 && totalDiffLines > state.lastWarnedLines;
+    const shouldWarn = onBeat || grewALot;
+    if (shouldWarn) state.lastWarnedLines = totalDiffLines;
+    try {
+      fs.writeFileSync(stateFile, JSON.stringify(state), 'utf8');
+    } catch (err) { /* ignore */ }
+
+    if (shouldWarn) {
+      // Plain stdout on exit 0 is only surfaced to Claude for UserPromptSubmit/
+      // SessionStart - for PreToolUse it's written to a debug log Claude never
+      // sees. To actually get an advisory (non-blocking) message in front of
+      // Claude here, it has to go through hookSpecificOutput.additionalContext.
+      const message = [
+        `Harness OS - Context Bloat Warning`,
+        `- Modified Files: ${modifiedCount}`,
+        `- Accumulated Diff: ${totalDiffLines} lines`,
+        ``,
+        `Caution: Large number of modified files or big diffs will bloat the Agent context window, leading to:`,
+        `  1. "Lost in the Middle" reasoning degradation`,
+        `  2. Rapidly inflating token costs`,
+        ``,
+        `Recommended Action:`,
+        `  - Run atomic commits or stage completed files.`,
+        `  - Use targeted sub-folders rather than broad searches.`,
+        `  - Ask user to run '/compact' or '/clear' if supported.`
+      ].join('\n');
+
+      console.log(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          additionalContext: message
+        }
+      }));
+    }
+  } catch (err) {
+    // Fail open - never block user execution on compaction checker
+  }
+
+  process.exit(0);
+}
+
+let inputData = '';
+const timeout = setTimeout(() => { main(null); }, 200);
+process.stdin.on('data', chunk => { inputData += chunk; });
+process.stdin.on('end', () => {
+  clearTimeout(timeout);
+  let payload = null;
+  try { payload = JSON.parse(inputData.trim()); } catch (err) { /* no payload */ }
+  main(payload);
+});
+process.stdin.on('error', () => {
+  clearTimeout(timeout);
+  main(null);
+});

package/hooks/scripts/contract-test.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+/**
+ * Contract Test (PostToolUse: Bash|PowerShell)
+ * Resolves fable-mode stage contracts. fable-orchestrator's discipline says
+ * every stage check must be "re-run or spot-checked... before building on
+ * its output" - but a verbal claim of "I re-ran it" isn't auditable. So the
+ * orchestrator now writes .claude/harness-state/contracts/<stageId>.json with
+ * status:"pending" and the exact checkCommand BEFORE running it. This hook
+ * watches every shell call; when the command matches a pending contract's
+ * checkCommand verbatim, it records pass/fail into that manifest using the
+ * same exitCode-or-stderr heuristic as rule-of-3-tracker.js.
+ * Contracts are shared across sessions, not scoped to one - the orchestrator
+ * writes them proactively (not in response to a hook message) and has no
+ * clean way to learn its own session_id, so a collision only matters if two
+ * fable-mode orchestrations run in the same repo at once.
+ * Contracts are audit trail, not synchronous enforcement - EXCEPT when a
+ * check this hook just resolved comes back FAILED, it surfaces that loudly
+ * (exit 2) so silently building on a failed stage doesn't slip through.
+ * Fails open on any parse/lookup error.
+ */
+const fs = require('fs');
+const path = require('path');
+const { getWorkspaceRoot, getStateRoot } = require('./lib/harness-state');
+
+let inputData = '';
+process.stdin.on('data', chunk => { inputData += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const payload = JSON.parse(inputData);
+    if (payload.tool_name !== 'Bash' && payload.tool_name !== 'PowerShell') process.exit(0);
+
+    const command = ((payload.tool_input && payload.tool_input.command) || '').trim();
+    if (!command) process.exit(0);
+
+    const contractsDir = path.join(getStateRoot(getWorkspaceRoot()), 'contracts');
+    if (!fs.existsSync(contractsDir)) process.exit(0);
+
+    const toolResponse = payload.tool_response || {};
+    const stdout = toolResponse.stdout ?? payload.stdout ?? '';
+    const stderr = toolResponse.stderr ?? payload.stderr ?? '';
+    const rawExitCode = toolResponse.exitCode ?? toolResponse.exit_code ?? payload.exitCode;
+    const exitCode = typeof rawExitCode === 'number' ? rawExitCode : undefined;
+    const stderrSignal = typeof stderr === 'string' && stderr.trim().length > 0;
+    const failed = (exitCode !== undefined && exitCode !== 0) || (exitCode === undefined && stderrSignal);
+
+    const files = fs.readdirSync(contractsDir).filter(f => f.endsWith('.json'));
+    let firstFailure = null;
+
+    for (const file of files) {
+      const manifestPath = path.join(contractsDir, file);
+      let manifest;
+      try {
+        manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+      } catch (e) {
+        continue;
+      }
+      if (manifest.status !== 'pending') continue;
+      if (!manifest.checkCommand || manifest.checkCommand.trim() !== command) continue;
+
+      manifest.status = failed ? 'fail' : 'pass';
+      manifest.evidence = ((stderrSignal ? stderr : stdout) || '').slice(-500).trim();
+      manifest.verifiedAt = new Date().toISOString();
+      fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');
+
+      if (failed && !firstFailure) firstFailure = manifest;
+    }
+
+    if (firstFailure) {
+      console.error(`[Contract Test] Stage "${firstFailure.stageId}" FAILED its named check: ${firstFailure.checkCommand}`);
+      console.error(`Evidence: ${firstFailure.evidence || '(no output captured)'}`);
+      console.error(`Do not build on this stage's output until it passes. Artifact: ${firstFailure.outputPath || '(no path recorded)'}`);
+      process.exit(2);
+    }
+
+    process.exit(0);
+  } catch (err) {
+    process.exit(0);
+  }
+});

package/hooks/scripts/depth-guard.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+/**
+ * Depth Guard (PreToolUse: Edit|Write)
+ * Claude Code already refuses to Edit a file that wasn't Read first in the
+ * same session - that's native behavior, not something this hook needs to
+ * re-check. The gap is Write: it happily overwrites an existing file with
+ * no prior Read at all. This hook closes that gap: blocks Write on a file
+ * that already exists on disk unless a Read of that exact path shows up
+ * earlier in this session's transcript.
+ * Fails open on any parse/lookup error - never blocks due to a bug here.
+ */
+const fs = require('fs');
+const path = require('path');
+
+let inputData = '';
+process.stdin.on('data', chunk => { inputData += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const payload = JSON.parse(inputData);
+    if (payload.tool_name !== 'Write') {
+      process.exit(0);
+    }
+
+    const filePath = payload.tool_input && payload.tool_input.file_path;
+    if (!filePath || !fs.existsSync(filePath)) {
+      // New file - nothing to have read first.
+      process.exit(0);
+    }
+
+    const transcriptPath = payload.transcript_path;
+    if (!transcriptPath || !fs.existsSync(transcriptPath)) {
+      // Can't verify either way - fail open.
+      process.exit(0);
+    }
+
+    const target = path.resolve(filePath).toLowerCase();
+    const lines = fs.readFileSync(transcriptPath, 'utf8').split('\n').filter(Boolean);
+
+    const wasRead = lines.some(line => {
+      try {
+        const entry = JSON.parse(line);
+        const content = entry && entry.message && entry.message.content;
+        if (!Array.isArray(content)) return false;
+        return content.some(block => {
+          if (!block || block.type !== 'tool_use' || block.name !== 'Read') return false;
+          const readPath = block.input && block.input.file_path;
+          return readPath && path.resolve(readPath).toLowerCase() === target;
+        });
+      } catch (e) {
+        return false;
+      }
+    });
+
+    if (!wasRead) {
+      console.error(`[Depth Guard] BLOCKED: "${filePath}" already exists but hasn't been Read in this session.`);
+      console.error(`Write() overwrites the whole file - doing that blind risks destroying content you never looked at.`);
+      console.error(`Read the file first (even a quick pass), then retry the Write, or use Edit for a targeted change.`);
+      process.exit(2);
+    }
+
+    process.exit(0);
+  } catch (err) {
+    process.exit(0);
+  }
+});

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

@@ -0,0 +1,202 @@
+#!/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);
+      }
+    }
+    
+    if (patternsToAdd.length > 0) {
+      const separator = content.length === 0 || content.endsWith('\n') ? '' : '\n';
+      fs.appendFileSync(gitignorePath, separator + patternsToAdd.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,
+};

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

@@ -0,0 +1,42 @@
+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'));
+  }
+};

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

@@ -0,0 +1,46 @@
+const path = require('path');
+const fs = require('fs');
+
+// Codex CLI's real project-scoped home is `.codex/` (it reads `.codex/skills/`
+// for project skills and `.codex/config.toml` for CLI/sandbox config, walking
+// up to the `.git` root exactly like AGENTS.md - see
+// https://developers.openai.com/codex/config-advanced and
+// https://www.agensi.io/learn/codex-cli-agents-md-complete-guide). Skills
+// stay at that native `.codex/skills/` location; only bookkeeping that never
+// had a home (runtime state, install manifest) converges into
+// `.codex/harness-everything/`.
+module.exports = {
+  name: 'codex',
+  label: 'Codex / Gemini',
+  getHarnessDir(workspaceRoot) {
+    return path.join(workspaceRoot, '.codex', 'harness-everything');
+  },
+  getStateDir(workspaceRoot) {
+    return path.join(this.getHarnessDir(workspaceRoot), 'state');
+  },
+  getSkillsDir(workspaceRoot) {
+    return path.join(workspaceRoot, '.codex', 'skills');
+  },
+  getIgnorePatterns(workspaceRoot) {
+    const patterns = ['.codex/harness-everything/'];
+    if (fs.existsSync(path.join(workspaceRoot, '.codex', 'skills'))) {
+      patterns.push('.codex/skills/');
+    }
+    return patterns;
+  },
+  isMatch(pattern, trimmedLine) {
+    if (pattern === '.codex/harness-everything/') {
+      return trimmedLine === '.codex/' ||
+             trimmedLine === '.codex' ||
+             trimmedLine === '.codex/harness-everything' ||
+             trimmedLine === '.codex/harness-everything/';
+    }
+    return trimmedLine === pattern || trimmedLine === pattern.slice(0, -1);
+  },
+  isInstalled(workspaceRoot, userHome, isGlobal) {
+    if (isGlobal) {
+      return false;
+    }
+    return fs.existsSync(path.join(workspaceRoot, 'AGENTS.md'));
+  }
+};

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

@@ -0,0 +1,41 @@
+const path = require('path');
+const fs = require('fs');
+
+// Continue's own skills location (.continue/skills/) is unchanged - it
+// already has an established home. Only bookkeeping that never had a home
+// (runtime state, install manifest) converges into .continue/harness-everything/.
+module.exports = {
+  name: 'continue',
+  label: 'Continue.dev',
+  getHarnessDir(workspaceRoot) {
+    return path.join(workspaceRoot, '.continue', 'harness-everything');
+  },
+  getStateDir(workspaceRoot) {
+    return path.join(this.getHarnessDir(workspaceRoot), 'state');
+  },
+  getSkillsDir(workspaceRoot) {
+    return path.join(workspaceRoot, '.continue', 'skills');
+  },
+  getIgnorePatterns(workspaceRoot) {
+    const patterns = ['.continue/harness-everything/'];
+    if (fs.existsSync(path.join(workspaceRoot, '.continue', 'skills'))) {
+      patterns.push('.continue/skills/');
+    }
+    return patterns;
+  },
+  isMatch(pattern, trimmedLine) {
+    if (pattern === '.continue/harness-everything/') {
+      return trimmedLine === '.continue/' ||
+             trimmedLine === '.continue' ||
+             trimmedLine === '.continue/harness-everything' ||
+             trimmedLine === '.continue/harness-everything/';
+    }
+    return trimmedLine === pattern || trimmedLine === pattern.slice(0, -1);
+  },
+  isInstalled(workspaceRoot, userHome, isGlobal) {
+    if (isGlobal) {
+      return fs.existsSync(path.join(userHome, '.continue', 'rules', 'harness.md'));
+    }
+    return fs.existsSync(path.join(workspaceRoot, '.continue', 'rules', 'harness.md'));
+  }
+};