@mindrian_os/install 1.13.0-beta.16 → 1.13.0-beta.19

package/lib/conversation/operator.test.cjs

@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 118-05 Plan 05 -- operator helper tests for transitionViaMVAOption.
+ *
+ * This is the FIRST test file for lib/conversation/operator.cjs. Plan 118-05
+ * Task 1 adds the transitionViaMVAOption(roomDir, optionId) helper -- a thin
+ * additive wrapper around the existing transition() function. The helper is
+ * called by lib/core/mva-option-router.cjs when the user picks 1, 2, or 3
+ * from the 30-second MVA brief footer.
+ *
+ * The 9 existing transition rules are NOT modified. The OPERATORS array is
+ * NOT modified. This is a small additive surface.
+ *
+ * Option 1 -> JUST_TALK (via 'manual_reset' trigger; existing ANY rule)
+ * Option 2 -> NO transition (stub per binding decision B6 OPTION A; Phase 119
+ *             will wire the BUILD_ROOM path)
+ * Option 3 -> METHODOLOGY (via 'mos_command' trigger; existing ANY rule)
+ *
+ * Pure CJS, node built-ins only.
+ */
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const operator = require('./operator.cjs');
+
+// Hermetic temp roomDir per test (so we never pollute real rooms).
+function makeTempRoom() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'op-mva-option-'));
+  return dir;
+}
+
+function cleanupTempRoom(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch (_) {}
+}
+
+// ---------- Task 1: transitionViaMVAOption helper ----------
+
+test('Test 1: transitionViaMVAOption(roomDir, 1) -> JUST_TALK', () => {
+  const roomDir = makeTempRoom();
+  try {
+    // Move to a non-JUST_TALK state first so the transition is meaningful.
+    // From the default JUST_TALK, step to EXPLORE_CAPTURE.
+    const pre = operator.transition(roomDir, 'EXPLORE_CAPTURE', 'user_message');
+    assert.equal(pre.success, true);
+    assert.equal(operator.getCurrent(roomDir).current, 'EXPLORE_CAPTURE');
+
+    const result = operator.transitionViaMVAOption(roomDir, 1);
+    assert.equal(result.ok, true, 'option 1 should succeed');
+    assert.equal(result.new_state, 'JUST_TALK', 'option 1 must end in JUST_TALK');
+    assert.equal(result.from, 'EXPLORE_CAPTURE', 'from must be the previous state');
+    assert.equal(operator.getCurrent(roomDir).current, 'JUST_TALK');
+  } finally {
+    cleanupTempRoom(roomDir);
+  }
+});
+
+test('Test 2: transitionViaMVAOption(roomDir, 2) -> no transition (stub)', () => {
+  const roomDir = makeTempRoom();
+  try {
+    // Move to METHODOLOGY first so we can verify "no transition" preserves it.
+    const pre = operator.transition(roomDir, 'METHODOLOGY', 'mos_command');
+    assert.equal(pre.success, true);
+    assert.equal(operator.getCurrent(roomDir).current, 'METHODOLOGY');
+
+    const result = operator.transitionViaMVAOption(roomDir, 2);
+    assert.equal(result.ok, true, 'option 2 returns ok:true (stub but valid)');
+    assert.equal(result.no_transition, true, 'option 2 must flag no_transition');
+    assert.equal(result.reason, 'option_2_stub', 'reason must be option_2_stub');
+    assert.equal(result.new_state, 'METHODOLOGY', 'state unchanged after stub option');
+    assert.equal(operator.getCurrent(roomDir).current, 'METHODOLOGY');
+  } finally {
+    cleanupTempRoom(roomDir);
+  }
+});
+
+test('Test 3: transitionViaMVAOption(roomDir, 3) -> METHODOLOGY', () => {
+  const roomDir = makeTempRoom();
+  try {
+    // From JUST_TALK default, option 3 should jump straight to METHODOLOGY
+    // via the ANY -> METHODOLOGY 'mos_command' rule.
+    assert.equal(operator.getCurrent(roomDir).current, 'JUST_TALK');
+
+    const result = operator.transitionViaMVAOption(roomDir, 3);
+    assert.equal(result.ok, true, 'option 3 should succeed');
+    assert.equal(result.new_state, 'METHODOLOGY', 'option 3 must end in METHODOLOGY');
+    assert.equal(result.from, 'JUST_TALK', 'from must be the previous state');
+    assert.equal(operator.getCurrent(roomDir).current, 'METHODOLOGY');
+  } finally {
+    cleanupTempRoom(roomDir);
+  }
+});
+
+test('Test 4: transitionViaMVAOption(roomDir, 99) -> invalid_option error', () => {
+  const roomDir = makeTempRoom();
+  try {
+    const before = operator.getCurrent(roomDir).current;
+    const result = operator.transitionViaMVAOption(roomDir, 99);
+    assert.equal(result.ok, false);
+    assert.equal(result.error, 'invalid_option');
+    assert.deepEqual(result.valid_options, [1, 2, 3]);
+    // State unchanged
+    assert.equal(operator.getCurrent(roomDir).current, before);
+  } finally {
+    cleanupTempRoom(roomDir);
+  }
+});
+
+test('Test 4b: transitionViaMVAOption rejects non-integer optionId', () => {
+  const roomDir = makeTempRoom();
+  try {
+    const r1 = operator.transitionViaMVAOption(roomDir, '1');
+    assert.equal(r1.ok, false, 'string "1" is rejected (strict int check)');
+    assert.equal(r1.error, 'invalid_option');
+
+    const r2 = operator.transitionViaMVAOption(roomDir, 0);
+    assert.equal(r2.ok, false, '0 is rejected');
+
+    const r3 = operator.transitionViaMVAOption(roomDir, null);
+    assert.equal(r3.ok, false, 'null is rejected');
+  } finally {
+    cleanupTempRoom(roomDir);
+  }
+});
+
+// ---------- Task 1 Test 5: no regression on OPERATORS or rules ----------
+
+test('Test 5a: OPERATORS array is unchanged (5 entries; canonical order)', () => {
+  assert.deepEqual(operator.OPERATORS, [
+    'JUST_TALK',
+    'EXPLORE_CAPTURE',
+    'BUILD_ROOM',
+    'METHODOLOGY',
+    'DECISION_GATE',
+  ]);
+});
+
+test('Test 5b: TRANSITION_RULES has 9 entries (Phase 99 D-08 invariant preserved)', () => {
+  assert.equal(operator.TRANSITION_RULES.length, 9);
+});
+
+test('Test 5c: existing transition rules still work (JUST_TALK -> EXPLORE_CAPTURE on user_message)', () => {
+  const roomDir = makeTempRoom();
+  try {
+    const r = operator.transition(roomDir, 'EXPLORE_CAPTURE', 'user_message');
+    assert.equal(r.success, true);
+    assert.equal(r.current, 'EXPLORE_CAPTURE');
+  } finally {
+    cleanupTempRoom(roomDir);
+  }
+});
+
+test('Test 5d: transitionViaMVAOption exported as top-level function', () => {
+  assert.equal(typeof operator.transitionViaMVAOption, 'function');
+});

