harness-everything 0.3.6 → 0.4.1

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

@@ -1,29 +1,40 @@
 #!/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.
+// counters, handoff/verification timestamps, etc).
 //
-// 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
+// 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('../../../scripts/lib/workspace');
 
 const CURRENT_SESSION_FILE = 'current-session';
 const DEFAULT_SESSION = 'default';
+const MIGRATION_MARKER = '.migrated-from';
 
-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 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) {
@@ -59,27 +70,148 @@ function detectActivePlatform(wsRoot) {
 // 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);
+// 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);
   }
-  return path.join(wsRoot, '.claude', 'harness-everything', 'state');
+  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) {
-  const resolvedRoot = root || getWorkspaceRoot();
-  const dir = path.join(getStateRoot(resolvedRoot), 'sessions', sessionId || DEFAULT_SESSION);
+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) {
-  const sessionsRoot = path.join(getStateRoot(root), 'sessions');
+function listSessionDirs(root, context) {
+  const sessionsRoot = path.join(getStateRoot(root, context), 'sessions');
   try {
     return fs.readdirSync(sessionsRoot, { withFileTypes: true })
       .filter(e => e.isDirectory())
@@ -128,11 +260,15 @@ function pruneStaleSessions(root, maxAgeMs = 14 * 24 * 60 * 60 * 1000) {
 
 module.exports = {
   DEFAULT_SESSION,
+  sessionDirectoryName,
   getWorkspaceRoot,
+  getSessionId,
+  resolveWorkspaceIdentity,
   detectActivePlatform,
   getStateRoot,
   getSessionDir,
   listSessionDirs,
+  migrateLegacyState,
   writeCurrentSession,
   readCurrentSession,
   pruneStaleSessions,

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

@@ -1,6 +1,8 @@
 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
@@ -17,31 +19,36 @@ function cleanupLegacySkillsDir(oldSkillsDir) {
       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)`);
-    }
+    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');
-  },
+  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');
@@ -49,16 +56,12 @@ module.exports = {
       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}/`);
-              }
-            }
-          }
+          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
@@ -79,37 +82,22 @@ module.exports = {
     return patterns;
   },
   isMatch(pattern, trimmedLine) {
-    if (trimmedLine === '.claude/' || trimmedLine === '.claude') {
-      return true;
-    }
+    if (trimmedLine === '.claude/' || trimmedLine === '.claude') return true;
     if (pattern === '.claude/harness-everything/') {
-      return trimmedLine === '.claude/harness-everything' ||
-             trimmedLine === '.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'));
+    return fs.existsSync(path.join(isGlobal ? userHome : 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)
-      };
-    }
+    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');
@@ -119,7 +107,7 @@ module.exports = {
       manifestPath: manifest.getManifestPath(claudeDir)
     };
   },
-  install({ isGlobal, targetWorkspaceRoot, harnessSourceDir, packageVersion, getUserPromptsDir, advisory, claudeHooks, manifest }) {
+  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)) {
@@ -132,7 +120,7 @@ module.exports = {
       try {
         claudeConfig = JSON.parse(fs.readFileSync(claudeSettingsFile, 'utf8'));
       } catch (e) {
-        console.warn(`  ⚠️ Existing ${isGlobal ? '~' : ''}/.claude/settings.json is malformed, creating fresh one.`);
+        throw new Error(`Refusing to modify malformed ${isGlobal ? '~/' : ''}.claude/settings.json: ${e.message}`);
       }
     }
 
@@ -146,10 +134,7 @@ module.exports = {
           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}"`;
-                });
+                h.command = resolveClaudeHookCommand(h.command, harnessSourceDir);
               }
               return h;
             });
@@ -163,23 +148,21 @@ module.exports = {
 
     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 }) {
+  uninstall({ removeLocal, removeGlobal, workspaceRoot, userHome, claudeHooks, 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]);
+      cleanEmptyDirs(path.join(userHome, '.claude'), [userHome]);
     }
+  },
+  resolveHookCommand(command, harnessSourceDir) {
+    return resolveClaudeHookCommand(command, harnessSourceDir);
   }
 };

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

@@ -1,43 +1,29 @@
 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 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, '.codex', 'skills');
-  },
+  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, '.codex', 'skills');
+    const skillsDir = path.join(workspaceRoot, '.agents', '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(`.codex/skills/${entry.name}/`);
-              }
-            }
-          }
+        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
@@ -46,19 +32,15 @@ module.exports = {
     return patterns;
   },
   isMatch(pattern, trimmedLine) {
-    if (trimmedLine === '.codex/' || trimmedLine === '.codex') {
-      return true;
-    }
+    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 === '.codex/harness-everything' || trimmedLine === '.codex/harness-everything/';
     }
     return trimmedLine === pattern || trimmedLine === pattern.slice(0, -1);
   },
   isInstalled(workspaceRoot, userHome, isGlobal) {
-    if (isGlobal) {
-      return false;
-    }
+    if (isGlobal) return false;
     return fs.existsSync(path.join(workspaceRoot, 'AGENTS.md'));
   },
   getSkillsTarget({ workspaceRoot, userHome, isGlobal, manifest }) {
@@ -69,46 +51,38 @@ module.exports = {
         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),
-      };
     }
+    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');
-    } 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}`);
-      }
+      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 (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)) {
+      if (fs.existsSync(vscodeAgentFile) && advisory.hasHarnessMarker(fs.readFileSync(vscodeAgentFile, 'utf8'))) {
         fs.unlinkSync(vscodeAgentFile);
         console.log(`  ✅ Removed global Codex agent: ${vscodeAgentFile}`);
       }
       cleanEmptyDirs(promptsDir, [userHome]);
     }
   }
-};
+};

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

@@ -1,9 +1,9 @@
 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/.
+// 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',
@@ -58,11 +58,11 @@ module.exports = {
   },
   getSkillsTarget({ workspaceRoot, userHome, isGlobal, manifest }) {
     if (isGlobal) {
-      const globalAgentsDir = path.join(userHome, '.agents');
+      const continueDir = path.join(userHome, '.continue');
       return {
-        path: path.join(globalAgentsDir, 'skills'),
-        label: '~/.agents/skills/',
-        manifestPath: manifest.getManifestPath(globalAgentsDir),
+        path: path.join(continueDir, 'skills'),
+        label: '~/.continue/skills/',
+        manifestPath: manifest.getManifestPath(continueDir),
       };
     } else {
       const continueDir = path.join(workspaceRoot, '.continue');