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

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

@@ -0,0 +1,251 @@
+'use strict';
+/*
+ * Phase 120-03 Wave 2 Task 1 -- voice-scaffold unit tests (Tests 1-14).
+ *
+ * Per CONTEXT.md D-17 LOCKED VERBATIM 4-rule voice scaffold:
+ *   Rule 1: Evidence requirement   -- artifact ids OR graph edges cited
+ *   Rule 2: Mechanism clause       -- "by Y" user action
+ *   Rule 3: Time anchor            -- "in the last N hours/days" / "this week" / etc.
+ *   Rule 4: No unbacked superlatives -- 6 forbidden + 3 frequency words guarded
+ *
+ * The auditor IS the structural enforcement (D-20 meta-principle).
+ */
+
+const test = require('node:test');
+const { strict: assert } = require('node:assert');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const SCAFFOLD_PATH = path.resolve(__dirname, 'voice-scaffold.cjs');
+const voiceScaffold = require('./voice-scaffold.cjs');
+const {
+  composeBreakthroughVoiceLine,
+  auditVoiceLine,
+  citeEvidence,
+  includeMechanism,
+  anchorTime,
+  noUnbackedSuperlatives,
+  formatTimeAnchor,
+  VOICE_RULE_NAMES,
+  FORBIDDEN_SUPERLATIVES,
+  FREQUENCY_WORDS,
+  KIND_DISPLAY,
+} = voiceScaffold;
+
+// --- T1: VOICE_RULE_NAMES verbatim ---
+test('T1: VOICE_RULE_NAMES verbatim + Object.freeze invariant', () => {
+  assert.deepEqual(VOICE_RULE_NAMES, [
+    'evidence_requirement',
+    'mechanism_clause',
+    'time_anchor',
+    'no_unbacked_superlatives',
+  ]);
+  assert.equal(VOICE_RULE_NAMES.length, 4);
+  // Object.freeze invariant
+  const before = VOICE_RULE_NAMES.slice();
+  try { VOICE_RULE_NAMES.push('extra'); } catch (_e) { /* strict mode throws */ }
+  assert.deepEqual(VOICE_RULE_NAMES.slice(0, 4), before);
+});
+
+// --- T2: FORBIDDEN_SUPERLATIVES verbatim ---
+test('T2: FORBIDDEN_SUPERLATIVES contains the 6 D-17 rule 4 words verbatim', () => {
+  assert.deepEqual(FORBIDDEN_SUPERLATIVES, [
+    'breakthrough', 'biggest', 'first', 'unprecedented', 'major', 'massive',
+  ]);
+  assert.equal(FORBIDDEN_SUPERLATIVES.length, 6);
+});
+
+// --- T3: composeBreakthroughVoiceLine happy path -- convergence ---
+test('T3: composeBreakthroughVoiceLine produces D-17-compliant line for convergence', () => {
+  const twoDaysAgoMs = Date.now() - 2 * 86400 * 1000;
+  const bk = {
+    kind: 'convergence',
+    theme: 'operator-state machines',
+    artifact_ids: ['art:1', 'art:2', 'art:3', 'art:4'],
+    detected_at: twoDaysAgoMs,
+  };
+  const roomState = {
+    mechanism_phrase: 'by uploading the four notes on Mode A and Mode B',
+  };
+  const line = composeBreakthroughVoiceLine(bk, roomState);
+  assert.match(
+    line,
+    /^You're seeing a convergence on operator-state machines \(artifacts art:1, art:2, art:3, art:4\) -- by uploading the four notes on Mode A and Mode B -- in the last two days\.$/,
+  );
+});
+
+// --- T4: composeBreakthroughVoiceLine default mechanism when roomState absent ---
+test('T4: composeBreakthroughVoiceLine uses structural default mechanism when roomState absent', () => {
+  const bk = {
+    kind: 'convergence',
+    theme: 'X',
+    artifact_ids: ['a1', 'a2', 'a3'],
+    detected_at: Date.now(),
+  };
+  const line = composeBreakthroughVoiceLine(bk, null);
+  // Default: "by adding N artifacts to this section"
+  assert.ok(/by adding 3 artifacts/.test(line),
+    'expected default mechanism with artifact count, got: ' + line);
+  // The default must still pass auditor (rule 2 satisfied)
+  const audit = auditVoiceLine(line);
+  assert.equal(audit.ok, true, 'default-mechanism line must pass auditor, violations: ' + JSON.stringify(audit.violations));
+});
+
+// --- T5: auditVoiceLine -- D-17 rule 1 violation -- no evidence cite ---
+test('T5: auditVoiceLine catches D-17 rule 1 violation (no evidence cite)', () => {
+  const bad = "You're seeing a convergence on X -- by uploading -- in the last two days.";
+  const r = auditVoiceLine(bad);
+  assert.equal(r.ok, false);
+  assert.ok(r.violations.indexOf('evidence_requirement') >= 0,
+    'expected evidence_requirement violation, got: ' + JSON.stringify(r.violations));
+});
+
+// --- T6: auditVoiceLine -- D-17 rule 2 violation -- no mechanism ---
+test('T6: auditVoiceLine catches D-17 rule 2 violation (no mechanism)', () => {
+  const bad = "You're seeing a convergence on X (artifacts a1, a2, a3) -- in the last two days.";
+  const r = auditVoiceLine(bad);
+  assert.equal(r.ok, false);
+  assert.ok(r.violations.indexOf('mechanism_clause') >= 0,
+    'expected mechanism_clause violation, got: ' + JSON.stringify(r.violations));
+});
+
+// --- T7: auditVoiceLine -- D-17 rule 3 violation -- no time anchor ---
+test('T7: auditVoiceLine catches D-17 rule 3 violation (no time anchor)', () => {
+  const bad = "You're seeing a convergence on X (artifacts a1, a2, a3) -- by uploading the notes.";
+  const r = auditVoiceLine(bad);
+  assert.equal(r.ok, false);
+  assert.ok(r.violations.indexOf('time_anchor') >= 0,
+    'expected time_anchor violation, got: ' + JSON.stringify(r.violations));
+});
+
+// --- T8: auditVoiceLine -- D-17 rule 4 violation -- unbacked superlative ---
+test('T8: auditVoiceLine catches D-17 rule 4 violation (unbacked superlative)', () => {
+  const bad = "You're seeing the BIGGEST breakthrough on X (artifacts a1, a2, a3) -- by uploading -- in the last hour.";
+  const r = auditVoiceLine(bad);
+  assert.equal(r.ok, false);
+  assert.ok(r.violations.indexOf('no_unbacked_superlatives') >= 0,
+    'expected no_unbacked_superlatives violation, got: ' + JSON.stringify(r.violations));
+});
+
+// --- T9: auditVoiceLine -- D-17 rule 4 SATISFIED with numeric backing ---
+test('T9: auditVoiceLine accepts D-17 rule 4 when superlative has numeric backing', () => {
+  const good = "You're seeing a convergence on X (artifacts a1, a2, a3) -- by uploading -- in the last hour. This is the highest differential score (0.78) in this room's history.";
+  const r = auditVoiceLine(good);
+  assert.equal(r.ok, true,
+    'expected no violations, got: ' + JSON.stringify(r.violations));
+});
+
+// --- T10: auditVoiceLine happy path passes all 4 rules ---
+test('T10: auditVoiceLine passes for T3-composed convergence line', () => {
+  const twoDaysAgoMs = Date.now() - 2 * 86400 * 1000;
+  const bk = {
+    kind: 'convergence',
+    theme: 'operator-state machines',
+    artifact_ids: ['art:1', 'art:2', 'art:3', 'art:4'],
+    detected_at: twoDaysAgoMs,
+  };
+  const roomState = {
+    mechanism_phrase: 'by uploading the four notes on Mode A and Mode B',
+  };
+  const line = composeBreakthroughVoiceLine(bk, roomState);
+  const r = auditVoiceLine(line);
+  assert.equal(r.ok, true,
+    'composer + auditor must be aligned, violations: ' + JSON.stringify(r.violations));
+  assert.deepEqual(r.violations, []);
+});
+
+// --- T11: auditVoiceLine -- multiple violations reported ---
+test('T11: auditVoiceLine reports multiple violations on maximally bad line', () => {
+  const veryBad = "You're seeing a convergence on X.";
+  const r = auditVoiceLine(veryBad);
+  assert.equal(r.ok, false);
+  // expect at least 3 violations: evidence, mechanism, time_anchor (no superlative present so rule 4 OK)
+  assert.ok(r.violations.indexOf('evidence_requirement') >= 0);
+  assert.ok(r.violations.indexOf('mechanism_clause') >= 0);
+  assert.ok(r.violations.indexOf('time_anchor') >= 0);
+  assert.ok(r.violations.length >= 3);
+});
+
+// --- T12: composeBreakthroughVoiceLine for EVERY kind passes auditor ---
+test('T12: composeBreakthroughVoiceLine output passes auditor for every kind', () => {
+  const kinds = [
+    'convergence',
+    'contradiction_resolved',
+    'cross_domain_analogy',
+    'reverse_salient_closed',
+  ];
+  for (const kind of kinds) {
+    const bk = {
+      kind: kind,
+      theme: 'sample-theme',
+      artifact_ids: ['art:1', 'art:2', 'art:3'],
+      detected_at: Date.now() - 6 * 3600 * 1000, // 6 hours ago
+    };
+    const line = composeBreakthroughVoiceLine(bk, null);
+    const r = auditVoiceLine(line);
+    assert.equal(r.ok, true,
+      'kind ' + kind + ': composer output failed audit, line: ' + line + ', violations: ' + JSON.stringify(r.violations));
+  }
+});
+
+// --- T13: Canon Part 8 source-grep -- zero Brain coupling ---
+test('T13: Canon Part 8 source-grep -- voice-scaffold.cjs has zero Brain coupling', () => {
+  const src = fs.readFileSync(SCAFFOLD_PATH, 'utf8');
+  // brain-client require
+  assert.ok(!/require\(.+brain-client/.test(src),
+    'voice-scaffold must not require brain-client');
+  // direct fetch to brain.mindrian
+  assert.ok(!/fetch.+brain\.mindrian/.test(src),
+    'voice-scaffold must not fetch brain.mindrian');
+  // cross-room aggregation
+  assert.ok(!/cross-room/i.test(src.split('\n').filter(l => !l.match(/^\s*\/\//)).join('\n')) ||
+    src.indexOf('Canon Part 8') >= 0,
+    'cross-room mentions require Canon Part 8 context comment');
+});
+
+// --- T14: em-dash invariant ---
+test('T14: zero U+2014 em-dashes in voice-scaffold.cjs', () => {
+  const src = fs.readFileSync(SCAFFOLD_PATH, 'utf8');
+  const idx = src.indexOf('—');
+  assert.equal(idx, -1, 'em-dash found at index ' + idx);
+});
+
+// --- Bonus: formatTimeAnchor buckets ---
+test('T15: formatTimeAnchor returns expected buckets', () => {
+  const now = Date.now();
+  assert.equal(formatTimeAnchor(now - 30 * 60 * 1000, now), 'in the last hour');
+  assert.equal(formatTimeAnchor(now - 4 * 3600 * 1000, now), 'in the last 4 hours');
+  assert.equal(formatTimeAnchor(now - 12 * 3600 * 1000, now), 'today');
+  assert.equal(formatTimeAnchor(now - 36 * 3600 * 1000, now), 'in the last day');
+  assert.equal(formatTimeAnchor(now - 2 * 86400 * 1000, now), 'in the last two days');
+  assert.equal(formatTimeAnchor(now - 5 * 86400 * 1000, now), 'this week');
+  assert.equal(formatTimeAnchor(now - 10 * 86400 * 1000, now), 'in the last two weeks');
+});
+
+// --- Bonus: rule predicates exposed ---
+test('T16: rule predicates exposed individually for unit-level testing', () => {
+  assert.equal(typeof citeEvidence, 'function');
+  assert.equal(typeof includeMechanism, 'function');
+  assert.equal(typeof anchorTime, 'function');
+  assert.equal(typeof noUnbackedSuperlatives, 'function');
+  // citeEvidence positive cases
+  assert.equal(citeEvidence('foo (artifacts a1, a2)'), true);
+  assert.equal(citeEvidence('foo [[wiki-link]]'), true);
+  assert.equal(citeEvidence('foo (see edges X, Y)'), true);
+  // citeEvidence negative
+  assert.equal(citeEvidence('foo bar baz'), false);
+});
+
+// --- Bonus: FREQUENCY_WORDS exposed ---
+test('T17: FREQUENCY_WORDS exposed verbatim', () => {
+  assert.deepEqual(FREQUENCY_WORDS, ['consistent', 'repeated', 'always']);
+});
+
+// --- Bonus: KIND_DISPLAY exposed ---
+test('T18: KIND_DISPLAY exposed with the 4 detector kinds', () => {
+  assert.equal(typeof KIND_DISPLAY, 'object');
+  assert.ok(KIND_DISPLAY.convergence);
+  assert.ok(KIND_DISPLAY.contradiction_resolved);
+  assert.ok(KIND_DISPLAY.cross_domain_analogy);
+  assert.ok(KIND_DISPLAY.reverse_salient_closed);
+});

package/lib/core/first-touch-version-stamper.cjs

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * first-touch-version-stamper.cjs
+ * --------------------------------
+ * Phase 121.5-05 Sub-plan F (SEED-007 absorption).
+ *
+ * Pure function module that returns the canonical version stamp for each
+ * first-touch surface (banner / splash / onboard / sessionstart /
+ * operator-update / larry-extended). The string the user sees -- "MindrianOS
+ * v<version>" -- is derived once, here, so the per-surface emission stays in
+ * lock-step with .claude-plugin/plugin.json.
+ *
+ * Source finding (SEED-007, 2026-05-09): a v1.12.0 "Three ways to do this"
+ * greeting was rendering on a stale Windows install with NO version-of-record
+ * visible. The user could not answer "what version am I running?" by LOOKING
+ * at the terminal. This module is the canonical answer to that question.
+ *
+ * Canon Part 7 (Reuse Before Build): the version-of-record source is
+ * .claude-plugin/plugin.json -- the same one scripts/banner already reads via
+ * lib/core/platform.cjs::readPluginJsonVersion. This module wraps that source
+ * with the per-surface rendering contract; it does NOT introduce a second
+ * version-of-record surface.
+ *
+ * Canon Part 8: local-only; no fetch, no Brain, no telemetry egress.
+ *
+ * No emoji. No em-dashes. ASCII-clean source.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const SURFACES_PATH = path.join(__dirname, '..', '..', 'data', 'first-touch-surfaces.json');
+const PLUGIN_JSON_PATH = path.join(__dirname, '..', '..', '.claude-plugin', 'plugin.json');
+
+const KNOWN_SURFACES = new Set([
+  'banner',
+  'splash',
+  'onboard',
+  'sessionstart',
+  'operator-update',
+  'larry-extended',
+]);
+
+function readSurfaces() {
+  return JSON.parse(fs.readFileSync(SURFACES_PATH, 'utf8'));
+}
+
+function resolveCurrentVersion() {
+  try {
+    return JSON.parse(fs.readFileSync(PLUGIN_JSON_PATH, 'utf8')).version;
+  } catch (_e) {
+    return 'unknown';
+  }
+}
+
+function stampVersion(surfaceId, version) {
+  if (!KNOWN_SURFACES.has(surfaceId)) {
+    throw new Error('unknown_surface: ' + surfaceId);
+  }
+  const v = version || resolveCurrentVersion();
+  switch (surfaceId) {
+    case 'banner':
+      return 'MindrianOS v' + v;
+    case 'splash':
+      return 'MindrianOS v' + v + ' -- conversation as the product surface';
+    case 'onboard':
+      return 'Welcome to MindrianOS v' + v + '. Let me show you around.';
+    case 'sessionstart':
+    case 'operator-update':
+    case 'larry-extended':
+      return 'MindrianOS v' + v;
+    default:
+      // unreachable: KNOWN_SURFACES gates entry
+      throw new Error('unknown_surface: ' + surfaceId);
+  }
+}
+
+// U+2014 EM DASH detector -- the no-em-dash hard rule scanner uses this
+// (CLAUDE.md / MEMORY feedback_no_emdashes). Written as an escape so this
+// source file stays ASCII-clean.
+const EM_DASH = '\u2014';
+
+function hasEmDash(text) {
+  return typeof text === 'string' && text.indexOf(EM_DASH) >= 0;
+}
+
+module.exports = {
+  stampVersion,
+  resolveCurrentVersion,
+  readSurfaces,
+  hasEmDash,
+  KNOWN_SURFACES,
+};
+
+// Allow CLI invocation: `node lib/core/first-touch-version-stamper.cjs banner`
+if (require.main === module) {
+  const surfaceArg = process.argv[2];
+  if (!surfaceArg) {
+    process.stdout.write(stampVersion('banner') + '\n');
+    process.exit(0);
+  }
+  try {
+    process.stdout.write(stampVersion(surfaceArg) + '\n');
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write('first-touch-version-stamper: ' + e.message + '\n');
+    process.exit(2);
+  }
+}

package/lib/core/larry-thinness-acknowledgment.cjs

@@ -0,0 +1,64 @@
+'use strict';
+/*
+ * Phase 119-02 -- Larry thinness-acknowledgment voice + thin-finding detector.
+ *
+ * Per CONTEXT.md D-05: when Phase 117's composeAutoExploreFinding returns
+ * thin output (null OR <= 1 finding), the room is still scaffolded but
+ * Larry's voice acknowledges thinness honestly via the verbatim copy below.
+ *
+ * The verbatim copy is LOCKED per .planning/phases/119-room-as-receipt-invariant/
+ * 119-02-PLAN.md objective block (lines 89-93). Do NOT paraphrase.
+ *
+ * Em-dash HARD RULE: uses `--` (two ASCII hyphens) NEVER `-` (U+2014).
+ * Smart-quote BAN: uses ASCII apostrophe `'` (0x27) only -- never `’`.
+ *
+ * Canon Part 8 invariant: pure-local module; no Brain call, no telemetry
+ * egress; the voice line is a static string with zero outbound surface.
+ * Canon Part 10 sub-claim 1: Larry IS the product -- the voice line is
+ * the conversational anchor that makes "rooms are receipts" feel honest
+ * rather than apologetic when the source material is thin (D-05).
+ */
+
+// The verbatim D-05 voice line. Locked per the plan. Length: 152 chars (ASCII).
+// Composed via two string literals (concat) for readability; the runtime
+// value is one continuous string.
+const THINNESS_VOICE_LINE =
+  "I made a room around this -- it's mostly empty until we have more to work with. " +
+  "Want to keep going and see what fills in?";
+
+/**
+ * Decide whether the room should surface the thinness acknowledgment to the user.
+ *
+ * Per .planning/phases/119-room-as-receipt-invariant/119-02-PLAN.md Task 1
+ * <behavior> Test 6: D-05 threshold is "2+ findings = substantive; <=1 finding
+ * = thin". The detector treats null / undefined / non-object / missing
+ * findings array / empty findings array / single-finding all as thin.
+ *
+ * @param {object|null} autoExploreFinding  the JSON shape Phase 117 writes
+ *                                          to .mindrian/auto-explore-<material_id>.json
+ *                                          (shape: { material_id, findings: [...], composed_at_ms })
+ * @returns {boolean}  true if Larry should render the thinness voice line
+ */
+function shouldAcknowledgeThinness(autoExploreFinding) {
+  if (autoExploreFinding === null || autoExploreFinding === undefined) return true;
+  if (typeof autoExploreFinding !== 'object') return true;
+  const findings = Array.isArray(autoExploreFinding.findings) ? autoExploreFinding.findings : [];
+  return findings.length <= 1;
+}
+
+/**
+ * Return the verbatim D-05 thinness voice line. Single source of truth -- callers
+ * MUST use this function (or the THINNESS_VOICE_LINE constant) rather than
+ * inlining the string. This avoids cross-file string drift.
+ *
+ * @returns {string}  the locked verbatim voice line
+ */
+function voiceLine() {
+  return THINNESS_VOICE_LINE;
+}
+
+module.exports = {
+  THINNESS_VOICE_LINE: THINNESS_VOICE_LINE,
+  shouldAcknowledgeThinness: shouldAcknowledgeThinness,
+  voiceLine: voiceLine,
+};

package/lib/core/larry-thinness-acknowledgment.test.cjs

@@ -0,0 +1,97 @@
+'use strict';
+/*
+ * Phase 119-02 Task 1 -- test suite for larry-thinness-acknowledgment.cjs.
+ *
+ * Verifies (per CONTEXT.md D-05 verbatim copy lock + the 11 behavior tests in
+ * .planning/phases/119-room-as-receipt-invariant/119-02-PLAN.md Task 1):
+ *   1. THINNESS_VOICE_LINE returns exact verbatim string.
+ *   2. voiceLine() returns the same string as THINNESS_VOICE_LINE.
+ *   3. shouldAcknowledgeThinness(null) -> true.
+ *   4. shouldAcknowledgeThinness({findings:[]}) -> true.
+ *   5. shouldAcknowledgeThinness({findings:[a,b]}) -> false (substantive).
+ *   6. shouldAcknowledgeThinness({findings:[a]}) -> true (D-05 threshold 2+).
+ *   7-10. Template files exist + valid frontmatter (verified by Task 2 + bash gate).
+ *   11. No smart quotes / em-dashes in the verbatim string (ASCII only).
+ */
+
+const assert = require('node:assert');
+const test = require('node:test');
+
+const {
+  THINNESS_VOICE_LINE,
+  shouldAcknowledgeThinness,
+  voiceLine,
+} = require('./larry-thinness-acknowledgment.cjs');
+
+const EXPECTED =
+  "I made a room around this -- it's mostly empty until we have more to work with. " +
+  "Want to keep going and see what fills in?";
+
+test('Test 1: THINNESS_VOICE_LINE is the verbatim D-05 string', () => {
+  assert.strictEqual(THINNESS_VOICE_LINE, EXPECTED);
+});
+
+test('Test 2: voiceLine() returns same string as THINNESS_VOICE_LINE (single source of truth)', () => {
+  assert.strictEqual(voiceLine(), THINNESS_VOICE_LINE);
+});
+
+test('Test 3: shouldAcknowledgeThinness(null) returns true', () => {
+  assert.strictEqual(shouldAcknowledgeThinness(null), true);
+});
+
+test('Test 4: shouldAcknowledgeThinness(undefined) returns true', () => {
+  assert.strictEqual(shouldAcknowledgeThinness(undefined), true);
+});
+
+test('Test 5: shouldAcknowledgeThinness({findings: []}) returns true (empty findings)', () => {
+  assert.strictEqual(shouldAcknowledgeThinness({ findings: [] }), true);
+});
+
+test('Test 6: shouldAcknowledgeThinness({findings: [a, b]}) returns false (substantive, 2+ findings)', () => {
+  const finding = {
+    findings: [
+      { source_pipeline: 'whitespace', hsi_score: 0.7 },
+      { source_pipeline: 'cross-domain', hsi_score: 0.6 },
+    ],
+  };
+  assert.strictEqual(shouldAcknowledgeThinness(finding), false);
+});
+
+test('Test 7: shouldAcknowledgeThinness({findings: [a]}) returns true (1-finding edge case, D-05 threshold)', () => {
+  const finding = {
+    findings: [{ source_pipeline: 'whitespace', hsi_score: 0.3 }],
+  };
+  assert.strictEqual(shouldAcknowledgeThinness(finding), true);
+});
+
+test('Test 8: shouldAcknowledgeThinness on non-object returns true (defensive)', () => {
+  assert.strictEqual(shouldAcknowledgeThinness('not an object'), true);
+  assert.strictEqual(shouldAcknowledgeThinness(42), true);
+});
+
+test('Test 9: shouldAcknowledgeThinness on object without findings array returns true', () => {
+  assert.strictEqual(shouldAcknowledgeThinness({}), true);
+  assert.strictEqual(shouldAcknowledgeThinness({ findings: null }), true);
+});
+
+test('Test 10: THINNESS_VOICE_LINE has no em-dash (em-dash HARD RULE)', () => {
+  // Construct via charCode so this test source itself contains no literal
+  // em-dash (which would self-trip the shell-harness em-dash invariant).
+  const EMDASH = String.fromCharCode(0x2014);
+  assert.strictEqual(THINNESS_VOICE_LINE.indexOf(EMDASH), -1, 'em-dash U+2014 present');
+});
+
+test('Test 11: THINNESS_VOICE_LINE has no smart-quote characters (ASCII only)', () => {
+  // Right single quote U+2019, left single quote U+2018, right double U+201D, left double U+201C
+  assert.strictEqual(THINNESS_VOICE_LINE.indexOf('’'), -1, 'right single quote U+2019 present');
+  assert.strictEqual(THINNESS_VOICE_LINE.indexOf('‘'), -1, 'left single quote U+2018 present');
+  assert.strictEqual(THINNESS_VOICE_LINE.indexOf('”'), -1, 'right double quote U+201D present');
+  assert.strictEqual(THINNESS_VOICE_LINE.indexOf('“'), -1, 'left double quote U+201C present');
+});
+
+test('Test 12: THINNESS_VOICE_LINE contains the locked phrase fragments', () => {
+  assert.ok(THINNESS_VOICE_LINE.includes('I made a room around this'), 'opener missing');
+  assert.ok(THINNESS_VOICE_LINE.includes("it's mostly empty"), 'middle (ASCII apostrophe) missing');
+  assert.ok(THINNESS_VOICE_LINE.includes('Want to keep going'), 'continuation invite missing');
+  assert.ok(THINNESS_VOICE_LINE.includes('see what fills in?'), 'closing question missing');
+});