gsd-pi 2.33.0-dev.69bff0f → 2.33.0

package/README.md

@@ -24,19 +24,24 @@ One command. Walk away. Come back to a built project with clean git history.
 
 ---
 
-## What's New in v2.33
-
-- **Dispatch loop hardening** — defensive guards, reentrancy protection, and 125 new regression tests covering the full `deriveState → resolveDispatch` chain without an LLM
-- **Live regression test harness** — post-build pipeline validation that catches dispatch, parser, and lock lifecycle regressions before promotion
-- **Unified error handling** — `getErrorMessage()` helper replaces 65 inline duplicates across the codebase
-- **Centralized unit ID parsing** — `parseUnitId()` eliminates fragile regex patterns scattered across dispatch, recovery, and metrics code
-- **Milestone merge consolidation** — `tryMergeMilestone()` replaces 4 duplicate merge paths in the auto-mode loop
-- **Lock alignment fix** — retry lock path now matches primary lock settings, preventing `ECOMPROMISED` errors on resume
-- **NixOS/nix-darwin support** — symlinks in `.gsd/` are skipped during `makeTreeWritable` to prevent `EPERM` failures
-- **Windows EPERM fallback** — `.gsd/` migration uses copy+delete when NTFS blocks direct rename
-- **Worktree identity fix** — stable project hash resolved from main repo root, not worktree path
-- **Quick-task branch cleanup** — `/gsd quick` branches auto-merge back to the original branch after completion
-- **Crash recovery guidance** — actionable next-step messages based on what was interrupted and what state survived
+## What's New in v2.32
+
+- **Simplified pipeline** — research merged into planning, mechanical completion (ADR-003)
+- **Always-on health widget** — 🟢🟡🔴 traffic-light indicator in the progress widget and visualizer health tab
+- **Environment health checks** — progress scoring and status integration for auto-mode
+- **Extension registry** — user-managed enable/disable for bundled and custom extensions
+- **Built-in skill authoring** — create and distribute custom skills from within GSD
+- **Workflow templates** — right-sized workflows for every task type (research, plan, execute, complete)
+- **AWS Bedrock auth** — automatic credential refresh via the new `aws-auth` extension
+- **`-w` / `--worktree` CLI flag** — launch isolated worktree sessions from the command line
+- **Native MCP client** — replaced MCPorter with a built-in MCP client for better reliability
+- **External state directory** — `.gsd/` now lives in `~/.gsd/projects/` with a symlink (ADR-002)
+- **Model health indicator** — live health status based on error trends and consecutive failures
+- **Quick-task branch cleanup** — `/gsd quick` branches auto-merge back after completion
+- **Windows EPERM fallback** — migration rename uses copy+delete when NTFS blocks rename
+- **Worktree identity fix** — stable project hash across worktrees and main repo
+- **Crash recovery guidance** — actionable next-step messages based on what was interrupted
+- **UAT verdict gating** — non-PASS verdicts now block slice progression instead of being ignored
 
 See the full [Changelog](./CHANGELOG.md) for details.
 

package/dist/resources/extensions/gsd/auto-supervisor.ts

@@ -1,5 +1,5 @@
 /**
- * Auto-mode Supervisor — signal handling and working-tree activity detection.
+ * Auto-mode Supervisor — SIGTERM handling and working-tree activity detection.
  *
  * Pure functions — no module-level globals or AutoContext dependency.
  */
@@ -8,10 +8,10 @@ import { clearLock } from "./crash-recovery.js";
 import { releaseSessionLock } from "./session-lock.js";
 import { nativeHasChanges } from "./native-git-bridge.js";
 
