@claude-flow/cli 3.12.0 → 3.12.2

package/plugins/ruflo-metaharness/scripts/test-similarity.mjs

@@ -0,0 +1,334 @@
+#!/usr/bin/env node
+// test-similarity.mjs — unit tests for the iter-36 production module
+// `_similarity.mjs` (ADR-152 §3.1).
+//
+// The spike (_spike-similarity.mjs) verifies the two architectural
+// invariants on synthetic fixtures. This test exercises each public
+// function in isolation: projectToVec, cosine, categoricalAgreement,
+// jaccard, similarity, opts.weights override, opts.perDimension shape.
+//
+// CONTRACT EACH FUNCTION MUST SATISFY
+//   - input contract documented in _similarity.mjs holds
+//   - missing optional fields default safely (graceful, never throws)
+//   - numerical results are deterministic (no floats from Math.random)
+//   - return shapes match ADR-152 §"return shape"
+//
+// USAGE
+//   node scripts/test-similarity.mjs
+//   node scripts/test-similarity.mjs --format json
+//
+// EXIT
+//   0  all unit tests pass
+//   1  at least one test failed
+
+import {
+  projectToVec, cosine, categoricalAgreement, jaccard, similarity,
+} from './_similarity.mjs';
+// iter 64 — also test the iter-63 shared severity primitives
+import { SEVERITY_RANK, rankSeverity, parseMcpScanText } from './_harness.mjs';
+
+const ARGS = (() => {
+  const a = { format: 'table' };
+  for (let i = 2; i < process.argv.length; i++) {
+    if (process.argv[i] === '--format') a.format = process.argv[++i];
+  }
+  return a;
+})();
+
+let passed = 0, failed = 0;
+const failures = [];
+
+function assert(cond, label) {
+  if (cond) { console.log(`  ✓ ${label}`); passed++; }
+  else { console.log(`  ✗ ${label}`); failures.push(label); failed++; }
+}
+
+function approx(a, b, eps = 0.0001) {
+  return Math.abs(a - b) < eps;
+}
+
+// ──────────────────────────────────────────────────────────────────
+// FIXTURES — share two harness shapes across all tests
+// ──────────────────────────────────────────────────────────────────
+
+const A = {
+  score: {
+    harnessFit: 80, compileConfidence: 100, taskCoverage: 70, toolSafety: 90,
+    memoryUsefulness: 50, estCostPerRunUsd: 0.05, recommendedMode: 'CLI + MCP',
+    archetype: 'typescript-sdk-harness', template: 'vertical:coding',
+  },
+  genome: {
+    repo_type: 'node_mcp_ci',
+    agent_topology: ['maintainer', 'tester', 'security'],
+    risk_score: 0.3, test_confidence: 0.85, publish_readiness: 0.9,
+  },
+};
+
+const B = {
+  score: {
+    harnessFit: 60, compileConfidence: 80, taskCoverage: 50, toolSafety: 70,
+    memoryUsefulness: 30, estCostPerRunUsd: 0.02, recommendedMode: 'CLI',
+    archetype: 'python-agent-harness', template: 'vertical:devops',
+  },
+  genome: {
+    repo_type: 'python_ops',
+    agent_topology: ['deployer', 'rollback'],
+    risk_score: 0.1, test_confidence: 0.6, publish_readiness: 0.5,
+  },
+};
+
+// ──────────────────────────────────────────────────────────────────
+console.log(`# test-similarity — _similarity.mjs unit tests (iter 39)\n`);
+
+console.log('Phase 1 — projectToVec');
+const vA = projectToVec(A);
+assert(Array.isArray(vA), 'returns an array');
+assert(vA.length === 9, 'returns 9-dim vector (ADR-152 §Decision Table 1)');
+assert(approx(vA[0], 0.80), 'index 0 = harnessFit/100 (80 → 0.80)');
+assert(approx(vA[1], 1.00), 'index 1 = compileConfidence/100 (100 → 1.00)');
+assert(approx(vA[2], 0.70), 'index 2 = taskCoverage/100');
+assert(approx(vA[3], 0.90), 'index 3 = toolSafety/100');
+assert(approx(vA[4], 0.50), 'index 4 = memoryUsefulness/100');
+assert(approx(vA[5], 0.30), 'index 5 = risk_score (already 0..1)');
+assert(approx(vA[6], 0.85), 'index 6 = test_confidence');
+assert(approx(vA[7], 0.90), 'index 7 = publish_readiness');
+// Missing-field defaults safely (graceful degradation)
+const vEmpty = projectToVec({});
+assert(vEmpty.length === 9, 'empty input still returns 9-dim');
+assert(vEmpty.every((x) => typeof x === 'number'), 'all elements numeric (no NaN propagation)');
+const vNoGenome = projectToVec({ score: A.score });
+assert(approx(vNoGenome[5], 0), 'missing genome → risk_score=0 default');
+assert(approx(vNoGenome[0], 0.80), 'missing genome does not corrupt score-derived indices');
+
+console.log('\nPhase 2 — cosine');
+assert(approx(cosine(vA, vA), 1), 'cosine(x, x) === 1');
+assert(approx(cosine([1, 0], [0, 1]), 0), 'orthogonal vectors → 0');
+assert(approx(cosine([0, 0, 0], [1, 1, 1]), 0), 'zero vector → 0 (graceful divide-by-zero)');
+assert(cosine([1, 2], [1, 2, 3]) === 0, 'length mismatch → 0 (graceful)');
+assert(cosine(null, vA) === 0, 'null input → 0 (graceful)');
+const cosAB = cosine(vA, projectToVec(B));
+assert(cosAB >= 0 && cosAB <= 1, 'output bounded to [0, 1] for nonneg vectors');
+
+console.log('\nPhase 3 — categoricalAgreement');
+assert(approx(categoricalAgreement(A, A), 1), 'identical input → 1 (all 4 enums match)');
+assert(approx(categoricalAgreement(A, B), 0), 'A vs B → 0 (all 4 enums differ)');
+assert(approx(categoricalAgreement({}, {}), 0), 'both empty → 0 (no matches counted)');
+// Partial match — 2 of 4 fields agree
+const partial = {
+  score: { archetype: A.score.archetype, template: 'different', recommendedMode: A.score.recommendedMode },
+  genome: { repo_type: 'different' },
+};
+assert(approx(categoricalAgreement(A, partial), 0.5),
+  '2-of-4 partial match → 0.5 (archetype + recommendedMode)');
+
+console.log('\nPhase 4 — jaccard');
+assert(approx(jaccard(A, A), 1), 'identical topology → 1');
+assert(approx(jaccard(A, B), 0), 'disjoint topology → 0');
+assert(approx(jaccard({ genome: {} }, { genome: {} }), 1),
+  'both empty topology → 1 (set-equality convention)');
+const overlap = {
+  genome: { agent_topology: ['maintainer', 'tester', 'extra'] },
+};
+// A has {maintainer, tester, security}; overlap has {maintainer, tester, extra}
+// |A ∩ B|=2, |A ∪ B|=4 → 2/4 = 0.5
+assert(approx(jaccard(A, overlap), 0.5), 'partial topology overlap → |∩|/|∪|');
+
+console.log('\nPhase 5 — similarity composite + return shape');
+const sAA = similarity(A, A);
+assert(typeof sAA === 'object' && sAA !== null, 'returns object');
+assert(typeof sAA.overall === 'number', 'overall is numeric');
+assert(approx(sAA.overall, 1), 'similarity(X, X).overall === 1');
+assert(typeof sAA.components === 'object', 'components present');
+assert(approx(sAA.components.cosine, 1), 'components.cosine === 1 on self-match');
+assert(approx(sAA.components.categorical, 1), 'components.categorical === 1');
+assert(approx(sAA.components.jaccard, 1), 'components.jaccard === 1');
+assert(typeof sAA.weights === 'object', 'weights echoed in return');
+assert(approx(sAA.weights.cosine, 0.6), 'default cosine weight = 0.6 (ADR-152)');
+assert(approx(sAA.weights.categorical, 0.25), 'default categorical weight = 0.25');
+assert(approx(sAA.weights.jaccard, 0.15), 'default jaccard weight = 0.15');
+assert(approx(sAA.weights.cosine + sAA.weights.categorical + sAA.weights.jaccard, 1),
+  'default weights sum to 1');
+
+console.log('\nPhase 6 — similarity opts.weights override');
+const reweighted = similarity(A, B, { weights: { cosine: 0, categorical: 0, jaccard: 1 } });
+const jacOnly = jaccard(A, B);
+assert(approx(reweighted.overall, jacOnly),
+  'opts.weights cosine=0/cat=0/jac=1 → overall === jaccard');
+const reweighted2 = similarity(A, A, { weights: { cosine: 0.5, categorical: 0.3, jaccard: 0.2 } });
+assert(approx(reweighted2.overall, 1),
+  'self-match holds under any weight scheme');
+
+console.log('\nPhase 7 — similarity opts.perDimension shape');
+const sPD = similarity(A, B, { perDimension: true });
+assert(typeof sPD.perDimension === 'object', 'perDimension included when requested');
+assert('numeric.harnessFit' in sPD.perDimension,
+  'perDimension exposes each numeric feature by name');
+assert('categorical.archetype' in sPD.perDimension,
+  'perDimension exposes each categorical field by name');
+assert('set.agent_topology' in sPD.perDimension,
+  'perDimension exposes the set-typed feature');
+const hf = sPD.perDimension['numeric.harnessFit'];
+assert(hf.a === 80 && hf.b === 60, 'perDimension preserves raw a/b values');
+assert(typeof hf.contribution === 'number', 'perDimension has numeric contribution');
+const sNoPD = similarity(A, B);
+assert(!('perDimension' in sNoPD), 'perDimension omitted by default');
+
+console.log('\nPhase 8 — round-trip with the iter-35 spike fixtures (regression anchor)');
+// Hard-coded spike numbers from `_spike-similarity.mjs` — ANY change
+// here means the production module drifted from the spike's frozen
+// invariants (catches future weight or normalization changes).
+const LEGAL = {
+  score: { harnessFit: 78, compileConfidence: 92, taskCoverage: 65, toolSafety: 88, memoryUsefulness: 70, estCostPerRunUsd: 0.04, recommendedMode: 'CLI + MCP', archetype: 'compliance-harness', template: 'vertical:legal' },
+  genome: { repo_type: 'node_mcp_ci', agent_topology: ['contract-analyst', 'redline-reviewer', 'risk-rater', 'compliance-officer'], risk_score: 0.45, test_confidence: 0.7, publish_readiness: 0.6 },
+};
+const SUPPORT = {
+  score: { harnessFit: 75, compileConfidence: 90, taskCoverage: 70, toolSafety: 90, memoryUsefulness: 72, estCostPerRunUsd: 0.05, recommendedMode: 'CLI + MCP', archetype: 'compliance-harness', template: 'vertical:support' },
+  genome: { repo_type: 'node_mcp_ci', agent_topology: ['triager', 'kb-searcher', 'responder', 'risk-rater', 'compliance-officer'], risk_score: 0.40, test_confidence: 0.75, publish_readiness: 0.65 },
+};
+const sLS = similarity(LEGAL, SUPPORT);
+assert(sLS.overall === 0.8296,
+  `LEGAL × SUPPORT overall must be exactly 0.8296 (got ${sLS.overall})`);
+assert(sLS.components.cosine === 0.9987,
+  `LEGAL × SUPPORT cosine must be 0.9987 (got ${sLS.components.cosine})`);
+assert(sLS.components.categorical === 0.75,
+  `LEGAL × SUPPORT categorical must be 0.75 (got ${sLS.components.categorical})`);
+assert(sLS.components.jaccard === 0.2857,
+  `LEGAL × SUPPORT jaccard must be 0.2857 (got ${sLS.components.jaccard})`);
+
+console.log('\nPhase 9 — iter-63 shared SEVERITY_RANK + rankSeverity()');
+// Known severities — full vocab the iter-50 parser produces
+assert(SEVERITY_RANK.clean === 0, 'rank.clean === 0');
+assert(SEVERITY_RANK.info === 0, 'rank.info === 0 (informational, no harm)');
+assert(SEVERITY_RANK.low === 1, 'rank.low === 1');
+assert(SEVERITY_RANK.medium === 2, 'rank.medium === 2');
+assert(SEVERITY_RANK.warn === 2, 'rank.warn === 2 (warn ≈ medium)');
+assert(SEVERITY_RANK.high === 3, 'rank.high === 3');
+assert(SEVERITY_RANK.error === 3, 'rank.error === 3 (error ≈ high)');
+assert(SEVERITY_RANK.critical === 4, 'rank.critical === 4 (elevated above high)');
+
+// Object.freeze blocks mutation — anti-tamper guard
+const before = SEVERITY_RANK.high;
+let mutated = false;
+try { SEVERITY_RANK.high = 999; mutated = SEVERITY_RANK.high !== before; } catch { /* strict mode throws */ }
+assert(!mutated, 'SEVERITY_RANK frozen — mutation does not stick');
+
+// rankSeverity safe accessor
+assert(rankSeverity('info') === 0, 'rankSeverity("info") === 0');
+assert(rankSeverity('CRITICAL') === 4, 'rankSeverity case-insensitive ("CRITICAL" → 4)');
+assert(rankSeverity('Warn') === 2, 'rankSeverity case-insensitive ("Warn" → 2)');
+assert(rankSeverity('unknown') === 0, 'rankSeverity("unknown") === 0 (no NaN)');
+assert(rankSeverity(null) === 0, 'rankSeverity(null) === 0');
+assert(rankSeverity(undefined) === 0, 'rankSeverity(undefined) === 0');
+assert(rankSeverity('') === 0, 'rankSeverity("") === 0');
+assert(rankSeverity(' high ') === 0,
+  'rankSeverity does not strip whitespace (returns 0 for non-normalized input)');
+
+// Rollup pattern mirrors oia-audit's reduce
+function rollup(findings) {
+  return findings.reduce((acc, f) => {
+    const s = String(f.severity || 'low').toLowerCase();
+    return rankSeverity(s) > rankSeverity(acc) ? s : acc;
+  }, 'clean');
+}
+assert(rollup([{ severity: 'info' }]) === 'clean',
+  'rollup info-only stays clean');
+assert(rollup([{ severity: 'warn' }]) === 'warn',
+  'rollup warn-only elevates to warn (was NaN-ignored pre-iter-63)');
+assert(rollup([{ severity: 'critical' }, { severity: 'info' }]) === 'critical',
+  'rollup with critical elevates above info');
+assert(rollup([{ severity: 'low' }, { severity: 'warn' }, { severity: 'high' }, { severity: 'critical' }]) === 'critical',
+  'rollup picks max across mixed severities');
+assert(rollup([{ severity: 'unknown-strange-value' }]) === 'clean',
+  'rollup with unknown severity stays clean (safe default)');
+
+console.log('\nPhase 10 — iter-50 parseMcpScanText edge cases');
+
+// Empty input — graceful return shape
+const empty = parseMcpScanText('');
+assert(Array.isArray(empty.findings) && empty.findings.length === 0,
+  'parseMcpScanText("") → findings:[]');
+assert(empty.summary === null, 'parseMcpScanText("") → summary:null');
+
+// null / undefined safe
+const nullParsed = parseMcpScanText(null);
+assert(Array.isArray(nullParsed.findings) && nullParsed.findings.length === 0,
+  'parseMcpScanText(null) → findings:[]');
+const undefParsed = parseMcpScanText(undefined);
+assert(Array.isArray(undefParsed.findings) && undefParsed.findings.length === 0,
+  'parseMcpScanText(undefined) → findings:[]');
+
+// Single finding — happy path
+const single = parseMcpScanText(`harness mcp-scan — /repo
+
+  [INFO] No MCP security issues found
+
+Result: INFO (1 finding, 0 high)
+`);
+assert(single.findings.length === 1, 'single [INFO] block → 1 finding');
+assert(single.findings[0].severity === 'info', 'severity lowercased');
+assert(single.findings[0].message === 'No MCP security issues found',
+  'message extracted');
+assert(single.summary?.overallSeverity === 'info',
+  'summary.overallSeverity from Result: line');
+assert(single.summary?.totalCount === 1,
+  'summary.totalCount === 1 from "(1 finding,"');
+
+// Continuation line — indented text appends to previous finding
+const cont = parseMcpScanText(`
+  [HIGH] Exposed credential path
+         Detected in .mcp/servers.json line 12
+         Recommended action: rotate immediately
+
+Result: HIGH (1 finding, 1 high)
+`);
+assert(cont.findings.length === 1, 'finding with continuation = 1 entry');
+assert(cont.findings[0].severity === 'high', 'HIGH lowercased to high');
+assert(cont.findings[0].message.includes('Detected in') &&
+       cont.findings[0].message.includes('rotate immediately'),
+  'continuation lines appended to message');
+
+// Multiple findings — distinct entries
+const multi = parseMcpScanText(`
+  [WARN] First issue
+  [HIGH] Second issue
+  [CRITICAL] Third issue
+
+Result: HIGH (3 findings, 2 high)
+`);
+assert(multi.findings.length === 3, 'multiple findings = 3 entries');
+assert(multi.findings.map((f) => f.severity).join(',') === 'warn,high,critical',
+  'severities preserved in order');
+assert(multi.summary?.totalCount === 3, 'multi summary totalCount === 3');
+
+// No Result: line — summary stays null but findings still parsed
+const noResult = parseMcpScanText(`  [INFO] Lone finding\n`);
+assert(noResult.findings.length === 1, 'no Result: line → still parses findings');
+assert(noResult.summary === null, 'no Result: line → summary === null');
+
+// Mixed-case severity in source — parser is intentionally strict: regex
+// captures `[A-Z]+` so mixed-case 'Warn' WON'T match. This is the
+// documented contract — upstream emits all-uppercase markers.
+const mixed = parseMcpScanText('  [Warn] Something\n  [HIGH] Other\n');
+assert(mixed.findings.length === 1,
+  'strict regex skips mixed-case [Warn], captures [HIGH] only');
+assert(mixed.findings[0].severity === 'high',
+  'strict regex captured the uppercase entry');
+
+// ──────────────────────────────────────────────────────────────────
+const summary = {
+  passed, failed,
+  failures,
+  total: passed + failed,
+  graduates: failed === 0,
+};
+
+console.log(`\n${passed} passed, ${failed} failed`);
+if (ARGS.format === 'json') {
+  console.log(JSON.stringify(summary, null, 2));
+}
+if (failed > 0) {
+  console.log('\nFailures:');
+  for (const f of failures) console.log(`  - ${f}`);
+  process.exit(1);
+}
+console.log('\n✓ All _similarity.mjs unit tests pass (ADR-152 §3.1 production contract).');

