harness-everything 0.16.4 → 0.16.6

package/plugins/harness-everything/scripts/lib/workspace.js

@@ -0,0 +1,290 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+const WORKSPACE_CONTEXT_KEYS = [
+  'workspace_root', 'workspaceRoot', 'project_root', 'projectRoot',
+  'working_directory', 'workingDirectory', 'cwd', 'root'
+];
+const SESSION_CONTEXT_KEYS = ['session_id', 'sessionId'];
+const HOST_CONTEXT_KEYS = [
+  'host_id', 'hostId', 'agent_id', 'agentId', 'client_id', 'clientId',
+  'machine_id', 'machineId', 'runtime_id', 'runtimeId'
+];
+const SESSION_REGISTRY_DIR = 'session-workspaces';
+const SESSION_REGISTRY_VERSION = 1;
+const UNBOUND_WORKSPACE_KEY = 'unbound-workspace';
+
+function findWorkspaceRoot(startPath, allowNonGit = false) {
+  if (typeof startPath !== 'string' || !startPath.trim()) return null;
+  let dir = path.resolve(startPath);
+  while (true) {
+    if (fs.existsSync(path.join(dir, '.git'))) return canonicalPath(dir);
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return allowNonGit ? canonicalPath(startPath) : null;
+}
+
+function canonicalPath(value) {
+  if (typeof value !== 'string' || !value.trim()) return null;
+  const resolved = path.resolve(value);
+  try { return fs.realpathSync(resolved); } catch (err) { return resolved; }
+}
+
+function getSessionId(context) {
+  if (!context || typeof context !== 'object') return null;
+  for (const key of SESSION_CONTEXT_KEYS) {
+    if (typeof context[key] === 'string' && context[key].trim()) {
+      return context[key].trim();
+    }
+  }
+  for (const key of ['session', 'metadata', 'context']) {
+    if (context[key] && typeof context[key] === 'object') {
+      const nested = getSessionId(context[key]);
+      if (nested) return nested;
+    }
+  }
+  return null;
+}
+
+function getHostId(context) {
+  if (!context || typeof context !== 'object') return null;
+  for (const key of HOST_CONTEXT_KEYS) {
+    if (typeof context[key] === 'string' && context[key].trim()) return context[key].trim();
+  }
+  if (typeof context.host === 'string' && context.host.trim()) return context.host.trim();
+  if (context.host && typeof context.host === 'object') return getHostId(context.host);
+  for (const key of ['agent', 'client', 'machine', 'runtime', 'metadata', 'context']) {
+    if (context[key] && typeof context[key] === 'object') {
+      const nested = getHostId(context[key]);
+      if (nested) return nested;
+    }
+  }
+  return null;
+}
+
+function contextPath(context, depth = 0) {
+  if (typeof context === 'string' && context.trim()) return context.trim();
+  if (!context || typeof context !== 'object' || depth > 2) return null;
+
+  for (const key of WORKSPACE_CONTEXT_KEYS) {
+    const value = context[key];
+    if (typeof value === 'string' && value.trim()) return value.trim();
+    if (value && typeof value === 'object') {
+      const nested = contextPath(value, depth + 1);
+      if (nested) return nested;
+    }
+  }
+
+  for (const key of ['workspace', 'project', 'host', 'context']) {
+    const nested = contextPath(context[key], depth + 1);
+    if (nested) return nested;
+  }
+  return null;
+}
+
+function sessionRegistryPath(sessionId, hostId) {
+  const namespace = hostId ? `${hostId}\0${sessionId}` : String(sessionId);
+  const hash = crypto.createHash('sha256').update(namespace).digest('hex');
+  return path.join(getStateHome(), SESSION_REGISTRY_DIR, `${hash}.json`);
+}
+
+function readRegistryRecord(filePath) {
+  try {
+    const record = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    if (record.version !== SESSION_REGISTRY_VERSION || typeof record.workspaceRoot !== 'string') return null;
+    return record;
+  } catch (err) {
+    return null;
+  }
+}
+
+function findSessionRecords(sessionId) {
+  const registryDir = path.join(getStateHome(), SESSION_REGISTRY_DIR);
+  try {
+    return fs.readdirSync(registryDir, { withFileTypes: true })
+      .filter(entry => entry.isFile() && entry.name.endsWith('.json'))
+      .map(entry => readRegistryRecord(path.join(registryDir, entry.name)))
+      .filter(record => record && record.sessionId === sessionId);
+  } catch (err) {
+    return [];
+  }
+}
+
+function readWorkspaceSession(sessionId, context) {
+  if (!sessionId) return null;
+  const hostId = getHostId(context);
+  const records = [];
+  const preferred = readRegistryRecord(sessionRegistryPath(sessionId, hostId));
+  if (preferred && (!hostId || !preferred.hostId || preferred.hostId === hostId)) records.push(preferred);
+  if (hostId) {
+    // A session may have been first observed by a caller that did not expose
+    // host metadata. Reuse that unscoped binding rather than forking state.
+    const unscoped = readRegistryRecord(sessionRegistryPath(sessionId, null));
+    if (unscoped && !unscoped.hostId) records.push(unscoped);
+  } else {
+    records.push(...findSessionRecords(sessionId));
+  }
+
+  const unique = [...new Map(records.map(record => [
+    `${record.hostId || ''}\0${record.workspaceRoot}`,
+    record
+  ])).values()];
+  if (unique.length === 1) return unique[0];
+  if (unique.length > 1) {
+    // Hostless payloads are safe only when all known host bindings agree on
+    // the same workspace. Otherwise select nothing and require context.
+    const roots = new Set(unique.map(record => canonicalPath(record.workspaceRoot)));
+    if (roots.size === 1) return unique[0];
+  }
+  return null;
+}
+
+function bindWorkspaceSession(sessionId, workspaceRoot, context, force = false) {
+  if (!sessionId) return null;
+  const root = findWorkspaceRoot(workspaceRoot, true);
+  if (!root) return null;
+  const hostId = getHostId(context);
+  const target = sessionRegistryPath(sessionId, hostId);
+  const record = {
+    version: SESSION_REGISTRY_VERSION,
+    sessionId,
+    hostId: hostId || undefined,
+    workspaceRoot: root,
+    workspaceKey: getWorkspaceKey(root),
+    updatedAt: new Date().toISOString()
+  };
+  const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(temporary, JSON.stringify(record, null, 2), 'utf8');
+    // Keep the first successful binding when two hooks initialize together.
+    if (fs.existsSync(target)) {
+      if (readRegistryRecord(target) && !force) fs.unlinkSync(temporary);
+      else {
+        fs.unlinkSync(target);
+        fs.renameSync(temporary, target);
+      }
+    } else fs.renameSync(temporary, target);
+  } catch (err) {
+    // Identity persistence is best effort. The caller still receives the
+    // resolved root and the next invocation can retry the binding.
+    try { if (fs.existsSync(temporary)) fs.unlinkSync(temporary); } catch (cleanupErr) { /* ignore */ }
+  }
+  return root;
+}
+
+function isIdentityReset(context) {
+  if (!context || typeof context !== 'object') return false;
+  return context.workspace_identity_reset === true ||
+    context.workspaceIdentityReset === true ||
+    context.new_session === true ||
+    context.newSession === true;
+}
+
+function getWorkspaceRoot(context) {
+  const sessionId = getSessionId(context);
+  const existing = readWorkspaceSession(sessionId, context);
+  const explicit = contextPath(context);
+
+  // SessionStart is the host's authoritative opportunity to establish (or
+  // re-establish) the project identity. All later hook invocations keep that
+  // binding even if the agent changes cwd or reports a nested repository.
+  if (existing && !isIdentityReset(context)) return existing.workspaceRoot;
+
+  const hostRoot = explicit || process.env.HARNESS_WORKSPACE_ROOT ||
+    process.env.CLAUDE_PROJECT_DIR || process.env.CODEX_PROJECT_DIR;
+  const root = findWorkspaceRoot(hostRoot || process.cwd(), Boolean(hostRoot));
+  if (sessionId) bindWorkspaceSession(sessionId, root, context, isIdentityReset(context));
+  return root;
+}
+
+// Single global root for ALL Harness runtime state (session counters,
+// circuit-breaker trips, audit logs, handoff timestamps, ...). Never
+// cwd-derived, so a script invoked from a fixture dir, worktree, submodule,
+// or any other nested non-git directory can never scatter files there
+// (issue #42). `$HARNESS_STATE_HOME` matches the env var the opencode
+// plugin already used for its own (differently-rooted) global state.
+function getStateHome() {
+  return process.env.HARNESS_STATE_HOME || path.join(os.homedir(), '.agents', 'harness-everything');
+}
+
+// Keys runtime state per real workspace instead of per invocation cwd, so
+// two different repos (or a repo and a stray subdirectory someone `cd`ed
+// into) never collide or fork the same state stream. Uses the resolved real
+// path (symlinks collapsed) hashed short, prefixed with a readable slug
+// purely so `~/.agents/harness-everything/workspaces/` stays eyeballable.
+function getWorkspaceKey(root) {
+  const workspaceRoot = typeof root === 'string' && root.trim() ? root : getWorkspaceRoot(root);
+  if (!workspaceRoot) return UNBOUND_WORKSPACE_KEY;
+  const resolved = path.resolve(workspaceRoot);
+  let real = resolved;
+  try { real = fs.realpathSync(resolved); } catch (err) { /* path may not exist yet (tests) */ }
+  const slug = path.basename(real).toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'workspace';
+  const hashInput = process.platform === 'win32' ? real.toLowerCase() : real;
+  const hash = crypto.createHash('sha1').update(hashInput).digest('hex').slice(0, 12);
+  return `${slug}-${hash}`;
+}
+
+function getWorkspaceStateDir(root) {
+  return path.join(getStateHome(), 'workspaces', getWorkspaceKey(root));
+}
+
+function resolveWorkspaceIdentity(context) {
+  const workspaceRoot = getWorkspaceRoot(context);
+  return {
+    workspaceRoot,
+    workspaceKey: getWorkspaceKey(workspaceRoot),
+    stateDir: getWorkspaceStateDir(workspaceRoot),
+    sessionId: getSessionId(context)
+  };
+}
+
+function getUserPromptsDir() {
+  if (process.env.VSCODE_USER_PROMPTS_FOLDER) {
+    return process.env.VSCODE_USER_PROMPTS_FOLDER;
+  }
+  const home = os.homedir();
+  if (process.platform === 'win32') {
+    return path.join(process.env.APPDATA || path.join(home, 'AppData', 'Roaming'), 'Code', 'User', 'prompts');
+  } else if (process.platform === 'darwin') {
+    return path.join(home, 'Library', 'Application Support', 'Code', 'User', 'prompts');
+  } else {
+    return path.join(home, '.config', 'Code', 'User', 'prompts');
+  }
+}
+
+// The harness repo must never be "repaired" into carrying its own generated
+// advisory files. Identify it by repo identity, not by comparing the caller's
+// __dirname: when harness runs from an npx/global install against its own
+// source checkout, the installed path and the workspace path differ and a
+// path-based guard silently fails open (issue #40).
+const HARNESS_PACKAGE_NAME = 'harness-everything';
+
+function isHarnessRepo(workspaceRoot) {
+  try {
+    const pkgPath = path.join(workspaceRoot, 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    return pkg.name === HARNESS_PACKAGE_NAME;
+  } catch (err) {
+    return false;
+  }
+}
+
+module.exports = {
+  getWorkspaceRoot,
+  resolveWorkspaceIdentity,
+  bindWorkspaceSession,
+  readWorkspaceSession,
+  getSessionId,
+  getHostId,
+  getStateHome,
+  getWorkspaceKey,
+  getWorkspaceStateDir,
+  getUserPromptsDir,
+  isHarnessRepo,
+  HARNESS_PACKAGE_NAME,
+};

package/plugins/harness-everything/skills/environment-detection/SKILL.md

@@ -4,38 +4,37 @@ description: Use at session start (Discover phase) to detect and align with the
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.4.0
+  version: 0.16.6
 ---
 
 # Environment Detection & Shell Alignment
 
-Think > Try > Summarize > Record: detect before executing.
-
 ## 📋 Skill Contract
 
 | Component | Specification |
 | :--- | :--- |
 | **Trigger / Input** | Session start or complex terminal sequences. |
-| **Expected Output** | Detected OS, shell, PATH via script or heuristics. |
-| **State Mutations** | Session context adopts path/env-var syntax. |
-| **Enforcement Gate** | Preflight; fall back to `<environment_info>` inspection and probing. |
+| **Expected Output** | OS, shell, PATH, available CLIs. |
+| **State Mutations** | Read-only by default; explicit repair may update Harness files. |
+| **Enforcement Gate** | Preflight; fall back to `<environment_info>` and minimal probes. |
 
-Boundary: operate solely within `process.cwd()`; ignore other workspaces, history, or temp paths surfaced by the IDE — never run commands outside the current project root.
+Boundary: stay inside `process.cwd()`. Detection never writes integrations or searches parent/cache paths for another runtime.
 
 ## Workflow
 
-1. Preflight from this skill's own directory; parse OS, shell, available CLIs: `node "<this-skill-dir>/scripts/preflight.js"`
-2. Self-heal harness touchpoints (idempotent): `node "<skills-repo-root>/harness-everything/scripts/self-heal.js"` — audits `<workspace>/.claude/settings.json`, `<workspace>/.cursorrules`, `<workspace>/.github/copilot-instructions.md`, `<workspace>/AGENTS.md`.
-3. Adopt syntax: Git Bash → forward `/`, `$VAR`, Unix cmds (`ls`, `rm -rf`), never `dir`/`del`/PowerShell · PowerShell → `$env:VAR`, cmdlets · CMD → `\`, `%VAR%`, `dir`/`del`/`copy`, never Unix.
-4. On failure don't blindly retry — suspect wrong-shell syntax. Three failures → trigger `zoom-out`.
+1. Run `node "<this-skill-dir>/scripts/preflight.js"`; detect OS, shell, CLIs.
+2. Where supported, audit read-only: `node "<this-skill-dir>/../harness-everything/scripts/self-heal.js" --check`. If unavailable, report and continue.
+3. Only explicit install/setup/repair intent may omit `--check`. Repair covers Claude, Codex, Copilot, Cursor, Continue, Hermes. OpenCode has its own plugin runtime; skills-only surfaces may lack repair.
+4. Adopt shell syntax: Git Bash → `/`, `$VAR`, Unix commands; PowerShell → `$env:VAR`, cmdlets; CMD → `\`, `%VAR%`, Windows commands. Three repeated failures → `zoom-out`.
 
 Deep dive: <this-skill-dir>/references/shell-syntax-rules.md
 
 ## USE FOR:
-- session-start OS/shell/toolchain detection
-- per-terminal command/path/env-var alignment
-- repairing missing harness touchpoints
+- session-start environment detection
+- shell/path/toolchain alignment
+- read-only audit or explicit repair
 
 ## DO NOT USE FOR:
-- operating outside the current workspace
-- installing toolchains from scratch
+- implicit repair during detection
+- six-adapter repair on OpenCode/skills-only surfaces
+- work outside the workspace or toolchain installation

package/plugins/harness-everything/skills/harness-everything/SKILL.md

@@ -4,7 +4,7 @@ description: "Route software/project work through the Harness kernel: classify T
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.16.3
+  version: 0.16.6
 ---
 
 # Harness Everything

package/plugins/harness-everything/skills/harness-everything/scripts/bootstrap.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 const fs = require('fs');
 const path = require('path');
+const { getHarnessRoot, requireHarnessState, requireWorkspace } = require('./runtime-paths');
 const {
   getWorkspaceRoot,
   getSessionId,
   getSessionDir,
   writeCurrentSession,
   pruneStaleSessions,
-} = require('../../hooks/scripts/lib/harness-state');
+} = requireHarnessState();
 
 console.log("Bootstrapping Harness Skills OS...");
 
@@ -162,9 +163,9 @@ try {
   // npx/global install auditing the harness checkout itself compares two
   // different paths and wrongly advises a repair that self-heal then skips
   // (issue #40). Required lazily so a missing lib can never break session start.
-  const { isHarnessRepo } = require('../../scripts/lib/workspace');
+  const { isHarnessRepo } = requireWorkspace();
   const auditingSelf = isHarnessRepo(workspaceRoot)
-    || path.resolve(workspaceRoot) === path.resolve(__dirname, '..', '..');
+    || path.resolve(workspaceRoot) === path.resolve(getHarnessRoot());
 
   if (missing.length > 0 && !auditingSelf) {
     console.log(`\n[Self-Heal] Missing integration touchpoints: ${missing.join(', ')}`);

package/plugins/harness-everything/skills/harness-everything/scripts/runtime-paths.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// Helpers live in both the source checkout and the packaged plugin's skill
+// tree. Resolve the owning runtime root instead of assuming either layout.
+function candidateRoots() {
+  return [
+    path.resolve(__dirname, '..', '..'),
+    path.resolve(__dirname, '..', '..', '..'),
+  ];
+}
+
+function getHarnessRoot() {
+  const root = candidateRoots().find(candidate =>
+    fs.existsSync(path.join(candidate, 'scripts', 'lib', 'workspace.js'))
+  );
+  if (!root) {
+    throw new Error(`Harness runtime root not found from ${__dirname}`);
+  }
+  return root;
+}
+
+function requireWorkspace() {
+  return require(path.join(getHarnessRoot(), 'scripts', 'lib', 'workspace.js'));
+}
+
+function requireHarnessState() {
+  return require(path.join(getHarnessRoot(), 'hooks', 'scripts', 'lib', 'harness-state.js'));
+}
+
+module.exports = {
+  getHarnessRoot,
+  requireWorkspace,
+  requireHarnessState,
+};

package/plugins/harness-everything/skills/harness-everything/scripts/self-heal.js

@@ -2,12 +2,12 @@
 /**
  * Self-healing installation audit for Harness OS.
  *
- * Audits the six platform integration touchpoints in the current workspace
- * and, when any are missing, re-runs the idempotent installer to repair them.
- * This makes the harness portable across editors: install once via Claude
- * Code, then open the same repo in Copilot/Cursor/Codex/Continue/Hermes and
- * the missing advisory instructions are backfilled automatically the first time
- * harness-everything (or the environment-detection Discover phase) runs.
+ * Audits the six platform integration touchpoints in the current workspace.
+ * Read-only callers use --check. Repair mode is explicit: only a direct run
+ * without --check may delegate to the idempotent installer.
+ *
+ * environment-detection uses the read-only path; ordinary Discover/preflight
+ * must never backfill hooks or advisory files as a side effect.
  *
  * Usage:
  *   node self-heal.js            Audit and repair anything missing.
@@ -23,7 +23,27 @@
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
-const { getWorkspaceRoot, isHarnessRepo } = require('../../scripts/lib/workspace');
+const { getHarnessRoot, requireWorkspace } = require('./runtime-paths');
+
+function resolveLocalRuntime(checkOnly) {
+  try {
+    const { getWorkspaceRoot, isHarnessRepo } = requireWorkspace();
+    return { getWorkspaceRoot, isHarnessRepo, harnessSourceDir: getHarnessRoot() };
+  } catch (err) {
+    const message = err && err.message ? err.message : String(err);
+    if (!/Harness runtime root not found/.test(message)) throw err;
+
+    if (checkOnly) {
+      console.log('[Harness Self-Heal Audit]');
+      console.log('  SKIPPED  Local repair runtime unavailable on this distribution surface.');
+      console.log('\nRead-only audit skipped; no workspace files were changed.');
+      return null;
+    }
+
+    console.error('Cannot repair: local Harness installer/runtime is unavailable on this distribution surface.');
+    process.exit(1);
+  }
+}
 
 const MARKER = 'Harness OS Guidance (Advisory)';
 const HOOK_ID = 'harness:pre:bootstrap';
@@ -193,8 +213,11 @@ function main() {
   const checkOnly = process.argv.includes('--check');
   const forceSelf = process.argv.includes('--force-self');
 
+  const runtime = resolveLocalRuntime(checkOnly);
+  if (!runtime) return;
+
+  const { getWorkspaceRoot, isHarnessRepo, harnessSourceDir } = runtime;
   const workspaceRoot = getWorkspaceRoot();
-  const harnessSourceDir = path.resolve(__dirname, '..', '..');
   const installerPath = path.join(harnessSourceDir, 'scripts', 'installer.js');
 
   console.log(`Workspace: ${workspaceRoot}`);

package/plugins/harness-everything/skills/harness-everything/scripts/tier-router.js

@@ -5,6 +5,7 @@ const {
   buildRouterContract,
   writeRouterContract,
 } = require('./router-contract');
+const { requireWorkspace } = require('./runtime-paths');
 
 const DEFAULT_ROUTING_CONFIG = {
   tiers: { tier3: [], tier2: [] },
@@ -163,7 +164,7 @@ function plannerInputsFromContext(context, promptLower) {
 function emitDynamicSkills(promptLower, context, recommendedGuides) {
   try {
     const userHome = process.env.HOME || process.env.USERPROFILE || '';
-    const { getWorkspaceRoot } = require('../../scripts/lib/workspace');
+    const { getWorkspaceRoot } = requireWorkspace();
     const workspaceRoot = getWorkspaceRoot(context);
 
     const manifestPaths = [
@@ -315,11 +316,6 @@ function run(userPrompt, context) {
   console.log(`\n=> RECOMMENDED TIER: ${recommendedTier}`);
   console.log(`=> RATIONALE: ${rationale}`);
 
-  if (recommendedTier.startsWith('Tier 2') || recommendedTier.startsWith('Tier 3')) {
-    console.log(`\n=> BASE EXECUTION LOOP: Load 'todo-driven-workflow' and initialize its checklist (3-7 verifiable sub-tasks) BEFORE editing any file.`);
-    console.log(`   Track exactly ONE item in-progress at a time; verify with real evidence before marking completed.`);
-  }
-
   const requestedFableModel = detectFableModel(promptLower);
   if (requestedFableModel) {
     console.log(`\n=> REQUESTED FABLE MODEL MODE: ${requestedFableModel}`);

package/scripts/installer.js

@@ -41,8 +41,15 @@ const detectedWorkspaceRoot = getWorkspaceRoot();
 // fallback private to global mode; main() rejects non-global work from a
 // directory whose workspace identity cannot be resolved.
 const workspaceRoot = detectedWorkspaceRoot || path.resolve(process.cwd());
-const harnessSourceDir = path.resolve(__dirname, '..');
-const packageVersion = require(path.join(harnessSourceDir, 'package.json')).version;
+const harnessPackageRoot = path.resolve(__dirname, '..');
+const harnessSourceDir = fs.existsSync(path.join(harnessPackageRoot, 'plugin.json')) &&
+  fs.existsSync(path.join(harnessPackageRoot, 'skills'))
+  ? path.join(harnessPackageRoot, 'skills')
+  : harnessPackageRoot;
+const packageManifestPath = fs.existsSync(path.join(harnessPackageRoot, 'package.json'))
+  ? path.join(harnessPackageRoot, 'package.json')
+  : path.join(harnessPackageRoot, 'plugin.json');
+const packageVersion = require(packageManifestPath).version;
 
 let platformModules = [];
 try {
@@ -80,11 +87,11 @@ async function main() {
   // auto-detection explicitly - --symlink surfaces a link failure as an
   // error instead of silently falling back, since the user asked for it.
   const linkMode = args.includes('--copy') ? 'copy' : args.includes('--symlink') ? 'symlink' : 'auto';
-  
+
   let requestedSkills = ['add', 'skill', 'skills'].includes(command)
     ? args.slice(3).filter(arg => !arg.startsWith('-'))
     : [];
-    
+
   const skillFlagIdx = args.indexOf('--skill') !== -1 ? args.indexOf('--skill') : args.indexOf('--skills');
   if (skillFlagIdx !== -1 && args[skillFlagIdx + 1] && !args[skillFlagIdx + 1].startsWith('-')) {
     requestedSkills.push(args[skillFlagIdx + 1]);
@@ -246,6 +253,7 @@ async function main() {
         isGlobal,
         targetWorkspaceRoot,
         harnessSourceDir,
+        harnessRuntimeRoot: harnessPackageRoot,
         packageVersion,
         getUserPromptsDir,
         advisory,

package/scripts/sync-openai-plugin.js

@@ -65,8 +65,11 @@ syncTree(sourceHooksScriptsRoot, packageHookScriptsRoot);
 const packageWorkspace = path.join(packageHookScriptsRoot, 'lib', 'workspace.js');
 syncTree(path.join(ROOT, 'scripts', 'lib', 'workspace.js'), packageWorkspace);
 
-const packageAdvisoryText = path.join(pluginRoot, 'scripts', 'lib', 'advisory-text.js');
-syncTree(path.join(ROOT, 'scripts', 'lib', 'advisory-text.js'), packageAdvisoryText);
+// Self-heal delegates to the installer. Package the installer and all of its
+// small local libraries under the plugin root so a published plugin does not
+// reach back into the source checkout.
+syncTree(path.join(ROOT, 'scripts', 'installer.js'), path.join(pluginRoot, 'scripts', 'installer.js'));
+syncTree(path.join(ROOT, 'scripts', 'lib'), path.join(pluginRoot, 'scripts', 'lib'));
 
 // Contract-integrity is shared runtime, not a directly-routed 27th skill.
 // Package it under the plugin root and rewrite its one canonical TDD import