@mindrian_os/install 1.13.0-beta.11

package/lib/import/branding.test.cjs

@@ -0,0 +1,235 @@
+'use strict';
+
+/**
+ * Phase 80-06 Task 1 -- branding.cjs tests.
+ *
+ * Zero-dep Node assert pattern. Uses os.tmpdir() for fixtures.
+ */
+
+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 matter = require('gray-matter');
+
+const branding = require('./branding.cjs');
+
+function tmpFile(contents) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'br-' + crypto.randomBytes(4).toString('hex') + '-'));
+  const p = path.join(dir, 'artifact.md');
+  fs.writeFileSync(p, contents);
+  return p;
+}
+
+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: injectBrandedFooter
+// ---------------------------------------------------------------------------
+test('Test 1: injectBrandedFooter appends and is idempotent', function () {
+  const p = tmpFile('# Title\n\nBody text.\n');
+  const ctx = {
+    import_id: '2026-04-13-test',
+    source_vault: '/vault',
+    imported_at: '2026-04-13T10:00:00.000Z'
+  };
+
+  const first = branding.injectBrandedFooter(p, ctx);
+  assert.equal(first, true, 'first injection returns true');
+  let content = fs.readFileSync(p, 'utf8');
+  assert.ok(content.includes('MindrianOS'), 'footer contains MindrianOS');
+  assert.ok(content.includes('2026-04-13-test'), 'footer contains import_id');
+
+  const second = branding.injectBrandedFooter(p, ctx);
+  assert.equal(second, false, 'second injection returns false (idempotent)');
+  const content2 = fs.readFileSync(p, 'utf8');
+  const occurrences = (content2.match(/MindrianOS/g) || []).length;
+  assert.equal(occurrences, 1, 'footer appears exactly once');
+});
+
+// ---------------------------------------------------------------------------
+// Test 2: normalizeFrontmatter
+// ---------------------------------------------------------------------------
+test('Test 2: normalizeFrontmatter enforces canonical shape', function () {
+  const p = tmpFile('---\ntitle: Old\ncustom_field: x\nauthor: Jane\n---\n\nBody.\n');
+  const classification = { section: 'problem-definition' };
+  const ctx = {
+    import_id: '2026-04-13-test',
+    source_path: 'notes/old.md',
+    source_vault: '/vault'
+  };
+
+  const canonical = branding.normalizeFrontmatter(p, classification, ctx);
+
+  assert.equal(canonical.title, 'Old', 'title preserved');
+  assert.equal(canonical.section, 'problem-definition', 'section set');
+  assert.equal(canonical.status, 'imported', 'status imported');
+  assert.equal(canonical.imported_from, 'notes/old.md', 'imported_from set');
+  assert.ok(/^\d{4}-\d{2}-\d{2}T/.test(canonical.imported_at), 'imported_at is ISO-like');
+  assert.equal(canonical.import_id, '2026-04-13-test', 'import_id set');
+  assert.ok(Array.isArray(canonical.source_wikilinks), 'source_wikilinks is array');
+  assert.ok(Array.isArray(canonical.tags), 'tags is array');
+  assert.ok(canonical._source_frontmatter, '_source_frontmatter present');
+  assert.equal(canonical._source_frontmatter.custom_field, 'x', 'custom_field preserved');
+  assert.equal(canonical._source_frontmatter.author, 'Jane', 'author preserved');
+
+  // Re-read and verify serialized form
+  const reparsed = matter(fs.readFileSync(p, 'utf8'));
+  assert.equal(reparsed.data.title, 'Old');
+  assert.equal(reparsed.data.section, 'problem-definition');
+  assert.equal(reparsed.data.status, 'imported');
+});
+
+// ---------------------------------------------------------------------------
+// Test 3: promoteCalloutFields
+// ---------------------------------------------------------------------------
+test('Test 3: promoteCalloutFields produces callout blocks from _source_frontmatter', function () {
+  // Seed with a post-normalize shape
+  const fm = {
+    title: 'Meeting',
+    section: 'team-execution',
+    status: 'imported',
+    imported_from: 'm.md',
+    imported_at: '2026-04-13T10:00:00.000Z',
+    import_id: '2026-04-13-test',
+    source_wikilinks: [],
+    tags: [],
+    _source_frontmatter: {
+      author: 'Jane Doe',
+      attendees: ['Jane Doe', 'John Roe'],
+      date: '2026-01-15'
+    }
+  };
+  const raw = matter.stringify('Meeting body.\n', fm);
+  const p = tmpFile(raw);
+
+  const changed = branding.promoteCalloutFields(p);
+  assert.equal(changed, true, 'promotion returned true');
+
+  const content = fs.readFileSync(p, 'utf8');
+  assert.ok(content.includes('<!-- destijl-callout -->'), 'callout marker present');
+  assert.ok(content.includes('> [!author] Jane Doe'), 'author callout');
+  assert.ok(content.includes('> [!attendees] Jane Doe, John Roe'), 'attendees callout');
+  assert.ok(content.includes('> [!date] 2026-01-15'), 'date callout');
+
+  // Idempotent
+  const again = branding.promoteCalloutFields(p);
+  assert.equal(again, false, 'second promotion returns false');
+  const content2 = fs.readFileSync(p, 'utf8');
+  const markers = (content2.match(/destijl-callout/g) || []).length;
+  assert.equal(markers, 1, 'exactly one callout marker');
+});
+
+// ---------------------------------------------------------------------------
+// Test 4: applyBranding idempotent end-to-end
+// ---------------------------------------------------------------------------
+test('Test 4: applyBranding is fully idempotent on second run', function () {
+  const p = tmpFile('---\ntitle: Notes\nauthor: Jane\ndate: 2026-02-01\ncustom: keep\n---\n\n# Heading\n\nBody paragraph.\n');
+  const cls = { section: 'market-analysis' };
+  const ctx = {
+    import_id: '2026-04-13-test',
+    source_path: 'notes/n.md',
+    source_vault: '/vault',
+    imported_at: '2026-04-13T10:00:00.000Z'
+  };
+
+  branding.applyBranding(p, cls, ctx);
+  const first = fs.readFileSync(p, 'utf8');
+  branding.applyBranding(p, cls, ctx);
+  const second = fs.readFileSync(p, 'utf8');
+
+  assert.equal(first, second, 'second applyBranding produced identical content');
+
+  // Checks
+  assert.ok(first.includes('MindrianOS'), 'footer present');
+  assert.ok(first.includes('<!-- destijl-callout -->'), 'callout marker present');
+  assert.ok(first.includes('> [!author] Jane'), 'author callout rendered');
+  assert.ok(first.includes('> [!date] 2026-02-01'), 'date callout rendered');
+
+  const fmParsed = matter(first);
+  assert.equal(fmParsed.data.section, 'market-analysis');
+  assert.equal(fmParsed.data.status, 'imported');
+  assert.ok(fmParsed.data._source_frontmatter, '_source_frontmatter preserved');
+  assert.equal(fmParsed.data._source_frontmatter.custom, 'keep', 'non-canonical field preserved');
+
+  const footerOccurrences = (first.match(/MindrianOS/g) || []).length;
+  assert.equal(footerOccurrences, 1, 'footer appears exactly once after double apply');
+});
+
+// ---------------------------------------------------------------------------
+// Test 5: enricher hook -- after enrichRoom runs, each file has branding
+// ---------------------------------------------------------------------------
+test('Test 5: enrichRoom hook applies branding to routed files', function () {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'br-enrich-' + crypto.randomBytes(4).toString('hex') + '-'));
+  const roomDir = path.join(dir, 'room');
+  const section = path.join(roomDir, 'problem-definition', 'onboarding');
+  fs.mkdirSync(section, { recursive: true });
+  const artifactPath = path.join(section, 'onboarding.md');
+  fs.writeFileSync(
+    artifactPath,
+    '---\ntitle: Onboarding\nauthor: Jane\n---\n\n# Onboarding\n\nBody.\n'
+  );
+
+  const manifest = {
+    import_id: '2026-04-13-enrich-test',
+    source_vault: '/vault',
+    destination_room: roomDir,
+    stage_states: { enrich: {} },
+    warnings: [],
+    people: [],
+    files: [
+      {
+        id: 'f1',
+        source_path: 'notes/onboarding.md',
+        destination_folder: path.join('problem-definition', 'onboarding'),
+        destination_path: path.join('problem-definition', 'onboarding', 'onboarding.md'),
+        destination_abs_path: artifactPath,
+        destination_section: 'problem-definition',
+        classification: { section: 'problem-definition', decision: 'AUTO', confidence: 0.9 },
+        source_wikilinks: []
+      }
+    ]
+  };
+
+  const { enrichRoom } = require('./enricher.cjs');
+  enrichRoom(manifest, { roomDir: roomDir });
+
+  const content = fs.readFileSync(artifactPath, 'utf8');
+  assert.ok(content.includes('MindrianOS'), 'branded footer present after enrichRoom');
+  const fm = matter(content).data;
+  assert.equal(fm.status, 'imported', 'canonical status set');
+  assert.equal(fm.section, 'problem-definition', 'section normalized');
+  assert.equal(fm.import_id, '2026-04-13-enrich-test', 'import_id in frontmatter');
+  assert.ok(content.includes('> [!author] Jane'), 'author callout promoted');
+
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+// ---------------------------------------------------------------------------
+// Test 6: no em-dashes
+// ---------------------------------------------------------------------------
+test('Test 6: branding.cjs and branding.test.cjs contain no em-dashes', function () {
+  const emDash = '\u2014';
+  const mod = fs.readFileSync(path.join(__dirname, 'branding.cjs'), 'utf8');
+  const tst = fs.readFileSync(__filename, 'utf8');
+  assert.equal(mod.indexOf(emDash), -1, 'branding.cjs has no em-dash');
+  assert.equal(tst.indexOf(emDash), -1, 'branding.test.cjs has no em-dash');
+});
+
+// ---------------------------------------------------------------------------
+process.stdout.write('\n' + passed + ' passed, ' + failed + ' failed\n');
+if (failed > 0) process.exit(1);
+process.stdout.write('all passing\n');

