harness-everything 0.16.3 → 0.16.5

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/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.5
 ---
 
 # 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

@@ -23,7 +23,8 @@
 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');
+const { getWorkspaceRoot, isHarnessRepo } = requireWorkspace();
 
 const MARKER = 'Harness OS Guidance (Advisory)';
 const HOOK_ID = 'harness:pre:bootstrap';
@@ -194,7 +195,7 @@ function main() {
   const forceSelf = process.argv.includes('--force-self');
 
   const workspaceRoot = getWorkspaceRoot();
-  const harnessSourceDir = path.resolve(__dirname, '..', '..');
+  const harnessSourceDir = getHarnessRoot();
   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