-// ─── Signal Handling ──────────────────────────────────────────────────────────
+// ─── SIGTERM Handling ─────────────────────────────────────────────────────────
 
 /**
- * Register SIGTERM and SIGINT handlers that clear lock files and exit cleanly.
+ * Register a SIGTERM handler that clears the lock file and exits cleanly.
  * Captures the active base path at registration time so the handler
  * always references the correct path even if the module variable changes.
  * Removes any previously registered handler before installing the new one.
@@ -22,25 +22,20 @@ export function registerSigtermHandler(
   currentBasePath: string,
   previousHandler: (() => void) | null,
 ): () => void {
-  if (previousHandler) {
-    process.off("SIGTERM", previousHandler);
-    process.off("SIGINT", previousHandler);
-  }
+  if (previousHandler) process.off("SIGTERM", previousHandler);
   const handler = () => {
     releaseSessionLock(currentBasePath);
     clearLock(currentBasePath);
     process.exit(0);
   };
   process.on("SIGTERM", handler);
-  process.on("SIGINT", handler);
   return handler;
 }
 
-/** Deregister signal handlers (called on stop/pause). */
+/** Deregister the SIGTERM handler (called on stop/pause). */
 export function deregisterSigtermHandler(handler: (() => void) | null): void {
   if (handler) {
     process.off("SIGTERM", handler);
-    process.off("SIGINT", handler);
   }
 }
 

package/dist/resources/extensions/gsd/auto-worktree.ts

@@ -6,7 +6,7 @@
  * manages create, enter, detect, and teardown for auto-mode worktrees.
  */
 
-import { existsSync, readFileSync, realpathSync, unlinkSync, statSync, rmSync, readdirSync, cpSync, lstatSync as lstatSyncFn } from "node:fs";
+import { existsSync, readFileSync, realpathSync, unlinkSync, statSync, rmSync } from "node:fs";
 import { isAbsolute, join, sep } from "node:path";
 import { GSDError, GSD_IO_ERROR, GSD_GIT_ERROR } from "./errors.js";
 import { execSync, execFileSync } from "node:child_process";
@@ -45,122 +45,6 @@ import { getErrorMessage } from "./error-utils.js";
 /** Original project root before chdir into auto-worktree. */
 let originalBase: string | null = null;
 
