@mindrian_os/install 1.13.0-beta.17 → 1.13.0-beta.21

package/hooks/hooks.json

@@ -18,88 +18,10 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/operator-update.cjs\"",
-            "timeout": 3000
-          }
-        ]
-      },
-      {
-        "matcher": "startup|clear|compact",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/memory-resume-nudge.cjs\"",
-            "timeout": 3000
-          }
-        ]
-      },
-      {
-        "matcher": "startup|clear|compact",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/migrate-stale-user-settings.cjs\" --auto --quiet",
-            "timeout": 2000
-          }
-        ]
-      },
-      {
-        "matcher": "startup|clear|compact",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/statusline-fallback-echo.cjs\"",
-            "timeout": 2000
-          }
-        ]
-      },
-      {
-        "matcher": "startup|clear|compact",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/check-onboard-statusline.cjs\"",
-            "timeout": 2000
-          }
-        ]
-      },
-      {
-        "matcher": "startup|clear|compact",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/preflight-tension-surface.cjs\"",
-            "timeout": 3000
-          }
-        ]
-      },
-      {
-        "matcher": "startup|clear|compact",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/preflight-doctor.cjs\"",
-            "timeout": 2000
-          }
-        ]
-      },
-      {
-        "matcher": "startup|clear|compact",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/preflight-release-drift.cjs\"",
-            "timeout": 2000
-          }
-        ]
-      },
-      {
-        "matcher": "startup|clear|compact",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/preflight-auto-explore.cjs\"",
-            "timeout": 3000
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/sessionstart-coordinator.cjs\"",
+            "timeout": 10000,
+            "async": false,
+            "statusMessage": "Loading room context..."
           }
         ]
       },
@@ -108,8 +30,10 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/restore-post-compact-context.cjs\"",
-            "timeout": 3000
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/sessionstart-npm-reconcile.cjs\"",
+            "timeout": 60000,
+            "async": true,
+            "statusMessage": "Reconciling dependencies..."
           }
         ]
       },
@@ -118,10 +42,10 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/sessionstart-npm-reconcile.cjs\"",
-            "timeout": 60000,
-            "async": true,
-            "statusMessage": "Reconciling dependencies..."
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/check-pending-breakthrough.cjs\"",
+            "timeout": 2000,
+            "async": false,
+            "statusMessage": "Scanning for breakthroughs..."
           }
         ]
       }
@@ -280,6 +204,16 @@
             "timeout": 3000
           }
         ]
+      },
+      {
+        "matcher": "SlashCommand",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/telemetry-command-invocation.cjs\"",
+            "timeout": 5000
+          }
+        ]
       }
     ],
     "UserPromptSubmit": [

package/lib/agents/auto-explore-agent.cjs

@@ -46,6 +46,26 @@ const path = require('node:path');
 const crypto = require('node:crypto');
 const store = require('../memory/explored-materials-store.cjs');
 
+// Phase 121-02 D-06: vocabulary maps for unified auto_explore_decision emit.
+// Phase 117 source_pipeline {domain, reverse-salients, cross-domain}
+//   -> unified finding_type {whitespace, reverse_salient, cross_domain}.
+// Phase 117 F.1 verbs {EXPLORE, LATER, SKIP}
+//   -> unified user_response {kept, redid, ignored}.
+// FREE_TEXT is intentionally EXCLUDED -- it is a system fallback when the
+// navigator types prose; it is not a clean engagement signal.
+// auto_explore_skipped (system-driven suppress paths) is also EXCLUDED --
+// those fire from emitSkipped, never from handleUserResponse.
+const D06_FINDING_TYPE_MAP = Object.freeze({
+  'domain':           'whitespace',
+  'reverse-salients': 'reverse_salient',
+  'cross-domain':     'cross_domain',
+});
+const D06_USER_RESPONSE_MAP = Object.freeze({
+  EXPLORE: 'kept',
+  LATER:   'redid',
+  SKIP:    'ignored',
+});
+
 // ---------- Constants ----------
 
 const MATERIAL_ID_LEN = 32;
@@ -773,6 +793,36 @@ function handleUserResponse(args) {
       });
     } catch (_e) { /* never throw on telemetry */ }
 
