gsd-pi 2.3.8 → 2.3.10

package/src/resources/extensions/gsd/files.ts

@@ -347,21 +347,23 @@ export function parseSummary(content: string): Summary {
   const [fmLines, body] = splitFrontmatter(content);
 
   const fm = fmLines ? parseFrontmatterMap(fmLines) : {};
+  const asStringArray = (v: unknown): string[] =>
+    Array.isArray(v) ? v : (typeof v === 'string' && v ? [v] : []);
   const frontmatter: SummaryFrontmatter = {
     id: (fm.id as string) || '',
     parent: (fm.parent as string) || '',
     milestone: (fm.milestone as string) || '',
-    provides: (fm.provides as string[]) || [],
+    provides: asStringArray(fm.provides),
     requires: ((fm.requires as Array<Record<string, string>>) || []).map(r => ({
       slice: r.slice || '',
       provides: r.provides || '',
     })),
-    affects: (fm.affects as string[]) || [],
-    key_files: (fm.key_files as string[]) || [],
-    key_decisions: (fm.key_decisions as string[]) || [],
-    patterns_established: (fm.patterns_established as string[]) || [],
-    drill_down_paths: (fm.drill_down_paths as string[]) || [],
-    observability_surfaces: (fm.observability_surfaces as string[]) || [],
+    affects: asStringArray(fm.affects),
+    key_files: asStringArray(fm.key_files),
+    key_decisions: asStringArray(fm.key_decisions),
+    patterns_established: asStringArray(fm.patterns_established),
+    drill_down_paths: asStringArray(fm.drill_down_paths),
+    observability_surfaces: asStringArray(fm.observability_surfaces),
     duration: (fm.duration as string) || '',
     verification_result: (fm.verification_result as string) || 'untested',
     completed_at: (fm.completed_at as string) || '',

package/src/resources/extensions/gsd/index.ts

@@ -47,6 +47,7 @@ import {
 import { Key } from "@mariozechner/pi-tui";
 import { join } from "node:path";
 import { existsSync } from "node:fs";
+import { shortcutDesc } from "../shared/terminal.js";
 import { Text } from "@mariozechner/pi-tui";
 
 // ── ASCII logo ────────────────────────────────────────────────────────────
@@ -185,7 +186,7 @@ export default function (pi: ExtensionAPI) {
 
   // ── Ctrl+Alt+G shortcut — GSD dashboard overlay ────────────────────────
   pi.registerShortcut(Key.ctrlAlt("g"), {
-    description: "Open GSD dashboard",
+    description: shortcutDesc("Open GSD dashboard", "/gsd status"),
     handler: async (ctx) => {
       // Only show if .gsd/ exists
       if (!existsSync(join(process.cwd(), ".gsd"))) {

package/src/resources/extensions/gsd/metrics.ts

@@ -129,8 +129,9 @@ export function snapshotUnitMetrics(
         tokens.cacheRead += msg.usage.cacheRead ?? 0;
         tokens.cacheWrite += msg.usage.cacheWrite ?? 0;
         tokens.total += msg.usage.totalTokens ?? 0;
-        if (msg.usage.cost) {
-          cost += msg.usage.cost.total ?? 0;
+        if (msg.usage.cost != null) {
+          const c = msg.usage.cost;
+          cost += typeof c === "number" ? c : (c.total ?? 0);
         }
       }
       // Count tool calls in this message
@@ -296,9 +297,10 @@ export function getProjectTotals(units: UnitMetrics[]): ProjectTotals {
 // ─── Formatting helpers ───────────────────────────────────────────────────────
 
 export function formatCost(cost: number): string {
-  if (cost < 0.01) return `$${cost.toFixed(4)}`;
-  if (cost < 1) return `$${cost.toFixed(3)}`;
-  return `$${cost.toFixed(2)}`;
+  const n = Number(cost) || 0;
+  if (n < 0.01) return `$${n.toFixed(4)}`;
+  if (n < 1) return `$${n.toFixed(3)}`;
+  return `$${n.toFixed(2)}`;
 }
 
 /**

package/src/resources/extensions/gsd/migrate/command.ts

@@ -96,7 +96,10 @@ export async function handleMigrate(
 
   if (!existsSync(sourcePath)) {
     ctx.ui.notify(
-      `Directory not found: ${sourcePath}\n\nMake sure the path points to a project root with a .planning directory.`,
+      `Directory not found: ${sourcePath}\n\n` +
+      'Migration converts a .planning/ directory (from older GSD versions) into .gsd/ format.\n' +
+      'If you are starting a new project, use /gsd:new-project instead.\n' +
+      'If migrating, ensure the path contains a .planning/ directory.',
       "error",
     );
     return;

package/src/resources/extensions/gsd/migrate/validator.ts

@@ -14,7 +14,7 @@ function issue(file: string, severity: ValidationSeverity, message: string): Val
 /**
  * Validate that a .planning directory has the minimum required structure.
  * Returns structured issues with severity levels:
- * - fatal: directory doesn't exist or ROADMAP.md missing (migration cannot proceed)
+ * - fatal: directory doesn't exist (migration cannot proceed)
  * - warning: optional files missing (migration can proceed with reduced data)
  */
 export async function validatePlanningDirectory(path: string): Promise<ValidationResult> {
@@ -26,9 +26,11 @@ export async function validatePlanningDirectory(path: string): Promise<Validatio
     return { valid: false, issues };
   }
 
-  // ROADMAP.md is required (fatal if missing)
+  // ROADMAP.md — warn if missing (transformer falls back to filesystem phases)
   if (!existsSync(join(path, 'ROADMAP.md'))) {
-    issues.push(issue('ROADMAP.md', 'fatal', 'ROADMAP.md is required for migration'));
+    issues.push(issue('ROADMAP.md', 'warning',
+      'ROADMAP.md not found — milestone structure will be inferred from phases/ directory',
+    ));
   }
 
   // Optional files — warn if missing

package/src/resources/extensions/gsd/prompts/system.md

@@ -76,7 +76,7 @@ Titles live inside file content (headings, frontmatter), not in file or director
 - **Slices** are demoable vertical increments (S01, S02, ...) ordered by risk. After each slice completes, the roadmap is reassessed before the next slice begins.
 - **Tasks** are single-context-window units of work (T01, T02, ...)
 - Checkboxes in roadmap and plan files track completion (`[ ]` → `[x]`)
-- Each slice gets its own git branch: `gsd/M001/S01`
+- Each slice gets its own git branch: `gsd/M001/S01` (or `gsd/<worktree>/M001/S01` when inside a worktree)
 - Slices are squash-merged to main when complete
 - Summaries compress prior work — read them instead of re-reading all task details
 - `STATE.md` is the quick-glance status file — keep it updated after changes

package/src/resources/extensions/gsd/tests/migrate-parser.test.ts

@@ -725,8 +725,8 @@ Another orphan.
     }
   }
 
-  // ─── Test 12: Validation — missing ROADMAP.md → fatal ─────────────────
-  console.log('\n=== Validation: missing ROADMAP.md → fatal ===');
+  // ─── Test 12: Validation — missing ROADMAP.md → warning (not fatal) ───
+  console.log('\n=== Validation: missing ROADMAP.md → warning (not fatal) ===');
   {
     const base = createFixtureBase();
     try {
@@ -736,10 +736,10 @@ Another orphan.
 
       const result = await validatePlanningDirectory(planning);
 
-      assertEq(result.valid, false, 'no roadmap: validation fails');
+      assertEq(result.valid, true, 'no roadmap: validation still passes');
       assert(
-        result.issues.some(i => i.severity === 'fatal' && i.file.includes('ROADMAP')),
-        'no roadmap: fatal issue mentions ROADMAP'
+        result.issues.some(i => i.severity === 'warning' && i.file.includes('ROADMAP')),
+        'no roadmap: warning issue mentions ROADMAP'
       );
     } finally {
       cleanup(base);

package/src/resources/extensions/gsd/tests/migrate-validator-parsers.test.ts

@@ -211,15 +211,15 @@ async function main(): Promise<void> {
     }
   }
 
-  console.log('\n=== Validator: missing ROADMAP.md → fatal ===');
+  console.log('\n=== Validator: missing ROADMAP.md → warning (not fatal) ===');
   {
     const base = createFixtureBase();
     try {
       const planning = createPlanningDir(base);
       writeFileSync(join(planning, 'PROJECT.md'), SAMPLE_PROJECT);
       const result = await validatePlanningDirectory(planning);
-      assertEq(result.valid, false, 'no roadmap: validation fails');
-      assert(result.issues.some(i => i.severity === 'fatal' && i.file.includes('ROADMAP')), 'no roadmap: fatal issue mentions ROADMAP');
+      assertEq(result.valid, true, 'no roadmap: validation still passes');
+      assert(result.issues.some(i => i.severity === 'warning' && i.file.includes('ROADMAP')), 'no roadmap: warning issue mentions ROADMAP');
     } finally {
       cleanup(base);
     }

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

@@ -1248,6 +1248,100 @@ console.log('\n=== parseRequirementCounts: total is sum of all section counts ==
   assertEq(counts.total, counts.active + counts.validated + counts.deferred + counts.outOfScope, 'total is exact sum');
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// parseSummary: bare scalar frontmatter fields (regression test for #91)
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== parseSummary: bare scalar "none" coerced to string array (#91) ===');
+{
+  const content = `---
+id: T04
+parent: S03
+milestone: M001
+provides:
+  - iOS rules
+key_files:
+  - .claude/rules/swift-style.md
+key_decisions: none
+patterns_established: none
+drill_down_paths: none
+observability_surfaces: none — static reference files
+affects: single-value
+---
+
+# T04: iOS Rules
+
+**Created iOS-specific rules.**
+
+## What Happened
+
+Added rules.
+
+## Deviations
+
+None.
+`;
+
+  const s = parseSummary(content);
+
+  // Array fields should remain arrays
+  assertEq(s.frontmatter.provides.length, 1, '#91: provides array preserved');
+  assertEq(s.frontmatter.provides[0], 'iOS rules', '#91: provides value');
+  assertEq(s.frontmatter.key_files.length, 1, '#91: key_files array preserved');
+
+  // Bare scalar "none" must be coerced to ["none"], not crash
+  assertEq(Array.isArray(s.frontmatter.key_decisions), true, '#91: key_decisions is array');
+  assertEq(s.frontmatter.key_decisions.length, 1, '#91: key_decisions has 1 element');
+  assertEq(s.frontmatter.key_decisions[0], 'none', '#91: key_decisions[0] is "none"');
+
+  assertEq(Array.isArray(s.frontmatter.patterns_established), true, '#91: patterns_established is array');
+  assertEq(s.frontmatter.patterns_established.length, 1, '#91: patterns_established coerced');
+
+  assertEq(Array.isArray(s.frontmatter.drill_down_paths), true, '#91: drill_down_paths is array');
+  assertEq(s.frontmatter.drill_down_paths.length, 1, '#91: drill_down_paths coerced');
+
+  // Scalar with spaces: "none — static reference files"
+  assertEq(Array.isArray(s.frontmatter.observability_surfaces), true, '#91: observability_surfaces is array');
+  assertEq(s.frontmatter.observability_surfaces.length, 1, '#91: observability_surfaces coerced');
+  assertEq(s.frontmatter.observability_surfaces[0], 'none — static reference files', '#91: full scalar preserved');
+
+  // Single value (not "none") also coerced
+  assertEq(Array.isArray(s.frontmatter.affects), true, '#91: affects is array');
+  assertEq(s.frontmatter.affects.length, 1, '#91: affects single value coerced');
+  assertEq(s.frontmatter.affects[0], 'single-value', '#91: affects value');
+
+  // .slice().join() must not crash (the original bug)
+  const decisions = s.frontmatter.key_decisions.slice(0, 2).join('; ');
+  assertEq(decisions, 'none', '#91: .slice().join() works on coerced array');
+}
+
+console.log('\n=== parseSummary: missing/empty frontmatter fields yield empty arrays ===');
+{
+  const content = `---
+id: T05
+parent: S04
+milestone: M001
+---
+
+# T05: Minimal Summary
+
+**Minimal.**
+
+## What Happened
+
+Nothing.
+`;
+
+  const s = parseSummary(content);
+  assertEq(s.frontmatter.provides.length, 0, 'missing provides = empty array');
+  assertEq(s.frontmatter.key_decisions.length, 0, 'missing key_decisions = empty array');
+  assertEq(s.frontmatter.affects.length, 0, 'missing affects = empty array');
+  assertEq(s.frontmatter.key_files.length, 0, 'missing key_files = empty array');
+  assertEq(s.frontmatter.patterns_established.length, 0, 'missing patterns_established = empty array');
+  assertEq(s.frontmatter.drill_down_paths.length, 0, 'missing drill_down_paths = empty array');
+  assertEq(s.frontmatter.observability_surfaces.length, 0, 'missing observability_surfaces = empty array');
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Results
 // ═══════════════════════════════════════════════════════════════════════════

package/src/resources/extensions/gsd/tests/resolve-ts-hooks.mjs

@@ -1,17 +1,34 @@
 // ESM resolve hook: .js → .ts rewriting for test environments.
 // Only rewrites relative imports from our own source files — not from node_modules.
+//
+// Handles two patterns:
+// 1. .js → .ts  (pi bundler convention: source files use .js specifiers)
+// 2. extensionless → .ts  (some source files omit extensions in relative imports)
 
 export function resolve(specifier, context, nextResolve) {
   const parentURL = context.parentURL || '';
   const isFromNodeModules = parentURL.includes('/node_modules/');
 
-  if (specifier.endsWith('.js') && !specifier.startsWith('node:') && !isFromNodeModules) {
-    const tsSpecifier = specifier.replace(/\.js$/, '.ts');
-    try {
-      return nextResolve(tsSpecifier, context);
-    } catch {
-      // fall through to default resolution
+  if (!isFromNodeModules && !specifier.startsWith('node:')) {
+    // Rewrite .js → .ts
+    if (specifier.endsWith('.js')) {
+      const tsSpecifier = specifier.replace(/\.js$/, '.ts');
+      try {
+        return nextResolve(tsSpecifier, context);
+      } catch {
+        // fall through to default resolution
+      }
+    }
+
+    // Try adding .ts to extensionless relative imports
+    if (specifier.startsWith('.') && !/\.[a-z]+$/i.test(specifier)) {
+      try {
+        return nextResolve(specifier + '.ts', context);
+      } catch {
+        // fall through to default resolution
+      }
     }
   }
+
   return nextResolve(specifier, context);
 }

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

@@ -0,0 +1,253 @@
+/**
+ * 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
+ * - switchToMain goes to worktree/<name>, not main
+ * - mergeSliceToMain merges into worktree/<name>
+ * - 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,
+  worktreePath,
+  worktreeBranchName,
+} from "../worktree-manager.ts";
+
+import {
+  detectWorktreeName,
+  ensureSliceBranch,
+  getActiveSliceBranch,
+  getCurrentBranch,
+  getMainBranch,
+  getSliceBranchName,
+  isOnSliceBranch,
+  mergeSliceToMain,
+  switchToMain,
+  autoCommitCurrentBranch,
+} from "../worktree.ts";
+
+import { deriveState } from "../state.ts";
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, message: string): void {
+  if (condition) passed++;
+  else {
+    failed++;
+    console.error(`  FAIL: ${message}`);
+  }
+}
+
+function assertEq<T>(actual: T, expected: T, message: string): void {
+  if (JSON.stringify(actual) === JSON.stringify(expected)) passed++;
+  else {
+    failed++;
+    console.error(`  FAIL: ${message} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+  }
+}
+
+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);
+
+async function main(): Promise<void> {
+  // ── 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");
+
+  // ── Create worktree and verify detection ───────────────────────────────────
+
+  console.log("\n=== Create worktree ===");
+  const wt = createWorktree(base, "alpha");
+  assert(existsSync(wt.path), "worktree created on disk");
+  assertEq(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");
+
+  // ── Verify current branch inside worktree ──────────────────────────────────
+
+  console.log("\n=== Worktree initial branch ===");
+  assertEq(getCurrentBranch(wt.path), "worktree/alpha", "worktree starts on its own branch");
+
+  // ── ensureSliceBranch inside worktree ──────────────────────────────────────
+
+  console.log("\n=== ensureSliceBranch in worktree ===");
+  const created = ensureSliceBranch(wt.path, "M001", "S01");
+  assert(created, "slice branch created");
+  assertEq(getCurrentBranch(wt.path), "gsd/alpha/M001/S01", "worktree-namespaced slice branch");
+  assert(isOnSliceBranch(wt.path), "isOnSliceBranch returns true");
+  assertEq(getActiveSliceBranch(wt.path), "gsd/alpha/M001/S01", "getActiveSliceBranch returns namespaced 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");
+
+  // ── 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);
+
+  // switchToMain should go to worktree/alpha, NOT main
+  switchToMain(wt.path);
+  assertEq(getCurrentBranch(wt.path), "worktree/alpha", "switchToMain goes to worktree branch, not main");
+
+  // mergeSliceToMain should merge into worktree/alpha
+  const merge = mergeSliceToMain(wt.path, "M001", "S01", "First");
+  assertEq(merge.branch, "gsd/alpha/M001/S01", "merged the namespaced branch");
+  assert(merge.deletedBranch, "slice branch deleted after merge");
+  assertEq(getCurrentBranch(wt.path), "worktree/alpha", "still on worktree branch after merge");
+  assert(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(!branches.includes("gsd/alpha/M001/S01"), "slice branch cleaned up");
+
+  // ── Second slice in same worktree ──────────────────────────────────────────
+
+  console.log("\n=== Second slice in worktree ===");
+  const created2 = ensureSliceBranch(wt.path, "M001", "S02");
+  assert(created2, "S02 branch created");
+  assertEq(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);
+
+  switchToMain(wt.path);
+  const merge2 = mergeSliceToMain(wt.path, "M001", "S02", "Second");
+  assertEq(merge2.branch, "gsd/alpha/M001/S02", "S02 merge correct");
+  assertEq(getCurrentBranch(wt.path), "worktree/alpha", "back on worktree branch");
+
+  // ── Main tree can still do its own slice work independently ────────────────
+
+  console.log("\n=== Main tree independent slice work ===");
+  assertEq(getCurrentBranch(base), "main", "main tree still on main");
+  const mainCreated = ensureSliceBranch(base, "M001", "S01");
+  assert(mainCreated, "main tree can create S01 branch (no conflict with worktree)");
+  assertEq(getCurrentBranch(base), "gsd/M001/S01", "main tree on plain branch name");
+
+  writeFileSync(join(base, "main-feature.txt"), "main work\n", "utf-8");
+  run("git add .", base);
+  run("git commit -m 'feat: main work'", base);
+
+  switchToMain(base);
+  assertEq(getCurrentBranch(base), "main", "main tree switchToMain goes to main");
+  const mainMerge = mergeSliceToMain(base, "M001", "S01", "First");
+  assertEq(mainMerge.branch, "gsd/M001/S01", "main tree merge uses plain 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");
+
+  // Both worktrees can create S01 branches without conflict
+  const betaCreated = ensureSliceBranch(wt2.path, "M001", "S01");
+  assert(betaCreated, "beta worktree can create S01");
+  assertEq(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 alphaReCreated = ensureSliceBranch(wt.path, "M001", "S01");
+  assert(alphaReCreated, "alpha worktree can re-create S01");
+  assertEq(getCurrentBranch(wt.path), "gsd/alpha/M001/S01", "alpha re-created S01");
+
+  // Both exist simultaneously
+  const allBranches = run("git branch", base);
+  assert(allBranches.includes("gsd/alpha/M001/S01"), "alpha S01 branch exists");
+  assert(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
+  switchToMain(wt.path);
+  const state = await deriveState(wt.path);
+  assert(state.activeMilestone !== null, "worktree has active milestone");
+  assertEq(state.activeMilestone?.id, "M001", "correct milestone");
+
+  // ── autoCommitCurrentBranch in worktree ────────────────────────────────────
+
+  console.log("\n=== autoCommitCurrentBranch in worktree ===");
+  ensureSliceBranch(wt2.path, "M001", "S01"); // re-checkout if needed
+  writeFileSync(join(wt2.path, "dirty.txt"), "uncommitted\n", "utf-8");
+  const commitMsg = autoCommitCurrentBranch(wt2.path, "execute-task", "M001/S01/T01");
+  assert(commitMsg !== null, "auto-commit works in worktree");
+  assertEq(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
+  switchToMain(wt.path);
+  switchToMain(wt2.path);
+  removeWorktree(base, "alpha", { deleteBranch: true });
+  removeWorktree(base, "beta", { deleteBranch: true });
+  assertEq(listWorktrees(base).length, 0, "all worktrees removed");
+
+  rmSync(base, { recursive: true, force: true });
+
+  console.log(`\nResults: ${passed} passed, ${failed} failed`);
+  if (failed > 0) process.exit(1);
+  console.log("All tests passed ✓");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});