gsd-pi 2.42.0 → 2.43.0-dev.5717b75

package/src/resources/extensions/gsd/tests/forensics-dedup.test.ts

@@ -0,0 +1,48 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const gsdDir = join(__dirname, "..");
+
+describe("forensics dedup (#2096)", () => {
+  it("forensics_dedup is in KNOWN_PREFERENCE_KEYS", () => {
+    const source = readFileSync(join(gsdDir, "preferences-types.ts"), "utf-8");
+    assert.ok(source.includes('"forensics_dedup"'),
+      "KNOWN_PREFERENCE_KEYS must contain forensics_dedup");
+    assert.ok(source.includes("forensics_dedup?: boolean"),
+      "GSDPreferences must declare forensics_dedup as optional boolean");
+  });
+
+  it("forensics prompt contains {{dedupSection}} placeholder", () => {
+    const prompt = readFileSync(join(gsdDir, "prompts", "forensics.md"), "utf-8");
+    assert.ok(prompt.includes("{{dedupSection}}"),
+      "forensics.md must contain {{dedupSection}} placeholder");
+  });
+
+  it("DEDUP_PROMPT_SECTION contains required search commands", async () => {
+    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
+    assert.ok(source.includes("DEDUP_PROMPT_SECTION"), "forensics.ts must define DEDUP_PROMPT_SECTION");
+    assert.ok(source.includes("gh issue list --repo gsd-build/gsd-2 --state closed"));
+    assert.ok(source.includes("gh pr list --repo gsd-build/gsd-2 --state open"));
+    assert.ok(source.includes("gh pr list --repo gsd-build/gsd-2 --state merged"));
+  });
+
+  it("handleForensics checks forensics_dedup preference", () => {
+    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
+    assert.ok(source.includes("forensics_dedup"),
+      "handleForensics must reference forensics_dedup preference");
+    assert.ok(source.includes("dedupSection"),
+      "handleForensics must pass dedupSection to loadPrompt");
+  });
+
+  it("first-time opt-in shows when preference is undefined", () => {
+    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
+    assert.ok(source.includes("=== undefined"),
+      "first-time detection must check for undefined (not false)");
+    assert.ok(source.includes("Duplicate detection available") || source.includes("duplicate detection"),
+      "opt-in notice must mention duplicate detection");
+  });
+});

package/src/resources/extensions/gsd/tests/forensics-issue-routing.test.ts

@@ -0,0 +1,43 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const promptsDir = join(process.cwd(), "src/resources/extensions/gsd/prompts");
+
+function readPrompt(name: string): string {
+  return readFileSync(join(promptsDir, `${name}.md`), "utf-8");
+}
+
+test("forensics prompt explicitly forbids github_issues tool for issue creation", () => {
+  const prompt = readPrompt("forensics");
+
+  // Must contain an explicit prohibition against using the github_issues tool
+  assert.match(
+    prompt,
+    /Do NOT use the `?github_issues`? tool/i,
+    "Prompt must explicitly prohibit the github_issues tool",
+  );
+});
+
+test("forensics prompt requires gh CLI with --repo gsd-build/gsd-2 for issue creation", () => {
+  const prompt = readPrompt("forensics");
+
+  // Must contain the exact gh CLI command with the correct repo flag
+  assert.match(
+    prompt,
+    /gh issue create --repo gsd-build\/gsd-2/,
+    "Prompt must specify gh issue create --repo gsd-build/gsd-2",
+  );
+});
+
+test("forensics prompt routes issue creation through bash tool, not github_issues", () => {
+  const prompt = readPrompt("forensics");
+
+  // The constraint about using bash tool must be present
+  assert.match(
+    prompt,
+    /`?bash`? tool/i,
+    "Prompt must instruct use of the bash tool for issue creation",
+  );
+});

package/src/resources/extensions/gsd/tests/git-locale.test.ts

