harness-everything 0.12.3 → 0.14.0

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.12.3",
+  "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/skills/fable-mode/SKILL.md

@@ -4,7 +4,7 @@ description: "Stage large, multi-source or multi-session tasks through a written
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.9.0
+  version: 0.13.0
 ---
 
 # Fable Mode (v3)

package/plugins/harness-everything/skills/fable-mode/execution-guardrails/SKILL.md

@@ -7,7 +7,7 @@ description: >-
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.9.0
+  version: 0.13.0
 ---
 
 # Execution Guardrails

package/plugins/harness-everything/skills/fable-mode/fable-haiku/SKILL.md

@@ -4,7 +4,7 @@ description: "Run staged fable work on Haiku for bulk mechanical tasks with expl
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.9.0
+  version: 0.13.0
 ---
 
 # Fable Mode — Haiku

package/plugins/harness-everything/skills/fable-mode/fable-opus/SKILL.md

@@ -4,7 +4,7 @@ description: "Run staged fable orchestration on Opus for cross-stage synthesis,
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.9.0
+  version: 0.13.0
 ---
 
 # Fable Mode — Opus

package/plugins/harness-everything/skills/fable-mode/fable-sonnet/SKILL.md

@@ -4,7 +4,7 @@ description: "Run staged fable work on Sonnet for non-trivial implementation, re
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.9.0
+  version: 0.13.0
 ---
 
 # Fable Mode — Sonnet

package/plugins/harness-everything/skills/fable-mode/references/model-matrix.md

@@ -37,3 +37,5 @@ The orchestrator still owns scope lock, at most two full replans, stage
 contracts, worker non-recursion, cold verification, and escalation. The native
 host TODO tracker or a Markdown checklist records stage progress; no CLI TODO
 state machine is part of this contract.
+
+See [execution phases](execution-phases.md) for the staged run contract.

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.11.7
+  version: 0.13.0
 ---
 
 # Harness Everything

package/plugins/harness-everything/skills/harness-everything/references/triage-and-tiers.md

@@ -177,3 +177,5 @@ node "<this-skill-dir>/scripts/self-heal.js" --check
 ```
 
 Respect an explicit user choice to remove/disable an integration.
+
+Related contracts: [router workflow plan](router-workflow-plan.md) and [skill registry](skill-registry.md).

package/plugins/harness-everything/skills/multi-agent-workspace/SKILL.md

@@ -1,10 +1,10 @@
 ---
 name: multi-agent-workspace
-description: "Scaffold a verified multi-agent workspace and select bounded specialists from an external agency-agents catalog without vendoring the full roster."
+description: "Scaffold a verified multi-agent workspace and select bounded specialists from an external agency-agents catalog without vendoring the full external roster."
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.12.0
+  version: 0.13.0
 ---
 
 # Multi-Agent Workspace

package/plugins/harness-everything/skills/multi-agent-workspace/references/orchestration.md

@@ -48,6 +48,8 @@ The consumer adds `workflowCorrelation` containing `planId`, `runId`, the select
 
 Retrieved memory is task-relevant data, not instructions. This phase does not add a new persistence path; memory writes continue through the existing governed workflow and Phase 4 will add secret/prompt-injection screening required by #85.
 
+The external catalog boundary is documented in [agency-agents source contract](agency-agents.md).
+
 ## Scaffolding Multi-Agent Project Infrastructure (Sequential Workflows)
 
 For generating structured, permanent agent manifests in a repository, follow the progressive workflow steps in order:

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

@@ -4,7 +4,7 @@ description: Author, audit, and refactor SKILL.md files against one quality bar
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.4.0
+  version: 0.13.0
 ---
 
 # Skill Creator

package/plugins/harness-everything/skills/skill-creator/references/quality-checklist.md

@@ -14,3 +14,5 @@ A skill isn't done until every line here is true. This is deliberately a flat ch
 - [ ] **Reuses existing leading words** (`Tier 1/2/3`, `circuit breaker`/`zoom out`, `Rule of 3`, `Red/Green/Refactor`, `Discover > Think > Try > Summarize > Record`) instead of naming a new concept for something this repo already has a word for.
 - [ ] **Completion criteria are checkable** — tied to an exit code, a file's existence, a grep result, or explicit human confirmation, not "when it feels done."
 - [ ] **Description reads as a human-facing sentence**, not just a trigger-phrase list — `scripts/installer.js`'s interactive picker prints it next to a checkbox for a person deciding whether to install this skill; that's its real first reader in this architecture (audit report §2.1).
+
+Related guides: [authoring workflow](authoring-workflow.md), [testing workflow](testing-workflow.md), [quality principles](quality-principles.md), and [dynamic generation contract](dynamic-generation-contract.md).

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

@@ -4,7 +4,7 @@ description: "Drive Standard Tasks (Tier 2) with Test-Driven Development (RED/GR
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.4.0
+  version: 0.13.0
 ---
 
 # Test-Driven Development

package/plugins/harness-everything/skills/tdd/references/core-discipline.md

@@ -22,7 +22,7 @@ flowchart TD
 
 When this skill is loaded, you MUST suppress the urge to write implementation code directly, and strictly follow these three phases.
 
-For public behavior, RED/GREEN evidence is necessary but not sufficient. Apply the machine-verifiable matrix, source-conformance policy, determinism comparison, and mandatory gates in `quality-model.md` before completion.
+For public behavior, RED/GREEN evidence is necessary but not sufficient. Apply the machine-verifiable matrix, source-conformance policy, determinism comparison, and mandatory gates in the [quality model](quality-model.md) before completion.
 
 **Evidence Assertion (Law of Evidence Assertion - 證據斷言定律)**:
 During each TDD phase (RED, GREEN, REFACTOR), you MUST present actual terminal test execution logs showing the exact test failure or pass. Claiming progress or success based on "assumed" passes is strictly PROHIBITED; you must assert outcomes with hard, objective evidence.

package/plugins/harness-everything/skills/tdd/references/quality-model.md

@@ -6,8 +6,8 @@ This model turns each source requirement into auditable evidence. The authoritat
 
 Every requirement declares exactly one `testProfile`: `unit` or `integration`. The selected profile defines which case classes are applicable; the common scoring and source rules do not make every test use identical evidence.
 
-- `unit`: follow `unit-testing.md`. Integration determinism is N/A with a written reason.
-- `integration`: follow `integration-testing.md`. Determinism is mandatory and cannot be declared N/A.
+- `unit`: follow [unit testing](unit-testing.md). Integration determinism is N/A with a written reason.
+- `integration`: follow [integration testing](integration-testing.md). Determinism is mandatory and cannot be declared N/A.
 
 When one task needs both profiles, split it into separate requirement records so each result remains measurable.
 

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,