harness-everything 0.13.0 → 0.14.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "harness-everything",
       "source": "./",
       "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-      "version": "0.13.0",
+      "version": "0.14.0",
       "author": {
         "name": "Miya Daniel"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "harness-everything",
   "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "author": {
     "name": "Miya Daniel"
   },

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.14.0](https://github.com/dyphn1/Harness-everything/compare/v0.13.0...v0.14.0) (2026-09-20)
+
+### Features
+
+* **contract:** add node npm probe adapter ([02f4044](https://github.com/dyphn1/Harness-everything/commit/02f4044c82a6cb082d4b8e4fe810071afe064c21))
+* **contract:** add packaged node probe adapter ([de72904](https://github.com/dyphn1/Harness-everything/commit/de7290434346cdc358ea119845c72ddca3ea0090))
+* **contract:** package node probe adapter runtime ([783dc8f](https://github.com/dyphn1/Harness-everything/commit/783dc8f891a3244461f3dfe154542bad15125f15))
+
+### Bug Fixes
+
+* **contract:** close linked-workspace isolation gap ([574ea2f](https://github.com/dyphn1/Harness-everything/commit/574ea2f299ae02aa93785cca7aa5b4a829e9f961))
+* **contract:** launch npm probes cross-platform ([b39b2c0](https://github.com/dyphn1/Harness-everything/commit/b39b2c09a223c64d3665d383852a6313fff888fc))
+* **contract:** launch npm probes cross-platform ([723bae1](https://github.com/dyphn1/Harness-everything/commit/723bae19ac4a05bfefe44ad0d61bd5dfb8b0ba50))
+* **contract:** reject symlink probe escapes ([bf577a5](https://github.com/dyphn1/Harness-everything/commit/bf577a5b58dec2a4779709402146073f0fd0ce29))
+* **contract:** reject symlink probe escapes ([5e3c569](https://github.com/dyphn1/Harness-everything/commit/5e3c569b1b7b883490e40fd66a64385f2d24d717))
+
 ## [0.13.0](https://github.com/dyphn1/Harness-everything/compare/v0.12.3...v0.13.0) (2026-09-19)
 
 ### Features

package/ci/mechanism-2ak-contract-probe-adapter.test.js

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..');
+const FIXTURE = path.join(ROOT, 'contract-integrity', 'fixtures', 'node-probe-project');
+const ADAPTER = path.join(ROOT, 'contract-integrity', 'scripts', 'node-probe-adapter.js');
+const { applyProbe, executePlan, validatePlan } = require(ADAPTER);
+const { evaluateTrace } = require(path.join(ROOT, 'contract-integrity', 'scripts', 'audit.js'));
+
+let failed = 0;
+function check(condition, message, detail = '') {
+  if (condition) console.log('  PASS ' + message);
+  else {
+    console.error('  FAIL ' + message + (detail ? ' — ' + detail : ''));
+    failed++;
+  }
+}
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function json(file) {
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+function digest(file) {
+  return require('crypto').createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+
+console.log('=== Contract Integrity Phase 3 Node Probe Adapter (#84) ===');
+
+const plan = json(path.join(FIXTURE, 'probe-plan.json'));
+check(validatePlan(plan).length === 0, 'declared node-npm-v1 probe plan validates');
+
+const beforeSource = digest(path.join(FIXTURE, 'src', 'limit.js'));
+const beforeTest = digest(path.join(FIXTURE, 'test', 'contract.test.js'));
+const protectedReport = executePlan(FIXTURE, plan);
+check(protectedReport.result === 'PROTECTED', 'green baseline plus both explicit probes produces PROTECTED evidence');
+check(protectedReport.probes.length === 2 && protectedReport.probes.every(probe =>
+  probe.status === 'KILLED' && probe.failureClass === 'contract' && probe.workspaceIsolation === 'isolated'),
+  'env and exact-replace probes are killed only by expected contract failures');
+check(digest(path.join(FIXTURE, 'src', 'limit.js')) === beforeSource &&
+  digest(path.join(FIXTURE, 'test', 'contract.test.js')) === beforeTest,
+  'adapter never mutates the source workspace');
+check(!JSON.stringify(protectedReport).includes('out-of-range input must be rejected'),
+  'probe report retains output hashes/evidence refs instead of project test output');
+
+const trace = json(path.join(ROOT, 'contract-integrity', 'fixtures', 'consistent-trace.json'));
+trace.probes = protectedReport.probes.filter(probe => probe.probeId === 'PROBE-001').map(probe => ({
+  probeId: probe.probeId,
+  requirementId: probe.requirementId,
+  status: probe.status,
+  sourceSection: probe.sourceSection,
+  evidenceRef: probe.evidenceRef,
+  workspaceIsolation: probe.workspaceIsolation,
+  failureClass: probe.failureClass,
+}));
+const tdd = json(path.join(ROOT, 'tdd', 'fixtures', 'pass-evidence.json'));
+tdd.requirements[0].source.path = 'docs/specs/api.md';
+tdd.requirements[0].source.section = 'REQ-001';
+const integrated = evaluateTrace(trace, { tddEvidence: tdd });
+check(integrated.result === 'PASS' && integrated.scores.protectionScore === 100,
+  'derived adapter evidence feeds the existing #84/#58 strict integrity gate');
+
+const survivingPlan = clone(plan);
+survivingPlan.probes = [clone(plan.probes[0])];
+survivingPlan.probes[0].env.HARNESS_CONTRACT_PROBE = 'noop';
+const surviving = executePlan(FIXTURE, survivingPlan);
+check(surviving.result === 'SURVIVED' && surviving.probes[0].status === 'SURVIVED',
+  'green test run under a required probe is explicitly SURVIVED, never PASS');
+const weakTrace = clone(trace);
+weakTrace.probes[0] = {
+  probeId: surviving.probes[0].probeId,
+  requirementId: surviving.probes[0].requirementId,
+  status: surviving.probes[0].status,
+  sourceSection: surviving.probes[0].sourceSection,
+  evidenceRef: surviving.probes[0].evidenceRef,
+  workspaceIsolation: surviving.probes[0].workspaceIsolation,
+  failureClass: surviving.probes[0].failureClass,
+};
+const weakAudit = evaluateTrace(weakTrace, { tddEvidence: tdd });
+check(weakAudit.result === 'FAIL' && weakAudit.scores.completenessScore === 100 &&
+  weakAudit.scores.protectionScore === 0,
+  'green but weak suite cannot compensate 100 completeness with a surviving contract probe');
+
+const unrelatedPlan = clone(plan);
+unrelatedPlan.probes = [clone(plan.probes[0])];
+unrelatedPlan.probes[0].expectedFailureContains = 'THIS-MARKER-DOES-NOT-EXIST';
+const unrelated = executePlan(FIXTURE, unrelatedPlan);
+check(unrelated.probes[0].status === 'INVALID' && unrelated.probes[0].failureClass === 'unknown',
+  'unrelated failing test output is INVALID and cannot be credited as a kill');
+
+const ambiguousReplace = clone(plan);
+ambiguousReplace.probes = [clone(plan.probes[1])];
+ambiguousReplace.probes[0].find = 'return';
+const ambiguous = executePlan(FIXTURE, ambiguousReplace);
+check(ambiguous.probes[0].status === 'NOT_EVALUATED' &&
+  /exactly once/.test(ambiguous.probes[0].adapterReason),
+  'ambiguous exact-replace fallback fails closed without mutating source');
+
+const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-contract-adapter-test-'));
+try {
+  const symlinkWorkspace = path.join(temp, 'symlink-workspace');
+  fs.mkdirSync(symlinkWorkspace, { recursive: true });
+  const outsideDir = path.join(temp, 'outside-dir');
+  fs.mkdirSync(outsideDir, { recursive: true });
+  const outsideTarget = path.join(outsideDir, 'outside.txt');
+  fs.writeFileSync(outsideTarget, 'SAFE', 'utf8');
+  fs.symlinkSync(outsideDir, path.join(symlinkWorkspace, 'linked-dir'),
+    process.platform === 'win32' ? 'junction' : 'dir');
+  let symlinkRejected = false;
+  try {
+    applyProbe(symlinkWorkspace, {
+      strategy: 'replace',
+      target: path.join('linked-dir', 'outside.txt'),
+      find: 'SAFE',
+      replace: 'MUTATED',
+    });
+  } catch (error) {
+    symlinkRejected = /symbolic link|reparse-point|outside isolated workspace/.test(String(error.message || error));
+  }
+  check(symlinkRejected && fs.readFileSync(outsideTarget, 'utf8') === 'SAFE',
+    'replace probe rejects symlink/junction escape without mutating outside the isolated workspace');
+
+  const linkedProject = path.join(temp, 'linked-project');
+  fs.mkdirSync(linkedProject, { recursive: true });
+  fs.writeFileSync(path.join(linkedProject, 'package.json'), JSON.stringify({
+    name: 'linked-project',
+    scripts: { contract: 'node test.js' },
+  }), 'utf8');
+  fs.writeFileSync(path.join(linkedProject, 'test.js'), [
+    "const fs = require('fs');",
+    "const path = require('path');",
+    "fs.writeFileSync(path.join(__dirname, 'linked-dir', 'outside.txt'), 'MUTATED', 'utf8');",
+  ].join('\n'), 'utf8');
+  fs.symlinkSync(outsideDir, path.join(linkedProject, 'linked-dir'),
+    process.platform === 'win32' ? 'junction' : 'dir');
+  const linkedPlan = {
+    schemaVersion: '1.0.0',
+    adapter: 'node-npm-v1',
+    script: 'contract',
+    probes: [{
+      probeId: 'PROBE-LINK',
+      requirementId: 'REQ-LINK',
+      sourceSection: 'Linked workspace',
+      strategy: 'env',
+      expectedFailureContains: 'unused',
+      env: { HARNESS_CONTRACT_PROBE: 'link' },
+    }],
+  };
+  const linkedReport = executePlan(linkedProject, linkedPlan);
+  check(linkedReport.result === 'NOT_EVALUATED' &&
+    linkedReport.baseline.workspaceIsolation === 'not-isolated' &&
+    linkedReport.probes.every(probe => probe.workspaceIsolation === 'not-isolated') &&
+    fs.readFileSync(outsideTarget, 'utf8') === 'SAFE',
+    'workspace copy rejects source symlinks/junctions before project code can mutate an outside target');
+
+  const dependent = path.join(temp, 'dependent');
+  fs.cpSync(FIXTURE, dependent, { recursive: true });
+  const pkg = json(path.join(dependent, 'package.json'));
+  pkg.dependencies = { leftpad: '1.0.0' };
+  fs.writeFileSync(path.join(dependent, 'package.json'), JSON.stringify(pkg, null, 2), 'utf8');
+  const dependencyReport = executePlan(dependent, plan);
+  check(dependencyReport.result === 'NOT_EVALUATED' &&
+    dependencyReport.discovery.reason === 'external-dependencies-not-supported-v1',
+    'v1 adapter refuses to infer/install external dependencies');
+
+  const broken = path.join(temp, 'broken');
+  fs.cpSync(FIXTURE, broken, { recursive: true });
+  fs.appendFileSync(path.join(broken, 'test', 'contract.test.js'), "\nthrow new Error('baseline fixture failure');\n", 'utf8');
+  const baselineFailure = executePlan(broken, plan);
+  check(baselineFailure.result === 'NOT_EVALUATED' &&
+    baselineFailure.baseline.status === 'FAIL' &&
+    baselineFailure.probes.every(probe => probe.status === 'NOT_EVALUATED'),
+    'non-green baseline blocks all protection claims');
+} finally {
+  fs.rmSync(temp, { recursive: true, force: true });
+}
+
+const invalidPlan = clone(plan);
+invalidPlan.probes[0].target = '../escape.js';
+invalidPlan.probes[0].strategy = 'replace';
+invalidPlan.probes[0].find = 'x';
+invalidPlan.probes[0].replace = 'y';
+delete invalidPlan.probes[0].env;
+check(validatePlan(invalidPlan).some(error => /repo-relative/.test(error)),
+  'probe plan rejects replace targets that escape the isolated workspace');
+
+const protectedCli = spawnSync(process.execPath, [
+  ADAPTER, '--workspace', FIXTURE, '--plan', path.join(FIXTURE, 'probe-plan.json'),
+], { encoding: 'utf8' });
+check(protectedCli.status === 0 && /"result": "PROTECTED"/.test(protectedCli.stdout),
+  'CLI returns exit 0 only for fully killed declared probes', protectedCli.stderr);
+
+const docs = fs.readFileSync(path.join(ROOT, 'contract-integrity', 'ADAPTERS.md'), 'utf8');
+check(/does \*\*not\*\* claim generic mutation-testing support/.test(docs) &&
+  /zero external npm dependencies/.test(docs) &&
+  /Not yet supported/.test(docs),
+  'adapter documentation states exact supported scope and explicit non-support');
+
+console.log('\n' + (failed === 0 ? 'PASS' : 'FAIL') +
+  ': #84 contract protection node adapter (' + failed + ' failure' + (failed === 1 ? '' : 's') + ')');
+process.exit(failed === 0 ? 0 : 1);

package/ci/openai-plugin-package.test.js

@@ -120,6 +120,16 @@ assert.doesNotMatch(packagedAuditSource, /\.\.\/\.\.\/tdd\/scripts\/quality-gate
 const packagedAudit = require(packagedContractAudit);
 assert.strictEqual(typeof packagedAudit.runCli, 'function', 'packaged contract audit runtime must load and export runCli');
 
+const packagedProbeAdapter = path.join(PLUGIN, 'contract-integrity', 'scripts', 'node-probe-adapter.js');
+const packagedAdapterDocs = path.join(PLUGIN, 'contract-integrity', 'ADAPTERS.md');
+assert.ok(fs.existsSync(packagedProbeAdapter) && fs.existsSync(packagedAdapterDocs),
+  'OpenAI package must include shared contract-probe adapter runtime and support boundary docs');
+const packagedAdapter = require(packagedProbeAdapter);
+assert.strictEqual(packagedAdapter.ADAPTER, 'node-npm-v1',
+  'packaged contract-probe adapter must load without becoming a routed skill');
+assert.match(fs.readFileSync(packagedAdapterDocs, 'utf8'), /does \*\*not\*\* claim generic mutation-testing support/,
+  'packaged adapter docs must preserve the narrow support boundary');
+
 const verificationContractWrapper = path.join(PLUGIN, 'skills', 'verification-loop', 'scripts', 'contract-integrity-audit.js');
 assert.ok(fs.existsSync(verificationContractWrapper), 'verification-loop must package its contract audit wrapper');
 const verificationWrapper = require(verificationContractWrapper);

package/contract-integrity/ADAPTERS.md

@@ -0,0 +1,37 @@
+# Contract Protection Adapters
+
+This directory does **not** claim generic mutation-testing support.
+
+## Supported in Phase 3
+
+### `node-npm-v1`
+
+Supported project shape:
+
+- Node.js project with a `package.json`;
+- one explicitly selected npm script used as the contract-test command;
+- **zero external npm dependencies** for this first adapter revision;
+- probes are predeclared in a local JSON plan and tied to stable `REQ-*` IDs and authoritative source sections;
+- every baseline and probe run executes in a fresh temporary copy; the source workspace is never mutated.
+
+Source workspaces containing symbolic-link or junction entries are rejected before project code runs. The v1 adapter does not claim isolation when a copied path could retain an external filesystem target.
+
+Supported probe strategies:
+
+1. **`env`** — explicit project-owned fault injection via environment variables.
+2. **`replace`** — exact one-occurrence text replacement in the isolated copy only. This is the fallback when the project has no built-in fault-injection seam.
+
+A probe is `KILLED` only when the selected npm script fails **and** its output contains the predeclared requirement-specific observable marker. A green run is `SURVIVED`. Timeout/spawn failures, baseline failures, unsafe/ambiguous replacement, missing dependencies, or unrelated failures are `NOT_EVALUATED` / `INVALID`; none of those earn protection credit.
+
+The adapter does not install dependencies, access the network, infer mutation locations, rewrite source documents, or commit generated probes.
+
+## Not yet supported
+
+- arbitrary Jest/Vitest/Mocha/Pytest/Go/Rust/.NET adapter discovery;
+- projects that require dependency installation inside the isolated copy;
+- automatic source-derived mutation synthesis;
+- compiler-failure-as-kill;
+- flaky-test attribution;
+- dirty-worktree mutation or in-place production changes.
+
+Those remain future adapters/slices. Phase 3 intentionally proves one narrow real runner plus an explicit isolated fault-injection fallback.

package/contract-integrity/fixtures/node-probe-project/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "contract-probe-fixture",
+  "private": true,
+  "version": "1.0.0",
+  "scripts": {
+    "test:contract": "node --test test/contract.test.js"
+  }
+}

package/contract-integrity/fixtures/node-probe-project/probe-plan.json

@@ -0,0 +1,27 @@
+{
+  "schemaVersion": "1.0.0",
+  "adapter": "node-npm-v1",
+  "script": "test:contract",
+  "probes": [
+    {
+      "probeId": "PROBE-001",
+      "requirementId": "REQ-001",
+      "sourceSection": "docs/specs/api.md#REQ-001",
+      "strategy": "env",
+      "env": {
+        "HARNESS_CONTRACT_PROBE": "accept-invalid"
+      },
+      "expectedFailureContains": "[REQ-001]"
+    },
+    {
+      "probeId": "PROBE-REPLACE",
+      "requirementId": "REQ-001",
+      "sourceSection": "docs/specs/api.md#REQ-001",
+      "strategy": "replace",
+      "target": "src/limit.js",
+      "find": "return Number.isInteger(value) && value >= 1 && value <= 10;",
+      "replace": "return true;",
+      "expectedFailureContains": "[REQ-001]"
+    }
+  ]
+}

package/contract-integrity/fixtures/node-probe-project/src/limit.js

@@ -0,0 +1,8 @@
+'use strict';
+
+function acceptsLimit(value) {
+  if (process.env.HARNESS_CONTRACT_PROBE === 'accept-invalid') return true;
+  return Number.isInteger(value) && value >= 1 && value <= 10;
+}
+
+module.exports = { acceptsLimit };

package/contract-integrity/fixtures/node-probe-project/test/contract.test.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { acceptsLimit } = require('../src/limit');
+
+test('[REQ-001] accepts supported boundary', () => {
+  assert.equal(acceptsLimit(1), true);
+  assert.equal(acceptsLimit(10), true);
+});
+
+test('[REQ-001] rejects out-of-range input', () => {
+  assert.equal(acceptsLimit(0), false, '[REQ-001] out-of-range input must be rejected');
+});

package/contract-integrity/scripts/node-probe-adapter.js

@@ -0,0 +1,390 @@
+#!/usr/bin/env node
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const VERSION = '1.0.0';
+const ADAPTER = 'node-npm-v1';
+const STRATEGIES = new Set(['env', 'replace']);
+const DEFAULT_TIMEOUT_MS = 30000;
+const MAX_TIMEOUT_MS = 120000;
+
+function isObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function safeRelative(value) {
+  if (typeof value !== 'string' || !value.trim() || path.isAbsolute(value)) return false;
+  const normalized = value.replace(/\\/g, '/');
+  return normalized !== '..' && !normalized.startsWith('../') && !normalized.includes('/../') && !normalized.includes('\0');
+}
+
+function sha256(value) {
+  return crypto.createHash('sha256').update(String(value || ''), 'utf8').digest('hex');
+}
+
+function validatePlan(plan) {
+  const errors = [];
+  if (!isObject(plan)) return ['probe plan must be an object'];
+  if (plan.schemaVersion !== VERSION) errors.push(`schemaVersion must be ${VERSION}`);
+  if (plan.adapter !== ADAPTER) errors.push(`adapter must be ${ADAPTER}`);
+  if (typeof plan.script !== 'string' || !/^[A-Za-z0-9:_-]+$/.test(plan.script)) errors.push('script must be an npm script name');
+  if (!Array.isArray(plan.probes) || plan.probes.length === 0) errors.push('probes must be a non-empty array');
+  const ids = new Set();
+  for (const [index, probe] of (Array.isArray(plan.probes) ? plan.probes : []).entries()) {
+    const p = `probes[${index}]`;
+    if (!isObject(probe)) { errors.push(`${p} must be an object`); continue; }
+    for (const field of ['probeId', 'requirementId', 'sourceSection', 'strategy', 'expectedFailureContains']) {
+      if (typeof probe[field] !== 'string' || !probe[field].trim()) errors.push(`${p}.${field} is required`);
+    }
+    if (probe.probeId && ids.has(probe.probeId)) errors.push(`${p}.probeId is duplicated: ${probe.probeId}`);
+    if (probe.probeId) ids.add(probe.probeId);
+    if (!STRATEGIES.has(probe.strategy)) errors.push(`${p}.strategy must be env or replace`);
+    if (probe.strategy === 'env') {
+      if (!isObject(probe.env) || Object.keys(probe.env).length === 0) errors.push(`${p}.env is required for env strategy`);
+      for (const [key, value] of Object.entries(isObject(probe.env) ? probe.env : {})) {
+        if (!/^[A-Z][A-Z0-9_]{0,79}$/.test(key)) errors.push(`${p}.env contains invalid key: ${key}`);
+        if (typeof value !== 'string' || value.length > 200) errors.push(`${p}.env.${key} must be a string <= 200 chars`);
+      }
+    }
+    if (probe.strategy === 'replace') {
+      if (!safeRelative(probe.target)) errors.push(`${p}.target must be a repo-relative path`);
+      if (typeof probe.find !== 'string' || probe.find.length === 0 || probe.find.length > 4000) errors.push(`${p}.find must be 1..4000 chars`);
+      if (typeof probe.replace !== 'string' || probe.replace.length > 4000) errors.push(`${p}.replace must be <= 4000 chars`);
+    }
+  }
+  if (plan.timeoutMs !== undefined && (!Number.isInteger(plan.timeoutMs) || plan.timeoutMs < 100 || plan.timeoutMs > MAX_TIMEOUT_MS)) {
+    errors.push(`timeoutMs must be an integer between 100 and ${MAX_TIMEOUT_MS}`);
+  }
+  return errors;
+}
+
+function discoverProject(workspace, plan) {
+  const packageFile = path.join(workspace, 'package.json');
+  if (!fs.existsSync(packageFile)) return { ok: false, reason: 'package-json-missing' };
+  let pkg;
+  try { pkg = JSON.parse(fs.readFileSync(packageFile, 'utf8')); }
+  catch (_) { return { ok: false, reason: 'package-json-invalid' }; }
+  if (!isObject(pkg.scripts) || typeof pkg.scripts[plan.script] !== 'string') {
+    return { ok: false, reason: 'npm-script-missing' };
+  }
+  const dependencyCount =
+    Object.keys(isObject(pkg.dependencies) ? pkg.dependencies : {}).length +
+    Object.keys(isObject(pkg.devDependencies) ? pkg.devDependencies : {}).length +
+    Object.keys(isObject(pkg.optionalDependencies) ? pkg.optionalDependencies : {}).length;
+  if (dependencyCount > 0) {
+    return {
+      ok: false,
+      reason: 'external-dependencies-not-supported-v1',
+      detail: 'node-npm-v1 intentionally supports zero-external-dependency projects only; dependency installation is never inferred or networked',
+    };
+  }
+  return {
+    ok: true,
+    packageName: typeof pkg.name === 'string' ? pkg.name : null,
+    script: plan.script,
+    command: `npm run ${plan.script}`,
+    dependencyMode: 'zero-external-dependencies',
+  };
+}
+
+function copyWorkspace(source) {
+  const sourceRoot = path.resolve(source);
+  if (fs.lstatSync(sourceRoot).isSymbolicLink()) {
+    throw new Error('source workspace contains a symbolic link/reparse-point root');
+  }
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-contract-probe-'));
+  const destination = path.join(root, 'workspace');
+  try {
+    fs.cpSync(sourceRoot, destination, {
+      recursive: true,
+      filter: src => {
+        if (fs.lstatSync(src).isSymbolicLink()) {
+          throw new Error('source workspace contains a symbolic link/reparse-point component');
+        }
+        const relative = path.relative(sourceRoot, src).replace(/\\/g, '/');
+        if (!relative) return true;
+        const head = relative.split('/')[0];
+        return !['.git', 'node_modules', '.harness'].includes(head);
+      },
+    });
+  } catch (error) {
+    fs.rmSync(root, { recursive: true, force: true });
+    throw error;
+  }
+  return { root, workspace: destination };
+}
+
+function runScript(workspace, plan, extraEnv = {}) {
+  const timeout = plan.timeoutMs || DEFAULT_TIMEOUT_MS;
+  // On Windows npm is normally a .cmd shim, which child_process cannot
+  // execute directly without a command shell. The script name is restricted
+  // to a safe identifier by validatePlan(), and no user-provided shell text is
+  // interpolated into the command.
+  const result = spawnSync('npm', ['run', plan.script], {
+    cwd: workspace,
+    encoding: 'utf8',
+    timeout,
+    windowsHide: true,
+    shell: process.platform === 'win32',
+    env: { ...process.env, CI: '1', ...extraEnv },
+  });
+  const stdout = String(result.stdout || '');
+  const stderr = String(result.stderr || '');
+  const combined = stdout + '\n' + stderr;
+  if (result.error) {
+    const timedOut = result.error.code === 'ETIMEDOUT';
+    return {
+      kind: timedOut ? 'timeout' : 'spawn-error',
+      exitCode: null,
+      signal: result.signal || null,
+      outputHash: sha256(combined + String(result.error.message || '')),
+      combined,
+    };
+  }
+  return {
+    kind: 'exit',
+    exitCode: Number.isInteger(result.status) ? result.status : null,
+    signal: result.signal || null,
+    outputHash: sha256(combined),
+    combined,
+  };
+}
+
+function isolatedRegularFile(workspace, relativeTarget) {
+  const root = path.resolve(workspace);
+  const target = path.resolve(root, relativeTarget);
+  const lexical = path.relative(root, target);
+  if (lexical === '..' || lexical.startsWith('..' + path.sep) || path.isAbsolute(lexical)) {
+    throw new Error('replace target escaped isolated workspace');
+  }
+
+  let current = root;
+  for (const segment of lexical.split(path.sep).filter(Boolean)) {
+    current = path.join(current, segment);
+    if (!fs.existsSync(current)) throw new Error('replace target does not exist');
+    const stat = fs.lstatSync(current);
+    if (stat.isSymbolicLink()) {
+      throw new Error('replace target contains symbolic link/reparse-point component');
+    }
+  }
+
+  const realRoot = fs.realpathSync(root);
+  const realTarget = fs.realpathSync(target);
+  const resolved = path.relative(realRoot, realTarget);
+  if (resolved === '..' || resolved.startsWith('..' + path.sep) || path.isAbsolute(resolved)) {
+    throw new Error('replace target resolved outside isolated workspace');
+  }
+  if (!fs.lstatSync(realTarget).isFile()) throw new Error('replace target does not exist');
+  return realTarget;
+}
+
+function applyProbe(workspace, probe) {
+  if (probe.strategy === 'env') return { env: { ...probe.env }, mutation: 'environment-only' };
+
+  const target = isolatedRegularFile(workspace, probe.target);
+  const source = fs.readFileSync(target, 'utf8');
+  const first = source.indexOf(probe.find);
+  const last = source.lastIndexOf(probe.find);
+  if (first < 0) throw new Error('replace find text was not present');
+  if (first !== last) throw new Error('replace find text must match exactly once');
+  fs.writeFileSync(target, source.slice(0, first) + probe.replace + source.slice(first + probe.find.length), 'utf8');
+  return { env: {}, mutation: `replace:${probe.target}` };
+}
+
+function evidenceRef(probe, run) {
+  return `probe:${probe.probeId}:output-sha256:${run.outputHash}`;
+}
+
+function notEvaluatedProbe(probe, reason, failureClass = 'infrastructure', workspaceIsolation = 'isolated') {
+  return {
+    probeId: probe.probeId,
+    requirementId: probe.requirementId,
+    status: 'NOT_EVALUATED',
+    sourceSection: probe.sourceSection,
+    evidenceRef: null,
+    workspaceIsolation,
+    failureClass,
+    adapterReason: reason,
+  };
+}
+
+function executePlan(workspace, plan) {
+  const errors = validatePlan(plan);
+  if (errors.length) return { schemaVersion: VERSION, adapter: ADAPTER, result: 'INVALID_PLAN', errors, probes: [] };
+
+  const discovered = discoverProject(workspace, plan);
+  if (!discovered.ok) {
+    return {
+      schemaVersion: VERSION,
+      adapter: ADAPTER,
+      result: 'NOT_EVALUATED',
+      discovery: discovered,
+      baseline: null,
+      probes: plan.probes.map(probe => notEvaluatedProbe(probe, discovered.reason)),
+      errors: [],
+    };
+  }
+
+  let baselineIsolation;
+  try {
+    baselineIsolation = copyWorkspace(workspace);
+    const baselineRun = runScript(baselineIsolation.workspace, plan);
+    const baseline = {
+      status: baselineRun.kind === 'exit' && baselineRun.exitCode === 0 ? 'PASS' : 'FAIL',
+      exitCode: baselineRun.exitCode,
+      failureClass: baselineRun.kind === 'exit' ? (baselineRun.exitCode === 0 ? 'none' : 'baseline-test') : 'infrastructure',
+      evidenceRef: `baseline:output-sha256:${baselineRun.outputHash}`,
+      workspaceIsolation: 'isolated',
+    };
+    if (baseline.status !== 'PASS') {
+      return {
+        schemaVersion: VERSION,
+        adapter: ADAPTER,
+        result: 'NOT_EVALUATED',
+        discovery: discovered,
+        baseline,
+        probes: plan.probes.map(probe => notEvaluatedProbe(probe, 'baseline-not-green')),
+        errors: [],
+      };
+    }
+  } catch (error) {
+    const reason = String(error.message || error);
+    return {
+      schemaVersion: VERSION,
+      adapter: ADAPTER,
+      result: 'NOT_EVALUATED',
+      discovery: discovered,
+      baseline: {
+        status: 'NOT_EVALUATED',
+        evidenceRef: null,
+        workspaceIsolation: 'not-isolated',
+        failureClass: 'infrastructure',
+        adapterReason: reason,
+      },
+      probes: plan.probes.map(probe =>
+        notEvaluatedProbe(probe, reason, 'infrastructure', 'not-isolated')),
+      errors: [],
+    };
+  } finally {
+    if (baselineIsolation?.root) fs.rmSync(baselineIsolation.root, { recursive: true, force: true });
+  }
+
+  const results = [];
+  for (const probe of plan.probes) {
+    let isolated;
+    try {
+      isolated = copyWorkspace(workspace);
+      const applied = applyProbe(isolated.workspace, probe);
+      const run = runScript(isolated.workspace, plan, applied.env);
+      if (run.kind !== 'exit') {
+        results.push(notEvaluatedProbe(probe, run.kind));
+        continue;
+      }
+      if (run.exitCode === 0) {
+        results.push({
+          probeId: probe.probeId,
+          requirementId: probe.requirementId,
+          status: 'SURVIVED',
+          sourceSection: probe.sourceSection,
+          evidenceRef: evidenceRef(probe, run),
+          workspaceIsolation: 'isolated',
+          failureClass: 'none',
+          adapterReason: 'project-test-suite-remained-green',
+        });
+        continue;
+      }
+      if (run.combined.includes(probe.expectedFailureContains)) {
+        results.push({
+          probeId: probe.probeId,
+          requirementId: probe.requirementId,
+          status: 'KILLED',
+          sourceSection: probe.sourceSection,
+          evidenceRef: evidenceRef(probe, run),
+          workspaceIsolation: 'isolated',
+          failureClass: 'contract',
+          adapterReason: 'expected-observable-contract-failure',
+        });
+      } else {
+        results.push({
+          probeId: probe.probeId,
+          requirementId: probe.requirementId,
+          status: 'INVALID',
+          sourceSection: probe.sourceSection,
+          evidenceRef: evidenceRef(probe, run),
+          workspaceIsolation: 'isolated',
+          failureClass: 'unknown',
+          adapterReason: 'test-failed-without-expected-contract-observable',
+        });
+      }
+    } catch (error) {
+      results.push(notEvaluatedProbe(
+        probe,
+        String(error.message || error),
+        'infrastructure',
+        isolated ? 'isolated' : 'not-isolated',
+      ));
+    } finally {
+      if (isolated?.root) fs.rmSync(isolated.root, { recursive: true, force: true });
+    }
+  }
+
+  return {
+    schemaVersion: VERSION,
+    adapter: ADAPTER,
+    result: results.every(probe => probe.status === 'KILLED') ? 'PROTECTED' :
+      results.some(probe => probe.status === 'SURVIVED') ? 'SURVIVED' : 'NOT_EVALUATED',
+    discovery: discovered,
+    baseline: { status: 'PASS', workspaceIsolation: 'isolated' },
+    probes: results,
+    errors: [],
+  };
+}
+
+function parseArgs(argv) {
+  const args = { workspace: null, plan: null, output: null };
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--workspace') args.workspace = argv[++i];
+    else if (argv[i] === '--plan') args.plan = argv[++i];
+    else if (argv[i] === '--output') args.output = argv[++i];
+    else throw new Error('unknown argument: ' + argv[i]);
+  }
+  if (!args.workspace || !args.plan) throw new Error('Usage: node node-probe-adapter.js --workspace <project> --plan <probe-plan.json> [--output report.json]');
+  return args;
+}
+
+function main() {
+  try {
+    const args = parseArgs(process.argv.slice(2));
+    const workspace = path.resolve(args.workspace);
+    const plan = JSON.parse(fs.readFileSync(path.resolve(args.plan), 'utf8'));
+    const report = executePlan(workspace, plan);
+    const json = JSON.stringify(report, null, 2) + '\n';
+    if (args.output) {
+      fs.mkdirSync(path.dirname(path.resolve(args.output)), { recursive: true });
+      fs.writeFileSync(path.resolve(args.output), json, 'utf8');
+    }
+    process.stdout.write(json);
+    process.exitCode = report.result === 'PROTECTED' ? 0 : report.result === 'SURVIVED' ? 1 : 2;
+  } catch (error) {
+    console.error('[Contract Probe Adapter] ' + error.message);
+    process.exitCode = 2;
+  }
+}
+
+if (require.main === module) main();
+
+module.exports = {
+  ADAPTER,
+  VERSION,
+  applyProbe,
+  discoverProject,
+  executePlan,
+  runScript,
+  safeRelative,
+  validatePlan,
+};

package/opencode-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "harness-enforcement",
   "description": "Repository inventory for the opencode enforcement plugin and its standalone helper",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "runtime": "index.mjs",
   "hooks": {
     "verify": "hooks/verify.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Harness OS: An Orchestrated Agent Operating System for AI-driven Development",
   "main": "harness-everything/scripts/bootstrap.js",
   "bin": {

package/plugins/harness-everything/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Invariant-first engineering harness for routing, verification, and failure recovery while preserving agent autonomy.",
   "author": {
     "name": "Miya Daniel",

package/plugins/harness-everything/contract-integrity/ADAPTERS.md

@@ -0,0 +1,37 @@
+# Contract Protection Adapters
+
+This directory does **not** claim generic mutation-testing support.
+
+## Supported in Phase 3
+
+### `node-npm-v1`
+
+Supported project shape:
+
+- Node.js project with a `package.json`;
+- one explicitly selected npm script used as the contract-test command;
+- **zero external npm dependencies** for this first adapter revision;
+- probes are predeclared in a local JSON plan and tied to stable `REQ-*` IDs and authoritative source sections;
+- every baseline and probe run executes in a fresh temporary copy; the source workspace is never mutated.
+
+Source workspaces containing symbolic-link or junction entries are rejected before project code runs. The v1 adapter does not claim isolation when a copied path could retain an external filesystem target.
+
+Supported probe strategies:
+
+1. **`env`** — explicit project-owned fault injection via environment variables.
+2. **`replace`** — exact one-occurrence text replacement in the isolated copy only. This is the fallback when the project has no built-in fault-injection seam.
+
+A probe is `KILLED` only when the selected npm script fails **and** its output contains the predeclared requirement-specific observable marker. A green run is `SURVIVED`. Timeout/spawn failures, baseline failures, unsafe/ambiguous replacement, missing dependencies, or unrelated failures are `NOT_EVALUATED` / `INVALID`; none of those earn protection credit.
+
+The adapter does not install dependencies, access the network, infer mutation locations, rewrite source documents, or commit generated probes.
+
+## Not yet supported
+
+- arbitrary Jest/Vitest/Mocha/Pytest/Go/Rust/.NET adapter discovery;
+- projects that require dependency installation inside the isolated copy;
+- automatic source-derived mutation synthesis;
+- compiler-failure-as-kill;
+- flaky-test attribution;
+- dirty-worktree mutation or in-place production changes.
+
+Those remain future adapters/slices. Phase 3 intentionally proves one narrow real runner plus an explicit isolated fault-injection fallback.

package/plugins/harness-everything/contract-integrity/scripts/node-probe-adapter.js

@@ -0,0 +1,390 @@
+#!/usr/bin/env node
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const VERSION = '1.0.0';
+const ADAPTER = 'node-npm-v1';
+const STRATEGIES = new Set(['env', 'replace']);
+const DEFAULT_TIMEOUT_MS = 30000;
+const MAX_TIMEOUT_MS = 120000;
+
+function isObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function safeRelative(value) {
+  if (typeof value !== 'string' || !value.trim() || path.isAbsolute(value)) return false;
+  const normalized = value.replace(/\\/g, '/');
+  return normalized !== '..' && !normalized.startsWith('../') && !normalized.includes('/../') && !normalized.includes('\0');
+}
+
+function sha256(value) {
+  return crypto.createHash('sha256').update(String(value || ''), 'utf8').digest('hex');
+}
+
+function validatePlan(plan) {
+  const errors = [];
+  if (!isObject(plan)) return ['probe plan must be an object'];
+  if (plan.schemaVersion !== VERSION) errors.push(`schemaVersion must be ${VERSION}`);
+  if (plan.adapter !== ADAPTER) errors.push(`adapter must be ${ADAPTER}`);
+  if (typeof plan.script !== 'string' || !/^[A-Za-z0-9:_-]+$/.test(plan.script)) errors.push('script must be an npm script name');
+  if (!Array.isArray(plan.probes) || plan.probes.length === 0) errors.push('probes must be a non-empty array');
+  const ids = new Set();
+  for (const [index, probe] of (Array.isArray(plan.probes) ? plan.probes : []).entries()) {
+    const p = `probes[${index}]`;
+    if (!isObject(probe)) { errors.push(`${p} must be an object`); continue; }
+    for (const field of ['probeId', 'requirementId', 'sourceSection', 'strategy', 'expectedFailureContains']) {
+      if (typeof probe[field] !== 'string' || !probe[field].trim()) errors.push(`${p}.${field} is required`);
+    }
+    if (probe.probeId && ids.has(probe.probeId)) errors.push(`${p}.probeId is duplicated: ${probe.probeId}`);
+    if (probe.probeId) ids.add(probe.probeId);
+    if (!STRATEGIES.has(probe.strategy)) errors.push(`${p}.strategy must be env or replace`);
+    if (probe.strategy === 'env') {
+      if (!isObject(probe.env) || Object.keys(probe.env).length === 0) errors.push(`${p}.env is required for env strategy`);
+      for (const [key, value] of Object.entries(isObject(probe.env) ? probe.env : {})) {
+        if (!/^[A-Z][A-Z0-9_]{0,79}$/.test(key)) errors.push(`${p}.env contains invalid key: ${key}`);
+        if (typeof value !== 'string' || value.length > 200) errors.push(`${p}.env.${key} must be a string <= 200 chars`);
+      }
+    }
+    if (probe.strategy === 'replace') {
+      if (!safeRelative(probe.target)) errors.push(`${p}.target must be a repo-relative path`);
+      if (typeof probe.find !== 'string' || probe.find.length === 0 || probe.find.length > 4000) errors.push(`${p}.find must be 1..4000 chars`);
+      if (typeof probe.replace !== 'string' || probe.replace.length > 4000) errors.push(`${p}.replace must be <= 4000 chars`);
+    }
+  }
+  if (plan.timeoutMs !== undefined && (!Number.isInteger(plan.timeoutMs) || plan.timeoutMs < 100 || plan.timeoutMs > MAX_TIMEOUT_MS)) {
+    errors.push(`timeoutMs must be an integer between 100 and ${MAX_TIMEOUT_MS}`);
+  }
+  return errors;
+}
+
+function discoverProject(workspace, plan) {
+  const packageFile = path.join(workspace, 'package.json');
+  if (!fs.existsSync(packageFile)) return { ok: false, reason: 'package-json-missing' };
+  let pkg;
+  try { pkg = JSON.parse(fs.readFileSync(packageFile, 'utf8')); }
+  catch (_) { return { ok: false, reason: 'package-json-invalid' }; }
+  if (!isObject(pkg.scripts) || typeof pkg.scripts[plan.script] !== 'string') {
+    return { ok: false, reason: 'npm-script-missing' };
+  }
+  const dependencyCount =
+    Object.keys(isObject(pkg.dependencies) ? pkg.dependencies : {}).length +
+    Object.keys(isObject(pkg.devDependencies) ? pkg.devDependencies : {}).length +
+    Object.keys(isObject(pkg.optionalDependencies) ? pkg.optionalDependencies : {}).length;
+  if (dependencyCount > 0) {
+    return {
+      ok: false,
+      reason: 'external-dependencies-not-supported-v1',
+      detail: 'node-npm-v1 intentionally supports zero-external-dependency projects only; dependency installation is never inferred or networked',
+    };
+  }
+  return {
+    ok: true,
+    packageName: typeof pkg.name === 'string' ? pkg.name : null,
+    script: plan.script,
+    command: `npm run ${plan.script}`,
+    dependencyMode: 'zero-external-dependencies',
+  };
+}
+
+function copyWorkspace(source) {
+  const sourceRoot = path.resolve(source);
+  if (fs.lstatSync(sourceRoot).isSymbolicLink()) {
+    throw new Error('source workspace contains a symbolic link/reparse-point root');
+  }
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-contract-probe-'));
+  const destination = path.join(root, 'workspace');
+  try {
+    fs.cpSync(sourceRoot, destination, {
+      recursive: true,
+      filter: src => {
+        if (fs.lstatSync(src).isSymbolicLink()) {
+          throw new Error('source workspace contains a symbolic link/reparse-point component');
+        }
+        const relative = path.relative(sourceRoot, src).replace(/\\/g, '/');
+        if (!relative) return true;
+        const head = relative.split('/')[0];
+        return !['.git', 'node_modules', '.harness'].includes(head);
+      },
+    });
+  } catch (error) {
+    fs.rmSync(root, { recursive: true, force: true });
+    throw error;
+  }
+  return { root, workspace: destination };
+}
+
+function runScript(workspace, plan, extraEnv = {}) {
+  const timeout = plan.timeoutMs || DEFAULT_TIMEOUT_MS;
+  // On Windows npm is normally a .cmd shim, which child_process cannot
+  // execute directly without a command shell. The script name is restricted
+  // to a safe identifier by validatePlan(), and no user-provided shell text is
+  // interpolated into the command.
+  const result = spawnSync('npm', ['run', plan.script], {
+    cwd: workspace,
+    encoding: 'utf8',
+    timeout,
+    windowsHide: true,
+    shell: process.platform === 'win32',
+    env: { ...process.env, CI: '1', ...extraEnv },
+  });
+  const stdout = String(result.stdout || '');
+  const stderr = String(result.stderr || '');
+  const combined = stdout + '\n' + stderr;
+  if (result.error) {
+    const timedOut = result.error.code === 'ETIMEDOUT';
+    return {
+      kind: timedOut ? 'timeout' : 'spawn-error',
+      exitCode: null,
+      signal: result.signal || null,
+      outputHash: sha256(combined + String(result.error.message || '')),
+      combined,
+    };
+  }
+  return {
+    kind: 'exit',
+    exitCode: Number.isInteger(result.status) ? result.status : null,
+    signal: result.signal || null,
+    outputHash: sha256(combined),
+    combined,
+  };
+}
+
+function isolatedRegularFile(workspace, relativeTarget) {
+  const root = path.resolve(workspace);
+  const target = path.resolve(root, relativeTarget);
+  const lexical = path.relative(root, target);
+  if (lexical === '..' || lexical.startsWith('..' + path.sep) || path.isAbsolute(lexical)) {
+    throw new Error('replace target escaped isolated workspace');
+  }
+
+  let current = root;
+  for (const segment of lexical.split(path.sep).filter(Boolean)) {
+    current = path.join(current, segment);
+    if (!fs.existsSync(current)) throw new Error('replace target does not exist');
+    const stat = fs.lstatSync(current);
+    if (stat.isSymbolicLink()) {
+      throw new Error('replace target contains symbolic link/reparse-point component');
+    }
+  }
+
+  const realRoot = fs.realpathSync(root);
+  const realTarget = fs.realpathSync(target);
+  const resolved = path.relative(realRoot, realTarget);
+  if (resolved === '..' || resolved.startsWith('..' + path.sep) || path.isAbsolute(resolved)) {
+    throw new Error('replace target resolved outside isolated workspace');
+  }
+  if (!fs.lstatSync(realTarget).isFile()) throw new Error('replace target does not exist');
+  return realTarget;
+}
+
+function applyProbe(workspace, probe) {
+  if (probe.strategy === 'env') return { env: { ...probe.env }, mutation: 'environment-only' };
+
+  const target = isolatedRegularFile(workspace, probe.target);
+  const source = fs.readFileSync(target, 'utf8');
+  const first = source.indexOf(probe.find);
+  const last = source.lastIndexOf(probe.find);
+  if (first < 0) throw new Error('replace find text was not present');
+  if (first !== last) throw new Error('replace find text must match exactly once');
+  fs.writeFileSync(target, source.slice(0, first) + probe.replace + source.slice(first + probe.find.length), 'utf8');
+  return { env: {}, mutation: `replace:${probe.target}` };
+}
+
+function evidenceRef(probe, run) {
+  return `probe:${probe.probeId}:output-sha256:${run.outputHash}`;
+}
+
+function notEvaluatedProbe(probe, reason, failureClass = 'infrastructure', workspaceIsolation = 'isolated') {
+  return {
+    probeId: probe.probeId,
+    requirementId: probe.requirementId,
+    status: 'NOT_EVALUATED',
+    sourceSection: probe.sourceSection,
+    evidenceRef: null,
+    workspaceIsolation,
+    failureClass,
+    adapterReason: reason,
+  };
+}
+
+function executePlan(workspace, plan) {
+  const errors = validatePlan(plan);
+  if (errors.length) return { schemaVersion: VERSION, adapter: ADAPTER, result: 'INVALID_PLAN', errors, probes: [] };
+
+  const discovered = discoverProject(workspace, plan);
+  if (!discovered.ok) {
+    return {
+      schemaVersion: VERSION,
+      adapter: ADAPTER,
+      result: 'NOT_EVALUATED',
+      discovery: discovered,
+      baseline: null,
+      probes: plan.probes.map(probe => notEvaluatedProbe(probe, discovered.reason)),
+      errors: [],
+    };
+  }
+
+  let baselineIsolation;
+  try {
+    baselineIsolation = copyWorkspace(workspace);
+    const baselineRun = runScript(baselineIsolation.workspace, plan);
+    const baseline = {
+      status: baselineRun.kind === 'exit' && baselineRun.exitCode === 0 ? 'PASS' : 'FAIL',
+      exitCode: baselineRun.exitCode,
+      failureClass: baselineRun.kind === 'exit' ? (baselineRun.exitCode === 0 ? 'none' : 'baseline-test') : 'infrastructure',
+      evidenceRef: `baseline:output-sha256:${baselineRun.outputHash}`,
+      workspaceIsolation: 'isolated',
+    };
+    if (baseline.status !== 'PASS') {
+      return {
+        schemaVersion: VERSION,
+        adapter: ADAPTER,
+        result: 'NOT_EVALUATED',
+        discovery: discovered,
+        baseline,
+        probes: plan.probes.map(probe => notEvaluatedProbe(probe, 'baseline-not-green')),
+        errors: [],
+      };
+    }
+  } catch (error) {
+    const reason = String(error.message || error);
+    return {
+      schemaVersion: VERSION,
+      adapter: ADAPTER,
+      result: 'NOT_EVALUATED',
+      discovery: discovered,
+      baseline: {
+        status: 'NOT_EVALUATED',
+        evidenceRef: null,
+        workspaceIsolation: 'not-isolated',
+        failureClass: 'infrastructure',
+        adapterReason: reason,
+      },
+      probes: plan.probes.map(probe =>
+        notEvaluatedProbe(probe, reason, 'infrastructure', 'not-isolated')),
+      errors: [],
+    };
+  } finally {
+    if (baselineIsolation?.root) fs.rmSync(baselineIsolation.root, { recursive: true, force: true });
+  }
+
+  const results = [];
+  for (const probe of plan.probes) {
+    let isolated;
+    try {
+      isolated = copyWorkspace(workspace);
+      const applied = applyProbe(isolated.workspace, probe);
+      const run = runScript(isolated.workspace, plan, applied.env);
+      if (run.kind !== 'exit') {
+        results.push(notEvaluatedProbe(probe, run.kind));
+        continue;
+      }
+      if (run.exitCode === 0) {
+        results.push({
+          probeId: probe.probeId,
+          requirementId: probe.requirementId,
+          status: 'SURVIVED',
+          sourceSection: probe.sourceSection,
+          evidenceRef: evidenceRef(probe, run),
+          workspaceIsolation: 'isolated',
+          failureClass: 'none',
+          adapterReason: 'project-test-suite-remained-green',
+        });
+        continue;
+      }
+      if (run.combined.includes(probe.expectedFailureContains)) {
+        results.push({
+          probeId: probe.probeId,
+          requirementId: probe.requirementId,
+          status: 'KILLED',
+          sourceSection: probe.sourceSection,
+          evidenceRef: evidenceRef(probe, run),
+          workspaceIsolation: 'isolated',
+          failureClass: 'contract',
+          adapterReason: 'expected-observable-contract-failure',
+        });
+      } else {
+        results.push({
+          probeId: probe.probeId,
+          requirementId: probe.requirementId,
+          status: 'INVALID',
+          sourceSection: probe.sourceSection,
+          evidenceRef: evidenceRef(probe, run),
+          workspaceIsolation: 'isolated',
+          failureClass: 'unknown',
+          adapterReason: 'test-failed-without-expected-contract-observable',
+        });
+      }
+    } catch (error) {
+      results.push(notEvaluatedProbe(
+        probe,
+        String(error.message || error),
+        'infrastructure',
+        isolated ? 'isolated' : 'not-isolated',
+      ));
+    } finally {
+      if (isolated?.root) fs.rmSync(isolated.root, { recursive: true, force: true });
+    }
+  }
+
+  return {
+    schemaVersion: VERSION,
+    adapter: ADAPTER,
+    result: results.every(probe => probe.status === 'KILLED') ? 'PROTECTED' :
+      results.some(probe => probe.status === 'SURVIVED') ? 'SURVIVED' : 'NOT_EVALUATED',
+    discovery: discovered,
+    baseline: { status: 'PASS', workspaceIsolation: 'isolated' },
+    probes: results,
+    errors: [],
+  };
+}
+
+function parseArgs(argv) {
+  const args = { workspace: null, plan: null, output: null };
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--workspace') args.workspace = argv[++i];
+    else if (argv[i] === '--plan') args.plan = argv[++i];
+    else if (argv[i] === '--output') args.output = argv[++i];
+    else throw new Error('unknown argument: ' + argv[i]);
+  }
+  if (!args.workspace || !args.plan) throw new Error('Usage: node node-probe-adapter.js --workspace <project> --plan <probe-plan.json> [--output report.json]');
+  return args;
+}
+
+function main() {
+  try {
+    const args = parseArgs(process.argv.slice(2));
+    const workspace = path.resolve(args.workspace);
+    const plan = JSON.parse(fs.readFileSync(path.resolve(args.plan), 'utf8'));
+    const report = executePlan(workspace, plan);
+    const json = JSON.stringify(report, null, 2) + '\n';
+    if (args.output) {
+      fs.mkdirSync(path.dirname(path.resolve(args.output)), { recursive: true });
+      fs.writeFileSync(path.resolve(args.output), json, 'utf8');
+    }
+    process.stdout.write(json);
+    process.exitCode = report.result === 'PROTECTED' ? 0 : report.result === 'SURVIVED' ? 1 : 2;
+  } catch (error) {
+    console.error('[Contract Probe Adapter] ' + error.message);
+    process.exitCode = 2;
+  }
+}
+
+if (require.main === module) main();
+
+module.exports = {
+  ADAPTER,
+  VERSION,
+  applyProbe,
+  discoverProject,
+  executePlan,
+  runScript,
+  safeRelative,
+  validatePlan,
+};

package/plugins/harness-everything/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "harness-everything",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Invariant-first engineering harness for routing, verification, and failure recovery while preserving agent autonomy.",
   "author": {
     "name": "Miya Daniel",

package/scripts/sync-openai-plugin.js

@@ -71,8 +71,11 @@ syncTree(path.join(ROOT, 'scripts', 'lib', 'advisory-text.js'), packageAdvisoryT
 // Contract-integrity is shared runtime, not a directly-routed 27th skill.
 // Package it under the plugin root and rewrite its one canonical TDD import
 // to the packaged skill tree.
-const packageContractAudit = path.join(pluginRoot, 'contract-integrity', 'scripts', 'audit.js');
+const packageContractRoot = path.join(pluginRoot, 'contract-integrity');
+const packageContractAudit = path.join(packageContractRoot, 'scripts', 'audit.js');
 syncTree(path.join(ROOT, 'contract-integrity', 'scripts', 'audit.js'), packageContractAudit);
+syncTree(path.join(ROOT, 'contract-integrity', 'scripts', 'node-probe-adapter.js'), path.join(packageContractRoot, 'scripts', 'node-probe-adapter.js'));
+syncTree(path.join(ROOT, 'contract-integrity', 'ADAPTERS.md'), path.join(packageContractRoot, 'ADAPTERS.md'));
 const contractAuditSource = fs.readFileSync(packageContractAudit, 'utf8');
 fs.writeFileSync(
   packageContractAudit,