@@ -0,0 +1,133 @@
+/**
+ * Regression tests for #1997: git locale not forced to C.
+ *
+ * Validates that GIT_NO_PROMPT_ENV includes LC_ALL=C so git always produces
+ * English output, and that nativeMergeSquash passes the env to execFileSync.
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { GIT_NO_PROMPT_ENV } from "../git-constants.ts";
+import { nativeAddAllWithExclusions } from "../native-git-bridge.ts";
+import { RUNTIME_EXCLUSION_PATHS } from "../git-service.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function git(cwd: string, ...args: string[]): string {
+  return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function initTempRepo(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-locale-"));
+  git(dir, "init");
+  git(dir, "config", "user.email", "test@test.com");
+  git(dir, "config", "user.name", "Test");
+  // Initial commit so HEAD exists
+  writeFileSync(join(dir, "init.txt"), "init");
+  git(dir, "add", "-A");
+  git(dir, "commit", "-m", "init");
+  return dir;
+}
+
+function createFile(base: string, relPath: string, content: string): void {
+  const full = join(base, relPath);
+  mkdirSync(join(full, ".."), { recursive: true });
+  writeFileSync(full, content);
+}
+
+async function main(): Promise<void> {
+  // ─── GIT_NO_PROMPT_ENV includes LC_ALL=C ─────────────────────────────
+
+  console.log("\n=== GIT_NO_PROMPT_ENV includes LC_ALL=C ===");
+
+  assertEq(
+    GIT_NO_PROMPT_ENV.LC_ALL,
+    "C",
+    "GIT_NO_PROMPT_ENV must set LC_ALL to 'C' to force English git output"
+  );
+
+  assertTrue(
+    "GIT_TERMINAL_PROMPT" in GIT_NO_PROMPT_ENV,
+    "GIT_NO_PROMPT_ENV still contains GIT_TERMINAL_PROMPT"
+  );
+
+  // ─── nativeAddAllWithExclusions: non-English locale does not throw ───
+
+  console.log("\n=== nativeAddAllWithExclusions: non-English locale does not throw ===");
+
+  {
+    // Simulate what happens on a German system: .gsd is gitignored,
+    // exclusion pathspecs trigger an advisory warning exit code 1.
+    // With LC_ALL=C the English stderr guard should match and suppress.
+    const repo = initTempRepo();
+
+    writeFileSync(join(repo, ".gitignore"), ".gsd\n");
+    createFile(repo, ".gsd/STATE.md", "# State");
+    createFile(repo, "src/app.ts", "export const x = 1;");
+
+    // Save original LC_ALL / LANG and force German locale env
+    const origLcAll = process.env.LC_ALL;
+    const origLang = process.env.LANG;
+    process.env.LANG = "de_DE.UTF-8";
+    delete process.env.LC_ALL;
+
+    let threw = false;
+    try {
+      nativeAddAllWithExclusions(repo, RUNTIME_EXCLUSION_PATHS);
+    } catch (e) {
+      threw = true;
+      console.error("  unexpected error:", e);
+    }
+
+    // Restore
+    if (origLcAll !== undefined) process.env.LC_ALL = origLcAll;
+    else delete process.env.LC_ALL;
+    if (origLang !== undefined) process.env.LANG = origLang;
+    else delete process.env.LANG;
+
+    assertTrue(
+      !threw,
+      "nativeAddAllWithExclusions must not throw on non-English locale when .gsd is gitignored (#1997)"
+    );
+
+    const staged = git(repo, "diff", "--cached", "--name-only");
+    assertTrue(staged.includes("src/app.ts"), "real file staged despite German locale");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ─── nativeMergeSquash: env is passed (merge-squash stderr is English) ─
+
+  console.log("\n=== nativeMergeSquash fallback uses GIT_NO_PROMPT_ENV ===");
+
+  {
+    // We verify indirectly: the source code must pass env: GIT_NO_PROMPT_ENV.
+    // Read the source and check for the pattern. This is a static check.
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "native-git-bridge.ts"),
+      "utf-8"
+    );
+
+    // Find the nativeMergeSquash function and check it uses GIT_NO_PROMPT_ENV
+    const fnStart = src.indexOf("export function nativeMergeSquash");
+    assertTrue(fnStart !== -1, "nativeMergeSquash function exists in source");
+
+    const fnBody = src.slice(fnStart, src.indexOf("\nexport function", fnStart + 1));
+    const hasEnv = fnBody.includes("env: GIT_NO_PROMPT_ENV");
+    assertTrue(
+      hasEnv,
+      "nativeMergeSquash fallback must pass env: GIT_NO_PROMPT_ENV to execFileSync (#1997)"
+    );
+  }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/src/resources/extensions/gsd/tests/git-service.test.ts

@@ -1411,6 +1411,50 @@ async function main(): Promise<void> {
     rmSync(repo, { recursive: true, force: true });
   }
 
+  // ─── autoCommit: symlinked .gsd does NOT stage milestone artifacts (#2247) ──
+
+  console.log("\n=== autoCommit: symlinked .gsd does NOT stage milestone artifacts (#2247) ===");
+
+  {
+    // When .gsd is a symlink (external state project), .gsd/ files live outside
+    // the repo by design. smartStage() must NOT force-stage them into git — the
+    // .gitignore exclusion is correct and intentional.
+    const repo = initTempRepo();
+
+    // Create an external .gsd directory and symlink it into the repo
+    const externalGsd = mkdtempSync(join(tmpdir(), "gsd-external-symlink-"));
+    mkdirSync(join(externalGsd, "milestones", "M009"), { recursive: true });
+    mkdirSync(join(externalGsd, "activity"), { recursive: true });
+    mkdirSync(join(externalGsd, "runtime"), { recursive: true });
+
+    symlinkSync(externalGsd, join(repo, ".gsd"));
+
+    // .gitignore blocks .gsd (as ensureGitignore would do for symlink projects)
+    writeFileSync(join(repo, ".gitignore"), ".gsd\n");
+    run('git add .gitignore', repo);
+    run('git commit -m "add gitignore"', repo);
+
+    // Simulate new milestone artifacts created during execution
+    writeFileSync(join(externalGsd, "milestones", "M009", "M009-SUMMARY.md"), "# M009 Summary");
+    writeFileSync(join(externalGsd, "milestones", "M009", "S01-SUMMARY.md"), "# S01 Summary");
+    writeFileSync(join(externalGsd, "milestones", "M009", "T01-VERIFY.json"), '{"passed":true}');
+
+    // Also create a normal source file change
+    createFile(repo, "src/feature.ts", "export const feature = true;");
+
+    const svc = new GitServiceImpl(repo);
+    const msg = svc.autoCommit("complete-milestone", "M009");
+    assertTrue(msg !== null, "symlink autoCommit: commit succeeds");
+
+    const committed = run("git show --name-only HEAD", repo);
+    assertTrue(committed.includes("src/feature.ts"), "symlink autoCommit: source file committed");
+    assertTrue(!committed.includes(".gsd/milestones/"),
+      "symlink autoCommit: .gsd/milestones/ files are NOT staged (external state stays external)");
+
+    try { rmSync(repo, { recursive: true, force: true }); } catch {}
+    try { rmSync(externalGsd, { recursive: true, force: true }); } catch {}
+  }
+
   report();
 }
 

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

@@ -1,4 +1,4 @@
-import test from "node:test";
+import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import {
   mkdirSync,
@@ -46,9 +46,12 @@ function makeEntry(overrides: Partial<JournalEntry> = {}): JournalEntry {
 
 // ─── emitJournalEvent ─────────────────────────────────────────────────────────
 
-test("emitJournalEvent creates journal directory and JSONL file", () => {
-  const base = makeTmpBase();
-  try {
+describe("emitJournalEvent", () => {
+  let base: string;
+  beforeEach(() => { base = makeTmpBase(); });
+  afterEach(() => { cleanup(base); });
+
+  test("creates journal directory and JSONL file", () => {
     const entry = makeEntry();
     emitJournalEvent(base, entry);
 
@@ -61,14 +64,9 @@ test("emitJournalEvent creates journal directory and JSONL file", () => {
     assert.equal(parsed.flowId, entry.flowId);
     assert.equal(parsed.seq, entry.seq);
     assert.equal(parsed.eventType, entry.eventType);
-  } finally {
-    cleanup(base);
-  }
-});
+  });
 
-test("emitJournalEvent appends multiple lines to the same file", () => {
-  const base = makeTmpBase();
-  try {
+  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" }));
@@ -82,26 +80,9 @@ test("emitJournalEvent appends multiple lines to the same file", () => {
     assert.equal(parsed[1].seq, 1);
     assert.equal(parsed[2].seq, 2);
     assert.equal(parsed[1].eventType, "dispatch-match");
-  } finally {
-    cleanup(base);
-  }
-});
-
-test("emitJournalEvent auto-creates nonexistent parent directory", () => {
-  const base = join(tmpdir(), `gsd-journal-test-${randomUUID()}`);
-  // Don't create .gsd/ — emitJournalEvent should handle it via mkdirSync recursive
-  try {
-    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");
-  } finally {
-    cleanup(base);
-  }
-});
+  });
 
-test("emitJournalEvent preserves optional fields (rule, causedBy, data)", () => {
-  const base = makeTmpBase();
-  try {
+  test("preserves optional fields (rule, causedBy, data)", () => {
     const entry = makeEntry({
       rule: "my-dispatch-rule",
       causedBy: { flowId: "flow-prior", seq: 3 },
@@ -115,24 +96,12 @@ test("emitJournalEvent preserves optional fields (rule, causedBy, data)", () =>
     assert.deepEqual(parsed.causedBy, { flowId: "flow-prior", seq: 3 });
     assert.equal(parsed.data.unitId, "M001/S01/T01");
     assert.equal(parsed.data.status, "ok");
-  } finally {
-    cleanup(base);
-  }
-});
-
-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());
   });
-});
 
-test("emitJournalEvent silently catches read-only directory errors", () => {
-  const base = makeTmpBase();
-  const journalDir = join(base, ".gsd", "journal");
-  mkdirSync(journalDir, { recursive: true });
+  test("silently catches read-only directory errors", () => {
+    const journalDir = join(base, ".gsd", "journal");
+    mkdirSync(journalDir, { recursive: true });
 
-  try {
     // Make the journal directory read-only
     chmodSync(journalDir, 0o444);
 
@@ -140,22 +109,46 @@ test("emitJournalEvent silently catches read-only directory errors", () => {
     assert.doesNotThrow(() => {
       emitJournalEvent(base, makeEntry());
     });
-  } finally {
+
     // Restore permissions for cleanup
     try {
       chmodSync(journalDir, 0o755);
     } catch {
       /* */
     }
