@claude-flow/cli 3.17.0 → 3.18.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.17.0",
+  "version": "3.18.1",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",

package/plugins/ruflo-metaharness/agents/metaharness-architect.md

@@ -38,7 +38,7 @@ needs its own ADR.
 
 ## Tools (subprocess-only, no library imports)
 
-- All skills shell out to `npx metaharness ...` or `npx -p metaharness@latest harness ...` via the `_harness.mjs` shared helper.
+- All skills shell out to the pinned `metaharness` / `harness` binaries (`metaharness@~0.3.0`, local install or one-time versioned cache — never `@latest`) via the `_harness.mjs` shared helper.
 - 60s hard timeout per subprocess.
 - Output captured + parsed; `--json` flag forced unless the script opts out.
 - No `@metaharness/*` import statement appears outside the optional-router path in `v3/@claude-flow/cli/src/ruvector/neural-router.ts`.

package/plugins/ruflo-metaharness/commands/ruflo-metaharness.md

@@ -3,9 +3,11 @@ name: ruflo-metaharness
 description: MetaHarness integration — score, genome, mint, mcp-scan, threat-model — via subprocess invocations honoring ADR-150 architectural constraint
 ---
 
-MetaHarness integration commands. All shell out to `npx metaharness ...`
-or `npx -p metaharness@latest harness ...` via the `_harness.mjs`
-shared helper; no library imports on ruflo's boot path.
+MetaHarness integration commands. All shell out to the PINNED
+`metaharness`/`harness` binaries (`metaharness@~0.3.0` — resolved from a local
+install or a one-time `~/.ruflo/metaharness-cache-<pin>` install, never
+`@latest`) via the `_harness.mjs` shared helper; no library imports on
+ruflo's boot path.
 
 **`harness score [--path .] [--alert-on-fit-below N] [--format table|json]`** -- 5-dimension readiness scorecard (harnessFit / compileConfidence / taskCoverage / toolSafety / memoryUsefulness + estCostPerRunUsd + scaffoldReady).
 1. Run `node plugins/ruflo-metaharness/scripts/score.mjs --path <dir>`

package/plugins/ruflo-metaharness/scripts/_darwin.mjs

@@ -4,6 +4,11 @@
 // but targets the separate darwin binary (`metaharness-darwin`) which is
 // published as its own npm package (`@metaharness/darwin@~0.8.0`).
 //
+// Shared plumbing (degraded classification, --json injection, trailing-JSON
+// parse, degraded emitter) lives in `_invoke.mjs`. What stays here is the
+// genuinely-darwin part: the ASYNC STREAMING variant (`runDarwinAsync`) that
+// long `evolve` runs need for per-generation progress visibility.
+//
 // Three subcommands surfaced (matches darwin 0.8.x — same verbs as 0.3.x,
 // with GEPA-engine evolve flags added upstream: --selection modes,
 // --crossover, --epistasis, --curriculum, --mutator ruvllm, --sandbox):
@@ -28,15 +33,24 @@
 //   smoke shapes only.
 
 import { spawnSync, spawn } from 'node:child_process';
+import {
+  classifyDegraded,
+  importOptionalLibrary,
+  injectJson,
+  makeDegradedEmitter,
+  parseTrailingJson,
+} from './_invoke.mjs';
 
 const DEFAULT_TIMEOUT_MS = 60_000;
 
 // Pinned semver range. Bump in lock-step with optionalDependencies in
 // @claude-flow/cli/package.json + ruflo/package.json. The `~` allows
 // patch upgrades without re-pinning.
-const DARWIN_PIN = '@metaharness/darwin@~0.8.0';
+const DARWIN_PKG = '@metaharness/darwin';
+const DARWIN_PIN_VERSION = '~0.8.0';
+const DARWIN_PIN = `${DARWIN_PKG}@${DARWIN_PIN_VERSION}`;
 
