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

package/lib/core/breakthrough/verb-dispatch.test.cjs

@@ -0,0 +1,185 @@
+'use strict';
+
+/*
+ * Phase 120-02 Wave 2 Task 2 -- verb-dispatch unit tests (D-08 + D-09 + D-10).
+ *
+ * Tests 1-10:
+ *   1. VERB_TO_EVENT lock verbatim (5 entries; 3 emit events; 2 navigational)
+ *   2. dispatchVerb 'Confirm' emits breakthrough_confirmed
+ *   3. dispatchVerb 'Dismiss' captures artifact_ids_at_dismiss (D-13 baseline)
+ *   4. dispatchVerb 'File as decision' emits event AND writes FILED_AS_DECISION edge
+ *   5. dispatchVerb 'Explore deeper' navigational; no event
+ *   6. dispatchVerb 'Back' escape; no event
+ *   7. dispatchVerb unknown verb -> {ok:false, reason:'unknown_verb'}
+ *   8. dispatchVerb flips Breakthrough node properties handled_at + handled_verb
+ *   9. Canon Part 8 source-grep
+ *   10. em-dash HARD RULE
+ */
+
+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 verbDispatch = require(path.join(REPO_ROOT, 'lib', 'core', 'breakthrough', 'verb-dispatch.cjs'));
+const schema = require(path.join(REPO_ROOT, 'lib', 'core', 'breakthrough', 'schema.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 seedArtifact(db, id) {
+  const nowMs = Date.now();
+  db.prepare(
+    "INSERT INTO nodes (id, type, properties, source_path, created_by, review_status, created_at, last_seen_at) " +
+    "VALUES (?, 'artifact', '{}', 'test', 'system', 'confirmed', ?, ?)"
+  ).run(id, nowMs, nowMs);
+}
+
+function seedBreakthrough(db, id, kind, artifactIds, theme) {
+  for (const aid of artifactIds) seedArtifact(db, aid);
+  const r = schema.writeBreakthrough(db, {
+    id: id,
+    kind: kind || 'convergence',
+    confidence: 0.55,
+    artifact_ids: artifactIds,
+    theme: theme || 'test-theme',
+    differential: 0.5,
+    cross_section_linked: false,
+  });
+  assert.equal(r.ok, true, 'seedBreakthrough writeBreakthrough should succeed');
+  return r;
+}
+
+test('120-02 Task 2 Test 1: VERB_TO_EVENT lock verbatim', () => {
+  const m = verbDispatch.VERB_TO_EVENT;
+  assert.equal(m['Explore deeper'], null);
+  assert.equal(m['Confirm'], 'breakthrough_confirmed');
+  assert.equal(m['File as decision'], 'breakthrough_filed_as_decision');
+  assert.equal(m['Dismiss'], 'breakthrough_dismissed');
+  assert.equal(m['Back'], null);
+  // Object.freeze invariant: cannot mutate keys.
+  assert.throws(function () {
+    'use strict';
+    m['Confirm'] = 'breakthrough_other';
+  });
+});
+
+test('120-02 Task 2 Test 2: dispatchVerb Confirm emits breakthrough_confirmed', () => {
+  const { dir, db } = makeTmpDb('p120-02-t2-t2-');
+  seedBreakthrough(db, 'bk:1', 'convergence', ['a1', 'a2']);
+  const r = verbDispatch.dispatchVerb('Confirm', 'bk:1', { db: db });
+  assert.equal(r.ok, true);
+  assert.equal(r.navigational, false);
+  // Verify event landed with breakthrough_id 'bk:1'.
+  const events = navigation.findRecentChanges(db, 0, { eventType: 'breakthrough_confirmed', limit: 10 });
+  assert.equal(events.length, 1);
+  assert.equal(events[0].properties.breakthrough_id, 'bk:1');
+});
+
+test('120-02 Task 2 Test 3: dispatchVerb Dismiss captures artifact_ids_at_dismiss (D-13 baseline)', () => {
+  const { dir, db } = makeTmpDb('p120-02-t2-t3-');
+  seedBreakthrough(db, 'bk:dis', 'convergence', ['a1', 'a2', 'a3']);
+  const r = verbDispatch.dispatchVerb('Dismiss', 'bk:dis', { db: db });
+  assert.equal(r.ok, true);
+  const events = navigation.findRecentChanges(db, 0, { eventType: 'breakthrough_dismissed', limit: 10 });
+  assert.equal(events.length, 1);
+  // The artifact_ids_at_dismiss MUST carry the DERIVED_FROM edge targets at dismiss time.
+  assert.ok(Array.isArray(events[0].properties.artifact_ids_at_dismiss));
+  assert.equal(events[0].properties.artifact_ids_at_dismiss.length, 3);
+  // Set equality on the ids (order may vary depending on edge query).
+  const got = new Set(events[0].properties.artifact_ids_at_dismiss);
+  assert.ok(got.has('a1'));
+  assert.ok(got.has('a2'));
+  assert.ok(got.has('a3'));
+});
+
+test('120-02 Task 2 Test 4: dispatchVerb File as decision emits event AND writes FILED_AS_DECISION edge', () => {
+  const { dir, db } = makeTmpDb('p120-02-t2-t4-');
+  seedBreakthrough(db, 'bk:file', 'convergence', ['a1', 'a2']);
+  // Seed the target Decision node so the FK in the FILED_AS_DECISION edge passes.
+  const nowMs = Date.now();
+  db.prepare(
+    "INSERT INTO nodes (id, type, properties, source_path, created_by, review_status, created_at, last_seen_at) " +
+    "VALUES (?, 'decision', '{}', 'test', 'system', 'proposed', ?, ?)"
+  ).run('decision:bk:file', nowMs, nowMs);
+  const r = verbDispatch.dispatchVerb('File as decision', 'bk:file', { db: db });
+  assert.equal(r.ok, true);
+  // (a) Event landed.
+  const events = navigation.findRecentChanges(db, 0, { eventType: 'breakthrough_filed_as_decision', limit: 10 });
+  assert.equal(events.length, 1);
+  assert.equal(events[0].properties.breakthrough_id, 'bk:file');
+  // (b) FILED_AS_DECISION edge landed.
+  const edges = db.prepare("SELECT source, target, type FROM edges WHERE source = ? AND type = 'FILED_AS_DECISION'").all('bk:file');
+  assert.equal(edges.length, 1);
+  assert.equal(edges[0].target, 'decision:bk:file');
+});
+
+test('120-02 Task 2 Test 5: dispatchVerb Explore deeper navigational; no event', () => {
+  const { dir, db } = makeTmpDb('p120-02-t2-t5-');
+  seedBreakthrough(db, 'bk:ex', 'convergence', ['a1', 'a2']);
+  const r = verbDispatch.dispatchVerb('Explore deeper', 'bk:ex', { db: db });
+  assert.equal(r.ok, true);
+  assert.equal(r.navigational, true);
+  assert.equal(r.drill_target, 'bk:ex');
+  // No memory_event for navigational verbs.
+  const conf = navigation.findRecentChanges(db, 0, { eventType: 'breakthrough_confirmed', limit: 10 });
+  const dism = navigation.findRecentChanges(db, 0, { eventType: 'breakthrough_dismissed', limit: 10 });
+  const file = navigation.findRecentChanges(db, 0, { eventType: 'breakthrough_filed_as_decision', limit: 10 });
+  assert.equal(conf.length, 0);
+  assert.equal(dism.length, 0);
+  assert.equal(file.length, 0);
+});
+
+test('120-02 Task 2 Test 6: dispatchVerb Back escape; no event', () => {
+  const { dir, db } = makeTmpDb('p120-02-t2-t6-');
+  seedBreakthrough(db, 'bk:bk', 'convergence', ['a1', 'a2']);
+  const r = verbDispatch.dispatchVerb('Back', 'bk:bk', { db: db });
+  assert.equal(r.ok, true);
+  assert.equal(r.navigational, true);
+  assert.equal(r.escape, true);
+  const conf = navigation.findRecentChanges(db, 0, { eventType: 'breakthrough_confirmed', limit: 10 });
+  assert.equal(conf.length, 0);
+});
+
+test('120-02 Task 2 Test 7: dispatchVerb unknown verb -> {ok:false, reason:"unknown_verb"}', () => {
+  const { dir, db } = makeTmpDb('p120-02-t2-t7-');
+  const r = verbDispatch.dispatchVerb('foo', 'bk:x', { db: db });
+  assert.equal(r.ok, false);
+  assert.equal(r.reason, 'unknown_verb');
+});
+
+test('120-02 Task 2 Test 8: dispatchVerb Confirm flips Breakthrough node handled_at + handled_verb', () => {
+  const { dir, db } = makeTmpDb('p120-02-t2-t8-');
+  seedBreakthrough(db, 'bk:h', 'convergence', ['a1', 'a2']);
+  verbDispatch.dispatchVerb('Confirm', 'bk:h', { db: db });
+  const row = db.prepare("SELECT properties FROM nodes WHERE id = ? AND type = 'breakthrough'").get('bk:h');
+  assert.ok(row, 'breakthrough node should exist after dispatch');
+  const props = JSON.parse(row.properties);
+  assert.equal(props.handled_verb, 'Confirm');
+  assert.ok(typeof props.handled_at === 'number');
+  assert.ok(props.handled_at > 0);
+});
+
+test('120-02 Task 2 Test 9: Canon Part 8 source-grep -- zero Brain coupling in verb-dispatch.cjs', () => {
+  const src = fs.readFileSync(path.join(REPO_ROOT, 'lib', 'core', 'breakthrough', 'verb-dispatch.cjs'), 'utf8');
+  assert.equal(/require\s*\(\s*['"][^'"]*brain-client[^'"]*['"]\s*\)/.test(src), false,
+    'verb-dispatch.cjs must not require brain-client');
+  assert.equal(/fetch\s*\(\s*['"][^'"]*brain\.mindrian/.test(src), false,
+    'verb-dispatch.cjs must not fetch brain.mindrian.*');
+});
+
+test('120-02 Task 2 Test 10: em-dash HARD RULE -- zero U+2014 in verb-dispatch.cjs', () => {
+  const src = fs.readFileSync(path.join(REPO_ROOT, 'lib', 'core', 'breakthrough', 'verb-dispatch.cjs'), 'utf8');
+  let count = 0;
+  for (const ch of src) {
+    if (ch.charCodeAt(0) === 0x2014) count++;
+  }
+  assert.equal(count, 0, 'verb-dispatch.cjs must contain zero U+2014 em-dash characters');
+});

package/lib/core/breakthrough/voice-scaffold.cjs

@@ -0,0 +1,247 @@
+'use strict';
+// Phase 120-03 Wave 2 Task 1 -- D-17 4-rule voice scaffold + auditor.
+//
+// Per CONTEXT.md D-17 LOCKED VERBATIM (the 4 rules):
+//   Rule 1: Evidence requirement.   Cite artifact ids OR graph edges. Pattern matches:
+//                                   "(artifacts #N, #M)" OR "[[artifact-name]]" OR
+//                                   "(see edges X, Y)".
+//   Rule 2: Mechanism clause.       "by Y" where Y is a user action.
+//   Rule 3: Time anchor.            One of: "in the last N hours/days", "across this
+//                                   week", "since YYYY-MM-DD" or specific weekday, or
+//                                   "today/this morning".
+//   Rule 4: No unbacked superlatives. 'breakthrough', 'biggest', 'first', 'unprecedented',
+//                                   'major', 'massive' MUST NOT appear UNLESS adjacent to
+//                                   a numeric backing. Frequency words 'consistent',
+//                                   'repeated', 'always' MUST be accompanied by a count.
+//
+// The auditor IS the structural enforcement (D-20 meta-principle: every voice claim
+// must be testable from graph state). Plan 120-03 scanner.cjs integration calls
+// auditVoiceLine BEFORE passing the line into the F.7 surface; failed-audit lines are
+// replaced with the structural default which is always auditor-safe.
+//
+// Canon Part 5: evidence is graded by context; the D-17 evidence requirement (rule 1)
+//   maps to the four evidence tiers Academic / Operational / Practitioner / None via
+//   the cite pattern (the cite IS the evidence anchor at this layer).
+// Canon Part 8: pure LOCAL; no Brain coupling; no cross-room aggregation. Pure
+//   function over the breakthrough record + an optional roomState scalar.
+// Canon Part 10 sub-claim 5: the math IS the surface; the voice IS the math's
+//   translation; honesty requires backing.
+//
+// Em-dash HARD RULE (CLAUDE.md feedback_no_emdashes): zero U+2014 in source -- use
+//   the ASCII double-hyphen "--" sequence everywhere.
+
+const VOICE_RULE_NAMES = Object.freeze([
+  'evidence_requirement',
+  'mechanism_clause',
+  'time_anchor',
+  'no_unbacked_superlatives',
+]);
+
+const FORBIDDEN_SUPERLATIVES = Object.freeze([
+  'breakthrough', 'biggest', 'first', 'unprecedented', 'major', 'massive',
+]);
+
+const FREQUENCY_WORDS = Object.freeze([
+  'consistent', 'repeated', 'always',
+]);
+
+// Display names for the 4 detector kinds emitted by Plan 120-00 detectors.cjs.
+// Kept aligned with shape-f7-breakthrough-renderer.cjs::KIND_DISPLAY_NAMES at the
+// human-readable surface (this module uses lowercase phrases since the voice line
+// embeds the kind mid-sentence; the renderer uses TitleCase for the title row).
+const KIND_DISPLAY = Object.freeze({
+  convergence: 'convergence',
+  contradiction_resolved: 'contradiction resolved',
+  cross_domain_analogy: 'cross-domain analogy',
+  reverse_salient_closed: 'closure on a lagging area',
+});
+
+// formatTimeAnchor mirrors the shape-f7-breakthrough-renderer.cjs bucket logic for
+// the title line, but with phrasing tuned for the voice line (mid-sentence). Plan
+// 120-01 renderer uses "in the last hour" / "today" / "this week"; this module
+// matches those for consistency at the audit-pattern level (D-17 rule 3 regex
+// patterns accept the same strings).
+//
+// Buckets (D-06 ethical fence: ages > 14 days surface the date):
+//   ageHours < 1                -> "in the last hour"
+//   ageHours < 8                -> "in the last N hours"
+//   ageHours < 24               -> "today"
+//   ageDays  < 2                -> "in the last day"
+//   ageDays  < 3                -> "in the last two days"
+//   ageDays  < 7                -> "this week"
+//   ageDays  < 14               -> "in the last two weeks"
+//   else                        -> "since YYYY-MM-DD"
+function formatTimeAnchor(detected_at, nowMs) {
+  const now = (typeof nowMs === 'number' && Number.isFinite(nowMs)) ? nowMs : Date.now();
+  const ts = (typeof detected_at === 'number' && Number.isFinite(detected_at)) ? detected_at : now;
+  const ageMs = Math.max(0, now - ts);
+  const ageHours = ageMs / 3600000;
+  const ageDays = ageHours / 24;
+  if (ageHours < 1) return 'in the last hour';
+  if (ageHours < 8) return 'in the last ' + Math.floor(ageHours) + ' hours';
+  if (ageHours < 24) return 'today';
+  if (ageDays < 2) return 'in the last day';
+  if (ageDays < 3) return 'in the last two days';
+  if (ageDays < 7) return 'this week';
+  if (ageDays < 14) return 'in the last two weeks';
+  const d = new Date(ts);
+  const yyyy = d.getUTCFullYear();
+  const mm = String(d.getUTCMonth() + 1).padStart(2, '0');
+  const dd = String(d.getUTCDate()).padStart(2, '0');
+  return 'since ' + yyyy + '-' + mm + '-' + dd;
+}
+
+// Structural default mechanism (D-17 rule 2 satisfaction without LLM/Brain).
+// Honest fallback: cites the user action without inferring intent. Per Canon
+// Part 8: no inferring; only counting.
+function buildDefaultMechanism(artifactCount, _kind) {
+  return 'by adding ' + artifactCount + ' artifacts to this section';
+}
+
+// composeBreakthroughVoiceLine -- THE composer. Pure function over the breakthrough
+// record + an optional roomState (which may carry a roomState.mechanism_phrase
+// that Larry has co-authored with the user, e.g. via a /mos:* command). Returns
+// a single-line string in the canonical D-17 format:
+//   "You're seeing a {kind} on {theme} (artifacts {ids}) -- {mechanism} -- {time_anchor}."
+//
+// Inputs:
+//   breakthrough.kind         -> one of the 4 DETECTOR_TYPES (Plan 120-00)
+//   breakthrough.theme        -> string (sliced to 120 chars at surface layer)
+//   breakthrough.artifact_ids -> string[] (non-empty; D-20 HARD FLOOR upstream)
+//   breakthrough.detected_at  -> number (epoch ms)
+//   roomState                 -> {mechanism_phrase?: string} | null
+//   nowMs                     -> number (epoch ms; for test determinism)
+function composeBreakthroughVoiceLine(breakthrough, roomState, nowMs) {
+  const bk = breakthrough || {};
+  const ids = Array.isArray(bk.artifact_ids)
+    ? bk.artifact_ids.filter((s) => typeof s === 'string' && s.length > 0)
+    : [];
+  const kindKey = (typeof bk.kind === 'string') ? bk.kind : '';
+  const kindDisplay = KIND_DISPLAY[kindKey] || kindKey || 'pattern';
+  const themeRaw = (typeof bk.theme === 'string') ? bk.theme : '';
+  const theme = themeRaw.slice(0, 120);
+  const evidenceCite = '(artifacts ' + ids.join(', ') + ')';
+  const mechanism = (roomState && typeof roomState.mechanism_phrase === 'string' && roomState.mechanism_phrase.length > 0)
+    ? roomState.mechanism_phrase
+    : buildDefaultMechanism(ids.length, kindKey);
+  const timeAnchor = formatTimeAnchor(bk.detected_at || Date.now(), nowMs);
+  const themePart = theme ? ' on ' + theme : '';
+  return "You're seeing a " + kindDisplay + themePart + ' ' + evidenceCite + ' -- ' + mechanism + ' -- ' + timeAnchor + '.';
+}
+
+// --- The 4 rule predicates ---
+// Each is a pure function (string) -> boolean. Together they constitute the
+// auditor's structural enforcement of D-17.
+
+function citeEvidence(line) {
+  // Rule 1: line MUST contain one of:
+  //   (artifacts ...)       -- artifact-id cite
+  //   [[...]]               -- wiki-link cite
+  //   (see edges X, Y)      -- graph-edge cite
+  if (typeof line !== 'string') return false;
+  if (/\(artifacts\s+[^)]+\)/i.test(line)) return true;
+  if (/\[\[[^\]]+\]\]/.test(line)) return true;
+  if (/\(see\s+edges?\s+[^)]+\)/i.test(line)) return true;
+  return false;
+}
+
+function includeMechanism(line) {
+  // Rule 2: line MUST contain "by " followed by a verb phrase. Heuristic: "by "
+  // immediately followed by a word character; rules out "by." standalone.
+  if (typeof line !== 'string') return false;
+  return /\bby\s+\w+/i.test(line);
+}
+
+function anchorTime(line) {
+  // Rule 3: line MUST contain a time-anchor pattern.
+  if (typeof line !== 'string') return false;
+  const patterns = [
+    /in the last\s+\d+\s+(hour|hours|day|days|week|weeks)/i,
+    /in the last\s+(hour|day|two days|week|two weeks)/i,
+    /this (week|morning|month)/i,
+    /\btoday\b|\byesterday\b|\btonight\b/i,
+    /across this week/i,
+    /since\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday|\d{4}-\d{2}-\d{2})/i,
+  ];
+  return patterns.some((p) => p.test(line));
+}
+
+// hasNumericBacking -- a digit alone is too lax (artifact ids like "a1, a2"
+// satisfy a naive /\d/ check while not actually backing the claim). The spec
+// example "the highest differential score (0.78)" shows the intent: a real
+// numeric measurement, typically a decimal/integer in parens, OR a multi-digit
+// number, OR a number followed by a unit/score-word. We accept any of:
+//   (N) or (N.N)            -- parenthesized number (the canonical D-17 form)
+//   N.NN                    -- decimal number (e.g., 0.78)
+//   \d{2,}                  -- multi-digit integer (count/score)
+//   \d+\s*(score|count|sessions|times|days|hours|sigma|sd|%) -- numeric + unit
+function hasNumericBacking(window) {
+  if (/\(\d+(?:\.\d+)?\)/.test(window)) return true;
+  if (/\d+\.\d+/.test(window)) return true;
+  if (/\b\d{2,}\b/.test(window)) return true;
+  if (/\b\d+\s*(score|count|sessions|times|days|hours|sigma|sd|%|x)\b/i.test(window)) return true;
+  return false;
+}
+
+function noUnbackedSuperlatives(line) {
+  // Rule 4: forbidden superlatives MUST NOT appear unless adjacent to numeric
+  // backing (within 60-char window). Frequency words need a count within 30 chars.
+  // "Numeric backing" is stricter than "contains a digit" -- see hasNumericBacking.
+  if (typeof line !== 'string') return true;
+  const lower = line.toLowerCase();
+  for (const word of FORBIDDEN_SUPERLATIVES) {
+    let searchFrom = 0;
+    while (true) {
+      const idx = lower.indexOf(word, searchFrom);
+      if (idx < 0) break;
+      const windowStart = Math.max(0, idx - 60);
+      const windowEnd = Math.min(lower.length, idx + word.length + 60);
+      const window = lower.slice(windowStart, windowEnd);
+      if (!hasNumericBacking(window)) {
+        return false;
+      }
+      searchFrom = idx + word.length;
+    }
+  }
+  for (const word of FREQUENCY_WORDS) {
+    let searchFrom = 0;
+    while (true) {
+      const idx = lower.indexOf(word, searchFrom);
+      if (idx < 0) break;
+      const windowStart = Math.max(0, idx - 30);
+      const windowEnd = Math.min(lower.length, idx + word.length + 30);
+      const window = lower.slice(windowStart, windowEnd);
+      if (!hasNumericBacking(window)) {
+        return false;
+      }
+      searchFrom = idx + word.length;
+    }
+  }
+  return true;
+}
+
+// auditVoiceLine -- the auditor. Pure function (string) -> {ok, violations}.
+// Returns {ok: true, violations: []} when ALL 4 rules pass.
+// Returns {ok: false, violations: [...rule names...]} when one or more fail.
+function auditVoiceLine(line) {
+  const violations = [];
+  if (!citeEvidence(line)) violations.push('evidence_requirement');
+  if (!includeMechanism(line)) violations.push('mechanism_clause');
+  if (!anchorTime(line)) violations.push('time_anchor');
+  if (!noUnbackedSuperlatives(line)) violations.push('no_unbacked_superlatives');
+  return { ok: violations.length === 0, violations: violations };
+}
+
+module.exports = {
+  composeBreakthroughVoiceLine,
+  auditVoiceLine,
+  citeEvidence,
+  includeMechanism,
+  anchorTime,
+  noUnbackedSuperlatives,
+  formatTimeAnchor,
+  VOICE_RULE_NAMES,
+  FORBIDDEN_SUPERLATIVES,
+  FREQUENCY_WORDS,
+  KIND_DISPLAY,
+};