-    cleanup(base);
-  }
+  });
+});
+
+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 ───────────────────────────────────────────────────────────
 
-test("daily rotation: events with different dates go to different files", () => {
-  const base = makeTmpBase();
-  try {
+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" }));
@@ -172,16 +165,17 @@ test("daily rotation: events with different dates go to different files", () =>
         .split("\n");
       assert.equal(lines.length, 1, `${date}.jsonl should have 1 line`);
     }
-  } finally {
-    cleanup(base);
-  }
+  });
 });
 
 // ─── queryJournal ─────────────────────────────────────────────────────────────
 
-test("queryJournal returns all entries when no filters provided", () => {
-  const base = makeTmpBase();
-  try {
+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" }));
 
@@ -189,14 +183,9 @@ test("queryJournal returns all entries when no filters provided", () => {
     assert.equal(results.length, 2);
     assert.equal(results[0].seq, 0);
     assert.equal(results[1].seq, 1);
-  } finally {
-    cleanup(base);
-  }
-});
+  });
 
-test("queryJournal filters by flowId", () => {
-  const base = makeTmpBase();
-  try {
+  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 }));
@@ -204,14 +193,9 @@ test("queryJournal filters by flowId", () => {
     const results = queryJournal(base, { flowId: "flow-aaa" });
     assert.equal(results.length, 2);
     assert.ok(results.every(e => e.flowId === "flow-aaa"));
-  } finally {
-    cleanup(base);
-  }
-});
+  });
 
