@mindrian_os/install 1.13.0-beta.12 → 1.13.0-beta.14

package/lib/memory/run-feynman-tests.cjs

@@ -1174,6 +1174,41 @@ const TEST_FILES = [
   // (migration used to crash openRoomDb for any room.db carrying the Phase-89
   // rs_discoveries view: "error in view rs_discoveries: no such table: main.nodes").
   path.join(REPO_ROOT, 'tests', 'test-navigation-migration-views.cjs'),
+  // Phase 109 SQL Context-Memory Navigation Spine: the 15 test suites that the
+  // Plan 109-00 Task 4 registration originally specified but that a later refactor
+  // dropped from this array before main HEAD (the originals ran via direct
+  // `node tests/test-*.cjs` and `bash tests/run-all.sh` throughout the phase).
+  // Re-registered by Plan 109-12 (bookkeeping reconciliation). Mapping:
+  //   test-navigation-acceptance.cjs                          -> 109-10 (NAV-109-09 load-bearing acceptance gate; zero non-SQLite reads)
+  //   test-navigation-focus.cjs                               -> 109-02 (NAV-109-01 session_focus + auto-focus cascade)
+  //   test-navigation-neighborhood.cjs                        -> 109-04 (NAV-109-02 recursive-CTE ranking correctness)
+  //   test-navigation-perf-10k.cjs                            -> 109-04 (NAV-109-02 perf: cold p95 <200ms / warm <50ms)
+  //   test-navigation-memory-events.cjs                       -> 109-03 (NAV-109-03 closed-15 event enum + findRecentChanges)
+  //   test-navigation-insights.cjs                            -> 109-05 (NAV-109-04 7 insight primitives + templated explanations)
+  //   test-navigation-chokepoint-hook.cjs                     -> 109-06 (NAV-109-05 no direct room-db.cjs imports outside allow-list)
+  //   test-navigation-packet-builder.cjs                      -> 109-07 (NAV-109-06 buildBrainPacket shape per D-06)
+  //   test-navigation-packet-part8-leak.cjs                   -> 109-07 (NAV-109-06 Part 8 JSON.stringify leak tripwires)
+  //   test-brain-ingestion-part-9-invariant.cjs               -> 109-08 (NAV-109-07 storeBrainSuggestions proposed-only + invariant SQL = 0)
+  //   test-room-home-vs-brain-derivation-regression.cjs       -> 109-09 (NAV-109-08 getRoomHomeView + Phase 90 deriveSection regression fence)
+  //   test-canon-part-9-ratification.cjs                      -> 109-11 (NAV-109-09 Canon Part 9 structural assertions)
+  //   test-navigation-migration-idempotent.cjs                -> 109-01 (migration twice = no-op; 12-column nodes schema)
+  //   test-navigation-migration-backfill.cjs                  -> 109-01 (properties JSON backfill + status_aliases mapping)
+  //   test-navigation-migration-coexistence.cjs               -> 109-01 (navigation API + assumptions.validity coexist mid-migration)
+  path.join(REPO_ROOT, 'tests', 'test-navigation-acceptance.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-navigation-focus.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-navigation-neighborhood.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-navigation-perf-10k.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-navigation-memory-events.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-navigation-insights.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-navigation-chokepoint-hook.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-navigation-packet-builder.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-navigation-packet-part8-leak.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-brain-ingestion-part-9-invariant.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-room-home-vs-brain-derivation-regression.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-canon-part-9-ratification.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-navigation-migration-idempotent.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-navigation-migration-backfill.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-navigation-migration-coexistence.cjs'),
   // Phase 89-07 Wave 0 (graph-native HARD RULE; ReverseSalientAgent dual-surface).
   path.join(REPO_ROOT, 'tests', 'test-reverse-salient-agent.cjs'),
   path.join(REPO_ROOT, 'tests', 'test-reverse-salient-cascade-emit.cjs'),
@@ -1225,6 +1260,92 @@ const TEST_FILES = [
   // -> validateChainAutonomy stop-point) + the Canon Part 8 zero-Brain-mutation
   // grep sweep.
   path.join(REPO_ROOT, 'lib', 'memory', 'workflow-layer-e2e.test.cjs'),
+  // Phase 110-00: Brain Context Packet Contract Wave 0 substrate (4 stubs filled by Plans 110-01 / 110-04 / 110-05).
+  //   test-brain-packet-schema-check.cjs              -> 110-01 (PACKET-110-01 + -02: the --check schema tripwire)
+  //   test-brain-packet-validation-per-job.cjs        -> 110-05 (PACKET-110-03 + -04 + -07 + -08: 12-job in/out + privacy + dual-path)
+  //   test-brain-packet-part8-invariant-per-job.cjs   -> 110-05 (PACKET-110-06 round-trip + D-11(d) adversarial sweep)
+  //   test-brain-packet-precommit-hook.cjs            -> 110-04 (PACKET-110-05 D-08 layer-2 hook)
+  path.join(REPO_ROOT, 'tests', 'test-brain-packet-schema-check.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-brain-packet-validation-per-job.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-brain-packet-part8-invariant-per-job.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-brain-packet-precommit-hook.cjs'),
+  // Phase 123 (install-lifecycle-harness) block.
+  //   Plan 123-01: release.sh semver bump algebra + two-commit form + dirty-repo guard + Step 9.5 rename.
+  //     Tests A-E (semver assertions) GREEN immediately; Tests F/G (release.sh
+  //     structural) RED until Plan 123-01 Task 2 rewrites release.sh -- intended RED->GREEN.
+  //   Plan 123-02: install-state record + data/deployment-surfaces.json manifest +
+  //     active-plugin-root.cjs topology classification. Tests 1+4+6 (topology /
+  //     Canon Part 8 / early-write ordering) GREEN after Task 1; Tests 2+3
+  //     (record write hermetic / idempotent re-run) GREEN after Task 2;
+  //     Test 5 (manifest schema) GREEN after Task 3.
+  //   Plan 123-03: doctor classes I (install-state + topology + 6-way version-
+  //     of-record consistency) + J (deployment-surface manifest reconciliation)
+  //     + aggressive --fix (legacy migration backup-verify-remove; never
+  //     touches a dev-clone) + Bug-7 fix (marketplace-cache topology is
+  //     HEALTHY, not drift). Tests RED until Task 2 lands class I + class J
+  //     in scripts/doctor.cjs -- intended RED->GREEN.
+  //   Plan 123-04: doctor --acceptance (release-gate-as-a-command) -- 5-point
+  //     pre-tag checklist + 7-point full checklist + --light-npx opt-in; wired
+  //     into release.sh as hard aborts (Step 6.6 pre-tag, Step 9.6 post-publish);
+  //     scripts/release-beta-smoke.sh retired. Tests RED until Task 2 lands
+  //     --acceptance in scripts/doctor.cjs AND Task 3 wires release.sh + deletes
+  //     release-beta-smoke.sh -- intended RED->GREEN.
+  //   Plan 123-05: cache-prune helper (HARNESS-123-13) + doc/test sweep
+  //     (HARNESS-123-14). 6 hermetic scenarios for pruneMarketplaceCache
+  //     (active + N most-recent kept; corrupt installed_plugins.json -> skip;
+  //     dryRun -> no mutation; belt+suspenders active-dir protection; Canon
+  //     Part 8 grep clean). Tests GREEN after Task 1 lands
+  //     lib/core/cache-prune.cjs.
+  //   Plan 123-07: resolve-brain-key.cjs (HARNESS-123-15) + brain-client.cjs
+  //     getApiKey() delegation (HARNESS-123-16). 9 hermetic scenarios cover
+  //     order (env -> ~/.mindrian.env -> CWD .env -> not-found), SEC-02
+  //     POSIX 0o077 reject, Canon Part 8 zero-network grep, the brain-client
+  //     delegation spy, brain-client preconditions, and the FLAG-3
+  //     env-aware-home structural assertion. rbk.1-6 + rbk.9 GREEN after
+  //     Task 1; rbk.7 + rbk.8 GREEN after Task 2 (brain-client rewire).
+  path.join(REPO_ROOT, 'tests', 'test-release-bump-algebra.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-install-state-record.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-doctor-class-i.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-doctor-class-j.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-doctor-acceptance.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-cache-prune.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-resolve-brain-key.cjs'),
+  // Phase 124-00: FEYNMAN.md Temporal Awareness Wave 0 substrate (4 stubs filled by Plans 124-01 / 124-02 / 124-04).
+  //   test-feynman-timeline-renderer.cjs              -> 124-01 (TEMPORAL-124-02 + -04 + -05 + -07: renderer unit + D-05 template + thresholds + section scoping)
+  //   test-feynman-timeline-empty-state.cjs           -> 124-01 (TEMPORAL-124-04: empty-state placeholder)
+  //   test-feynman-timeline-runner.cjs                -> 124-02 (TEMPORAL-124-01 + -03 + -08 + -09: sentinel-bounded merge + body byte-identical + watermark + idempotent + memory_event + EVENT_TYPES +2)
+  //   test-feynman-timeline-canon-part-9-invariant.cjs -> 124-04 (TEMPORAL-124-10: forbidden-substring sweep + fs-instrument allow-list)
+  path.join(REPO_ROOT, 'tests', 'test-feynman-timeline-renderer.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-feynman-timeline-empty-state.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-feynman-timeline-runner.cjs'),
+  path.join(REPO_ROOT, 'tests', 'test-feynman-timeline-canon-part-9-invariant.cjs'),
+  // Phase 125 F-Selector Ranker (8 plans: Plan 00 writeEdge through Plan 07 miss).
+  //   navigation-write-edge.test.cjs          -> Plan 125-00 (writeEdge primitive)
+  //   navigation-projections.test.cjs         -> Plan 125-01 (projection helpers)
+  //   brain-cypher-chain-slice.test.cjs       -> Plan 125-02 (Brain Cypher slice)
+  //   packet-chain-hint.test.cjs              -> Plan 125-03 (packet builder ext)
+  //   packet-schema-validation.test.cjs       -> Plan 125-04 (schema superset)
+  //   f-selector-ranker.test.cjs              -> Plan 125-05 + 125-07 D8 label tests (34 tests)
+  //   selector-decisions.test.cjs             -> Plan 125-06 (D7 decisions + decay; 17 tests)
+  //   selector-miss.test.cjs                  -> Plan 125-07 (D8 miss capture; 10 tests)
+  // Aggregator: tests/run-all-125.sh.
+  path.join(REPO_ROOT, 'lib', 'memory', 'navigation-write-edge.test.cjs'),
+  path.join(REPO_ROOT, 'lib', 'memory', 'navigation-projections.test.cjs'),
+  path.join(REPO_ROOT, 'lib', 'memory', 'brain-cypher-chain-slice.test.cjs'),
+  path.join(REPO_ROOT, 'lib', 'memory', 'packet-chain-hint.test.cjs'),
+  path.join(REPO_ROOT, 'lib', 'memory', 'packet-schema-validation.test.cjs'),
+  path.join(REPO_ROOT, 'lib', 'memory', 'f-selector-ranker.test.cjs'),
+  path.join(REPO_ROOT, 'lib', 'memory', 'selector-decisions.test.cjs'),
+  path.join(REPO_ROOT, 'lib', 'memory', 'selector-miss.test.cjs'),
+  // Phase 104.1 (per-command-teaching-content) block. RED-by-design until
+  // Plan 02 lands the 86 teaching strings; the jtbd-derivation suite is
+  // GREEN immediately after Plan 01 Task 1.
+  //   per-command-teaching.test.cjs        -> 104.1-01 Task 2 (RED today; GREEN after Plan 02)
+  //   per-command-jtbd-derivation.test.cjs -> 104.1-01 Task 3 (GREEN immediately)
+  // Aggregator: tests/run-all-104.1.sh. Documented at
+  //   .planning/phases/104.1-per-command-teaching-content/104.1-01-PLAN.md.
+  path.join(REPO_ROOT, 'lib', 'memory', 'per-command-teaching.test.cjs'),
+  path.join(REPO_ROOT, 'lib', 'memory', 'per-command-jtbd-derivation.test.cjs'),
 ];
 
 // Exit code convention for child tests:

package/lib/memory/security-trifecta.test.cjs

@@ -290,14 +290,31 @@ test('brain-client.cjs has zero legacy .replace(/"/g, ...) injection patterns',
   );
 });
 
