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

package/lib/memory/navigation-projections.test.cjs

@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ * Phase 125-01 -- lib/core/navigation/projections.cjs test suite.
+ *
+ * Covers the 8 acceptance bullets from 125-CONTEXT.md "Projections" section
+ * (D1 + D2 + D3) via 16 behaviors:
+ *   resolveActiveFrameworks  (Tests 1-5)   D1 multi-signal precedence
+ *   resolveHopDepth          (Tests 6-9)   D2 depth + rationale; default WIDE
+ *   computeInvestmentLevel   (Tests 10-15) D3 linear gradient 0..1
+ *   purity invariant         (Test 16)     all three helpers pure + idempotent
+ *
+ * Three-surface compatibility: pure CJS + node built-ins + node:test. No
+ * surface-specific branches. No db / no fs / no Brain / no network.
+ */
+
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert');
+const path = require('node:path');
+
+const PROJECTIONS_PATH = path.resolve(__dirname, '..', 'core', 'navigation', 'projections.cjs');
+
+function loadProjections() {
+  delete require.cache[require.resolve(PROJECTIONS_PATH)];
+  return require(PROJECTIONS_PATH);
+}
+
+// ----------- resolveActiveFrameworks (D1) -----------
+
+test('Test 1: resolveActiveFrameworks({}) returns []', () => {
+  const { resolveActiveFrameworks } = loadProjections();
+  const out = resolveActiveFrameworks({});
+  assert.ok(Array.isArray(out), 'returns an array');
+  assert.strictEqual(out.length, 0, 'empty for empty roomState');
+});
+
+test('Test 1b: resolveActiveFrameworks(null/undefined) returns []', () => {
+  const { resolveActiveFrameworks } = loadProjections();
+  assert.deepStrictEqual(resolveActiveFrameworks(null), []);
+  assert.deepStrictEqual(resolveActiveFrameworks(undefined), []);
+  assert.deepStrictEqual(resolveActiveFrameworks('not-an-object'), []);
+});
+
+test('Test 2: resolveActiveFrameworks extracts Mullins 7 Domains from governing_thought', () => {
+  const { resolveActiveFrameworks } = loadProjections();
+  const out = resolveActiveFrameworks({
+    governing_thought: 'Apply Mullins 7 Domains to validate market attractiveness',
+  });
+  assert.ok(out.length >= 1, 'at least one entry');
+  const fw = out.find((x) => x.name === 'Mullins 7 Domains');
+  assert.ok(fw, 'Mullins 7 Domains is present');
+  assert.strictEqual(fw.source, 'governing_thought');
+  assert.strictEqual(fw.weight, 1.0);
+});
+
+test('Test 3: resolveActiveFrameworks precedence -- governing_thought sorts first by weight', () => {
+  const { resolveActiveFrameworks } = loadProjections();
+  const out = resolveActiveFrameworks({
+    governing_thought: 'Use SWOT to assess the position',
+    activeJtbd: 'find-problem',
+  });
+  assert.ok(out.length >= 1);
+  // First entry has the highest weight; governing_thought wins (1.0 > 0.75)
+  assert.strictEqual(out[0].source, 'governing_thought');
+  assert.strictEqual(out[0].weight, 1.0);
+});
+
+test('Test 4: resolveActiveFrameworks reads brainAnchors with source=brain_md weight 0.5', () => {
+  const { resolveActiveFrameworks } = loadProjections();
+  const out = resolveActiveFrameworks({
+    brainAnchors: ['SWOT', 'Porter Five Forces'],
+  });
+  assert.strictEqual(out.length, 2);
+  const names = out.map((x) => x.name).sort();
+  assert.deepStrictEqual(names, ['Porter Five Forces', 'SWOT']);
+  for (const e of out) {
+    assert.strictEqual(e.source, 'brain_md');
+    assert.strictEqual(e.weight, 0.5);
+  }
+});
+
+test('Test 5: resolveActiveFrameworks 4-signal output ordered by weight desc', () => {
+  const { resolveActiveFrameworks } = loadProjections();
+  const out = resolveActiveFrameworks({
+    governing_thought: 'Use SWOT to find white space',
+    activeJtbd: 'find-problem',
+    brainAnchors: ['Wardley Map'],
+    recentFrameworks: ['Cynefin'],
+  });
+  // All 4 sources should appear (assuming activeJtbd resolves to *some* framework
+  // and the registry is loadable; if it doesn't resolve, that signal silently
+  // drops -- still strictly weight-desc ordered)
+  // Weights monotonically descend.
+  for (let i = 1; i < out.length; i++) {
+    assert.ok(out[i - 1].weight >= out[i].weight,
+      `weight at ${i-1} (${out[i-1].weight}) >= weight at ${i} (${out[i].weight})`);
+  }
+  // First entry is governing_thought (the highest weight, 1.0)
+  assert.strictEqual(out[0].source, 'governing_thought');
+  // Sources observed are a subset of the 4 canonical sources
+  const allowed = new Set(['governing_thought', 'activeJtbd', 'brain_md', 'memory_event']);
+  for (const e of out) {
+    assert.ok(allowed.has(e.source), `unknown source ${e.source}`);
+  }
+});
+
+// ----------- resolveHopDepth (D2) -----------
+
+test('Test 6: resolveHopDepth({problemType: "WDP", governing_thought: "strong"}) returns depth 1', () => {
+  const { resolveHopDepth } = loadProjections();
+  const out = resolveHopDepth({ problemType: 'WDP', governing_thought: 'strong' });
+  assert.strictEqual(out.depth, 1);
+  assert.ok(typeof out.rationale === 'string' && out.rationale.length > 0);
+  const r = out.rationale.toLowerCase();
+  assert.ok(r.includes('well-defined') || r.includes('execution'),
+    `rationale mentions well-defined or execution: "${out.rationale}"`);
+});
+
+test('Test 7: resolveHopDepth({problemType: "IDP"}) returns depth 2', () => {
+  const { resolveHopDepth } = loadProjections();
+  const out = resolveHopDepth({ problemType: 'IDP' });
+  assert.strictEqual(out.depth, 2);
+  assert.ok(typeof out.rationale === 'string' && out.rationale.length > 0);
+  const r = out.rationale.toLowerCase();
+  assert.ok(r.includes('ill-defined') || r.includes('evolving') || r.includes('exploratory'),
+    `rationale mentions ill-defined / evolving / exploratory: "${out.rationale}"`);
+});
+
+test('Test 8: resolveHopDepth on unknown problemType returns depth 3 (default WIDE)', () => {
+  const { resolveHopDepth } = loadProjections();
+  const out = resolveHopDepth({ problemType: 'WDP-but-actually-unknown' });
+  assert.strictEqual(out.depth, 3);
+  assert.ok(typeof out.rationale === 'string' && out.rationale.length > 0);
+  const r = out.rationale.toLowerCase();
+  assert.ok(r.includes('wicked') || r.includes('no anchor') || r.includes('default') || r.includes('ambiguity'),
+    `rationale mentions wicked / no anchor / default / ambiguity: "${out.rationale}"`);
+});
+
+test('Test 9: resolveHopDepth({}) returns {depth: 3, ...} (default WIDE on ambiguity per D2)', () => {
+  const { resolveHopDepth } = loadProjections();
+  const out = resolveHopDepth({});
+  assert.strictEqual(out.depth, 3);
+  assert.ok(typeof out.rationale === 'string' && out.rationale.length > 0);
+});
+
+test('Test 9b: resolveHopDepth(null/undefined) returns depth 3', () => {
+  const { resolveHopDepth } = loadProjections();
+  assert.strictEqual(resolveHopDepth(null).depth, 3);
+  assert.strictEqual(resolveHopDepth(undefined).depth, 3);
+  assert.strictEqual(resolveHopDepth('not-an-object').depth, 3);
+});
+
+// ----------- computeInvestmentLevel (D3) -----------
+
+test('Test 10: computeInvestmentLevel({framework_invocations: 0}) returns level 0', () => {
+  const { computeInvestmentLevel } = loadProjections();
+  const out = computeInvestmentLevel({ framework_invocations: 0 });
+  assert.strictEqual(out.level, 0);
+  assert.ok(typeof out.label === 'string' && out.label.length > 0);
+  assert.strictEqual(out.label, 'fresh room, ranking with Brain priors');
+});
+
+test('Test 11: computeInvestmentLevel({framework_invocations: 3}) returns level 0.3 label includes Brain', () => {
+  const { computeInvestmentLevel } = loadProjections();
+  const out = computeInvestmentLevel({ framework_invocations: 3 });
+  assert.strictEqual(out.level, 0.3);
+  assert.ok(typeof out.label === 'string' && out.label.length > 0);
+  const l = out.label.toLowerCase();
+  assert.ok(l.includes('brain') && (l.includes('local signal') || l.includes('local')),
+    `label includes Brain and local signal: "${out.label}"`);
+});
+
+test('Test 12: computeInvestmentLevel({framework_invocations: 5}) returns level 0.5 balanced', () => {
+  const { computeInvestmentLevel } = loadProjections();
+  const out = computeInvestmentLevel({ framework_invocations: 5 });
+  assert.strictEqual(out.level, 0.5);
+  assert.ok(typeof out.label === 'string' && out.label.length > 0);
+  assert.ok(out.label.toLowerCase().includes('balanced'),
+    `label includes 'balanced': "${out.label}"`);
+});
+
+test('Test 13: computeInvestmentLevel({framework_invocations: 10}) returns level 1.0 full local', () => {
+  const { computeInvestmentLevel } = loadProjections();
+  const out = computeInvestmentLevel({ framework_invocations: 10 });
+  assert.strictEqual(out.level, 1.0);
+  assert.ok(typeof out.label === 'string' && out.label.length > 0);
+  const l = out.label.toLowerCase();
+  assert.ok(l.includes('full local') || l.includes('full'),
+    `label includes 'full local' or 'full': "${out.label}"`);
+});
+
+test('Test 14: computeInvestmentLevel({framework_invocations: 15}) caps at 1.0', () => {
+  const { computeInvestmentLevel } = loadProjections();
+  const out = computeInvestmentLevel({ framework_invocations: 15 });
+  assert.strictEqual(out.level, 1.0);
+});
+
+test('Test 15: computeInvestmentLevel({}) returns level 0 (cold-start with no counter)', () => {
+  const { computeInvestmentLevel } = loadProjections();
+  const out = computeInvestmentLevel({});
+  assert.strictEqual(out.level, 0);
+  assert.ok(typeof out.label === 'string' && out.label.length > 0);
+});
+
+test('Test 15b: computeInvestmentLevel(null/undefined) returns level 0', () => {
+  const { computeInvestmentLevel } = loadProjections();
+  assert.strictEqual(computeInvestmentLevel(null).level, 0);
+  assert.strictEqual(computeInvestmentLevel(undefined).level, 0);
+});
+
+test('Test 15c: computeInvestmentLevel handles negative input by clamping to 0', () => {
+  const { computeInvestmentLevel } = loadProjections();
+  const out = computeInvestmentLevel({ framework_invocations: -3 });
+  assert.strictEqual(out.level, 0);
+});
+
+// ----------- Purity invariant (Test 16) -----------
+
+test('Test 16: All three functions are pure -- twice with identical input -> deepEqual result', () => {
+  const { resolveActiveFrameworks, resolveHopDepth, computeInvestmentLevel } = loadProjections();
+  const roomState = {
+    problemType: 'IDP',
+    governing_thought: 'Use SWOT to assess the venture',
+    activeJtbd: 'find-problem',
+    brainAnchors: ['Porter Five Forces', 'Wardley Map'],
+    recentFrameworks: ['Cynefin'],
+    framework_invocations: 4,
+  };
+  const a1 = resolveActiveFrameworks(roomState);
+  const a2 = resolveActiveFrameworks(roomState);
+  assert.deepStrictEqual(a1, a2, 'resolveActiveFrameworks is pure');
+
+  const h1 = resolveHopDepth(roomState);
+  const h2 = resolveHopDepth(roomState);
+  assert.deepStrictEqual(h1, h2, 'resolveHopDepth is pure');
+
+  const c1 = computeInvestmentLevel(roomState);
+  const c2 = computeInvestmentLevel(roomState);
+  assert.deepStrictEqual(c1, c2, 'computeInvestmentLevel is pure');
+});

