@mindrian_os/install 1.13.0-beta.11

package/lib/memory/test-rs-chain-feeder-core.cjs

@@ -0,0 +1,344 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ * Phase 89.4 Plan 02 -- rs-chain-feeder core fixture suite.
+ *
+ * 8 scenarios + A1 sweep covering the Wave-2 core module:
+ *   lib/core/rs-chain-feeder.cjs
+ *
+ * Test 1 (Brain unreachable graceful degradation): mock brainClient
+ *        with isAvailable() returning false; lookupUpstream returns
+ *        {state: ready}; stderr captures warning containing chain-feeder
+ *        + Brain unreachable.
+ *
+ * Test 2 (Pause-state with missing upstream): mock brainClient.query()
+ *        to return records with fresh:false flags; opts.upstreamFreshness
+ *        Map keyed false; lookupUpstream returns {state: pause,
+ *        missing_upstream: [...], suggested_action: Run Methodology}.
+ *
+ * Test 3 (Ready-state with all upstream present): mock brainClient.query()
+ *        to return records; default freshness map -> all upstream fresh;
+ *        lookupUpstream returns {state: ready}.
+ *
+ * Test 4 (emitChainMetadata happy-path shape): structural_transfer + 8 +
+ *        empty active_context produces recommended_verb in CANONICAL_VERBS,
+ *        feeds_into === PWS VP, spawn_skill === null.
+ *
+ * Test 5 (emitChainMetadata feeds_into branch coverage):
+ *        structural_transfer -> PWS VP, semantic_implementation ->
+ *        Causal Loop, hybrid -> Navigation Engine.
+ *
+ * Test 6 (Canon Part 8 adversarial -- lookupUpstream input):
+ *        problem_type containing 'meeting with' throws
+ *        ExternalEgressViolation with err.meta.surface ===
+ *        rs-chain-feeder-lookup-upstream.
+ *
+ * Test 7 (Canon Part 8 adversarial -- emitChainMetadata active_context):
+ *        active_context.meta.contact === 'john@acme.com' throws
+ *        ExternalEgressViolation with err.meta.surface ===
+ *        rs-chain-feeder-emit-metadata.
+ *
+ * Test 8 (chokepoint exclusivity): brainClient.query is invoked at least
+ *        once via injected spy; ZERO direct global.fetch() calls.
+ *
+ * Test 9 (recommendSkillSpawn STUB shape).
+ *
+ * A1 sweep: 5 happy-path emitChainMetadata calls produce zero
+ *           forbidden-pattern hits in the JSON.stringify of returned blocks.
+ *
+ * Pure CJS, zero npm deps, node built-ins only (assert).
+ */
+
+const assert = require('node:assert/strict');
+
+// ---------- Suite bookkeeping ----------
+
+let passed = 0;
+let failed = 0;
+const failures = [];
+const tests = [];
+
+// Register an async or sync test under a name. The runner awaits each
+// in series so stderr captures and brainClient spies do not interleave.
+function record(name, fn) {
+  tests.push({ name, fn });
+}
+
+async function runAll() {
+  for (const t of tests) {
+    try {
+      const maybe = t.fn();
+      if (maybe && typeof maybe.then === 'function') await maybe;
+      passed++;
+      process.stdout.write('PASS ' + t.name + '\n');
+    } catch (err) {
+      failed++;
+      failures.push({ name: t.name, message: err && err.message ? err.message : String(err) });
+      process.stdout.write('FAIL ' + t.name + ': ' + (err && err.message ? err.message : String(err)) + '\n');
+    }
+  }
+}
+
+// Stderr capture helper. Returns a thunk that, after fn settles, returns
+// what was written to process.stderr. Restores original write at the end.
+async function captureStderrAsync(fn) {
+  const chunks = [];
+  const origWrite = process.stderr.write.bind(process.stderr);
+  process.stderr.write = function (chunk) {
+    chunks.push(typeof chunk === 'string' ? chunk : chunk.toString());
+    return true;
+  };
+  try {
+    const value = await fn();
+    return { value, stderr: chunks.join('') };
+  } finally {
+    process.stderr.write = origWrite;
+  }
+}
+
+// Build a Brain client stub with a configurable query() return + spy.
+function makeBrainClientStub(opts) {
+  opts = opts || {};
+  const queryReturn = opts.queryReturn !== undefined ? opts.queryReturn : { records: [] };
+  const isAvailableValue = opts.isAvailable !== undefined ? opts.isAvailable : true;
+  const queryThrows = opts.queryThrows || null;
+  const callLog = [];
+  const stub = {
+    isAvailable: function () { return isAvailableValue; },
+    query: async function (cypher) {
+      callLog.push({ method: 'query', cypher });
+      if (queryThrows) throw queryThrows;
+      return queryReturn;
+    },
+    search: async function () { callLog.push({ method: 'search' }); return null; },
+    _callLog: callLog,
+  };
+  return stub;
+}
+
+// ---------- Module under test ----------
+
+const mod = require('../core/rs-chain-feeder.cjs');
+const {
+  lookupUpstream,
+  emitChainMetadata,
+  recommendSkillSpawn,
+  CANONICAL_VERBS,
+} = mod;
+
+// ---------- Tests ----------
+
+// Test 1: Brain unreachable graceful degradation
+record('T1 Brain unreachable -> lookupUpstream returns {state: ready} + stderr warning', async function () {
+  const brainClient = makeBrainClientStub({ isAvailable: false });
+  const captured = await captureStderrAsync(function () {
+    return lookupUpstream('IDP', 'opportunity_identified', { brainClient: brainClient });
+  });
+  assert.deepEqual(captured.value, { state: 'ready' },
+    'expected {state: ready}, got ' + JSON.stringify(captured.value));
+  assert.ok(captured.stderr.indexOf('chain-feeder') !== -1,
+    'expected stderr to contain chain-feeder, got ' + JSON.stringify(captured.stderr));
+  assert.ok(captured.stderr.indexOf('Brain unreachable') !== -1,
+    'expected stderr to contain Brain unreachable, got ' + JSON.stringify(captured.stderr));
+});
+
+// Test 2: Pause-state with missing upstream
+record('T2 Brain reachable + missing upstream -> {state: pause, missing_upstream, suggested_action}', async function () {
+  const brainClient = makeBrainClientStub({
+    queryReturn: {
+      records: [
+        { name: 'systems-thinking' },
+        { name: 'hsi_semantic_surprise_analysis' },
+      ],
+    },
+  });
+  const freshness = new Map();
+  freshness.set('systems-thinking', false);
+  freshness.set('hsi_semantic_surprise_analysis', false);
+  const result = await lookupUpstream('IDP', 'opportunity_identified', {
+    brainClient: brainClient,
+    upstreamFreshness: freshness,
+  });
+  assert.equal(result.state, 'pause', 'expected state: pause, got ' + result.state);
+  assert.ok(Array.isArray(result.missing_upstream), 'missing_upstream must be array');
+  assert.equal(result.missing_upstream.length, 2, 'expected 2 missing_upstream entries');
+  assert.ok(result.missing_upstream.indexOf('systems-thinking') !== -1,
+    'expected systems-thinking in missing_upstream');
+  assert.ok(result.missing_upstream.indexOf('hsi_semantic_surprise_analysis') !== -1,
+    'expected hsi_semantic_surprise_analysis in missing_upstream');
+  assert.equal(result.suggested_action, 'Run Methodology',
+    'expected suggested_action: Run Methodology, got ' + result.suggested_action);
+});
+
+// Test 3: Ready-state with all upstream present
+record('T3 Brain reachable + all upstream fresh (no freshness Map) -> {state: ready}', async function () {
+  const brainClient = makeBrainClientStub({
+    queryReturn: {
+      records: [
+        { name: 'systems-thinking' },
+        { name: 'Cynefin' },
+      ],
+    },
+  });
+  const result = await lookupUpstream('IDP', 'opportunity_identified', { brainClient: brainClient });
+  assert.deepEqual(result, { state: 'ready' },
+    'expected {state: ready}, got ' + JSON.stringify(result));
+});
+
+// Test 4: emitChainMetadata happy-path shape
+// Plan 89.4-03 update: spawn_skill assertion broadened from "must be null"
+// (STUB) to "must be string-or-null with /mos: prefix when non-null"
+// (additive-shape invariant). The 89.4-02 stub returned null; the 89.4-03
+// rule-table wires Rule 1 (structural_transfer + score 8 ->
+// /mos:find-analogies). The shape contract (string|null) is preserved.
+record('T4 emitChainMetadata structural_transfer + 8 -> shape with verb in CANONICAL_VERBS + PWS VP + spawn_skill string|null', function () {
+  const block = emitChainMetadata('structural_transfer', 8, {});
+  assert.ok(block && typeof block === 'object', 'expected object return');
+  assert.ok(typeof block.recommended_verb === 'string', 'recommended_verb must be string');
+  assert.ok(CANONICAL_VERBS.indexOf(block.recommended_verb) !== -1,
+    'recommended_verb must be in CANONICAL_VERBS, got ' + JSON.stringify(block.recommended_verb));
+  assert.equal(block.feeds_into, 'PWS VP',
+    'feeds_into must be PWS VP for structural_transfer, got ' + JSON.stringify(block.feeds_into));
+  assert.ok(block.spawn_skill === null || typeof block.spawn_skill === 'string',
+    'spawn_skill must be string|null, got ' + JSON.stringify(block.spawn_skill));
+  if (typeof block.spawn_skill === 'string') {
+    assert.ok(block.spawn_skill.indexOf('/mos:') === 0,
+      'when non-null, spawn_skill must start with /mos:, got ' + JSON.stringify(block.spawn_skill));
+  }
+});
+
+// Test 5: feeds_into branch coverage
+record('T5 emitChainMetadata feeds_into branches: structural_transfer -> PWS VP, semantic_implementation -> Causal Loop, hybrid -> Navigation Engine', function () {
+  const a = emitChainMetadata('structural_transfer', 8, {});
+  assert.equal(a.feeds_into, 'PWS VP', 'structural_transfer -> PWS VP');
+  const b = emitChainMetadata('semantic_implementation', 8, {});
+  assert.equal(b.feeds_into, 'Causal Loop', 'semantic_implementation -> Causal Loop');
+  const c = emitChainMetadata('hybrid', 8, {});
+  assert.equal(c.feeds_into, 'Navigation Engine', 'hybrid -> Navigation Engine');
+});
+
+// Test 6: Canon Part 8 adversarial -- forbidden pattern in lookupUpstream input
+record('T6 Canon Part 8 adversarial -- forbidden pattern in problem_type throws ExternalEgressViolation', async function () {
+  const brainClient = makeBrainClientStub({});
+  let caught = null;
+  try {
+    await lookupUpstream('IDP-meeting with john', 'opportunity_identified', { brainClient: brainClient });
+  } catch (e) {
+    caught = e;
+  }
+  assert.ok(caught !== null, 'expected throw');
+  assert.equal(caught.name, 'ExternalEgressViolation',
+    'expected ExternalEgressViolation, got ' + caught.name);
+  assert.equal(caught.meta.surface, 'rs-chain-feeder-lookup-upstream',
+    'expected meta.surface rs-chain-feeder-lookup-upstream, got ' + caught.meta.surface);
+  assert.equal(brainClient._callLog.length, 0,
+    'brain query must NOT be invoked when audit trips (got ' + brainClient._callLog.length + ' calls)');
+});
+
+// Test 7: Canon Part 8 adversarial -- forbidden pattern nested in active_context
+record('T7 Canon Part 8 adversarial -- email nested in active_context.meta throws ExternalEgressViolation', function () {
+  let caught = null;
+  try {
+    emitChainMetadata('structural_transfer', 8, { meta: { contact: 'john@acme.com' } });
+  } catch (e) {
+    caught = e;
+  }
+  assert.ok(caught !== null, 'expected throw');
+  assert.equal(caught.name, 'ExternalEgressViolation',
+    'expected ExternalEgressViolation, got ' + caught.name);
+  assert.equal(caught.meta.surface, 'rs-chain-feeder-emit-metadata',
+    'expected meta.surface rs-chain-feeder-emit-metadata, got ' + caught.meta.surface);
+});
+
+// Test 8: chokepoint exclusivity -- brainClient.query invoked, no direct fetch
+record('T8 chokepoint exclusivity -- brainClient.query called >=1 time + zero direct global.fetch calls', async function () {
+  const fetchCalls = [];
+  const originalFetch = global.fetch;
+  global.fetch = function () {
+    fetchCalls.push(Array.prototype.slice.call(arguments));
+    return Promise.resolve(null);
+  };
+  try {
+    const brainClient = makeBrainClientStub({
+      queryReturn: { records: [{ name: 'systems-thinking' }] },
+    });
+    await lookupUpstream('IDP', 'opportunity_identified', { brainClient: brainClient });
+    assert.ok(brainClient._callLog.length >= 1,
+      'expected brainClient.query called >=1 time, got ' + brainClient._callLog.length);
+    assert.equal(brainClient._callLog[0].method, 'query',
+      'expected first method call to be query, got ' + brainClient._callLog[0].method);
+    assert.equal(fetchCalls.length, 0,
+      'expected ZERO direct fetch() calls; got ' + fetchCalls.length);
+  } finally {
+    if (originalFetch === undefined) delete global.fetch;
+    else global.fetch = originalFetch;
+  }
+});
+
+// Test 9: recommendSkillSpawn shape invariant
+// Plan 89.4-03 update: assertion broadened from STUB-specific "spawn_skill
+// null + 89.4-02 reasoning string" to the SHAPE invariant -- result is an
+// object with spawn_skill (string|null), numeric confidence in [0, 1], and
+// non-empty reasoning string. The 89.4-02 stub returned null/0/stub-text;
+// the 89.4-03 rule-table fires Rule 1 here -> /mos:find-analogies / 0.85.
+// Shape is byte-identical across both implementations.
+record('T9 recommendSkillSpawn shape invariant -- {spawn_skill: string|null, confidence: 0..1, reasoning: non-empty string}', function () {
+  const result = recommendSkillSpawn('structural_transfer', 8, {});
+  assert.ok(result && typeof result === 'object', 'expected object');
+  assert.ok(result.spawn_skill === null || typeof result.spawn_skill === 'string',
+    'spawn_skill must be string|null, got ' + typeof result.spawn_skill);
+  if (typeof result.spawn_skill === 'string') {
+    assert.ok(result.spawn_skill.indexOf('/mos:') === 0,
+      'when non-null, spawn_skill must start with /mos:, got ' + JSON.stringify(result.spawn_skill));
+  }
+  assert.equal(typeof result.confidence, 'number', 'confidence must be a number');
+  assert.ok(result.confidence >= 0 && result.confidence <= 1,
+    'confidence must be in [0, 1], got ' + result.confidence);
+  assert.ok(typeof result.reasoning === 'string' && result.reasoning.length > 0,
+    'reasoning must be non-empty string');
+});
+
+// A1 sweep: 5 happy-path emitChainMetadata calls produce zero
+// forbidden-pattern hits in JSON.stringify of returned blocks.
+record('A1 sweep: 5 happy-path emitChainMetadata calls produce zero forbidden-pattern hits in returned blocks', function () {
+  const calls = [
+    ['structural_transfer', 9, {}],
+    ['semantic_implementation', 7, { industry_signals_count: 3 }],
+    ['hybrid', 5, { cross_methodology_substrates: ['SAPPhIRE', 'TRIZ'] }],
+    ['structural_transfer', 4, {}],
+    ['semantic_implementation', 6, { resolved_experts_count: 8 }],
+  ];
+  const { FORBIDDEN_PATTERNS } = require('../core/rs-egress-prompts.cjs');
+  for (const [rs_type, score, ctx] of calls) {
+    const block = emitChainMetadata(rs_type, score, ctx);
+    const json = JSON.stringify(block);
+    for (const re of FORBIDDEN_PATTERNS) {
+      assert.ok(!re.test(json),
+        'A1 sweep: emitChainMetadata output for (' + rs_type + ', ' + score + ') matched forbidden pattern '
+        + re.source + '; output was ' + json);
+    }
+    assert.ok(CANONICAL_VERBS.indexOf(block.recommended_verb) !== -1,
+      'A1 sweep: recommended_verb ' + JSON.stringify(block.recommended_verb)
+      + ' not in CANONICAL_VERBS for (' + rs_type + ', ' + score + ')');
+  }
+});
+
+// ---------- Suite report ----------
+
+(async function main() {
+  await runAll();
+  const total = passed + failed;
+  process.stdout.write('\n');
+  if (failed === 0) {
+    process.stdout.write('=== 89.4-02 rs-chain-feeder-core suite: ' + passed + '/' + total + ' passed ===\n');
+    process.exit(0);
+  } else {
+    process.stdout.write('=== 89.4-02 rs-chain-feeder-core suite: ' + passed + '/' + total + ' passed (' + failed + ' failed) ===\n');
+    for (const f of failures) {
+      process.stdout.write('  FAIL ' + f.name + ': ' + f.message + '\n');
+    }
+    process.exit(1);
+  }
+})();

