lsd-pi 1.0.0 → 1.1.1

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

@@ -1,181 +0,0 @@
-/**
- * worktree-health.test.ts — Unit tests for worktree health status computation.
- *
- * Creates real temp git repos with GSD worktrees in various states and verifies
- * that getWorktreeHealth and formatWorktreeStatusLine return correct results.
- */
-
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { execSync } from "node:child_process";
-
-import { getWorktreeHealth, formatWorktreeStatusLine } from "../worktree-health.ts";
-import { listWorktrees } from "../worktree-manager.ts";
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-
-
-function run(cmd: string, cwd: string): string {
-  return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
-}
-
-function createBaseRepo(): string {
-  const dir = realpathSync(mkdtempSync(join(tmpdir(), "wt-health-test-")));
-  run("git init", dir);
-  run("git config user.email test@test.com", dir);
-  run("git config user.name Test", dir);
-  writeFileSync(join(dir, "README.md"), "# test\n");
-  run("git add .", dir);
-  run("git commit -m init", dir);
-  run("git branch -M main", dir);
-  return dir;
-}
-
-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)");
-    return;
-  }
-
-  const cleanups: string[] = [];
-
-  try {
-    // ─── Test: merged worktree is detected as merged + safe to remove ──
-    console.log("\n=== worktree health: merged worktree ===");
-    {
-      const dir = createBaseRepo();
-      cleanups.push(dir);
-
-      mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
-      run("git worktree add -b worktree/done-feature .gsd/worktrees/done-feature", dir);
-      const wtPath = join(dir, ".gsd", "worktrees", "done-feature");
-      writeFileSync(join(wtPath, "done.txt"), "done\n");
-      run("git add -A", wtPath);
-      run("git -c user.email=test@test.com -c user.name=Test commit -m \"done\"", wtPath);
-      run("git merge worktree/done-feature --no-edit", dir);
-
-      const worktrees = listWorktrees(dir);
-      const wt = worktrees.find(w => w.name === "done-feature");
-      assert.ok(!!wt, "worktree found");
-
-      const health = getWorktreeHealth(dir, wt!);
-      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);
-      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 ──────────────────────
-    console.log("\n=== worktree health: dirty unmerged worktree ===");
-    {
-      const dir = createBaseRepo();
-      cleanups.push(dir);
-
-      mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
-      run("git worktree add -b worktree/dirty-wip .gsd/worktrees/dirty-wip", dir);
-      const wtPath = join(dir, ".gsd", "worktrees", "dirty-wip");
-      // Make a commit so the branch diverges from main, then leave dirty state
-      writeFileSync(join(wtPath, "committed.txt"), "committed\n");
-      run("git add -A", wtPath);
-      run("git -c user.email=test@test.com -c user.name=Test commit -m \"diverge\"", wtPath);
-      // Now leave an uncommitted file
-      writeFileSync(join(wtPath, "uncommitted.txt"), "wip\n");
-
-      const worktrees = listWorktrees(dir);
-      const wt = worktrees.find(w => w.name === "dirty-wip");
-      assert.ok(!!wt, "worktree found");
-
-      const health = getWorktreeHealth(dir, wt!);
-      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 ─────────────────
-    console.log("\n=== worktree health: unpushed commits ===");
-    {
-      const dir = createBaseRepo();
-      cleanups.push(dir);
-
-      mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
-      run("git worktree add -b worktree/unpushed .gsd/worktrees/unpushed", dir);
-      const wtPath = join(dir, ".gsd", "worktrees", "unpushed");
-      writeFileSync(join(wtPath, "feature.txt"), "feature\n");
-      run("git add -A", wtPath);
-      run("git -c user.email=test@test.com -c user.name=Test commit -m \"feature\"", wtPath);
-
-      const worktrees = listWorktrees(dir);
-      const wt = worktrees.find(w => w.name === "unpushed");
-      assert.ok(!!wt, "worktree found");
-
-      const health = getWorktreeHealth(dir, wt!);
-      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 ────────────────────
-    console.log("\n=== worktree health: stale detection ===");
-    {
-      const dir = createBaseRepo();
-      cleanups.push(dir);
-
-      mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
-      run("git worktree add -b worktree/stale-test .gsd/worktrees/stale-test", dir);
-      // Diverge from main so the branch is not "merged"
-      const wtPath = join(dir, ".gsd", "worktrees", "stale-test");
-      writeFileSync(join(wtPath, "stale.txt"), "stale\n");
-      run("git add -A", wtPath);
-      run("git -c user.email=test@test.com -c user.name=Test commit -m \"stale work\"", wtPath);
-
-      const worktrees = listWorktrees(dir);
-      const wt = worktrees.find(w => w.name === "stale-test");
-      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);
-      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);
-      assert.ok(!healthNotStale.stale, "not stale with high threshold");
-    }
-
-    // ─── Test: formatWorktreeStatusLine for clean active worktree ──────
-    console.log("\n=== worktree health: format clean active worktree ===");
-    {
-      const dir = createBaseRepo();
-      cleanups.push(dir);
-
-      mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
-      run("git worktree add -b worktree/clean-active .gsd/worktrees/clean-active", dir);
-      // Diverge from main so it's not "merged"
-      const wtPath = join(dir, ".gsd", "worktrees", "clean-active");
-      writeFileSync(join(wtPath, "active.txt"), "active\n");
-      run("git add -A", wtPath);
-      run("git -c user.email=test@test.com -c user.name=Test commit -m \"active work\"", wtPath);
-
-      const worktrees = listWorktrees(dir);
-      const wt = worktrees.find(w => w.name === "clean-active");
-      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
-      assert.ok(line.includes("last commit"), "shows last commit age for active worktree");
-    }
-
-  } finally {
-    for (const dir of cleanups) {
-      try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
-    }
-  }
-});

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

@@ -1,200 +0,0 @@
-/**
- * Worktree Integration Tests
- *
- * Tests the full lifecycle of GSD operations inside a worktree:
- * - Branch namespacing (gsd/<wt>/<M>/<S> instead of gsd/<M>/<S>)
- * - getMainBranch returns worktree/<name> inside a worktree
- * - Parallel worktrees don't conflict on branch names
- * - State derivation works correctly inside worktrees
- */
-
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { execSync } from "node:child_process";
-
-import {
-  createWorktree,
-  listWorktrees,
-  removeWorktree,
-} from "../worktree-manager.ts";
-
-import {
-  detectWorktreeName,
-  getCurrentBranch,
-  getMainBranch,
-  getSliceBranchName,
-  autoCommitCurrentBranch,
-  SLICE_BRANCH_RE,
-} from "../worktree.ts";
-
-import { deriveState } from "../state.ts";
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-
-function run(command: string, cwd: string): string {
-  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
-}
-
-// ─── Test repo setup ──────────────────────────────────────────────────────────
-
-const base = mkdtempSync(join(tmpdir(), "gsd-wt-integration-"));
-run("git init -b main", base);
-run("git config user.name 'Pi Test'", base);
-run("git config user.email 'pi@example.com'", base);
-
-// Create a project with one milestone and two slices
-mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
-mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S02", "tasks"), { recursive: true });
-writeFileSync(join(base, "README.md"), "# Test Project\n", "utf-8");
-writeFileSync(
-  join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
-  [
-    "# M001: Demo",
-    "",
-    "## Slices",
-    "- [ ] **S01: First** `risk:low` `depends:[]`",
-    "  > After this: part one works",
-    "- [ ] **S02: Second** `risk:low` `depends:[]`",
-    "  > After this: part two works",
-  ].join("\n") + "\n",
-  "utf-8",
-);
-writeFileSync(
-  join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
-  "# S01: First\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Must-Haves\n- done\n\n## Tasks\n- [ ] **T01: Implement** `est:10m`\n  do it\n",
-  "utf-8",
-);
-writeFileSync(
-  join(base, ".gsd", "milestones", "M001", "slices", "S02", "S02-PLAN.md"),
-  "# S02: Second\n\n**Goal:** Demo\n**Demo:** Demo\n\n## Must-Haves\n- done\n\n## Tasks\n- [ ] **T01: Implement** `est:10m`\n  do it\n",
-  "utf-8",
-);
-run("git add .", base);
-run('git commit -m "chore: init"', base);
-
-describe('worktree-integration', async () => {
-  // ── Verify main tree baseline ──────────────────────────────────────────────
-
-  console.log("\n=== Main tree baseline ===");
-  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");
-  assert.ok(existsSync(wt.path), "worktree created on disk");
-  assert.deepStrictEqual(wt.branch, "worktree/alpha", "worktree branch name");
-
-  console.log("\n=== Worktree detection ===");
-  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 ===");
-  assert.deepStrictEqual(getCurrentBranch(wt.path), "worktree/alpha", "worktree starts on its own branch");
-
-  // ── Verify branch name helper ──────────────────────────────────────────────
-
-  console.log("\n=== getSliceBranchName with worktree ===");
-  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);
-  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 ─────────────────
-
-  console.log("\n=== Work and merge slice in worktree ===");
-  writeFileSync(join(wt.path, "feature.txt"), "new feature\n", "utf-8");
-  run("git add .", wt.path);
-  run('git commit -m "feat: add feature"', wt.path);
-
-  // Checkout worktree base branch and merge slice branch
-  run("git checkout worktree/alpha", wt.path);
-  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);
-  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);
-  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);
-  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);
-  run('git commit -m "feat: add feature 2"', wt.path);
-
-  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);
-  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");
-  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);
-  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);
-  assert.deepStrictEqual(getCurrentBranch(wt.path), "gsd/alpha/M001/S01", "alpha re-created S01");
-
-  // Both exist simultaneously
-  const allBranches = run("git branch", base);
-  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 ───────────────────────────────────────────
-
-  console.log("\n=== State derivation in worktree ===");
-  // Switch alpha back to its base so deriveState sees milestone files
-  run("git checkout worktree/alpha", wt.path);
-  const state = await deriveState(wt.path);
-  assert.ok(state.activeMilestone !== null, "worktree has active milestone");
-  assert.deepStrictEqual(state.activeMilestone?.id, "M001", "correct milestone");
-
-  // ── autoCommitCurrentBranch in worktree ────────────────────────────────────
-
-  console.log("\n=== autoCommitCurrentBranch in worktree ===");
-  // Re-checkout the beta slice branch
-  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");
-  assert.ok(commitMsg !== null, "auto-commit works in worktree");
-  assert.deepStrictEqual(run("git status --short", wt2.path), "", "worktree clean after auto-commit");
-
-  // ── Cleanup ────────────────────────────────────────────────────────────────
-
-  console.log("\n=== Cleanup ===");
-  // Switch worktrees back to their base branches before removal
-  run("git checkout worktree/alpha", wt.path);
-  run("git checkout worktree/beta", wt2.path);
-  removeWorktree(base, "alpha", { deleteBranch: true });
-  removeWorktree(base, "beta", { deleteBranch: true });
-  assert.deepStrictEqual(listWorktrees(base).length, 0, "all worktrees removed");
-
-  rmSync(base, { recursive: true, force: true });
-});

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

@@ -1,220 +0,0 @@
-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");
-  });
-});