gsd-pi 2.37.0-dev.b5e7ebc → 2.37.0-dev.c5c85d8

package/README.md

@@ -16,7 +16,7 @@ This version is different. GSD is now a standalone CLI built on the [Pi SDK](htt
 
 One command. Walk away. Come back to a built project with clean git history.
 
-<pre><code>npm install -g gsd-pi</code></pre>
+<pre><code>npm install -g gsd-pi@latest</code></pre>
 
 > **📋 NOTICE: New to Node on Mac?** If you installed Node.js via Homebrew, you may be running a development release instead of LTS. **[Read this guide](./docs/node-lts-macos.md)** to pin Node 24 LTS and avoid compatibility issues.
 

package/dist/resources/extensions/gsd/auto.js

@@ -209,6 +209,29 @@ export function stopAutoRemote(projectRoot) {
         return { found: false, error: err.message };
     }
 }
+/**
+ * Check if a remote auto-mode session is running (from a different process).
+ * Reads the crash lock, checks PID liveness, and returns session details.
+ * Used by the guard in commands.ts to prevent bare /gsd, /gsd next, and
+ * /gsd auto from stealing the session lock.
+ */
+export function checkRemoteAutoSession(projectRoot) {
+    const lock = readCrashLock(projectRoot);
+    if (!lock)
+        return { running: false };
+    if (!isLockProcessAlive(lock)) {
+        // Stale lock from a dead process — not a live remote session
+        return { running: false };
+    }
+    return {
+        running: true,
+        pid: lock.pid,
+        unitType: lock.unitType,
+        unitId: lock.unitId,
+        startedAt: lock.startedAt,
+        completedUnits: lock.completedUnits,
+    };
+}
 export function isStepMode() {
     return s.stepMode;
 }

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

@@ -12,7 +12,7 @@ import { deriveState } from "./state.js";
 import { GSDDashboardOverlay } from "./dashboard-overlay.js";
 import { GSDVisualizerOverlay } from "./visualizer-overlay.js";
 import { showQueue, showDiscuss, showHeadlessMilestoneCreation } from "./guided-flow.js";
-import { startAuto, stopAuto, pauseAuto, isAutoActive, isAutoPaused, stopAutoRemote } from "./auto.js";
+import { startAuto, stopAuto, pauseAuto, isAutoActive, isAutoPaused, stopAutoRemote, checkRemoteAutoSession } from "./auto.js";
 import { dispatchDirectPhase } from "./auto-direct-dispatch.js";
 import { resolveProjectRoot } from "./worktree.js";
 import { assertSafeDirectory } from "./validate-directory.js";
@@ -36,8 +36,8 @@ import { computeProgressScore, formatProgressLine } from "./progress-score.js";
 import { runEnvironmentChecks } from "./doctor-environment.js";
 import { handleLogs } from "./commands-logs.js";
 import { handleStart, handleTemplates, getTemplateCompletions } from "./commands-workflow-templates.js";
-import { readSessionLockData, isSessionLockProcessAlive } from "./session-lock.js";
 import { handleCmux } from "./commands-cmux.js";