package/lib/memory/test-rs-chain-feeder-skill-spawn.cjs

@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ * Phase 89.4 Plan 03 -- rs-chain-feeder skill-spawn rule table fixture suite.
+ *
+ * 11 scenarios covering the Wave-3 skill-spawn rule table per kickoff
+ * section 6.4 (LOCKED deterministic 5-rule table). Tests are Plan-89.4-03
+ * RED-then-GREEN: written against the swapped recommendSkillSpawn body and
+ * SKILL_SPAWN_RULES Object.freeze export. Plan 89.4-02 stub MUST fail
+ * Tests 1-5 + Test 7 + Test 9 + Test 11 because the stub returns
+ * spawn_skill: null for every input.
+ *
+ *   Test 1 (Rule 1 positive): recommendSkillSpawn(structural_transfer, 8, {})
+ *           returns {spawn_skill: /mos:find-analogies, confidence: 0.85,
+ *           reasoning includes SAPPhIRE}.
+ *
+ *   Test 2 (Rule 2 positive): recommendSkillSpawn(semantic_implementation,
+ *           7, {industry_signals_count: 3}) returns {spawn_skill:
+ *           /mos:lean-canvas, confidence: 0.80, reasoning includes
+ *           market signal}.
+ *
+ *   Test 3 (Rule 3 positive): recommendSkillSpawn(hybrid, 6,
+ *           {cross_methodology_substrates: [JTBD, Causal Loop]}) returns
+ *           {spawn_skill: /mos:pipeline, confidence: 0.75, reasoning
+ *           includes cross-methodology}.
+ *
+ *   Test 4 (Rule 4 positive): recommendSkillSpawn(semantic_implementation,
+ *           5, {resolved_experts_count: 10, resolved_institutions_count: 3})
+ *           returns {spawn_skill: /mos:persona, confidence: 0.70,
+ *           reasoning includes expert network}.
+ *
+ *   Test 5 (Rule 5 positive): recommendSkillSpawn(semantic_implementation,
+ *           2, {cynefin: complex}) returns {spawn_skill: /mos:think-hats,
+ *           confidence: 0.65, reasoning includes perspective diversity}.
+ *
+ *   Test 6 (no-match fallback): recommendSkillSpawn(semantic_implementation,
+ *           5, {}) returns {spawn_skill: null, confidence: 0, reasoning:
+ *           no rule matched}.
+ *
+ *   Test 7 (first-match-wins): recommendSkillSpawn(structural_transfer, 8,
+ *           {industry_signals_count: 3, cross_methodology_substrates:
+ *           [A, B]}) returns Rule 1 (find-analogies) NOT Rule 2 NOT Rule 3.
+ *
+ *   Test 8 (Canon Part 8 adversarial): opts.contact carrying an email
+ *           string throws ExternalEgressViolation with
+ *           err.meta.surface === rs-chain-feeder-recommend-skill-spawn.
+ *
+ *   Test 9 (integration smoke): emitChainMetadata(structural_transfer, 8,
+ *           {}) returns object with spawn_skill === /mos:find-analogies,
+ *           confidence: 0.85, recommended_verb: Bank Opportunity,
+ *           feeds_into: PWS VP.
+ *
+ *   Test 10 (regression): emitChainMetadata(structural_transfer, 3, {})
+ *           returns spawn_skill === null (no rule matches; Rule 5 needs
+ *           cynefin) + recommended_verb === Reformulate (score < 5).
+ *
+ *   Test 11 (frozen rule table): SKILL_SPAWN_RULES is exported as an
+ *           array; Array.isArray true; length 5; Object.isFrozen true;
+ *           each rule entry is also frozen.
+ *
+ * Pure CJS, zero npm deps, node built-ins only (assert).
+ */
+
+const assert = require('node:assert/strict');
+
+// ---------- Suite bookkeeping ----------
+
+let passed = 0;
+let failed = 0;
+const failures = [];
+const tests = [];
+
+function record(name, fn) {
+  tests.push({ name, fn });
+}
+
+async function runAll() {
+  for (const t of tests) {
+    try {
+      const maybe = t.fn();
+      if (maybe && typeof maybe.then === 'function') await maybe;
+      passed++;
+      process.stdout.write('PASS ' + t.name + '\n');
+    } catch (err) {
+      failed++;
+      failures.push({ name: t.name, message: err && err.message ? err.message : String(err) });
+      process.stdout.write('FAIL ' + t.name + ': ' + (err && err.message ? err.message : String(err)) + '\n');
+    }
+  }
+}
+
+// ---------- Module under test ----------
+
+const mod = require('../core/rs-chain-feeder.cjs');
+const {
+  recommendSkillSpawn,
+  emitChainMetadata,
+  SKILL_SPAWN_RULES,
+} = mod;
+
+// ---------- Tests ----------
+
+// Test 1: Rule 1 positive -- structural_transfer + score 8
+record('T1 Rule 1 -- structural_transfer + score 8 -> /mos:find-analogies (0.85)', function () {
+  const result = recommendSkillSpawn('structural_transfer', 8, {});
+  assert.ok(result && typeof result === 'object', 'expected object return');
+  assert.equal(result.spawn_skill, '/mos:find-analogies',
+    'expected /mos:find-analogies, got ' + JSON.stringify(result.spawn_skill));
+  assert.equal(result.confidence, 0.85,
+    'expected confidence 0.85, got ' + result.confidence);
+  assert.ok(typeof result.reasoning === 'string' && result.reasoning.length > 0,
+    'reasoning must be non-empty string');
+  assert.ok(result.reasoning.indexOf('SAPPhIRE') !== -1 || result.reasoning.indexOf('TRIZ') !== -1
+    || result.reasoning.indexOf('structural') !== -1,
+    'reasoning should reference SAPPhIRE / TRIZ / structural; got ' + JSON.stringify(result.reasoning));
+});
+
+// Test 2: Rule 2 positive -- score 7 + industry signals
+record('T2 Rule 2 -- score 7 + industry_signals_count 3 -> /mos:lean-canvas (0.80)', function () {
+  const result = recommendSkillSpawn('semantic_implementation', 7, { industry_signals_count: 3 });
+  assert.equal(result.spawn_skill, '/mos:lean-canvas',
+    'expected /mos:lean-canvas, got ' + JSON.stringify(result.spawn_skill));
+  assert.equal(result.confidence, 0.80,
+    'expected confidence 0.80, got ' + result.confidence);
+  assert.ok(result.reasoning.indexOf('market signal') !== -1
+    || result.reasoning.indexOf('business model') !== -1,
+    'reasoning should reference market signal / business model; got ' + JSON.stringify(result.reasoning));
+});
+
+// Test 3: Rule 3 positive -- cross-methodology substrates
+record('T3 Rule 3 -- cross_methodology_substrates length > 1 -> /mos:pipeline (0.75)', function () {
+  const result = recommendSkillSpawn('hybrid', 6, {
+    cross_methodology_substrates: ['JTBD', 'Causal Loop'],
+  });
+  assert.equal(result.spawn_skill, '/mos:pipeline',
+    'expected /mos:pipeline, got ' + JSON.stringify(result.spawn_skill));
+  assert.equal(result.confidence, 0.75,
+    'expected confidence 0.75, got ' + result.confidence);
+  assert.ok(result.reasoning.indexOf('cross-methodology') !== -1
+    || result.reasoning.indexOf('chained pipeline') !== -1,
+    'reasoning should reference cross-methodology / chained pipeline; got '
+    + JSON.stringify(result.reasoning));
+});
+
+// Test 4: Rule 4 positive -- expert network dense
+record('T4 Rule 4 -- experts > 5 + institutions > 1 -> /mos:persona (0.70)', function () {
+  const result = recommendSkillSpawn('semantic_implementation', 5, {
+    resolved_experts_count: 10,
+    resolved_institutions_count: 3,
+  });
+  assert.equal(result.spawn_skill, '/mos:persona',
+    'expected /mos:persona, got ' + JSON.stringify(result.spawn_skill));
+  assert.equal(result.confidence, 0.70,
+    'expected confidence 0.70, got ' + result.confidence);
+  assert.ok(result.reasoning.indexOf('expert network') !== -1
+    || result.reasoning.indexOf('team composition') !== -1,
+    'reasoning should reference expert network / team composition; got '
+    + JSON.stringify(result.reasoning));
+});
+
+// Test 5: Rule 5 positive -- low breakthrough + Cynefin complex
+record('T5 Rule 5 -- score 2 + cynefin complex -> /mos:think-hats (0.65)', function () {
+  const result = recommendSkillSpawn('semantic_implementation', 2, { cynefin: 'complex' });
+  assert.equal(result.spawn_skill, '/mos:think-hats',
+    'expected /mos:think-hats, got ' + JSON.stringify(result.spawn_skill));
+  assert.equal(result.confidence, 0.65,
+    'expected confidence 0.65, got ' + result.confidence);
+  assert.ok(result.reasoning.indexOf('perspective diversity') !== -1
+    || result.reasoning.indexOf('Cynefin') !== -1,
+    'reasoning should reference perspective diversity / Cynefin; got '
+    + JSON.stringify(result.reasoning));
+});
+
+// Test 6: no-match fallback
+record('T6 no-match -- score 5 + empty opts -> {spawn_skill: null, confidence: 0, reasoning: no rule matched}', function () {
+  const result = recommendSkillSpawn('semantic_implementation', 5, {});
+  assert.equal(result.spawn_skill, null,
+    'expected null spawn_skill, got ' + JSON.stringify(result.spawn_skill));
+  assert.equal(result.confidence, 0,
+    'expected confidence 0, got ' + result.confidence);
+  assert.equal(result.reasoning, 'no rule matched',
+    'expected reasoning "no rule matched", got ' + JSON.stringify(result.reasoning));
+});
+
+// Test 7: first-match-wins -- Rule 1 wins over Rule 2 + Rule 3
+record('T7 first-match-wins -- Rule 1 inputs + Rule 2 + Rule 3 inputs -> Rule 1 wins (find-analogies)', function () {
+  const result = recommendSkillSpawn('structural_transfer', 8, {
+    industry_signals_count: 3,
+    cross_methodology_substrates: ['A', 'B'],
+  });
+  assert.equal(result.spawn_skill, '/mos:find-analogies',
+    'first-match-wins violated: expected /mos:find-analogies (Rule 1), got '
+    + JSON.stringify(result.spawn_skill));
+  assert.equal(result.confidence, 0.85,
+    'expected Rule 1 confidence 0.85, got ' + result.confidence);
+});
+
+// Test 8: Canon Part 8 adversarial -- email in opts
+record('T8 Canon Part 8 adversarial -- opts.contact carries email -> ExternalEgressViolation', function () {
+  let caught = null;
+  try {
+    recommendSkillSpawn('structural_transfer', 8, {
+      industry_signals_count: 3,
+      contact: 'john@acme.com',
+    });
+  } catch (e) {
+    caught = e;
+  }
+  assert.ok(caught !== null, 'expected throw');
+  assert.equal(caught.name, 'ExternalEgressViolation',
+    'expected ExternalEgressViolation, got ' + caught.name);
+  assert.equal(caught.meta.surface, 'rs-chain-feeder-recommend-skill-spawn',
+    'expected meta.surface rs-chain-feeder-recommend-skill-spawn, got '
+    + caught.meta.surface);
+});
+
+// Test 9: integration smoke -- rule propagates through emitChainMetadata
+record('T9 integration smoke -- emitChainMetadata(structural_transfer, 8) carries Rule 1 fields', function () {
+  const block = emitChainMetadata('structural_transfer', 8, {});
+  assert.equal(block.spawn_skill, '/mos:find-analogies',
+    'expected spawn_skill /mos:find-analogies in chain metadata, got '
+    + JSON.stringify(block.spawn_skill));
+  assert.equal(block.confidence, 0.85,
+    'expected confidence 0.85 in chain metadata, got ' + block.confidence);
+  assert.equal(block.recommended_verb, 'Bank Opportunity',
+    'expected recommended_verb Bank Opportunity, got '
+    + JSON.stringify(block.recommended_verb));
+  assert.equal(block.feeds_into, 'PWS VP',
+    'expected feeds_into PWS VP, got ' + JSON.stringify(block.feeds_into));
+  assert.ok(typeof block.reasoning === 'string' && block.reasoning.length > 0,
+    'reasoning must be non-empty string in chain metadata');
+});
+
+// Test 10: regression -- score 3 + structural_transfer -> no rule matches
+record('T10 regression -- emitChainMetadata(structural_transfer, 3) -> spawn_skill null + Reformulate verb', function () {
+  const block = emitChainMetadata('structural_transfer', 3, {});
+  assert.equal(block.spawn_skill, null,
+    'expected null spawn_skill (no rule matches at score 3), got '
+    + JSON.stringify(block.spawn_skill));
+  assert.equal(block.recommended_verb, 'Reformulate',
+    'expected recommended_verb Reformulate (score < 5), got '
+    + JSON.stringify(block.recommended_verb));
+  assert.equal(block.feeds_into, 'PWS VP',
+    'expected feeds_into PWS VP (structural_transfer), got '
+    + JSON.stringify(block.feeds_into));
+  assert.equal(block.confidence, 0,
+    'expected confidence 0 (no rule matched), got ' + block.confidence);
+});
+
+// Test 11: SKILL_SPAWN_RULES is frozen + exported with correct shape
+record('T11 SKILL_SPAWN_RULES exported + frozen + length 5 + each entry frozen', function () {
+  assert.ok(Array.isArray(SKILL_SPAWN_RULES),
+    'SKILL_SPAWN_RULES must be an array, got ' + typeof SKILL_SPAWN_RULES);
+  assert.equal(SKILL_SPAWN_RULES.length, 5,
+    'expected 5 rules per kickoff section 6.4, got ' + SKILL_SPAWN_RULES.length);
+  assert.equal(Object.isFrozen(SKILL_SPAWN_RULES), true,
+    'SKILL_SPAWN_RULES must be Object.freeze\'d');
+  for (let i = 0; i < SKILL_SPAWN_RULES.length; i++) {
+    const rule = SKILL_SPAWN_RULES[i];
+    assert.ok(rule && typeof rule === 'object',
+      'rule ' + i + ' must be object');
+    assert.equal(typeof rule.match, 'function',
+      'rule ' + i + ' must have match() function');
+    assert.equal(typeof rule.spawn, 'string',
+      'rule ' + i + ' must have spawn string');
+    assert.ok(rule.spawn.indexOf('/mos:') === 0,
+      'rule ' + i + ' spawn must start with /mos:, got ' + rule.spawn);
+    assert.equal(typeof rule.confidence, 'number',
+      'rule ' + i + ' must have numeric confidence');
+    assert.ok(rule.confidence > 0 && rule.confidence <= 1,
+      'rule ' + i + ' confidence must be (0, 1], got ' + rule.confidence);
+    assert.equal(typeof rule.reasoning, 'string',
+      'rule ' + i + ' must have reasoning string');
+    assert.equal(Object.isFrozen(rule), true,
+      'rule ' + i + ' entry must also be Object.freeze\'d');
+  }
+});
+
+// ---------- Suite report ----------
+
+(async function main() {
+  await runAll();
+  const total = passed + failed;
+  process.stdout.write('\n');
+  if (failed === 0) {
+    process.stdout.write('=== 89.4-03 rs-chain-feeder-skill-spawn suite: ' + passed + '/' + total + ' passed ===\n');
+    process.exit(0);
+  } else {
+    process.stdout.write('=== 89.4-03 rs-chain-feeder-skill-spawn suite: ' + passed + '/' + total + ' passed (' + failed + ' failed) ===\n');
+    for (const f of failures) {
+      process.stdout.write('  FAIL ' + f.name + ': ' + f.message + '\n');
+    }
+    process.exit(1);
+  }
+})();