-// ─── Worktree ↔ Main Repo Sync (#1311) ──────────────────────────────────────
-
-/**
- * Sync .gsd/ state from the main repo into the worktree.
- *
- * When .gsd/ is a symlink to the external state directory, both the main
- * repo and worktree share the same directory — no sync needed.
- *
- * When .gsd/ is a real directory (e.g., git-tracked or manage_gitignore:false),
- * the worktree has its own copy that may be stale. This function copies
- * missing milestones, CONTEXT, ROADMAP, DECISIONS, REQUIREMENTS, and
- * PROJECT files from the main repo's .gsd/ into the worktree's .gsd/.
- *
- * Only adds missing content — never overwrites existing files in the worktree
- * (the worktree's execution state is authoritative for in-progress work).
- */
-export function syncGsdStateToWorktree(mainBasePath: string, worktreePath_: string): { synced: string[] } {
-  const mainGsd = gsdRoot(mainBasePath);
-  const wtGsd = gsdRoot(worktreePath_);
-  const synced: string[] = [];
-
-  // If both resolve to the same directory (symlink), no sync needed
-  try {
-    const mainResolved = realpathSync(mainGsd);
-    const wtResolved = realpathSync(wtGsd);
-    if (mainResolved === wtResolved) return { synced };
-  } catch {
-    // Can't resolve — proceed with sync as a safety measure
-  }
-
-  if (!existsSync(mainGsd) || !existsSync(wtGsd)) return { synced };
-
-  // Sync root-level .gsd/ files (DECISIONS, REQUIREMENTS, PROJECT, KNOWLEDGE)
-  const rootFiles = ["DECISIONS.md", "REQUIREMENTS.md", "PROJECT.md", "KNOWLEDGE.md", "OVERRIDES.md"];
-  for (const f of rootFiles) {
-    const src = join(mainGsd, f);
-    const dst = join(wtGsd, f);
-    if (existsSync(src) && !existsSync(dst)) {
-      try {
-        cpSync(src, dst);
-        synced.push(f);
-      } catch { /* non-fatal */ }
-    }
-  }
-
-  // Sync milestones: copy entire milestone directories that are missing
-  const mainMilestonesDir = join(mainGsd, "milestones");
-  const wtMilestonesDir = join(wtGsd, "milestones");
-  if (existsSync(mainMilestonesDir) && existsSync(wtMilestonesDir)) {
-    try {
-      const mainMilestones = readdirSync(mainMilestonesDir, { withFileTypes: true })
-        .filter(d => d.isDirectory() && /^M\d{3}/.test(d.name))
-        .map(d => d.name);
-
-      for (const mid of mainMilestones) {
-        const srcDir = join(mainMilestonesDir, mid);
-        const dstDir = join(wtMilestonesDir, mid);
-
-        if (!existsSync(dstDir)) {
-          // Entire milestone missing from worktree — copy it
-          try {
-            cpSync(srcDir, dstDir, { recursive: true });
-            synced.push(`milestones/${mid}/`);
-          } catch { /* non-fatal */ }
-        } else {
-          // Milestone directory exists but may be missing files (stale snapshot).
-          // Sync individual top-level milestone files (CONTEXT, ROADMAP, RESEARCH, etc.)
-          try {
-            const srcFiles = readdirSync(srcDir).filter(f => f.endsWith(".md") || f.endsWith(".json"));
-            for (const f of srcFiles) {
-              const srcFile = join(srcDir, f);
-              const dstFile = join(dstDir, f);
-              if (!existsSync(dstFile)) {
-                try {
-                  const srcStat = lstatSyncFn(srcFile);
-                  if (srcStat.isFile()) {
-                    cpSync(srcFile, dstFile);
-                    synced.push(`milestones/${mid}/${f}`);
-                  }
-                } catch { /* non-fatal */ }
-              }
-            }
-
-            // Sync slices directory if it exists in main but not in worktree
-            const srcSlicesDir = join(srcDir, "slices");
-            const dstSlicesDir = join(dstDir, "slices");
-            if (existsSync(srcSlicesDir) && !existsSync(dstSlicesDir)) {
-              try {
-                cpSync(srcSlicesDir, dstSlicesDir, { recursive: true });
-                synced.push(`milestones/${mid}/slices/`);
-              } catch { /* non-fatal */ }
-            } else if (existsSync(srcSlicesDir) && existsSync(dstSlicesDir)) {
-              // Both exist — sync missing slice directories
-              const srcSlices = readdirSync(srcSlicesDir, { withFileTypes: true })
-                .filter(d => d.isDirectory())
-                .map(d => d.name);
-              for (const sid of srcSlices) {
-                const srcSlice = join(srcSlicesDir, sid);
-                const dstSlice = join(dstSlicesDir, sid);
-                if (!existsSync(dstSlice)) {
-                  try {
-                    cpSync(srcSlice, dstSlice, { recursive: true });
-                    synced.push(`milestones/${mid}/slices/${sid}/`);
-                  } catch { /* non-fatal */ }
-                }
-              }
-            }
-          } catch { /* non-fatal */ }
-        }
-      }
-    } catch { /* non-fatal */ }
-  }
-
-  return { synced };
-}
-
 // ─── Worktree Post-Create Hook (#597) ────────────────────────────────────────
 
 /**
@@ -241,12 +125,6 @@ export function createAutoWorktree(basePath: string, milestoneId: string): strin
   // Ensure worktree shares external state via symlink
   ensureGsdSymlink(info.path);
 
-  // Sync .gsd/ state from main repo into the worktree (#1311).
-  // Even with the symlink, the worktree may have stale git-tracked files
-  // if .gsd/ is not gitignored. And on fresh create, the milestone files
-  // created on main since the branch point won't be in the worktree.
-  syncGsdStateToWorktree(basePath, info.path);
-
   // Run user-configured post-create hook (#597) — e.g. copy .env, symlink assets
   const hookError = runWorktreePostCreateHook(basePath, info.path);
   if (hookError) {
@@ -389,18 +267,6 @@ export function enterAutoWorktree(basePath: string, milestoneId: string): string
     throw new GSDError(GSD_IO_ERROR, `Auto-worktree path ${p} exists but .git is unreadable`);
   }
 
-  // Ensure worktree shares external state via symlink (#1311).
-  // On resume (enterAutoWorktree), the symlink may be missing if it was
-  // created before ensureGsdSymlink existed, or the .gsd/ directory may be
-  // a stale git-tracked copy instead of a symlink. Refreshing here ensures
-  // the worktree sees the same milestone state as the main repo.
-  ensureGsdSymlink(p);
-
-  // Sync .gsd/ state from main repo into worktree (#1311).
-  // Covers the case where .gsd/ is a real directory (not symlinked) and
-  // milestones were created on main after the worktree was last used.
-  syncGsdStateToWorktree(basePath, p);
-
   const previousCwd = process.cwd();
 
   try {

package/dist/resources/extensions/gsd/commands.ts

@@ -52,20 +52,8 @@ import { handleStart, handleTemplates, getTemplateCompletions } from "./commands
 
 /** Resolve the effective project root, accounting for worktree paths. */
 export function projectRoot(): string {
-  const cwd = process.cwd();
-  const root = resolveProjectRoot(cwd);
-
-  // When running inside a GSD worktree, the resolved root may be a "dangerous"
-  // directory (e.g., $HOME used as a git repo root — #1317). The safety check
-  // should validate the actual working directory, not the upstream root,
-  // because the worktree itself is a safe project subdirectory.
-  // Only skip the root check when we can confirm we're in a valid worktree.
-  if (root !== cwd) {
-    // We're in a worktree — validate the worktree path instead of the root
-    assertSafeDirectory(cwd);
-  } else {
-    assertSafeDirectory(root);
-  }
+  const root = resolveProjectRoot(process.cwd());
+  assertSafeDirectory(root);
   return root;
 }
 