package/lib/core/breakthrough/canary.cjs

@@ -0,0 +1,134 @@
+'use strict';
+/*
+ * Phase 120-02 Wave 2 Task 1 -- D-19 per-detector dismissal-rate canary. Per
+ * CONTEXT.md D-19 verbatim:
+ *
+ *   Track per-detector dismissal rate over a 100-fire rolling window. If the
+ *   rate crosses 30%, auto-throttle that detector to soft-fire-only until
+ *   manually reviewed. This is the user-telling-us-with-the-dismiss-button
+ *   signal -- catches drift before it shows up in any other metric.
+ *
+ * STATIC thresholds for v1.13.0 (ML-tuned weights deferred to v1.14.0 per
+ * CONTEXT.md OUT OF SCOPE). The auto-throttle recovery surface (the user-facing
+ * "this detector needs review" affordance) is deferred to Phase 121
+ * housekeeping per CONTEXT.md Deferred Ideas. v1.13.0 only emits the
+ * `breakthrough_throttled` event for /mos:doctor to find.
+ *
+ * Canon Part 8 + Part 9: ALL reads via navigation.cjs::findRecentChanges
+ *   chokepoint (Canon Part 9 D-06); pure LOCAL; no Brain coupling.
+ *
+ * Em-dash HARD RULE (CLAUDE.md feedback_no_emdashes): use "--" not U+2014.
+ *
+ * Pure CJS, node built-ins only, zero deps.
+ *
+ * Coordination note: scoring.cjs (Plan 120-01 Task 3) also exports the D-19
+ * canary constants + isThrottledKind. canary.cjs is the PRIMARY ownership for
+ * v1.13.0+ -- scoring.cjs's copy is kept byte-stable for backwards compat with
+ * Plan 120-01 acceptance; downstream code should import from canary.cjs going
+ * forward. The two surfaces share the same threshold values verbatim.
+ */
+
+const navigation = require('../navigation.cjs');
+
+// CONTEXT.md D-19 verbatim lock. Object.freeze is not strictly required for
+// primitive numbers (they are immutable by value) but the named exports +
+// scaffold-harness shell grep + unit test (Test 15) form the three-layer
+// invariant defense.
+const D19_DISMISSAL_THRESHOLD = 0.30;
+const D19_FIRE_WINDOW = 100;
+const D19_MIN_SAMPLE = 10;
+
+// 90-day search window for canary lookups. Older events stay in log but the
+// canary considers them stale (mirrors the scoring.cjs PRIOR_WINDOW_DAYS=90).
+const CANARY_WINDOW_MS = 90 * 24 * 3600 * 1000;
+const CANARY_QUERY_LIMIT = 500;
+
+// computeDismissalRate -- D-19 canary computation for a single detector kind.
+//
+// Returns { rate, sample_size, throttled }:
+//   - rate: dismissed_in_window / sample_size (or 0 if sample_size = 0).
+//   - sample_size: number of recent surfaces for kind, capped at D19_FIRE_WINDOW.
+//   - throttled: true IFF sample_size >= D19_MIN_SAMPLE AND rate > D19_DISMISSAL_THRESHOLD.
+//
+// Implementation:
+//   1. Read recent breakthrough_surfaced events for the kind (most-recent first).
+//   2. Take the top D19_FIRE_WINDOW (the rolling window).
+//   3. Read recent breakthrough_dismissed events; match against the in-window
+//      surfaced ids (a dismiss for an out-of-window fire is noise).
+//   4. Apply the D19_MIN_SAMPLE floor before throttling kicks in (1-of-2 = 50%
+//      would otherwise trip the 30% canary on essentially noise).
+//
+// Graceful degradation: missing/invalid kind or db -> returns the zero-state
+// object. Chokepoint throw -> same. Fail-open: never lock out a detector on
+// infra hiccup.
+function computeDismissalRate(kind, db) {
+  try {
+    if (!kind || !db) return { rate: 0, sample_size: 0, throttled: false };
+    const since = Date.now() - CANARY_WINDOW_MS;
+    const surfaced = navigation.findRecentChanges(db, since, {
+      eventType: 'breakthrough_surfaced',
+      limit: CANARY_QUERY_LIMIT,
+    }) || [];
+    const dismissed = navigation.findRecentChanges(db, since, {
+      eventType: 'breakthrough_dismissed',
+      limit: CANARY_QUERY_LIMIT,
+    }) || [];
+    const kindSurfaced = surfaced
+      .filter(function (e) { return e && e.properties && e.properties.kind === kind; })
+      .slice(0, D19_FIRE_WINDOW);
+    const sample = kindSurfaced.length;
+    const fireIds = new Set(
+      kindSurfaced
+        .map(function (e) { return e.properties && e.properties.breakthrough_id; })
+        .filter(function (id) { return typeof id === 'string' && id.length > 0; })
+    );
+    const dismissedInWindow = dismissed.filter(function (e) {
+      return e && e.properties && e.properties.kind === kind &&
+             typeof e.properties.breakthrough_id === 'string' &&
+             fireIds.has(e.properties.breakthrough_id);
+    }).length;
+    const rate = sample > 0 ? dismissedInWindow / sample : 0;
+    const throttled = sample >= D19_MIN_SAMPLE && rate > D19_DISMISSAL_THRESHOLD;
+    return { rate: rate, sample_size: sample, throttled: throttled };
+  } catch (_e) {
+    return { rate: 0, sample_size: 0, throttled: false };
+  }
+}
+
+// isThrottled -- thin convenience wrapper. Use computeDismissalRate when the
+// caller also needs the rate + sample_size scalars (e.g., for breakthrough_throttled
+// event payload). Per-kind isolation is enforced by the kind filter inside
+// computeDismissalRate -- one drifting detector cannot throttle siblings.
+function isThrottled(kind, db) {
+  return computeDismissalRate(kind, db).throttled;
+}
+
+// emitThrottleEvent -- writes a breakthrough_throttled memory_event via the
+// navigation.cjs chokepoint. Payload carries the canary scalars + a wall-clock
+// timestamp + a source_path so /mos:doctor can find throttled detectors at
+// session-start.
+//
+// The auto-throttle recovery surface (the user-facing affordance for unthrottling)
+// is DEFERRED to Phase 121 housekeeping. v1.13.0 just persists the signal.
+function emitThrottleEvent(kind, db, result) {
+  const safeResult = (result && typeof result === 'object') ? result : { rate: 0, sample_size: 0 };
+  const payload = {
+    kind: kind,
+    rate: typeof safeResult.rate === 'number' ? safeResult.rate : 0,
+    sample_size: typeof safeResult.sample_size === 'number' ? safeResult.sample_size : 0,
+    threshold: D19_DISMISSAL_THRESHOLD,
+    throttled_at: Date.now(),
+    source_path: 'system:breakthrough-canary',
+    created_by: 'system',
+  };
+  return navigation.logMemoryEvent(db, 'breakthrough_throttled', payload);
+}
+
+module.exports = {
+  computeDismissalRate: computeDismissalRate,
+  isThrottled: isThrottled,
+  emitThrottleEvent: emitThrottleEvent,
+  D19_DISMISSAL_THRESHOLD: D19_DISMISSAL_THRESHOLD,
+  D19_FIRE_WINDOW: D19_FIRE_WINDOW,
+  D19_MIN_SAMPLE: D19_MIN_SAMPLE,
+};

