gsd-pi 2.41.0 → 2.42.0-dev.1df898f

package/src/resources/extensions/gsd/tests/journal.test.ts

@@ -0,0 +1,341 @@
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdirSync,
+  readFileSync,
+  existsSync,
+  rmSync,
+  chmodSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import {
+  emitJournalEvent,
+  queryJournal,
+  type JournalEntry,
+} from "../journal.ts";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-journal-test-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try {
+    rmSync(base, { recursive: true, force: true });
+  } catch {
+    /* */
+  }
+}
+
+function makeEntry(overrides: Partial<JournalEntry> = {}): JournalEntry {
+  return {
+    ts: "2025-03-21T10:00:00.000Z",
+    flowId: "flow-aaa",
+    seq: 0,
+    eventType: "iteration-start",
+    ...overrides,
+  };
+}
+
+// ─── emitJournalEvent ─────────────────────────────────────────────────────────
+
+describe("emitJournalEvent", () => {
+  let base: string;
+  beforeEach(() => { base = makeTmpBase(); });
+  afterEach(() => { cleanup(base); });
+
+  test("creates journal directory and JSONL file", () => {
+    const entry = makeEntry();
+    emitJournalEvent(base, entry);
+
+    const filePath = join(base, ".gsd", "journal", "2025-03-21.jsonl");
+    assert.ok(existsSync(filePath), "JSONL file should exist");
+
+    const raw = readFileSync(filePath, "utf-8").trim();
+    const parsed = JSON.parse(raw);
+    assert.equal(parsed.ts, entry.ts);
+    assert.equal(parsed.flowId, entry.flowId);
+    assert.equal(parsed.seq, entry.seq);
+    assert.equal(parsed.eventType, entry.eventType);
+  });
+
+  test("appends multiple lines to the same file", () => {
+    emitJournalEvent(base, makeEntry({ seq: 0 }));
+    emitJournalEvent(base, makeEntry({ seq: 1, eventType: "dispatch-match" }));
+    emitJournalEvent(base, makeEntry({ seq: 2, eventType: "unit-start" }));
+
+    const filePath = join(base, ".gsd", "journal", "2025-03-21.jsonl");
+    const lines = readFileSync(filePath, "utf-8").trim().split("\n");
+    assert.equal(lines.length, 3, "Should have 3 lines");
+
+    const parsed = lines.map(l => JSON.parse(l));
+    assert.equal(parsed[0].seq, 0);
+    assert.equal(parsed[1].seq, 1);
+    assert.equal(parsed[2].seq, 2);
+    assert.equal(parsed[1].eventType, "dispatch-match");
+  });
+
+  test("preserves optional fields (rule, causedBy, data)", () => {
+    const entry = makeEntry({
+      rule: "my-dispatch-rule",
+      causedBy: { flowId: "flow-prior", seq: 3 },
+      data: { unitId: "M001/S01/T01", status: "ok" },
+    });
+    emitJournalEvent(base, entry);
+
+    const filePath = join(base, ".gsd", "journal", "2025-03-21.jsonl");
+    const parsed = JSON.parse(readFileSync(filePath, "utf-8").trim());
+    assert.equal(parsed.rule, "my-dispatch-rule");
+    assert.deepEqual(parsed.causedBy, { flowId: "flow-prior", seq: 3 });
+    assert.equal(parsed.data.unitId, "M001/S01/T01");
+    assert.equal(parsed.data.status, "ok");
+  });
+
+  test("silently catches read-only directory errors", () => {
+    const journalDir = join(base, ".gsd", "journal");
+    mkdirSync(journalDir, { recursive: true });
+
+    // Make the journal directory read-only
+    chmodSync(journalDir, 0o444);
+
+    // Should not throw
+    assert.doesNotThrow(() => {
+      emitJournalEvent(base, makeEntry());
+    });
+
+    // Restore permissions for cleanup
+    try {
+      chmodSync(journalDir, 0o755);
+    } catch {
+      /* */
+    }
+  });
+});
+
+describe("emitJournalEvent — auto-creates parent directory", () => {
+  let base: string;
+  beforeEach(() => {
+    base = join(tmpdir(), `gsd-journal-test-${randomUUID()}`);
+    // Don't create .gsd/ — emitJournalEvent should handle it via mkdirSync recursive
+  });
+  afterEach(() => { cleanup(base); });
+
+  test("auto-creates nonexistent parent directory", () => {
+    emitJournalEvent(base, makeEntry());
+    const filePath = join(base, ".gsd", "journal", "2025-03-21.jsonl");
+    assert.ok(existsSync(filePath), "File should exist even when parent dirs did not");
+  });
+});
+
+test("emitJournalEvent silently catches write errors (no throw)", () => {
+  // Use a path that can't be created — null bytes in path
+  assert.doesNotThrow(() => {
+    emitJournalEvent("/dev/null/impossible\0path", makeEntry());
+  });
+});
+
+// ─── Daily Rotation ───────────────────────────────────────────────────────────
+
+describe("daily rotation", () => {
+  let base: string;
+  beforeEach(() => { base = makeTmpBase(); });
+  afterEach(() => { cleanup(base); });
+
+  test("events with different dates go to different files", () => {
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-20T23:59:59.000Z" }));
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-21T00:00:01.000Z" }));
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-22T12:00:00.000Z" }));
+
+    const journalDir = join(base, ".gsd", "journal");
+    assert.ok(existsSync(join(journalDir, "2025-03-20.jsonl")));
+    assert.ok(existsSync(join(journalDir, "2025-03-21.jsonl")));
+    assert.ok(existsSync(join(journalDir, "2025-03-22.jsonl")));
+
+    // Verify each file has exactly one line
+    for (const date of ["2025-03-20", "2025-03-21", "2025-03-22"]) {
+      const lines = readFileSync(join(journalDir, `${date}.jsonl`), "utf-8")
+        .trim()
+        .split("\n");
+      assert.equal(lines.length, 1, `${date}.jsonl should have 1 line`);
+    }
+  });
+});
+
+// ─── queryJournal ─────────────────────────────────────────────────────────────
+
+describe("queryJournal", () => {
+  let base: string;
+  beforeEach(() => { base = makeTmpBase(); });
+  afterEach(() => { cleanup(base); });
+
+  test("returns all entries when no filters provided", () => {
+    emitJournalEvent(base, makeEntry({ seq: 0 }));
+    emitJournalEvent(base, makeEntry({ seq: 1, eventType: "dispatch-match" }));
+
+    const results = queryJournal(base);
+    assert.equal(results.length, 2);
+    assert.equal(results[0].seq, 0);
+    assert.equal(results[1].seq, 1);
+  });
+
+  test("filters by flowId", () => {
+    emitJournalEvent(base, makeEntry({ flowId: "flow-aaa", seq: 0 }));
+    emitJournalEvent(base, makeEntry({ flowId: "flow-bbb", seq: 1 }));
+    emitJournalEvent(base, makeEntry({ flowId: "flow-aaa", seq: 2 }));
+
+    const results = queryJournal(base, { flowId: "flow-aaa" });
+    assert.equal(results.length, 2);
+    assert.ok(results.every(e => e.flowId === "flow-aaa"));
+  });
+
+  test("filters by eventType", () => {
+    emitJournalEvent(base, makeEntry({ eventType: "iteration-start", seq: 0 }));
+    emitJournalEvent(base, makeEntry({ eventType: "dispatch-match", seq: 1 }));
+    emitJournalEvent(base, makeEntry({ eventType: "unit-start", seq: 2 }));
+    emitJournalEvent(base, makeEntry({ eventType: "dispatch-match", seq: 3 }));
+
+    const results = queryJournal(base, { eventType: "dispatch-match" });
+    assert.equal(results.length, 2);
+    assert.ok(results.every(e => e.eventType === "dispatch-match"));
+  });
+
+  test("filters by unitId (from data.unitId)", () => {
+    emitJournalEvent(
+      base,
+      makeEntry({ seq: 0, data: { unitId: "M001/S01/T01" } }),
+    );
+    emitJournalEvent(
+      base,
+      makeEntry({ seq: 1, data: { unitId: "M001/S01/T02" } }),
+    );
+    emitJournalEvent(
+      base,
+      makeEntry({ seq: 2, data: { unitId: "M001/S01/T01" } }),
+    );
+    emitJournalEvent(base, makeEntry({ seq: 3 })); // no data
+
+    const results = queryJournal(base, { unitId: "M001/S01/T01" });
+    assert.equal(results.length, 2);
+    assert.ok(
+      results.every(
+        e => (e.data as Record<string, unknown>)?.unitId === "M001/S01/T01",
+      ),
+    );
+  });
+
+  test("filters by time range (after/before)", () => {
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-20T08:00:00.000Z", seq: 0 }));
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-21T10:00:00.000Z", seq: 1 }));
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-21T15:00:00.000Z", seq: 2 }));
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-22T20:00:00.000Z", seq: 3 }));
+
+    // After only
+    const afterResults = queryJournal(base, { after: "2025-03-21T00:00:00.000Z" });
+    assert.equal(afterResults.length, 3, "3 entries on or after 2025-03-21");
+
+    // Before only
+    const beforeResults = queryJournal(base, { before: "2025-03-21T12:00:00.000Z" });
+    assert.equal(beforeResults.length, 2, "2 entries on or before noon on 03-21");
+
+    // Both after and before
+    const rangeResults = queryJournal(base, {
+      after: "2025-03-21T00:00:00.000Z",
+      before: "2025-03-21T23:59:59.000Z",
+    });
+    assert.equal(rangeResults.length, 2, "2 entries within 2025-03-21");
+  });
+
+  test("combines multiple filters", () => {
+    emitJournalEvent(
+      base,
+      makeEntry({ flowId: "flow-aaa", eventType: "unit-start", seq: 0 }),
+    );
+    emitJournalEvent(
+      base,
+      makeEntry({ flowId: "flow-aaa", eventType: "dispatch-match", seq: 1 }),
+    );
+    emitJournalEvent(
+      base,
+      makeEntry({ flowId: "flow-bbb", eventType: "unit-start", seq: 2 }),
+    );
+
+    const results = queryJournal(base, {
+      flowId: "flow-aaa",
+      eventType: "unit-start",
+    });
+    assert.equal(results.length, 1);
+    assert.equal(results[0].flowId, "flow-aaa");
+    assert.equal(results[0].eventType, "unit-start");
+  });
+
+  test("skips malformed JSON lines gracefully", () => {
+    const journalDir = join(base, ".gsd", "journal");
+    mkdirSync(journalDir, { recursive: true });
+
+    // Write a file with a mix of valid and invalid lines
+    const validEntry = JSON.stringify(makeEntry({ seq: 0 }));
+    const content = `${validEntry}\n{not valid json\n${JSON.stringify(makeEntry({ seq: 1 }))}\n`;
+    writeFileSync(join(journalDir, "2025-03-21.jsonl"), content);
+
+    const results = queryJournal(base);
+    assert.equal(results.length, 2, "Should skip the malformed line");
+    assert.equal(results[0].seq, 0);
+    assert.equal(results[1].seq, 1);
+  });
+
+  test("reads across multiple daily files", () => {
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-20T12:00:00.000Z", seq: 0 }));
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-21T12:00:00.000Z", seq: 1 }));
+    emitJournalEvent(base, makeEntry({ ts: "2025-03-22T12:00:00.000Z", seq: 2 }));
+
+    const results = queryJournal(base);
+    assert.equal(results.length, 3, "Should read from all 3 files");
+    // Files are sorted, so order should be chronological
+    assert.equal(results[0].ts, "2025-03-20T12:00:00.000Z");
+    assert.equal(results[1].ts, "2025-03-21T12:00:00.000Z");
+    assert.equal(results[2].ts, "2025-03-22T12:00:00.000Z");
+  });
+
+  test("filters by rule", () => {
+    emitJournalEvent(
+      base,
+      makeEntry({ seq: 0, eventType: "dispatch-match", rule: "dispatch-task" }),
+    );
+    emitJournalEvent(
+      base,
+      makeEntry({ seq: 1, eventType: "post-unit-hook", rule: "post-unit-hook" }),
+    );
+    emitJournalEvent(
+      base,
+      makeEntry({ seq: 2, eventType: "dispatch-match", rule: "dispatch-task" }),
+    );
+
+    const results = queryJournal(base, { rule: "dispatch-task" });
+    assert.equal(results.length, 2, "Should return only dispatch-task entries");
+    assert.ok(
+      results.every(e => e.rule === "dispatch-task"),
+      "All results should have rule === 'dispatch-task'",
+    );
+  });
+});
+
+describe("queryJournal — nonexistent directory", () => {
+  let base: string;
+  beforeEach(() => {
+    base = join(tmpdir(), `gsd-journal-test-${randomUUID()}`);
+    // Don't create anything
+  });
+  afterEach(() => { cleanup(base); });
+
+  test("on nonexistent directory returns empty array", () => {
+    const results = queryJournal(base);
+    assert.deepEqual(results, []);
+  });
+});

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