+    // Phase 121-02 D-06: capture user F.1 decision into the unified
+    // ~/.mindrian/telemetry/v1.13/events-YYYY-WNN.jsonl stream (Plan 121-00
+    // writer chokepoint). Emit ONLY for the 3 engagement verbs
+    // (EXPLORE -> kept, LATER -> redid, SKIP -> ignored). FREE_TEXT is a
+    // system fallback and is intentionally excluded. auto_explore_skipped
+    // (fingerprint/fire suppress paths) is NEVER routed through this
+    // function and therefore cannot emit auto_explore_decision either.
+    // Non-blocking: try/catch swallows any writer breach so the handler
+    // still returns ok:true to its caller (the F.1 surface).
+    try {
+      if (D06_USER_RESPONSE_MAP[userResponse]) {
+        let writer = null;
+        try { writer = require('../core/telemetry/writer.cjs'); } catch (_e) { writer = null; }
+        if (writer && typeof writer.emit === 'function') {
+          const findingType = D06_FINDING_TYPE_MAP[String(finding.source_pipeline || '')] || 'whitespace';
+          const score = (typeof finding.score === 'number' && Number.isFinite(finding.score))
+            ? finding.score
+            : 0;
+          const slugSrc = String(roomSlug || (roomDir ? path.basename(roomDir) : '')).slice(0, 256);
+          const slugHash = crypto.createHash('sha256').update(slugSrc).digest('hex');
+          writer.emit('auto_explore_decision', {
+            finding_type: String(findingType).slice(0, 64),
+            user_response: D06_USER_RESPONSE_MAP[userResponse],
+            domain_match_score: score,
+            room_slug_sha256: slugHash,
+          });
+        }
+      }
+    } catch (_e) { /* never throw on telemetry */ }
+
     return {
       ok: true,
       response: userResponse,
@@ -1014,6 +1064,36 @@ function _resetDriftCacheForTests() {
   _driftEmittedThisSession = false;
 }
 
+/**
+ * Phase 119-00 helper: read $ROOMS_HOME/.rooms/registry.json and return true
+ * iff there is no active room (registry missing OR registry.active is empty
+ * string).
+ *
+ * Used by scripts/auto-explore-fingerprint.cjs to decide whether to call
+ * lib/core/room-auto-create.cjs::autoCreatePlaceholderRoom as a sibling action.
+ *
+ * Per CONTEXT.md D-01: only the "first material lands AND no active room"
+ * configuration triggers auto-create. An active room means the user already
+ * chose a room; never overwrite.
+ *
+ * Pure file-read; no network, no Brain MCP. Canon Part 8 boundary preserved.
+ *
+ * @param {string} roomsHome  absolute path to $ROOMS_HOME (or $MINDRIAN_ROOMS_HOME)
+ * @returns {boolean}
+ */
+function detectNoActiveRoom(roomsHome) {
+  if (!roomsHome || typeof roomsHome !== 'string') return true;
+  const registryPath = path.join(roomsHome, '.rooms', 'registry.json');
+  try {
+    if (!fs.existsSync(registryPath)) return true;
+    const raw = fs.readFileSync(registryPath, 'utf8');
+    const reg = JSON.parse(raw);
+    return !(reg && typeof reg.active === 'string' && reg.active.length > 0);
+  } catch (_e) {
+    return true; // unreadable registry -> treat as no-active-room (fail-open to auto-create)
+  }
+}
+
 // ---------- Module exports ----------
 
 module.exports = {
@@ -1033,6 +1113,8 @@ module.exports = {
   emitSkipped,
   emitSanitizerHit,
   emitBrainCanonDrift,
+  // Phase 119-00 sibling helper (D-01 invariant check for the auto-create hook):
+  detectNoActiveRoom,
   // Constants:
   BQ_TEMPLATE_REGISTRY,
   CANONICAL_CHAIN_ORDER,

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');
+});