package/lib/core/breakthrough/canary.test.cjs

@@ -0,0 +1,136 @@
+'use strict';
+
+/*
+ * Phase 120-02 Wave 2 Task 1 -- D-19 per-detector dismissal-rate canary unit tests.
+ *
+ * Tests 15-23 cover:
+ *   - D19 constants verbatim (D19_DISMISSAL_THRESHOLD=0.30 / D19_FIRE_WINDOW=100 /
+ *     D19_MIN_SAMPLE=10)
+ *   - computeDismissalRate empty / below-sample / happy-path
+ *   - isThrottled per-kind isolation
+ *   - emitThrottleEvent writes breakthrough_throttled via navigation.logMemoryEvent
+ *   - Canon Part 8 source-grep + em-dash HARD RULE (Tests 22 + 23)
+ */
+
+const test = require('node:test');
+const { strict: assert } = require('node:assert');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..', '..');
+const canary = require(path.join(REPO_ROOT, 'lib', 'core', 'breakthrough', 'canary.cjs'));
+const navigation = require(path.join(REPO_ROOT, 'lib', 'core', 'navigation.cjs'));
+const { openRoomDb } = require(path.join(REPO_ROOT, 'lib', 'core', 'room-db.cjs'));
+
+function makeTmpDb(prefix) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  const db = openRoomDb(dir);
+  return { dir, db };
+}
+
+function seedSurfacedDismissedPair(db, kind, breakthroughId, dismissed) {
+  const surfacedR = navigation.logMemoryEvent(db, 'breakthrough_surfaced', {
+    breakthrough_id: breakthroughId,
+    kind: kind,
+    source_path: 'system:test',
+    created_by: 'system',
+  });
+  assert.equal(surfacedR.ok, true);
+  if (dismissed) {
+    const dismR = navigation.logMemoryEvent(db, 'breakthrough_dismissed', {
+      breakthrough_id: breakthroughId,
+      kind: kind,
+      source_path: 'system:test',
+      created_by: 'system',
+    });
+    assert.equal(dismR.ok, true);
+  }
+}
+
+test('120-02 Task 1 Test 15: D-19 constants verbatim', () => {
+  assert.equal(canary.D19_DISMISSAL_THRESHOLD, 0.30);
+  assert.equal(canary.D19_FIRE_WINDOW, 100);
+  assert.equal(canary.D19_MIN_SAMPLE, 10);
+});
+
+test('120-02 Task 1 Test 16: computeDismissalRate on empty db -> rate=0 sample=0 throttled=false', () => {
+  const { dir, db } = makeTmpDb('p120-02-t1-t16-');
+  const r = canary.computeDismissalRate('convergence', db);
+  assert.equal(r.rate, 0);
+  assert.equal(r.sample_size, 0);
+  assert.equal(r.throttled, false);
+});
+
+test('120-02 Task 1 Test 17: computeDismissalRate below D19_MIN_SAMPLE -> throttled stays false', () => {
+  const { dir, db } = makeTmpDb('p120-02-t1-t17-');
+  // 5 surfaced + 2 dismissed; 40% rate; but sample < D19_MIN_SAMPLE=10 -> not throttled.
+  for (let i = 0; i < 3; i++) seedSurfacedDismissedPair(db, 'convergence', 'bk:' + i, false);
+  for (let i = 3; i < 5; i++) seedSurfacedDismissedPair(db, 'convergence', 'bk:' + i, true);
+  const r = canary.computeDismissalRate('convergence', db);
+  assert.equal(r.sample_size, 5);
+  // 2 out of 5 = 0.4 rate, but throttled gates on sample size.
+  assert.ok(r.rate > 0);
+  assert.equal(r.throttled, false);
+});
+
+test('120-02 Task 1 Test 18: computeDismissalRate with sample >= floor + rate above threshold -> throttled=true', () => {
+  const { dir, db } = makeTmpDb('p120-02-t1-t18-');
+  // 12 surfaced + 5 dismissed (5/12 ~= 0.42 > 0.30); sample 12 > 10 floor.
+  for (let i = 0; i < 7; i++) seedSurfacedDismissedPair(db, 'convergence', 'bk:s' + i, false);
+  for (let i = 0; i < 5; i++) seedSurfacedDismissedPair(db, 'convergence', 'bk:d' + i, true);
+  const r = canary.computeDismissalRate('convergence', db);
+  assert.equal(r.sample_size, 12);
+  assert.ok(r.rate > 0.30, 'rate should exceed 0.30 threshold');
+  assert.equal(r.throttled, true);
+});
+
+test('120-02 Task 1 Test 19: isThrottled returns true when computeDismissalRate.throttled is true', () => {
+  const { dir, db } = makeTmpDb('p120-02-t1-t19-');
+  for (let i = 0; i < 7; i++) seedSurfacedDismissedPair(db, 'convergence', 'bk:s' + i, false);
+  for (let i = 0; i < 5; i++) seedSurfacedDismissedPair(db, 'convergence', 'bk:d' + i, true);
+  assert.equal(canary.isThrottled('convergence', db), true);
+});
+
+test('120-02 Task 1 Test 20: isThrottled isolated per-kind -- throttled convergence does NOT throttle cross_domain_analogy', () => {
+  const { dir, db } = makeTmpDb('p120-02-t1-t20-');
+  // Throttle convergence.
+  for (let i = 0; i < 7; i++) seedSurfacedDismissedPair(db, 'convergence', 'bk:cs' + i, false);
+  for (let i = 0; i < 5; i++) seedSurfacedDismissedPair(db, 'convergence', 'bk:cd' + i, true);
+  // cross_domain_analogy has no events.
+  assert.equal(canary.isThrottled('convergence', db), true);
+  assert.equal(canary.isThrottled('cross_domain_analogy', db), false);
+});
+
+test('120-02 Task 1 Test 21: emitThrottleEvent writes breakthrough_throttled memory_event', () => {
+  const { dir, db } = makeTmpDb('p120-02-t1-t21-');
+  const rate = { rate: 0.35, sample_size: 100, throttled: true };
+  const r = canary.emitThrottleEvent('convergence', db, rate);
+  assert.equal(r.ok, true);
+  assert.match(r.eventId, /^memory_event:breakthrough_throttled:/);
+  // Verify the event landed.
+  const found = navigation.findRecentChanges(db, 0, { eventType: 'breakthrough_throttled', limit: 10 });
+  assert.equal(found.length, 1);
+  assert.equal(found[0].properties.kind, 'convergence');
+  assert.equal(found[0].properties.rate, 0.35);
+  assert.equal(found[0].properties.threshold, 0.30);
+  assert.equal(found[0].properties.sample_size, 100);
+  assert.ok(typeof found[0].properties.throttled_at === 'number');
+});
+
+test('120-02 Task 1 Test 22: Canon Part 8 source-grep -- zero Brain coupling in canary.cjs', () => {
+  const src = fs.readFileSync(path.join(REPO_ROOT, 'lib', 'core', 'breakthrough', 'canary.cjs'), 'utf8');
+  assert.equal(/require\s*\(\s*['"][^'"]*brain-client[^'"]*['"]\s*\)/.test(src), false,
+    'canary.cjs must not require brain-client');
+  assert.equal(/fetch\s*\(\s*['"][^'"]*brain\.mindrian/.test(src), false,
+    'canary.cjs must not fetch brain.mindrian.*');
+});
+
+test('120-02 Task 1 Test 23: em-dash HARD RULE -- zero U+2014 in canary.cjs', () => {
+  const src = fs.readFileSync(path.join(REPO_ROOT, 'lib', 'core', 'breakthrough', 'canary.cjs'), 'utf8');
+  let count = 0;
+  for (const ch of src) {
+    if (ch.charCodeAt(0) === 0x2014) count++;
+  }
+  assert.equal(count, 0, 'canary.cjs must contain zero U+2014 em-dash characters');
+});