-test('brain-client.cjs guards .env reads with checkFilePermissions', () => {
+test('SEC-02 .env gating lives in resolve-brain-key.cjs (Phase 123 Plan-07)', () => {
+  // Phase 123 Plan-07: getApiKey() now delegates to lib/core/resolve-brain-key.cjs,
+  // which owns the SEC-02 POSIX 0o077 permission check for both ~/.mindrian.env
+  // and CWD .env. The brain-client.cjs::checkFilePermissions() helper remains
+  // exported via _test for backward-compat (and unit-test surface above), but
+  // the live gating call sites moved one layer down. The invariant is:
+  //   1. brain-client.cjs requires resolve-brain-key.cjs (delegation lives).
+  //   2. resolve-brain-key.cjs contains the 0o077 mask check (SEC-02 lives).
+  // Both must hold; either failure is a regression that re-introduces the
+  // pre-Plan-07 multiple-resolver disease.
   const brainPath = path.resolve(__dirname, '..', 'core', 'brain-client.cjs');
-  const src = fs.readFileSync(brainPath, 'utf8');
-  const matches = src.match(/checkFilePermissions\s*\(/g) || [];
-  // 1 definition + 2 getApiKey call sites (cwd .env + ~/.mindrian.env) = 3.
+  const resolverPath = path.resolve(__dirname, '..', 'core', 'resolve-brain-key.cjs');
+  const brainSrc = fs.readFileSync(brainPath, 'utf8');
+  const resolverSrc = fs.readFileSync(resolverPath, 'utf8');
   assert.ok(
-    matches.length >= 3,
-    `expected >= 3 checkFilePermissions occurrences, got ${matches.length}`
+    /require\(['"][^'"]*resolve-brain-key[^'"]*['"]\)/.test(brainSrc),
+    'brain-client.cjs must require resolve-brain-key.cjs (Phase 123 Plan-07 delegation)'
+  );
+  assert.ok(
+    /0o077/.test(resolverSrc),
+    'resolve-brain-key.cjs must contain the SEC-02 0o077 mask check'
+  );
+  assert.ok(
+    /process\.platform/.test(resolverSrc),
+    'resolve-brain-key.cjs must short-circuit the SEC-02 check on Windows (process.platform)'
   );
 });
 

package/lib/memory/selector-decisions.test.cjs

@@ -0,0 +1,417 @@
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 125-06 -- lib/workflow/selector-decisions.cjs test suite.
+ *
+ * Covers 16 acceptance behaviors from 125-06-PLAN.md <behavior> block:
+ *   Tests 1-7   Decision writes (D7): recordSelectorDecision
+ *   Tests 8-14  Decay weight (D7): applyDecayWeight + shouldExclude
+ *   Tests 15-16 Integration with Plan 05 ranker (opts._applyDecayWeight)
+ *
+ * Three-surface compatibility: pure CJS + node:test. Uses fs.mkdtempSync +
+ * openRoomDb fixture pattern from Plan 00's navigation-write-edge.test.cjs.
+ * All writes route through the navigation.cjs chokepoint; tests verify both
+ * the memory_event row AND the typed cascade edge row land in room.db.
+ */
+
+'use strict';
+
+const { test } = require('node:test');
+const { ok, equal, deepStrictEqual } = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const SELECTOR_DECISIONS_PATH = path.join(REPO_ROOT, 'lib', 'workflow', 'selector-decisions.cjs');
+const RANKER_PATH = path.join(REPO_ROOT, 'lib', 'workflow', 'f-selector-ranker.cjs');
+const { openRoomDb } = require(path.join(REPO_ROOT, 'lib', 'core', 'room-db.cjs'));
+const selectorDecisions = require(SELECTOR_DECISIONS_PATH);
+const ranker = require(RANKER_PATH);
+
+function freshDb() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'p125-06-selector-decisions-'));
+  const db = openRoomDb(dir);
+  return { dir, db };
+}
+
+// FK fixture (mirrors Plan 00's seedAnchorNode pattern in
+// lib/memory/navigation-write-edge.test.cjs). The shipped edges table has
+// FK (source, target) -> nodes(id), so we must seed anchor nodes for the
+// command + framework before writeEdge can succeed.
+function seedAnchorNode(db, id, type) {
+  const nowMs = Date.now();
+  db.prepare(
+    "INSERT OR IGNORE INTO nodes (id, type, properties, source_path, created_by, confidence, review_status, created_at, last_seen_at) " +
+    "VALUES (?, ?, '{}', 'p125-06-fixture', 'system', NULL, 'confirmed', ?, ?)"
+  ).run(id, type, nowMs, nowMs);
+}
+
+function seedAnchorsFor(db, command, framework) {
+  seedAnchorNode(db, 'cmd:' + command, 'command');
+  seedAnchorNode(db, 'framework:' + framework, 'framework');
+}
+
+function fetchMemoryEvent(db, decisionId) {
+  return db.prepare(
+    "SELECT id, type, properties FROM nodes WHERE id = ?"
+  ).get(decisionId);
+}
+
+function fetchEdge(db, source, target, type) {
+  return db.prepare(
+    "SELECT source, target, type, properties FROM edges WHERE source = ? AND target = ? AND type = ?"
+  ).get(source, target, type);
+}
+
+// ---------------------------------------------------------------------------
+// Tests 1-7: Decision writes (D7)
+// ---------------------------------------------------------------------------
+
+test('Test 1: recordSelectorDecision({decision: "defer"}) writes memory_event with decision="defer"', () => {
+  const { db } = freshDb();
+  seedAnchorsFor(db, 'mos:beautiful-question', 'Beautiful Question Framework');
+  const r = selectorDecisions.recordSelectorDecision({
+    decision: 'defer',
+    command: 'mos:beautiful-question',
+    framework: 'Beautiful Question Framework',
+    reason: 'not now',
+    roomState: { db, investment_level: 0.3 },
+  });
+  ok(r.ok, 'recordSelectorDecision should return ok: true; got reason=' + (r && r.reason));
+  ok(typeof r.decision_id === 'string' && r.decision_id.length > 0, 'decision_id is non-empty string');
+  ok(typeof r.edge_id === 'string' && r.edge_id.length > 0, 'edge_id is non-empty string');
+  const row = fetchMemoryEvent(db, r.decision_id);
+  ok(row, 'memory_event row present in nodes table');
+  equal(row.type, 'memory_event');
+  const props = JSON.parse(row.properties);
+  equal(props.event_type, 'f_selector_decision');
+  equal(props.decision, 'defer');
+  equal(props.command, 'mos:beautiful-question');
+});
+
+test('Test 2: recordSelectorDecision with decision="reject" writes REJECTED edge', () => {
+  const { db } = freshDb();
+  seedAnchorsFor(db, 'mos:swot', 'SWOT');
+  const r = selectorDecisions.recordSelectorDecision({
+    decision: 'reject',
+    command: 'mos:swot',
+    framework: 'SWOT',
+    reason: 'wrong approach for our stage',
+    roomState: { db, investment_level: 0.5 },
+  });
+  ok(r.ok);
+  // memory_event has decision='reject'.
+  const memRow = fetchMemoryEvent(db, r.decision_id);
+  ok(memRow);
+  const memProps = JSON.parse(memRow.properties);
+  equal(memProps.decision, 'reject');
+  equal(memProps.edge_semantic, 'REJECTED');
+  // edge of type REJECTED is present.
+  const edge = fetchEdge(db, 'cmd:mos:swot', 'framework:SWOT', 'REJECTED');
+  ok(edge, 'REJECTED edge row should be present');
+  equal(edge.type, 'REJECTED');
+});
+
+test('Test 3: DEFERRED edge has expires_at ~30 days from now; REJECTED edge does NOT', () => {
+  const { db } = freshDb();
+  seedAnchorsFor(db, 'mos:c1', 'F1');
+  seedAnchorsFor(db, 'mos:c2', 'F2');
+
+  // Defer: expires_at present and within 5min of now+30 days.
+  const r1 = selectorDecisions.recordSelectorDecision({
+    decision: 'defer',
+    command: 'mos:c1',
+    framework: 'F1',
+    reason: null,
+    roomState: { db },
+  });
+  ok(r1.ok);
+  const e1 = fetchEdge(db, 'cmd:mos:c1', 'framework:F1', 'DEFERRED');
+  ok(e1);
+  const props1 = JSON.parse(e1.properties);
+  ok(typeof props1.expires_at === 'string' && props1.expires_at.length > 0, 'expires_at present on DEFERRED');
+  const expiresMs = Date.parse(props1.expires_at);
+  const expectedMs = Date.now() + 30 * 24 * 3600 * 1000;
+  const deltaMs = Math.abs(expiresMs - expectedMs);
+  ok(deltaMs < 5 * 60 * 1000, 'expires_at ~30 days from now (within 5 min tolerance); delta=' + deltaMs);
+
+  // Reject: expires_at absent.
+  const r2 = selectorDecisions.recordSelectorDecision({
+    decision: 'reject',
+    command: 'mos:c2',
+    framework: 'F2',
+    reason: null,
+    roomState: { db },
+  });
+  ok(r2.ok);
+  const e2 = fetchEdge(db, 'cmd:mos:c2', 'framework:F2', 'REJECTED');
+  ok(e2);
+  const props2 = JSON.parse(e2.properties);
+  equal(Object.prototype.hasOwnProperty.call(props2, 'expires_at'), false, 'REJECTED edge has no expires_at');
+});
+
+test('Test 4: edge properties include reason verbatim and decision_id', () => {
+  const { db } = freshDb();
+  seedAnchorsFor(db, 'mos:c4', 'F4');
+  const reasonText = 'team is split; defer until next milestone';
+  const r = selectorDecisions.recordSelectorDecision({
+    decision: 'defer',
+    command: 'mos:c4',
+    framework: 'F4',
+    reason: reasonText,
+    roomState: { db },
+  });
+  ok(r.ok);
+  const edge = fetchEdge(db, 'cmd:mos:c4', 'framework:F4', 'DEFERRED');
+  ok(edge);
+  const props = JSON.parse(edge.properties);
+  equal(props.reason, reasonText);
+  equal(props.decision_id, r.decision_id);
+});
+
+test('Test 5: invalid decision (e.g. "maybe") returns ok:false; no writes', () => {
+  const { db } = freshDb();
+  seedAnchorsFor(db, 'mos:c5', 'F5');
+  const r = selectorDecisions.recordSelectorDecision({
+    decision: 'maybe',
+    command: 'mos:c5',
+    framework: 'F5',
+    roomState: { db },
+  });
+  equal(r.ok, false);
+  equal(r.reason, 'invalid_decision');
+  // No edges of any type for this command.
+  const edges = db.prepare("SELECT 1 FROM edges WHERE source = ?").all('cmd:mos:c5');
+  equal(edges.length, 0, 'no edges should be written on invalid decision');
+  // No memory_event for f_selector_decision tied to this command.
+  const mems = db.prepare(
+    "SELECT 1 FROM nodes WHERE type = 'memory_event' AND json_extract(properties, '$.command') = ?"
+  ).all('mos:c5');
+  equal(mems.length, 0, 'no memory_event should be written on invalid decision');
+});
+
+test('Test 6: reason is optional -- when omitted, payload.reason is null AND edge.properties.reason is null', () => {
+  const { db } = freshDb();
+  seedAnchorsFor(db, 'mos:c6', 'F6');
+  const r = selectorDecisions.recordSelectorDecision({
+    decision: 'defer',
+    command: 'mos:c6',
+    framework: 'F6',
+    // reason omitted intentionally
+    roomState: { db },
+  });
+  ok(r.ok);
+  const mem = fetchMemoryEvent(db, r.decision_id);
+  const memProps = JSON.parse(mem.properties);
+  equal(memProps.reason, null, 'payload.reason is null when omitted');
+  const edge = fetchEdge(db, 'cmd:mos:c6', 'framework:F6', 'DEFERRED');
+  const edgeProps = JSON.parse(edge.properties);
+  equal(edgeProps.reason, null, 'edge.properties.reason is null when omitted');
+});
+
+test('Test 7: all writes route through navigation.cjs chokepoint (grep audit)', () => {
+  const src = fs.readFileSync(SELECTOR_DECISIONS_PATH, 'utf8');
+  ok(/require\(['"]\.\.\/core\/navigation\.cjs['"]\)/.test(src),
+    "source must require('../core/navigation.cjs')");
+  ok(src.indexOf('navigation.writeEdge') !== -1, 'must call navigation.writeEdge');
+  ok(src.indexOf('navigation.logMemoryEvent') !== -1, 'must call navigation.logMemoryEvent');
+  // No direct room-db.cjs require allowed.
+  ok(!/require\([^)]*room-db/.test(src),
+    'must NOT require room-db.cjs directly (Canon Part 8 chokepoint invariant)');
+  // No direct internal memory-events module require.
+  ok(!/require\([^)]*navigation\/memory-events/.test(src),
+    'must NOT require navigation/memory-events.cjs directly; route via navigation.cjs');
+  // No direct better-sqlite3 / sqlite3 require.
+  ok(!/require\(['"]better-sqlite3['"]\)/.test(src),
+    'must NOT require better-sqlite3 directly');
+  ok(!/require\(['"]sqlite3['"]\)/.test(src),
+    'must NOT require sqlite3 directly');
+});
+
+// ---------------------------------------------------------------------------
+// Tests 8-14: Decay weight (D7) + shouldExclude helper
+// ---------------------------------------------------------------------------
+
+test('Test 8: applyDecayWeight at invocation 0 since decision returns 0 (factor = 0)', () => {
+  const roomState = { invocationsSinceDecision: { 'mos:x': 0 } };
+  const out = selectorDecisions.applyDecayWeight(0.8, 'mos:x', roomState);
+  ok(typeof out === 'number' && isFinite(out), 'returns finite number');
+  ok(Math.abs(out - 0) < 1e-9, 'at invocation 0, factor = 0; got ' + out);
+});
+
+test('Test 9: applyDecayWeight at invocation 5 returns ~0.632 * base (within 0.05)', () => {
+  // factor = 1 - exp(-5/5) = 1 - 1/e ~= 0.6321...
+  const roomState = { invocationsSinceDecision: { 'mos:x': 5 } };
+  const out = selectorDecisions.applyDecayWeight(0.8, 'mos:x', roomState);
+  const expected = 0.8 * (1 - Math.exp(-1));
+  ok(Math.abs(out - expected) < 0.05, 'invocation 5 -> ~0.5057; got ' + out);
+});
+
+test('Test 10: applyDecayWeight at invocation 10 returns factor ~0.865 (within 0.05)', () => {
+  // factor = 1 - exp(-10/5) = 1 - exp(-2) ~= 0.8647
+  const roomState = { invocationsSinceDecision: { 'mos:x': 10 } };
+  const out = selectorDecisions.applyDecayWeight(1.0, 'mos:x', roomState);
+  const expected = 1 - Math.exp(-2);
+  ok(Math.abs(out - expected) < 0.05, 'invocation 10 -> ~0.865; got ' + out);
+});
+
+test('Test 11: applyDecayWeight at invocation 15 returns >= 0.95 of base (effectively expired)', () => {
+  const roomState = { invocationsSinceDecision: { 'mos:x': 15 } };
+  const out = selectorDecisions.applyDecayWeight(1.0, 'mos:x', roomState);
+  ok(out >= 0.95, 'at invocation 15, factor >= 0.95 of base; got ' + out);
+});
+
+test('Test 12: shouldExclude returns true when decay factor < 0.1; false when >= 0.1', () => {
+  // factor < 0.1 means 1 - exp(-n/5) < 0.1 => exp(-n/5) > 0.9 => n/5 < ln(1/0.9) ~ 0.1054
+  // => n < 0.527. So at n=0 -> exclude; at n=1 -> factor ~= 0.181 -> include.
+  const exclude0 = selectorDecisions.shouldExclude('mos:x', { invocationsSinceDecision: { 'mos:x': 0 } });
+  equal(exclude0, true, 'at invocation 0 (freshly deferred), shouldExclude=true');
+  const include1 = selectorDecisions.shouldExclude('mos:x', { invocationsSinceDecision: { 'mos:x': 1 } });
+  equal(include1, false, 'at invocation 1, factor ~= 0.181, shouldExclude=false');
+  const include5 = selectorDecisions.shouldExclude('mos:x', { invocationsSinceDecision: { 'mos:x': 5 } });
+  equal(include5, false, 'at invocation 5, factor ~= 0.632, shouldExclude=false');
+});
+
+test('Test 13: applyDecayWeight is pure -- same inputs produce same output', () => {
+  const roomState = { invocationsSinceDecision: { 'mos:x': 3 } };
+  const a = selectorDecisions.applyDecayWeight(0.7, 'mos:x', roomState);
+  const b = selectorDecisions.applyDecayWeight(0.7, 'mos:x', roomState);
+  const c = selectorDecisions.applyDecayWeight(0.7, 'mos:x', roomState);
+  equal(a, b);
+  equal(b, c);
+});
+
+test('Test 14: applyDecayWeight gracefully handles roomState without decision history -- returns base_score unchanged', () => {
+  // No invocationsSinceDecision counter; no db; no decision recorded => no decay.
+  const out1 = selectorDecisions.applyDecayWeight(0.65, 'mos:never-deferred', {});
+  equal(out1, 0.65, 'returns base_score when no history');
+  // Counter present but missing this command key -> no decay.
+  const out2 = selectorDecisions.applyDecayWeight(0.65, 'mos:never-deferred', { invocationsSinceDecision: {} });
+  equal(out2, 0.65);
+  // Null/undefined roomState -> returns base_score gracefully.
+  const out3 = selectorDecisions.applyDecayWeight(0.65, 'mos:never-deferred', null);
+  equal(out3, 0.65);
+  const out4 = selectorDecisions.applyDecayWeight(0.65, 'mos:never-deferred', undefined);
+  equal(out4, 0.65);
+});
+
+// ---------------------------------------------------------------------------
+// Tests 15-16: Integration with Plan 05 ranker (opts._applyDecayWeight)
+// ---------------------------------------------------------------------------
+
+test('Test 15: ranker with opts._applyDecayWeight applies decay; freshly-deferred command ranks at bottom (or filtered)', () => {
+  // Use the ranker's fake-registry seam to inject a deterministic 2-command set.
+  ranker._test._resetCaches();
+  ranker._test._setRegistry({
+    commands: [
+      {
+        command: '/mos:beautiful-question',
+        kind: 'methodology',
+        frameworks: ['Beautiful Question Framework'],
+        serves_jtbd: ['find-problem'],
+        jtbd_label: 'Find root problem',
+        jtbd_summary: 'BQ surfaces real problems under the symptom.',
+        teaching: 'Widen before narrowing.',
+      },
+      {
+        command: '/mos:swot',
+        kind: 'methodology',
+        frameworks: ['SWOT'],
+        serves_jtbd: ['validate-thesis'],
+        jtbd_label: 'Audit S/W/O/T',
+        jtbd_summary: 'SWOT structures internal vs external.',
+        teaching: 'SWOT after JTBD.',
+      },
+    ],
+  });
+  // Mark beautiful-question as freshly deferred (invocation 0 since decision).
+  const roomState = {
+    invocationsSinceDecision: { '/mos:beautiful-question': 0 },
+  };
+  const out = ranker.rankForSelector({
+    roomState,
+    k: 3,
+    _applyDecayWeight: selectorDecisions.applyDecayWeight,
+  });
+  // BQ is at invocation 0 => factor 0 => score multiplied by 0 => 0. SWOT untouched.
+  ok(out.length >= 1, 'returns at least one ranked command');
+  const bq = out.find((x) => x.command === '/mos:beautiful-question');
+  const swot = out.find((x) => x.command === '/mos:swot');
+  ok(bq, 'BQ should still appear in the result (decay does not filter from ranker output)');
+  ok(swot, 'SWOT should appear');
+  ok(bq.score === 0, 'freshly-deferred BQ has score 0 after decay; got ' + bq.score);
+  // SWOT outranks BQ when BQ score = 0.
+  ok(swot.score >= bq.score, 'SWOT ranks at least as high as decayed BQ');
+  // Reset for downstream tests.
+  ranker._test._resetCaches();
+});
+
+test('Test 16: after 15 invocations since decision, decayed score ~= un-decayed score (decision effectively expired)', () => {
+  ranker._test._resetCaches();
+  ranker._test._setRegistry({
+    commands: [
+      {
+        command: '/mos:beautiful-question',
+        kind: 'methodology',
+        frameworks: ['Beautiful Question Framework'],
+        serves_jtbd: ['find-problem'],
+        jtbd_label: 'Find root problem',
+        jtbd_summary: 'BQ surfaces real problems.',
+        teaching: 'Widen before narrowing.',
+      },
+    ],
+  });
+  // Un-decayed baseline (no decay hook).
+  const baseline = ranker.rankForSelector({
+    roomState: {},
+    k: 3,
+  });
+  // After 15 invocations since decision, factor ~= 0.9502, effectively expired.
+  const decayed = ranker.rankForSelector({
+    roomState: { invocationsSinceDecision: { '/mos:beautiful-question': 15 } },
+    k: 3,
+    _applyDecayWeight: selectorDecisions.applyDecayWeight,
+  });
+  const baseBq = baseline.find((x) => x.command === '/mos:beautiful-question');
+  const decayBq = decayed.find((x) => x.command === '/mos:beautiful-question');
+  ok(baseBq);
+  ok(decayBq);
+  // Decayed score should be within ~5% of baseline (decay factor >= 0.95 at n=15).
+  const ratio = decayBq.score / Math.max(baseBq.score, 1e-9);
+  ok(ratio >= 0.94, 'decayed score is at least 94% of baseline at n=15; got ratio=' + ratio);
+  ranker._test._resetCaches();
+});
+
+// ---------------------------------------------------------------------------
+// Bonus regression: db-backed _invocationsSinceDecision counts framework_invoked
+// events newer than the most recent f_selector_decision for the command.
+// ---------------------------------------------------------------------------
+
+test('Bonus: _invocationsSinceDecision counts framework_invoked events after the last decision', () => {
+  const { db } = freshDb();
+  seedAnchorsFor(db, 'mos:bonus-decay', 'BonusFramework');
+  // Record a decision at t0.
+  const r = selectorDecisions.recordSelectorDecision({
+    decision: 'defer',
+    command: 'mos:bonus-decay',
+    framework: 'BonusFramework',
+    reason: null,
+    roomState: { db },
+  });
+  ok(r.ok);
+  // Sleep at least 2 ms so the framework_invoked rows land strictly after the
+  // memory_event row (createdAt > lastDecisionAt). Phase 109's findRecentChanges
+  // uses strict '>' on created_at.
+  const target = Date.now() + 3;
+  while (Date.now() < target) { /* busy-wait <= 3ms */ }
+  // Log a few framework_invoked events via the chokepoint.
+  const navigation = require(path.join(REPO_ROOT, 'lib', 'core', 'navigation.cjs'));
+  navigation.logMemoryEvent(db, 'framework_invoked', { command: 'mos:bonus-decay', framework: 'BonusFramework' });
+  navigation.logMemoryEvent(db, 'framework_invoked', { command: 'mos:bonus-decay', framework: 'BonusFramework' });
+  // Now applyDecayWeight should compute decay relative to 2 invocations since decision.
+  // factor = 1 - exp(-2/5) ~= 0.3297; 0.5 * 0.3297 ~= 0.1648.
+  const decayed = selectorDecisions.applyDecayWeight(0.5, 'mos:bonus-decay', { db });
+  const expected = 0.5 * (1 - Math.exp(-2 / 5));
+  ok(Math.abs(decayed - expected) < 0.1, 'db-backed decay factor with 2 framework_invoked events; got ' + decayed + ' expected ~' + expected);
+});