@mindrian_os/install 1.13.0-beta.11

package/lib/core/rs-breakthrough-scorer.cjs

@@ -0,0 +1,255 @@
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ * Phase 89.2 Plan 07 Task 2 -- Phase 3 deterministic breakthrough scorer.
+ *
+ * 5-dimension 0-10 rubric per kickoff §5 Phase 3 enumeration. Deterministic
+ * weighted sum from substrate metadata + classifier output. Each dimension
+ * is scored 0-2; total is the simple sum.
+ *
+ *   feasibility   0-2 from substrate.tier
+ *                   core         -> 2.0
+ *                   applied      -> 1.5
+ *                   theoretical  -> 1.0
+ *                   <other>      -> 1.0  (defensive default)
+ *
+ *   market        0-2 from industry signal count (Tavily-orchestrated
+ *                 industry-fetcher signal count for the target domain):
+ *                   0            -> 0.0
+ *                   1-3          -> 0.5
+ *                   4-9          -> 1.0
+ *                   10-19        -> 1.5
+ *                   >=20         -> 2.0
+ *
+ *   magnitude     0-2 from differential score (`diff` value mapped):
+ *                   0.0 - 0.3    -> 0.0
+ *                   0.3 - 0.5    -> 1.0
+ *                   0.5 - 0.7    -> 1.5
+ *                   >=0.7        -> 2.0
+ *
+ *   advantage     0-2 from cross-domain pair rarity. Computed from
+ *                 opts.pair_density (density of similar pairs in the
+ *                 substrate, [0, 1]; 1 = fully dense, 0 = perfectly rare).
+ *                 advantage = 2 * (1 - density), clamped to [0, 2].
+ *                 Default density = 1.0 (fully dense -> zero advantage)
+ *                 when pair_density is omitted -- pessimistic default.
+ *
+ *   impact        0-2 from BERT cosine score (semantic depth):
+ *                   0.0 - 0.2    -> 0.0
+ *                   0.2 - 0.4    -> 0.5
+ *                   0.4 - 0.6    -> 1.0
+ *                   0.6 - 0.8    -> 1.5
+ *                   >=0.8        -> 2.0
+ *
+ * dominant_dimension is the breakdown key with the highest score. Ties
+ * are broken by frozen DIMENSIONS order ['feasibility', 'market',
+ * 'magnitude', 'advantage', 'impact'] -- the FIRST matching key wins.
+ * The frozen-order tie-break is the determinism contract; without it,
+ * Object.keys insertion order would be the implicit tie-breaker, which
+ * is fragile under refactor.
+ *
+ * Determinism contract: byte-identical JSON.stringify(out1) === JSON.stringify(out2)
+ * for identical inputs. No Math.random, no Date.now, no LLM call.
+ *
+ * Canon Part 8 (Graph Boundary): two defense-in-depth layers.
+ *
+ *   Layer 1 -- pre-input scan: classified_pair.query_concept and
+ *     classified_pair.doc_concept passed through auditQueryString BEFORE
+ *     any rubric application. Throws ExternalEgressViolation on hit.
+ *
+ *   Layer 2 -- pre-return audit: composite output passed through
+ *     auditQueryObject before return. Defense-in-depth so any forbidden
+ *     pattern smuggled via opts.substrate_metadata.title (or any field
+ *     that propagates into the return envelope) is caught at the gate.
+ *
+ * Pure CJS, zero npm deps, node built-ins only beyond rs-egress-* primitives.
+ */
+'use strict';
+
+const { auditQueryString, auditQueryObject } = require('./rs-egress-prompts.cjs');
+require('./rs-egress-violations.cjs');
+
+// ---------- Frozen invariants ----------
+
+// 5-dimension space, frozen. Order is the tie-break contract for
+// dominant_dimension: first matching key wins.
+const DIMENSIONS = Object.freeze([
+  'feasibility',
+  'market',
+  'magnitude',
+  'advantage',
+  'impact',
+]);
+
+// substrate.tier -> feasibility lookup (frozen).
+const TIER_TO_FEASIBILITY = Object.freeze({
+  core: 2.0,
+  applied: 1.5,
+  theoretical: 1.0,
+});
+
+// ---------- Dimension functions ----------
+
+// Industry signal count -> market score. Pure step function.
+function SIGNAL_COUNT_TO_MARKET(n) {
+  const x = (typeof n === 'number' && isFinite(n)) ? n : 0;
+  if (x >= 20) return 2.0;
+  if (x >= 10) return 1.5;
+  if (x >= 4) return 1.0;
+  if (x >= 1) return 0.5;
+  return 0.0;
+}
+
+// Differential score -> magnitude score. Pure step function.
+function DIFF_TO_MAGNITUDE(d) {
+  const x = (typeof d === 'number' && isFinite(d)) ? d : 0;
+  if (x >= 0.7) return 2.0;
+  if (x >= 0.5) return 1.5;
+  if (x >= 0.3) return 1.0;
+  return 0.0;
+}
+
+// Cross-domain pair density -> advantage score. Density in [0, 1] inverts
+// to advantage = 2 * (1 - density), clamped to [0, 2] for defense against
+// out-of-range inputs (e.g., NaN, density > 1, density < 0).
+function PAIR_DENSITY_TO_ADVANTAGE(rho) {
+  const x = (typeof rho === 'number' && isFinite(rho)) ? rho : 1.0;
+  const raw = 2.0 * (1.0 - x);
+  if (raw < 0) return 0.0;
+  if (raw > 2.0) return 2.0;
+  return raw;
+}
+
+// BERT score -> impact score. Pure step function.
+function BERT_TO_IMPACT(b) {
+  const x = (typeof b === 'number' && isFinite(b)) ? b : 0;
+  if (x >= 0.8) return 2.0;
+  if (x >= 0.6) return 1.5;
+  if (x >= 0.4) return 1.0;
+  if (x >= 0.2) return 0.5;
+  return 0.0;
+}
+
+// ---------- computeDominant ----------
+//
+// Returns the first DIMENSIONS key whose breakdown value equals the max.
+// Frozen-order tie-break is the determinism contract.
+
+function computeDominant(breakdown) {
+  if (!breakdown || typeof breakdown !== 'object') return DIMENSIONS[0];
+  let max = -Infinity;
+  for (let i = 0; i < DIMENSIONS.length; i += 1) {
+    const v = breakdown[DIMENSIONS[i]];
+    if (typeof v === 'number' && v > max) max = v;
+  }
+  for (let i = 0; i < DIMENSIONS.length; i += 1) {
+    if (breakdown[DIMENSIONS[i]] === max) return DIMENSIONS[i];
+  }
+  return DIMENSIONS[0];
+}
+
+// ---------- scoreBreakthrough ----------
+//
+// Public entry point. Synchronous (no I/O, no spawn). Throws only on
+// Canon Part 8 violations.
+//
+// Inputs:
+//   classified_pair  object  the post-classifier shape (pass-through fields)
+//   opts             optional:
+//     substrate_metadata    {tier: 'core'|'applied'|'theoretical', ...}
+//     industry_signal_count number  count of industry-fetcher signals
+//     pair_density          number  [0, 1]; 1 = fully dense, 0 = rare
+//
+// Output (happy path):
+//   {<pass-through classified_pair fields>,
+//    breakthrough: {
+//      score: 0-10,
+//      breakdown: {feasibility, market, magnitude, advantage, impact},
+//      dominant_dimension: <one of DIMENSIONS>,
+//    }}
+//
+// Output (invalid input):
+//   {error: 'invalid_input', reason: <string>}
+
+function scoreBreakthrough(classified_pair, opts) {
+  if (!classified_pair || typeof classified_pair !== 'object') {
+    return { error: 'invalid_input', reason: 'not_object' };
+  }
+
+  // Canon Part 8 Layer 1: pre-input scan on user-controlled concepts
+  // BEFORE any rubric application. Throws ExternalEgressViolation on hit.
+  if (typeof classified_pair.query_concept === 'string') {
+    auditQueryString(classified_pair.query_concept, 'breakthrough-scorer');
+  }
+  if (typeof classified_pair.doc_concept === 'string') {
+    auditQueryString(classified_pair.doc_concept, 'breakthrough-scorer');
+  }
+
+  opts = opts || {};
+  const substrateMeta = (opts.substrate_metadata && typeof opts.substrate_metadata === 'object')
+    ? opts.substrate_metadata
+    : {};
+  const tier = (typeof substrateMeta.tier === 'string') ? substrateMeta.tier : 'theoretical';
+
+  // 5-dimension rubric application.
+  const feasibility = (tier in TIER_TO_FEASIBILITY) ? TIER_TO_FEASIBILITY[tier] : 1.0;
+  const market = SIGNAL_COUNT_TO_MARKET(opts.industry_signal_count);
+  const magnitude = DIFF_TO_MAGNITUDE(classified_pair.diff);
+  const advantage = PAIR_DENSITY_TO_ADVANTAGE(
+    (typeof opts.pair_density === 'number') ? opts.pair_density : 1.0
+  );
+  const impact = BERT_TO_IMPACT(classified_pair.bert);
+
+  const breakdown = {
+    feasibility: feasibility,
+    market: market,
+    magnitude: magnitude,
+    advantage: advantage,
+    impact: impact,
+  };
+  // Score = simple sum, bounded in [0, 10] by construction (each
+  // dimension is in [0, 2]).
+  const score = feasibility + market + magnitude + advantage + impact;
+  const dominant_dimension = computeDominant(breakdown);
+
+  // Pass-through preserves the classifier shape so downstream
+  // thesis-generator can read all 3 layers (pair + classification +
+  // breakthrough) from a single object.
+  const out = {
+    query_concept: classified_pair.query_concept,
+    doc_concept: classified_pair.doc_concept,
+    diff: classified_pair.diff,
+    lsa: classified_pair.lsa,
+    bert: classified_pair.bert,
+    passes: classified_pair.passes,
+    classification: classified_pair.classification,
+    bridge_concept: classified_pair.bridge_concept,
+    breakthrough: {
+      score: score,
+      breakdown: breakdown,
+      dominant_dimension: dominant_dimension,
+    },
+  };
+
+  // Canon Part 8 Layer 2: pre-return audit on composite output. Defense
+  // in depth. If a future refactor propagates substrate_metadata.title or
+  // similar fields into the envelope, the audit catches forbidden bytes
+  // at the gate.
+  auditQueryObject(out, 'breakthrough-scorer');
+
+  return out;
+}
+
+// ---------- Exports ----------
+
+module.exports = {
+  scoreBreakthrough: scoreBreakthrough,
+  _test: {
+    DIMENSIONS: DIMENSIONS,
+    TIER_TO_FEASIBILITY: TIER_TO_FEASIBILITY,
+    SIGNAL_COUNT_TO_MARKET: SIGNAL_COUNT_TO_MARKET,
+    DIFF_TO_MAGNITUDE: DIFF_TO_MAGNITUDE,
+    PAIR_DENSITY_TO_ADVANTAGE: PAIR_DENSITY_TO_ADVANTAGE,
+    BERT_TO_IMPACT: BERT_TO_IMPACT,
+    computeDominant: computeDominant,
+  },
+};