package/lib/memory/navigation-write-edge.test.cjs

@@ -0,0 +1,206 @@
+'use strict';
+// Phase 125-00 -- writeEdge chokepoint primitive tests.
+// Adds the writeEdge edge-write surface to lib/core/navigation.cjs (the closed
+// chokepoint per Phase 109). Mirrors the Phase 110-03 logMemoryEvent additive
+// re-export precedent.
+//
+// Per Plan 125-00 frontmatter <behavior>: 9 scenarios -- happy-path (DEFERRED),
+// allowlist enforcement, REJECTED edge shape, missing source_id, missing
+// target_id, non-serializable properties, UPSERT idempotency, write-isolation
+// across handles, and the extensibility-Set membership check.
+//
+// CRITICAL: this test REQUIRES navigation.cjs (the chokepoint) -- NOT the
+// internal edges.cjs -- to prove the Task 2 re-export wiring is intact.
+
+const { test } = require('node:test');
+const { ok, equal } = 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 { openRoomDb } = require(path.join(REPO_ROOT, 'lib', 'core', 'room-db.cjs'));
+const navigation = require(path.join(REPO_ROOT, 'lib', 'core', 'navigation.cjs'));
+const edgesInternal = require(path.join(REPO_ROOT, 'lib', 'core', 'navigation', 'edges.cjs'));
+
+function freshDb() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'p125-00-writeedge-'));
+  const db = openRoomDb(dir);
+  return { dir, db };
+}
+
+// The shipped edges table has FK constraints on (source, target) -> nodes(id),
+// per lib/core/lazygraph-ops.cjs initSchema(). Tests must insert anchor nodes
+// before writeEdge, mirroring the fixture pattern in
+// tests/test-navigation-packet-builder.cjs (Phase 109-07).
+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-00-fixture', 'system', NULL, 'confirmed', ?, ?)"
+  ).run(id, type, nowMs, nowMs);
+}
+
+test('Test 1: happy-path DEFERRED edge writes row with full properties', () => {
+  const { db } = freshDb();
+  seedAnchorNode(db, 'cmd:beautiful-question', 'command');
+  seedAnchorNode(db, 'framework:Beautiful Question Framework', 'framework');
+  const r = navigation.writeEdge(db, {
+    source_id: 'cmd:beautiful-question',
+    target_id: 'framework:Beautiful Question Framework',
+    edge_type: 'DEFERRED',
+    properties: {
+      reason: 'not now',
+      decision_id: 'memory_event:xyz',
+      expires_at: '2026-06-12T00:00:00Z',
+    },
+  });
+  ok(r.ok, 'writeEdge should return ok:true on valid input');
+  equal(r.type, 'DEFERRED');
+  equal(r.source, 'cmd:beautiful-question');
+  equal(r.target, 'framework:Beautiful Question Framework');
+  ok(typeof r.edge_id === 'string' && r.edge_id.startsWith('edge:DEFERRED:'), 'edge_id should be a non-empty string with edge:DEFERRED: prefix');
+
+  const row = db.prepare(
+    "SELECT properties FROM edges WHERE source = ? AND target = ? AND type = ?"
+  ).get('cmd:beautiful-question', 'framework:Beautiful Question Framework', 'DEFERRED');
+  ok(row, 'row should be present after writeEdge');
+  const props = JSON.parse(row.properties);
+  equal(props.reason, 'not now');
+  equal(props.decision_id, 'memory_event:xyz');
+  equal(props.expires_at, '2026-06-12T00:00:00Z');
+});
+
+test('Test 2: edge_type allowlist enforcement rejects unknown types', () => {
+  const { db } = freshDb();
+  const r = navigation.writeEdge(db, {
+    source_id: 'cmd:x',
+    target_id: 'framework:Y',
+    edge_type: 'NOT_A_REAL_TYPE',
+    properties: {},
+  });
+  equal(r.ok, false);
+  equal(r.reason, 'invalid_edge_type');
+  equal(r.detail, 'NOT_A_REAL_TYPE');
+  // Verify no row was inserted.
+  const row = db.prepare(
+    "SELECT 1 FROM edges WHERE source = ? AND target = ? AND type = ?"
+  ).get('cmd:x', 'framework:Y', 'NOT_A_REAL_TYPE');
+  equal(row, undefined, 'no row should be inserted on rejected edge_type');
+});
+
+test('Test 3: REJECTED edge writes row without expires_at', () => {
+  const { db } = freshDb();
+  seedAnchorNode(db, 'cmd:beautiful-question', 'command');
+  seedAnchorNode(db, 'framework:Beautiful Question Framework', 'framework');
+  const r = navigation.writeEdge(db, {
+    source_id: 'cmd:beautiful-question',
+    target_id: 'framework:Beautiful Question Framework',
+    edge_type: 'REJECTED',
+    properties: { reason: 'wrong approach', decision_id: 'memory_event:abc' },
+  });
+  ok(r.ok);
+  equal(r.type, 'REJECTED');
+  const row = db.prepare(
+    "SELECT properties FROM edges WHERE source = ? AND target = ? AND type = ?"
+  ).get('cmd:beautiful-question', 'framework:Beautiful Question Framework', 'REJECTED');
+  ok(row);
+  const props = JSON.parse(row.properties);
+  equal(props.reason, 'wrong approach');
+  equal(props.decision_id, 'memory_event:abc');
+  equal(Object.prototype.hasOwnProperty.call(props, 'expires_at'), false, 'REJECTED edge should not carry expires_at');
+});
+
+test('Test 4: missing source_id rejected with invalid_source_id', () => {
+  const { db } = freshDb();
+  const r = navigation.writeEdge(db, {
+    source_id: '',
+    target_id: 'framework:X',
+    edge_type: 'DEFERRED',
+    properties: {},
+  });
+  equal(r.ok, false);
+  equal(r.reason, 'invalid_source_id');
+});
+
+test('Test 5: missing target_id rejected with invalid_target_id', () => {
+  const { db } = freshDb();
+  const r = navigation.writeEdge(db, {
+    source_id: 'cmd:x',
+    target_id: null,
+    edge_type: 'DEFERRED',
+    properties: {},
+  });
+  equal(r.ok, false);
+  equal(r.reason, 'invalid_target_id');
+});
+
+test('Test 6: non-serializable properties rejected with properties_serialize_failed', () => {
+  const { db } = freshDb();
+  const circular = {};
+  circular.self = circular;
+  const r = navigation.writeEdge(db, {
+    source_id: 'cmd:x',
+    target_id: 'framework:Y',
+    edge_type: 'DEFERRED',
+    properties: circular,
+  });
+  equal(r.ok, false);
+  equal(r.reason, 'properties_serialize_failed');
+});
+
+test('Test 7: UPSERT idempotency -- second write with different props replaces row', () => {
+  const { db } = freshDb();
+  seedAnchorNode(db, 'cmd:same', 'command');
+  seedAnchorNode(db, 'framework:Same', 'framework');
+  const r1 = navigation.writeEdge(db, {
+    source_id: 'cmd:same',
+    target_id: 'framework:Same',
+    edge_type: 'DEFERRED',
+    properties: { reason: 'first', decision_id: 'memory_event:1' },
+  });
+  ok(r1.ok);
+  const r2 = navigation.writeEdge(db, {
+    source_id: 'cmd:same',
+    target_id: 'framework:Same',
+    edge_type: 'DEFERRED',
+    properties: { reason: 'second', decision_id: 'memory_event:2' },
+  });
+  ok(r2.ok);
+  const rows = db.prepare(
+    "SELECT properties FROM edges WHERE source = ? AND target = ? AND type = ?"
+  ).all('cmd:same', 'framework:Same', 'DEFERRED');
+  equal(rows.length, 1, 'UPSERT must keep exactly one row for (source, target, type)');
+  const props = JSON.parse(rows[0].properties);
+  equal(props.reason, 'second');
+  equal(props.decision_id, 'memory_event:2');
+});
+
+test('Test 8: write-isolation -- second handle to same path sees the row', () => {
+  const { dir, db } = freshDb();
+  seedAnchorNode(db, 'cmd:iso', 'command');
+  seedAnchorNode(db, 'framework:Iso', 'framework');
+  const r = navigation.writeEdge(db, {
+    source_id: 'cmd:iso',
+    target_id: 'framework:Iso',
+    edge_type: 'DEFERRED',
+    properties: { reason: 'isolation-test', decision_id: 'memory_event:iso' },
+  });
+  ok(r.ok);
+  // Open a second handle to the same room dir; the WAL-mode DB must surface the row.
+  const db2 = openRoomDb(dir);
+  const row = db2.prepare(
+    "SELECT properties FROM edges WHERE source = ? AND target = ? AND type = ?"
+  ).get('cmd:iso', 'framework:Iso', 'DEFERRED');
+  ok(row, 'second handle must see the row -- no stuck transaction');
+});
+
+test('Test 9: ALLOWED_EDGE_TYPES Set membership (extensibility check)', () => {
+  // Plan 125-00 ships DEFERRED + REJECTED for v1. Future Phases 116/117/118
+  // extend this Set additively (mirrors EVENT_TYPES Set precedent in
+  // memory-events.cjs). Test asserts a FLOOR -- present-and-additive -- not
+  // an exact size, so a future phase extension cannot regress this baseline.
+  ok(edgesInternal.ALLOWED_EDGE_TYPES instanceof Set, 'ALLOWED_EDGE_TYPES must be a Set');
+  ok(edgesInternal.ALLOWED_EDGE_TYPES.has('DEFERRED'), 'DEFERRED must be in v1 allowlist');
+  ok(edgesInternal.ALLOWED_EDGE_TYPES.has('REJECTED'), 'REJECTED must be in v1 allowlist');
+});