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

package/lib/memory/body-shape-coverage.test.cjs

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 121.5-01 Task 2 -- Body-shape coverage acceptance tests.
+ *
+ * Verifies scripts/audit-body-shape-coverage.cjs and output-styles/destijl.md.
+ * The audit script is the CI tripwire that scans commands/*.md frontmatter for
+ * body_shape: presence and a valid value from the locked vocabulary. The
+ * output style is the system-prompt-enforced 4-zone De Stijl format that lifts
+ * SKILL.md from skill-instruction-suggested to force-for-plugin-enforced.
+ *
+ * Canon references:
+ *   Part 3 UI Ruling System -- this test enforces the body_shape contract
+ *           that the ruling system depends on.
+ *   Part 7 Reuse Before Build -- no new commands are created; this is a
+ *           pure compliance + infrastructure pass.
+ *   Part 8 Graph Boundary -- audit script + output style add zero network
+ *           surface, zero Brain calls, zero telemetry egress.
+ *
+ * Test map (7 cases, one-to-one with PLAN Task 2 <behavior>):
+ *
+ *   1.  output-styles/destijl.md exists and parses as valid YAML frontmatter
+ *       + markdown body.
+ *   2.  Frontmatter contains exactly `force-for-plugin: true` AND
+ *       `keep-coding-instructions: true` (literal string match).
+ *   3.  Body documents the four zones in fixed order matching SKILL.md
+ *       Section 1: Header Panel / Content Body / Intelligence Strip /
+ *       Action Footer.
+ *   4.  Body documents the 5+2 body shapes (A, B, C, D, E + F family)
+ *       mapping to the SKILL.md Section 2 vocabulary.
+ *   5.  scripts/audit-body-shape-coverage.cjs exits 0 against the live
+ *       commands/ directory (post-Task-1 state). Exits 1 against a
+ *       synthetic fixture with a command missing body_shape:.
+ *   6.  The audit script reports per-category counts (A / B / C / D / E /
+ *       F.x / methodology) in --json mode.
+ *   7.  Every body_shape: value in commands/*.md is one of the locked
+ *       vocabulary {A, B, C, D, E, F.0..F.6, methodology}. The audit
+ *       script flags any other value.
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const REPO = path.resolve(__dirname, '..', '..');
+const DESTIJL_PATH = path.join(REPO, 'output-styles', 'destijl.md');
+const AUDIT_PATH = path.join(REPO, 'scripts', 'audit-body-shape-coverage.cjs');
+const COMMANDS_DIR = path.join(REPO, 'commands');
+
+// ---------- Fixture helpers ----------
+
+const TMP_ROOTS = [];
+function mkTmp(prefix) {
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  TMP_ROOTS.push(d);
+  return d;
+}
+process.on('exit', () => {
+  for (const d of TMP_ROOTS) {
+    try { fs.rmSync(d, { recursive: true, force: true }); } catch (_) {}
+  }
+});
+
+function readDestijl() {
+  return fs.readFileSync(DESTIJL_PATH, 'utf8');
+}
+
+function loadAudit() {
+  try { delete require.cache[require.resolve(AUDIT_PATH)]; } catch (_) {}
+  return require(AUDIT_PATH);
+}
+
+// Run audit script as a subprocess (mirrors how CI will invoke it).
+// Returns { code, stdout, stderr }.
+function runAudit(args, env) {
+  const result = { code: 0, stdout: '', stderr: '' };
+  try {
+    result.stdout = execFileSync('node', [AUDIT_PATH, ...(args || [])], {
+      env: Object.assign({}, process.env, env || {}),
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+  } catch (e) {
+    result.code = (e && typeof e.status === 'number') ? e.status : 1;
+    result.stdout = (e && e.stdout) ? e.stdout.toString() : '';
+    result.stderr = (e && e.stderr) ? e.stderr.toString() : '';
+  }
+  return result;
+}
+
+// ---------- Tests ----------
+
+let passed = 0;
+let failed = 0;
+const failures = [];
+
+function test(name, fn) {
+  try {
+    fn();
+    passed++;
+    console.log('  ok  ' + name);
+  } catch (e) {
+    failed++;
+    failures.push({ name, error: e });
+    console.log('  FAIL  ' + name);
+    console.log('         ' + (e && e.message ? e.message : String(e)));
+  }
+}
+
+console.log('Phase 121.5-01 Task 2 -- body-shape-coverage acceptance suite');
+console.log('');
+
+// Test 1: destijl.md exists and parses
+test('Test 1: output-styles/destijl.md exists with frontmatter + body', () => {
+  assert.ok(fs.existsSync(DESTIJL_PATH), 'output-styles/destijl.md missing');
+  const text = readDestijl();
+  const fm = text.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  assert.ok(fm, 'destijl.md does not parse as frontmatter + body');
+  assert.ok(fm[1].length > 0, 'frontmatter is empty');
+  assert.ok(fm[2].length > 100, 'body is too short (< 100 chars)');
+});
+
+// Test 2: force-for-plugin + keep-coding-instructions present
+test('Test 2: frontmatter has force-for-plugin: true AND keep-coding-instructions: true', () => {
+  const text = readDestijl();
+  const fm = text.match(/^---\n([\s\S]*?)\n---/);
+  assert.ok(fm, 'no frontmatter found');
+  assert.ok(/^force-for-plugin:\s*true\s*$/m.test(fm[1]),
+    'force-for-plugin: true not found in frontmatter');
+  assert.ok(/^keep-coding-instructions:\s*true\s*$/m.test(fm[1]),
+    'keep-coding-instructions: true not found in frontmatter');
+});
+
+// Test 3: 4 zones documented in fixed order
+test('Test 3: body documents 4 zones in SKILL.md Section 1 order', () => {
+  const text = readDestijl();
+  const idxHeader = text.indexOf('Header Panel');
+  const idxBody = text.indexOf('Content Body');
+  const idxStrip = text.indexOf('Intelligence Strip');
+  const idxFooter = text.indexOf('Action Footer');
+  assert.ok(idxHeader > 0, 'Header Panel zone not documented');
+  assert.ok(idxBody > idxHeader, 'Content Body must come after Header Panel');
+  assert.ok(idxStrip > idxBody, 'Intelligence Strip must come after Content Body');
+  assert.ok(idxFooter > idxStrip, 'Action Footer must come after Intelligence Strip');
+});
+
+// Test 4: 5+2 body shapes documented
+test('Test 4: body documents shapes A, B, C, D, E + F family + methodology', () => {
+  const text = readDestijl();
+  // Each shape letter must appear in the shape table or shape documentation.
+  // Use regex to find the shape table row pattern: "| <letter> |" or "Shape <letter>".
+  for (const shape of ['A', 'B', 'C', 'D', 'E']) {
+    const re = new RegExp('(\\|\\s*' + shape + '\\s*\\||Shape\\s+' + shape + '\\b)');
+    assert.ok(re.test(text), 'Shape ' + shape + ' not documented in body');
+  }
+  // F family members
+  for (const fSub of ['F.0', 'F.1', 'F.2', 'F.3', 'F.4', 'F.5', 'F.6']) {
+    const re = new RegExp('\\b' + fSub.replace('.', '\\.') + '\\b');
+    assert.ok(re.test(text), fSub + ' not documented in body');
+  }
+  assert.ok(/methodology/i.test(text), 'methodology not documented in body');
+});
+
+// Test 5a: audit script exits 0 against live commands/ (post-Task-1 state)
+test('Test 5a: audit exits 0 against live commands/ (100% coverage)', () => {
+  assert.ok(fs.existsSync(AUDIT_PATH), 'audit script missing');
+  const r = runAudit([]);
+  if (r.code !== 0) {
+    console.log('         stdout: ' + r.stdout);
+    console.log('         stderr: ' + r.stderr);
+  }
+  assert.strictEqual(r.code, 0, 'audit script exited non-zero on live repo');
+});
+
+// Test 5b: audit exits 1 on synthetic fixture missing body_shape
+test('Test 5b: audit exits 1 on synthetic command missing body_shape', () => {
+  const tmp = mkTmp('body-shape-audit-');
+  const cmdsDir = path.join(tmp, 'commands');
+  fs.mkdirSync(cmdsDir, { recursive: true });
+  // Good file
+  fs.writeFileSync(path.join(cmdsDir, 'good.md'),
+    '---\nname: good\ndescription: test\nbody_shape: A\n---\n# good\n');
+  // Bad file (missing body_shape)
+  fs.writeFileSync(path.join(cmdsDir, 'bad.md'),
+    '---\nname: bad\ndescription: test\n---\n# bad\n');
+
+  // Audit accepts a --dir override.
+  const r = runAudit(['--dir', cmdsDir]);
+  assert.notStrictEqual(r.code, 0,
+    'audit must fail when a command is missing body_shape (got exit 0)');
+});
+
+// Test 6: --json mode reports per-category counts
+test('Test 6: --json mode reports histogram per category', () => {
+  const r = runAudit(['--json']);
+  assert.strictEqual(r.code, 0, 'audit --json exited non-zero');
+  let parsed;
+  try {
+    parsed = JSON.parse(r.stdout);
+  } catch (e) {
+    assert.fail('--json output not valid JSON: ' + e.message);
+  }
+  assert.ok(parsed && typeof parsed === 'object', '--json must emit object');
+  assert.ok(typeof parsed.total === 'number', 'total missing in --json output');
+  assert.ok(parsed.histogram && typeof parsed.histogram === 'object',
+    'histogram missing in --json output');
+  // At least 3 distinct shape categories should appear in a healthy repo
+  // (proves the sweep is a spread, not a monoculture).
+  const keys = Object.keys(parsed.histogram);
+  assert.ok(keys.length >= 3,
+    'histogram has < 3 distinct shapes -- monoculture detected: ' + keys.join(','));
+});
+
+// Test 7: all body_shape values in live repo are in the locked vocabulary
+test('Test 7: every body_shape value in commands/*.md is in locked vocab', () => {
+  const { VALID_SHAPES } = loadAudit();
+  assert.ok(VALID_SHAPES && typeof VALID_SHAPES.has === 'function',
+    'audit must export VALID_SHAPES Set');
+  // Sanity-check the vocabulary itself
+  for (const v of ['A', 'B', 'C', 'D', 'E',
+                   'F.0', 'F.1', 'F.2', 'F.3', 'F.4', 'F.5', 'F.6',
+                   'methodology']) {
+    assert.ok(VALID_SHAPES.has(v), 'VALID_SHAPES missing required value: ' + v);
+  }
+  // Now scan live commands and validate each
+  const files = fs.readdirSync(COMMANDS_DIR).filter(f => f.endsWith('.md'));
+  const offenders = [];
+  for (const f of files) {
+    const text = fs.readFileSync(path.join(COMMANDS_DIR, f), 'utf8');
+    const fm = text.match(/^---\n([\s\S]*?)\n---/);
+    if (!fm) { offenders.push(f + ' (no frontmatter)'); continue; }
+    const m = fm[1].match(/^body_shape:\s*(.+)$/m);
+    if (!m) { offenders.push(f + ' (no body_shape)'); continue; }
+    // Strip trailing parenthetical (e.g. "B (Semantic Tree)" -> "B")
+    let v = m[1].trim().replace(/\s*\(.*\)\s*$/, '');
+    // Strip surrounding quotes if present
+    v = v.replace(/^['"]|['"]$/g, '');
+    if (!VALID_SHAPES.has(v)) {
+      offenders.push(f + ' = "' + m[1].trim() + '" (extracted: "' + v + '")');
+    }
+  }
+  if (offenders.length) {
+    assert.fail('commands with invalid body_shape values:\n  ' + offenders.join('\n  '));
+  }
+});
+
+// ---------- Summary ----------
+
+console.log('');
+console.log('========================================');
+console.log('Tests: ' + (passed + failed) + ' total, ' + passed + ' passed, ' + failed + ' failed');
+console.log('========================================');
+
+if (failed > 0) {
+  console.log('');
+  console.log('Failures:');
+  for (const f of failures) {
+    console.log('  - ' + f.name);
+  }
+  process.exit(1);
+}
+
+process.exit(0);

package/lib/memory/brain-derivation-graceful-degradation.test.cjs

@@ -620,8 +620,8 @@ async function main() {
   //         category); no BRAIN.md; no tmpfile.
   await runScenario('Scenario 07: Network partition', async function () {
     installMockBrainClient({
-      query: function () { throw new Error('ECONNREFUSED brain.mindrian.ai:443'); },
-      search: function () { throw new Error('ECONNREFUSED brain.mindrian.ai:443'); },
+      query: function () { throw new Error('ECONNREFUSED mindrian-brain.onrender.com:443'); },
+      search: function () { throw new Error('ECONNREFUSED mindrian-brain.onrender.com:443'); },
     });
     const { sections } = buildRoom({ tag: 's07', count: 1 });
     const s = sections[0];

package/lib/memory/doctor-deprecation-surface.test.cjs

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+/*
+ * Phase 121.5-08 Plan Task 2 -- doctor class I (deprecated-usage surface)
+ * + F.1 selector wiring on onboard Step 6 + diagnose recommendation.
+ *
+ * Behavior contract (per plan):
+ *   T1: scripts/doctor.cjs --deprecated-usage detects synthetic usage in temp
+ *       transcript fixtures (a temp ~/.claude/projects/.../session.jsonl-like
+ *       fixture mentioning "/mos:heal" -- the class I detector picks it up).
+ *   T2: Class I returns {class: 'I', status, action, deprecated_uses: []}.
+ *   T3: --deprecated-usage exits 0 when no deprecated commands used; exits 1
+ *       when violations found.
+ *   T4: doctor --all includes class I in the cascade.
+ *   T5: commands/onboard.md Step 6 body contains the canonical F.1 selector
+ *       vocabulary (Run Methodology / Defer / Free-Text).
+ *   T6: commands/diagnose.md recommendation block contains the canonical F.1
+ *       selector vocabulary.
+ *   T7: CHANGELOG.md has an Unreleased / next-beta entry listing all 5
+ *       renames + the /mos:mos creation + the F.1 wiring + the class I add.
+ *
+ * Hermetic: uses fs.mkdtempSync for synthetic transcript fixture (T1). The
+ * doctor invocation spawns scripts/doctor.cjs as a subprocess with the
+ * fixture dir bound via MINDRIAN_DOCTOR_TRANSCRIPTS_DIR.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const cp = require('child_process');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const DOCTOR_CJS = path.join(REPO_ROOT, 'scripts', 'doctor.cjs');
+
+let pass = 0;
+let fail = 0;
+const failures = [];
+
+function assert(cond, name, detail) {
+  if (cond) {
+    pass++;
+    console.log('PASS  ' + name);
+  } else {
+    fail++;
+    failures.push(name + (detail ? ' -- ' + detail : ''));
+    console.log('FAIL  ' + name + (detail ? ' -- ' + detail : ''));
+  }
+}
+
+// --- T1 + T2 + T3 (positive): synthesize a fixture transcript dir with
+// "/mos:heal" usage; --deprecated-usage detects + exits 1 + returns class I.
+{
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'doctor-deprec-'));
+  const sessionDir = path.join(tmpRoot, 'sessions', 'fake-project-hash');
+  fs.mkdirSync(sessionDir, { recursive: true });
+  const jsonlPath = path.join(sessionDir, 'session-abc.jsonl');
+  // Recent mtime (now). Per implementation contract: scan last 7 days.
+  const fixture = JSON.stringify({ role: 'user', content: 'let me run /mos:heal here' }) + '\n'
+                + JSON.stringify({ role: 'user', content: 'now /mos:query something' }) + '\n';
+  fs.writeFileSync(jsonlPath, fixture);
+  const now = Date.now();
+  fs.utimesSync(jsonlPath, new Date(now), new Date(now));
+
+  const r = cp.spawnSync('node', [DOCTOR_CJS, '--deprecated-usage', '--json'], {
+    encoding: 'utf8',
+    env: Object.assign({}, process.env, { MINDRIAN_DOCTOR_TRANSCRIPTS_DIR: tmpRoot }),
+    timeout: 30000,
+  });
+  // Parse JSON envelope
+  let envelope = null;
+  if (r.stdout) {
+    const start = r.stdout.indexOf('{');
+    if (start >= 0) {
+      try { envelope = JSON.parse(r.stdout.slice(start)); } catch (_) { envelope = null; }
+    }
+  }
+  assert(envelope !== null, 'T1: --deprecated-usage emits parseable JSON', (r.stdout || '').slice(0, 300));
+  const cls = envelope && envelope.checks && envelope.checks['deprecated-usage'];
+  assert(cls !== undefined && cls !== null, 'T1: report.checks["deprecated-usage"] exists', JSON.stringify(envelope && envelope.checks));
+  if (cls) {
+    assert(cls.class === 'L', 'T2: class==="L"', cls.class);
+    assert(typeof cls.status === 'string', 'T2: status is a string', cls.status);
+    assert(typeof cls.action === 'string', 'T2: action is a string', cls.action);
+    assert(Array.isArray(cls.deprecated_uses), 'T2: deprecated_uses is array', JSON.stringify(cls.deprecated_uses));
+    assert(cls.deprecated_uses.length >= 2, 'T1: detected at least 2 deprecated uses (heal + query)', JSON.stringify(cls.deprecated_uses));
+    const found = cls.deprecated_uses.map(function (x) { return x.deprecated; }).sort();
+    assert(found.indexOf('/mos:heal') >= 0, 'T1: /mos:heal detected', JSON.stringify(found));
+    assert(found.indexOf('/mos:query') >= 0, 'T1: /mos:query detected', JSON.stringify(found));
+    assert(cls.status === 'DEPRECATED_USAGE' || cls.status === 'warn', 'T2: status flags violation', cls.status);
+  }
+  // Cleanup
+  try { fs.rmSync(tmpRoot, { recursive: true, force: true }); } catch (_) {}
+}
+
+// --- T3 negative: no transcripts -> --deprecated-usage clean.
+{
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'doctor-deprec-clean-'));
+  const r = cp.spawnSync('node', [DOCTOR_CJS, '--deprecated-usage', '--json'], {
+    encoding: 'utf8',
+    env: Object.assign({}, process.env, { MINDRIAN_DOCTOR_TRANSCRIPTS_DIR: tmpRoot }),
+    timeout: 30000,
+  });
+  let envelope = null;
+  if (r.stdout) {
+    const start = r.stdout.indexOf('{');
+    if (start >= 0) { try { envelope = JSON.parse(r.stdout.slice(start)); } catch (_) {} }
+  }
+  const cls = envelope && envelope.checks && envelope.checks['deprecated-usage'];
+  assert(cls && cls.status === 'OK', 'T3: status === OK with no deprecated usage', cls && cls.status);
+  assert(cls && cls.deprecated_uses && cls.deprecated_uses.length === 0, 'T3: deprecated_uses is empty array');
+  // Per spec: --deprecated-usage exits 0 when clean.
+  assert(r.status === 0, 'T3: exit 0 when clean', String(r.status));
+  try { fs.rmSync(tmpRoot, { recursive: true, force: true }); } catch (_) {}
+}
+
+// --- T4: --all activates --deprecated-usage in the cascade.
+{
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'doctor-deprec-all-'));
+  const r = cp.spawnSync('node', [DOCTOR_CJS, '--all', '--json'], {
+    encoding: 'utf8',
+    env: Object.assign({}, process.env, { MINDRIAN_DOCTOR_TRANSCRIPTS_DIR: tmpRoot }),
+    timeout: 60000,
+  });
+  let envelope = null;
+  if (r.stdout) {
+    const start = r.stdout.indexOf('{');
+    if (start >= 0) { try { envelope = JSON.parse(r.stdout.slice(start)); } catch (_) {} }
+  }
+  const cls = envelope && envelope.checks && envelope.checks['deprecated-usage'];
+  assert(cls !== undefined && cls !== null, 'T4: --all includes deprecated-usage in cascade', JSON.stringify(envelope && envelope.checks ? Object.keys(envelope.checks) : null));
+  try { fs.rmSync(tmpRoot, { recursive: true, force: true }); } catch (_) {}
+}
+
+// --- T5: commands/onboard.md Step 6 has F.1 selector vocabulary.
+{
+  const onboardPath = path.join(REPO_ROOT, 'commands', 'onboard.md');
+  const body = fs.readFileSync(onboardPath, 'utf8');
+  // Locate Step 6 region for verification (the test asserts the F.1 lives
+  // inside or in the vicinity of Step 6, not just anywhere in the file).
+  const step6Idx = body.indexOf('## Step 6');
+  assert(step6Idx > 0, 'T5: Step 6 section exists', String(step6Idx));
+  // The whole step-6 region (from Step 6 to end of file or next ##)
+  const rest = body.slice(step6Idx);
+  const nextStep = rest.indexOf('\n## ', 5);
+  const step6Region = nextStep > 0 ? rest.slice(0, nextStep) : rest;
+  assert(/F\.1/.test(step6Region), 'T5: Step 6 mentions F.1', step6Region.slice(0, 400));
+  assert(/Run Methodology/.test(step6Region), 'T5: Step 6 has "Run Methodology" verb');
+  assert(/Defer/.test(step6Region), 'T5: Step 6 has "Defer" verb');
+  assert(/Free-Text/.test(step6Region), 'T5: Step 6 has "Free-Text" verb');
+  assert(step6Region.indexOf('—') < 0, 'T5: Step 6 region has no em-dash');
+}
+
+// --- T6: commands/diagnose.md recommendation has F.1 selector vocabulary.
+{
+  const diagPath = path.join(REPO_ROOT, 'commands', 'diagnose.md');
+  const body = fs.readFileSync(diagPath, 'utf8');
+  assert(/F\.1/.test(body), 'T6: diagnose.md mentions F.1');
+  assert(/Run Methodology/.test(body), 'T6: diagnose.md has "Run Methodology" verb');
+  assert(/Defer/.test(body), 'T6: diagnose.md has "Defer" verb');
+  assert(/Free-Text/.test(body), 'T6: diagnose.md has "Free-Text" verb');
+  assert(body.indexOf('—') < 0, 'T6: diagnose.md has no em-dash');
+}
+
+// --- T7: CHANGELOG.md entry for Phase 121.5-08 covers all 5 renames + /mos:mos + F.1.
+{
+  const cl = fs.readFileSync(path.join(REPO_ROOT, 'CHANGELOG.md'), 'utf8');
+  assert(/Phase 121\.5-08/.test(cl), 'T7: CHANGELOG mentions Phase 121.5-08');
+  assert(/heal/i.test(cl), 'T7: CHANGELOG mentions heal rename');
+  assert(/query/i.test(cl), 'T7: CHANGELOG mentions query rename');
+  assert(/organize/i.test(cl), 'T7: CHANGELOG mentions organize rename');
+  assert(/hmi-status/i.test(cl), 'T7: CHANGELOG mentions hmi-status rename');
+  assert(/visualize/i.test(cl), 'T7: CHANGELOG mentions visualize rename');
+  assert(/\/mos:mos/.test(cl), 'T7: CHANGELOG mentions /mos:mos creation');
+  // F.1 selector wiring announcement
+  assert(/F\.1/.test(cl) || /F.1 selector/.test(cl), 'T7: CHANGELOG mentions F.1 selector wiring');
+}
+
+console.log('');
+console.log('doctor-deprecation-surface.test.cjs: ' + pass + ' passed, ' + fail + ' failed');
+if (fail > 0) {
+  console.log('FAILURES:');
+  for (const f of failures) console.log('  - ' + f);
+  process.exit(1);
+}
+process.exit(0);

package/lib/memory/first-touch-version.test.cjs

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * lib/memory/first-touch-version.test.cjs
+ * ---------------------------------------
+ * Phase 121.5-05 Sub-plan F Task 1 acceptance tests.
+ *
+ * 8 tests covering the first-touch-version-stamper module:
+ *
+ *   1. stampVersion('banner', '1.13.0-beta.15') contains "MindrianOS v1.13.0-beta.15"
+ *   2. stampVersion('splash', '1.13.0') starts with "MindrianOS v1.13.0"
+ *   3. stampVersion('onboard', '1.14.0') embeds "MindrianOS v1.14.0"
+ *   4. stampVersion(<unknown_surface>, version) throws Error('unknown_surface: ...')
+ *   5. stampVersion called without version arg auto-resolves from plugin.json
+ *   6. data/first-touch-surfaces.json parses; surfaces[] length >= 6
+ *   7. hasEmDash(text) returns true on U+2014, false otherwise
+ *   8. scripts/banner output contains "MindrianOS v" + live plugin.json version
+ *
+ * Pure CJS, node built-ins only. No emoji. No em-dashes.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const stamperPath = path.join(REPO_ROOT, 'lib', 'core', 'first-touch-version-stamper.cjs');
+const stamper = require(stamperPath);
+
+let passed = 0;
+let failed = 0;
+const failures = [];
+
+function assert(name, cond, detail) {
+  if (cond) {
+    passed++;
+    console.log('  PASS  ' + name);
+  } else {
+    failed++;
+    failures.push({ name, detail });
+    console.log('  FAIL  ' + name + (detail ? ' :: ' + detail : ''));
+  }
+}
+
+// --- Test 1: banner stamp contains MindrianOS v<version> ----------------
+{
+  const out = stamper.stampVersion('banner', '1.13.0-beta.15');
+  assert(
+    'Test 1: stampVersion(banner, "1.13.0-beta.15") contains "MindrianOS v1.13.0-beta.15"',
+    out.indexOf('MindrianOS v1.13.0-beta.15') >= 0,
+    'got: ' + out,
+  );
+}
+
+// --- Test 2: splash stamp starts with MindrianOS v<version> -------------
+{
+  const out = stamper.stampVersion('splash', '1.13.0');
+  assert(
+    'Test 2: stampVersion(splash, "1.13.0") starts with "MindrianOS v1.13.0"',
+    out.indexOf('MindrianOS v1.13.0') === 0,
+    'got: ' + out,
+  );
+}
+
+// --- Test 3: onboard stamp embeds MindrianOS v<version> -----------------
+{
+  const out = stamper.stampVersion('onboard', '1.14.0');
+  assert(
+    'Test 3: stampVersion(onboard, "1.14.0") embeds "MindrianOS v1.14.0"',
+    out.indexOf('MindrianOS v1.14.0') >= 0,
+    'got: ' + out,
+  );
+}
+
+// --- Test 4: unknown surface throws -------------------------------------
+{
+  let threw = false;
+  let msg = '';
+  try {
+    stamper.stampVersion('not-a-real-surface', '1.0.0');
+  } catch (e) {
+    threw = true;
+    msg = e.message;
+  }
+  assert(
+    'Test 4: stampVersion(unknown_surface) throws Error(unknown_surface: ...)',
+    threw && /^unknown_surface:/.test(msg),
+    'threw=' + threw + ' msg=' + msg,
+  );
+}
+
+// --- Test 5: no version arg -> auto-resolve from plugin.json ------------
+{
+  const pluginJsonPath = path.join(REPO_ROOT, '.claude-plugin', 'plugin.json');
+  const liveVersion = JSON.parse(fs.readFileSync(pluginJsonPath, 'utf8')).version;
+  const out = stamper.stampVersion('banner');
+  assert(
+    'Test 5: stampVersion(banner) auto-resolves version from plugin.json (' + liveVersion + ')',
+    out.indexOf(liveVersion) >= 0,
+    'got: ' + out + ' live=' + liveVersion,
+  );
+}
+
+// --- Test 6: surfaces JSON parses + has >= 6 entries --------------------
+{
+  const surfaces = stamper.readSurfaces();
+  assert(
+    'Test 6: data/first-touch-surfaces.json parses; surfaces[].length >= 6',
+    Array.isArray(surfaces.surfaces) && surfaces.surfaces.length >= 6,
+    'length=' + (surfaces.surfaces ? surfaces.surfaces.length : 'undefined'),
+  );
+
+  // Sanity: each surface has the required keys.
+  const requiredKeys = ['id', 'file', 'kind', 'version_stamp_required', 'em_dash_check'];
+  let allOk = true;
+  let missingDetail = '';
+  for (const s of surfaces.surfaces) {
+    for (const k of requiredKeys) {
+      if (!(k in s)) {
+        allOk = false;
+        missingDetail = 'surface ' + (s.id || '?') + ' missing key ' + k;
+        break;
+      }
+    }
+    if (!allOk) break;
+  }
+  assert(
+    'Test 6b: every surface has id / file / kind / version_stamp_required / em_dash_check',
+    allOk,
+    missingDetail,
+  );
+}
+
+// --- Test 7: hasEmDash detects U+2014 -----------------------------------
+{
+  // U+2014 EM DASH, written via escape so this source stays ASCII-clean.
+  const withDash = 'this has an \u2014 em dash';
+  const withoutDash = 'this has a - hyphen';
+  assert(
+    'Test 7a: hasEmDash returns true on U+2014',
+    stamper.hasEmDash(withDash) === true,
+  );
+  assert(
+    'Test 7b: hasEmDash returns false on plain hyphen',
+    stamper.hasEmDash(withoutDash) === false,
+  );
+  assert(
+    'Test 7c: hasEmDash returns false on non-string',
+    stamper.hasEmDash(null) === false && stamper.hasEmDash(42) === false,
+  );
+}
+
+// --- Test 8: scripts/banner emits "MindrianOS v" + live version ---------
+{
+  const bannerPath = path.join(REPO_ROOT, 'scripts', 'banner');
+  let bannerOut = '';
+  let bannerErr = null;
+  try {
+    bannerOut = execSync('bash ' + JSON.stringify(bannerPath), {
+      cwd: REPO_ROOT,
+      encoding: 'utf8',
+      env: Object.assign({}, process.env, { COLUMNS: '120' }),
+    });
+  } catch (e) {
+    bannerErr = e.message;
+  }
+  const liveVersion = stamper.resolveCurrentVersion();
+  assert(
+    'Test 8a: scripts/banner runs without error',
+    bannerErr === null,
+    bannerErr || '',
+  );
+  assert(
+    'Test 8b: banner output contains "MindrianOS v"',
+    bannerOut.indexOf('MindrianOS v') >= 0,
+    'first 200 chars: ' + bannerOut.slice(0, 200),
+  );
+  assert(
+    'Test 8c: banner output contains the live plugin.json version (' + liveVersion + ')',
+    bannerOut.indexOf(liveVersion) >= 0,
+    'live=' + liveVersion,
+  );
+}
+
+// --- Summary ------------------------------------------------------------
+console.log('');
+console.log('first-touch-version.test.cjs: ' + passed + ' passed, ' + failed + ' failed');
+if (failed > 0) {
+  for (const f of failures) {
+    console.log('  - ' + f.name + (f.detail ? ' :: ' + f.detail : ''));
+  }
+  process.exit(1);
+}
+process.exit(0);