gsd-pi 2.44.0 → 2.45.0-dev.1afbdaa

package/src/resources/extensions/gsd/tests/worktree-e2e.test.ts

@@ -22,9 +22,9 @@ import {
 import { getSliceBranchName } from "../worktree.ts";
 import { abortAndReset } from "../git-self-heal.ts";
 import { runGSDDoctor } from "../doctor.ts";
-import { createTestContext } from "./test-helpers.ts";
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 
-const { assertEq, assertTrue, assertMatch, report } = createTestContext();
 
 // ---- Helpers ----
 
@@ -80,7 +80,7 @@ function addSliceToMilestone(
   run(`git merge --no-ff ${sliceBranch} -m "merge ${sliceId}"`, wtPath);
 }
 
-async function main(): Promise<void> {
+describe('worktree-e2e', async () => {
   const savedCwd = process.cwd();
   const tempDirs: string[] = [];
 
@@ -100,7 +100,7 @@ async function main(): Promise<void> {
       // Create worktree for M001
       const wtPath = createAutoWorktree(repo, "M001");
       tempDirs.push(wtPath);
-      assertTrue(existsSync(wtPath), "worktree directory created");
+      assert.ok(existsSync(wtPath), "worktree directory created");
 
       // Add two slices with commits
       addSliceToMilestone(repo, wtPath, "M001", "S01", "Add auth", [
@@ -124,19 +124,19 @@ async function main(): Promise<void> {
       // Assert exactly one new commit on main
       const mainLogAfter = run("git log --oneline main", repo);
       const commitCountAfter = mainLogAfter.split("\n").length;
-      assertEq(commitCountAfter, commitCountBefore + 1, "exactly one new commit on main");
+      assert.deepStrictEqual(commitCountAfter, commitCountBefore + 1, "exactly one new commit on main");
 
       // Commit message contains both slice titles
       const lastCommitMsg = run("git log -1 --format=%B main", repo);
-      assertMatch(lastCommitMsg, /Add auth/, "commit message contains S01 title");
-      assertMatch(lastCommitMsg, /Add dashboard/, "commit message contains S02 title");
+      assert.match(lastCommitMsg, /Add auth/, "commit message contains S01 title");
+      assert.match(lastCommitMsg, /Add dashboard/, "commit message contains S02 title");
 
       // Worktree directory removed
-      assertTrue(!existsSync(wtPath), "worktree directory removed after merge");
+      assert.ok(!existsSync(wtPath), "worktree directory removed after merge");
 
       // Milestone branch deleted
       const branches = run("git branch", repo);
-      assertTrue(!branches.includes("milestone/M001"), "milestone branch deleted");
+      assert.ok(!branches.includes("milestone/M001"), "milestone branch deleted");
     }
 
     // ================================================================
@@ -159,11 +159,11 @@ async function main(): Promise<void> {
 
       // Trigger merge conflict
       try { run("git merge feature", repo); } catch { /* expected */ }
-      assertTrue(existsSync(join(repo, ".git", "MERGE_HEAD")), "MERGE_HEAD exists before abort");
+      assert.ok(existsSync(join(repo, ".git", "MERGE_HEAD")), "MERGE_HEAD exists before abort");
 
       const abortResult = abortAndReset(repo);
-      assertTrue(!existsSync(join(repo, ".git", "MERGE_HEAD")), "MERGE_HEAD removed after abort");
-      assertTrue(abortResult.cleaned.length > 0, "abortAndReset reports cleaned items");
+      assert.ok(!existsSync(join(repo, ".git", "MERGE_HEAD")), "MERGE_HEAD removed after abort");
+      assert.ok(abortResult.cleaned.length > 0, "abortAndReset reports cleaned items");
     }
 
     // ================================================================
@@ -211,19 +211,19 @@ _None_
       // Detect
       const detect = await runGSDDoctor(repo, { isolationMode: "worktree" });
       const orphanIssues = detect.issues.filter(i => i.code === "orphaned_auto_worktree");
-      assertTrue(orphanIssues.length > 0, "doctor detects orphaned worktree");
-      assertEq(orphanIssues[0]?.unitId, "M001", "orphaned worktree unitId is M001");
+      assert.ok(orphanIssues.length > 0, "doctor detects orphaned worktree");
+      assert.deepStrictEqual(orphanIssues[0]?.unitId, "M001", "orphaned worktree unitId is M001");
 
       // Fix
       const fixed = await runGSDDoctor(repo, { fix: true, isolationMode: "worktree" });
-      assertTrue(
+      assert.ok(
         fixed.fixesApplied.some(f => f.includes("removed orphaned worktree")),
         "doctor fix removes orphaned worktree",
       );
 
       // Verify gone
       const wtList = run("git worktree list", repo);
-      assertTrue(!wtList.includes("milestone/M001"), "worktree gone after doctor fix");
+      assert.ok(!wtList.includes("milestone/M001"), "worktree gone after doctor fix");
     }
     } else {
       console.log("\n=== Doctor: orphaned worktree detection (skipped on Windows) ===");
@@ -234,8 +234,4 @@ _None_
       try { rmSync(d, { recursive: true, force: true }); } catch { /* ignore */ }
     }
   }
-
-  report();
-}
-
-main();
+});

package/src/resources/extensions/gsd/tests/worktree-health.test.ts

@@ -12,9 +12,9 @@ import { execSync } from "node:child_process";
 
 import { getWorktreeHealth, formatWorktreeStatusLine } from "../worktree-health.ts";
 import { listWorktrees } from "../worktree-manager.ts";
-import { createTestContext } from "./test-helpers.ts";
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 
-const { assertEq, assertTrue, report } = createTestContext();
 
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
@@ -32,11 +32,10 @@ function createBaseRepo(): string {
   return dir;
 }
 
-async function main(): Promise<void> {
+describe('worktree-health', async () => {
   // Skip all tests on Windows — git worktree path resolution issues
   if (process.platform === "win32") {
     console.log("(all worktree-health tests skipped on Windows)");
-    report();
     return;
   }
 
@@ -59,16 +58,16 @@ async function main(): Promise<void> {
 
       const worktrees = listWorktrees(dir);
       const wt = worktrees.find(w => w.name === "done-feature");
-      assertTrue(!!wt, "worktree found");
+      assert.ok(!!wt, "worktree found");
 
       const health = getWorktreeHealth(dir, wt!);
-      assertTrue(health.mergedIntoMain, "branch detected as merged");
-      assertTrue(!health.dirty, "not dirty");
-      assertTrue(health.safeToRemove, "safe to remove");
+      assert.ok(health.mergedIntoMain, "branch detected as merged");
+      assert.ok(!health.dirty, "not dirty");
+      assert.ok(health.safeToRemove, "safe to remove");
 
       const line = formatWorktreeStatusLine(health);
-      assertTrue(line.includes("merged"), "status line mentions merged");
-      assertTrue(line.includes("safe to remove"), "status line mentions safe to remove");
+      assert.ok(line.includes("merged"), "status line mentions merged");
+      assert.ok(line.includes("safe to remove"), "status line mentions safe to remove");
     }
 
     // ─── Test: unmerged worktree with dirty files ──────────────────────
@@ -89,13 +88,13 @@ async function main(): Promise<void> {
 
       const worktrees = listWorktrees(dir);
       const wt = worktrees.find(w => w.name === "dirty-wip");
-      assertTrue(!!wt, "worktree found");
+      assert.ok(!!wt, "worktree found");
 
       const health = getWorktreeHealth(dir, wt!);
-      assertTrue(!health.mergedIntoMain, "not merged");
-      assertTrue(health.dirty, "dirty detected");
-      assertTrue(health.dirtyFileCount > 0, "dirty file count > 0");
-      assertTrue(!health.safeToRemove, "not safe to remove");
+      assert.ok(!health.mergedIntoMain, "not merged");
+      assert.ok(health.dirty, "dirty detected");
+      assert.ok(health.dirtyFileCount > 0, "dirty file count > 0");
+      assert.ok(!health.safeToRemove, "not safe to remove");
     }
 
     // ─── Test: unmerged worktree with unpushed commits ─────────────────
@@ -113,12 +112,12 @@ async function main(): Promise<void> {
 
       const worktrees = listWorktrees(dir);
       const wt = worktrees.find(w => w.name === "unpushed");
-      assertTrue(!!wt, "worktree found");
+      assert.ok(!!wt, "worktree found");
 
       const health = getWorktreeHealth(dir, wt!);
-      assertTrue(!health.mergedIntoMain, "not merged");
-      assertTrue(health.unpushedCommits > 0, "unpushed commits detected");
-      assertTrue(!health.safeToRemove, "not safe to remove");
+      assert.ok(!health.mergedIntoMain, "not merged");
+      assert.ok(health.unpushedCommits > 0, "unpushed commits detected");
+      assert.ok(!health.safeToRemove, "not safe to remove");
     }
 
     // ─── Test: stale detection with short threshold ────────────────────
@@ -137,17 +136,17 @@ async function main(): Promise<void> {
 
       const worktrees = listWorktrees(dir);
       const wt = worktrees.find(w => w.name === "stale-test");
-      assertTrue(!!wt, "worktree found");
+      assert.ok(!!wt, "worktree found");
 
       // With staleDays=0, any worktree should be stale (commit was just now, but threshold is 0)
       // Actually, a just-created worktree has lastCommitAgeDays ~0 which is >= 0
       const health = getWorktreeHealth(dir, wt!, 0);
-      assertTrue(health.stale, "stale with 0-day threshold");
-      assertTrue(health.lastCommitAgeDays >= 0, "last commit age is non-negative");
+      assert.ok(health.stale, "stale with 0-day threshold");
+      assert.ok(health.lastCommitAgeDays >= 0, "last commit age is non-negative");
 
       // With staleDays=9999, should NOT be stale
       const healthNotStale = getWorktreeHealth(dir, wt!, 9999);
-      assertTrue(!healthNotStale.stale, "not stale with high threshold");
+      assert.ok(!healthNotStale.stale, "not stale with high threshold");
     }
 
     // ─── Test: formatWorktreeStatusLine for clean active worktree ──────
@@ -166,12 +165,12 @@ async function main(): Promise<void> {
 
       const worktrees = listWorktrees(dir);
       const wt = worktrees.find(w => w.name === "clean-active");
-      assertTrue(!!wt, "worktree found");
+      assert.ok(!!wt, "worktree found");
 
       const health = getWorktreeHealth(dir, wt!, 9999); // high threshold so not stale
       const line = formatWorktreeStatusLine(health);
       // Should show last commit age since it's not merged and not stale
-      assertTrue(line.includes("last commit"), "shows last commit age for active worktree");
+      assert.ok(line.includes("last commit"), "shows last commit age for active worktree");
     }
 
   } finally {
@@ -179,8 +178,4 @@ async function main(): Promise<void> {
       try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
     }
   }
-
-  report();
-}
-
-main();
+});

package/src/resources/extensions/gsd/tests/worktree-integration.test.ts

@@ -29,9 +29,9 @@ import {
 } from "../worktree.ts";
 
 import { deriveState } from "../state.ts";
-import { createTestContext } from './test-helpers.ts';
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 
-const { assertEq, assertTrue, report } = createTestContext();
 function run(command: string, cwd: string): string {
   return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }
@@ -73,42 +73,42 @@ writeFileSync(
 run("git add .", base);
 run('git commit -m "chore: init"', base);
 
-async function main(): Promise<void> {
+describe('worktree-integration', async () => {
   // ── Verify main tree baseline ──────────────────────────────────────────────
 
   console.log("\n=== Main tree baseline ===");
-  assertEq(getMainBranch(base), "main", "main tree getMainBranch returns main");
-  assertEq(detectWorktreeName(base), null, "main tree not detected as worktree");
+  assert.deepStrictEqual(getMainBranch(base), "main", "main tree getMainBranch returns main");
+  assert.deepStrictEqual(detectWorktreeName(base), null, "main tree not detected as worktree");
 
   // ── Create worktree and verify detection ───────────────────────────────────
 
   console.log("\n=== Create worktree ===");
   const wt = createWorktree(base, "alpha");
-  assertTrue(existsSync(wt.path), "worktree created on disk");
-  assertEq(wt.branch, "worktree/alpha", "worktree branch name");
+  assert.ok(existsSync(wt.path), "worktree created on disk");
+  assert.deepStrictEqual(wt.branch, "worktree/alpha", "worktree branch name");
 
   console.log("\n=== Worktree detection ===");
-  assertEq(detectWorktreeName(wt.path), "alpha", "detectWorktreeName inside worktree");
-  assertEq(getMainBranch(wt.path), "worktree/alpha", "getMainBranch returns worktree branch inside worktree");
+  assert.deepStrictEqual(detectWorktreeName(wt.path), "alpha", "detectWorktreeName inside worktree");
+  assert.deepStrictEqual(getMainBranch(wt.path), "worktree/alpha", "getMainBranch returns worktree branch inside worktree");
 
   // ── Verify current branch inside worktree ──────────────────────────────────
 
   console.log("\n=== Worktree initial branch ===");
-  assertEq(getCurrentBranch(wt.path), "worktree/alpha", "worktree starts on its own branch");
+  assert.deepStrictEqual(getCurrentBranch(wt.path), "worktree/alpha", "worktree starts on its own branch");
 
   // ── Verify branch name helper ──────────────────────────────────────────────
 
   console.log("\n=== getSliceBranchName with worktree ===");
-  assertEq(getSliceBranchName("M001", "S01", "alpha"), "gsd/alpha/M001/S01", "explicit worktree param");
-  assertEq(getSliceBranchName("M001", "S01"), "gsd/M001/S01", "no worktree param = plain branch");
+  assert.deepStrictEqual(getSliceBranchName("M001", "S01", "alpha"), "gsd/alpha/M001/S01", "explicit worktree param");
+  assert.deepStrictEqual(getSliceBranchName("M001", "S01"), "gsd/M001/S01", "no worktree param = plain branch");
 
   // ── Slice branch creation and detection inside worktree ────────────────────
 
   console.log("\n=== Slice branch in worktree ===");
   const sliceBranch = getSliceBranchName("M001", "S01", "alpha");
   run(`git checkout -b ${sliceBranch}`, wt.path);
-  assertEq(getCurrentBranch(wt.path), "gsd/alpha/M001/S01", "worktree-namespaced slice branch");
-  assertTrue(SLICE_BRANCH_RE.test(getCurrentBranch(wt.path)), "slice branch regex matches namespaced branch");
+  assert.deepStrictEqual(getCurrentBranch(wt.path), "gsd/alpha/M001/S01", "worktree-namespaced slice branch");
+  assert.ok(SLICE_BRANCH_RE.test(getCurrentBranch(wt.path)), "slice branch regex matches namespaced branch");
 
   // ── Do work on slice branch, then merge to worktree branch ─────────────────
 
@@ -119,23 +119,23 @@ async function main(): Promise<void> {
 
   // Checkout worktree base branch and merge slice branch
   run("git checkout worktree/alpha", wt.path);
-  assertEq(getCurrentBranch(wt.path), "worktree/alpha", "back on worktree branch");
+  assert.deepStrictEqual(getCurrentBranch(wt.path), "worktree/alpha", "back on worktree branch");
 
   run(`git merge --no-ff ${sliceBranch} -m "feat(M001/S01): First"`, wt.path);
   run(`git branch -d ${sliceBranch}`, wt.path);
-  assertEq(getCurrentBranch(wt.path), "worktree/alpha", "still on worktree branch after merge");
-  assertTrue(readFileSync(join(wt.path, "feature.txt"), "utf-8").includes("new feature"), "merge brought feature to worktree branch");
+  assert.deepStrictEqual(getCurrentBranch(wt.path), "worktree/alpha", "still on worktree branch after merge");
+  assert.ok(readFileSync(join(wt.path, "feature.txt"), "utf-8").includes("new feature"), "merge brought feature to worktree branch");
 
   // Verify slice branch is gone
   const branches = run("git branch", base);
-  assertTrue(!branches.includes("gsd/alpha/M001/S01"), "slice branch cleaned up");
+  assert.ok(!branches.includes("gsd/alpha/M001/S01"), "slice branch cleaned up");
 
   // ── Second slice in same worktree ──────────────────────────────────────────
 
   console.log("\n=== Second slice in worktree ===");
   const sliceBranch2 = getSliceBranchName("M001", "S02", "alpha");
   run(`git checkout -b ${sliceBranch2}`, wt.path);
-  assertEq(getCurrentBranch(wt.path), "gsd/alpha/M001/S02", "on S02 namespaced branch");
+  assert.deepStrictEqual(getCurrentBranch(wt.path), "gsd/alpha/M001/S02", "on S02 namespaced branch");
 
   writeFileSync(join(wt.path, "feature2.txt"), "second feature\n", "utf-8");
   run("git add .", wt.path);
@@ -144,28 +144,28 @@ async function main(): Promise<void> {
   run("git checkout worktree/alpha", wt.path);
   run(`git merge --no-ff ${sliceBranch2} -m "feat(M001/S02): Second"`, wt.path);
   run(`git branch -d ${sliceBranch2}`, wt.path);
-  assertEq(getCurrentBranch(wt.path), "worktree/alpha", "back on worktree branch");
+  assert.deepStrictEqual(getCurrentBranch(wt.path), "worktree/alpha", "back on worktree branch");
 
   // ── Parallel worktrees don't conflict ──────────────────────────────────────
 
   console.log("\n=== Parallel worktrees ===");
   const wt2 = createWorktree(base, "beta");
-  assertEq(getMainBranch(wt2.path), "worktree/beta", "second worktree has its own base branch");
+  assert.deepStrictEqual(getMainBranch(wt2.path), "worktree/beta", "second worktree has its own base branch");
 
   // Both worktrees can create S01 branches without conflict
   const betaBranch = getSliceBranchName("M001", "S01", "beta");
   run(`git checkout -b ${betaBranch}`, wt2.path);
-  assertEq(getCurrentBranch(wt2.path), "gsd/beta/M001/S01", "beta has its own namespaced branch");
+  assert.deepStrictEqual(getCurrentBranch(wt2.path), "gsd/beta/M001/S01", "beta has its own namespaced branch");
 
   // Alpha worktree can re-create S01 too (it was already merged+deleted earlier)
   const alphaReBranch = getSliceBranchName("M001", "S01", "alpha");
   run(`git checkout -b ${alphaReBranch}`, wt.path);
-  assertEq(getCurrentBranch(wt.path), "gsd/alpha/M001/S01", "alpha re-created S01");
+  assert.deepStrictEqual(getCurrentBranch(wt.path), "gsd/alpha/M001/S01", "alpha re-created S01");
 
   // Both exist simultaneously
   const allBranches = run("git branch", base);
-  assertTrue(allBranches.includes("gsd/alpha/M001/S01"), "alpha S01 branch exists");
-  assertTrue(allBranches.includes("gsd/beta/M001/S01"), "beta S01 branch exists");
+  assert.ok(allBranches.includes("gsd/alpha/M001/S01"), "alpha S01 branch exists");
+  assert.ok(allBranches.includes("gsd/beta/M001/S01"), "beta S01 branch exists");
 
   // ── State derivation in worktree ───────────────────────────────────────────
 
@@ -173,8 +173,8 @@ async function main(): Promise<void> {
   // Switch alpha back to its base so deriveState sees milestone files
   run("git checkout worktree/alpha", wt.path);
   const state = await deriveState(wt.path);
-  assertTrue(state.activeMilestone !== null, "worktree has active milestone");
-  assertEq(state.activeMilestone?.id, "M001", "correct milestone");
+  assert.ok(state.activeMilestone !== null, "worktree has active milestone");
+  assert.deepStrictEqual(state.activeMilestone?.id, "M001", "correct milestone");
 
   // ── autoCommitCurrentBranch in worktree ────────────────────────────────────
 
@@ -183,8 +183,8 @@ async function main(): Promise<void> {
   run(`git checkout ${betaBranch}`, wt2.path);
   writeFileSync(join(wt2.path, "dirty.txt"), "uncommitted\n", "utf-8");
   const commitMsg = autoCommitCurrentBranch(wt2.path, "execute-task", "M001/S01/T01");
-  assertTrue(commitMsg !== null, "auto-commit works in worktree");
-  assertEq(run("git status --short", wt2.path), "", "worktree clean after auto-commit");
+  assert.ok(commitMsg !== null, "auto-commit works in worktree");
+  assert.deepStrictEqual(run("git status --short", wt2.path), "", "worktree clean after auto-commit");
 
   // ── Cleanup ────────────────────────────────────────────────────────────────
 
@@ -194,14 +194,7 @@ async function main(): Promise<void> {
   run("git checkout worktree/beta", wt2.path);
   removeWorktree(base, "alpha", { deleteBranch: true });
   removeWorktree(base, "beta", { deleteBranch: true });
-  assertEq(listWorktrees(base).length, 0, "all worktrees removed");
+  assert.deepStrictEqual(listWorktrees(base).length, 0, "all worktrees removed");
 
   rmSync(base, { recursive: true, force: true });
-
-  report();
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
 });

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

@@ -0,0 +1,220 @@
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  WorktreeResolver,
+  type WorktreeResolverDeps,
+  type NotifyCtx,
+} from "../worktree-resolver.js";
+import { AutoSession } from "../auto/session.js";
+import type { JournalEntry } from "../journal.js";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeSession(
+  overrides?: Partial<{ basePath: string; originalBasePath: string }>,
+): AutoSession {
+  const s = new AutoSession();
+  s.basePath = overrides?.basePath ?? "/project";
+  s.originalBasePath = overrides?.originalBasePath ?? "/project";
+  return s;
+}
+
+function makeDeps(
+  overrides?: Partial<WorktreeResolverDeps>,
+): WorktreeResolverDeps {
+  const deps: WorktreeResolverDeps = {
+    isInAutoWorktree: () => false,
+    shouldUseWorktreeIsolation: () => true,
+    getIsolationMode: () => "worktree",
+    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+    syncWorktreeStateBack: () => ({ synced: [] }),
+    teardownAutoWorktree: () => {},
+    createAutoWorktree: (_basePath: string, milestoneId: string) =>
+      `/project/.gsd/worktrees/${milestoneId}`,
+    enterAutoWorktree: (_basePath: string, milestoneId: string) =>
+      `/project/.gsd/worktrees/${milestoneId}`,
+    getAutoWorktreePath: () => null,
+    autoCommitCurrentBranch: () => {},
+    getCurrentBranch: () => "main",
+    autoWorktreeBranch: (milestoneId: string) => `milestone/${milestoneId}`,
+    resolveMilestoneFile: (_basePath: string, milestoneId: string) =>
+      `/project/.gsd/milestones/${milestoneId}/${milestoneId}-ROADMAP.md`,
+    readFileSync: () => "# Roadmap\n- [x] S01: Slice one\n",
+    GitServiceImpl: class {
+      constructor() {}
+    } as unknown as WorktreeResolverDeps["GitServiceImpl"],
+    loadEffectiveGSDPreferences: () => ({ preferences: { git: {} } }),
+    invalidateAllCaches: () => {},
+    captureIntegrationBranch: () => {},
+    ...overrides,
+  };
+  return deps;
+}
+
+function makeNotifyCtx(): NotifyCtx {
+  return {
+    notify: () => {},
+  };
+}
+
+/** Read all journal entries from a temp .gsd/journal directory. */
+function readJournalEntries(basePath: string): JournalEntry[] {
+  const journalDir = join(basePath, ".gsd", "journal");
+  try {
+    const files = readdirSync(journalDir).filter(f => f.endsWith(".jsonl")).sort();
+    const entries: JournalEntry[] = [];
+    for (const file of files) {
+      const raw = readFileSync(join(journalDir, file), "utf-8");
+      for (const line of raw.split("\n")) {
+        if (!line.trim()) continue;
+        entries.push(JSON.parse(line) as JournalEntry);
+      }
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("worktree journal events", () => {
+  let tmp: string;
+  const originalCwd = process.cwd();
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "wt-journal-"));
+  });
+  afterEach(() => {
+    // Restore cwd before cleanup — on Windows, rmSync fails with EPERM
+    // if the process cwd is inside the directory being deleted.
+    try { process.chdir(originalCwd); } catch { /* best-effort */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  test("enterMilestone emits worktree-enter on success (new worktree)", () => {
+    const s = makeSession({ basePath: tmp, originalBasePath: tmp });
+    const deps = makeDeps({ getAutoWorktreePath: () => null });
+    const resolver = new WorktreeResolver(s, deps);
+
+    resolver.enterMilestone("M001", makeNotifyCtx());
+
+    const entries = readJournalEntries(tmp);
+    const enter = entries.find(e => e.eventType === "worktree-enter");
+    assert.ok(enter, "worktree-enter event should be emitted");
+    assert.equal(enter!.data?.milestoneId, "M001");
+    assert.equal(enter!.data?.created, true);
+    assert.ok(enter!.data?.wtPath);
+  });
+
+  test("enterMilestone emits worktree-enter with created=false for existing worktree", () => {
+    const s = makeSession({ basePath: tmp, originalBasePath: tmp });
+    const deps = makeDeps({
+      getAutoWorktreePath: () => "/project/.gsd/worktrees/M001",
+    });
+    const resolver = new WorktreeResolver(s, deps);
+
+    resolver.enterMilestone("M001", makeNotifyCtx());
+
+    const entries = readJournalEntries(tmp);
+    const enter = entries.find(e => e.eventType === "worktree-enter");
+    assert.ok(enter, "worktree-enter event should be emitted");
+    assert.equal(enter!.data?.created, false);
+  });
+
+  test("enterMilestone emits worktree-skip when isolation disabled", () => {
+    const s = makeSession({ basePath: tmp, originalBasePath: tmp });
+    const deps = makeDeps({ shouldUseWorktreeIsolation: () => false });
+    const resolver = new WorktreeResolver(s, deps);
+
+    resolver.enterMilestone("M001", makeNotifyCtx());
+
+    const entries = readJournalEntries(tmp);
+    const skip = entries.find(e => e.eventType === "worktree-skip");
+    assert.ok(skip, "worktree-skip event should be emitted");
+    assert.equal(skip!.data?.milestoneId, "M001");
+    assert.equal(skip!.data?.reason, "isolation-disabled");
+  });
+
+  test("enterMilestone emits worktree-create-failed on error", () => {
+    const s = makeSession({ basePath: tmp, originalBasePath: tmp });
+    const deps = makeDeps({
+      getAutoWorktreePath: () => null,
+      createAutoWorktree: () => { throw new Error("disk full"); },
+    });
+    const resolver = new WorktreeResolver(s, deps);
+
+    resolver.enterMilestone("M001", makeNotifyCtx());
+
+    const entries = readJournalEntries(tmp);
+    const failed = entries.find(e => e.eventType === "worktree-create-failed");
+    assert.ok(failed, "worktree-create-failed event should be emitted");
+    assert.equal(failed!.data?.milestoneId, "M001");
+    assert.equal(failed!.data?.error, "disk full");
+    assert.equal(failed!.data?.fallback, "project-root");
+  });
+
+  test("mergeAndExit emits worktree-merge-start", () => {
+    const s = makeSession({
+      basePath: join(tmp, "worktree"),
+      originalBasePath: tmp,
+    });
+    const deps = makeDeps({
+      isInAutoWorktree: () => true,
+      getIsolationMode: () => "worktree",
+    });
+    const resolver = new WorktreeResolver(s, deps);
+
+    resolver.mergeAndExit("M001", makeNotifyCtx());
+
+    const entries = readJournalEntries(tmp);
+    const start = entries.find(e => e.eventType === "worktree-merge-start");
+    assert.ok(start, "worktree-merge-start event should be emitted");
+    assert.equal(start!.data?.milestoneId, "M001");
+    assert.equal(start!.data?.mode, "worktree");
+  });
+
+  test("mergeAndExit emits worktree-merge-failed on error", () => {
+    const s = makeSession({
+      basePath: join(tmp, "worktree"),
+      originalBasePath: tmp,
+    });
+    const deps = makeDeps({
+      isInAutoWorktree: () => true,
+      getIsolationMode: () => "worktree",
+      mergeMilestoneToMain: () => { throw new Error("conflict in main"); },
+    });
+    const resolver = new WorktreeResolver(s, deps);
+
+    resolver.mergeAndExit("M001", makeNotifyCtx());
+
+    const entries = readJournalEntries(tmp);
+    const failed = entries.find(e => e.eventType === "worktree-merge-failed");
+    assert.ok(failed, "worktree-merge-failed event should be emitted");
+    assert.equal(failed!.data?.milestoneId, "M001");
+    assert.equal(failed!.data?.error, "conflict in main");
+  });
+
+  test("journal entries have valid flowId, seq, and ts fields", () => {
+    const s = makeSession({ basePath: tmp, originalBasePath: tmp });
+    const deps = makeDeps({ shouldUseWorktreeIsolation: () => false });
+    const resolver = new WorktreeResolver(s, deps);
+
+    resolver.enterMilestone("M001", makeNotifyCtx());
+
+    const entries = readJournalEntries(tmp);
+    assert.ok(entries.length > 0, "at least one entry should exist");
+    const entry = entries[0];
+    assert.ok(entry.flowId, "flowId should be set");
+    assert.ok(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(entry.flowId),
+      "flowId should be a valid UUID",
+    );
+    assert.equal(entry.seq, 0);
+    assert.ok(entry.ts, "ts should be set");
+    assert.ok(!isNaN(Date.parse(entry.ts)), "ts should be a valid ISO date");
+  });
+});