@mindrian_os/cli 2.0.0-beta.3 → 2.0.0-beta.31

package/lib/hmi/agentshield-drift-gate.cjs

@@ -0,0 +1,142 @@
+'use strict';
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 199-06 (AS-07) -- the AgentShield drift Decision Gate.
+ * ==========================================================================
+ * When the SessionStart drift scan (scripts/agentshield-sessionstart-scan.cjs)
+ * finds a NEW finding since the last locally-cached scan, the informative move is
+ * to surface it through a Shape F.1 Decision Gate {Investigate, Defer}, never a
+ * silent swallow and never a hard block (a SessionStart hook INFORMS). This module
+ * is that gate: a thin composition over the shipped open-vocab Shape F.1 renderer
+ * (lib/hmi/shape-f1-renderer.cjs). It invents no new selector shape (Part 7
+ * reuse) and mints no new frozen scalar -- it reuses the renderer's MAX_K / verb-
+ * cap / mode machinery untouched, exactly as 196-05's part8-egress-gate.cjs does.
+ *
+ * Constitutional invariants:
+ *   - The verb set is EXACTLY {Investigate, Defer} plus the auto-appended
+ *     Free-Text. 'Defer' is already a CANONICAL_VERB (shape-f1-renderer.cjs:62);
+ *     'Investigate' rides the open-vocabulary user-supplied verb path, mirroring
+ *     how 196-05 mixed one canonical verb (Reformulate) with one custom verb
+ *     (Cancel). Investigate is marked recommended in Mode A.
+ *   - D-09 discipline (borrowed from 196-05 even though this is NOT a Part-8
+ *     egress gate): the header names the SURFACE SLUG and the COUNT only, never a
+ *     file path and never a matched byte of the offending target. No payload
+ *     sample rides the render.
+ *   - This module opens ZERO Brain wire and makes ZERO network call. There is no
+ *     Brain-availability concept for this gate, so no degrade() function exists;
+ *     instead a pure shouldRender(cacheEntry, finding) helper suppresses a finding
+ *     the local dedup cache has already surfaced, so the SAME finding is never
+ *     re-rendered every session.
+ *
+ * NO em-dashes anywhere (CLAUDE.md HARD RULE). Hyphens only. Pure CJS, zero deps.
+ *
+ * License: BSL 1.1.
+ */
+
+const path = require('node:path');
+
+const RENDERER_PATH = path.join(__dirname, 'shape-f1-renderer.cjs');
+
+// The exact verb set the gate offers. Investigate + Defer ONLY; the renderer
+// appends Free-Text last automatically. This constant is the gate contract.
+const GATE_VERBS = ['Investigate', 'Defer'];
+const RECOMMENDED_VERB = 'Investigate';
+
+/**
+ * _surfaceSlug(v) -> string
+ *
+ * Reduce the surface name to a bounded lowercase slug so the header can name the
+ * surface CATEGORY without ever carrying an offending byte (D-09). Anything
+ * non-slug collapses to 'unknown'.
+ */
+function _surfaceSlug(v) {
+  if (typeof v !== 'string' || v.length === 0) return 'unknown';
+  const s = v.toLowerCase().replace(/[^a-z0-9_]/g, '_').slice(0, 40);
+  return s.length > 0 ? s : 'unknown';
+}
+
+/**
+ * _count(v) -> number
+ *
+ * Coerce findingCount to a non-negative integer for the header. Anything
+ * non-numeric collapses to 0.
+ */
+function _count(v) {
+  const n = (typeof v === 'number' && isFinite(v)) ? Math.floor(v) : 0;
+  return n >= 0 ? n : 0;
+}
+
+/**
+ * renderGate({ surface, findingCount, ruleId }) -> { zones, contract }
+ *
+ * Compose the Shape F.1 renderer with the fixed {Investigate, Defer} verb set and
+ * a surface-slug-plus-count-only header (never a file path, never matched bytes).
+ * The gate is always a Mode-A decision gate (tier:2, Investigate recommended).
+ * Returns the renderer's { zones, contract } straight through. Asserts by
+ * construction that both gate verbs survived into the contract before returning.
+ */
+function renderGate(input) {
+  const v = (input && typeof input === 'object') ? input : {};
+  const surfaceSlug = _surfaceSlug(v.surface);
+  const findingCount = _count(v.findingCount);
+  const header = '-- agentshield -- ' + findingCount + ' new finding(s) on '
+    + surfaceSlug + ' -- pick --';
+
+  const renderShapeF1 = require(RENDERER_PATH).renderShapeF1;
+  const out = renderShapeF1({
+    tier: 2, // Mode A -- the drift gate always recommends Investigate.
+    recommendedVerb: RECOMMENDED_VERB,
+    verbs: GATE_VERBS.slice(),
+    header: header,
+  });
+
+  // By-construction assertion: the composed contract MUST carry both gate verbs.
+  // The verb set is fixed above so this can never trip; it is a self-check that
+  // fails LOUD rather than silently surface a malformed gate.
+  const verbs = (out && out.contract && Array.isArray(out.contract.verbs))
+    ? out.contract.verbs
+    : [];
+  for (let i = 0; i < GATE_VERBS.length; i++) {
+    if (verbs.indexOf(GATE_VERBS[i]) === -1) {
+      throw new Error('agentshield-drift-gate: gate verb "' + GATE_VERBS[i]
+        + '" missing from composed contract');
+    }
+  }
+  return out;
+}
+
+/**
+ * findingKey(finding) -> string
+ *
+ * The stable local dedup key for a scan finding: surface + ruleId + id. This is
+ * the key the drift cache stores and shouldRender checks against, so the SAME
+ * finding on the SAME surface with the SAME rule never re-renders across sessions.
+ */
+function findingKey(finding) {
+  const f = (finding && typeof finding === 'object') ? finding : {};
+  return String(f.surface) + '::' + String(f.ruleId) + '::' + String(f.id);
+}
+
+/**
+ * shouldRender(cacheEntry, finding) -> boolean
+ *
+ * Returns false when the finding's surface+ruleId+id key was already present in
+ * the local dedup cache (already surfaced in a prior session), true otherwise.
+ * cacheEntry is the parsed local cache object; its `keys` array holds the seen
+ * finding keys. A missing / malformed cache means nothing has been seen yet, so a
+ * finding renders.
+ */
+function shouldRender(cacheEntry, finding) {
+  if (!finding || typeof finding !== 'object') return false;
+  const seen = (cacheEntry && Array.isArray(cacheEntry.keys)) ? cacheEntry.keys : [];
+  return seen.indexOf(findingKey(finding)) === -1;
+}
+
+module.exports = {
+  renderGate: renderGate,
+  shouldRender: shouldRender,
+  findingKey: findingKey,
+  GATE_VERBS: GATE_VERBS.slice(),
+  RECOMMENDED_VERB: RECOMMENDED_VERB,
+};