-test("queryJournal filters by eventType", () => {
-  const base = makeTmpBase();
-  try {
+  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 }));
@@ -220,14 +204,9 @@ test("queryJournal filters by eventType", () => {
     const results = queryJournal(base, { eventType: "dispatch-match" });
     assert.equal(results.length, 2);
     assert.ok(results.every(e => e.eventType === "dispatch-match"));
-  } finally {
-    cleanup(base);
-  }
-});
+  });
 
-test("queryJournal filters by unitId (from data.unitId)", () => {
-  const base = makeTmpBase();
-  try {
+  test("filters by unitId (from data.unitId)", () => {
     emitJournalEvent(
       base,
       makeEntry({ seq: 0, data: { unitId: "M001/S01/T01" } }),
@@ -249,14 +228,9 @@ test("queryJournal filters by unitId (from data.unitId)", () => {
         e => (e.data as Record<string, unknown>)?.unitId === "M001/S01/T01",
       ),
     );
-  } finally {
-    cleanup(base);
-  }
-});
+  });
 
-test("queryJournal filters by time range (after/before)", () => {
-  const base = makeTmpBase();
-  try {
+  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 }));
@@ -276,14 +250,9 @@ test("queryJournal filters by time range (after/before)", () => {
       before: "2025-03-21T23:59:59.000Z",
     });
     assert.equal(rangeResults.length, 2, "2 entries within 2025-03-21");
-  } finally {
-    cleanup(base);
-  }
-});
+  });
 
