gsd-pi 2.45.0-dev.fdcf73c → 2.46.0-dev.cc9d310

package/src/resources/extensions/gsd/tests/sync-lock.test.ts

@@ -0,0 +1,122 @@
+// GSD Extension — sync-lock unit tests
+// Tests acquireSyncLock() and releaseSyncLock().
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { acquireSyncLock, releaseSyncLock } from '../sync-lock.ts';
+
+function tempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-sync-lock-'));
+}
+
+function cleanupDir(dirPath: string): void {
+  try { fs.rmSync(dirPath, { recursive: true, force: true }); } catch { /* best effort */ }
+}
+
+// ─── acquireSyncLock ─────────────────────────────────────────────────────
+
+test('sync-lock: acquireSyncLock returns { acquired: true } when no lock exists', () => {
+  const base = tempDir();
+  fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+  try {
+    const result = acquireSyncLock(base);
+    assert.strictEqual(result.acquired, true);
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('sync-lock: acquireSyncLock creates lock file at .gsd/sync.lock', () => {
+  const base = tempDir();
+  fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+  try {
+    acquireSyncLock(base);
+    const lockPath = path.join(base, '.gsd', 'sync.lock');
+    assert.ok(fs.existsSync(lockPath), 'sync.lock should exist after acquire');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('sync-lock: lock file contains pid and acquired_at fields', () => {
+  const base = tempDir();
+  fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+  try {
+    acquireSyncLock(base);
+    const lockPath = path.join(base, '.gsd', 'sync.lock');
+    const content = JSON.parse(fs.readFileSync(lockPath, 'utf-8'));
+    assert.strictEqual(typeof content.pid, 'number');
+    assert.strictEqual(typeof content.acquired_at, 'string');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+// ─── releaseSyncLock ─────────────────────────────────────────────────────
+
+test('sync-lock: releaseSyncLock removes lock file', () => {
+  const base = tempDir();
+  fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+  try {
+    acquireSyncLock(base);
+    const lockPath = path.join(base, '.gsd', 'sync.lock');
+    assert.ok(fs.existsSync(lockPath), 'lock file should exist before release');
+    releaseSyncLock(base);
+    assert.ok(!fs.existsSync(lockPath), 'lock file should not exist after release');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('sync-lock: releaseSyncLock is a no-op when no lock file exists', () => {
+  const base = tempDir();
+  fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+  try {
+    // Should not throw
+    releaseSyncLock(base);
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+// ─── acquire → release → re-acquire round-trip ───────────────────────────
+
+test('sync-lock: can re-acquire after release', () => {
+  const base = tempDir();
+  fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+  try {
+    const r1 = acquireSyncLock(base);
+    assert.strictEqual(r1.acquired, true, 'first acquire should succeed');
+    releaseSyncLock(base);
+    const r2 = acquireSyncLock(base);
+    assert.strictEqual(r2.acquired, true, 're-acquire after release should succeed');
+    releaseSyncLock(base);
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+// ─── stale lock override ─────────────────────────────────────────────────
+
+test('sync-lock: overrides stale lock file (mtime backdated)', (t) => {
+  const base = tempDir();
+  fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+  const lockPath = path.join(base, '.gsd', 'sync.lock');
+  try {
+    // Write a lock file with a very old mtime (simulating staleness)
+    fs.writeFileSync(lockPath, JSON.stringify({ pid: 99999, acquired_at: new Date(0).toISOString() }));
+    // Backdate mtime by 2 minutes
+    const staleTime = new Date(Date.now() - 120_000);
+    fs.utimesSync(lockPath, staleTime, staleTime);
+
+    // Should override stale lock and acquire
+    const result = acquireSyncLock(base, 500);
+    assert.strictEqual(result.acquired, true, 'should acquire over stale lock');
+    releaseSyncLock(base);
+  } finally {
+    cleanupDir(base);
+  }
+});

package/src/resources/extensions/gsd/tests/unit-ownership.test.ts

@@ -0,0 +1,175 @@
+// GSD — unit-ownership tests
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  claimUnit,
+  releaseUnit,
+  getOwner,
+  checkOwnership,
+  taskUnitKey,
+  sliceUnitKey,
+} from '../unit-ownership.ts';
+
+function makeTmpBase(): string {
+  return mkdtempSync(join(tmpdir(), 'gsd-ownership-'));
+}
+
+function cleanup(base: string): void {
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+// ─── Key builders ────────────────────────────────────────────────────────
+
+test('taskUnitKey: builds correct key', () => {
+  assert.equal(taskUnitKey('M001', 'S01', 'T01'), 'M001/S01/T01');
+});
+
+test('sliceUnitKey: builds correct key', () => {
+  assert.equal(sliceUnitKey('M001', 'S01'), 'M001/S01');
+});
+
+// ─── Claim / get / release ───────────────────────────────────────────────
+
+test('claimUnit: creates claim file and records agent', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'executor-01');
+
+    assert.ok(existsSync(join(base, '.gsd', 'unit-claims.json')), 'claim file should exist');
+    assert.equal(getOwner(base, 'M001/S01/T01'), 'executor-01');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('claimUnit: overwrites existing claim (last writer wins)', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'executor-01');
+    claimUnit(base, 'M001/S01/T01', 'executor-02');
+
+    assert.equal(getOwner(base, 'M001/S01/T01'), 'executor-02');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('claimUnit: multiple units can be claimed independently', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+    claimUnit(base, 'M001/S01/T02', 'agent-b');
+
+    assert.equal(getOwner(base, 'M001/S01/T01'), 'agent-a');
+    assert.equal(getOwner(base, 'M001/S01/T02'), 'agent-b');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('getOwner: returns null when no claim file exists', () => {
+  const base = makeTmpBase();
+  try {
+    assert.equal(getOwner(base, 'M001/S01/T01'), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('getOwner: returns null for unclaimed unit', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+    assert.equal(getOwner(base, 'M001/S01/T99'), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('releaseUnit: removes claim', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+    releaseUnit(base, 'M001/S01/T01');
+
+    assert.equal(getOwner(base, 'M001/S01/T01'), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('releaseUnit: no-op for non-existent claim', () => {
+  const base = makeTmpBase();
+  try {
+    // Should not throw
+    releaseUnit(base, 'M001/S01/T01');
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── checkOwnership ──────────────────────────────────────────────────────
+
+test('checkOwnership: returns null when no actorName provided (opt-in)', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+
+    // No actorName → ownership not enforced
+    assert.equal(checkOwnership(base, 'M001/S01/T01', undefined), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('checkOwnership: returns null when no claim file exists', () => {
+  const base = makeTmpBase();
+  try {
+    assert.equal(checkOwnership(base, 'M001/S01/T01', 'agent-a'), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('checkOwnership: returns null when unit is unclaimed', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+
+    // Different unit, unclaimed
+    assert.equal(checkOwnership(base, 'M001/S01/T99', 'agent-b'), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('checkOwnership: returns null when actor matches owner', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+
+    assert.equal(checkOwnership(base, 'M001/S01/T01', 'agent-a'), null);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('checkOwnership: returns error string when actor does not match owner', () => {
+  const base = makeTmpBase();
+  try {
+    claimUnit(base, 'M001/S01/T01', 'agent-a');
+
+    const err = checkOwnership(base, 'M001/S01/T01', 'agent-b');
+    assert.ok(err !== null, 'should return error');
+    assert.match(err!, /owned by agent-a/);
+    assert.match(err!, /not agent-b/);
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/workflow-events.test.ts

@@ -0,0 +1,205 @@
+// GSD Extension — workflow-events unit tests
+// Tests appendEvent, readEvents, findForkPoint, compactMilestoneEvents.
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  appendEvent,
+  readEvents,
+  findForkPoint,
+  compactMilestoneEvents,
+  type WorkflowEvent,
+} from '../workflow-events.ts';
+
+function tempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-events-'));
+}
+
+function cleanupDir(dirPath: string): void {
+  try { fs.rmSync(dirPath, { recursive: true, force: true }); } catch { /* best effort */ }
+}
+
+function makeEvent(cmd: string, params: Record<string, unknown> = {}): Omit<WorkflowEvent, 'hash' | 'session_id'> {
+  return { cmd, params, ts: new Date().toISOString(), actor: 'agent' };
+}
+
+// ─── appendEvent ─────────────────────────────────────────────────────────
+
+test('workflow-events: appendEvent creates .gsd dir and event-log.jsonl', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M001', taskId: 'T01' }));
+    assert.ok(fs.existsSync(path.join(base, '.gsd', 'event-log.jsonl')));
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('workflow-events: appendEvent writes valid JSON line', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M001', taskId: 'T01' }));
+    const content = fs.readFileSync(path.join(base, '.gsd', 'event-log.jsonl'), 'utf-8');
+    const lines = content.trim().split('\n');
+    assert.strictEqual(lines.length, 1);
+    const parsed = JSON.parse(lines[0]!) as WorkflowEvent;
+    assert.strictEqual(parsed.cmd, 'complete-task');
+    assert.strictEqual(parsed.actor, 'agent');
+    assert.strictEqual(typeof parsed.hash, 'string');
+    assert.strictEqual(parsed.hash.length, 16);
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('workflow-events: appendEvent appends multiple events', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { taskId: 'T01' }));
+    appendEvent(base, makeEvent('complete-slice', { sliceId: 'S01' }));
+    const events = readEvents(path.join(base, '.gsd', 'event-log.jsonl'));
+    assert.strictEqual(events.length, 2);
+    assert.strictEqual(events[0]!.cmd, 'complete-task');
+    assert.strictEqual(events[1]!.cmd, 'complete-slice');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('workflow-events: same cmd+params → same hash (deterministic)', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('plan-task', { milestoneId: 'M001', sliceId: 'S01' }));
+    appendEvent(base, makeEvent('plan-task', { milestoneId: 'M001', sliceId: 'S01' }));
+    const events = readEvents(path.join(base, '.gsd', 'event-log.jsonl'));
+    assert.strictEqual(events[0]!.hash, events[1]!.hash, 'identical cmd+params produce identical hash');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('workflow-events: different params → different hash', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { taskId: 'T01' }));
+    appendEvent(base, makeEvent('complete-task', { taskId: 'T02' }));
+    const events = readEvents(path.join(base, '.gsd', 'event-log.jsonl'));
+    assert.notStrictEqual(events[0]!.hash, events[1]!.hash, 'different params produce different hash');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+// ─── readEvents ──────────────────────────────────────────────────────────
+
+test('workflow-events: readEvents returns [] for non-existent file', () => {
+  const result = readEvents('/nonexistent/path/event-log.jsonl');
+  assert.deepStrictEqual(result, []);
+});
+
+test('workflow-events: readEvents skips corrupted lines', () => {
+  const base = tempDir();
+  try {
+    fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+    const logPath = path.join(base, '.gsd', 'event-log.jsonl');
+    // Write a valid line, a corrupted line, and another valid line
+    fs.writeFileSync(logPath,
+      '{"cmd":"complete-task","params":{},"ts":"2026-01-01T00:00:00Z","hash":"abcd1234abcd1234","actor":"agent"}\n' +
+      'NOT VALID JSON {{{{\n' +
+      '{"cmd":"plan-task","params":{},"ts":"2026-01-01T00:00:01Z","hash":"1234abcd1234abcd","actor":"system"}\n',
+    );
+    const events = readEvents(logPath);
+    assert.strictEqual(events.length, 2, 'should return 2 valid events, skipping the corrupted line');
+    assert.strictEqual(events[0]!.cmd, 'complete-task');
+    assert.strictEqual(events[1]!.cmd, 'plan-task');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+// ─── findForkPoint ───────────────────────────────────────────────────────
+
+test('workflow-events: findForkPoint returns -1 for two empty logs', () => {
+  assert.strictEqual(findForkPoint([], []), -1);
+});
+
+test('workflow-events: findForkPoint returns -1 when first events differ', () => {
+  const e1 = { cmd: 'a', params: {}, ts: '', hash: 'hash1', actor: 'agent' } as WorkflowEvent;
+  const e2 = { cmd: 'b', params: {}, ts: '', hash: 'hash2', actor: 'agent' } as WorkflowEvent;
+  assert.strictEqual(findForkPoint([e1], [e2]), -1);
+});
+
+test('workflow-events: findForkPoint returns 0 when only first event is common', () => {
+  const common = { cmd: 'a', params: {}, ts: '', hash: 'hash1', actor: 'agent' } as WorkflowEvent;
+  const eA = { cmd: 'b', params: {}, ts: '', hash: 'hash2', actor: 'agent' } as WorkflowEvent;
+  const eB = { cmd: 'c', params: {}, ts: '', hash: 'hash3', actor: 'agent' } as WorkflowEvent;
+  // logA: [common, eA], logB: [common, eB]
+  assert.strictEqual(findForkPoint([common, eA], [common, eB]), 0);
+});
+
+test('workflow-events: findForkPoint returns last common index for prefix relationship', () => {
+  const e1 = { cmd: 'a', params: {}, ts: '', hash: 'h1', actor: 'agent' } as WorkflowEvent;
+  const e2 = { cmd: 'b', params: {}, ts: '', hash: 'h2', actor: 'agent' } as WorkflowEvent;
+  const e3 = { cmd: 'c', params: {}, ts: '', hash: 'h3', actor: 'agent' } as WorkflowEvent;
+  // logA is a prefix of logB → fork point is last index of logA
+  assert.strictEqual(findForkPoint([e1, e2], [e1, e2, e3]), 1);
+});
+
+test('workflow-events: findForkPoint handles equal logs', () => {
+  const e1 = { cmd: 'a', params: {}, ts: '', hash: 'h1', actor: 'agent' } as WorkflowEvent;
+  const e2 = { cmd: 'b', params: {}, ts: '', hash: 'h2', actor: 'agent' } as WorkflowEvent;
+  assert.strictEqual(findForkPoint([e1, e2], [e1, e2]), 1);
+});
+
+// ─── compactMilestoneEvents ──────────────────────────────────────────────
+
+test('workflow-events: compactMilestoneEvents returns { archived: 0 } when no matching events', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M002', taskId: 'T01' }));
+    const result = compactMilestoneEvents(base, 'M001');
+    assert.strictEqual(result.archived, 0);
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('workflow-events: compactMilestoneEvents archives milestone events', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M001', taskId: 'T01' }));
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M001', taskId: 'T02' }));
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M002', taskId: 'T03' }));
+
+    const result = compactMilestoneEvents(base, 'M001');
+    assert.strictEqual(result.archived, 2, 'should archive 2 M001 events');
+
+    // Archive file should exist
+    const archivePath = path.join(base, '.gsd', 'event-log-M001.jsonl.archived');
+    assert.ok(fs.existsSync(archivePath), 'archive file should exist');
+    const archived = readEvents(archivePath);
+    assert.strictEqual(archived.length, 2, 'archive file should have 2 events');
+
+    // Active log should retain only M002 event
+    const active = readEvents(path.join(base, '.gsd', 'event-log.jsonl'));
+    assert.strictEqual(active.length, 1, 'active log should have 1 remaining event');
+    assert.strictEqual((active[0]!.params as { milestoneId?: string }).milestoneId, 'M002');
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+test('workflow-events: compactMilestoneEvents empties active log when all events are from milestone', () => {
+  const base = tempDir();
+  try {
+    appendEvent(base, makeEvent('complete-task', { milestoneId: 'M001', taskId: 'T01' }));
+    compactMilestoneEvents(base, 'M001');
+    const active = readEvents(path.join(base, '.gsd', 'event-log.jsonl'));
+    assert.strictEqual(active.length, 0, 'active log should be empty after full compact');
+  } finally {
+    cleanupDir(base);
+  }
+});

package/src/resources/extensions/gsd/tests/workflow-manifest.test.ts

@@ -0,0 +1,186 @@
+// GSD Extension — workflow-manifest unit tests
+// Tests writeManifest, readManifest, snapshotState, bootstrapFromManifest.
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+} from '../gsd-db.ts';
+import {
+  writeManifest,
+  readManifest,
+  snapshotState,
+  bootstrapFromManifest,
+} from '../workflow-manifest.ts';
+
+function tempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-manifest-'));
+}
+
+function tempDbPath(base: string): string {
+  return path.join(base, 'test.db');
+}
+
+function cleanupDir(dirPath: string): void {
+  try { fs.rmSync(dirPath, { recursive: true, force: true }); } catch { /* best effort */ }
+}
+
+// ─── readManifest: no file ────────────────────────────────────────────────
+
+test('workflow-manifest: readManifest returns null when file does not exist', () => {
+  const base = tempDir();
+  try {
+    const result = readManifest(base);
+    assert.strictEqual(result, null);
+  } finally {
+    cleanupDir(base);
+  }
+});
+
+// ─── writeManifest + readManifest round-trip ─────────────────────────────
+
+test('workflow-manifest: writeManifest creates state-manifest.json with version 1', () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    writeManifest(base);
+    const manifestPath = path.join(base, '.gsd', 'state-manifest.json');
+    assert.ok(fs.existsSync(manifestPath), 'state-manifest.json should exist');
+    const raw = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+    assert.strictEqual(raw.version, 1);
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+test('workflow-manifest: readManifest parses manifest written by writeManifest', () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    writeManifest(base);
+    const manifest = readManifest(base);
+    assert.ok(manifest !== null);
+    assert.strictEqual(manifest!.version, 1);
+    assert.ok(typeof manifest!.exported_at === 'string');
+    assert.ok(Array.isArray(manifest!.milestones));
+    assert.ok(Array.isArray(manifest!.slices));
+    assert.ok(Array.isArray(manifest!.tasks));
+    assert.ok(Array.isArray(manifest!.decisions));
+    assert.ok(Array.isArray(manifest!.verification_evidence));
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+// ─── snapshotState: captures DB rows ─────────────────────────────────────
+
+test('workflow-manifest: snapshotState includes inserted milestone', () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    insertMilestone({ id: 'M001', title: 'Auth Milestone' });
+    const snap = snapshotState();
+    assert.strictEqual(snap.version, 1);
+    const m = snap.milestones.find((r) => r.id === 'M001');
+    assert.ok(m !== undefined, 'M001 should appear in snapshot');
+    assert.strictEqual(m!.title, 'Auth Milestone');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+test('workflow-manifest: snapshotState captures tasks', () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    insertMilestone({ id: 'M001' });
+    insertSlice({ id: 'S01', milestoneId: 'M001' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Do thing', status: 'complete' });
+    const snap = snapshotState();
+    const t = snap.tasks.find((r) => r.id === 'T01');
+    assert.ok(t !== undefined, 'T01 should appear in snapshot');
+    assert.strictEqual(t!.status, 'complete');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+// ─── bootstrapFromManifest ────────────────────────────────────────────────
+
+test('workflow-manifest: bootstrapFromManifest returns false when no manifest file', () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    const result = bootstrapFromManifest(base);
+    assert.strictEqual(result, false);
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+test('workflow-manifest: bootstrapFromManifest restores DB from manifest (round-trip)', () => {
+  const base = tempDir();
+  openDatabase(tempDbPath(base));
+  try {
+    // Insert data and write manifest
+    insertMilestone({ id: 'M001', title: 'Restored Milestone' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Restored Slice' });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Restored Task', status: 'complete' });
+    writeManifest(base);
+    closeDatabase();
+
+    // Open a fresh DB and bootstrap from manifest
+    const newDbPath = path.join(base, 'new.db');
+    openDatabase(newDbPath);
+    const result = bootstrapFromManifest(base);
+    assert.strictEqual(result, true, 'bootstrapFromManifest should return true');
+
+    // Verify restored state
+    const snap = snapshotState();
+    const m = snap.milestones.find((r) => r.id === 'M001');
+    assert.ok(m !== undefined, 'M001 should be restored');
+    assert.strictEqual(m!.title, 'Restored Milestone');
+
+    const s = snap.slices.find((r) => r.id === 'S01');
+    assert.ok(s !== undefined, 'S01 should be restored');
+
+    const t = snap.tasks.find((r) => r.id === 'T01');
+    assert.ok(t !== undefined, 'T01 should be restored');
+    assert.strictEqual(t!.status, 'complete');
+  } finally {
+    closeDatabase();
+    cleanupDir(base);
+  }
+});
+
+// ─── readManifest: version check ─────────────────────────────────────────
+
+test('workflow-manifest: readManifest throws on unsupported version', () => {
+  const base = tempDir();
+  try {
+    fs.mkdirSync(path.join(base, '.gsd'), { recursive: true });
+    fs.writeFileSync(
+      path.join(base, '.gsd', 'state-manifest.json'),
+      JSON.stringify({ version: 99, exported_at: '', milestones: [], slices: [], tasks: [], decisions: [], verification_evidence: [] }),
+    );
+    assert.throws(
+      () => readManifest(base),
+      /Unsupported manifest version/,
+      'should throw on version mismatch',
+    );
+  } finally {
+    cleanupDir(base);
+  }
+});