package/lib/hmi/brain-review-packet.cjs

@@ -0,0 +1,221 @@
+'use strict';
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 148-05 Task 2 (IRW-08, D-04) -- the typed Brain-review packet builder.
+ * ==========================================================================
+ * The Brain-review standing option ("outside review") auto-reviews the latest
+ * findings and surfaces contradictions + the next framework chain WITHOUT a scope
+ * prompt (D-04). It is the SINGLE highest-risk path in the phase (Canon Part 8
+ * boundary): a finding body egressed via Brain review is a constitutional breach.
+ *
+ * The defense is STRUCTURAL, not procedural:
+ *
+ *   1. Contradictions are surfaced LOCALLY from room.db via navigation.cjs
+ *      (getNeighborhood + the CONTRADICTS edges) -- never sent to Brain. The
+ *      packet carries ONLY the count of local contradictions + the generic
+ *      framework handles involved, never a finding body, artifact text, number,
+ *      or name (Phase 110 typed-packet contract).
+ *
+ *   2. The outbound methodology question is composed ONLY from generic framework
+ *      handles + phase ids + enum scalars ("what chains from <framework> at phase
+ *      <N>?"). The framework handle is gated through
+ *      rs-egress-prompts.auditQueryString (default-deny) BEFORE it is allowed into
+ *      the packet -- a smuggled body throws ExternalEgressViolation and the build
+ *      degrades to local-only.
+ *
+ *   3. Any Brain response is passed through brain-response-sanitize.sanitize
+ *      (the A3 PII-redaction sanitizer, the 6th Part-8 tripwire) before it is
+ *      surfaced.
+ *
+ *   4. On Brain-unreachable (mode_b / tier_0) the option DEGRADES to a local-only
+ *      answer (omits the Brain line) -- it NEVER blocks (D-04).
+ *
+ * All reads route through navigation.cjs (Part 9 chokepoint); this module opens no
+ * room.db directly and writes nothing.
+ *
+ * NO em-dashes / en-dashes anywhere (CLAUDE.md HARD RULE). Hyphens only.
+ *
+ * License: BSL 1.1.
+ */
+
+const EGRESS_SURFACE = 'brain-review';
+
+// How far the local contradiction scan reaches off the focus node.
+const NEIGHBORHOOD_TOP_K = 200;
+const NEIGHBORHOOD_MAX_DEPTH = 2;
+
+/**
+ * _safeAudit(handle) -> string | null
+ *
+ * Run a single generic framework handle through the default-deny
+ * auditQueryString gate. On a forbidden-pattern hit (a smuggled body, an email, a
+ * number, etc.) auditQueryString THROWS; we catch and return null so the caller
+ * drops the handle rather than letting it cross. Returns the handle on a clean
+ * pass. This is the structural egress gate (T-148-05-01 mitigation).
+ */
+function _safeAudit(handle) {
+  if (typeof handle !== 'string' || handle.trim().length === 0) return null;
+  try {
+    const egress = require('../core/rs-egress-prompts.cjs');
+    return egress.auditQueryString(handle.trim(), EGRESS_SURFACE);
+  } catch (_e) {
+    // ExternalEgressViolation (or any audit failure) -> drop the handle.
+    return null;
+  }
+}
+
+/**
+ * _localContradictions(db, focusNodeId) -> { count, framework_handles }
+ *
+ * Surface contradictions LOCALLY from room.db via navigation.cjs. Reads the
+ * neighborhood off the focus node and filters to CONTRADICTS edges, returning the
+ * COUNT only. The navigation.cjs getNeighborhood projection deliberately exposes
+ * ONLY typed scalars (id / type / edgeTypeIn / score / review_status / timestamps)
+ * and NEVER the node `properties` blob -- so there is structurally NO finding
+ * body, summary, artifact text, number, or name available to leak here. The
+ * framework_handles set therefore stays driven ONLY by the explicitly-passed,
+ * audited input.framework (see buildBrainReviewPacket), never derived from a local
+ * node body. Wrapped: any read failure returns the empty shape (degrade, never
+ * crash).
+ */
+function _localContradictions(db, focusNodeId) {
+  const empty = { count: 0, framework_handles: [] };
+  if (!db || typeof focusNodeId !== 'string' || focusNodeId.length === 0) return empty;
+  try {
+    const navigation = require('../core/navigation.cjs');
+    const neighbors = navigation.getNeighborhood(db, focusNodeId, {
+      topK: NEIGHBORHOOD_TOP_K,
+      maxDepth: NEIGHBORHOOD_MAX_DEPTH,
+    }) || [];
+    const contradicts = neighbors.filter(function (n) {
+      return n && n.edgeTypeIn === 'CONTRADICTS';
+    });
+    // Count only -- no per-node handle is read off the (intentionally bodyless)
+    // neighborhood projection. framework_handles is populated solely from the
+    // audited input.framework at the call site.
+    return { count: contradicts.length, framework_handles: [] };
+  } catch (_e) {
+    return empty;
+  }
+}
+
+/**
+ * buildBrainReviewPacket(input) -> packet
+ *
+ * input = {
+ *   db,             // room.db handle (opened by the caller via room-db.cjs)
+ *   focusNodeId,    // the node the review centers on (e.g. 'section:<slug>')
+ *   framework,      // the generic framework handle the chain question is about
+ *   phaseId,        // optional integer phase id for the chain question
+ *   tierMode,       // 'mode_a' | 'mode_b' | 'tier_0' (Brain reachability)
+ *   brainResponse,  // optional raw Brain response string (sanitized before use)
+ * }
+ *
+ * Returns a TYPED methodology packet:
+ *   {
+ *     kind: 'brain_review',
+ *     local: { contradiction_count, framework_handles[] },   // LOCAL only
+ *     methodology_question: '<generic handle + phase id>' | null,  // audited
+ *     brain_line: '<sanitized brain response>' | null,        // null when degraded
+ *     degraded: boolean,                                      // true => local-only
+ *   }
+ *
+ * NEVER contains a finding body, artifact text, raw number, or name. On
+ * Brain-unreachable, brain_line is null and degraded is true (D-04: never blocks).
+ * Never throws.
+ */
+function buildBrainReviewPacket(input) {
+  const inp = (input && typeof input === 'object') ? input : {};
+  const tierMode = (inp.tierMode === 'mode_a' || inp.tierMode === 'mode_b' || inp.tierMode === 'tier_0')
+    ? inp.tierMode : 'tier_0';
+
+  // 1. LOCAL contradictions (never sent to Brain). Count-only; the projection
+  //    carries no node body.
+  const local = _localContradictions(inp.db, inp.focusNodeId);
+
+  // 2. The outbound methodology question -- composed ONLY from a generic
+  //    framework handle (audited, default-deny) + an optional integer phase id +
+  //    enum scalars. A smuggled body fails the audit and yields a null question.
+  const auditedFramework = _safeAudit(inp.framework);
+
+  // The only framework handle the packet surfaces is the audited input.framework
+  // (a generic handle that cleared the default-deny gate). A smuggled body yields
+  // null here and never reaches framework_handles.
+  if (auditedFramework && local.framework_handles.indexOf(auditedFramework) === -1) {
+    local.framework_handles.push(auditedFramework);
+  }
+  let methodologyQuestion = null;
+  if (auditedFramework) {
+    const phaseId = Number.isInteger(inp.phaseId) ? inp.phaseId : null;
+    methodologyQuestion = (phaseId !== null)
+      ? ('what chains from ' + auditedFramework + ' at phase ' + phaseId + '?')
+      : ('what chains from ' + auditedFramework + '?');
+    // Final defense-in-depth: audit the COMPOSED question too (the handle was
+    // clean, but re-audit the whole string so the composed form cannot smuggle).
+    methodologyQuestion = _safeAuditQuestion(methodologyQuestion);
+  }
+
+  // 3. Brain line: only when Brain is reachable (mode_a) AND a response was
+  //    provided. The response is sanitized (A3 PII redaction) before it surfaces.
+  //    Otherwise degrade to local-only (omit the Brain line; never block).
+  let brainLine = null;
+  let degraded = true;
+  if (tierMode === 'mode_a' && typeof inp.brainResponse === 'string' && inp.brainResponse.length > 0) {
+    brainLine = _sanitizeBrain(inp.brainResponse);
+    degraded = false;
+  }
+
+  return {
+    kind: 'brain_review',
+    local: {
+      contradiction_count: local.count,
+      framework_handles: local.framework_handles,
+    },
+    methodology_question: methodologyQuestion,
+    brain_line: brainLine,
+    degraded: degraded,
+  };
+}
+
+/**
+ * _safeAuditQuestion(question) -> string | null
+ *
+ * Re-audit the COMPOSED methodology question through the default-deny gate. The
+ * handle was already clean, but the composed string is the actual outbound
+ * payload, so it gets the final word. Returns null on any violation.
+ */
+function _safeAuditQuestion(question) {
+  if (typeof question !== 'string' || question.length === 0) return null;
+  try {
+    const egress = require('../core/rs-egress-prompts.cjs');
+    return egress.auditQueryString(question, EGRESS_SURFACE);
+  } catch (_e) {
+    return null;
+  }
+}
+
+/**
+ * _sanitizeBrain(text) -> string
+ *
+ * Pass a Brain response through brain-response-sanitize.sanitize (A3 PII
+ * redaction). Wrapped: if the sanitizer module is unavailable, return an empty
+ * string (fail closed -- never surface an unsanitized response).
+ */
+function _sanitizeBrain(text) {
+  try {
+    const sanitizer = require('../core/brain-response-sanitize.cjs');
+    return sanitizer.sanitize(text);
+  } catch (_e) {
+    return '';
+  }
+}
+
+module.exports = {
+  buildBrainReviewPacket: buildBrainReviewPacket,
+  EGRESS_SURFACE: EGRESS_SURFACE,
+  // Test seams (the IRW-08 adversarial suite spies these).
+  _localContradictions: _localContradictions,
+  _safeAudit: _safeAudit,
+  _sanitizeBrain: _sanitizeBrain,
+};

package/lib/hmi/cortex-reach-adapter.cjs

@@ -0,0 +1,271 @@
+'use strict';
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 150-06 (MEM-06, D-02) -- the cortex -> reachScores adapter.
+ * =================================================================
+ * The NEW caller that folds the projected cortex (the Wave-2 legD cortexNodes
+ * from lib/core/navigation/room-context.cjs getRoomContext) into the
+ * roomState.reachScores prior map that the FROZEN dial ranker
+ * (lib/hmi/dial-reach-orchestrator.cjs buildReachList) already consumes.
+ *
+ * THIS IS A CALLER, NOT AN ORCHESTRATOR EDIT (Canon Part 7 + the UI-SPEC
+ * resolve/format split). The orchestrator stays a PURE renderer: it reads
+ * roomState.reachScores and ranks; it never opens room.db, never reaches the
+ * cortex. This module reads the already-surfaced cortexNodes (legD already did
+ * the single caller-owned-db SELECT) and produces the 0..1 prior map. It does
+ * NOT raise or lower DIAL_REACH_K, MAX_K, or the 0.70/0.15 gate -- it only
+ * supplies the priors the frozen ranker consumes.
+ *
+ * THE FLAT-FILE SIDE-CHANNEL IS DEMOTED TO FALLBACK (D-02). When cortexNodes are
+ * present the adapter's scores win (the caller threads them into
+ * roomState.reachScores). When cortexNodes are ABSENT the adapter returns an
+ * empty map, so the orchestrator's existing flat-file path (the registry-only
+ * defaults + the D4 floor) is the fallback. The adapter never fabricates a prior
+ * out of an empty cortex.
+ *
+ * Canon Part 8 (Graph Boundary): the adapter reads ONLY projected node-type
+ * presence + enum/scalar signals from cortexNodes (type, review_status, a small
+ * fixed set of property enums). It NEVER reads cortex PROSE into the dial and
+ * NEVER egresses -- pure, synchronous, LOCAL-only, zero Brain calls, zero fs,
+ * zero db (the legD SELECT already happened upstream). The output is a normalized
+ * 0..1 score map; no user-content string ever flows through it (threat
+ * T-150-06-03: the adapter reads presence + enums, never prose).
+ *
+ * Canon Part 9 (Memory Locality): SQL navigated (legD), this module reasons over
+ * the structured node fields, the dial ranks. No prose, no truth promotion.
+ *
+ * No em-dashes anywhere (CLAUDE.md HARD RULE). Hyphens only.
+ *
+ * Public API:
+ *   buildReachScoresFromCortex(cortexNodes) -> { reach_id: score(0..1) }
+ *   hasContradiction(cortexNodes) -> boolean   (the archetype-escalation signal)
+ *   CONTRIBUTIONS                              (the per-signal weight table)
+ *
+ * License: BSL 1.1.
+ */
+
+// The six frozen machine reaches (mirror dial-reach-orchestrator REACH_DEFS;
+// kept as a flat list here so the adapter never imports the orchestrator and the
+// two stay decoupled -- the orchestrator consumes whatever keys we hand it).
+const REACH_IDS = Object.freeze([
+  'context_block',
+  'contradiction',
+  'cross_room',
+  'brain_consult',
+  'deep_research',
+  'hats',
+]);
+
+// The cortex node types legD surfaces (mirror room-context.cjs CORTEX_NODE_TYPES).
+// presence-only reads -- never a prose field.
+//
+// Phase 150.8-04 (DIKW-09): 'claim' is added ADDITIVELY so a fresh typed truth-
+// claim node (lib/core/navigation/typed-claim.cjs writeClaimNode) lifts the dial.
+// It mirrors room-context.cjs CORTEX_NODE_TYPES (the two lists stay in lockstep
+// per the room-context :60 comment) so legD surfaces claim nodes and this adapter
+// reads them. The branch reads ONLY the knowledge_type ENUM (presence + enum),
+// NEVER claim prose (Canon Part 8 header :27-33), and a single claim_present
+// signal stays BELOW the 0.70 recommend floor solo (the :70-73 doctrine). Frozen
+// constants are UNTOUCHED: the adapter never imports the orchestrator, so
+// DIAL_REACH_K / MAX_K / 0.70 / 0.15 stay exactly where they are.
+const CORTEX_NODE_TYPES = Object.freeze([
+  'memory_artifact',
+  'governing_thought',
+  'navigator_persona',
+  'decision',
+  'claim',
+]);
+
+// Per-signal contribution weights. Each is a bounded additive nudge onto a
+// reach's prior; the sum is clamped to 0..1. The weights keep every cortex-built
+// prior BELOW the 0.70 recommend floor unless multiple signals stack -- a cold
+// cortex never solo-crosses the gate (mirrors the orchestrator's registry-only
+// 0.5 default discipline).
+const CONTRIBUTIONS = Object.freeze({
+  // A contradiction-flagged decision node present -> push the contradiction reach
+  // above the orchestrator's registry-only 0.5 floor (a contradiction in the
+  // cortex IS the one move most worth attention) while staying below the 0.70
+  // recommend gate, so a single signal escalates the one-move but never solo-
+  // crosses the marker floor.
+  contradiction_present: 0.55,
+  // A fresh governing_thought present -> the context_block reach is grounded.
+  governing_thought_fresh: 0.30,
+  // A governing_thought present at all (any freshness) -> modest context grounding.
+  governing_thought_present: 0.15,
+  // A navigator_persona projection present -> hats (persona hat-spin) is warmer.
+  persona_present: 0.20,
+  // A memory_artifact present -> brain_consult has local material to enrich.
+  memory_artifact_present: 0.10,
+  // Phase 150.8-04 (DIKW-09): a fresh typed claim present (knowledge_type enum
+  // resolves to a member of the frozen 6) -> context_block (the DIKW knowledge
+  // ladder is grounded by typed claims) gets a modest nudge. 0.10-class so a
+  // single claim signal stays BELOW the 0.70 recommend floor solo (the doctrine
+  // above); only stacked signals can cross the gate. The branch reads the
+  // knowledge_type ENUM only -- never claim prose (Canon Part 8).
+  claim_present: 0.10,
+});
+
+// Phase 150.8-04 (DIKW-09): the frozen 6-member knowledge-type enum (mirrors
+// lib/core/navigation/typed-claim.cjs KNOWLEDGE_TYPES). The claim branch accepts a
+// claim ONLY when its knowledge_type enum resolves to a member of this set -- an
+// off-enum value (or prose smuggled into the field) is ignored, so a poisoned
+// knowledge_type cannot influence reach scores (threat T-150.8-14). Enum/presence
+// only -- the adapter never reads claim prose (Canon Part 8).
+const KNOWLEDGE_TYPES = Object.freeze([
+  'fact', 'causal', 'heuristic', 'anomaly_cue', 'mental_model', 'assumption',
+]);
+
+function _clamp01(n) {
+  if (typeof n !== 'number' || !isFinite(n)) return 0;
+  if (n < 0) return 0;
+  if (n > 1) return 1;
+  return n;
+}
+
+// Read a small fixed set of property enums WITHOUT touching prose. The 150-01
+// writer contract stores handles/enums only, but we still treat property values
+// defensively: we read only the named enum keys and compare to fixed tokens.
+function _propEnum(node, key) {
+  if (!node || typeof node !== 'object') return null;
+  const props = node.properties;
+  if (!props || typeof props !== 'object') return null;
+  const v = props[key];
+  return (typeof v === 'string') ? v : null;
+}
+
+/**
+ * hasContradiction(cortexNodes) -> boolean
+ *
+ * The archetype-escalation signal (D-02): a decision node flagged as a
+ * contradiction is present in the projected cortex. Presence-only; reads the
+ * 'kind' enum, never prose. resolveArchetype(reach, cortexState) consumes this
+ * to escalate a 'select' reach to 'confirm'.
+ */
+function hasContradiction(cortexNodes) {
+  if (!Array.isArray(cortexNodes)) return false;
+  for (const node of cortexNodes) {
+    if (!node || typeof node !== 'object') continue;
+    if (node.type !== 'decision') continue;
+    if (_propEnum(node, 'kind') === 'contradiction') return true;
+  }
+  return false;
+}
+
+/**
+ * deriveCortexCtxSignals(cortexNodes) -> { staleGoverningThought, freshContradictions }
+ *
+ * The MED-01 PRODUCER: derive the two LOCAL ctx scalars sensorMemoryCortex reads
+ * (ctx.staleGoverningThought : boolean, ctx.freshContradictions : number) from
+ * the projected cortex (the legD cortexNodes). Presence + enum reads only -- a
+ * governing_thought whose freshness enum is 'stale' sets staleGoverningThought;
+ * each decision whose kind enum is 'contradiction' increments freshContradictions.
+ * Never reads prose (Canon Part 8). The navigation-engine decide() body threads
+ * the result onto sensorCtx so dispatchSensors can fire the memory-cortex bridge.
+ *
+ * Defensive: a non-array / empty input returns the neutral
+ * { staleGoverningThought: false, freshContradictions: 0 }; never throws.
+ */
+function deriveCortexCtxSignals(cortexNodes) {
+  const out = { staleGoverningThought: false, freshContradictions: 0 };
+  if (!Array.isArray(cortexNodes) || cortexNodes.length === 0) return out;
+  for (const node of cortexNodes) {
+    if (!node || typeof node !== 'object') continue;
+    if (CORTEX_NODE_TYPES.indexOf(node.type) === -1) continue;
+    if (node.type === 'governing_thought') {
+      if (_propEnum(node, 'freshness') === 'stale') out.staleGoverningThought = true;
+    } else if (node.type === 'decision') {
+      if (_propEnum(node, 'kind') === 'contradiction') out.freshContradictions += 1;
+    }
+  }
+  return out;
+}
+
+/**
+ * buildReachScoresFromCortex(cortexNodes) -> { reach_id: score(0..1) }
+ *
+ * Fold the projected cortex node-type presence + enum signals into a normalized
+ * prior map keyed by reach_id. Returns an EMPTY object when cortexNodes is empty
+ * or not an array -- so the orchestrator's flat-file path is the fallback (D-02).
+ *
+ * Pure / synchronous / LOCAL-only. Reads presence + enums, never prose. No Brain,
+ * no fs, no db.
+ */
+function buildReachScoresFromCortex(cortexNodes) {
+  if (!Array.isArray(cortexNodes) || cortexNodes.length === 0) {
+    // Empty cortex -> no priors -> flat-file fallback wins (D-02).
+    return {};
+  }
+
+  // Accumulate per-reach additive nudges from the observed cortex signals.
+  const acc = {};
+  function bump(reachId, weight) {
+    if (REACH_IDS.indexOf(reachId) === -1) return;
+    acc[reachId] = (typeof acc[reachId] === 'number' ? acc[reachId] : 0) + weight;
+  }
+
+  let sawGoverningThought = false;
+  let sawFreshGoverningThought = false;
+  let sawPersona = false;
+  let sawMemoryArtifact = false;
+  let sawContradiction = false;
+  let sawTypedClaim = false;
+
+  for (const node of cortexNodes) {
+    if (!node || typeof node !== 'object') continue;
+    const type = node.type;
+    if (CORTEX_NODE_TYPES.indexOf(type) === -1) continue;
+
+    if (type === 'governing_thought') {
+      sawGoverningThought = true;
+      if (_propEnum(node, 'freshness') === 'fresh') sawFreshGoverningThought = true;
+    } else if (type === 'navigator_persona') {
+      sawPersona = true;
+    } else if (type === 'memory_artifact') {
+      sawMemoryArtifact = true;
+    } else if (type === 'decision') {
+      if (_propEnum(node, 'kind') === 'contradiction') sawContradiction = true;
+    } else if (type === 'claim') {
+      // Phase 150.8-04 (DIKW-09): a typed truth-claim present. Read the
+      // knowledge_type ENUM ONLY (presence + enum membership); never claim prose
+      // (Canon Part 8). An off-enum / prose value is ignored, so a poisoned
+      // knowledge_type cannot lift the dial (threat T-150.8-14).
+      const kt = _propEnum(node, 'knowledge_type');
+      if (kt !== null && KNOWLEDGE_TYPES.indexOf(kt) !== -1) sawTypedClaim = true;
+    }
+  }
+
+  if (sawContradiction) bump('contradiction', CONTRIBUTIONS.contradiction_present);
+  if (sawFreshGoverningThought) {
+    bump('context_block', CONTRIBUTIONS.governing_thought_fresh);
+  } else if (sawGoverningThought) {
+    bump('context_block', CONTRIBUTIONS.governing_thought_present);
+  }
+  if (sawPersona) bump('hats', CONTRIBUTIONS.persona_present);
+  if (sawMemoryArtifact) bump('brain_consult', CONTRIBUTIONS.memory_artifact_present);
+  // Phase 150.8-04 (DIKW-09): a fresh typed claim nudges context_block (the DIKW
+  // knowledge ladder). 0.10-class -> stays BELOW the 0.70 recommend floor solo;
+  // it stacks additively with governing_thought signals on the same reach.
+  if (sawTypedClaim) bump('context_block', CONTRIBUTIONS.claim_present);
+
+  // Normalize: clamp each accumulated prior to 0..1. Only reaches that received
+  // a signal appear in the map; reaches with no cortex signal are left to the
+  // orchestrator's existing path (the flat-file fallback for those keys).
+  const out = {};
+  for (const reachId of Object.keys(acc)) {
+    out[reachId] = _clamp01(acc[reachId]);
+  }
+  return out;
+}
+
+module.exports = {
+  buildReachScoresFromCortex: buildReachScoresFromCortex,
+  hasContradiction: hasContradiction,
+  deriveCortexCtxSignals: deriveCortexCtxSignals,
+  CONTRIBUTIONS: CONTRIBUTIONS,
+  REACH_IDS: REACH_IDS,
+  // Phase 150.8-04 (DIKW-09): surfaced so the claim-branch test can assert the
+  // enum gate (enum-only read; off-enum ignored) and the CORTEX_NODE_TYPES mirror.
+  CORTEX_NODE_TYPES: CORTEX_NODE_TYPES,
+  KNOWLEDGE_TYPES: KNOWLEDGE_TYPES,
+};