-test("queryJournal combines multiple filters", () => {
-  const base = makeTmpBase();
-  try {
+  test("combines multiple filters", () => {
     emitJournalEvent(
       base,
       makeEntry({ flowId: "flow-aaa", eventType: "unit-start", seq: 0 }),
@@ -304,25 +273,9 @@ test("queryJournal combines multiple filters", () => {
     assert.equal(results.length, 1);
     assert.equal(results[0].flowId, "flow-aaa");
     assert.equal(results[0].eventType, "unit-start");
-  } finally {
-    cleanup(base);
-  }
-});
-
-test("queryJournal on nonexistent directory returns empty array", () => {
-  const base = join(tmpdir(), `gsd-journal-test-${randomUUID()}`);
-  // Don't create anything
-  try {
-    const results = queryJournal(base);
-    assert.deepEqual(results, []);
-  } finally {
-    cleanup(base);
-  }
-});
+  });
 
-test("queryJournal skips malformed JSON lines gracefully", () => {
-  const base = makeTmpBase();
-  try {
+  test("skips malformed JSON lines gracefully", () => {
     const journalDir = join(base, ".gsd", "journal");
     mkdirSync(journalDir, { recursive: true });
 
@@ -335,14 +288,9 @@ test("queryJournal skips malformed JSON lines gracefully", () => {
     assert.equal(results.length, 2, "Should skip the malformed line");
     assert.equal(results[0].seq, 0);
     assert.equal(results[1].seq, 1);
-  } finally {
-    cleanup(base);
-  }
-});
+  });
 
-test("queryJournal reads across multiple daily files", () => {
-  const base = makeTmpBase();
-  try {
+  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 }));
@@ -353,14 +301,9 @@ test("queryJournal reads across multiple daily files", () => {
     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");
-  } finally {
-    cleanup(base);
-  }
-});
+  });
 
-test("queryJournal filters by rule", () => {
-  const base = makeTmpBase();
-  try {
+  test("filters by rule", () => {
     emitJournalEvent(
       base,
       makeEntry({ seq: 0, eventType: "dispatch-match", rule: "dispatch-task" }),
@@ -380,7 +323,19 @@ test("queryJournal filters by rule", () => {
       results.every(e => e.rule === "dispatch-task"),
       "All results should have rule === 'dispatch-task'",
     );
-  } finally {
-    cleanup(base);
-  }
+  });
+});
+
+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, []);
+  });
 });