package/dist/resources/extensions/gsd/session-lock.ts

@@ -17,7 +17,7 @@
  */
 
 import { createRequire } from "node:module";
-import { existsSync, readFileSync, readdirSync, mkdirSync, unlinkSync, rmSync, statSync } from "node:fs";
+import { existsSync, readFileSync, mkdirSync, unlinkSync, rmSync, statSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { atomicWriteSync } from "./atomic-write.js";
@@ -54,81 +54,12 @@ let _lockPid: number = 0;
 /** Set to true when proper-lockfile fires onCompromised (mtime drift, sleep, etc.). */
 let _lockCompromised: boolean = false;
 
-/** Whether we've already registered a process.on('exit') handler. */
-let _exitHandlerRegistered: boolean = false;
-
 const LOCK_FILE = "auto.lock";
 
 function lockPath(basePath: string): string {
   return join(gsdRoot(basePath), LOCK_FILE);
 }
 
-// ─── Stray Lock Cleanup ─────────────────────────────────────────────────────
-
-/**
- * Remove numbered lock file variants (e.g. "auto 2.lock", "auto 3.lock")
- * that accumulate from macOS file conflict resolution (iCloud/Dropbox/OneDrive)
- * or other filesystem-level copy-on-conflict behavior (#1315).
- *
- * Also removes stray proper-lockfile directories beyond the canonical `.gsd.lock/`.
- */
-export function cleanupStrayLockFiles(basePath: string): void {
-  const gsdDir = gsdRoot(basePath);
-
-  // Clean numbered auto lock files inside .gsd/
-  try {
-    if (existsSync(gsdDir)) {
-      for (const entry of readdirSync(gsdDir)) {
-        // Match "auto <N>.lock" or "auto (<N>).lock" variants but NOT the canonical "auto.lock"
-        if (entry !== LOCK_FILE && /^auto\s.+\.lock$/i.test(entry)) {
-          try { unlinkSync(join(gsdDir, entry)); } catch { /* best-effort */ }
-        }
-      }
-    }
-  } catch { /* non-fatal: directory read failure */ }
-
-  // Clean stray proper-lockfile directories (e.g. ".gsd 2.lock/")
-  // The canonical one is ".gsd.lock/" — anything else is stray.
-  try {
-    const parentDir = dirname(gsdDir);
-    const gsdDirName = gsdDir.split("/").pop() || ".gsd";
-    if (existsSync(parentDir)) {
-      for (const entry of readdirSync(parentDir)) {
-        // Match ".gsd <N>.lock" or ".gsd (<N>).lock" directories but NOT ".gsd.lock"
-        if (entry !== `${gsdDirName}.lock` && entry.startsWith(gsdDirName) && entry.endsWith(".lock")) {
-          const fullPath = join(parentDir, entry);
-          try {
-            const stat = statSync(fullPath);
-            if (stat.isDirectory()) {
-              rmSync(fullPath, { recursive: true, force: true });
-            }
-          } catch { /* best-effort */ }
-        }
-      }
-    }
-  } catch { /* non-fatal */ }
-}
-
-/**
- * Register a single process exit handler that cleans up lock state.
- * Uses module-level references so it always operates on current state.
- * Only registers once — subsequent calls are no-ops.
- */
-function ensureExitHandler(gsdDir: string): void {
-  if (_exitHandlerRegistered) return;
-  _exitHandlerRegistered = true;
-
-  process.once("exit", () => {
-    try {
-      if (_releaseFunction) { _releaseFunction(); _releaseFunction = null; }
-    } catch { /* best-effort */ }
-    try {
-      const lockDir = join(gsdDir + ".lock");
-      if (existsSync(lockDir)) rmSync(lockDir, { recursive: true, force: true });
-    } catch { /* best-effort */ }
-  });
-}
-
 // ─── Public API ─────────────────────────────────────────────────────────────
 
 /**
@@ -146,9 +77,6 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
   // Ensure the directory exists
   mkdirSync(dirname(lp), { recursive: true });
 
-  // Clean up numbered lock file variants from cloud sync conflicts (#1315)
-  cleanupStrayLockFiles(basePath);
-
   // Write our lock data first (the content is informational; the OS lock is the real guard)
   const lockData: SessionLockData = {
     pid: process.pid,
@@ -196,7 +124,15 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
 
     // Safety net: clean up lock dir on process exit if _releaseFunction
     // wasn't called (e.g., normal exit after clean completion) (#1245).
-    ensureExitHandler(gsdDir);
+    const lockDirForCleanup = join(gsdDir + ".lock");
+    process.once("exit", () => {
+      try {
+        if (_releaseFunction) { _releaseFunction(); _releaseFunction = null; }
+      } catch { /* best-effort */ }
+      try {
+        if (existsSync(lockDirForCleanup)) rmSync(lockDirForCleanup, { recursive: true, force: true });
+      } catch { /* best-effort */ }
+    });
 
     // Write the informational lock data
     atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