package/lib/import/classifications-sync.cjs

@@ -0,0 +1,104 @@
+'use strict';
+
+/**
+ * classifications-sync.cjs -- round-trip Larry/human edits from the Stage 02
+ * classifications.md review gate back into MANIFEST.json.
+ *
+ * Addresses Blocker 4 from the Phase 80 plan-check (CONTEXT.md Locked Fix 4):
+ * when a human opens classifications.md, edits a row, and saves, those edits
+ * MUST persist into manifest.files[].classification before Stage 03 routes.
+ *
+ * The classifications.md table shape (rendered by Stage 02) is:
+ *   | File | Section | Confidence | Evidence | Decision |
+ *   |------|---------|------------|----------|----------|
+ *   | notes/onboarding.md | problem-definition | 0.84 | "..." | AUTO |
+ */
+
+const fs = require('node:fs');
+const manifestMod = require('./manifest.cjs');
+
+function parseClassificationsMarkdown(mdPath) {
+  const raw = fs.readFileSync(mdPath, 'utf8');
+  const lines = raw.split(/\r?\n/);
+  const rows = [];
+  let inTable = false;
+  for (const line of lines) {
+    if (/^\|\s*File\s*\|/i.test(line)) {
+      inTable = true;
+      continue;
+    }
+    if (!inTable) continue;
+    if (/^\|\s*-+/.test(line)) continue;
+    if (line.trim() === '') {
+      if (rows.length > 0) break;
+      continue;
+    }
+    if (!line.trim().startsWith('|')) {
+      if (rows.length > 0) break;
+      continue;
+    }
+    const cells = line.split('|').slice(1, -1).map(function (c) { return c.trim(); });
+    if (cells.length < 5) {
+      throw new Error('malformed classifications row (expected 5 columns, got ' + cells.length + '): ' + line);
+    }
+    const file = cells[0];
+    const section = cells[1];
+    const confidenceRaw = cells[2];
+    const evidence = cells[3];
+    const decision = cells[4];
+    const confidence = Number(confidenceRaw);
+    if (!Number.isFinite(confidence)) {
+      throw new Error('malformed classifications row (confidence not numeric): ' + line);
+    }
+    rows.push({
+      file: file,
+      section: section,
+      confidence: confidence,
+      evidence: evidence,
+      decision: decision
+    });
+  }
+  return rows;
+}
+
+function syncClassificationsToManifest(mdPath, manifestPath) {
+  const rows = parseClassificationsMarkdown(mdPath);
+  const manifest = manifestMod.readManifest(manifestPath);
+  const byPath = new Map();
+  for (const f of manifest.files) {
+    byPath.set(f.source_path, f);
+  }
+  let edits = 0;
+  for (const row of rows) {
+    const f = byPath.get(row.file);
+    if (!f) {
+      manifest.warnings = manifest.warnings || [];
+      manifest.warnings.push({ type: 'classification_unmatched', context: row.file });
+      continue;
+    }
+    const prev = f.classification || {};
+    if (
+      prev.section !== row.section ||
+      prev.decision !== row.decision ||
+      prev.confidence !== row.confidence
+    ) {
+      edits += 1;
+    }
+    f.classification = {
+      section: row.section,
+      confidence: row.confidence,
+      evidence: row.evidence,
+      decision: row.decision,
+      stage: 'classify'
+    };
+  }
+  manifest.stage_states.classify.human_edited = edits > 0 || manifest.stage_states.classify.human_edited === true;
+  manifest.stage_states.classify.edits_count = (manifest.stage_states.classify.edits_count || 0) + edits;
+  manifestMod.writeManifest(manifestPath, manifest);
+  return { rows: rows.length, edits: edits };
+}
+
+module.exports = {
+  parseClassificationsMarkdown: parseClassificationsMarkdown,
+  syncClassificationsToManifest: syncClassificationsToManifest
+};