@@ -8,7 +8,7 @@
  * Uses temp directories with real .gsd/milestones/M001/ structure.
  */
 
-import test from 'node:test';
+import { describe, test, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
@@ -30,12 +30,21 @@ function writeManifest(base: string, content: string): void {
 
 // ─── Mixed statuses ──────────────────────────────────────────────────────────
 
-test('getManifestStatus: mixed statuses — categorizes entries correctly', async () => {
-  const tmp = makeTempDir('manifest-mixed');
-  const savedVal = process.env.GSD_TEST_EXISTING_KEY_001;
-  try {
+describe('getManifestStatus: mixed statuses', () => {
+  let tmp: string;
+  let savedVal: string | undefined;
+  beforeEach(() => {
+    tmp = makeTempDir('manifest-mixed');
+    savedVal = process.env.GSD_TEST_EXISTING_KEY_001;
     process.env.GSD_TEST_EXISTING_KEY_001 = 'some-value';
+  });
+  afterEach(() => {
+    delete process.env.GSD_TEST_EXISTING_KEY_001;
+    if (savedVal !== undefined) process.env.GSD_TEST_EXISTING_KEY_001 = savedVal;
+    rmSync(tmp, { recursive: true, force: true });
+  });
 
+  test('categorizes entries correctly', async () => {
     writeManifest(tmp, `# Secrets Manifest
 
 **Milestone:** M001
@@ -80,18 +89,17 @@ test('getManifestStatus: mixed statuses — categorizes entries correctly', asyn
     assert.deepStrictEqual(result!.collected, ['COLLECTED_KEY']);
     assert.deepStrictEqual(result!.skipped, ['SKIPPED_KEY']);
     assert.deepStrictEqual(result!.existing, ['GSD_TEST_EXISTING_KEY_001']);
-  } finally {
-    delete process.env.GSD_TEST_EXISTING_KEY_001;
-    if (savedVal !== undefined) process.env.GSD_TEST_EXISTING_KEY_001 = savedVal;
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  });
 });
 
 // ─── All pending ─────────────────────────────────────────────────────────────
 
-test('getManifestStatus: all pending — 3 pending entries, none in env', async () => {
-  const tmp = makeTempDir('manifest-pending');
-  try {
+describe('getManifestStatus: simple temp dir tests', () => {
+  let tmp: string;
+  beforeEach(() => { tmp = makeTempDir('manifest-test'); });
+  afterEach(() => { rmSync(tmp, { recursive: true, force: true }); });
+
+  test('all pending — 3 pending entries, none in env', async () => {
     // Ensure none of these are in process.env
     delete process.env.PEND_A;
     delete process.env.PEND_B;
@@ -133,16 +141,11 @@ test('getManifestStatus: all pending — 3 pending entries, none in env', async
     assert.deepStrictEqual(result!.collected, []);
     assert.deepStrictEqual(result!.skipped, []);
     assert.deepStrictEqual(result!.existing, []);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
+  });
 
-// ─── All collected ───────────────────────────────────────────────────────────
+  // ─── All collected ───────────────────────────────────────────────────────────
 
-test('getManifestStatus: all collected — 2 collected entries, none in env', async () => {
-  const tmp = makeTempDir('manifest-collected');
-  try {
+  test('all collected — 2 collected entries, none in env', async () => {
     delete process.env.COLL_X;
     delete process.env.COLL_Y;
 
@@ -174,64 +177,19 @@ test('getManifestStatus: all collected — 2 collected entries, none in env', as
     assert.deepStrictEqual(result!.collected, ['COLL_X', 'COLL_Y']);
     assert.deepStrictEqual(result!.skipped, []);
     assert.deepStrictEqual(result!.existing, []);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
-// ─── Key in env overrides manifest status ────────────────────────────────────
-
-test('getManifestStatus: key in env overrides manifest status — collected key in env goes to existing', async () => {
-  const tmp = makeTempDir('manifest-override');
-  const savedVal = process.env.GSD_TEST_OVERRIDE_KEY;
-  try {
-    process.env.GSD_TEST_OVERRIDE_KEY = 'already-here';
-
-    writeManifest(tmp, `# Secrets Manifest
-
-**Milestone:** M001
-**Generated:** 2025-06-20T10:00:00Z
-
-### GSD_TEST_OVERRIDE_KEY
-
-**Service:** Override
-**Status:** collected
-**Destination:** dotenv
-
-1. Was collected but now in env
-`);
-
-    const result = await getManifestStatus(tmp, 'M001');
-    assert.notStrictEqual(result, null);
-    assert.deepStrictEqual(result!.pending, []);
-    assert.deepStrictEqual(result!.collected, []);
-    assert.deepStrictEqual(result!.skipped, []);
-    assert.deepStrictEqual(result!.existing, ['GSD_TEST_OVERRIDE_KEY']);
-  } finally {
-    delete process.env.GSD_TEST_OVERRIDE_KEY;
-    if (savedVal !== undefined) process.env.GSD_TEST_OVERRIDE_KEY = savedVal;
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
+  });
 
-// ─── Missing manifest ────────────────────────────────────────────────────────
+  // ─── Missing manifest ────────────────────────────────────────────────────────
 
-test('getManifestStatus: missing manifest — returns null', async () => {
-  const tmp = makeTempDir('manifest-missing');
-  try {
+  test('missing manifest — returns null', async () => {
     // No .gsd directory at all
     const result = await getManifestStatus(tmp, 'M001');
     assert.strictEqual(result, null);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
+  });
 
-// ─── Empty manifest (no entries) ─────────────────────────────────────────────
+  // ─── Empty manifest (no entries) ─────────────────────────────────────────────
 
-test('getManifestStatus: empty manifest — exists but no H3 sections', async () => {
-  const tmp = makeTempDir('manifest-empty');
-  try {
+  test('empty manifest — exists but no H3 sections', async () => {
     writeManifest(tmp, `# Secrets Manifest
 
 **Milestone:** M001
@@ -244,16 +202,11 @@ test('getManifestStatus: empty manifest — exists but no H3 sections', async ()
     assert.deepStrictEqual(result!.collected, []);
     assert.deepStrictEqual(result!.skipped, []);
     assert.deepStrictEqual(result!.existing, []);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
+  });
 
-// ─── Env via .env file (not just process.env) ────────────────────────────────
+  // ─── Env via .env file (not just process.env) ────────────────────────────────
 
-test('getManifestStatus: key in .env file counts as existing', async () => {
-  const tmp = makeTempDir('manifest-dotenv');
-  try {
+  test('key in .env file counts as existing', async () => {
     delete process.env.DOTENV_ONLY_KEY;
 
     writeManifest(tmp, `# Secrets Manifest
@@ -277,7 +230,45 @@ test('getManifestStatus: key in .env file counts as existing', async () => {
     assert.notStrictEqual(result, null);
     assert.deepStrictEqual(result!.existing, ['DOTENV_ONLY_KEY']);
     assert.deepStrictEqual(result!.pending, []);
-  } finally {
+  });
+});
+
+// ─── Key in env overrides manifest status ────────────────────────────────────
+
+describe('getManifestStatus: key in env overrides manifest status', () => {
+  let tmp: string;
+  let savedVal: string | undefined;
+  beforeEach(() => {
+    tmp = makeTempDir('manifest-override');
+    savedVal = process.env.GSD_TEST_OVERRIDE_KEY;
+    process.env.GSD_TEST_OVERRIDE_KEY = 'already-here';
+  });
+  afterEach(() => {
+    delete process.env.GSD_TEST_OVERRIDE_KEY;
+    if (savedVal !== undefined) process.env.GSD_TEST_OVERRIDE_KEY = savedVal;
     rmSync(tmp, { recursive: true, force: true });
-  }
+  });
+
+  test('collected key in env goes to existing', async () => {
+    writeManifest(tmp, `# Secrets Manifest
+
+**Milestone:** M001
+**Generated:** 2025-06-20T10:00:00Z
+
+### GSD_TEST_OVERRIDE_KEY
+
+**Service:** Override
+**Status:** collected
+**Destination:** dotenv
+
+1. Was collected but now in env
+`);
+
+    const result = await getManifestStatus(tmp, 'M001');
+    assert.notStrictEqual(result, null);
+    assert.deepStrictEqual(result!.pending, []);
+    assert.deepStrictEqual(result!.collected, []);
+    assert.deepStrictEqual(result!.skipped, []);
+    assert.deepStrictEqual(result!.existing, ['GSD_TEST_OVERRIDE_KEY']);
+  });
 });

package/src/resources/extensions/gsd/tests/md-importer.test.ts

@@ -187,6 +187,36 @@ console.log('=== md-importer: malformed/empty rows skipped ===');
   assertEq(decisions[1].id, 'D003', 'second valid row (skipping malformed)');
 }
 
+console.log('=== md-importer: made_by backward compatibility (old 7-column format) ===');
+
+{
+  const decisions = parseDecisionsTable(DECISIONS_MD);
+  // Old format has no Made By column — should default to 'agent'
+  for (const d of decisions) {
+    assertEq(d.made_by, 'agent', `${d.id} made_by defaults to agent for legacy format`);
+  }
+}
+
+console.log('=== md-importer: made_by column parsing (new 8-column format) ===');
+
+{
+  const newFormatMd = `# Decisions Register
+
+| # | When | Scope | Decision | Choice | Rationale | Revisable? | Made By |
+|---|------|-------|----------|--------|-----------|------------|---------|
+| D001 | M001 | library | SQLite library | better-sqlite3 | Sync API | No | human |
+| D002 | M001 | arch | DB location | .gsd/gsd.db | Derived state | No | agent |
+| D003 | M002 | impl | Config format | JSON | Simple | Yes | collaborative |
+| D004 | M002 | impl | Cache strategy | LRU | Predictable | No | bogus |
+`;
+  const decisions = parseDecisionsTable(newFormatMd);
+  assertEq(decisions.length, 4, 'should parse 4 decisions with new format');
+  assertEq(decisions[0].made_by, 'human', 'D001 made_by = human');
+  assertEq(decisions[1].made_by, 'agent', 'D002 made_by = agent');
+  assertEq(decisions[2].made_by, 'collaborative', 'D003 made_by = collaborative');
+  assertEq(decisions[3].made_by, 'agent', 'D004 invalid made_by defaults to agent');
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // md-importer: parseRequirementsSections
 // ═══════════════════════════════════════════════════════════════════════════
@@ -354,7 +384,7 @@ console.log('=== md-importer: schema v1→v2 migration ===');
   openDatabase(':memory:');
   const adapter = _getAdapter();
   const version = adapter?.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(version?.v, 3, 'new DB should be at schema version 3');
+  assertEq(version?.v, 4, 'new DB should be at schema version 4');
 
   // Artifacts table should exist
   const tableCheck = adapter?.prepare("SELECT count(*) as c FROM sqlite_master WHERE type='table' AND name='artifacts'").get();

package/src/resources/extensions/gsd/tests/memory-store.test.ts

@@ -335,9 +335,9 @@ console.log('\n=== memory-store: schema includes memories table ===');
   const viewCount = adapter.prepare('SELECT count(*) as cnt FROM active_memories').get();
   assertEq(viewCount?.['cnt'], 0, 'active_memories view should exist');
 
-  // Verify schema version is 3
+  // Verify schema version is 4
   const version = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assertEq(version?.['v'], 3, 'schema version should be 3');
+  assertEq(version?.['v'], 4, 'schema version should be 4');
 
   closeDatabase();
 }

package/src/resources/extensions/gsd/tests/milestone-id-reservation.test.ts

@@ -1,5 +1,5 @@
 // milestone-id-reservation — Verifies that preview IDs from guided-flow
-// match the IDs claimed by gsd_generate_milestone_id via the shared
+// match the IDs claimed by gsd_milestone_generate_id via the shared
 // reservation mechanism in milestone-ids.ts.
 //
 // Regression test for #1569.