@@ -222,15 +158,18 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
           update: 10_000,
           onCompromised: () => {
             _lockCompromised = true;
-            _releaseFunction = null;
           },
         });
         _releaseFunction = release;
         _lockedPath = basePath;
         _lockPid = process.pid;
 
-        // Safety net — uses centralized handler to avoid double-registration
-        ensureExitHandler(gsdDir);
+        // Safety net for retry path too
+        const retryLockDir = join(gsdDir + ".lock");
+        process.once("exit", () => {
+          try { if (_releaseFunction) { _releaseFunction(); _releaseFunction = null; } } catch {}
+          try { if (existsSync(retryLockDir)) rmSync(retryLockDir, { recursive: true, force: true }); } catch {}
+        });
 
         atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
         return { acquired: true };
@@ -371,9 +310,6 @@ export function releaseSessionLock(basePath: string): void {
     // Non-fatal
   }
 
-  // Clean up numbered lock file variants from cloud sync conflicts (#1315)
-  cleanupStrayLockFiles(basePath);
-
   _lockedPath = null;
   _lockPid = 0;
   _lockCompromised = false;

package/dist/resources/extensions/gsd/tests/loop-regression.test.ts

@@ -609,48 +609,10 @@ test("session lock: onCompromised handler exists in both primary and retry paths
   const compromisedMatches = [...lockSource.matchAll(/onCompromised/g)];
   // Should have at least 2 onCompromised handlers (primary + retry)
   // plus the flag declaration and the check in validateSessionLock
-  assert.ok(compromisedMatches.length >= 3,
+  assert.ok(compromisedMatches.length >= 3, 
     `expected ≥3 onCompromised references (primary + retry + flag), got ${compromisedMatches.length}`);
 });
 
