gsd-pi 2.32.0-dev.f3d5d53 → 2.33.0-dev.69bff0f

package/src/resources/extensions/gsd/tests/session-lock.test.ts

@@ -12,6 +12,7 @@ import {
   readSessionLockData,
   isSessionLockHeld,
   isSessionLockProcessAlive,
+  cleanupStrayLockFiles,
 } from "../session-lock.ts";
 
 // ─── acquireSessionLock ──────────────────────────────────────────────────
@@ -313,3 +314,121 @@ test("acquireSessionLock creates .gsd/ if it does not exist", () => {
   releaseSessionLock(dir);
   rmSync(dir, { recursive: true, force: true });
 });
+
+// ─── cleanupStrayLockFiles (#1315) ──────────────────────────────────────
+
+test("cleanupStrayLockFiles removes numbered lock variants but preserves auto.lock", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  const gsdDir = join(dir, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  // Create canonical lock file + numbered variants
+  writeFileSync(join(gsdDir, "auto.lock"), '{"pid":1}');
+  writeFileSync(join(gsdDir, "auto 2.lock"), '{"pid":2}');
+  writeFileSync(join(gsdDir, "auto 3.lock"), '{"pid":3}');
+  writeFileSync(join(gsdDir, "auto 4.lock"), '{"pid":4}');
+
+  cleanupStrayLockFiles(dir);
+
+  assert.ok(existsSync(join(gsdDir, "auto.lock")), "canonical auto.lock should be preserved");
+  assert.ok(!existsSync(join(gsdDir, "auto 2.lock")), "auto 2.lock should be removed");
+  assert.ok(!existsSync(join(gsdDir, "auto 3.lock")), "auto 3.lock should be removed");
+  assert.ok(!existsSync(join(gsdDir, "auto 4.lock")), "auto 4.lock should be removed");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("cleanupStrayLockFiles handles parenthesized variants", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  const gsdDir = join(dir, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  // macOS sometimes uses parenthesized format: "auto (2).lock"
+  writeFileSync(join(gsdDir, "auto.lock"), '{"pid":1}');
+  writeFileSync(join(gsdDir, "auto (2).lock"), '{"pid":2}');
+
+  cleanupStrayLockFiles(dir);
+
+  assert.ok(existsSync(join(gsdDir, "auto.lock")), "canonical auto.lock should be preserved");
+  assert.ok(!existsSync(join(gsdDir, "auto (2).lock")), "auto (2).lock should be removed");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("cleanupStrayLockFiles does not remove unrelated files", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  const gsdDir = join(dir, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  // Create unrelated files that should NOT be removed
+  writeFileSync(join(gsdDir, "auto.lock"), '{"pid":1}');
+  writeFileSync(join(gsdDir, "config.json"), '{}');
+  writeFileSync(join(gsdDir, "other.lock"), '{}');
+
+  cleanupStrayLockFiles(dir);
+
+  assert.ok(existsSync(join(gsdDir, "auto.lock")), "auto.lock should be preserved");
+  assert.ok(existsSync(join(gsdDir, "config.json")), "config.json should be preserved");
+  assert.ok(existsSync(join(gsdDir, "other.lock")), "other.lock should be preserved");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("cleanupStrayLockFiles is safe on empty directory", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  const gsdDir = join(dir, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  // Should not throw
+  cleanupStrayLockFiles(dir);
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("cleanupStrayLockFiles is safe when .gsd/ does not exist", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+
+  // Should not throw even without .gsd/
+  cleanupStrayLockFiles(dir);
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("acquireSessionLock cleans stray lock files before acquiring", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  const gsdDir = join(dir, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  // Plant stray lock files before acquire
+  writeFileSync(join(gsdDir, "auto 2.lock"), '{"pid":9999999}');
+  writeFileSync(join(gsdDir, "auto 3.lock"), '{"pid":9999998}');
+
+  const result = acquireSessionLock(dir);
+  assert.equal(result.acquired, true, "should acquire lock");
+
+  // Stray files should be cleaned up
+  assert.ok(!existsSync(join(gsdDir, "auto 2.lock")), "auto 2.lock should be removed during acquire");
+  assert.ok(!existsSync(join(gsdDir, "auto 3.lock")), "auto 3.lock should be removed during acquire");
+
+  releaseSessionLock(dir);
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("releaseSessionLock cleans stray lock files after releasing", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  const gsdDir = join(dir, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  const result = acquireSessionLock(dir);
+  assert.equal(result.acquired, true);
+
+  // Plant stray lock files (simulating cloud sync creating them during session)
+  writeFileSync(join(gsdDir, "auto 2.lock"), '{"pid":9999999}');
+
+  releaseSessionLock(dir);
+
+  assert.ok(!existsSync(join(gsdDir, "auto 2.lock")), "auto 2.lock should be removed during release");
+  assert.ok(!existsSync(join(gsdDir, "auto.lock")), "auto.lock should also be removed");
+
+  rmSync(dir, { recursive: true, force: true });
+});

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

@@ -0,0 +1,206 @@
+/**
+ * worktree-sync-milestones.test.ts — Regression test for #1311.
+ *
+ * Verifies that syncGsdStateToWorktree copies missing milestones,
+ * milestone files, and slice directories from the main repo's .gsd/
+ * into the worktree's .gsd/.
+ *
+ * Covers:
+ *   - Entirely missing milestone directory
+ *   - Milestone exists but missing CONTEXT/ROADMAP files
+ *   - Missing slices within an existing milestone
+ *   - No-op when directories are identical (symlinked)
+ *   - Root-level files (DECISIONS, REQUIREMENTS, etc.)
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, symlinkSync, realpathSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { syncGsdStateToWorktree } from '../auto-worktree.ts';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function createBase(name: string): string {
+  const base = mkdtempSync(join(tmpdir(), `gsd-wt-sync-${name}-`));
+  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+async function main(): Promise<void> {
+
+  // ─── 1. Missing milestone directory is synced ─────────────────────────
+  console.log('\n=== 1. missing milestone directory is copied from main ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      // Main repo has M001 and M002
+      const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(m001Dir, { recursive: true });
+      writeFileSync(join(m001Dir, 'M001-CONTEXT.md'), '# M001\nDone.');
+      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# Roadmap');
+
+      const m002Dir = join(mainBase, '.gsd', 'milestones', 'M002');
+      mkdirSync(m002Dir, { recursive: true });
+      writeFileSync(join(m002Dir, 'M002-CONTEXT.md'), '# M002\nNew milestone.');
+      writeFileSync(join(m002Dir, 'M002-ROADMAP.md'), '# Roadmap');
+
+      // Worktree only has M001
+      const wtM001Dir = join(wtBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(wtM001Dir, { recursive: true });
+      writeFileSync(join(wtM001Dir, 'M001-CONTEXT.md'), '# M001\nDone.');
+
+      // M002 is missing from worktree
+      assertTrue(!existsSync(join(wtBase, '.gsd', 'milestones', 'M002')), 'M002 missing before sync');
+
+      const result = syncGsdStateToWorktree(mainBase, wtBase);
+
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M002')), '#1311: M002 synced to worktree');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M002', 'M002-CONTEXT.md')), 'M002 CONTEXT synced');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M002', 'M002-ROADMAP.md')), 'M002 ROADMAP synced');
+      assertTrue(result.synced.length > 0, 'sync reported files');
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+
+  // ─── 2. Missing files within existing milestone ───────────────────────
+  console.log('\n=== 2. missing files within existing milestone are synced ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      // Main repo M001 has CONTEXT, ROADMAP, RESEARCH
+      const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(m001Dir, { recursive: true });
+      writeFileSync(join(m001Dir, 'M001-CONTEXT.md'), '# M001 Context');
+      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# M001 Roadmap');
+      writeFileSync(join(m001Dir, 'M001-RESEARCH.md'), '# M001 Research');
+
+      // Worktree M001 only has CONTEXT (stale snapshot)
+      const wtM001Dir = join(wtBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(wtM001Dir, { recursive: true });
+      writeFileSync(join(wtM001Dir, 'M001-CONTEXT.md'), '# M001 Context');
+
+      const result = syncGsdStateToWorktree(mainBase, wtBase);
+
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md')), 'ROADMAP synced');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'M001-RESEARCH.md')), 'RESEARCH synced');
+      // Existing file should NOT be overwritten
+      assertEq(
+        readFileSync(join(wtBase, '.gsd', 'milestones', 'M001', 'M001-CONTEXT.md'), 'utf-8'),
+        '# M001 Context',
+        'existing CONTEXT not overwritten',
+      );
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+
+  // ─── 3. Missing slices directory synced ───────────────────────────────
+  console.log('\n=== 3. missing slices directory synced ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      // Main repo has M001 with slices S01–S03
+      const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(join(m001Dir, 'slices', 'S01'), { recursive: true });
+      mkdirSync(join(m001Dir, 'slices', 'S02'), { recursive: true });
+      mkdirSync(join(m001Dir, 'slices', 'S03'), { recursive: true });
+      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# Roadmap');
+      writeFileSync(join(m001Dir, 'slices', 'S01', 'S01-PLAN.md'), '# S01 Plan');
+      writeFileSync(join(m001Dir, 'slices', 'S02', 'S02-PLAN.md'), '# S02 Plan');
+      writeFileSync(join(m001Dir, 'slices', 'S03', 'S03-PLAN.md'), '# S03 Plan');
+
+      // Worktree M001 has slices S01–S02 only (S03 missing)
+      const wtM001Dir = join(wtBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(join(wtM001Dir, 'slices', 'S01'), { recursive: true });
+      mkdirSync(join(wtM001Dir, 'slices', 'S02'), { recursive: true });
+      writeFileSync(join(wtM001Dir, 'M001-ROADMAP.md'), '# Roadmap');
+      writeFileSync(join(wtM001Dir, 'slices', 'S01', 'S01-PLAN.md'), '# S01 Plan');
+      writeFileSync(join(wtM001Dir, 'slices', 'S02', 'S02-PLAN.md'), '# S02 Plan');
+
+      assertTrue(!existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S03')), 'S03 missing before sync');
+
+      syncGsdStateToWorktree(mainBase, wtBase);
+
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S03')), '#1311: S03 synced');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S03', 'S03-PLAN.md')), 'S03 PLAN synced');
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+
+  // ─── 4. No-op when both resolve to same directory (symlink) ───────────
+  console.log('\n=== 4. no-op when .gsd/ resolves to same path (symlinked) ===');
+  {
+    const sharedDir = createBase('shared');
+    const mainBase = mkdtempSync(join(tmpdir(), 'gsd-wt-sync-main-'));
+    const wtBase = mkdtempSync(join(tmpdir(), 'gsd-wt-sync-wt-'));
+
+    try {
+      // Both main and worktree symlink to the same shared directory
+      writeFileSync(join(sharedDir, '.gsd', 'milestones', 'keep'), '');
+      symlinkSync(join(sharedDir, '.gsd'), join(mainBase, '.gsd'));
+      symlinkSync(join(sharedDir, '.gsd'), join(wtBase, '.gsd'));
+
+      const result = syncGsdStateToWorktree(mainBase, wtBase);
+      assertEq(result.synced.length, 0, 'no files synced when both point to same dir');
+    } finally {
+      cleanup(sharedDir);
+      rmSync(mainBase, { recursive: true, force: true });
+      rmSync(wtBase, { recursive: true, force: true });
+    }
+  }
+
+  // ─── 5. Root-level .gsd/ files synced ─────────────────────────────────
+  console.log('\n=== 5. root-level .gsd/ files synced ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      writeFileSync(join(mainBase, '.gsd', 'DECISIONS.md'), '# Decisions');
+      writeFileSync(join(mainBase, '.gsd', 'REQUIREMENTS.md'), '# Requirements');
+      writeFileSync(join(mainBase, '.gsd', 'PROJECT.md'), '# Project');
+
+      // Worktree has none of these
+      const result = syncGsdStateToWorktree(mainBase, wtBase);
+
+      assertTrue(existsSync(join(wtBase, '.gsd', 'DECISIONS.md')), 'DECISIONS.md synced');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'REQUIREMENTS.md')), 'REQUIREMENTS.md synced');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'PROJECT.md')), 'PROJECT.md synced');
+      assertTrue(result.synced.length >= 3, 'at least 3 files synced');
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+
+  // ─── 6. Non-existent directories handled gracefully ───────────────────
+  console.log('\n=== 6. non-existent directories → no-op ===');
+  {
+    const result = syncGsdStateToWorktree('/tmp/does-not-exist-main', '/tmp/does-not-exist-wt');
+    assertEq(result.synced.length, 0, 'no crash on missing directories');
+  }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

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

@@ -9,6 +9,7 @@ import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { gsdRoot, resolveTasksDir, resolveSlicePath, buildTaskFileName } from "./paths.js";
 import { sendDesktopNotification } from "./notifications.js";
+import { parseUnitId } from "./unit-id.js";
 
 /**
  * Undo the last completed unit: revert git commits, remove from completed-units,
@@ -62,11 +63,10 @@ export async function handleUndo(args: string, ctx: ExtensionCommandContext, _pi
   writeFileSync(completedKeysFile, JSON.stringify(keys), "utf-8");
 
   // 3. Delete summary artifact
-  const parts = unitId.split("/");
+  const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
   let summaryRemoved = false;
-  if (parts.length === 3) {
+  if (mid && sid && tid) {
     // Task-level: M001/S01/T01
-    const [mid, sid, tid] = parts;
     const tasksDir = resolveTasksDir(basePath, mid, sid);
     if (tasksDir) {
       const summaryFile = join(tasksDir, buildTaskFileName(tid, "SUMMARY"));
@@ -75,9 +75,8 @@ export async function handleUndo(args: string, ctx: ExtensionCommandContext, _pi
         summaryRemoved = true;
       }
     }
-  } else if (parts.length === 2) {
+  } else if (mid && sid) {
     // Slice-level: M001/S01
-    const [mid, sid] = parts;
     const slicePath = resolveSlicePath(basePath, mid, sid);
     if (slicePath) {
       // Try common summary filenames
@@ -93,8 +92,7 @@ export async function handleUndo(args: string, ctx: ExtensionCommandContext, _pi
 
   // 4. Uncheck task in PLAN if execute-task
   let planUpdated = false;
-  if (unitType === "execute-task" && parts.length === 3) {
-    const [mid, sid, tid] = parts;
+  if (unitType === "execute-task" && mid && sid && tid) {
     planUpdated = uncheckTaskInPlan(basePath, mid, sid, tid);
   }
 

package/src/resources/extensions/gsd/unit-id.ts

@@ -0,0 +1,14 @@
+// GSD Extension — Unit ID Parsing
+// Centralizes the milestone/slice/task decomposition of unit ID strings.
+
+export interface ParsedUnitId {
+  milestone: string;
+  slice?: string;
+  task?: string;
+}
+
+/** Parse a unit ID string (e.g. "M1/S1/T1") into its milestone, slice, and task components. */
+export function parseUnitId(unitId: string): ParsedUnitId {
+  const [milestone, slice, task] = unitId.split("/");
+  return { milestone: milestone!, slice, task };
+}

package/src/resources/extensions/gsd/unit-runtime.ts

@@ -9,6 +9,7 @@ import {
 } from "./paths.js";
 import { loadFile, parseTaskPlanMustHaves, countMustHavesMentionedInSummary } from "./files.js";
 import { loadJsonFileOrNull, saveJsonFile } from "./json-persistence.js";
+import { parseUnitId } from "./unit-id.js";
 
 export type UnitRuntimePhase =
   | "dispatched"
@@ -131,7 +132,7 @@ export async function inspectExecuteTaskDurability(
   basePath: string,
   unitId: string,
 ): Promise<ExecuteTaskRecoveryStatus | null> {
-  const [mid, sid, tid] = unitId.split("/");
+  const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
   if (!mid || !sid || !tid) return null;
 
   const planAbs = resolveSliceFile(basePath, mid, sid, "PLAN");

package/dist/resources/extensions/mcporter/extension-manifest.json

@@ -1,12 +0,0 @@
-{
-  "id": "mcporter",
-  "name": "MCPorter",
-  "version": "1.0.0",
-  "description": "Discover and call tools from MCP servers configured in Claude Desktop, Cursor, and VS Code",
-  "tier": "bundled",
-  "requires": { "platform": ">=2.29.0" },
-  "provides": {
-    "tools": ["mcp_servers", "mcp_discover", "mcp_call"],
-    "hooks": ["session_start"]
-  }
-}

package/src/resources/extensions/mcporter/extension-manifest.json

@@ -1,12 +0,0 @@
-{
-  "id": "mcporter",
-  "name": "MCPorter",
-  "version": "1.0.0",
-  "description": "Discover and call tools from MCP servers configured in Claude Desktop, Cursor, and VS Code",
-  "tier": "bundled",
-  "requires": { "platform": ">=2.29.0" },
-  "provides": {
-    "tools": ["mcp_servers", "mcp_discover", "mcp_call"],
-    "hooks": ["session_start"]
-  }
-}