package/lib/core/rs-canon-violations.cjs

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ * Phase 89.4 Plan 01 -- Canon Part 3 closed-vocabulary enforcement.
+ *
+ * Sibling of rs-egress-violations.cjs (89.2-01) by ANATOMY but
+ * SEPARATE module by SEMANTICS. ExternalEgressViolation guards
+ * outbound flow to public external fetchers; CanonVerbViolation
+ * guards the 10-verb closed vocabulary at the Decision Gate
+ * boundary. Sharing the class would conflate two distinct
+ * chokepoints. Both classes follow identical anatomy (.name + .meta)
+ * so Canon-aware caller wrappers catch them uniformly via err.name.
+ *
+ * The 10-verb canonical vocabulary is authoritative per
+ * docs/MINDRIAN-CANON.md Part 3 lines 153-162. New verbs require
+ * canon amendment, not a code-level invention.
+ *
+ * meta convention (informal, not enforced): callers SHOULD populate
+ *   meta.attempted_verb (string)  the verb_string that failed validation
+ *   meta.surface        (string)  the call-site tag, e.g. 'navigation-engine'
+ * The class itself does not enforce shape so adversarial fixtures can
+ * probe edge cases (default meta = {}, omitted meta) without
+ * instantiation fighting them.
+ *
+ * validateVerb contract:
+ *   typeof verb_string !== 'string'  -> TypeError ('must be a string')
+ *   empty or out-of-set string       -> CanonVerbViolation
+ *   in-set string                    -> returns the input verbatim
+ *
+ * surface argument is optional. When supplied as a non-empty string it
+ * propagates to err.meta.surface. When omitted or empty, defaults to
+ * the literal 'unknown' so downstream audit log lines always carry a
+ * non-empty surface tag (mirrors Phase 89.2 audit-triple convention).
+ *
+ * CANONICAL_VERBS is Object.freeze'd so accidental mutation throws in
+ * strict mode and Object.isFrozen returns true. Downstream consumers
+ * (89.5 NL-Graph Surface UI, future Decision Gate renderers) can
+ * enumerate the set without defensive copying.
+ *
+ * Pure CJS, zero npm deps, no Node built-ins beyond core require.
+ */
+'use strict';
+
+class CanonVerbViolation extends Error {
+  constructor(message, meta) {
+    super(message);
+    this.name = 'CanonVerbViolation';
+    this.meta = meta || {};
+  }
+}
+
+const CANONICAL_VERBS = Object.freeze([
+  'Run Methodology',
+  'Reformulate',
+  'Spawn Sub-Agent',
+  'Navigate Graph',
+  "Devil's Advocate",
+  'Scenario Plan',
+  'Synthesize',
+  'Bank Opportunity',
+  'Defer',
+  'Free-Text',
+]);
+
+function validateVerb(verb_string, surface) {
+  if (typeof verb_string !== 'string') {
+    throw new TypeError(
+      'validateVerb: input must be a string; got ' + typeof verb_string
+    );
+  }
+  const surfaceTag = (typeof surface === 'string' && surface.length > 0)
+    ? surface
+    : 'unknown';
+  if (!CANONICAL_VERBS.includes(verb_string)) {
+    throw new CanonVerbViolation(
+      'verb not in Canon Part 3 closed vocabulary: ' + JSON.stringify(verb_string),
+      { attempted_verb: verb_string, surface: surfaceTag }
+    );
+  }
+  return verb_string;
+}
+
+module.exports = { CanonVerbViolation, CANONICAL_VERBS, validateVerb };

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

