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

package/lib/core/sensors/sensor-external-fact.cjs

@@ -0,0 +1,184 @@
+'use strict';
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 143-03 Task 1 -- SENS-04 external-fact detector (the gate-relevant web sensor).
+ *
+ * When the navigator references an external fact (competitor / market /
+ * state-of-the-art), this detector surfaces a HAT-SCOPED WebSearch candidate
+ * reach. The hat-scope comes from hat-scoping-table.cjs (Canon Part 2): White =
+ * data/arxiv, Green = patents + arxiv + deep-research, Black = failure-cases,
+ * Yellow = success-cases, Red = intuition-only (no web tool), Blue = synthesis.
+ *
+ * REUSE BEFORE BUILD (Canon Part 7): the underlying capability is shipped --
+ * /mos:research + WebSearch (commands/research.md). This detector does NOT run a
+ * search inline. It surfaces the DISPATCH HANDLE + the hat-scoped tool set; the
+ * navigator approves at the Decision Gate before any web call fires.
+ *
+ * THE MCP-STACK-ASK RULE (CLAUDE.md feedback_mcp_stack_awareness + 00c Section
+ * 3a): when the web trigger fires, the reach surfaces a Decision-Gate tool choice
+ * (Tavily / Firecrawl / Exa) UNLESS the active hat is pre-configured. It NEVER
+ * marks a silent WebSearch dispatch. The tool_choice_gate evidence flag and the
+ * tool-choice companions encode this.
+ *
+ * CANON PART 8 -- THE WEB QUERY IS PUBLIC SIGNAL: SIGNAL -> LOCAL is allowed (the
+ * sourced artifact files locally); SIGNAL -> Brain is forbidden. The reach's
+ * web-query payload carries ONLY a generic public topic handle (the matched
+ * external-fact category enum), NEVER the user's turn text or artifact bytes. The
+ * detector classifies WHICH category of external fact was named; it never copies
+ * the proprietary content into the reach. The inherited Part-8 sweep over
+ * lib/core/sensors/ spans this file -- it constructs the topic handle as a plain
+ * generic enum string, never via a hashing or egress-projection path.
+ *
+ * Phase 144 fence: this file PRODUCES a candidate reach; it never assigns
+ * routing_source and never requires/defines decide(). The routing fence over
+ * lib/core/sensors/ asserts this.
+ *
+ * Pure / sync / LOCAL-first. node built-ins + project libs only. No new deps.
+ * House rule: hyphens only, no em-dashes.
+ */
+
+const { makeReach } = require('./sensor-types.cjs');
+const { hatScopeFor } = require('./hat-scoping-table.cjs');
+
+/**
+ * External-fact reference patterns. Each maps a STRUCTURAL phrasing to a generic
+ * public TOPIC HANDLE (a category enum). The detector reports only WHICH category
+ * of external fact was named -- never the user's specific content. The handle is
+ * the public SIGNAL that may flow to LOCAL/web; it is generic by construction.
+ */
+const EXTERNAL_FACT_PATTERNS = [
+  { rx: /\bstate[- ]of[- ]the[- ]art\b/i, handle: 'state-of-the-art' },
+  { rx: /\bcompetitor(?:s|'s)?\b/i, handle: 'competitor' },
+  { rx: /\bcompeting\b/i, handle: 'competitor' },
+  { rx: /\bmarket (?:leader|leaders|landscape|analysis|size|share)\b/i, handle: 'market' },
+  { rx: /\bthe market\b/i, handle: 'market' },
+  { rx: /\bindustry benchmark\b/i, handle: 'benchmark' },
+  { rx: /\bbenchmark\b/i, handle: 'benchmark' },
+  { rx: /\bprior art\b/i, handle: 'prior-art' },
+  { rx: /\bpatent landscape\b/i, handle: 'prior-art' },
+  { rx: /\bwhat (?:is|are) (?:others|other teams|incumbents) (?:doing|building)\b/i, handle: 'incumbents' },
+];
+
+/**
+ * Pull the turn text as a string. Tolerant of { text } or { utterance }. Returns
+ * '' when absent/non-string so the caller soft-fails to null rather than throwing.
+ */
+function turnText(turn) {
+  if (!turn || typeof turn !== 'object') return '';
+  if (typeof turn.text === 'string') return turn.text;
+  if (typeof turn.utterance === 'string') return turn.utterance;
+  return '';
+}
+
+/**
+ * Pull the active hat off the turn (or ctx). Returns '' when absent. Defensive.
+ */
+function activeHat(turn, ctx) {
+  if (turn && typeof turn === 'object' && typeof turn.active_hat === 'string') return turn.active_hat;
+  if (ctx && typeof ctx === 'object' && typeof ctx.active_hat === 'string') return ctx.active_hat;
+  return '';
+}
+
+/**
+ * Classify the external-fact category from the turn text. Returns the generic
+ * public topic handle (a category enum) or '' when no external-fact pattern
+ * matches. This is the ONLY thing about the turn that ever rides the reach --
+ * the WHICH category, never the user's specific content.
+ */
+function classifyExternalFact(text) {
+  for (const p of EXTERNAL_FACT_PATTERNS) {
+    if (p.rx.test(text)) return p.handle;
+  }
+  return '';
+}
+
+/**
+ * True if the active hat is pre-configured to a single web tool, so the
+ * MCP-stack-ask Decision Gate is skipped. ctx.hat_tool_preconfigured is an
+ * optional LOCAL map { <Hat>: '<tool>' }.
+ */
+function preconfiguredTool(ctx, hat) {
+  if (!ctx || typeof ctx !== 'object') return '';
+  const map = ctx.hat_tool_preconfigured;
+  if (!map || typeof map !== 'object') return '';
+  const v = map[hat];
+  return (typeof v === 'string' && v.length > 0) ? v : '';
+}
+
+/**
+ * SENS-04 -- external-fact reference -> hat-scoped WebSearch reach.
+ *
+ * @param {object} turn  -- the turn signal bag (reads turn.text + turn.active_hat)
+ * @param {object} _tuple -- the /mos:diagnose tuple (unused for detection)
+ * @param {object} ctx   -- LOCAL context (optional active_hat + hat_tool_preconfigured map)
+ * @returns {Readonly<object>|null}
+ */
+function sensorExternalFact(turn, _tuple, ctx) {
+  const text = turnText(turn);
+  if (!text) return null;
+
+  // Classify WHICH external-fact category was named -> the generic public topic
+  // handle. Never the user's specific content.
+  const topicHandle = classifyExternalFact(text);
+  if (!topicHandle) return null;
+
+  // Hat-scope the reach per Canon Part 2. Red Hat (and any web_enabled=false
+  // scope) returns null: intuition only, no external tool.
+  const hat = activeHat(turn, ctx);
+  const scope = hatScopeFor(hat);
+  if (!scope.web_enabled) return null;
+
+  // Green's deep-research lane folds in here as a non-gate-blocking escalation
+  // lane: a Green-hat external-fact reach uses reach_id 'deep_research'; every
+  // other hat uses the shallow 'context_block' external-fact lookup.
+  const reach_id = scope.deep_research ? 'deep_research' : 'context_block';
+
+  // THE MCP-STACK-ASK GATE. If the hat is pre-configured to a single tool, skip
+  // the Decision Gate (no ask). Otherwise surface a tool-choice Decision Gate
+  // (Tavily / Firecrawl / Exa) -- NEVER a silent WebSearch dispatch.
+  const preTool = preconfiguredTool(ctx, hat);
+  const toolChoiceGate = preTool === '';
+
+  // Companions carry ONLY generic handles: the hat's scoped tool set, plus the
+  // tool-choice offer when the gate is active. No user content.
+  const companions = [];
+  // The hat-scoped tool set (generic tool-name handles).
+  for (const t of scope.tools) {
+    companions.push('web_tool:' + t);
+  }
+  if (toolChoiceGate) {
+    // The MCP-stack-ask Decision Gate offer. The closed tool-choice set.
+    companions.push('tool_choice:Tavily/Firecrawl/Exa');
+  } else {
+    // Pre-configured: the chosen tool rides as a generic handle (no gate).
+    companions.push('tool_preconfigured:' + preTool);
+  }
+
+  return makeReach({
+    reach_id: reach_id,
+    // 'push_forward' posture: an external-fact reference is a signal to push
+    // outward for public evidence (Part 3 SIGNAL context), not to pull back.
+    posture: 'push_forward',
+    // Dispatch names the SHIPPED /mos:research + WebSearch surface (a handle, not
+    // a call). It is explicitly NOT a silent dispatch -- the tool choice routes
+    // through the Decision Gate when the gate is active.
+    dispatch: 'mos:research (hat-scoped WebSearch)',
+    companions: companions,
+    signal: 'external_fact',
+    // LOCAL/SIGNAL scalars only: the generic public topic handle (category enum),
+    // the active hat, the search focus tag, and the gate flag. NO turn text, NO
+    // artifact body -- the WHICH never rides the reach.
+    evidence: {
+      topic_handle: topicHandle,
+      hat: hat || 'unspecified',
+      focus: scope.focus,
+      tool_choice_gate: toolChoiceGate,
+      deep_research_lane: scope.deep_research === true,
+    },
+  });
+}
+
+module.exports = {
+  sensorExternalFact: sensorExternalFact,
+};

package/lib/core/sensors/sensor-gate-approach.cjs

@@ -0,0 +1,104 @@
+'use strict';
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 143-02 Task 3 -- SENS-07 gate-approach detector.
+ *
+ * A net-new STATE-PATTERN detector over the SHIPPED Phase 120 breakthrough
+ * scanner (lib/core/breakthrough/scanner.cjs::scanForBreakthroughs +
+ * surfaceBreakthrough; scripts/check-pending-breakthrough.cjs) and the
+ * agents/investor.md objection surface. When the venture nears a gate /
+ * milestone -- a commit-near stage (Well-Defined Problem / Ready to Build),
+ * or a STATE.md venture_stage advance toward a commit decision -- this sensor
+ * SURFACES the candidate reach that dispatches the breakthrough scan (Category G)
+ * + the investor-objection surface.
+ *
+ * REUSE BEFORE BUILD (Canon Part 7): the breakthrough scan + investor agent are
+ * SHIPPED. This sensor does NOT re-run the scanner inline and does NOT
+ * re-implement breakthrough scoring. It surfaces the DISPATCH HANDLE only; the
+ * navigator approves at the Decision Gate (Canon Part 3) before the scan runs.
+ * (T-143-06: the sensor SURFACES a candidate; the navigator approves.)
+ *
+ * Reach: context_block (LOCAL) -- the breakthrough scan reads the room's OWN
+ * artifact corpus and the investor objection surface argues from LOCAL state.
+ * Neither is a Brain or web call, so the reach is context_block. Posture
+ * 'push_forward': a gate approaching is a forward-momentum moment -- surface the
+ * pre-commit breakthrough check + the investor stress-test, then push through.
+ *
+ * Phase 144 fence: this file PRODUCES a candidate reach; it never assigns
+ * routing_source and never requires/defines decide(). The routing fence over
+ * lib/core/sensors/ asserts this.
+ *
+ * Pure / sync / LOCAL-first. node built-ins + project libs only. No new deps.
+ * House rule: hyphens only, no em-dashes.
+ */
+
+const { makeReach } = require('./sensor-types.cjs');
+
+/**
+ * Commit-near stages: the gate/milestone stages where a breakthrough scan +
+ * investor stress-test is warranted before committing (funding, hiring, build,
+ * public launch). Compared case-insensitively and whitespace-normalized so
+ * "well-defined problem" and "Well-Defined Problem" both match.
+ */
+const COMMIT_NEAR_STAGES = [
+  'well-defined problem',
+  'ready to build',
+  'ready-to-build',
+  'investment',
+  'commit',
+  'pre-commit',
+];
+
+/** Normalize a stage label for matching: lowercase + collapse whitespace. */
+function normStage(s) {
+  if (typeof s !== 'string') return '';
+  return s.toLowerCase().replace(/\s+/g, ' ').trim();
+}
+
+/** True if the normalized stage is a commit-near gate stage. */
+function isCommitNear(stageLabel) {
+  const n = normStage(stageLabel);
+  if (!n) return false;
+  return COMMIT_NEAR_STAGES.indexOf(n) !== -1;
+}
+
+/**
+ * SENS-07 -- gate/milestone approach -> the breakthrough scan + investor reach.
+ *
+ * The gate signal comes from tuple.stage (the /mos:diagnose classification) OR
+ * the LOCAL ctx.venture_stage (the STATE.md venture_stage advance). Either being
+ * commit-near fires the reach.
+ *
+ * @param {object} _turn -- the turn signal bag (unused; the gate is state-driven)
+ * @param {object} tuple -- the /mos:diagnose tuple { ..., stage }
+ * @param {object} ctx   -- LOCAL context (optional ctx.venture_stage from STATE.md)
+ * @returns {Readonly<object>|null}
+ */
+function sensorGateApproach(_turn, tuple, ctx) {
+  const tupleStage = (tuple && typeof tuple === 'object') ? tuple.stage : '';
+  const ventureStage = (ctx && typeof ctx === 'object') ? ctx.venture_stage : '';
+
+  const gateApproaching = isCommitNear(tupleStage) || isCommitNear(ventureStage);
+  if (!gateApproaching) return null;
+
+  // Which stage label tripped the gate (a generic enum, not user content).
+  const stageEnum = isCommitNear(tupleStage) ? normStage(tupleStage) : normStage(ventureStage);
+
+  return makeReach({
+    reach_id: 'context_block',
+    posture: 'push_forward',
+    // Dispatch names the SHIPPED Phase 120 breakthrough scan (Category G) + the
+    // agents/investor objection surface. Handles, not calls -- the navigator
+    // approves at the Decision Gate before scanForBreakthroughs runs.
+    dispatch: 'breakthrough-scan (Category G) + agents/investor objection',
+    companions: ['scanForBreakthroughs', 'agents/investor'],
+    signal: 'gate_approach',
+    // LOCAL scalars only: the commit-near stage enum. No artifact bytes.
+    evidence: { stage: stageEnum, category: 'G', surfaces: 2 },
+  });
+}
+
+module.exports = {
+  sensorGateApproach: sensorGateApproach,
+};

package/lib/core/sensors/sensor-jtbd-reweight.cjs

@@ -0,0 +1,141 @@
+'use strict';
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 143-03 Task 2 -- SENS-05 JTBD set/changed re-weighting detector.
+ *
+ * The CONSUMER over the shipped-but-unconsumed Phase 104 JTBD signal
+ * (lib/hmi/jtbd-state.cjs, v1.12.3). The JTBD state has been CAPTURED since
+ * Phase 100/104 but never consumed for re-weighting -- this detector is that
+ * consumer. When the room's JTBD is set or changed (the current jtbd differs
+ * from the prior history transition), SENS-05 surfaces a candidate reach
+ * carrying the re-weight signal for two downstream consumers:
+ *
+ *   - SELECTOR MENU re-weight: the new JTBD slug, which lib/workflow/
+ *     f-selector-ranker.cjs already consumes as roomState.activeJtbd
+ *     (_resolveJtbdForCommand leans the activeJtbd that matches a command's
+ *     serves_jtbd). SENS-05 does NOT re-rank inline -- it surfaces the slug; the
+ *     ranker consumes it.
+ *   - BRAIN-QUERY weight: the ADDRESSES_PROBLEM_TYPE handle (references/brain/
+ *     query-patterns.md), carrying ONLY the generic problem-type ENUM.
+ *
+ * REUSE BEFORE BUILD (Canon Part 7): the JTBD state I/O is shipped. This sensor
+ * READS it (getCurrent + history) and surfaces the re-weight signal. It never
+ * re-implements the JTBD inference engine or the selector ranker.
+ *
+ * CANON PART 8: the reach carries ONLY generic handles -- the JTBD slug (a
+ * taxonomy enum) + the problem-type enum. Never the evidence text, meeting
+ * content, or proprietary numbers that the jtbd-state rows may carry. The
+ * detector reads the slug + the `to` transition field only; it never copies the
+ * evidence array. The inherited Part-8 sweep over lib/core/sensors/ spans this
+ * file: no packet/brain-client require, no projection token, no hashing path.
+ *
+ * Phase 144 fence: this file PRODUCES a candidate reach; it never assigns
+ * routing_source and never requires/defines decide(). The routing fence over
+ * lib/core/sensors/ asserts this.
+ *
+ * Pure / sync / LOCAL-first. node built-ins + project libs only. No new deps.
+ * House rule: hyphens only, no em-dashes.
+ */
+
+const { makeReach } = require('./sensor-types.cjs');
+const jtbdState = require('../../hmi/jtbd-state.cjs');
+
+/**
+ * Pull the problem_type enum off the diagnose tuple as a generic handle.
+ * Returns 'undefined' (the enum value) when absent -- never user content.
+ */
+function problemTypeEnum(tuple) {
+  if (!tuple || typeof tuple !== 'object') return 'undefined';
+  const pt = tuple.problem_type;
+  return (typeof pt === 'string' && pt) ? pt : 'undefined';
+}
+
+/**
+ * The current JTBD slug for the room, or '' when no current state exists.
+ * Reads ONLY the slug -- never the evidence array or confidence.
+ */
+function currentJtbdSlug(roomDir) {
+  const current = jtbdState.getCurrent(roomDir);
+  if (!current || typeof current !== 'object') return '';
+  return (typeof current.jtbd === 'string' && current.jtbd) ? current.jtbd : '';
+}
+
+/**
+ * The prior JTBD slug -- the `from` of the most recent transition row whose `to`
+ * equals the current slug. This is what the current slug CHANGED FROM. Returns
+ * '' when there is no prior transition (a brand-new set). Reads ONLY the
+ * `from`/`to` slug fields, never the row's evidence.
+ */
+function priorJtbdSlug(roomDir, currentSlug) {
+  const rows = jtbdState.history(roomDir, 50);
+  if (!Array.isArray(rows) || rows.length === 0) return '';
+  // Walk from the newest row backward; the first row whose `to` is the current
+  // slug names the transition INTO the current JTBD, and its `from` is the prior.
+  for (let i = rows.length - 1; i >= 0; i -= 1) {
+    const row = rows[i];
+    if (row && typeof row === 'object' && row.to === currentSlug) {
+      return (typeof row.from === 'string') ? row.from : '';
+    }
+  }
+  return '';
+}
+
+/**
+ * SENS-05 -- JTBD set/changed -> the selector-menu + Brain-query re-weight reach.
+ *
+ * Fires when the room's current JTBD differs from what it changed from (a real
+ * set/change event). Returns null when the JTBD is unchanged or absent.
+ *
+ * @param {object} _turn -- the turn signal bag (unused; the change lives in state)
+ * @param {object} tuple -- the /mos:diagnose tuple { problem_type }
+ * @param {object} ctx   -- LOCAL context { roomDir }
+ * @returns {Readonly<object>|null}
+ */
+function sensorJtbdReweight(_turn, tuple, ctx) {
+  const roomDir = (ctx && typeof ctx === 'object' && typeof ctx.roomDir === 'string') ? ctx.roomDir : '';
+  if (!roomDir) return null;
+
+  const currentSlug = currentJtbdSlug(roomDir);
+  if (!currentSlug) return null; // no JTBD set -> nothing to re-weight
+
+  const priorSlug = priorJtbdSlug(roomDir, currentSlug);
+  // A change requires a prior that differs from the current. A first-ever set
+  // (priorSlug '' / the seed 'explore' equal to current) or a re-set to the same
+  // slug is NOT a change -> no spurious re-weight.
+  if (!priorSlug || priorSlug === currentSlug) return null;
+
+  const pt = problemTypeEnum(tuple);
+
+  // Companions carry ONLY generic handles:
+  //   - serves_jtbd:<slug>            -> the selector-menu re-weight (f-selector-ranker)
+  //   - ADDRESSES_PROBLEM_TYPE:<enum> -> the Brain-query weighting (generic enum only)
+  // The JTBD slug is a taxonomy enum (jtbd-taxonomy.json), not user content.
+  const companions = [
+    'serves_jtbd:' + currentSlug,
+    'ADDRESSES_PROBLEM_TYPE:' + pt,
+  ];
+
+  return makeReach({
+    reach_id: 'context_block',
+    // 'hold' posture: a JTBD change re-weights the menus and holds for the
+    // navigator's next Decision Gate selection rather than auto-advancing.
+    posture: 'hold',
+    // Dispatch names the re-weight surface (a handle): f-selector-ranker consumes
+    // the serves_jtbd slug as roomState.activeJtbd; the sensor does not re-rank.
+    dispatch: 'jtbd-reweight (f-selector-ranker serves_jtbd)',
+    companions: companions,
+    signal: 'jtbd_changed',
+    // LOCAL scalars only: the new + prior JTBD slugs (taxonomy enums) + the
+    // problem-type enum. No evidence text, no confidence, no user content.
+    evidence: {
+      jtbd: currentSlug,
+      prior_jtbd: priorSlug,
+      problem_type: pt,
+    },
+  });
+}
+
+module.exports = {
+  sensorJtbdReweight: sensorJtbdReweight,
+};

package/lib/core/sensors/sensor-lagging-component.cjs

@@ -0,0 +1,115 @@
+'use strict';
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 143-02 Task 1 -- SENS-02 lagging-component detector.
+ *
+ * A net-new CONVERSATION-PATTERN detector over the SHIPPED Phase 89
+ * reverse-salient engine. When the navigator names a lagging component (the
+ * Appendix E "Risk surface identified" trigger, the Hughes 1983 reverse-salient
+ * framing -- "the bottleneck is X", "X is lagging", "X is holding us back"),
+ * this sensor SURFACES the find-bottlenecks / reverse-salient candidate reach.
+ *
+ * REUSE BEFORE BUILD (Canon Part 7): the underlying capability is shipped --
+ * scripts/rs-engine.py (the 4-mode reverse-salient CLI) + commands/find-bottlenecks.md.
+ * This sensor does NOT re-run rs-engine inline and does NOT re-implement
+ * reverse-salient scoring. It surfaces the DISPATCH HANDLE only; the navigator
+ * approves at the Decision Gate (Canon Part 3) before any engine runs.
+ *
+ * LOCAL surface (reach_id = 'context_block'): find-bottlenecks / reverse-salient
+ * reads the room's OWN artifact corpus + section fill levels. It is a LOCAL
+ * analysis surface, NOT a Brain or web surface -- so the reach is context_block,
+ * never brain_consult or deep_research. The detector reads ONLY the turn text
+ * (and, optionally, LOCAL section fill scalars threaded on ctx); it makes no
+ * network call (Canon Part 8) and never throws on malformed input.
+ *
+ * Posture 'pull_back': a stated lagging component is a signal to pull back to
+ * the weakest subsystem and re-set, rather than push forward past it.
+ *
+ * Phase 144 fence: this file PRODUCES a candidate reach; it never assigns
+ * routing_source and never requires/defines decide(). The routing fence over
+ * lib/core/sensors/ asserts this.
+ *
+ * Pure / sync / LOCAL-first. node built-ins + project libs only. No new deps.
+ * House rule: hyphens only, no em-dashes.
+ */
+
+const path = require('node:path');
+
+const { makeReach } = require('./sensor-types.cjs');
+
+/**
+ * Lagging-component / reverse-salient conversation patterns. Each matches the
+ * shape "<component> is the bottleneck / is lagging / is holding us back / is
+ * the reverse salient / is the weakest link / is the constraint". Case
+ * insensitive. These are STRUCTURAL phrasings of the Hughes reverse-salient
+ * framing, not user-content keywords -- the detector never inspects WHICH
+ * component, only THAT a lagging component was named.
+ */
+const LAGGING_PATTERNS = [
+  /\bbottleneck\b/i,
+  /\bis lagging\b/i,
+  /\bare lagging\b/i,
+  /\blagging behind\b/i,
+  /\bholding (?:us|me|it|the team|everything) back\b/i,
+  /\breverse salient\b/i,
+  /\bweakest (?:link|component|subsystem|section)\b/i,
+  /\bis the constraint\b/i,
+  /\bis the limiting (?:factor|step)\b/i,
+];
+
+/**
+ * Pull the turn text as a string. Tolerant of the two turn shapes the dispatch
+ * chokepoint may carry: { text } or { utterance }. Returns '' when absent or
+ * non-string so the caller soft-fails to null rather than throwing.
+ */
+function turnText(turn) {
+  if (!turn || typeof turn !== 'object') return '';
+  if (typeof turn.text === 'string') return turn.text;
+  if (typeof turn.utterance === 'string') return turn.utterance;
+  return '';
+}
+
+/**
+ * SENS-02 -- lagging-component -> the find-bottlenecks / reverse-salient reach.
+ *
+ * @param {object} turn  -- the turn signal bag (reads turn.text only)
+ * @param {object} tuple -- the /mos:diagnose tuple (unused for detection; the
+ *                          pattern is conversational, not classification-driven)
+ * @param {object} ctx   -- LOCAL context (optional section fill scalars)
+ * @returns {Readonly<object>|null}
+ */
+function sensorLaggingComponent(turn, tuple, ctx) {
+  const text = turnText(turn);
+  if (!text) return null;
+
+  let matched = false;
+  for (const rx of LAGGING_PATTERNS) {
+    if (rx.test(text)) { matched = true; break; }
+  }
+  if (!matched) return null;
+
+  // Optional LOCAL evidence scalar: a section-fill count threaded on ctx by the
+  // caller (how many room sections are below the fill threshold). LOCAL only --
+  // never a section name or artifact body, just a count.
+  let lowFillSections = 0;
+  if (ctx && typeof ctx === 'object' && typeof ctx.lowFillSections === 'number') {
+    lowFillSections = ctx.lowFillSections;
+  }
+
+  return makeReach({
+    reach_id: 'context_block',
+    posture: 'pull_back',
+    // Dispatch names the SHIPPED Phase 89 surface. A handle, not user content.
+    dispatch: 'find-bottlenecks (rs-engine reverse-salient)',
+    companions: [],
+    signal: 'lagging_component',
+    // LOCAL scalars only: the low-fill section count. No component name, no
+    // turn text, no artifact body -- the WHICH never rides the reach.
+    evidence: { low_fill_sections: lowFillSections, engine: 'rs-engine' },
+  });
+}
+
+module.exports = {
+  sensorLaggingComponent: sensorLaggingComponent,
+};

package/lib/core/sensors/sensor-memory-cortex.cjs

@@ -0,0 +1,111 @@
+'use strict';
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 150-05 (MEM-05, D-05) -- SENS-08 memory-cortex detector.
+ *
+ * A net-new STATE-PATTERN detector over the SHIPPED Phase 150-04 projected
+ * cortex. When the projected memory cortex signals it needs attention -- a STALE
+ * governing thought (the navigator's MINTO spine sentence no longer governs what
+ * the room now holds) OR a FRESH contradiction (a newly projected contradiction
+ * edge against a claim the navigator depends on) -- this sensor SURFACES the
+ * memory-cortex bridge candidate reach.
+ *
+ * REUSE BEFORE BUILD (Canon Part 7): the cortex is SHIPPED -- Phase 150-01 mints
+ * the memory_artifact / governing_thought / decision nodes, Phase 150-03 projects
+ * them, Phase 150-04 surfaces them on getRoomContext legD (cortexNodes) and
+ * derives the cortex ctx scalars. This sensor does NOT re-run the projection and
+ * does NOT read room.db. It CONSUMES the projected cortex signals threaded on the
+ * LOCAL ctx and surfaces the DISPATCH HANDLE only; the navigator approves at the
+ * Decision Gate (Canon Part 3) before the orchestrator reads the cortex.
+ *
+ * The two cortex signals it reads from ctx (both LOCAL scalars, produced by the
+ * Wave-2 cortex producers in 150-04, never user content -- a boolean freshness
+ * flag and a contradiction count):
+ *   - ctx.staleGoverningThought  : boolean -- a governing thought has gone stale
+ *   - ctx.freshContradictions    : number  -- count of freshly projected
+ *                                  contradiction edges (> 0 fires)
+ *
+ * Reach: cross_room (the cortex reach is a cross-room/memory bridge per D-05 --
+ * NEVER a 7th reach). Posture push_forward: bringing the cortex signal forward to
+ * the Decision Gate is a forward-momentum move (surface the stale thought / fresh
+ * contradiction, then push through with the navigator's call).
+ *
+ * Phase 144 fence: this file PRODUCES a candidate reach; it never assigns
+ * routing_source and never requires/defines decide(). The routing fence over
+ * lib/core/sensors/ asserts this. It MUST soft-fail to null on a malformed or
+ * empty ctx (never throw -- one bad sensor cannot poison dispatchSensors).
+ *
+ * Canon Part 8: the sensor reads ONLY enum/scalar ctx signals; it carries no
+ * cortex prose, no governing-thought text, no claim body. The Part-8 sensor sweep
+ * auto-covers every lib/core/sensors/*.cjs, including this file.
+ *
+ * Pure / sync / LOCAL-first. node built-ins + project libs only. No new deps.
+ * House rule: hyphens only, no em-dashes.
+ */
+
+const { makeReach } = require('./sensor-types.cjs');
+
+/**
+ * True if the projected cortex carries a stale-governing-thought signal on ctx.
+ * Tolerant of a missing/malformed ctx -- returns false rather than throwing.
+ */
+function hasStaleGoverningThought(ctx) {
+  if (!ctx || typeof ctx !== 'object') return false;
+  return ctx.staleGoverningThought === true;
+}
+
+/**
+ * The count of freshly projected contradiction edges on ctx (0 when absent or
+ * malformed). A count > 0 is the fresh-contradiction signal.
+ */
+function freshContradictionCount(ctx) {
+  if (!ctx || typeof ctx !== 'object') return 0;
+  const n = ctx.freshContradictions;
+  return typeof n === 'number' && isFinite(n) && n > 0 ? n : 0;
+}
+
+/**
+ * SENS-08 -- memory-cortex -> the cross-room memory-cortex bridge reach.
+ *
+ * Fires when EITHER cortex signal is present: a stale governing thought OR a
+ * fresh contradiction. Soft-fails to null when neither is present (or the ctx is
+ * malformed); never throws.
+ *
+ * @param {object} _turn -- the turn signal bag (unused; the cortex signal is
+ *                          state-driven, threaded on ctx by the 150-04 producer)
+ * @param {object} _tuple -- the /mos:diagnose tuple (unused for detection)
+ * @param {object} ctx    -- LOCAL context carrying the projected cortex scalars
+ * @returns {Readonly<object>|null}
+ */
+function sensorMemoryCortex(_turn, _tuple, ctx) {
+  const stale = hasStaleGoverningThought(ctx);
+  const fresh = freshContradictionCount(ctx);
+  if (!stale && fresh === 0) return null;
+
+  // The signal kind that tripped the sensor (a generic enum, not user content).
+  // A stale governing thought takes precedence in the label when both fire.
+  const trigger = stale ? 'stale_governing_thought' : 'fresh_contradiction';
+
+  return makeReach({
+    reach_id: 'cross_room',
+    posture: 'push_forward',
+    // Dispatch names the SHIPPED memory-cortex bridge surface (the reach the
+    // orchestrator routes per the connector registry). A handle, not user content.
+    dispatch: 'memory-cortex-bridge',
+    companions: [],
+    signal: 'memory_cortex',
+    // LOCAL scalars only: the trigger enum + the contradiction count + the
+    // stale flag. No governing-thought text, no claim body -- the WHICH never
+    // rides the reach.
+    evidence: {
+      trigger: trigger,
+      stale_governing_thought: stale,
+      fresh_contradictions: fresh,
+    },
+  });
+}
+
+module.exports = {
+  sensorMemoryCortex: sensorMemoryCortex,
+};