harness-everything 0.2.2 → 0.4.0

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

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+// Shared path resolution for Harness runtime state (hook JSON, circuit-breaker
+// counters, handoff/verification timestamps, etc).
+//
+// Lives under a single user-global root - `getWorkspaceStateDir()` from
+// scripts/lib/workspace.js, i.e. `~/.agents/harness-everything/workspaces/
+// <slug-hash>/state/` - keyed by the workspace's real (symlink-resolved)
+// path, NEVER by process.cwd() at invocation time. Earlier versions rooted
+// state under `<workspace>/.claude/harness-everything/state/` (or the
+// per-platform equivalent from hooks/scripts/lib/platforms/), which silently
+// re-materialized in whatever directory a script happened to be invoked
+// from - a test fixture, a worktree, a submodule - because the underlying
+// workspace-root walk falls back to bare process.cwd() when no `.git`
+// ancestor exists. Rooting at a fixed global location instead of a
+// cwd-derived one closes that hole entirely (issue #42); migrateLegacyState()
+// below moves any state a pre-fix install already scattered into a
+// workspace, once, the first time that workspace is seen again.
+//
+// Session state keys under `sessions/<id>/` so two sessions open on the same
+// workspace 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 { getWorkspaceRoot, getWorkspaceStateDir, resolveWorkspaceIdentity, getSessionId } = require('./workspace');
+
+const CURRENT_SESSION_FILE = 'current-session';
+const DEFAULT_SESSION = 'default';
+const MIGRATION_MARKER = '.migrated-from';
+
+function sessionDirectoryName(sessionId) {
+  const value = String(sessionId || DEFAULT_SESSION)
+    .replace(/[^A-Za-z0-9._-]+/g, '_')
+    .replace(/^\.+/, '')
+    .slice(0, 128);
+  return value || DEFAULT_SESSION;
+}
+
+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.
+
+// Move state a pre-#42 install left inside the workspace (under
+// any platform's old `<workspaceRoot>/.<platform>/harness-everything/state/`
+// - see hooks/scripts/lib/platforms/*.getStateDir()) into the new global
+// location. Tries every platform's legacy dir, not just the currently
+// detected one, since a workspace may have been used under a different
+// platform (or misdetected) before this fix landed. The destination may
+// already exist: migration merges every source into it without overwriting
+// newer state. A source is removed only after its complete merge succeeds;
+// failed/conflicting sources remain in place so a later invocation can retry.
+function migrateLegacyState(wsRoot, newStateDir) {
+  const results = [];
+  if (!wsRoot) return results;
+  let allPlatforms;
+  try { allPlatforms = require('./platforms'); } catch (err) { allPlatforms = []; }
+  const legacySources = [path.join(wsRoot, '.harness', 'multi-agent')];
+  const seen = new Set();
+  for (const platform of allPlatforms) {
+    if (typeof platform.getStateDir !== 'function') continue;
+    let legacyDir;
+    try { legacyDir = platform.getStateDir(wsRoot); } catch (err) { continue; }
+    if (legacyDir) legacySources.push(legacyDir);
+  }
+  for (const legacyDir of legacySources) {
+    if (!legacyDir || path.resolve(legacyDir) === path.resolve(newStateDir)) continue;
+    const legacyKey = path.resolve(legacyDir).toLowerCase();
+    if (seen.has(legacyKey)) continue;
+    seen.add(legacyKey);
+    if (!fs.existsSync(legacyDir)) continue;
+    const target = path.basename(legacyDir) === 'multi-agent'
+      ? path.join(newStateDir, 'multi-agent')
+      : newStateDir;
+    try {
+      mergeLegacyTree(legacyDir, target);
+      fs.rmSync(legacyDir, { recursive: true, force: true });
+      try { appendMigrationMarker(newStateDir, legacyDir); } catch (markerError) {
+        // The source has already been removed; a missing breadcrumb must not
+        // be reported as a preserved source or make the migration retry.
+      }
+      results.push({ source: legacyDir, status: 'migrated' });
+    } catch (err) {
+      // Preserve the legacy source. A partial merge is safe to retry because
+      // identical destination files are skipped and conflicting files cause
+      // the source to remain available for manual recovery.
+      results.push({ source: legacyDir, status: 'preserved', error: err.message });
+    }
+  }
+  if (results.some(result => result.status === 'preserved')) {
+    writeMigrationReport(newStateDir, results);
+  }
+  return results;
+}
+
+function mergeLegacyTree(source, target) {
+  const sourceStat = fs.lstatSync(source);
+  if (!sourceStat.isDirectory()) throw new Error(`legacy state is not a directory: ${source}`);
+  fs.mkdirSync(target, { recursive: true });
+
+  for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
+    const from = path.join(source, entry.name);
+    const to = path.join(target, entry.name);
+    if (entry.isDirectory()) {
+      if (pathExists(to) && !fs.lstatSync(to).isDirectory()) {
+        throw new Error(`legacy state conflicts with a file: ${to}`);
+      }
+      mergeLegacyTree(from, to);
+      continue;
+    }
+    if (!entry.isFile()) {
+      throw new Error(`unsupported legacy state entry (preserved): ${from}`);
+    }
+    if (pathExists(to)) {
+      if (!fs.lstatSync(to).isFile() || !filesEqual(from, to)) {
+        throw new Error(`legacy state conflicts with existing state: ${to}`);
+      }
+      continue;
+    }
+    fs.mkdirSync(path.dirname(to), { recursive: true });
+    try {
+      fs.copyFileSync(from, to, fs.constants.COPYFILE_EXCL);
+    } catch (err) {
+      // A concurrent migration may have won the exclusive create. Accept it
+      // only when the resulting file is byte-for-byte identical; never let a
+      // race overwrite newer state.
+      if (err.code !== 'EEXIST' || !filesEqual(from, to)) throw err;
+    }
+  }
+}
+
+function pathExists(target) {
+  try { fs.lstatSync(target); return true; } catch (err) { return false; }
+}
+
+function filesEqual(left, right) {
+  try { return fs.readFileSync(left).equals(fs.readFileSync(right)); } catch (err) { return false; }
+}
+
+function appendMigrationMarker(newStateDir, legacyDir) {
+  fs.mkdirSync(newStateDir, { recursive: true });
+  const marker = path.join(newStateDir, MIGRATION_MARKER);
+  const prior = fs.existsSync(marker) ? fs.readFileSync(marker, 'utf8') : '';
+  const line = `${legacyDir}\t${new Date().toISOString()}\n`;
+  if (!prior.split('\n').some(existing => existing.startsWith(`${legacyDir}\t`))) {
+    fs.writeFileSync(marker, prior + line, 'utf8');
+  }
+}
+
+function writeMigrationReport(newStateDir, results) {
+  try {
+    const reportPath = path.join(path.dirname(newStateDir), 'migration-report.json');
+    let report = { version: 1, sources: [] };
+    if (fs.existsSync(reportPath)) {
+      try { report = JSON.parse(fs.readFileSync(reportPath, 'utf8')); } catch (err) { /* replace malformed report */ }
+    }
+    const bySource = new Map((report.sources || []).map(entry => [entry.source, entry]));
+    for (const result of results) bySource.set(result.source, { ...result, updatedAt: new Date().toISOString() });
+    report.sources = [...bySource.values()];
+    report.updatedAt = new Date().toISOString();
+    fs.mkdirSync(path.dirname(reportPath), { recursive: true });
+    fs.writeFileSync(reportPath, JSON.stringify(report, null, 2), 'utf8');
+  } catch (err) {
+    // The source directory remains the recovery record when the report itself
+    // cannot be written (for example, a read-only state home).
+  }
+}
+
+function getStateRoot(root, context) {
+  const wsRoot = root || getWorkspaceRoot(context);
+  const stateDir = path.join(getWorkspaceStateDir(wsRoot), 'state');
+  migrateLegacyState(wsRoot, stateDir);
+  return stateDir;
+}
+
+function getSessionDir(root, sessionId, context) {
+  const resolvedRoot = root || getWorkspaceRoot(context || (typeof sessionId === 'object' ? sessionId : undefined));
+  if (sessionId && typeof sessionId === 'object') sessionId = getSessionId(sessionId);
+  const dir = path.join(getStateRoot(resolvedRoot), 'sessions', sessionDirectoryName(sessionId));
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function listSessionDirs(root, context) {
+  const sessionsRoot = path.join(getStateRoot(root, context), '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,
+  sessionDirectoryName,
+  getWorkspaceRoot,
+  getSessionId,
+  resolveWorkspaceIdentity,
+  detectActivePlatform,
+  getStateRoot,
+  getSessionDir,
+  listSessionDirs,
+  migrateLegacyState,
+  writeCurrentSession,
+  readCurrentSession,
+  pruneStaleSessions,
+};

package/plugins/harness-everything/hooks/scripts/lib/platforms/claude.js

@@ -0,0 +1,168 @@
+const path = require('path');
+const fs = require('fs');
+
+const CLAUDE_PLUGIN_ROOT_TOKEN = '${CLAUDE_PLUGIN_ROOT}';
+
+// 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}`);
+  }
+}
+
+function resolveClaudeHookCommand(command, harnessSourceDir) {
+  return command.replace(/^node\s+"?([^"\s]+)"?/, (match, scriptPath) => {
+    let abs;
+    if (scriptPath === CLAUDE_PLUGIN_ROOT_TOKEN || scriptPath.startsWith(`${CLAUDE_PLUGIN_ROOT_TOKEN}/`) || scriptPath.startsWith(`${CLAUDE_PLUGIN_ROOT_TOKEN}\\`)) {
+      const relative = scriptPath
+        .slice(CLAUDE_PLUGIN_ROOT_TOKEN.length)
+        .replace(/^[/\\]+/, '');
+      abs = path.join(harnessSourceDir, relative);
+    } else {
+      abs = path.isAbsolute(scriptPath) ? scriptPath : path.join(harnessSourceDir, scriptPath);
+    }
+    return `node "${abs}"`;
+  });
+}
+
+// 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()) continue;
+          const skillMdPath = path.join(skillsDir, entry.name, 'SKILL.md');
+          if (!fs.existsSync(skillMdPath)) continue;
+          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) {
+    return fs.existsSync(path.join(isGlobal ? userHome : workspaceRoot, '.claude', 'settings.json'));
+  },
+  getSkillsTarget({ workspaceRoot, userHome, isGlobal, manifest }) {
+    const claudeDir = isGlobal ? path.join(userHome, '.claude') : path.join(workspaceRoot, '.claude');
+    return {
+      path: path.join(claudeDir, 'skills'),
+      label: isGlobal ? '~/.claude/skills/' : '.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, 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) {
+        throw new Error(`Refusing to modify malformed ${isGlobal ? '~/' : ''}.claude/settings.json: ${e.message}`);
+      }
+    }
+
+    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 = resolveClaudeHookCommand(h.command, harnessSourceDir);
+              }
+              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`);
+    cleanupLegacySkillsDir(path.join(claudeDir, 'harness-everything', 'skills'));
+  },
+  uninstall({ removeLocal, removeGlobal, workspaceRoot, userHome, claudeHooks, cleanEmptyDirs }) {
+    if (removeLocal) {
+      const localSettingsFile = path.join(workspaceRoot, '.claude', 'settings.json');
+      claudeHooks.removeHarnessHooks(localSettingsFile);
+      cleanupLegacySkillsDir(path.join(workspaceRoot, '.claude', 'harness-everything', 'skills'));
+    }
+    if (removeGlobal) {
+      const globalSettingsFile = path.join(userHome, '.claude', 'settings.json');
+      claudeHooks.removeHarnessHooks(globalSettingsFile);
+      cleanEmptyDirs(path.join(userHome, '.claude'), [userHome]);
+    }
+  },
+  resolveHookCommand(command, harnessSourceDir) {
+    return resolveClaudeHookCommand(command, harnessSourceDir);
+  }
+};

package/plugins/harness-everything/hooks/scripts/lib/platforms/codex.js

@@ -0,0 +1,88 @@
+const path = require('path');
+const fs = require('fs');
+
+// Codex discovers project Agent Skills from repo-scoped `.agents/skills/`
+// (walking from cwd toward the repository root). Keep project skills at that
+// native shared location so every installer mode, including `--copy`, remains
+// discoverable. Codex-specific runtime/install bookkeeping still lives under
+// `.codex/harness-everything/`.
+module.exports = {
+  name: 'codex',
+  label: 'Codex',
+  getHarnessDir(workspaceRoot) { return path.join(workspaceRoot, '.codex', 'harness-everything'); },
+  getStateDir(workspaceRoot) { return path.join(this.getHarnessDir(workspaceRoot), 'state'); },
+  getSkillsDir(workspaceRoot) { return path.join(workspaceRoot, '.agents', 'skills'); },
+  getIgnorePatterns(workspaceRoot) {
+    const patterns = ['.codex/harness-everything/'];
+    const skillsDir = path.join(workspaceRoot, '.agents', 'skills');
+    if (fs.existsSync(skillsDir)) {
+      try {
+        for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+          if (!entry.isDirectory()) continue;
+          const skillMdPath = path.join(skillsDir, entry.name, 'SKILL.md');
+          if (!fs.existsSync(skillMdPath)) continue;
+          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(`.agents/skills/${entry.name}/`);
+        }
+      } catch (e) {
+        // Fallback or ignore to prevent breaking execution
+      }
+    }
+    return patterns;
+  },
+  isMatch(pattern, trimmedLine) {
+    if (trimmedLine === '.codex/' || trimmedLine === '.codex') return pattern === '.codex/harness-everything/';
+    if (trimmedLine === '.agents/' || trimmedLine === '.agents') return pattern.startsWith('.agents/skills/');
+    if (pattern === '.codex/harness-everything/') {
+      return 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'));
+  },
+  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),
+      };
+    }
+    const codexDir = path.join(workspaceRoot, '.codex');
+    return {
+      path: path.join(workspaceRoot, '.agents', 'skills'),
+      label: '.agents/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');
+      return;
+    }
+    const promptsDir = getUserPromptsDir();
+    if (!fs.existsSync(promptsDir)) fs.mkdirSync(promptsDir, { recursive: true });
+    const vscodeAgentFile = path.join(promptsDir, 'harness.agent.md');
+    advisory.assertHarnessOwnedOrAbsent(vscodeAgentFile, 'global Codex agent');
+    fs.writeFileSync(vscodeAgentFile, advisory.buildCodexGlobalContent(), 'utf8');
+    console.log(`  ✅ Installed global Codex agent to VS Code: ${vscodeAgentFile}`);
+  },
+  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) && advisory.hasHarnessMarker(fs.readFileSync(vscodeAgentFile, 'utf8'))) {
+        fs.unlinkSync(vscodeAgentFile);
+        console.log(`  ✅ Removed global Codex agent: ${vscodeAgentFile}`);
+      }
+      cleanEmptyDirs(promptsDir, [userHome]);
+    }
+  }
+};

package/plugins/harness-everything/hooks/scripts/lib/platforms/continue.js

@@ -0,0 +1,91 @@
+const path = require('path');
+const fs = require('fs');
+
+// The reviewed official Continue documentation establishes `.continue/rules/`,
+// not a native `SKILL.md` discovery contract. Keep these paths as explicit
+// installer adapter targets without claiming that Continue will load them.
+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/'];
+    const skillsDir = path.join(workspaceRoot, '.continue', '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(`.continue/skills/${entry.name}/`);
+              }
+            }
+          }
+        }
+      } catch (e) {
+        // Fallback or ignore to prevent breaking execution
+      }
+    }
+    return patterns;
+  },
+  isMatch(pattern, trimmedLine) {
+    if (trimmedLine === '.continue/' || trimmedLine === '.continue') {
+      return true;
+    }
+    if (pattern === '.continue/harness-everything/') {
+      return 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'));
+  },
+  getSkillsTarget({ workspaceRoot, userHome, isGlobal, manifest }) {
+    if (isGlobal) {
+      const continueDir = path.join(userHome, '.continue');
+      return {
+        path: path.join(continueDir, 'skills'),
+        label: '~/.continue/skills/',
+        manifestPath: manifest.getManifestPath(continueDir),
+      };
+    } 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]);
+    }
+  }
+};