@@ -0,0 +1,343 @@
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ * Phase 89.4 Plan 02 -- engine-choreography codification (core).
+ * Phase 89.4 Plan 03 -- skill-spawn rule table wired in place.
+ *
+ * Codifies upstream + downstream chain wiring for the RS Discovery
+ * Engine per kickoff section 6 (USER LOAD-BEARING INTENT 7).
+ *
+ *   lookupUpstream(problem_type, stage, opts?)
+ *     -- queries Brain FEEDS_INTO topology via the EXISTING brain-client
+ *        chokepoint (Canon Part 7); returns {state: 'ready'} OR
+ *        {state: 'pause', missing_upstream, suggested_action}.
+ *
+ *   emitChainMetadata(rs_type, breakthrough_score, active_context)
+ *     -- returns the chain metadata block consumed by RS output
+ *        layer; recommended_verb validated via Canon Part 3 closed-
+ *        vocabulary checker (89.4-01) BEFORE the block is returned.
+ *        Plan 89.4-03 wires the internal recommendSkillSpawn call so the
+ *        chain metadata block carries spawn_skill + confidence + reasoning
+ *        derived from the SKILL_SPAWN_RULES table.
+ *
+ *   recommendSkillSpawn(rs_type, breakthrough_score, opts)
+ *     -- Plan 89.4-03 swap: first-match-wins iteration over the locked
+ *        SKILL_SPAWN_RULES table per kickoff section 6.4. Returns the
+ *        recommendation; NEVER auto-invokes a skill (the user picks via
+ *        the Canon Part 3 verb at the Decision Gate; 89.5 / 91 concern).
+ *
+ *   SKILL_SPAWN_RULES (frozen)
+ *     -- 5 rules per kickoff section 6.4 in declared order. Object.freeze'd
+ *        at module scope AND each rule entry is independently frozen so
+ *        the table cannot mutate at runtime.
+ *
+ * Reuses (Canon Part 7):
+ *   brain-client.cjs::query / isAvailable           (89.1a chokepoint)
+ *   rs-egress-prompts.cjs::auditQueryObject         (89.2-01 chokepoint)
+ *   rs-canon-violations.cjs::validateVerb           (89.4-01)
+ *   rs-canon-violations.cjs::CanonVerbViolation     (89.4-01)
+ *   rs-egress-violations.cjs::ExternalEgressViolation (89.2-01)
+ *
+ * Brain query graceful-degradation order (mirrors Phase 90 Mode B/C/Tier-0):
+ *   1. brainClient.isAvailable() === false -> {state: 'ready'} + warn
+ *   2. brainClient.query() throws or returns null -> {state: 'ready'} + warn
+ *   3. response.records absent or wrong shape -> {state: 'ready'} + warn
+ *   4. Cross-reference returned framework names against
+ *      opts.upstreamFreshness Map<name, boolean>; absent key = fresh.
+ *
+ * Canon Part 8 defense-in-depth:
+ *   - lookupUpstream input ({problem_type, stage}) is audited via
+ *     auditQueryObject BEFORE any Brain query is dispatched. If the
+ *     audit trips, no Brain RPC is made and ExternalEgressViolation
+ *     bubbles to the caller.
+ *   - emitChainMetadata input (active_context) is audited via
+ *     auditQueryObject so adversarial bytes nested in active_context.meta
+ *     cannot smuggle into the returned metadata block.
+ *   - recommendSkillSpawn opts (when non-empty) is audited as well.
+ *   - The module never reaches the network directly; the only outbound
+ *     surface is brainClient.query, which inherits 89.1a's allow-list.
+ *
+ * Pure CJS, zero npm deps, no Node built-ins beyond core require.
+ */
+'use strict';
+
+const brainClientDefault = require('./brain-client.cjs');
+const { auditQueryObject } = require('./rs-egress-prompts.cjs');
+const { ExternalEgressViolation } = require('./rs-egress-violations.cjs');
+const {
+  validateVerb,
+  CanonVerbViolation,
+  CANONICAL_VERBS,
+} = require('./rs-canon-violations.cjs');
+
+// ---------- Skill-spawn rule table (Plan 89.4-03; LOCKED per kickoff section 6.4) ----------
+
+// Rules are evaluated in declared order via first-match-wins semantics.
+// Confidence values match the kickoff section 6.4 specification verbatim;
+// the 0.7 RECOMMENDED threshold is enforced by the CALLER (Plan 89.5
+// Decision Gate UI) per Phase 88.2 Navigation Engine Brain interface
+// contract. recommendSkillSpawn returns the raw confidence so callers can
+// choose whether to surface a RECOMMENDED chip.
+//
+// Each rule entry is independently Object.freeze'd so the table cannot be
+// mutated at runtime even if a caller obtains a reference to a rule. The
+// match() functions are pure (no side effects, no I/O) and tolerate
+// missing opts keys via `(opts.X || 0)` / `(opts.X || []).length` guards.
+const SKILL_SPAWN_RULES = Object.freeze([
+  Object.freeze({
+    match: function (rs, score, opts) {
+      return score >= 7 && rs === 'structural_transfer';
+    },
+    spawn: '/mos:find-analogies',
+    confidence: 0.85,
+    reasoning: 'high breakthrough + structural transfer -> SAPPhIRE/TRIZ deepening',
+  }),
+  Object.freeze({
+    match: function (rs, score, opts) {
+      return score >= 7 && (opts.industry_signals_count || 0) > 0;
+    },
+    spawn: '/mos:lean-canvas',
+    confidence: 0.80,
+    reasoning: 'high breakthrough + market signal -> business model exploration',
+  }),
+  Object.freeze({
+    match: function (rs, score, opts) {
+      return (opts.cross_methodology_substrates || []).length > 1;
+    },
+    spawn: '/mos:pipeline',
+    confidence: 0.75,
+    reasoning: 'cross-methodology discovery -> chained pipeline (RS -> JTBD -> Persona)',
+  }),
+  Object.freeze({
+    match: function (rs, score, opts) {
+      return (opts.resolved_experts_count || 0) > 5
+        && (opts.resolved_institutions_count || 0) > 1;
+    },
+    spawn: '/mos:persona',
+    confidence: 0.70,
+    reasoning: 'expert network dense -> team composition',
+  }),
+  Object.freeze({
+    match: function (rs, score, opts) {
+      return score < 5 && opts.cynefin === 'complex';
+    },
+    spawn: '/mos:think-hats',
+    confidence: 0.65,
+    reasoning: 'low breakthrough + Cynefin complex -> perspective diversity',
+  }),
+]);
+
+// ---------- Internal helpers ----------
+
+// Sanitize a string for embedding in a Cypher query. Mirrors the byte-
+// for-byte whitelist from brain-client.cjs::sanitizeCypherInput
+// ([a-zA-Z0-9 ._-]). We do NOT call brainClient._test.sanitizeCypherInput
+// directly so this module remains testable with a stub brainClient.
+function _sanitizeCypher(value) {
+  if (value === null || value === undefined) return '';
+  const s = typeof value === 'string' ? value : String(value);
+  return s.replace(/[^a-zA-Z0-9 ._-]/g, '');
+}
+
+// Build the Brain Cypher query asking for upstream FEEDS_INTO frameworks
+// for the reverse-salient engine, parameterized (defensively sanitized)
+// by problem_type + stage for forward-compat (89.5 may bind these via
+// Brain's parameterized query path).
+function _buildUpstreamCypher(problem_type, stage) {
+  const safeProblem = _sanitizeCypher(problem_type);
+  const safeStage = _sanitizeCypher(stage);
+  // Note: safeProblem / safeStage are intentionally embedded in a
+  // comment line so they participate in the query text without
+  // affecting the MATCH semantics. The authoritative Brain edge query
+  // is for upstream frameworks pointing at the reverse-salient node.
+  return (
+    '// chain-feeder upstream lookup (problem_type=' + safeProblem +
+    ' stage=' + safeStage + ')\n' +
+    'MATCH (rs:Framework {id: "reverse-salient-framework"}) ' +
+    '<-[:FEEDS_INTO]-(upstream:Framework) ' +
+    'WHERE rs.id IS NOT NULL ' +
+    'RETURN upstream.name AS name LIMIT 10'
+  );
+}
+
+// Defensively pull the framework name from a Brain record. Brain
+// returns either {name: '...'} (driver-mode) or [n0, n1, ...] (raw
+// columns). We support both.
+function _recordName(rec) {
+  if (!rec || typeof rec !== 'object') return null;
+  if (typeof rec.name === 'string') return rec.name;
+  if (Array.isArray(rec) && typeof rec[0] === 'string') return rec[0];
+  return null;
+}
+
+// ---------- Public surface: lookupUpstream ----------
+
+async function lookupUpstream(problem_type, stage, opts) {
+  opts = opts || {};
+  const brainClient = opts.brainClient || brainClientDefault;
+
+  // Canon Part 8: pre-flight audit on the input strings before they
+  // can reach Brain. ExternalEgressViolation bubbles to the caller.
+  auditQueryObject(
+    { problem_type: problem_type, stage: stage },
+    'rs-chain-feeder-lookup-upstream'
+  );
+
+  if (!brainClient.isAvailable()) {
+    process.stderr.write('chain-feeder: Brain unreachable; assuming upstream ready\n');
+    return { state: 'ready' };
+  }
+
+  let result;
+  try {
+    const cypher = _buildUpstreamCypher(problem_type, stage);
+    result = await brainClient.query(cypher);
+  } catch (_err) {
+    process.stderr.write('chain-feeder: Brain query threw; assuming upstream ready\n');
+    return { state: 'ready' };
+  }
+
+  if (!result || !Array.isArray(result.records)) {
+    process.stderr.write(
+      'chain-feeder: Brain query returned unexpected shape; assuming upstream ready\n'
+    );
+    return { state: 'ready' };
+  }
+
+  // Cross-reference upstream framework names against active room state
+  // freshness. Plan 89.4-02 ships a minimal in-memory check: if
+  // opts.upstreamFreshness is provided (Map<framework_name, boolean>),
+  // use it. Absent key = fresh by default (Phase 89.5 will integrate
+  // folder-memory.cjs for real freshness reads against BRAIN.md
+  // quadruples per Phase 90).
+  const freshness = opts.upstreamFreshness instanceof Map
+    ? opts.upstreamFreshness
+    : new Map();
+
+  const missing = [];
+  for (const rec of result.records) {
+    const name = _recordName(rec);
+    if (typeof name !== 'string' || name.length === 0) continue;
+    if (freshness.has(name) && freshness.get(name) === false) {
+      missing.push(name);
+    }
+  }
+
+  if (missing.length === 0) return { state: 'ready' };
+  return {
+    state: 'pause',
+    missing_upstream: missing,
+    suggested_action: 'Run Methodology',
+  };
+}
+
+// ---------- Public surface: emitChainMetadata ----------
+
+function emitChainMetadata(rs_type, breakthrough_score, active_context) {
+  active_context = active_context || {};
+
+  // Canon Part 8: scan active_context for FORBIDDEN_PATTERNS via the
+  // existing chokepoint. Adversarial bytes nested in any field
+  // (e.g., active_context.meta.contact) get caught here.
+  auditQueryObject(active_context, 'rs-chain-feeder-emit-metadata');
+
+  // feeds_into mapping (deterministic per rs_type).
+  let feeds_into;
+  if (rs_type === 'structural_transfer') feeds_into = 'PWS VP';
+  else if (rs_type === 'semantic_implementation') feeds_into = 'Causal Loop';
+  else if (rs_type === 'hybrid') feeds_into = 'Navigation Engine';
+  else feeds_into = 'JTBD'; // fallback for unknown rs_type
+
+  // recommended_verb selection (deterministic per breakthrough_score).
+  // Plan 89.4-03 may refine via skill rules; this module ships the
+  // baseline heuristic.
+  const score = Number(breakthrough_score);
+  const safeScore = Number.isFinite(score) ? score : 0;
+  let recommended_verb;
+  if (safeScore >= 7) recommended_verb = 'Bank Opportunity';
+  else if (safeScore >= 5) recommended_verb = 'Synthesize';
+  else recommended_verb = 'Reformulate';
+
+  // Canon Part 3: validate before returning. Defensive against future
+  // edits to the heuristic introducing out-of-set verbs.
+  validateVerb(recommended_verb, 'rs-chain-feeder-emit-metadata');
+
+  // Plan 89.4-03 wiring: the chain metadata block now carries the rule
+  // recommendation. active_context is reused as opts for the rule-table
+  // evaluation. recommendSkillSpawn re-runs auditQueryObject under its
+  // own surface tag; this is intentional double-defense and matches the
+  // sibling pattern in lookupUpstream (audit before any consequential
+  // computation, even if the caller already audited).
+  const skill = recommendSkillSpawn(rs_type, safeScore, active_context);
+
+  return {
+    recommended_verb: recommended_verb,
+    feeds_into: feeds_into,
+    spawn_skill: skill.spawn_skill,
+    confidence: skill.confidence,
+    reasoning: skill.reasoning,
+  };
+}
+
+// ---------- Public surface: recommendSkillSpawn (Plan 89.4-03 rule-table wired) ----------
+
+function recommendSkillSpawn(rs_type, breakthrough_score, opts) {
+  opts = opts || {};
+  // Canon Part 8 defense-in-depth (TIGHTENED in Plan 89.4-03): always run
+  // auditQueryObject when opts is a non-null object. The Plan 89.4-02 stub
+  // had a `Object.keys().length > 0` guard which, while sufficient for the
+  // stub, allowed adversarial single-key payloads to slip through if a
+  // caller post-mutated opts after the gate. The unconditional audit
+  // closes that window. Empty `{}` opts pass JSON.stringify('{}') trivially
+  // (zero forbidden-pattern hits).
+  auditQueryObject(opts, 'rs-chain-feeder-recommend-skill-spawn');
+
+  const score = Number(breakthrough_score);
+  const safeScore = Number.isFinite(score) ? score : 0;
+
+  // First-match-wins: iterate SKILL_SPAWN_RULES in declared order; the
+  // first rule whose match() returns true wins; subsequent rules are NOT
+  // evaluated. If no rule matches, return the no-rule fallback shape.
+  for (let i = 0; i < SKILL_SPAWN_RULES.length; i++) {
+    const rule = SKILL_SPAWN_RULES[i];
+    let matched = false;
+    try {
+      matched = !!rule.match(rs_type, safeScore, opts);
+    } catch (_e) {
+      // Defensive: a rule predicate that throws on unexpected opts shape
+      // never crashes the loop. Treated as a non-match so the iteration
+      // continues. This preserves first-match-wins semantics even under
+      // malformed input.
+      matched = false;
+    }
+    if (matched) {
+      return {
+        spawn_skill: rule.spawn,
+        confidence: rule.confidence,
+        reasoning: rule.reasoning,
+      };
+    }
+  }
+
+  return {
+    spawn_skill: null,
+    confidence: 0,
+    reasoning: 'no rule matched',
+  };
+}
+
+// ---------- Module exports ----------
+
+module.exports = {
+  lookupUpstream,
+  emitChainMetadata,
+  recommendSkillSpawn,
+  // Plan 89.4-03 export (additive). Frozen array; callers may iterate
+  // for introspection (e.g., 89.5 NL-Graph Surface UI listing
+  // recommended skills) but cannot mutate.
+  SKILL_SPAWN_RULES,
+  // Re-export so Canon-aware caller wrappers can catch by err.name
+  // without re-requiring the upstream modules themselves.
+  ExternalEgressViolation,
+  CanonVerbViolation,
+  CANONICAL_VERBS,
+};