+import { showNextAction } from "../shared/mod.js";
 /** Resolve the effective project root, accounting for worktree paths. */
 export function projectRoot() {
     const cwd = process.cwd();
@@ -57,36 +57,81 @@ export function projectRoot() {
     return root;
 }
 /**
- * Check if another process holds the auto-mode session lock.
- * Returns the lock data if a remote session is alive, null otherwise.
+ * Guard against starting auto-mode when a remote session is already running.
+ * Returns true if the caller should proceed with startAuto, false if handled.
  */
-function getRemoteAutoSession(basePath) {
-    const lockData = readSessionLockData(basePath);
-    if (!lockData)
-        return null;
-    if (lockData.pid === process.pid)
-        return null;
-    if (!isSessionLockProcessAlive(lockData))
-        return null;
-    return { pid: lockData.pid };
-}
-/**
- * Show a steering menu when auto-mode is running in another process.
- * Returns true if a remote session was detected (caller should return early).
- */
-function notifyRemoteAutoActive(ctx, basePath) {
-    const remote = getRemoteAutoSession(basePath);
-    if (!remote)
+async function guardRemoteSession(ctx, pi) {
+    // Local session already active — proceed (startAuto handles re-entrant calls)
+    if (isAutoActive() || isAutoPaused())
+        return true;
+    const remote = checkRemoteAutoSession(projectRoot());
+    if (!remote.running || !remote.pid)
+        return true;
+    const unitLabel = remote.unitType && remote.unitId
+        ? `${remote.unitType} (${remote.unitId})`
+        : "unknown unit";
+    const unitsMsg = remote.completedUnits != null
+        ? `${remote.completedUnits} units completed`
+        : "";
+    const choice = await showNextAction(ctx, {
+        title: `Auto-mode is running in another terminal (PID ${remote.pid})`,
+        summary: [
+            `Currently executing: ${unitLabel}`,
+            ...(unitsMsg ? [unitsMsg] : []),
+            ...(remote.startedAt ? [`Started: ${remote.startedAt}`] : []),
+        ],
+        actions: [
+            {
+                id: "status",
+                label: "View status",
+                description: "Show the current GSD progress dashboard.",
+                recommended: true,
+            },
+            {
+                id: "steer",
+                label: "Steer the session",
+                description: "Use /gsd steer <instruction> to redirect the running session.",
+            },
+            {
+                id: "stop",
+                label: "Stop remote session",
+                description: `Send SIGTERM to PID ${remote.pid} to stop it gracefully.`,
+            },
+            {
+                id: "force",
+                label: "Force start (steal lock)",
+                description: "Start a new session, terminating the existing one.",
+            },
+        ],
+        notYetMessage: "Run /gsd when ready.",
+    });
+    if (choice === "status") {
+        await handleStatus(ctx);
+        return false;
+    }
+    if (choice === "steer") {
+        ctx.ui.notify("Use /gsd steer <instruction> to redirect the running auto-mode session.\n" +
+            "Example: /gsd steer Use Postgres instead of SQLite", "info");
+        return false;
+    }
+    if (choice === "stop") {
+        const result = stopAutoRemote(projectRoot());
+        if (result.found) {
+            ctx.ui.notify(`Sent stop signal to auto-mode session (PID ${result.pid}). It will shut down gracefully.`, "info");
+        }
+        else if (result.error) {
+            ctx.ui.notify(`Failed to stop remote auto-mode: ${result.error}`, "error");
+        }
+        else {
+            ctx.ui.notify("Remote session is no longer running.", "info");
+        }
         return false;
-    ctx.ui.notify(`Auto-mode is running in another process (PID ${remote.pid}).\n` +
-        `Use these commands to interact with it:\n` +
-        `  /gsd status   — check progress\n` +
-        `  /gsd discuss  — discuss architecture decisions\n` +
-        `  /gsd queue    — queue the next milestone\n` +
-        `  /gsd steer    — apply an override to active work\n` +
-        `  /gsd capture  — fire-and-forget thought\n` +
-        `  /gsd stop     — stop auto-mode`, "warning");
-    return true;
+    }
+    if (choice === "force") {
+        return true; // Proceed — startAuto will steal the lock
+    }
+    // "not_yet" or escape
+    return false;
 }
 export function registerGSDCommand(pi) {
     pi.registerCommand("gsd", {
@@ -542,12 +587,12 @@ export async function handleGSDCommand(args, ctx, pi) {
             await handleDryRun(ctx, projectRoot());
             return;
         }
-        if (notifyRemoteAutoActive(ctx, projectRoot()))
-            return;
         const verboseMode = trimmed.includes("--verbose");
         const debugMode = trimmed.includes("--debug");
         if (debugMode)
             enableDebug(projectRoot());
+        if (!(await guardRemoteSession(ctx, pi)))
+            return;
         await startAuto(ctx, pi, projectRoot(), verboseMode, { step: true });
         return;
     }
@@ -556,6 +601,8 @@ export async function handleGSDCommand(args, ctx, pi) {
         const debugMode = trimmed.includes("--debug");
         if (debugMode)
             enableDebug(projectRoot());
+        if (!(await guardRemoteSession(ctx, pi)))
+            return;
         await startAuto(ctx, pi, projectRoot(), verboseMode);
         return;
     }
@@ -899,7 +946,7 @@ Examples:
         return;
     }
     if (trimmed === "") {
-        if (notifyRemoteAutoActive(ctx, projectRoot()))
+        if (!(await guardRemoteSession(ctx, pi)))
             return;
         await startAuto(ctx, pi, projectRoot(), false, { step: true });
         return;

package/package.json

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

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

@@ -418,6 +418,38 @@ export function stopAutoRemote(projectRoot: string): {
   }
 }
 
+/**
+ * Check if a remote auto-mode session is running (from a different process).
+ * Reads the crash lock, checks PID liveness, and returns session details.
+ * Used by the guard in commands.ts to prevent bare /gsd, /gsd next, and
+ * /gsd auto from stealing the session lock.
+ */
+export function checkRemoteAutoSession(projectRoot: string): {
+  running: boolean;
+  pid?: number;
+  unitType?: string;
+  unitId?: string;
+  startedAt?: string;
+  completedUnits?: number;
+} {
+  const lock = readCrashLock(projectRoot);
+  if (!lock) return { running: false };
+
+  if (!isLockProcessAlive(lock)) {
+    // Stale lock from a dead process — not a live remote session
+    return { running: false };
+  }
+
+  return {
+    running: true,
+    pid: lock.pid,
+    unitType: lock.unitType,
+    unitId: lock.unitId,
+    startedAt: lock.startedAt,
+    completedUnits: lock.completedUnits,
+  };
+}
+
 export function isStepMode(): boolean {
   return s.stepMode;
 }

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

@@ -15,7 +15,7 @@ import { deriveState } from "./state.js";
 import { GSDDashboardOverlay } from "./dashboard-overlay.js";
 import { GSDVisualizerOverlay } from "./visualizer-overlay.js";
 import { showQueue, showDiscuss, showHeadlessMilestoneCreation } from "./guided-flow.js";
-import { startAuto, stopAuto, pauseAuto, isAutoActive, isAutoPaused, isStepMode, stopAutoRemote } from "./auto.js";
+import { startAuto, stopAuto, pauseAuto, isAutoActive, isAutoPaused, isStepMode, stopAutoRemote, checkRemoteAutoSession } from "./auto.js";
 import { dispatchDirectPhase } from "./auto-direct-dispatch.js";
 import { resolveProjectRoot } from "./worktree.js";
 import { assertSafeDirectory } from "./validate-directory.js";
@@ -50,6 +50,7 @@ import { handleLogs } from "./commands-logs.js";
 import { handleStart, handleTemplates, getTemplateCompletions } from "./commands-workflow-templates.js";
 import { readSessionLockData, isSessionLockProcessAlive } from "./session-lock.js";
 import { handleCmux } from "./commands-cmux.js";
+import { showNextAction } from "../shared/mod.js";
 
 
 /** Resolve the effective project root, accounting for worktree paths. */
@@ -72,36 +73,88 @@ export function projectRoot(): string {
 }
 
 /**
- * Check if another process holds the auto-mode session lock.
- * Returns the lock data if a remote session is alive, null otherwise.
+ * Guard against starting auto-mode when a remote session is already running.
+ * Returns true if the caller should proceed with startAuto, false if handled.
  */
-function getRemoteAutoSession(basePath: string): { pid: number } | null {
-  const lockData = readSessionLockData(basePath);
-  if (!lockData) return null;
-  if (lockData.pid === process.pid) return null;
-  if (!isSessionLockProcessAlive(lockData)) return null;
-  return { pid: lockData.pid };
-}
+async function guardRemoteSession(
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+): Promise<boolean> {
+  // Local session already active — proceed (startAuto handles re-entrant calls)
+  if (isAutoActive() || isAutoPaused()) return true;
+
+  const remote = checkRemoteAutoSession(projectRoot());
+  if (!remote.running || !remote.pid) return true;
+
+  const unitLabel = remote.unitType && remote.unitId
+    ? `${remote.unitType} (${remote.unitId})`
+    : "unknown unit";
+  const unitsMsg = remote.completedUnits != null
+    ? `${remote.completedUnits} units completed`
+    : "";
+
+  const choice = await showNextAction(ctx, {
+    title: `Auto-mode is running in another terminal (PID ${remote.pid})`,
+    summary: [
+      `Currently executing: ${unitLabel}`,
+      ...(unitsMsg ? [unitsMsg] : []),
+      ...(remote.startedAt ? [`Started: ${remote.startedAt}`] : []),
+    ],
+    actions: [
+      {
+        id: "status",
+        label: "View status",
+        description: "Show the current GSD progress dashboard.",
+        recommended: true,
+      },
+      {
+        id: "steer",
+        label: "Steer the session",
+        description: "Use /gsd steer <instruction> to redirect the running session.",
+      },
+      {
+        id: "stop",
+        label: "Stop remote session",
+        description: `Send SIGTERM to PID ${remote.pid} to stop it gracefully.`,
+      },
+      {
+        id: "force",
+        label: "Force start (steal lock)",
+        description: "Start a new session, terminating the existing one.",
+      },
+    ],
+    notYetMessage: "Run /gsd when ready.",
+  });
 
-/**
- * Show a steering menu when auto-mode is running in another process.
- * Returns true if a remote session was detected (caller should return early).
- */
-function notifyRemoteAutoActive(ctx: ExtensionCommandContext, basePath: string): boolean {
-  const remote = getRemoteAutoSession(basePath);
-  if (!remote) return false;
-  ctx.ui.notify(
-    `Auto-mode is running in another process (PID ${remote.pid}).\n` +
-    `Use these commands to interact with it:\n` +
-    `  /gsd status   — check progress\n` +
-    `  /gsd discuss  — discuss architecture decisions\n` +
-    `  /gsd queue    — queue the next milestone\n` +
-    `  /gsd steer    — apply an override to active work\n` +
-    `  /gsd capture  — fire-and-forget thought\n` +
-    `  /gsd stop     — stop auto-mode`,
-    "warning",
-  );
-  return true;
+  if (choice === "status") {
+    await handleStatus(ctx);
+    return false;
+  }
+  if (choice === "steer") {
+    ctx.ui.notify(
+      "Use /gsd steer <instruction> to redirect the running auto-mode session.\n" +
+      "Example: /gsd steer Use Postgres instead of SQLite",
+      "info",
+    );
+    return false;
+  }
+  if (choice === "stop") {
+    const result = stopAutoRemote(projectRoot());
+    if (result.found) {
+      ctx.ui.notify(`Sent stop signal to auto-mode session (PID ${result.pid}). It will shut down gracefully.`, "info");
+    } else if (result.error) {
+      ctx.ui.notify(`Failed to stop remote auto-mode: ${result.error}`, "error");
+    } else {
+      ctx.ui.notify("Remote session is no longer running.", "info");
+    }
+    return false;
+  }
+  if (choice === "force") {
+    return true; // Proceed — startAuto will steal the lock
+  }
+
+  // "not_yet" or escape
+  return false;
 }
 
 export function registerGSDCommand(pi: ExtensionAPI): void {
@@ -598,10 +651,10 @@ export async function handleGSDCommand(
           await handleDryRun(ctx, projectRoot());
           return;
         }
-        if (notifyRemoteAutoActive(ctx, projectRoot())) return;
         const verboseMode = trimmed.includes("--verbose");
         const debugMode = trimmed.includes("--debug");
         if (debugMode) enableDebug(projectRoot());
+        if (!(await guardRemoteSession(ctx, pi))) return;
         await startAuto(ctx, pi, projectRoot(), verboseMode, { step: true });
         return;
       }
@@ -610,6 +663,7 @@ export async function handleGSDCommand(
         const verboseMode = trimmed.includes("--verbose");
         const debugMode = trimmed.includes("--debug");
         if (debugMode) enableDebug(projectRoot());
+        if (!(await guardRemoteSession(ctx, pi))) return;
         await startAuto(ctx, pi, projectRoot(), verboseMode);
         return;
       }
@@ -993,7 +1047,7 @@ Examples:
       }
 
       if (trimmed === "") {
-        if (notifyRemoteAutoActive(ctx, projectRoot())) return;
+        if (!(await guardRemoteSession(ctx, pi))) return;
         await startAuto(ctx, pi, projectRoot(), false, { step: true });
         return;
       }