@mindrian_os/install 1.13.0-beta.11

package/lib/import/smoke-test.test.cjs

@@ -0,0 +1,148 @@
+'use strict';
+
+/**
+ * Phase 80-06 Task 2 -- smoke-test.cjs tests.
+ *
+ * Uses compute-state fallback by default (mindrian-tools is blocked by the
+ * lazygraph-ops PRECONDITIONS issue).
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const crypto = require('node:crypto');
+
+const { runMosSmokeTest, renderSmokeTestSection, parseSectionCounts } = require('./smoke-test.cjs');
+
+function tmpRoom(prefix) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'st-' + prefix + '-' + crypto.randomBytes(4).toString('hex') + '-'));
+  fs.writeFileSync(path.join(dir, 'STATE.md'), '---\nstatus: executing\n---\n\n# Room\n');
+  return dir;
+}
+
+function cleanup(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch (e) { /* soft */ }
+}
+
+function writeArtifact(roomDir, relPath, body) {
+  const abs = path.join(roomDir, relPath);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, body || '---\ntitle: x\n---\n\n# x\n');
+}
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    process.stdout.write('ok ' + name + '\n');
+    passed++;
+  } catch (e) {
+    process.stderr.write('FAIL ' + name + '\n  ' + (e.stack || e.message) + '\n');
+    failed++;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Test 1: happy path -- populated problem-definition passes
+// ---------------------------------------------------------------------------
+test('Test 1: runMosSmokeTest passes on populated room', function () {
+  const room = tmpRoom('happy');
+  try {
+    writeArtifact(room, 'problem-definition/onboarding.md');
+    writeArtifact(room, 'problem-definition/pricing.md');
+    const r = runMosSmokeTest(room);
+    assert.equal(typeof r, 'object');
+    assert.equal(typeof r.passed, 'boolean');
+    assert.ok(r.method, 'method set (got ' + r.method + ')');
+    assert.ok((r.sectionCounts['problem-definition'] || 0) >= 1, 'problem-definition counted (got ' + r.sectionCounts['problem-definition'] + ')');
+    assert.equal(r.passed, true, 'passed=true when canonical section populated');
+  } finally { cleanup(room); }
+});
+
+// ---------------------------------------------------------------------------
+// Test 2: empty room -- warning + passed false
+// ---------------------------------------------------------------------------
+test('Test 2: empty room returns passed=false with warning', function () {
+  const room = tmpRoom('empty');
+  try {
+    const r = runMosSmokeTest(room);
+    assert.equal(r.passed, false, 'empty room passed=false');
+    assert.ok(r.warnings.some(function (w) { return /no populated canonical sections/.test(w); }), 'warning present (got: ' + JSON.stringify(r.warnings) + ')');
+  } finally { cleanup(room); }
+});
+
+// ---------------------------------------------------------------------------
+// Test 3: team count via filesystem walk
+// ---------------------------------------------------------------------------
+test('Test 3: team count picked up via filesystem walk', function () {
+  const room = tmpRoom('team');
+  try {
+    writeArtifact(room, 'team/core-team/jane-doe/jane-doe.md');
+    writeArtifact(room, 'team/core-team/jane-doe/ROOM.md', '# ROOM\n');
+    const r = runMosSmokeTest(room);
+    assert.ok((r.sectionCounts.team || 0) >= 1, 'team >= 1 (got ' + r.sectionCounts.team + ')');
+  } finally { cleanup(room); }
+});
+
+// ---------------------------------------------------------------------------
+// Test 4: forceFallback path
+// ---------------------------------------------------------------------------
+test('Test 4: forceFallback reaches compute-state and returns result', function () {
+  const room = tmpRoom('fb');
+  try {
+    writeArtifact(room, 'solution-design/arch.md');
+    const r = runMosSmokeTest(room, { forceFallback: true });
+    assert.equal(r.method, 'compute-state', 'method=compute-state (got ' + r.method + ')');
+    assert.ok((r.sectionCounts['solution-design'] || 0) >= 1, 'solution-design counted');
+    assert.equal(r.passed, true);
+  } finally { cleanup(room); }
+});
+
+// ---------------------------------------------------------------------------
+// Test 5: renderSmokeTestSection emits the required heading
+// ---------------------------------------------------------------------------
+test('Test 5: renderSmokeTestSection contains "/mos: Usability Check" heading', function () {
+  const md = renderSmokeTestSection({ passed: true, method: 'compute-state', sectionCounts: { 'problem-definition': 3 }, warnings: [] });
+  assert.match(md, /## \/mos: Usability Check/, 'heading present');
+  assert.match(md, /problem-definition: 3/, 'section count rendered');
+});
+
+// ---------------------------------------------------------------------------
+// Test 6: parseSectionCounts handles compute-state table fragment
+// ---------------------------------------------------------------------------
+test('Test 6: parseSectionCounts parses a compute-state-style table', function () {
+  const sample = [
+    '# Data Room State',
+    '',
+    '## Sections',
+    '| Section | Entries | Progress | Status | Last Updated |',
+    '|---------|---------|----------|--------|-------------|',
+    '| problem-definition | 3 | [bar] | Well-developed | 2026-04-13 |',
+    '| inbox | 1 | [bar] | Active | 2026-04-13 |',
+    '',
+    '## Gaps',
+    '- nothing'
+  ].join('\n');
+  const counts = parseSectionCounts(sample);
+  assert.equal(counts['problem-definition'], 3);
+  assert.equal(counts['inbox'], 1);
+});
+
+// ---------------------------------------------------------------------------
+// Test 7: no em-dashes
+// ---------------------------------------------------------------------------
+test('Test 7: smoke-test.cjs and smoke-test.test.cjs contain no em-dashes', function () {
+  const emDash = '\u2014';
+  const mod = fs.readFileSync(path.join(__dirname, 'smoke-test.cjs'), 'utf8');
+  const tst = fs.readFileSync(__filename, 'utf8');
+  assert.equal(mod.indexOf(emDash), -1);
+  assert.equal(tst.indexOf(emDash), -1);
+});
+
+// ---------------------------------------------------------------------------
+process.stdout.write('\n' + passed + ' passed, ' + failed + ' failed\n');
+if (failed > 0) process.exit(1);
+process.stdout.write('all passing\n');

package/lib/import/test-fixtures/collision-vault/preexisting-room/STATE.md

@@ -0,0 +1,8 @@
+---
+gsd_state_version: 1.0
+status: executing
+---
+
+# Project State
+
+Minimal preexisting room used by Phase 80 collision tests.

package/lib/import/test-fixtures/collision-vault/preexisting-room/problem-definition/onboarding/onboarding.md

@@ -0,0 +1,7 @@
+---
+title: Onboarding pain (preexisting)
+section: problem-definition
+---
+This is the preexisting artifact in the collision target location. Phase 80
+router tests will detect the filename collision against this file and route
+the incoming onboarding.md into an `-imported-{date}` sibling folder.

package/lib/import/test-fixtures/collision-vault/source/onboarding.md

@@ -0,0 +1,5 @@
+---
+title: Onboarding pain
+section: problem-definition
+---
+A colliding onboarding note that should trigger the -imported-{date} suffix path.

package/lib/import/test-fixtures/obsidian-vault/.obsidian/workspace.json

@@ -0,0 +1 @@
+{"main": "scanner-must-skip-this"}

package/lib/import/test-fixtures/obsidian-vault/notes/with-wikilinks.md

@@ -0,0 +1,4 @@
+---
+title: Wikilink sample
+---
+see [[dror-cohen]] and [[activation-funnel]]

package/lib/import/test-fixtures/tiny-vault/notes/2026-01-15-team-sync.md

@@ -0,0 +1,9 @@
+---
+title: Team sync
+attendees: ["Jane Doe", "John Roe"]
+---
+## Attendees
+- Jane Doe
+- John Roe
+
+Discussed onboarding flow and pricing. Jane Doe, co-founder.

package/lib/import/test-fixtures/tiny-vault/notes/empty.md

@@ -0,0 +1,3 @@
+---
+title: Empty placeholder
+---

package/lib/import/test-fixtures/tiny-vault/notes/onboarding.md

@@ -0,0 +1,5 @@
+---
+title: Onboarding pain
+tags: [activation, dror]
+---
+Dror could not activate alone. The funnel is broken at step 3.

package/lib/import/test-fixtures/tiny-vault/notes/pricing.md

@@ -0,0 +1,5 @@
+---
+title: Pricing notes
+tags: [business-model, freemium]
+---
+Freemium tier with usage-based upgrade path. Convert at 10% target.

package/lib/import/test-fixtures/tiny-vault/notes/random.md

@@ -0,0 +1,4 @@
+---
+title: Random thoughts
+---
+Unsorted note with no clear section signal. Placeholder content for inbox routing test.

package/lib/import/undo.test.cjs

@@ -0,0 +1,199 @@
+'use strict';
+
+/**
+ * Phase 80 Plan 80-05 -- undo roundtrip end-to-end.
+ *
+ * Runs scripts/vault-import.cjs as a subprocess against tiny-vault, captures
+ * routed files, then runs --undo and asserts:
+ *   1. Routed files are moved to imports/{id}/undone/ (not deleted, not
+ *      restored to source)
+ *   2. Running --undo again is idempotent (exit 0, no errors, no changes)
+ *   3. IMPORT-REPORT.md gains UNDONE: true in its frontmatter after undo
+ *   4. The source vault is untouched
+ *   5. --undo against a missing import id exits non-zero
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const crypto = require('node:crypto');
+const { spawnSync } = require('node:child_process');
+
+const pluginRoot = path.resolve(__dirname, '../..');
+const script = path.join(pluginRoot, 'scripts/vault-import.cjs');
+const tinyVault = path.join(pluginRoot, 'lib/import/test-fixtures/tiny-vault');
+
+function tmpDir(prefix) {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'vi-undo-' + prefix + '-' + crypto.randomBytes(4).toString('hex') + '-'));
+}
+
+function copyDir(src, dst) {
+  fs.mkdirSync(dst, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, entry.name);
+    const d = path.join(dst, entry.name);
+    if (entry.isDirectory()) copyDir(s, d);
+    else if (entry.isFile()) fs.copyFileSync(s, d);
+  }
+}
+
+function scaffoldMinimalRoom(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'STATE.md'), '---\ngsd_state_version: 1.0\nstatus: executing\n---\n\n# Room\n');
+}
+
+function run(args) {
+  const res = spawnSync(process.execPath, [script].concat(args), {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  return { code: res.status, stdout: res.stdout || '', stderr: res.stderr || '' };
+}
+
+function cleanup(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch (e) { /* soft */ }
+}
+
+function snapshotSourceVault(dir) {
+  const out = {};
+  function walk(d, rel) {
+    for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
+      const full = path.join(d, entry.name);
+      const r = path.join(rel, entry.name);
+      if (entry.isDirectory()) walk(full, r);
+      else if (entry.isFile()) out[r] = fs.readFileSync(full, 'utf8');
+    }
+  }
+  walk(dir, '');
+  return out;
+}
+
+let passed = 0, failed = 0;
+function test(name, fn) {
+  try {
+    fn();
+    process.stdout.write('ok ' + name + '\n');
+    passed++;
+  } catch (e) {
+    process.stderr.write('FAIL ' + name + '\n  ' + (e.stack || e.message) + '\n');
+    failed++;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Test 1: roundtrip -- import then undo
+// ---------------------------------------------------------------------------
+test('undo moves routed files to imports/{id}/undone/ and marks report', function () {
+  const src = tmpDir('rt-src');
+  const dst = tmpDir('rt-dst');
+  try {
+    copyDir(tinyVault, src);
+    scaffoldMinimalRoom(dst);
+    const sourceBefore = snapshotSourceVault(src);
+
+    // Run full pipeline
+    let r = run(['--path', src, '--room', dst, '--yes']);
+    assert.equal(r.code, 0, 'import exit 0 (stderr=' + r.stderr + ')');
+
+    const importsRoot = path.join(dst, 'imports');
+    const importIds = fs.readdirSync(importsRoot);
+    assert.equal(importIds.length, 1, 'one import dir');
+    const importId = importIds[0];
+    const importDir = path.join(importsRoot, importId);
+    const manifestPath = path.join(importDir, '01-ingest/output/MANIFEST.json');
+    const m = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+
+    // Capture routed destinations that actually exist on disk
+    const routedExisting = [];
+    for (const f of m.files) {
+      if (f.destination_abs_path && fs.existsSync(f.destination_abs_path)) {
+        routedExisting.push(f.destination_abs_path);
+      }
+    }
+    assert.ok(routedExisting.length > 0, 'at least one routed file exists pre-undo');
+
+    // Run undo
+    r = run(['--undo', importId, '--room', dst]);
+    assert.equal(r.code, 0, 'undo exit 0 (stderr=' + r.stderr + ')');
+
+    // Every previously routed file must now be gone from its destination
+    for (const abs of routedExisting) {
+      assert.ok(!fs.existsSync(abs), 'routed file removed from destination: ' + abs);
+    }
+
+    // All moved files must be present somewhere under imports/{id}/undone/
+    const undoneRoot = path.join(importDir, 'undone');
+    assert.ok(fs.existsSync(undoneRoot), 'undone/ exists');
+    const undoneFiles = [];
+    (function walk(d) {
+      for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
+        const p = path.join(d, entry.name);
+        if (entry.isDirectory()) walk(p);
+        else if (entry.isFile()) undoneFiles.push(p);
+      }
+    })(undoneRoot);
+    assert.ok(undoneFiles.length >= routedExisting.length, 'undone/ holds at least routed count (got ' + undoneFiles.length + ', expected >= ' + routedExisting.length + ')');
+
+    // Manifest marked undone
+    const mAfter = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    assert.equal(mAfter.undo.is_undone, true, 'manifest.undo.is_undone');
+    assert.ok(mAfter.undo.undone_at, 'undone_at set');
+
+    // Report has UNDONE: true
+    const report = fs.readFileSync(path.join(importDir, 'IMPORT-REPORT.md'), 'utf8');
+    assert.ok(/^---\nUNDONE: true\n/.test(report), 'IMPORT-REPORT.md has UNDONE: true');
+
+    // Source vault untouched
+    const sourceAfter = snapshotSourceVault(src);
+    assert.deepEqual(sourceAfter, sourceBefore, 'source vault unchanged by undo');
+  } finally {
+    cleanup(src);
+    cleanup(dst);
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Test 2: idempotent -- running undo twice is a no-op exit 0
+// ---------------------------------------------------------------------------
+test('undo is idempotent (second run exits 0)', function () {
+  const src = tmpDir('idem-src');
+  const dst = tmpDir('idem-dst');
+  try {
+    copyDir(tinyVault, src);
+    scaffoldMinimalRoom(dst);
+
+    let r = run(['--path', src, '--room', dst, '--yes']);
+    assert.equal(r.code, 0, 'import exit 0');
+
+    const importId = fs.readdirSync(path.join(dst, 'imports'))[0];
+
+    r = run(['--undo', importId, '--room', dst]);
+    assert.equal(r.code, 0, 'first undo exit 0');
+
+    r = run(['--undo', importId, '--room', dst]);
+    assert.equal(r.code, 0, 'second undo exit 0');
+    assert.ok(/already undone/.test(r.stdout), 'second undo reports already undone');
+  } finally {
+    cleanup(src);
+    cleanup(dst);
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Test 3: missing import id -> non-zero exit
+// ---------------------------------------------------------------------------
+test('undo against missing import id exits non-zero', function () {
+  const dst = tmpDir('miss-dst');
+  try {
+    scaffoldMinimalRoom(dst);
+    const r = run(['--undo', '9999-99-99-nothing', '--room', dst]);
+    assert.notEqual(r.code, 0, 'non-zero exit for missing id');
+    assert.ok(/manifest not found/.test(r.stderr), 'stderr mentions manifest not found');
+  } finally {
+    cleanup(dst);
+  }
+});
+
+process.stdout.write('\n' + passed + ' passed, ' + failed + ' failed\n');
+if (failed > 0) process.exit(1);

package/lib/import/vault-scanner.cjs

@@ -0,0 +1,105 @@
+'use strict';
+
+/**
+ * Deterministic vault scanner for Phase 80 Stage 01 (ingest).
+ *
+ * Walks a directory of .md/.markdown files and returns the files[] array
+ * consumed by Stage 02. No AI. No file moves. Safe to re-run.
+ *
+ * Skips .obsidian/, .git/, node_modules/, .trash/, hidden dirs, and any
+ * folder in SKIP_DIRS. Parses YAML frontmatter via gray-matter with a
+ * try/catch that swallows malformed YAML (sets source_frontmatter = {}).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const matter = require('gray-matter');
+
+const SKIP_DIRS = new Set([
+  '.obsidian',
+  '.git',
+  'node_modules',
+  '.trash',
+  '.context',
+  '.lazygraph',
+  '.mindrian'
+]);
+const MD_EXT = new Set(['.md', '.markdown']);
+const WIKILINK_RE = /\[\[([^\]]+)\]\]/g;
+
+function scanVault(sourcePath, opts) {
+  opts = opts || {};
+  if (!fs.existsSync(sourcePath)) {
+    throw new Error('source path not found: ' + sourcePath);
+  }
+  const files = [];
+  const skipped = [];
+  let counter = 0;
+
+  function walk(dir, rel) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch (e) {
+      return;
+    }
+    // Stable ordering for deterministic output
+    entries.sort(function (a, b) { return a.name < b.name ? -1 : a.name > b.name ? 1 : 0; });
+    for (const entry of entries) {
+      const relPath = rel ? path.join(rel, entry.name) : entry.name;
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name) || (entry.name.startsWith('.') && entry.name !== '.')) {
+          skipped.push(relPath);
+          continue;
+        }
+        walk(path.join(dir, entry.name), relPath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const ext = path.extname(entry.name).toLowerCase();
+      if (!MD_EXT.has(ext)) continue;
+
+      const abs = path.join(dir, entry.name);
+      let content;
+      try {
+        content = fs.readFileSync(abs, 'utf8');
+      } catch (e) {
+        skipped.push(relPath);
+        continue;
+      }
+      let parsed = { data: {}, content: content };
+      try {
+        parsed = matter(content);
+      } catch (e) {
+        parsed = { data: {}, content: content };
+      }
+      const wikilinks = [];
+      let m;
+      const body = parsed.content || '';
+      WIKILINK_RE.lastIndex = 0;
+      while ((m = WIKILINK_RE.exec(body)) !== null) {
+        const target = m[1].split('|')[0].trim();
+        if (target) wikilinks.push(target);
+      }
+      const stat = fs.statSync(abs);
+      counter += 1;
+      files.push({
+        id: 'f_' + String(counter).padStart(3, '0'),
+        source_path: relPath,
+        source_abs_path: abs,
+        source_size: stat.size,
+        source_mtime: stat.mtime.toISOString(),
+        source_hash: 'sha1:' + crypto.createHash('sha1').update(content).digest('hex'),
+        source_frontmatter: parsed.data || {},
+        source_wikilinks: wikilinks,
+        parent_folder: rel ? path.basename(rel) : null
+      });
+    }
+  }
+
+  walk(sourcePath, '');
+  return { files: files, skipped: skipped };
+}
+
+module.exports = { scanVault: scanVault, SKIP_DIRS: SKIP_DIRS };

package/lib/import/vault-scanner.test.cjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Unit tests for lib/import/vault-scanner.cjs
+ * Run: node lib/import/vault-scanner.test.cjs
+ */
+
+const assert = require('node:assert/strict');
+const path = require('node:path');
+const { scanVault } = require('./vault-scanner.cjs');
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try {
+    fn();
+    passed += 1;
+    process.stdout.write('  ok  ' + name + '\n');
+  } catch (err) {
+    failed += 1;
+    process.stdout.write('  FAIL ' + name + '\n    ' + err.message + '\n');
+  }
+}
+
+const TINY = path.join(__dirname, 'test-fixtures', 'tiny-vault');
+const OBS = path.join(__dirname, 'test-fixtures', 'obsidian-vault');
+
+test('scanVault on tiny-vault returns 5 files with full metadata', function () {
+  const r = scanVault(TINY);
+  assert.equal(r.files.length, 5, 'expected 5 files, got ' + r.files.length);
+  for (const f of r.files) {
+    assert.ok(f.source_path, 'source_path');
+    assert.ok(typeof f.source_size === 'number', 'source_size');
+    assert.ok(f.source_mtime, 'source_mtime');
+    assert.ok(/^sha1:[0-9a-f]{40}$/.test(f.source_hash), 'source_hash sha1');
+    assert.ok(f.source_frontmatter && typeof f.source_frontmatter === 'object', 'source_frontmatter');
+    assert.ok(Array.isArray(f.source_wikilinks), 'source_wikilinks array');
+    assert.ok('parent_folder' in f, 'parent_folder');
+  }
+});
+
+test('scanVault skips .obsidian/, .git/, hidden dirs', function () {
+  const r = scanVault(OBS);
+  for (const f of r.files) {
+    assert.ok(!f.source_path.includes('.obsidian'), 'should not include .obsidian paths: ' + f.source_path);
+  }
+  // skipped[] should have recorded .obsidian
+  const skippedJoined = r.skipped.join('|');
+  assert.ok(skippedJoined.includes('.obsidian'), 'expected .obsidian in skipped list, got: ' + skippedJoined);
+});
+
+test('scanVault extracts [[wikilinks]] from body into source_wikilinks', function () {
+  const r = scanVault(OBS);
+  const withLinks = r.files.find(function (f) { return f.source_path.indexOf('with-wikilinks') !== -1; });
+  assert.ok(withLinks, 'expected with-wikilinks.md in results');
+  assert.ok(withLinks.source_wikilinks.indexOf('dror-cohen') !== -1, 'expected dror-cohen wikilink');
+  assert.ok(withLinks.source_wikilinks.indexOf('activation-funnel') !== -1, 'expected activation-funnel wikilink');
+});
+
+test('scanVault throws on missing path', function () {
+  assert.throws(function () { scanVault('/nonexistent/path/xyz-123'); }, /source path not found/);
+});
+
+process.stdout.write('\n' + passed + ' passed, ' + failed + ' failed\n');
+if (failed > 0) process.exit(1);
+process.stdout.write('PASS\n');