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

package/lib/core/sensors/sensor-methodology-decision.cjs

@@ -0,0 +1,131 @@
+'use strict';
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 143-02 Task 2 -- SENS-03 methodology-decision detector.
+ *
+ * A net-new detector that finally AUTO-INVOKES the EXISTING but never-fired
+ * brain_framework_chain CHAINS_TO pattern (references/brain/query-patterns.md
+ * Section 1: "recommend a framework for a {problem_type} venture that has already
+ * applied {current_frameworks}"). When a methodology just completed, a decision
+ * point is reached, or the Decision Gate verb-1 ("Run Methodology") context
+ * lands, this sensor SURFACES a brain_consult candidate reach whose companion is
+ * the brain_framework_chain query.
+ *
+ * CANON PART 8 -- THE BRAIN SEAM (the reason this is the Brain-touching sensor):
+ * the brain_framework_chain companion carries ONLY generic handles --
+ *   - the framework NAMES from the LOCAL methodology cache (tuple.current_frameworks),
+ *   - the problem_type ENUM (tuple.problem_type).
+ * Never artifact bodies, meeting content, proprietary numbers, or identifiers.
+ * "recommend a framework for a wicked venture that applied SWOT, Porter" is
+ * allowed; "here is the user's model, what does Brain say" is the forbidden
+ * breach line. The sensor itself makes NO Brain call -- it constructs the
+ * generic-handle companion and surfaces the reach for the Decision Gate
+ * (Canon Part 3). decide() / a Brain client CONSUMES it later, never here.
+ *
+ * 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. The inherited Part-8 5-tripwire sweep
+ * (no packet/brain-client require, no projection token, no hashing call site)
+ * also spans this file -- so the sensor constructs the companion as a plain
+ * generic-handle string, never via a hashing or egress-projection path.
+ *
+ * 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');
+
+/**
+ * The methodology-decision signal kinds. A turn is { signals: [...] } where each
+ * signal is a string kind or { kind }. Any of these means a methodology just
+ * landed / a decision point was reached / the Decision Gate verb-1 context fired.
+ */
+const DECISION_SIGNALS = [
+  'methodology_completed',
+  'methodology_ran',
+  'decision_point',
+  'decision_gate',
+  'chains_to',
+  'run_methodology',
+];
+
+/**
+ * True if `turn` carries any methodology-decision signal. Defensive against
+ * malformed input -- returns false rather than throwing.
+ */
+function hasDecisionSignal(turn) {
+  if (!turn || typeof turn !== 'object') return false;
+  const signals = Array.isArray(turn.signals) ? turn.signals : [];
+  for (const s of signals) {
+    const kind = (typeof s === 'string') ? s : (s && typeof s === 'object' ? s.kind : '');
+    if (typeof kind === 'string' && DECISION_SIGNALS.indexOf(kind) !== -1) return true;
+  }
+  return false;
+}
+
+/**
+ * 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';
+}
+
+/**
+ * Pull the framework-NAME handles from the LOCAL methodology cache
+ * (tuple.current_frameworks). These are generic framework names (e.g. "SWOT",
+ * "Porter Five Forces") -- generic handles, never artifact bodies. Non-string
+ * entries are dropped defensively so no object can smuggle user content.
+ */
+function frameworkHandles(tuple) {
+  if (!tuple || typeof tuple !== 'object') return [];
+  const fw = Array.isArray(tuple.current_frameworks) ? tuple.current_frameworks : [];
+  return fw.filter(function (f) { return typeof f === 'string' && f.length > 0; });
+}
+
+/**
+ * SENS-03 -- methodology-decision -> the brain_framework_chain CHAINS_TO reach.
+ *
+ * @param {object} turn  -- the turn signal bag (reads turn.signals only)
+ * @param {object} tuple -- the /mos:diagnose tuple { problem_type, current_frameworks }
+ * @param {object} _ctx  -- LOCAL context (unused; the handles come off the tuple)
+ * @returns {Readonly<object>|null}
+ */
+function sensorMethodologyDecision(turn, tuple, _ctx) {
+  if (!hasDecisionSignal(turn)) return null;
+
+  const pt = problemTypeEnum(tuple);
+  const handles = frameworkHandles(tuple);
+
+  // The brain_framework_chain companion. Format encodes ONLY generic handles:
+  //   'brain_framework_chain:<problem_type_enum>:<framework_name>'
+  // one companion per already-applied framework (the CHAINS_TO traversal input),
+  // plus a bare problem-type companion so the query has the enum even when no
+  // framework has been applied yet. NO user content -- only enum + framework name.
+  const companions = ['brain_framework_chain:' + pt];
+  for (const fw of handles) {
+    companions.push('brain_framework_chain:' + pt + ':' + fw);
+  }
+
+  return makeReach({
+    reach_id: 'brain_consult',
+    // 'hold' posture: surface the next-framework recommendation and hold for the
+    // navigator's Decision Gate selection rather than auto-advancing.
+    posture: 'hold',
+    // Dispatch names the generic CHAINS_TO query pattern (a handle, not a call).
+    dispatch: 'brain_framework_chain (CHAINS_TO next-framework)',
+    companions: companions,
+    signal: 'methodology_decision',
+    // LOCAL scalars only: the count of already-applied frameworks + the enum.
+    // The framework NAMES ride the companions (generic handles); no count of
+    // user bytes, no artifact reference.
+    evidence: { problem_type: pt, current_framework_count: handles.length },
+  });
+}
+
+module.exports = {
+  sensorMethodologyDecision: sensorMethodologyDecision,
+};

package/lib/core/sensors/sensor-opportunity-harvest.cjs

@@ -0,0 +1,195 @@
+'use strict';
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 219-03 -- SENS-14 opportunity-harvest detector: the REQ-2 sensor half.
+ *
+ * This detector reads the LOCAL side-channel
+ * <roomDir>/.mindrian/last-opportunity-harvest.json that the Phase 219-03
+ * producer (lib/core/eureka/opportunity-harvest.cjs) wrote after a READ-ONLY
+ * graph-event scan (bridge / whitespace / contradiction / eureka_proposal /
+ * meeting_filing scored per the Q1..Q8 rubric), and SURFACES the
+ * qualification-card offer the top candidate represents. It PRODUCES a
+ * candidate reach; it never routes and never executes (Phase 144 fence).
+ *
+ * NAMING DE-COLLISION (checker MAJOR, logged): Phase 188's
+ * lib/hmi/harvest-scope-state.cjs owns the bare 'harvest' name and writes
+ * <roomDir>/.mindrian/harvest-scope-state.json. This sensor's surfaces are
+ * namespaced: sensor-opportunity-harvest.cjs / last-opportunity-harvest.json /
+ * sensorOpportunityHarvest.
+ *
+ * SENSOR ID: SENS-14. SENS-13 = eureka (the last registered id, verified free
+ * against the live lib/core/insight-sensors.cjs this session, 2026-07-13, per
+ * the Brain-mandated build-time re-check). SENS-14 is free.
+ *
+ * FROZEN REACH (CIRS R3, D-02): this sensor rides the EXISTING context_block
+ * reach (the SENS-11 expert-skill precedent) with signal 'harvest'. It mints
+ * NO 7th reach id; deep_research stays reserved for the [Explore] verb
+ * (planner decision resolving RESEARCH open question 1 / A2). Fail closed at
+ * load if the reach ever drifts off the frozen REACH_IDS bank.
+ *
+ * POSTURE 'hold': a STANDING SUGGESTION at the Decision Gate, never an
+ * auto-open. The dispatch slug 'qualify-opportunity' is the born-wired
+ * command surface Plan 04 mints (the 213 Plan 03 born-wired-at-feature-time
+ * precedent); opportunities are DETECTED and OFFERED, never auto-filed.
+ *
+ * FIRING PRECONDITION (the Q2 Connection hard gate RESTATED at the sensor):
+ * fire ONLY when the fresh side-channel carries at least one candidate whose
+ * connection_count >= 1. One dot is noise; the producer already gates, and
+ * the sensor re-asserts so a hand-edited side-channel cannot smuggle a
+ * zero-connection candidate into a reach (T-219-11).
+ *
+ * CANON PART 8 (evidence is enum/handle-only): the evidence bag carries a
+ * count, an opaque candidate-id handle, and closed enums (lens, band) plus
+ * one quantized scalar (score). Zero user prose crosses. The Part-8
+ * five-tripwire sweep spans lib/core/sensors/* automatically.
+ *
+ * FRESHNESS (Spoofing mitigation T-219-11): a stale side-channel never
+ * re-fires the sensor. The 30-minute window + the WR-01 future-mtime guard is
+ * REPLICATED locally here -- we do NOT import insight-sensors.cjs (that would
+ * be a circular require from a sensors/ file, Pitfall 4); only
+ * ./sensor-types.cjs is required.
+ *
+ * Pure / sync / LOCAL-first, soft-fail-to-null on every malformed input;
+ * never throws. House rule: hyphens only, no em-dashes.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { makeReach, REACH_IDS } = require('./sensor-types.cjs');
+
+// SENS-14: the next free sensor id (13 = eureka is the last registered).
+const SENSOR_ID = 'SENS-14';
+
+// FROZEN: rides the existing context_block reach (D-02; the SENS-11
+// precedent). Fail closed at load if it ever drifts off the frozen bank.
+const REACH_ID = 'context_block';
+if (REACH_IDS.indexOf(REACH_ID) === -1) {
+  throw new Error('sensor-opportunity-harvest: REACH_ID "' + REACH_ID + '" is not in the frozen REACH_IDS bank');
+}
+
+// The closed schema version the producer stamps; a mismatch never fires.
+const SCHEMA_VERSION = 1;
+
+// The side-channel freshness window (REPLICATED from insight-sensors.cjs
+// SIGNAL_FRESHNESS_MS, NOT imported -- Pitfall 4 circular require). 30 minutes.
+const HARVEST_SIGNAL_FRESHNESS_MS = 30 * 60 * 1000;
+
+// ---------- LOCAL helpers (replicated, sync, soft-fail) ----------
+
+/**
+ * Read + parse a JSON file, returning null on any failure. LOCAL only.
+ */
+function readJsonSafe(filePath) {
+  try {
+    if (typeof filePath !== 'string' || !filePath) return null;
+    if (!fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (_e) {
+    return null;
+  }
+}
+
+/**
+ * True when the file exists and its mtime is within
+ * HARVEST_SIGNAL_FRESHNESS_MS. WR-01 guard: a FUTURE-dated mtime (clock skew,
+ * archive restore) must NOT read as fresh forever -- age must be NON-NEGATIVE
+ * and within the window. Soft-fail to false; never throws.
+ */
+function isFreshFile(filePath) {
+  try {
+    const st = fs.statSync(filePath);
+    const age = Date.now() - st.mtimeMs;
+    return age >= 0 && age <= HARVEST_SIGNAL_FRESHNESS_MS;
+  } catch (_e) {
+    return false;
+  }
+}
+
+// ---------- SENS-14: the opportunity-harvest sensor ----------
+
+/**
+ * SENS-14 -- fresh scored opportunity candidates -> the context_block reach
+ * carrying the qualification-card offer.
+ *
+ * Fires (returns a Readonly reach) ONLY when ALL preconditions hold:
+ *   - ctx.roomDir is a non-empty string, AND
+ *   - <roomDir>/.mindrian/last-opportunity-harvest.json exists and is FRESH
+ *     (stat-before-parse; mtime within the 30-minute window, non-negative
+ *     age), AND
+ *   - it parses and payload.schema_version === 1, AND
+ *   - payload.candidates contains at least one candidate whose
+ *     connection_count >= 1 (the Q2 Connection hard gate restated here).
+ *
+ * On any malformed input (bad JSON, missing roomDir, wrong schema_version,
+ * stale/future mtime, zero gated candidates) it soft-fails to null and NEVER
+ * throws.
+ *
+ * @param {object} turn   -- the normalized turn (unused for detection here)
+ * @param {object} tuple  -- the /mos:diagnose tuple (unused for detection here)
+ * @param {object} ctx    -- LOCAL context ({ roomDir })
+ * @returns {Readonly<object>|null}
+ */
+function sensorOpportunityHarvest(turn, tuple, ctx) {
+  try {
+    const roomDir = (ctx && typeof ctx === 'object' && typeof ctx.roomDir === 'string') ? ctx.roomDir : '';
+    if (!roomDir) return null;
+
+    const sideChannel = path.join(roomDir, '.mindrian', 'last-opportunity-harvest.json');
+
+    // Freshness gate BEFORE the parse (stat-before-parse): a stale or
+    // future-dated side-channel never re-fires the sensor (T-219-11).
+    if (!isFreshFile(sideChannel)) return null;
+
+    const payload = readJsonSafe(sideChannel);
+    if (!payload || typeof payload !== 'object') return null;
+    if (payload.schema_version !== SCHEMA_VERSION) return null;
+
+    const all = Array.isArray(payload.candidates) ? payload.candidates : [];
+    // The Q2 Connection hard gate, re-asserted: only connected candidates
+    // count toward the fire decision ("one dot is noise").
+    const gated = all.filter(function (c) {
+      return c && typeof c === 'object'
+        && typeof c.connection_count === 'number' && c.connection_count >= 1;
+    });
+    if (gated.length === 0) return null;
+
+    // The producer sorted by score desc; re-derive the top defensively so a
+    // hand-reordered file cannot promote a weaker candidate.
+    let top = gated[0];
+    for (const c of gated) {
+      if (typeof c.score === 'number' && typeof top.score === 'number' && c.score > top.score) top = c;
+    }
+
+    // Evidence: a count, an opaque candidate-id handle, closed enums, and a
+    // quantized scalar ONLY -- never titles or artifact text (Canon Part 8).
+    return makeReach({
+      reach_id: REACH_ID,
+      posture: 'hold',
+      dispatch: 'qualify-opportunity',
+      companions: [],
+      signal: 'harvest',
+      evidence: {
+        candidate_count: gated.length,
+        top_candidate_id: (typeof top.candidate_id === 'string') ? top.candidate_id : '',
+        top_lens: (typeof top.lens === 'string') ? top.lens : 'unknown',
+        top_band: (typeof top.band === 'string') ? top.band : 'unknown',
+        top_score: (typeof top.score === 'number') ? top.score : 0,
+      },
+    });
+  } catch (_e) {
+    return null; // soft-fail: a malformed input never throws out of the sensor
+  }
+}
+
+module.exports = {
+  sensorOpportunityHarvest: sensorOpportunityHarvest,
+  SENSOR_ID: SENSOR_ID,
+  REACH_ID: REACH_ID,
+  SCHEMA_VERSION: SCHEMA_VERSION,
+  HARVEST_SIGNAL_FRESHNESS_MS: HARVEST_SIGNAL_FRESHNESS_MS,
+  // Replicated LOCAL helpers (exposed for the Plan 03 suite).
+  readJsonSafe: readJsonSafe,
+  isFreshFile: isFreshFile,
+};

package/lib/core/sensors/sensor-perspective-lock.cjs

@@ -0,0 +1,174 @@
+'use strict';
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 245-06 (REQ-3, D-12 through D-17) -- SENS-17 perspective-lock detector.
+ *
+ * WHY THIS FILE EXISTS
+ *
+ * `hats` is one of the SIX frozen Phase-148 reach categories (sensor-types.cjs
+ * REACH_IDS) with a shipped render path (lib/hmi/dial-reach-orchestrator.cjs
+ * REACH_DEFS, lib/hmi/dial-label-composer.cjs) and a canonical-verb mapping to
+ * the Synthesize skill family. Until this file, ZERO sensor in the 18-sensor
+ * bank ever assigned it: `hats` was reachable ONLY by a manual navigator pick.
+ * A frozen reach that no sensor can produce is a dead branch of the dial.
+ * SENS-17 is the first sensor that can independently assign it.
+ *
+ * THE TRIGGER IS DOCTRINE, NOT INVENTION (D-13)
+ *
+ * skills/larry-personality/SKILL.md:383 already names the Six Thinking Hats
+ * trigger condition verbatim:
+ *
+ *   "| Team stuck in one perspective (CONTRADICTS edges, circular pattern,
+ *     decision point, jargon spike) | Six Thinking Hats -> add the missing
+ *     perspective (illustration: /mos:think-hats serial, or
+ *     /mos:persona --parallel) |"
+ *
+ * The first named condition, CONTRADICTS edges, is already computed and
+ * threaded onto sensorCtx as `ctx.freshContradictions` by the MED-01 cortex
+ * producer in lib/core/navigation-engine.cjs (the projected-cortex read at the
+ * ctx-assembly seam, where a caller-threaded ctx.freshContradictions override
+ * wins as the test seam). So this sensor adds NO new plumbing: it consumes a
+ * LOCAL scalar that the engine already derives.
+ *
+ * THE >= 2 THRESHOLD IS LOAD-BEARING (D-14) -- see PERSPECTIVE_LOCK_THRESHOLD.
+ *
+ * WHY A NEW FILE RATHER THAN A FIFTH CAUSE ON SENS-10 (D-16)
+ *
+ * Extending lib/core/sensors/sensor-circularity.cjs was considered and
+ * REJECTED for three independent reasons: SENS-10 is keyword-only FALLBACK-tier
+ * detection (Canon Part 11 R3) while this trigger is a projected-cortex
+ * problem-state read, which is context-tier; adding a cause would break that
+ * sensor's audited zero-collision property; and its own header and tests encode
+ * "four causes, four exits" as a closed contract. A cortex-state sensor does not
+ * belong inside a lexical one.
+ *
+ * ALSO REJECTED (D-31): a model-judgment trigger in the shape of the
+ * obra/superpowers "even a 1 percent chance" rule. It does not transfer, for
+ * three each-sufficient reasons: dispatchSensors runs in a fresh pre-turn hook
+ * process with no model in the loop; a model verdict produces no NUMBER, and
+ * buildReachList needs a 0..1 score per reach; and Requirement 4's acceptance
+ * criterion demands reproducibility across runs, which model judgment cannot
+ * give. A 1-percent firing threshold is also close to the opposite of Canon
+ * Part 12's invisibility mandate. SENS-17 stays a deterministic threshold
+ * sensor.
+ *
+ * FLIP-CONDITION CHECK (D-17, corroborated by 245-RESEARCH.md F-9): NOT
+ * tripped. SENS-17 takes registered sensor implementations from 18 to 19,
+ * against the dial-rethink research's named ~25-30 rewrite threshold. Six to
+ * eleven files of headroom remain, so the bank stays inside its current shape.
+ *
+ * Phase 144 fence: this file PRODUCES a candidate reach; it never assigns
+ * routing_source and never requires/defines the routing entry point. 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, whose per-sensor try/catch treats a throw as "did not
+ * fire"; the sensor is still defensive on its own account).
+ *
+ * Canon Part 8: the sensor reads ONLY a LOCAL scalar off ctx and emits ONLY a
+ * trigger enum plus a count. It carries no claim body, no decision text, no
+ * contradiction prose, no node id. The Part-8 sensor sweep auto-covers every
+ * lib/core/sensors/*.cjs, including this file.
+ *
+ * Pure / sync / LOCAL-first. One project require (the shared struct contract).
+ * No db, no fs, no network, no new deps.
+ * House rule: hyphens only, no em-dashes.
+ */
+
+const { makeReach } = require('./sensor-types.cjs');
+
+/**
+ * The count of freshly projected contradiction edges at or above which the
+ * room is treated as PERSPECTIVE-LOCKED rather than merely bridging.
+ *
+ * WHY 2 AND NOT 1 (D-14). This number ships WITH the sensor, not after it, and
+ * it is load-bearing on three counts:
+ *
+ *   1. De-duplication. SENS-08 (lib/core/sensors/sensor-memory-cortex.cjs:84)
+ *      already fires the `cross_room` reach on `freshContradictions > 0`,
+ *      reading the SAME ctx field. A hats sensor at `> 0` would double-fire on
+ *      every single contradiction the cortex ever projects.
+ *
+ *   2. Semantics. ONE fresh contradiction is a memory-cortex bridge: the room
+ *      just learned something that tensions with a claim, and the right move is
+ *      to surface the bridge. TWO OR MORE unresolved contradictions is a
+ *      different state -- the room is stuck arguing from one stance and the
+ *      tensions are accumulating faster than they resolve. That is a
+ *      perspective lock, and a hats rotation is the move for it.
+ *
+ *   3. Canon Part 12 invisibility. Larry is measured by how invisible he is
+ *      when the insight lands. A sensor that interrupts the navigator on every
+ *      contradiction is the opposite of invisible. The higher threshold is a
+ *      restraint on interruption, not merely a de-dup fix.
+ *
+ * At exactly 2 BOTH sensors fire, on purpose: SENS-08's `> 0` still holds and
+ * SENS-17's `>= 2` now also holds, and they emit DIFFERENT reach ids. That
+ * co-fire is the intended designed behavior and is pinned in both directions by
+ * tests/test-245-sens17-no-double-fire.cjs.
+ */
+const PERSPECTIVE_LOCK_THRESHOLD = 2;
+
+/**
+ * The count of freshly projected contradiction edges on ctx (0 when absent or
+ * malformed). Mirrors the freshContradictionCount helper shape in
+ * sensor-memory-cortex.cjs rather than inlining the guard, so the two sensors
+ * that read this one field read it the same way.
+ *
+ * Tolerant of a missing / non-object / non-numeric / non-finite value --
+ * returns 0 rather than throwing.
+ */
+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-17 -- perspective-lock -> the hats reach (the six-hats perspective
+ * rotation).
+ *
+ * Fires when the projected cortex carries at least PERSPECTIVE_LOCK_THRESHOLD
+ * fresh contradictions. Soft-fails to null below the threshold, on an absent or
+ * malformed ctx, and on a non-numeric value; never throws.
+ *
+ * Posture `hold` (D-12): a perspective rotation HALTS the current line of
+ * reasoning so a different stance can be taken, rather than pushing the current
+ * line forward. `hold` is exactly that movement in the Hierarchical Navigator
+ * vocabulary POSTURE_IDS mirrors.
+ *
+ * @param {object} _turn  -- the turn signal bag (unused; the perspective-lock
+ *                           signal is state-driven, threaded on ctx by the
+ *                           MED-01 cortex 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 sensorPerspectiveLock(_turn, _tuple, ctx) {
+  const fresh = freshContradictionCount(ctx);
+  if (fresh < PERSPECTIVE_LOCK_THRESHOLD) return null;
+
+  return makeReach({
+    reach_id: 'hats',
+    posture: 'hold',
+    // Dispatch names the SHIPPED hats surface (the reach the orchestrator
+    // routes per the connector registry). A descriptive handle, not user
+    // content -- the same convention as 'memory-cortex-bridge' (SENS-08) and
+    // 'room-chooser card (renderRoomChooserCard -> pickShape F.1)' (SENS-12).
+    dispatch: 'think-hats (six-hats perspective rotation)',
+    companions: [],
+    signal: 'perspective_lock',
+    // LOCAL scalars ONLY: the trigger enum + the contradiction count. No claim
+    // body, no decision text, no contradiction prose, no node id -- the WHICH
+    // never rides the reach. `sensor_id` is stamped CENTRALLY by
+    // dispatchSensors (Phase 245-01), so it is deliberately not set here.
+    evidence: {
+      trigger: 'perspective_lock',
+      fresh_contradictions: fresh,
+    },
+  });
+}
+
+module.exports = {
+  sensorPerspectiveLock: sensorPerspectiveLock,
+  PERSPECTIVE_LOCK_THRESHOLD: PERSPECTIVE_LOCK_THRESHOLD,
+};