package/lib/import/classifications-sync.test.cjs

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Unit tests for lib/import/classifications-sync.cjs
+ * Run: node lib/import/classifications-sync.test.cjs
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const manifestMod = require('./manifest.cjs');
+const sync = require('./classifications-sync.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 tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cs-test-'));
+
+function seedManifest(fileRows) {
+  const manifest = manifestMod.createManifest('/tmp/v', '2026-04-13-cs');
+  fileRows.forEach(function (row, i) {
+    manifest.files.push({
+      id: 'f_' + String(i + 1).padStart(3, '0'),
+      source_path: row.source_path,
+      source_size: 1,
+      source_mtime: '2026-01-01T00:00:00.000Z',
+      source_hash: 'sha1:aaa',
+      source_frontmatter: {},
+      source_wikilinks: [],
+      parent_folder: null,
+      classification: row.classification || null
+    });
+  });
+  return manifest;
+}
+
+function writeClassificationsMd(filePath, rows) {
+  let out = '| File | Section | Confidence | Evidence | Decision |\n';
+  out += '|------|---------|------------|----------|----------|\n';
+  for (const r of rows) {
+    out += '| ' + r.file + ' | ' + r.section + ' | ' + r.confidence + ' | ' + r.evidence + ' | ' + r.decision + ' |\n';
+  }
+  fs.writeFileSync(filePath, out, 'utf8');
+}
+
+test('round-trip: write classifications.md, parse, get back same rows', function () {
+  const mdPath = path.join(tmpRoot, 'rt.md');
+  const rows = [
+    { file: 'notes/a.md', section: 'problem-definition', confidence: '0.84', evidence: 'clear signal', decision: 'AUTO' },
+    { file: 'notes/b.md', section: 'business-model', confidence: '0.58', evidence: 'freemium', decision: 'SUGGEST' },
+    { file: 'notes/c.md', section: 'inbox', confidence: '0.31', evidence: 'no signal', decision: 'INBOX' }
+  ];
+  writeClassificationsMd(mdPath, rows);
+  const parsed = sync.parseClassificationsMarkdown(mdPath);
+  assert.equal(parsed.length, 3);
+  assert.equal(parsed[0].file, 'notes/a.md');
+  assert.equal(parsed[0].section, 'problem-definition');
+  assert.equal(parsed[0].confidence, 0.84);
+  assert.equal(parsed[0].decision, 'AUTO');
+});
+
+test('section edit: inbox -> problem-definition persists into manifest', function () {
+  const manifestPath = path.join(tmpRoot, 'sec.json');
+  const mdPath = path.join(tmpRoot, 'sec.md');
+  const manifest = seedManifest([
+    { source_path: 'notes/a.md', classification: { section: 'inbox', confidence: 0.31, evidence: 'no signal', decision: 'INBOX', stage: 'classify' } }
+  ]);
+  manifestMod.writeManifest(manifestPath, manifest);
+  writeClassificationsMd(mdPath, [
+    { file: 'notes/a.md', section: 'problem-definition', confidence: '0.80', evidence: 'edited', decision: 'AUTO' }
+  ]);
+  const result = sync.syncClassificationsToManifest(mdPath, manifestPath);
+  assert.equal(result.rows, 1);
+  assert.equal(result.edits, 1);
+  const back = manifestMod.readManifest(manifestPath);
+  assert.equal(back.files[0].classification.section, 'problem-definition');
+  assert.equal(back.stage_states.classify.human_edited, true);
+  assert.equal(back.stage_states.classify.edits_count, 1);
+});
+
+test('decision edit: INBOX -> AUTO persists into manifest', function () {
+  const manifestPath = path.join(tmpRoot, 'dec.json');
+  const mdPath = path.join(tmpRoot, 'dec.md');
+  const manifest = seedManifest([
+    { source_path: 'notes/a.md', classification: { section: 'problem-definition', confidence: 0.5, evidence: 'ok', decision: 'INBOX', stage: 'classify' } }
+  ]);
+  manifestMod.writeManifest(manifestPath, manifest);
+  writeClassificationsMd(mdPath, [
+    { file: 'notes/a.md', section: 'problem-definition', confidence: '0.5', evidence: 'ok', decision: 'AUTO' }
+  ]);
+  sync.syncClassificationsToManifest(mdPath, manifestPath);
+  const back = manifestMod.readManifest(manifestPath);
+  assert.equal(back.files[0].classification.decision, 'AUTO');
+});
+
+test('malformed row (missing Decision column) throws', function () {
+  const mdPath = path.join(tmpRoot, 'bad.md');
+  let out = '| File | Section | Confidence | Evidence | Decision |\n';
+  out += '|------|---------|------------|----------|----------|\n';
+  out += '| notes/a.md | problem-definition | 0.84 | "ok" |\n';
+  fs.writeFileSync(mdPath, out, 'utf8');
+  assert.throws(function () { sync.parseClassificationsMarkdown(mdPath); }, /malformed classifications row/);
+});
+
+test('confidence "0.84" parses as Number 0.84 (not string)', function () {
+  const mdPath = path.join(tmpRoot, 'num.md');
+  writeClassificationsMd(mdPath, [
+    { file: 'notes/a.md', section: 'problem-definition', confidence: '0.84', evidence: 'ok', decision: 'AUTO' }
+  ]);
+  const parsed = sync.parseClassificationsMarkdown(mdPath);
+  assert.equal(typeof parsed[0].confidence, 'number');
+  assert.equal(parsed[0].confidence, 0.84);
+});
+
+process.stdout.write('\n' + passed + ' passed, ' + failed + ' failed\n');
+if (failed > 0) process.exit(1);
+process.stdout.write('PASS\n');