package/plugins/ruflo-metaharness/scripts/test-with-openrouter.mjs

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+// test-with-openrouter.mjs — runtime test that exercises metaharness
+// scaffolding + lifecycle commands using OPENROUTER_API_KEY fetched
+// from GCP Secret Manager.
+//
+// WHAT IT DOES (end-to-end)
+//   1. Fetch OPENROUTER_API_KEY from GCP Secret Manager via
+//      `gcloud secrets versions access latest --secret=OPENROUTER_API_KEY`
+//   2. Verify the secret authenticates against OpenRouter by listing
+//      models (1 HTTP call, ~$0)
+//   3. Scaffold a fresh harness into a temp dir via
+//      `metaharness new --name test-h --template vertical:coding
+//      --host claude-code --yes`
+//   4. Run lifecycle commands against the scaffold:
+//        - harness doctor    (smoke health check)
+//        - harness validate  (full validation; --skip-gcp to avoid
+//                             nested GCP fetches in this test)
+//        - harness score     (5-dim scorecard of the scaffolded
+//                             harness itself)
+//        - harness genome    (7-section report)
+//   5. (Optional) make one real LLM call through OpenRouter to a
+//      cheap model (e.g. openrouter/auto with a 1-token prompt) to
+//      prove the token works for actual inference
+//   6. Clean up the temp dir
+//
+// COST: ~$0 (1 model-list call + optional <$0.0001 inference call)
+//
+// USAGE
+//   node scripts/test-with-openrouter.mjs                 # full e2e
+//   node scripts/test-with-openrouter.mjs --skip-inference  # no LLM call
+//   node scripts/test-with-openrouter.mjs --keep-fixtures # leave scaffold for inspection
+//
+// EXIT CODES
+//   0  all checks passed
+//   1  at least one assertion failed
+//   2  setup error (gcloud not authed, OPENROUTER_API_KEY missing in GCP, etc.)
+//   3  cost/safety guard tripped
+
+import { spawnSync, execSync } from 'node:child_process';
+import { mkdtempSync, rmSync, mkdirSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const ARGS = (() => {
+  const a = { skipInference: false, keep: false, format: 'table' };
+  for (let i = 2; i < process.argv.length; i++) {
+    const v = process.argv[i];
+    if (v === '--skip-inference') a.skipInference = true;
+    else if (v === '--keep-fixtures') a.keep = true;
+    else if (v === '--format') a.format = process.argv[++i];
+  }
+  return a;
+})();
+
+let passed = 0, failed = 0;
+const failures = [];
+function assert(cond, label) {
+  if (cond) { console.log(`  ✓ ${label}`); passed++; }
+  else { console.log(`  ✗ ${label}`); failures.push(label); failed++; }
+}
+
+function fetchSecretFromGcp(secretName) {
+  try {
+    const out = execSync(
+      `gcloud secrets versions access latest --secret=${secretName}`,
+      { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 15_000 },
+    );
+    return out.trim();
+  } catch (e) {
+    console.error(`  ⚠ gcloud secret fetch failed: ${(e.message || '').slice(0, 120)}`);
+    return null;
+  }
+}
+
+async function listOpenRouterModels(apiKey) {
+  const resp = await fetch('https://openrouter.ai/api/v1/models', {
+    headers: { Authorization: `Bearer ${apiKey}` },
+  });
+  if (!resp.ok) {
+    return { ok: false, status: resp.status, body: (await resp.text()).slice(0, 200) };
+  }
+  const data = await resp.json();
+  return { ok: true, modelCount: data.data?.length ?? 0 };
+}
+
+async function cheapInferenceCall(apiKey) {
+  // openrouter/auto picks the cheapest viable model; 5-token prompt;
+  // max_tokens=1 to bound cost at ~$0.00005.
+  const resp = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+      'HTTP-Referer': 'https://github.com/ruvnet/ruflo',
+      'X-Title': 'ruflo-metaharness-test',
+    },
+    body: JSON.stringify({
+      model: 'openrouter/auto',
+      messages: [{ role: 'user', content: 'OK' }],
+      max_tokens: 1,
+    }),
+  });
+  if (!resp.ok) return { ok: false, status: resp.status, body: (await resp.text()).slice(0, 200) };
+  const data = await resp.json();
+  return { ok: true, model: data.model, usage: data.usage };
+}
+
+function runHarness(args, opts = {}) {
+  const r = spawnSync('npx', ['-y', '-p', 'metaharness@latest', 'harness', ...args], {
+    stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf-8',
+    timeout: opts.timeoutMs ?? 60_000,
+    env: { ...process.env, ...opts.env },
+  });
+  return { exitCode: r.status ?? 1, stdout: r.stdout || '', stderr: r.stderr || '' };
+}
+
+function runMetaharness(args, opts = {}) {
+  const r = spawnSync('npx', ['-y', 'metaharness@latest', ...args], {
+    stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf-8',
+    timeout: opts.timeoutMs ?? 120_000,
+    cwd: opts.cwd,  // metaharness new writes to cwd/<name>; --target is ignored
+    env: { ...process.env, ...opts.env },
+  });
+  return { exitCode: r.status ?? 1, stdout: r.stdout || '', stderr: r.stderr || '' };
+}
+
+async function main() {
+  console.log('# test-with-openrouter — metaharness × GCP × OpenRouter e2e\n');
+
+  // ── 0. Preflight ──────────────────────────────────────────────────
+  console.log('Phase 0 — preflight');
+  const gcloudWho = execSync('gcloud config get-value account 2>&1', { encoding: 'utf-8' }).trim();
+  assert(!!gcloudWho && !/None/.test(gcloudWho), `gcloud authenticated (${gcloudWho || 'none'})`);
+
+  // ── 1. Fetch OPENROUTER_API_KEY ───────────────────────────────────
+  console.log('\nPhase 1 — fetch OPENROUTER_API_KEY from GCP Secret Manager');
+  const apiKey = fetchSecretFromGcp('OPENROUTER_API_KEY');
+  assert(typeof apiKey === 'string' && apiKey.length > 20, 'OPENROUTER_API_KEY fetched (length OK)');
+  if (!apiKey) {
+    console.error('Setup error: cannot proceed without OPENROUTER_API_KEY. Skipping further phases.');
+    process.exit(2);
+  }
+  // Echo only length+prefix, never the raw key
+  console.log(`  key length: ${apiKey.length}, prefix: ${apiKey.slice(0, 7)}…`);
+
+  // ── 2. Verify the key authenticates against OpenRouter ────────────
+  console.log('\nPhase 2 — verify OpenRouter authentication');
+  const modelsResp = await listOpenRouterModels(apiKey);
+  assert(modelsResp.ok, `OpenRouter /api/v1/models returns 2xx (got ${modelsResp.ok ? 'ok' : modelsResp.status})`);
+  if (modelsResp.ok) {
+    assert(modelsResp.modelCount > 10, `model list non-empty (${modelsResp.modelCount} models)`);
+  }
+
+  // ── 3. Scaffold a fresh harness ───────────────────────────────────
+  // CRITICAL: `metaharness new <name>` writes to $CWD/<name> — the
+  // --target flag is ignored by the CLI (verified 2026-06-16 against
+  // metaharness@0.1.11). Run from inside a fresh temp dir so the
+  // scaffold lands there, not in the ruflo project root.
+  console.log('\nPhase 3 — scaffold a fresh harness');
+  const fixture = mkdtempSync(join(tmpdir(), 'ruflo-mh-openrouter-'));
+  const target = join(fixture, 'test-harness');
+  console.log(`  fixture cwd: ${fixture}`);
+  console.log(`  expected target: ${target}`);
+  const scaffold = runMetaharness(
+    ['test-harness', '--template', 'vertical:coding', '--host', 'claude-code'],
+    { timeoutMs: 180_000, cwd: fixture },
+  );
+  assert(scaffold.exitCode === 0, `metaharness new exit 0 (got ${scaffold.exitCode})`);
+  assert(existsSync(target), `target dir created at ${target}`);
+
+  // ── 4. Run lifecycle commands against the scaffold ────────────────
+  console.log('\nPhase 4 — lifecycle commands on the scaffold');
+  // harness doctor — quick smoke
+  const doc = runHarness(['doctor', target]);
+  assert(doc.exitCode === 0, `harness doctor exit 0 (got ${doc.exitCode})`);
+
+  // harness score on the scaffold itself
+  const score = runHarness(['score', target, '--json']);
+  assert(score.exitCode === 0, `harness score exit 0 (got ${score.exitCode})`);
+  const scoreJson = (() => {
+    const m = /\{[\s\S]*\}/.exec(score.stdout);
+    try { return m ? JSON.parse(m[0]) : null; } catch { return null; }
+  })();
+  assert(scoreJson && typeof scoreJson.score === 'number', 'score.json has numeric score');
+
+  // harness genome — exit 0 (ready) or 1 (needs-work) both acceptable.
+  // Only exit 2 (blocked / scan-error) is a real failure.
+  const gen = runHarness(['genome', target, '--json']);
+  assert(gen.exitCode === 0 || gen.exitCode === 1, `harness genome exit 0 or 1 (got ${gen.exitCode})`);
+
+  // harness mcp-scan
+  const scan = runHarness(['mcp-scan', target]);
+  // mcp-scan can exit 1 on findings; either 0 or 1 is acceptable here.
+  assert(scan.exitCode === 0 || scan.exitCode === 1, `harness mcp-scan exit 0 or 1 (got ${scan.exitCode})`);
+
+  // ── 5. (Optional) one real OpenRouter inference call ──────────────
+  if (!ARGS.skipInference) {
+    console.log('\nPhase 5 — single OpenRouter inference call (cheapest auto-route, max_tokens=1)');
+    const inf = await cheapInferenceCall(apiKey);
+    assert(inf.ok, `OpenRouter inference 2xx (got ${inf.ok ? 'ok' : inf.status})`);
+    if (inf.ok) {
+      console.log(`  model used: ${inf.model}`);
+      console.log(`  usage: prompt=${inf.usage?.prompt_tokens} completion=${inf.usage?.completion_tokens}`);
+    }
+  } else {
+    console.log('\nPhase 5 — SKIPPED (--skip-inference)');
+  }
+
+  // ── 6. Cleanup ────────────────────────────────────────────────────
+  if (!ARGS.keep) {
+    rmSync(fixture, { recursive: true, force: true });
+    console.log(`\nFixture cleaned: ${fixture}`);
+  } else {
+    console.log(`\nFixture kept at: ${fixture}`);
+  }
+
+  console.log(`\n${passed} passed, ${failed} failed`);
+  if (failed > 0) {
+    console.log('\nFailures:');
+    for (const f of failures) console.log(`  - ${f}`);
+    process.exit(1);
+  }
+  console.log('\n✓ All harness × OpenRouter integration checks passed.');
+}
+
+main().catch((e) => {
+  console.error('test-with-openrouter crashed:', e.message || e);
+  process.exit(2);
+});