-const DEGRADED_RX = /could not determine executable|404|not installed|MODULE_NOT_FOUND|ENOTFOUND|getaddrinfo|ECONNREFUSED|ETIMEDOUT/i;
+const REASON_PREFIX = 'metaharness-darwin';
 
 function buildArgv(args, wantJson) {
   // `metaharness-darwin` historically does NOT take --json on every
@@ -45,30 +59,14 @@ function buildArgv(args, wantJson) {
   // explicitly request it, but never silently inject it on subcommands
   // that don't accept it. The shape that does support --json is the
   // single-verb `evolve` and `bench verify`.
-  if (!wantJson || args.includes('--json')) return args;
-  return [...args, '--json'];
-}
-
-function classifyDegraded(stderr, exitCode) {
-  if (exitCode === null) return { degraded: true, reason: 'metaharness-darwin-timeout' };
-  if (DEGRADED_RX.test(stderr)) return { degraded: true, reason: 'metaharness-darwin-not-available' };
-  return { degraded: false };
+  return injectJson(args, wantJson);
 }
 
-function maybeParseJson(stdout) {
-  // darwin's evolve emits a final JSON object at end of stdout when --json
-  // is passed; everything before is human-readable progress. Grab the LAST
-  // {...} block, not the first — the first may be a per-generation log line.
-  const matches = [...stdout.matchAll(/\{[\s\S]*?\}/g)];
-  if (matches.length === 0) return null;
-  // Try last match first; fall back to greedy single-block match.
-  for (let i = matches.length - 1; i >= 0; i--) {
-    try { return JSON.parse(matches[i][0]); } catch { /* try previous */ }
-  }
-  const greedy = /\{[\s\S]*\}/.exec(stdout);
-  if (greedy) { try { return JSON.parse(greedy[0]); } catch { return null; } }
-  return null;
-}
+// darwin's evolve emits a final JSON object at end of stdout when --json
+// is passed; everything before is human-readable progress. Grab the LAST
+// {...} block, not the first — the first may be a per-generation log line.
+// (This last-block parse is now the family-wide shared implementation.)
+const maybeParseJson = parseTrailingJson;
 
 /**
  * Sync invocation. Use for short subcommands (`bench verify`, smoke shapes).
@@ -90,7 +88,7 @@ export function runDarwin(args, opts = {}) {
   const durationMs = Date.now() - start;
   const stdout = r.stdout || '';
   const stderr = r.stderr || '';
-  const classified = classifyDegraded(stderr, r.status);
+  const classified = classifyDegraded(stderr, r.status, REASON_PREFIX);
   if (classified.degraded) {
     return {
       stdout, stderr,
@@ -142,7 +140,9 @@ export function runDarwinAsync(args, opts = {}) {
         for (const line of lines) opts.onProgress(line);
       }
     });
+    let timedOut = false;
     const timer = setTimeout(() => {
+      timedOut = true;
       try { p.kill('SIGTERM'); } catch { /* ignore */ }
     }, timeoutMs);
     if (opts.signal) {
@@ -156,13 +156,13 @@ export function runDarwinAsync(args, opts = {}) {
         stdout,
         stderr: stderr + String(e?.message ?? e),
         exitCode: 127, json: null, durationMs: Date.now() - start,
-        degraded: true, reason: 'metaharness-darwin-not-available',
+        degraded: true, reason: `${REASON_PREFIX}-not-available`,
       });
     });
     p.on('close', (code) => {
       clearTimeout(timer);
       const durationMs = Date.now() - start;
-      const classified = classifyDegraded(stderr, code);
+      const classified = classifyDegraded(stderr, timedOut ? null : code, REASON_PREFIX);
       if (classified.degraded) {
         resolve({
           stdout, stderr,
@@ -185,18 +185,26 @@ export function runDarwinAsync(args, opts = {}) {
 /**
  * Match the existing `emitDegradedJsonAndExit` shape used by the
  * metaharness-umbrella scripts so MCP tool consumers see one contract.
+ * Exit 0 — ADR-150 architectural constraint: ruflo continues to function
+ * when MetaHarness is absent. Same posture as the umbrella scripts.
  */
-export function emitDarwinDegradedJsonAndExit(reason) {
-  const payload = {
-    degraded: true,
-    reason,
-    hint: 'Install with `npm i -D ' + DARWIN_PIN + '` or run `npx -y ' + DARWIN_PIN + ' --help` to verify network access.',
-    generatedAt: new Date().toISOString(),
-  };
-  console.log(JSON.stringify(payload, null, 2));
-  // Exit 0 — ADR-150 architectural constraint: ruflo continues to function
-  // when MetaHarness is absent. Same posture as the umbrella scripts.
-  process.exit(0);
-}
+export const emitDarwinDegradedJsonAndExit = makeDegradedEmitter(DARWIN_PKG, DARWIN_PIN_VERSION);
 
 export const DARWIN_VERSION_PIN = DARWIN_PIN;
+
+/**
+ * Resolver for the darwin GEPA LIBRARY entry (`@metaharness/darwin/gepa`).
+ * Lives here (not in gepa.mjs) because gepa.mjs is a CLI script that runs
+ * main() on import — this module is the import-safe home for the darwin
+ * pin. Used by gepa.mjs (genome/validate/render/analyze ops) and by
+ * evolve.mjs --diagnose (failure-class analysis of run transcripts).
+ * Returns the module namespace or null. Never throws on absence.
+ */
+export function importGepa() {
+  return importOptionalLibrary({
+    specifier: '@metaharness/darwin/gepa',
+    pkg: DARWIN_PKG,
+    pinVersion: DARWIN_PIN_VERSION,
+    entryRelPath: 'dist/gepa/index.js',
+  });
+}

package/plugins/ruflo-metaharness/scripts/_harness.mjs

@@ -7,41 +7,147 @@
 // vetted bridge that every skill imports from.
 //
 // CONTRACT
-//   - `runMetaharness(args, opts)` — invoke `npx metaharness <args>`
-//   - `runHarness(args, opts)`     — invoke `npx -p metaharness harness <args>`
-//   - both return `{ stdout, stderr, exitCode, json|null, durationMs }`
+//   - `runMetaharness(args, opts)` — invoke the `metaharness` binary
+//   - `runHarness(args, opts)`     — invoke the sibling `harness` binary
+//   - both return `{ stdout, stderr, exitCode, json|null, durationMs, degraded, reason? }`
 //   - `--json` flag is appended automatically when `opts.json !== false`
 //   - subprocess hard timeout (default 60s) — captured in opts.timeoutMs
-//   - on MODULE_NOT_FOUND or "not installed", returns degraded result with
-//     `degraded: true, reason: 'metaharness-not-available'` — never throws
-//     (ADR-150 graceful-degradation rule #3)
+//   - when the package cannot be resolved/installed, returns degraded result
+//     with `degraded: true, reason: 'metaharness-not-available'` — never
+//     throws (ADR-150 graceful-degradation rule #3). A subprocess killed by
+//     the timeout reports `reason: 'metaharness-timeout'` instead (matches
+//     the sibling _darwin/_redblue helpers).
+//
+// SECURITY + PERF (supersedes the iter-27 npx-with-@latest-dist-tag path)
+// =========================================================================
+// The pre-consolidation implementation shelled to `npx -y` with the @latest
+// dist-tag. Two problems, both fixed here:
+//   1. SECURITY (HIGH): @latest means a compromised upstream publish executes
+//      arbitrary code on user machines on the very next skill invocation.
+//      The version is now PINNED to METAHARNESS_PIN_VERSION (tilde range —
+//      patch updates only) and only bumped deliberately, in lock-step with
+//      optionalDependencies in @claude-flow/cli + ruflo package.json.
+//   2. PERF: @latest forced an npm-registry metadata check on EVERY call.
+//      Resolution is now (a) an already-installed local metaharness
+//      satisfying the pin (walk-up node_modules — free), then (b) a ONE-TIME
+//      `npm install --prefix ~/.ruflo/metaharness-cache-<pin>` versioned
+//      cache (same proven pattern as _redblue.mjs / gepa.mjs), after which
+//      every call is a plain `node <abs-path-to-cli>` spawn — zero network.
+//
+// BOTH BINARIES: the `metaharness` package ships two bins (`metaharness`
+// and `harness`); their entry paths are read from the resolved package.json
+// bin map rather than hardcoded, so upstream layout changes inside the
+// pinned range cannot silently break us.
 
 import { spawnSync, spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+  classifyDegraded,
+  ensureCachedInstall,
+  findLocalPackageDir,
+  injectJson,
+  makeDegradedEmitter,
+  parseTrailingJson,
+} from './_invoke.mjs';
 
 const DEFAULT_TIMEOUT_MS = 60_000;
 
+// Pinned semver range. Bump in lock-step with optionalDependencies in
+// @claude-flow/cli/package.json + ruflo/package.json. NEVER @latest.
+const METAHARNESS_PKG = 'metaharness';
+const METAHARNESS_PIN_VERSION = '~0.3.0';
+
+const REASON_NOT_AVAILABLE = 'metaharness-not-available';
+
+/**
+ * Resolve absolute paths for the two bins shipped by the metaharness
+ * package. Memoized per process — the whole point is that after the first
+ * resolution (or one-time cache install) every call is local-only.
+ */
+let RESOLVED = null;
+function resolveMetaharnessBins() {
+  if (RESOLVED) return RESOLVED;
+  // (a) already-installed local copy satisfying the pin — free.
+  const localDir = findLocalPackageDir(METAHARNESS_PKG, METAHARNESS_PIN_VERSION);
+  if (localDir) {
+    const bins = readBinMap(localDir);
+    if (bins) return (RESOLVED = { ok: true, bins, source: 'local' });
+  }
+  // (b) one-time versioned cache install of the pinned range.
+  const cached = ensureCachedInstall({ pkg: METAHARNESS_PKG, pinVersion: METAHARNESS_PIN_VERSION });
+  if (!cached.ok) {
+    return (RESOLVED = {
+      ok: false,
+      reason: REASON_NOT_AVAILABLE,
+      stderr: cached.stderr ?? cached.error ?? '',
+      stdout: cached.stdout ?? '',
+    });
+  }
+  const bins = readBinMap(cached.pkgDir);
+  if (!bins) {
+    return (RESOLVED = {
+      ok: false,
+      reason: REASON_NOT_AVAILABLE,
+      stderr: `metaharness package at ${cached.pkgDir} is missing the expected bin map (metaharness + harness)`,
+      stdout: '',
+    });
+  }
+  return (RESOLVED = { ok: true, bins, source: 'cache' });
+}
+
+/** Read both bin entry points from the package's bin map. */
+function readBinMap(pkgDir) {
+  try {
+    const pj = JSON.parse(readFileSync(join(pkgDir, 'package.json'), 'utf-8'));
+    const bin = pj.bin || {};
+    if (!bin.metaharness || !bin.harness) return null;
+    const metaharness = join(pkgDir, bin.metaharness);
+    const harness = join(pkgDir, bin.harness);
+    if (!existsSync(metaharness) || !existsSync(harness)) return null;
+    return { metaharness, harness };
+  } catch {
+    return null;
+  }
+}
+
+function degradedResult(resolved, start) {
+  return {
+    stdout: resolved.stdout ?? '',
+    stderr: resolved.stderr ?? '',
+    exitCode: 127,
+    json: null,
+    durationMs: Date.now() - start,
+    degraded: true,
+    reason: resolved.reason ?? REASON_NOT_AVAILABLE,
+  };
+}
+
 /**
- * iter 56 — async variant of execCli. Used by oia-audit.mjs to parallelize
- * its 5 subprocess calls, dropping worst-case wall-clock from 5×TIMEOUT
- * (sequential) to 1×TIMEOUT (parallel). Identical return shape to the
- * sync execCli so callers can swap without ceremony.
+ * Async variant (iter 56) — used by oia-audit.mjs to parallelize its 5
+ * subprocess calls, dropping worst-case wall-clock from 5×TIMEOUT to
+ * 1×TIMEOUT. Identical return shape to the sync path.
  */
-function execCliAsync(npxArgs, opts = {}) {
+function execBinAsync(binName, args, opts = {}) {
+  const start = Date.now();
+  const resolved = resolveMetaharnessBins();
+  if (!resolved.ok) return Promise.resolve(degradedResult(resolved, start));
   return new Promise((resolve) => {
-    const start = Date.now();
     const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const wantJson = opts.json !== false;
-    const argv = wantJson && !npxArgs.includes('--json') ? [...npxArgs, '--json'] : [...npxArgs];
-    const p = spawn('npx', argv, {
+    const argv = injectJson(args, wantJson);
+    const p = spawn('node', [resolved.bins[binName], ...argv], {
       stdio: ['ignore', 'pipe', 'pipe'],
       cwd: opts.cwd,
       env: { ...process.env, ...(opts.env || {}) },
-      shell: process.platform === 'win32',
+      shell: false,
     });
     let stdout = '', stderr = '';
     p.stdout?.on('data', (d) => { stdout += d.toString(); });
     p.stderr?.on('data', (d) => { stderr += d.toString(); });
+    let timedOut = false;
     const timer = setTimeout(() => {
+      timedOut = true;
       try { p.kill('SIGTERM'); } catch { /* ignore */ }
     }, timeoutMs);
     p.on('error', (e) => {
@@ -49,123 +155,87 @@ function execCliAsync(npxArgs, opts = {}) {
       resolve({
         stdout, stderr: stderr + String(e?.message ?? e),
         exitCode: 127, json: null, durationMs: Date.now() - start,
-        degraded: true, reason: 'metaharness-not-available',
+        degraded: true, reason: REASON_NOT_AVAILABLE,
       });
     });
     p.on('close', (code) => {
       clearTimeout(timer);
       const durationMs = Date.now() - start;
-      if (code === null || /could not determine executable|404|not installed|MODULE_NOT_FOUND|ENOTFOUND|getaddrinfo|ECONNREFUSED|ETIMEDOUT/i.test(stderr)) {
+      const classified = classifyDegraded(stderr, timedOut ? null : code, 'metaharness');
+      if (classified.degraded) {
         resolve({
           stdout, stderr,
           exitCode: code ?? 127, json: null, durationMs,
-          degraded: true, reason: 'metaharness-not-available',
+          degraded: true, reason: classified.reason,
         });
         return;
       }
-      let json = null;
-      if (wantJson) {
-        const m = /\{[\s\S]*\}/.exec(stdout);
-        if (m) { try { json = JSON.parse(m[0]); } catch { /* leave null */ } }
-      }
-      resolve({ stdout, stderr, exitCode: code ?? 0, json, durationMs, degraded: false });
+      resolve({
+        stdout, stderr,
+        exitCode: code ?? 0,
+        json: wantJson ? parseTrailingJson(stdout) : null,
+        durationMs,
+        degraded: false,
+      });
     });
   });
 }
 
-export function runMetaharnessAsync(args, opts) {
-  return execCliAsync(['-y', 'metaharness@latest', ...args], opts);
-}
-
-export function runHarnessAsync(args, opts) {
-  return execCliAsync(['-y', '-p', 'metaharness@latest', 'harness', ...args], opts);
-}
-
-// ITER 27 — npx invocation hardening.
-// The pre-iter-27 implementation passed `'-y metaharness@latest'` as a
-// SINGLE argv element to npx (`spawnSync('npx', [bin, ...argv])` where
-// bin contained two whitespace-separated tokens). spawnSync with
-// shell:false does no word-splitting, so npx received a literal string
-// with an embedded space and either failed silently or treated the
-// whole thing as a package name. The graceful-degradation path then
-// reported `degraded: true` for every skill — masking the bug. Every
-// argv token must now be its own array element.
-function execCli(npxArgs, opts = {}) {
+/** Sync invocation of one of the two resolved bins via `node <abs-path>`. */
+function execBin(binName, args, opts = {}) {
   const start = Date.now();
+  const resolved = resolveMetaharnessBins();
+  if (!resolved.ok) return degradedResult(resolved, start);
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const wantJson = opts.json !== false;
-  const argv = wantJson && !npxArgs.includes('--json') ? [...npxArgs, '--json'] : [...npxArgs];
-  const r = spawnSync('npx', argv, {
+  const argv = injectJson(args, wantJson);
+  const r = spawnSync('node', [resolved.bins[binName], ...argv], {
     stdio: ['ignore', 'pipe', 'pipe'],
     encoding: 'utf-8',
     timeout: timeoutMs,
     cwd: opts.cwd,  // iter 27 — let callers redirect $CWD (mint.mjs needs this)
     env: { ...process.env, ...(opts.env || {}) },
-    shell: process.platform === 'win32',
+    shell: false,
   });
   const durationMs = Date.now() - start;
   const stdout = r.stdout || '';
   const stderr = r.stderr || '';
-  // Graceful degradation — npx couldn't find the binary.
-  if (r.status === null || /could not determine executable|404|not installed|MODULE_NOT_FOUND|ENOTFOUND|getaddrinfo|ECONNREFUSED|ETIMEDOUT/i.test(stderr)) {
+  const classified = classifyDegraded(stderr, r.status, 'metaharness');
+  if (classified.degraded) {
     return {
       stdout, stderr,
       exitCode: r.status ?? 127,
       json: null,
       durationMs,
       degraded: true,
-      reason: 'metaharness-not-available',
+      reason: classified.reason,
     };
   }
-  let json = null;
-  if (wantJson) {
-    const m = /\{[\s\S]*\}/.exec(stdout);
-    if (m) { try { json = JSON.parse(m[0]); } catch { /* leave null */ } }
-  }
-  return { stdout, stderr, exitCode: r.status ?? 0, json, durationMs, degraded: false };
+  return {
+    stdout, stderr,
+    exitCode: r.status ?? 0,
+    json: wantJson ? parseTrailingJson(stdout) : null,
+    durationMs,
+    degraded: false,
+  };
 }
 
 export function runMetaharness(args, opts) {
-  // iter 27 — explicit argv tokens (was: '-y metaharness@latest' as one
-  // string, which silently degraded every skill).
-  return execCli(['-y', 'metaharness@latest', ...args], opts);
+  return execBin('metaharness', args, opts);
 }
 
 export function runHarness(args, opts) {
-  // The `harness` binary ships inside the `metaharness` package, so we
-  // need `npx -p metaharness@latest harness <args>`. spawnSync receives
-  // a single argv array, so encode the `-p` flag as its own argument.
-  const start = Date.now();
-  const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const wantJson = opts?.json !== false;
-  const argv = wantJson && !args.includes('--json') ? [...args, '--json'] : [...args];
-  const r = spawnSync('npx', ['-y', '-p', 'metaharness@latest', 'harness', ...argv], {
-    stdio: ['ignore', 'pipe', 'pipe'],
-    encoding: 'utf-8',
-    timeout: timeoutMs,
-    cwd: opts?.cwd,  // iter 27 — same cwd-redirect support as runMetaharness
-    env: { ...process.env, ...(opts?.env || {}) },
-    shell: process.platform === 'win32',
-  });
-  const durationMs = Date.now() - start;
-  const stdout = r.stdout || '';
-  const stderr = r.stderr || '';
-  if (r.status === null || /could not determine executable|404|not installed|MODULE_NOT_FOUND|ENOTFOUND|getaddrinfo|ECONNREFUSED|ETIMEDOUT/i.test(stderr)) {
-    return {
-      stdout, stderr,
-      exitCode: r.status ?? 127,
-      json: null,
-      durationMs,
-      degraded: true,
-      reason: 'metaharness-not-available',
-    };
-  }
-  let json = null;
-  if (wantJson) {
-    const m = /\{[\s\S]*\}/.exec(stdout);
-    if (m) { try { json = JSON.parse(m[0]); } catch { /* leave null */ } }
-  }
-  return { stdout, stderr, exitCode: r.status ?? 0, json, durationMs, degraded: false };
+  // The `harness` binary ships inside the same `metaharness` package —
+  // resolved from the package.json bin map above.
+  return execBin('harness', args, opts);
+}
+
+export function runMetaharnessAsync(args, opts) {
+  return execBinAsync('metaharness', args, opts);
+}
+
+export function runHarnessAsync(args, opts) {
+  return execBinAsync('harness', args, opts);
 }
 
 /**
@@ -244,18 +314,17 @@ export function parseMcpScanText(stdout) {
   return { findings, summary };
 }
 
-// Convenience emitters for skill scripts — keep the boilerplate out of
+// Convenience emitter for skill scripts — keep the boilerplate out of
 // each skill so they focus on argument parsing + exit-code semantics.
-export function emitDegradedJsonAndExit(reason) {
-  const payload = {
-    degraded: true,
-    reason,
-    hint: 'Install metaharness manually with `npm i -D metaharness` or run `npx metaharness@latest --version` to verify network access.',
-    generatedAt: new Date().toISOString(),
-  };
-  console.log(JSON.stringify(payload, null, 2));
-  // Exit 0 — ADR-150 architectural constraint says ruflo continues to
-  // function when MetaHarness is absent. Skills emit a structured
-  // degraded payload rather than failing.
-  process.exit(0);
+// Exit 0 — ADR-150 architectural constraint says ruflo continues to
+// function when MetaHarness is absent. Skills emit a structured
+// degraded payload rather than failing.
+export const emitDegradedJsonAndExit = makeDegradedEmitter(METAHARNESS_PKG, METAHARNESS_PIN_VERSION);
+
+export const METAHARNESS_VERSION_PIN = `${METAHARNESS_PKG}@${METAHARNESS_PIN_VERSION}`;
+
+/** Expose resolution for diagnostics/tests (which path served the bins). */
+export function metaharnessResolution() {
+  const r = resolveMetaharnessBins();
+  return r.ok ? { ok: true, source: r.source, bins: r.bins } : { ok: false, reason: r.reason };
 }