-test("session lock: both onCompromised handlers null _releaseFunction (#1315)", async () => {
-  const lockSource = readFileSync(
-    "src/resources/extensions/gsd/session-lock.ts", "utf-8"
-  );
-  // Extract onCompromised handler blocks — both should set _releaseFunction = null
-  const handlers = lockSource.match(/onCompromised:\s*\(\)\s*=>\s*\{[^}]+\}/g) || [];
-  assert.ok(handlers.length >= 2, `expected ≥2 onCompromised handlers, got ${handlers.length}`);
-  for (const h of handlers) {
-    assert.ok(h.includes("_releaseFunction = null"),
-      `onCompromised handler should null _releaseFunction: ${h}`);
-  }
-});
-
-test("session lock: exit handler uses ensureExitHandler to prevent double-registration (#1315)", async () => {
-  const lockSource = readFileSync(
-    "src/resources/extensions/gsd/session-lock.ts", "utf-8"
-  );
-  // Should use ensureExitHandler instead of direct process.once("exit") in acquire paths
-  const directExitHandlers = (lockSource.match(/process\.once\("exit"/g) || []).length;
-  const ensureExitCalls = (lockSource.match(/ensureExitHandler\(/g) || []).length;
-  // Only 1 direct process.once("exit") allowed — inside ensureExitHandler itself
-  assert.ok(directExitHandlers <= 1,
-    `expected ≤1 direct process.once("exit") (inside ensureExitHandler), got ${directExitHandlers}`);
-  assert.ok(ensureExitCalls >= 2,
-    `expected ≥2 ensureExitHandler calls (primary + retry path), got ${ensureExitCalls}`);
-});
-
-test("signal handler: SIGINT handler registered alongside SIGTERM (#1315)", async () => {
-  const supervisorSource = readFileSync(
-    "src/resources/extensions/gsd/auto-supervisor.ts", "utf-8"
-  );
-  // registerSigtermHandler should register on both SIGTERM and SIGINT
-  assert.ok(supervisorSource.includes('process.on("SIGINT"') || supervisorSource.includes("process.on('SIGINT'"),
-    "registerSigtermHandler should register SIGINT handler");
-  assert.ok(supervisorSource.includes('process.off("SIGINT"') || supervisorSource.includes("process.off('SIGINT'"),
-    "deregisterSigtermHandler should deregister SIGINT handler");
-});
-
 // ─── Scope 5: Crash Recovery — Message Guidance per Unit Type ────────────
 
 test("crash recovery: formatCrashInfo includes guidance for bootstrap crash", async () => {

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

@@ -12,7 +12,6 @@ import {
   readSessionLockData,
   isSessionLockHeld,
   isSessionLockProcessAlive,
-  cleanupStrayLockFiles,
 } from "../session-lock.ts";
 
 // ─── acquireSessionLock ──────────────────────────────────────────────────
@@ -314,121 +313,3 @@ 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/dist/resources/extensions/mcporter/extension-manifest.json

@@ -0,0 +1,12 @@
+{
+  "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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.33.0-dev.69bff0f",
+  "version": "2.33.0",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {