gsd-pi 2.41.0 → 2.42.0-dev.1df898f

package/src/resources/extensions/gsd/tests/windows-path-normalization.test.ts

@@ -0,0 +1,99 @@
+/**
+ * windows-path-normalization.test.ts — Verify Windows backslash paths are
+ * normalised to forward slashes before embedding in bash command strings.
+ *
+ * Regression test for #1436: on Windows, `cd C:\Users\user\project` in bash
+ * strips backslashes (escape characters), producing `C:Usersuserproject`.
+ */
+
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ─── shellEscape + path normalization ──────────────────────────────────────
+
+// Replicate the shellEscape helper from cmux/index.ts
+function shellEscape(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+// The bashPath pattern used in subagent/index.ts
+function bashPath(p: string): string {
+  return shellEscape(p.replaceAll("\\", "/"));
+}
+
+console.log("\n=== Windows backslash path normalization (#1436) ===");
+
+// Backslash paths are converted to forward slashes
+assertEq(
+  bashPath("C:\\Users\\user\\project"),
+  "'C:/Users/user/project'",
+  "backslash path normalised to forward slashes in shell-escaped string",
+);
+
+// Unix paths pass through unchanged
+assertEq(
+  bashPath("/home/user/project"),
+  "'/home/user/project'",
+  "Unix path unchanged",
+);
+
+// Mixed separators are normalised
+assertEq(
+  bashPath("C:\\Users/user\\project/src"),
+  "'C:/Users/user/project/src'",
+  "mixed separators normalised",
+);
+
+// Paths with single quotes are still properly escaped
+assertEq(
+  bashPath("C:\\Users\\o'brien\\project"),
+  "'C:/Users/o'\\''brien/project'",
+  "single quote in path is escaped after normalisation",
+);
+
+// UNC paths
+assertEq(
+  bashPath("\\\\server\\share\\dir"),
+  "'//server/share/dir'",
+  "UNC path normalised",
+);
+
+// Empty string
+assertEq(
+  bashPath(""),
+  "''",
+  "empty string handled",
+);
+
+// ─── cd command construction ───────────────────────────────────────────────
+
+console.log("\n=== cd command construction with normalised paths ===");
+
+const windowsCwd = "C:\\Users\\user\\project\\.gsd\\worktrees\\M001";
+const cdCommand = `cd ${bashPath(windowsCwd)}`;
+assertEq(
+  cdCommand,
+  "cd 'C:/Users/user/project/.gsd/worktrees/M001'",
+  "cd command uses forward slashes for Windows worktree path",
+);
+
+// Verify the mangled form from #1436 is NOT produced
+assertTrue(
+  !cdCommand.includes("C:Users"),
+  "mangled path C:Usersuserproject must not appear",
+);
+
+// ─── Worktree teardown orphan detection ────────────────────────────────────
+
+console.log("\n=== teardown orphan warning path formatting ===");
+
+const windowsWtDir = "C:\\Users\\user\\project\\.gsd\\worktrees\\M001";
+const helpCommand = `rm -rf "${windowsWtDir.replaceAll("\\", "/")}"`;
+assertEq(
+  helpCommand,
+  'rm -rf "C:/Users/user/project/.gsd/worktrees/M001"',
+  "orphan cleanup help command uses forward slashes",
+);
+
+report();

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

@@ -138,6 +138,7 @@ async function main(): Promise<void> {
         choice: "reconcile on merge",
         rationale: "test coverage",
         revisable: "no",
+        made_by: 'agent',
         superseded_by: null,
       });
       closeDatabase();

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

@@ -47,6 +47,7 @@ function seedMainDb(dbPath: string): void {
     choice: 'node:sqlite',
     rationale: 'Built-in',
     revisable: 'yes',
+    made_by: 'agent',
     superseded_by: null,
   });
   insertRequirement({
@@ -182,6 +183,7 @@ console.log('\n=== worktree-db: reconcileWorktreeDb ===');
     choice: 'WAL',
     rationale: 'Performance',
     revisable: 'yes',
+    made_by: 'agent',
     superseded_by: null,
   });
   closeDatabase();
@@ -357,6 +359,7 @@ console.log('\n=== worktree-db: reconcileWorktreeDb ===');
     choice: 'yes',
     rationale: 'Robustness',
     revisable: 'no',
+    made_by: 'agent',
     superseded_by: null,
   });
   closeDatabase();
@@ -395,6 +398,7 @@ console.log('\n=== worktree-db: reconcileWorktreeDb ===');
     choice: 'works',
     rationale: 'Verify DETACH cleanup',
     revisable: 'no',
+    made_by: 'agent',
     superseded_by: null,
   });
 

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

@@ -0,0 +1,135 @@
+/**
+ * worktree-health-dispatch.test.ts — Regression tests for the worktree health
+ * check in auto/phases.ts (#1833, #1843).
+ *
+ * Verifies that the pre-dispatch health check recognises non-JS project types
+ * (Rust, Go, Python, etc.) via the shared PROJECT_FILES list from detection.ts,
+ * rather than hard-coding package.json / src/ only.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import { PROJECT_FILES } from "../detection.js";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+/** Create a minimal git repo and return its path. */
+function createGitRepo(): string {
+  const dir = mkdtempSync(join(tmpdir(), "wt-dispatch-test-"));
+  // All execSync calls use hardcoded strings only — no user input, no injection risk.
+  execSync("git init", { cwd: dir, stdio: "ignore" });
+  execSync("git config user.email test@test.com", { cwd: dir, stdio: "ignore" });
+  execSync("git config user.name Test", { cwd: dir, stdio: "ignore" });
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  execSync("git add . && git commit -m init", { cwd: dir, stdio: "ignore" });
+  return dir;
+}
+
+/**
+ * Simulate the health check logic from auto/phases.ts.
+ *
+ * Returns true when the directory would PASS the health check (dispatch
+ * proceeds), false when it would FAIL (dispatch blocked).
+ *
+ * This mirrors the fixed logic: .git must exist, AND at least one
+ * PROJECT_FILES entry or a src/ directory must exist.
+ */
+function wouldPassHealthCheck(basePath: string, existsSyncFn: (p: string) => boolean): boolean {
+  const hasGit = existsSyncFn(join(basePath, ".git"));
+  if (!hasGit) return false;
+
+  for (const file of PROJECT_FILES) {
+    if (existsSyncFn(join(basePath, file))) return true;
+  }
+  if (existsSyncFn(join(basePath, "src"))) return true;
+
+  return false;
+}
+
+import { existsSync } from "node:fs";
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+test("PROJECT_FILES is exported and contains expected multi-ecosystem entries", () => {
+  assert.ok(Array.isArray(PROJECT_FILES), "PROJECT_FILES is an array");
+  assert.ok(PROJECT_FILES.length >= 17, `expected >= 17 entries, got ${PROJECT_FILES.length}`);
+  // Spot-check key ecosystems
+  assert.ok(PROJECT_FILES.includes("Cargo.toml"), "includes Rust marker");
+  assert.ok(PROJECT_FILES.includes("go.mod"), "includes Go marker");
+  assert.ok(PROJECT_FILES.includes("pyproject.toml"), "includes Python marker");
+  assert.ok(PROJECT_FILES.includes("package.json"), "includes JS marker");
+  assert.ok(PROJECT_FILES.includes("pom.xml"), "includes Java marker");
+  assert.ok(PROJECT_FILES.includes("Package.swift"), "includes Swift marker");
+});
+
+describe("health check with git repo", () => {
+  let dir: string;
+  beforeEach(() => { dir = createGitRepo(); });
+  afterEach(() => { rmSync(dir, { recursive: true, force: true }); });
+
+  test("health check passes for Rust project (Cargo.toml, no package.json)", () => {
+    writeFileSync(join(dir, "Cargo.toml"), "[package]\nname = \"test\"\n");
+    mkdirSync(join(dir, "crates"), { recursive: true });
+    assert.ok(wouldPassHealthCheck(dir, existsSync), "Rust project should pass health check");
+  });
+
+  test("health check passes for Go project (go.mod, no package.json)", () => {
+    writeFileSync(join(dir, "go.mod"), "module example.com/test\n\ngo 1.21\n");
+    assert.ok(wouldPassHealthCheck(dir, existsSync), "Go project should pass health check");
+  });
+
+  test("health check passes for Python project (pyproject.toml, no package.json)", () => {
+    writeFileSync(join(dir, "pyproject.toml"), "[project]\nname = \"test\"\n");
+    assert.ok(wouldPassHealthCheck(dir, existsSync), "Python project should pass health check");
+  });
+
+  test("health check passes for Java project (pom.xml, no package.json)", () => {
+    writeFileSync(join(dir, "pom.xml"), "<project></project>\n");
+    assert.ok(wouldPassHealthCheck(dir, existsSync), "Java project should pass health check");
+  });
+
+  test("health check passes for Swift project (Package.swift, no package.json)", () => {
+    writeFileSync(join(dir, "Package.swift"), "// swift-tools-version:5.7\n");
+    assert.ok(wouldPassHealthCheck(dir, existsSync), "Swift project should pass health check");
+  });
+
+  test("health check passes for C/C++ project (CMakeLists.txt, no package.json)", () => {
+    writeFileSync(join(dir, "CMakeLists.txt"), "cmake_minimum_required(VERSION 3.20)\n");
+    assert.ok(wouldPassHealthCheck(dir, existsSync), "C/C++ project should pass health check");
+  });
+
+  test("health check passes for Elixir project (mix.exs, no package.json)", () => {
+    writeFileSync(join(dir, "mix.exs"), "defmodule Test.MixProject do\nend\n");
+    assert.ok(wouldPassHealthCheck(dir, existsSync), "Elixir project should pass health check");
+  });
+
+  test("health check passes for JS project (package.json, backward compat)", () => {
+    writeFileSync(join(dir, "package.json"), '{"name":"test"}\n');
+    assert.ok(wouldPassHealthCheck(dir, existsSync), "JS project should pass health check");
+  });
+
+  test("health check passes for src/-only project (backward compat)", () => {
+    mkdirSync(join(dir, "src"), { recursive: true });
+    assert.ok(wouldPassHealthCheck(dir, existsSync), "src/-only project should pass health check");
+  });
+
+  test("health check fails for empty git repo with no project files", () => {
+    assert.ok(!wouldPassHealthCheck(dir, existsSync), "empty git repo should fail health check");
+  });
+});
+
+describe("health check without git repo", () => {
+  let dir: string;
+  beforeEach(() => { dir = mkdtempSync(join(tmpdir(), "wt-dispatch-test-nogit-")); });
+  afterEach(() => { rmSync(dir, { recursive: true, force: true }); });
+
+  test("health check fails for directory with no .git", () => {
+    writeFileSync(join(dir, "Cargo.toml"), "[package]\nname = \"test\"\n");
+    assert.ok(!wouldPassHealthCheck(dir, existsSync), "no-git directory should fail health check");
+  });
+});

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

