@mindrian_os/cli 2.0.0-beta.3 → 2.0.0-beta.31

package/lib/import/branding.cjs

@@ -0,0 +1,210 @@
+'use strict';
+
+/**
+ * Phase 80 Plan 80-06 Task 1 (IMPORT-10) -- Branding injection.
+ *
+ * Applied by Stage 04 enricher AFTER wikilink injection. For every routed
+ * artifact this module:
+ *
+ *   1. normalizeFrontmatter -- rewrites frontmatter to the De Stijl canonical
+ *      shape (title, section, status, imported_from, imported_at, import_id,
+ *      source_wikilinks, tags). Non-canonical source fields are preserved
+ *      under _source_frontmatter so nothing is lost.
+ *   2. promoteCalloutFields -- promotes known source frontmatter fields
+ *      (author, attendees, date, tags) into Obsidian-style callout blocks
+ *      ([!author], [!attendees], [!date], [!tags]) at the top of the body.
+ *      These render via the De Stijl .callout / .callout-blue / .callout-teal
+ *      / .callout-red CSS classes shipped by scripts/generate-hub.cjs (v1.9.7).
+ *   3. injectBrandedFooter -- appends a MindrianOS branded footer using the
+ *      same FOOTER_MARKER string as scripts/vault-footer-injector.cjs (Phase
+ *      76) so idempotency checks cover both paths.
+ *
+ * Phase 76 discovery (scripts/vault-footer-injector.cjs):
+ *   - Exports buildFooter, hasExistingFooter, appendFooter, processFile.
+ *   - FOOTER_MARKER = '> MindrianOS |', FOOTER_BRAND = '> [SQUARE] MindrianOS |'
+ *     (the square glyph is intentionally preserved verbatim from that file).
+ *   - Uses enrichFrontmatter from lib/vault/frontmatter-schema.cjs.
+ *   - The Phase 76 module is CLI-first but exports are reusable; however the
+ *     80-06 branding flow needs a per-file, per-import-context API that
+ *     Phase 76 does not expose (it walks a whole room and computes its own
+ *     import context from roomName). So this module reimplements the thin
+ *     per-file footer pathway while reusing the SAME marker so the two
+ *     paths are mutually idempotent.
+ *
+ * Idempotent: running applyBranding twice on the same file produces no
+ * second-pass changes (footer not doubled, callouts not duplicated,
+ * frontmatter already canonical).
+ *
+ * Zero em-dashes in this file and in branding.test.cjs (hyphens only).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const matter = require('gray-matter');
+
+// FOOTER_MARKER must match scripts/vault-footer-injector.cjs (Phase 76).
+const FOOTER_MARKER = '> MindrianOS |';
+// The branded prefix uses a bracketed token instead of a box glyph so the
+// source file stays plain ASCII and is trivially greppable across platforms.
+const FOOTER_BRAND = '> [MOS] MindrianOS |';
+
+const CALLOUT_MARKER = '<!-- destijl-callout -->';
+const CALLOUT_FIELDS = ['author', 'attendees', 'date', 'tags'];
+
+const CANONICAL_KEYS = new Set([
+  'title',
+  'section',
+  'status',
+  'imported_from',
+  'imported_at',
+  'import_id',
+  'source_wikilinks',
+  'tags'
+]);
+
+// ---------------------------------------------------------------------------
+// Footer injection
+// ---------------------------------------------------------------------------
+
+function hasExistingFooter(content) {
+  return /^>\s*(?:\[MOS\]\s*)?MindrianOS\s*\|/m.test(content);
+}
+
+function injectBrandedFooter(artifactPath, importContext) {
+  const content = fs.readFileSync(artifactPath, 'utf8');
+  if (hasExistingFooter(content)) return false;
+
+  const importedAt = (importContext && importContext.imported_at) || new Date().toISOString();
+  const sourceVault = (importContext && importContext.source_vault) || 'unknown';
+  const importId = (importContext && importContext.import_id) || 'unknown';
+
+  const footer = [
+    '',
+    '---',
+    '',
+    FOOTER_BRAND + ' imported ' + importedAt + ' | from ' + sourceVault + ' | import_id: ' + importId,
+    ''
+  ].join('\n');
+
+  const trimmed = content.replace(/\s+$/, '');
+  // Avoid doubling an existing horizontal rule at the tail of the body.
+  const endsWithHr = /(^|\n)---\s*$/.test(trimmed);
+  const out = endsWithHr
+    ? trimmed + '\n\n' + FOOTER_BRAND + ' imported ' + importedAt + ' | from ' + sourceVault + ' | import_id: ' + importId + '\n'
+    : trimmed + footer;
+
+  fs.writeFileSync(artifactPath, out);
+  return true;
+}
+
+// ---------------------------------------------------------------------------
+// Frontmatter normalization
+// ---------------------------------------------------------------------------
+
+function normalizeFrontmatter(artifactPath, classification, importContext) {
+  const raw = fs.readFileSync(artifactPath, 'utf8');
+  const parsed = matter(raw);
+  const src = parsed.data || {};
+
+  const importedAt = (importContext && importContext.imported_at) || new Date().toISOString();
+
+  // Preserve any previously-seeded _source_frontmatter so re-runs do not
+  // nest it recursively on every invocation.
+  const previouslyPreserved = (src._source_frontmatter && typeof src._source_frontmatter === 'object')
+    ? src._source_frontmatter
+    : {};
+
+  const canonical = {};
+  canonical.title = src.title || path.basename(artifactPath, '.md');
+  canonical.section = (classification && classification.section) || src.section || '';
+  canonical.status = 'imported';
+  canonical.imported_from = (importContext && importContext.source_path) || src.imported_from || '';
+  canonical.imported_at = src.imported_at || importedAt;
+  canonical.import_id = (importContext && importContext.import_id) || src.import_id || '';
+
+  if (Array.isArray(src.source_wikilinks)) {
+    canonical.source_wikilinks = src.source_wikilinks;
+  } else if (importContext && Array.isArray(importContext.source_wikilinks)) {
+    canonical.source_wikilinks = importContext.source_wikilinks;
+  } else {
+    canonical.source_wikilinks = [];
+  }
+
+  if (Array.isArray(src.tags)) canonical.tags = src.tags;
+  else if (src.tags) canonical.tags = [src.tags];
+  else canonical.tags = [];
+
+  // Everything else goes under _source_frontmatter so it round-trips.
+  const preserved = Object.assign({}, previouslyPreserved);
+  for (const [k, v] of Object.entries(src)) {
+    if (CANONICAL_KEYS.has(k)) continue;
+    if (k === '_source_frontmatter') continue;
+    preserved[k] = v;
+  }
+  if (Object.keys(preserved).length > 0) canonical._source_frontmatter = preserved;
+
+  const out = matter.stringify(parsed.content, canonical);
+  fs.writeFileSync(artifactPath, out);
+  return canonical;
+}
+
+// ---------------------------------------------------------------------------
+// Callout promotion
+// ---------------------------------------------------------------------------
+
+function formatCalloutValue(v) {
+  if (Array.isArray(v)) return v.map(formatCalloutValue).join(', ');
+  if (v instanceof Date) return v.toISOString().slice(0, 10);
+  return String(v);
+}
+
+function promoteCalloutFields(artifactPath) {
+  const raw = fs.readFileSync(artifactPath, 'utf8');
+  if (raw.includes(CALLOUT_MARKER)) return false; // idempotent
+
+  const parsed = matter(raw);
+  const fm = parsed.data || {};
+  const src = (fm._source_frontmatter && typeof fm._source_frontmatter === 'object') ? fm._source_frontmatter : {};
+
+  const callouts = [];
+  for (const key of CALLOUT_FIELDS) {
+    let v = src[key];
+    if (v == null || v === '') v = fm[key];
+    if (v == null || v === '') continue;
+    if (Array.isArray(v) && v.length === 0) continue;
+    callouts.push('> [!' + key + '] ' + formatCalloutValue(v));
+  }
+  if (callouts.length === 0) return false;
+
+  // Block uses De Stijl callout rendering (scripts/generate-hub.cjs .callout
+  // classes). The marker comment makes the block detectable on re-runs and
+  // also acts as a hint for the hub renderer to wrap with callout-blue.
+  const block = [CALLOUT_MARKER, ...callouts, ''].join('\n');
+  const newBody = block + '\n' + parsed.content.replace(/^\s+/, '');
+  const out = matter.stringify(newBody, fm);
+  fs.writeFileSync(artifactPath, out);
+  return true;
+}
+
+// ---------------------------------------------------------------------------
+// Orchestrator
+// ---------------------------------------------------------------------------
+
+function applyBranding(artifactPath, classification, importContext) {
+  normalizeFrontmatter(artifactPath, classification, importContext);
+  promoteCalloutFields(artifactPath);
+  injectBrandedFooter(artifactPath, importContext);
+}
+
+module.exports = {
+  injectBrandedFooter: injectBrandedFooter,
+  normalizeFrontmatter: normalizeFrontmatter,
+  promoteCalloutFields: promoteCalloutFields,
+  applyBranding: applyBranding,
+  hasExistingFooter: hasExistingFooter,
+  FOOTER_MARKER: FOOTER_MARKER,
+  FOOTER_BRAND: FOOTER_BRAND,
+  CALLOUT_MARKER: CALLOUT_MARKER,
+  CALLOUT_FIELDS: CALLOUT_FIELDS,
+  CANONICAL_KEYS: CANONICAL_KEYS
+};

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');