package/plugins/ruflo-metaharness/scripts/threat-model.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+// threat-model.mjs — wrapper around `harness threat-model <path>`.
+//
+// USAGE
+//   node scripts/threat-model.mjs --path . --fail-on high --format json
+
+import { runHarness, emitDegradedJsonAndExit } from './_harness.mjs';
+
+const SEVERITY_RANK = { clean: 0, low: 1, medium: 2, high: 3 };
+
+const ARGS = (() => {
+  const a = { path: '.', format: 'json', failOn: 'high' };
+  for (let i = 2; i < process.argv.length; i++) {
+    const v = process.argv[i];
+    if (v === '--path') a.path = process.argv[++i];
+    else if (v === '--fail-on') a.failOn = String(process.argv[++i] || 'high').toLowerCase();
+    else if (v === '--format') a.format = process.argv[++i];
+  }
+  return a;
+})();
+
+function main() {
+  if (!SEVERITY_RANK.hasOwnProperty(ARGS.failOn)) {
+    console.error(`threat-model: --fail-on must be one of clean|low|medium|high`);
+    process.exit(2);
+  }
+  const r = runHarness(['threat-model', ARGS.path]);
+  if (r.degraded) { emitDegradedJsonAndExit(r.reason); return; }
+  if (r.exitCode !== 0 && r.exitCode !== 1) {
+    console.error(`threat-model: harness exited ${r.exitCode}`);
+    if (r.stderr) console.error(r.stderr.slice(0, 400));
+    process.exit(2);
+  }
+  const payload = r.json ?? { rawStdout: r.stdout.slice(0, 400) };
+  const worst = String(payload?.worst || 'clean').toLowerCase();
+  const threshold = SEVERITY_RANK[ARGS.failOn];
+  const triggered = SEVERITY_RANK[worst] >= threshold && threshold > 0;
+  const alert = {
+    threshold: ARGS.failOn, worst, triggered,
+    reason: triggered
+      ? `worst=${worst} at or above ${ARGS.failOn}`
+      : `worst=${worst} below ${ARGS.failOn} — OK`,
+  };
+
+  if (ARGS.format === 'json') {
+    console.log(JSON.stringify({ ...payload, durationMs: r.durationMs, alert }, null, 2));
+  } else {
+    console.log(`# harness threat-model — ${ARGS.path}`);
+    console.log('');
+    console.log(`Worst severity: ${worst}`);
+    console.log(`Findings: ${(payload?.findings || []).length}`);
+    console.log('');
+    console.log(alert.triggered ? `⚠ **ALERT**: ${alert.reason}` : `✓ ${alert.reason}`);
+  }
+
+  if (alert.triggered) process.exit(1);
+}
+
+main();