@@ -1,4 +1,6 @@
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from "node:fs";
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
@@ -13,82 +15,42 @@ import {
   worktreeBranchName,
   worktreePath,
 } from "../worktree-manager.ts";
-import { createTestContext } from './test-helpers.ts';
 
-const { assertEq, assertTrue, report } = createTestContext();
 function run(command: string, cwd: string): string {
   return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }
 
-// Set up a test repo
-const base = mkdtempSync(join(tmpdir(), "gsd-worktree-mgr-test-"));
-run("git init -b main", base);
-run('git config user.name "Pi Test"', base);
-run('git config user.email "pi@example.com"', base);
-
-// Create initial project structure
-mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
-writeFileSync(join(base, "README.md"), "# Test Project\n", "utf-8");
-writeFileSync(
-  join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
-  "# M001: Demo\n\n## Slices\n- [ ] **S01: First** `risk:low` `depends:[]`\n  > After this: it works\n",
-  "utf-8",
-);
-run("git add .", base);
-run('git commit -m "chore: init"', base);
-
-async function main(): Promise<void> {
-  console.log("\n=== worktreeBranchName ===");
-  assertEq(worktreeBranchName("feature-x"), "worktree/feature-x", "branch name format");
-
-  console.log("\n=== createWorktree ===");
-  const info = createWorktree(base, "feature-x");
-  assertTrue(info.name === "feature-x", "name matches");
-  assertTrue(info.branch === "worktree/feature-x", "branch matches");
-  assertTrue(info.exists, "worktree exists");
-  assertTrue(existsSync(info.path), "worktree path exists on disk");
-  assertTrue(existsSync(join(info.path, "README.md")), "README.md copied to worktree");
-  assertTrue(existsSync(join(info.path, ".gsd", "milestones", "M001", "M001-ROADMAP.md")), ".gsd files copied");
-
-  // Branch was created
-  const branches = run("git branch", base);
-  assertTrue(branches.includes("worktree/feature-x"), "branch was created");
-
-  console.log("\n=== createWorktree — duplicate ===");
-  let duplicateError = "";
-  try {
-    createWorktree(base, "feature-x");
-  } catch (e) {
-    duplicateError = (e as Error).message;
-  }
-  assertTrue(duplicateError.includes("already exists"), "duplicate creation fails");
-
-  console.log("\n=== createWorktree — invalid name ===");
-  let invalidError = "";
-  try {
-    createWorktree(base, "bad name!");
-  } catch (e) {
-    invalidError = (e as Error).message;
-  }
-  assertTrue(invalidError.includes("Invalid worktree name"), "invalid name rejected");
-
-  console.log("\n=== listWorktrees ===");
-  const list = listWorktrees(base);
-  assertEq(list.length, 1, "one worktree listed");
-  assertEq(list[0]!.name, "feature-x", "correct name");
-  assertEq(list[0]!.branch, "worktree/feature-x", "correct branch");
-  assertTrue(list[0]!.exists, "exists flag is true");
-
-  console.log("\n=== make changes in worktree ===");
-  const wtPath = worktreePath(base, "feature-x");
-  // Add a new GSD artifact in the worktree
+function makeBaseRepo(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-wt-test-"));
+  run("git init -b main", base);
+  run('git config user.name "Test User"', base);
+  run('git config user.email "test@example.com"', base);
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(join(base, "README.md"), "# Test Project\n", "utf-8");
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    "# M001: Demo\n\n## Slices\n- [ ] **S01: First** `risk:low` `depends:[]`\n  > After this: it works\n",
+    "utf-8",
+  );
+  run("git add .", base);
+  run('git commit -m "chore: init"', base);
+  return base;
+}
+
+function makeRepoWithWorktree(worktreeName: string): { base: string; wtPath: string } {
+  const base = makeBaseRepo();
+  createWorktree(base, worktreeName);
+  return { base, wtPath: worktreePath(base, worktreeName) };
+}
+
+function makeRepoWithChanges(worktreeName: string): { base: string; wtPath: string } {
+  const { base, wtPath } = makeRepoWithWorktree(worktreeName);
   mkdirSync(join(wtPath, ".gsd", "milestones", "M002"), { recursive: true });
   writeFileSync(
     join(wtPath, ".gsd", "milestones", "M002", "M002-ROADMAP.md"),
     "# M002: New Feature\n\n## Slices\n- [ ] **S01: Setup** `risk:low` `depends:[]`\n  > After this: new feature ready\n",
     "utf-8",
   );
-  // Modify an existing artifact
   writeFileSync(
     join(wtPath, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
     "# M001: Demo (updated)\n\n## Slices\n- [x] **S01: First** `risk:low` `depends:[]`\n  > Done\n",
@@ -96,46 +58,181 @@ async function main(): Promise<void> {
   );
   run("git add .", wtPath);
   run('git commit -m "feat: add M002 and update M001"', wtPath);
-
-  console.log("\n=== diffWorktreeGSD ===");
-  const diff = diffWorktreeGSD(base, "feature-x");
-  assertTrue(diff.added.length > 0, "has added files");
-  assertTrue(diff.added.some(f => f.includes("M002")), "M002 roadmap is in added");
-  assertTrue(diff.modified.length > 0, "has modified files");
-  assertTrue(diff.modified.some(f => f.includes("M001")), "M001 roadmap is in modified");
-  assertEq(diff.removed.length, 0, "no removed files");
-
-  console.log("\n=== getWorktreeGSDDiff ===");
-  const fullDiff = getWorktreeGSDDiff(base, "feature-x");
-  assertTrue(fullDiff.includes("M002"), "full diff mentions M002");
-  assertTrue(fullDiff.includes("updated"), "full diff mentions update");
-
-  console.log("\n=== getWorktreeLog ===");
-  const log = getWorktreeLog(base, "feature-x");
-  assertTrue(log.includes("add M002"), "log shows commit message");
-
-  console.log("\n=== removeWorktree ===");
-  removeWorktree(base, "feature-x", { deleteBranch: true });
-  assertTrue(!existsSync(wtPath), "worktree directory removed");
-  const branchesAfter = run("git branch", base);
-  assertTrue(!branchesAfter.includes("worktree/feature-x"), "branch deleted");
-
-  console.log("\n=== listWorktrees after removal ===");
-  const listAfter = listWorktrees(base);
-  assertEq(listAfter.length, 0, "no worktrees after removal");
-
-  console.log("\n=== removeWorktree — already gone ===");
-  // Should not throw
-  removeWorktree(base, "feature-x", { deleteBranch: true });
-  assertTrue(true, "removeWorktree on missing worktree does not throw");
-
-  // Cleanup
-  rmSync(base, { recursive: true, force: true });
-
-  report();
+  return { base, wtPath };
 }
 
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
+// ─── worktreeBranchName ───────────────────────────────────────────────────────
+
+test("worktreeBranchName formats branch name", () => {
+  assert.strictEqual(
+    worktreeBranchName("feature-x"),
+    "worktree/feature-x",
+    "should prefix with worktree/",
+  );
+});
+
+// ─── createWorktree ───────────────────────────────────────────────────────────
+
+describe("createWorktree", () => {
+  let base: string;
+  beforeEach(() => { base = makeBaseRepo(); });
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("creates worktree with correct metadata", () => {
+    const info = createWorktree(base, "feature-x");
+    assert.strictEqual(info.name, "feature-x", "name should match");
+    assert.strictEqual(info.branch, "worktree/feature-x", "branch should be prefixed");
+    assert.ok(info.exists, "exists flag should be true");
+    assert.ok(existsSync(info.path), "worktree path should exist on disk");
+    assert.ok(existsSync(join(info.path, "README.md")), "README.md should be in worktree");
+    assert.ok(
+      existsSync(join(info.path, ".gsd", "milestones", "M001", "M001-ROADMAP.md")),
+      ".gsd files should be in worktree",
+    );
+    const branches = run("git branch", base);
+    assert.ok(branches.includes("worktree/feature-x"), "branch should be created in base repo");
+  });
+
+  test("rejects invalid name", () => {
+    assert.throws(
+      () => createWorktree(base, "bad name!"),
+      (err: Error) => {
+        assert.ok(
+          err.message.includes("Invalid worktree name"),
+          `expected "Invalid worktree name" in error, got: ${err.message}`,
+        );
+        return true;
+      },
+      "should throw on invalid worktree name",
+    );
+  });
+});
+
+describe("createWorktree — duplicate rejection", () => {
+  let base: string;
+  beforeEach(() => {
+    const repo = makeRepoWithWorktree("feature-x");
+    base = repo.base;
+  });
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("rejects duplicate name", () => {
+    assert.throws(
+      () => createWorktree(base, "feature-x"),
+      (err: Error) => {
+        assert.ok(
+          err.message.includes("already exists"),
+          `expected "already exists" in error, got: ${err.message}`,
+        );
+        return true;
+      },
+      "should throw on duplicate worktree name",
+    );
+  });
+});
+
+// ─── listWorktrees ────────────────────────────────────────────────────────────
+
+describe("listWorktrees", () => {
+  let base: string;
+  beforeEach(() => {
+    const repo = makeRepoWithWorktree("feature-x");
+    base = repo.base;
+  });
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("returns active worktrees", () => {
+    const list = listWorktrees(base);
+    assert.strictEqual(list.length, 1, "should list exactly one worktree");
+    assert.strictEqual(list[0]!.name, "feature-x", "name should match");
+    assert.strictEqual(list[0]!.branch, "worktree/feature-x", "branch should match");
+    assert.ok(list[0]!.exists, "exists flag should be true");
+  });
+
+  test("returns empty after removal", () => {
+    removeWorktree(base, "feature-x");
+    const list = listWorktrees(base);
+    assert.strictEqual(list.length, 0, "should have no worktrees after removal");
+  });
+});
+
+// ─── diffWorktreeGSD ─────────────────────────────────────────────────────────
+
+describe("diffWorktreeGSD and getWorktreeGSDDiff", () => {
+  let base: string;
+  beforeEach(() => {
+    const repo = makeRepoWithChanges("feature-x");
+    base = repo.base;
+  });
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("detects added and modified GSD files", () => {
+    const diff = diffWorktreeGSD(base, "feature-x");
+    assert.ok(diff.added.length > 0, "should have added files");
+    assert.ok(
+      diff.added.some((f) => f.includes("M002")),
+      "M002 roadmap should be in added files",
+    );
+    assert.ok(diff.modified.length > 0, "should have modified files");
+    assert.ok(
+      diff.modified.some((f) => f.includes("M001")),
+      "M001 roadmap should be in modified files",
+    );
+    assert.strictEqual(diff.removed.length, 0, "should have no removed files");
+  });
+
+  test("returns patch content", () => {
+    const fullDiff = getWorktreeGSDDiff(base, "feature-x");
+    assert.ok(fullDiff.includes("M002"), "diff should mention M002");
+    assert.ok(fullDiff.includes("updated"), "diff should mention the update");
+  });
+});
+
+// ─── getWorktreeLog ───────────────────────────────────────────────────────────
+
+describe("getWorktreeLog", () => {
+  let base: string;
+  beforeEach(() => {
+    const repo = makeRepoWithChanges("feature-x");
+    base = repo.base;
+  });
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("shows commits", () => {
+    const log = getWorktreeLog(base, "feature-x");
+    assert.ok(log.includes("add M002"), "log should include the commit message");
+  });
+});
+
+// ─── removeWorktree ───────────────────────────────────────────────────────────
+
+describe("removeWorktree", () => {
+  let base: string;
+  let wtPath: string;
+  beforeEach(() => {
+    const repo = makeRepoWithWorktree("feature-x");
+    base = repo.base;
+    wtPath = repo.wtPath;
+  });
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("removes directory and branch", () => {
+    removeWorktree(base, "feature-x", { deleteBranch: true });
+    assert.ok(!existsSync(wtPath), "worktree directory should be gone");
+    const branches = run("git branch", base);
+    assert.ok(!branches.includes("worktree/feature-x"), "branch should be deleted");
+  });
+});
+
+describe("removeWorktree — missing worktree", () => {
+  let base: string;
+  beforeEach(() => { base = makeBaseRepo(); });
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("on missing worktree does not throw", () => {
+    assert.doesNotThrow(
+      () => removeWorktree(base, "nonexistent"),
+      "should not throw when worktree does not exist",
+    );
+  });
 });