gsd-pi 2.16.0 → 2.18.0

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

@@ -29,7 +29,7 @@ import {
   buildMilestoneFileName, buildSliceFileName, buildTaskFileName,
 } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
-import { saveActivityLog } from "./activity-log.js";
+import { saveActivityLog, clearActivityLogState } from "./activity-log.js";
 import { synthesizeCrashRecovery, getDeepDiagnostic } from "./session-forensics.js";
 import { writeLock, clearLock, readCrashLock, formatCrashInfo, isLockProcessAlive } from "./crash-recovery.js";
 import {
@@ -92,7 +92,9 @@ import {
   getAutoWorktreePath,
   getAutoWorktreeOriginalBase,
   mergeMilestoneToMain,
+  autoWorktreeBranch,
 } from "./auto-worktree.js";
+import { pruneQueueOrder } from "./queue-order.js";
 import { showNextAction } from "../shared/next-action-ui.js";
 import {
   resolveExpectedArtifactPath,
@@ -196,6 +198,33 @@ function shouldUseWorktreeIsolation(): boolean {
   return true; // default: worktree
 }
 
+/**
+ * Detect and escape a stale worktree cwd (#608).
+ *
+ * After milestone completion + merge, the worktree directory is removed but
+ * the process cwd may still point inside `.gsd/worktrees/<MID>/`.
+ * When a new session starts, `process.cwd()` is passed as `base` to startAuto
+ * and all subsequent writes land in the wrong directory. This function detects
+ * that scenario and chdir back to the project root.
+ *
+ * Returns the corrected base path.
+ */
+function escapeStaleWorktree(base: string): string {
+  const marker = `${pathSep}.gsd${pathSep}worktrees${pathSep}`;
+  const idx = base.indexOf(marker);
+  if (idx === -1) return base;
+
+  // base is inside .gsd/worktrees/<something> — extract the project root
+  const projectRoot = base.slice(0, idx);
+  try {
+    process.chdir(projectRoot);
+  } catch {
+    // If chdir fails, return the original — caller will handle errors downstream
+    return base;
+  }
+  return projectRoot;
+}
+
 /** Crash recovery prompt — set by startAuto, consumed by first dispatchNextUnit */
 let pendingCrashRecovery: string | null = null;
 
@@ -228,6 +257,9 @@ const DISPATCH_GAP_TIMEOUT_MS = 5_000; // 5 seconds
 /** SIGTERM handler registered while auto-mode is active — cleared on stop/pause. */
 let _sigtermHandler: (() => void) | null = null;
 
+/** Tool calls currently being executed — prevents false idle detection during long-running tools. */
+const inFlightTools = new Set<string>();
+
 type BudgetAlertLevel = 0 | 75 | 90 | 100;
 
 export function getBudgetAlertLevel(budgetPct: number): BudgetAlertLevel {
@@ -293,6 +325,57 @@ export function isAutoPaused(): boolean {
   return paused;
 }
 
+/**
+ * Mark a tool execution as in-flight. Called from index.ts on tool_execution_start.
+ * Prevents the idle watchdog from declaring the agent idle while tools are executing.
+ */
+export function markToolStart(toolCallId: string): void {
+  if (!active) return;
+  inFlightTools.add(toolCallId);
+}
+
+/**
+ * Mark a tool execution as completed. Called from index.ts on tool_execution_end.
+ */
+export function markToolEnd(toolCallId: string): void {
+  inFlightTools.delete(toolCallId);
+}
+
+/**
+ * Return the base path to use for the auto.lock file.
+ * Always uses the original project root (not the worktree) so that
+ * a second terminal can discover and stop a running auto-mode session.
+ */
+function lockBase(): string {
+  return originalBasePath || basePath;
+}
+
+/**
+ * Attempt to stop a running auto-mode session from a different process.
+ * Reads the lock file at the project root, checks if the PID is alive,
+ * and sends SIGTERM to gracefully stop it.
+ *
+ * Returns true if a remote session was found and signaled, false otherwise.
+ */
+export function stopAutoRemote(projectRoot: string): { found: boolean; pid?: number; error?: string } {
+  const lock = readCrashLock(projectRoot);
+  if (!lock) return { found: false };
+
+  if (!isLockProcessAlive(lock)) {
+    // Stale lock — clean it up
+    clearLock(projectRoot);
+    return { found: false };
+  }
+
+  // Send SIGTERM — the auto-mode process has a handler that clears the lock and exits
+  try {
+    process.kill(lock.pid, "SIGTERM");
+    return { found: true, pid: lock.pid };
+  } catch (err) {
+    return { found: false, error: (err as Error).message };
+  }
+}
+
 export function isStepMode(): boolean {
   return stepMode;
 }
@@ -310,6 +393,7 @@ function clearUnitTimeout(): void {
     clearInterval(idleWatchdogHandle);
     idleWatchdogHandle = null;
   }
+  inFlightTools.clear();
   clearDispatchGapWatchdog();
 }
 
@@ -371,7 +455,7 @@ function startDispatchGapWatchdog(ctx: ExtensionContext, pi: ExtensionAPI): void
 export async function stopAuto(ctx?: ExtensionContext, pi?: ExtensionAPI): Promise<void> {
   if (!active && !paused) return;
   clearUnitTimeout();
-  if (basePath) clearLock(basePath);
+  if (lockBase()) clearLock(lockBase());
   clearSkillSnapshot();
   _dispatching = false;
   _skipDepth = 0;
@@ -391,14 +475,18 @@ export async function stopAuto(ctx?: ExtensionContext, pi?: ExtensionAPI): Promi
         `Auto-worktree teardown failed: ${err instanceof Error ? err.message : String(err)}`,
         "warning",
       );
-      // Force basePath back to original even if teardown failed
-      if (originalBasePath) {
-        basePath = originalBasePath;
-        try { process.chdir(basePath); } catch { /* best-effort */ }
-      }
     }
   }
 
+  // Always restore cwd to project root on stop (#608).
+  // Even if isInAutoWorktree returned false (e.g., module state was already
+  // cleared by mergeMilestoneToMain), the process cwd may still be inside
+  // the worktree directory. Force it back to originalBasePath.
+  if (originalBasePath) {
+    basePath = originalBasePath;
+    try { process.chdir(basePath); } catch { /* best-effort */ }
+  }
+
   const ledger = getLedger();
   if (ledger && ledger.units.length > 0) {
     const totals = getProjectTotals(ledger.units);
@@ -423,12 +511,15 @@ export async function stopAuto(ctx?: ExtensionContext, pi?: ExtensionAPI): Promi
   stepMode = false;
   unitDispatchCount.clear();
   unitRecoveryCount.clear();
+  inFlightTools.clear();
   lastBudgetAlertLevel = 0;
   unitLifetimeDispatches.clear();
   currentUnit = null;
   currentMilestoneId = null;
   originalBasePath = "";
+  completedUnits = [];
   clearSliceProgressCache();
+  clearActivityLogState();
   pendingCrashRecovery = null;
   _handlingAgentEnd = false;
   ctx?.ui.setStatus("gsd-auto", undefined);
@@ -454,7 +545,7 @@ export async function stopAuto(ctx?: ExtensionContext, pi?: ExtensionAPI): Promi
 export async function pauseAuto(ctx?: ExtensionContext, _pi?: ExtensionAPI): Promise<void> {
   if (!active) return;
   clearUnitTimeout();
-  if (basePath) clearLock(basePath);
+  if (lockBase()) clearLock(lockBase());
 
   // Remove SIGTERM handler registered at auto-mode start
   deregisterSigtermHandler();
@@ -484,6 +575,11 @@ export async function startAuto(
 ): Promise<void> {
   const requestedStepMode = options?.step ?? false;
 
+  // Escape stale worktree cwd from a previous milestone (#608).
+  // After milestone merge + worktree removal, the process cwd may still point
+  // inside .gsd/worktrees/<MID>/ — detect and chdir back to project root.
+  base = escapeStaleWorktree(base);
+
   // If resuming from paused state, just re-activate and dispatch next unit.
   // The conversation is still intact — no need to reinitialize everything.
   if (paused) {
@@ -527,24 +623,24 @@ export async function startAuto(
       }
     }
 
-    // Re-register SIGTERM handler for the resumed session
-    registerSigtermHandler(basePath);
+    // Re-register SIGTERM handler for the resumed session (use original base for lock)
+    registerSigtermHandler(lockBase());
 
     ctx.ui.setStatus("gsd-auto", stepMode ? "next" : "auto");
     ctx.ui.setFooter(hideFooter);
     ctx.ui.notify(stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "info");
     // Restore hook state from disk in case session was interrupted
-    restoreHookState(base);
+    restoreHookState(basePath);
     // Rebuild disk state before resuming — user interaction during pause may have changed files
-    try { await rebuildState(base); } catch { /* non-fatal */ }
+    try { await rebuildState(basePath); } catch { /* non-fatal */ }
     try {
-      const report = await runGSDDoctor(base, { fix: true });
+      const report = await runGSDDoctor(basePath, { fix: true });
       if (report.fixesApplied.length > 0) {
         ctx.ui.notify(`Resume: applied ${report.fixesApplied.length} fix(es) to state.`, "info");
       }
     } catch { /* non-fatal */ }
     // Self-heal: clear stale runtime records where artifacts already exist
-    await selfHealRuntimeRecords(base, ctx, completedKeySet);
+    await selfHealRuntimeRecords(basePath, ctx, completedKeySet);
     invalidateAllCaches();
     await dispatchNextUnit(ctx, pi);
     return;
@@ -557,17 +653,21 @@ export async function startAuto(
   }
 
   // Ensure .gitignore has baseline patterns
-  ensureGitignore(base);
+  const commitDocs = loadEffectiveGSDPreferences()?.preferences?.git?.commit_docs;
+  ensureGitignore(base, { commitDocs });
   untrackRuntimeFiles(base);
 
   // Bootstrap .gsd/ if it doesn't exist
   const gsdDir = join(base, ".gsd");
   if (!existsSync(gsdDir)) {
     mkdirSync(join(gsdDir, "milestones"), { recursive: true });
-    try {
-      nativeAddPaths(base, [".gsd", ".gitignore"]);
-      nativeCommit(base, "chore: init gsd");
-    } catch { /* nothing to commit */ }
+    // Only commit .gsd/ init when commit_docs is not explicitly false
+    if (commitDocs !== false) {
+      try {
+        nativeAddPaths(base, [".gsd", ".gitignore"]);
+        nativeCommit(base, "chore: init gsd");
+      } catch { /* nothing to commit */ }
+    }
   }
 
   // Initialize GitServiceImpl — basePath is set and git repo confirmed
@@ -658,7 +758,7 @@ export async function startAuto(
   // of the repo's default (main/master). Idempotent when the branch is the
   // same; updates the record when started from a different branch (#300).
   if (currentMilestoneId) {
-    captureIntegrationBranch(base, currentMilestoneId);
+    captureIntegrationBranch(base, currentMilestoneId, { commitDocs });
     setActiveMilestoneId(base, currentMilestoneId);
   }
 
@@ -695,8 +795,8 @@ export async function startAuto(
         gitService = new GitServiceImpl(basePath, loadEffectiveGSDPreferences()?.preferences?.git ?? {});
         ctx.ui.notify(`Created auto-worktree at ${wtPath}`, "info");
       }
-      // Re-register SIGTERM handler with the new basePath
-      registerSigtermHandler(basePath);
+      // Re-register SIGTERM handler with the original basePath (lock lives there)
+      registerSigtermHandler(originalBasePath);
     } catch (err) {
       // Worktree creation is non-fatal — continue in the project root.
       ctx.ui.notify(
@@ -952,7 +1052,7 @@ export async function handleAgentEnd(
         return;
       }
       const sessionFile = ctx.sessionManager.getSessionFile();
-      writeLock(basePath, hookUnit.unitType, hookUnit.unitId, completedUnits.length, sessionFile);
+      writeLock(lockBase(), hookUnit.unitType, hookUnit.unitId, completedUnits.length, sessionFile);
       // Persist hook state so cycle counts survive crashes
       persistHookState(basePath);
 
@@ -1211,7 +1311,12 @@ async function dispatchNextUnit(
     unitRecoveryCount.clear();
     unitLifetimeDispatches.clear();
     // Capture integration branch for the new milestone and update git service
-    captureIntegrationBranch(originalBasePath || basePath, mid);
+    captureIntegrationBranch(originalBasePath || basePath, mid, { commitDocs: loadEffectiveGSDPreferences()?.preferences?.git?.commit_docs });
+    // Prune completed milestone from queue order file
+    const pendingIds = state.registry
+      .filter(m => m.status !== "complete")
+      .map(m => m.id);
+    pruneQueueOrder(basePath, pendingIds);
   }
   if (mid) {
     currentMilestoneId = mid;
@@ -1292,6 +1397,39 @@ async function dispatchNextUnit(
           `Milestone merge failed: ${err instanceof Error ? err.message : String(err)}`,
           "warning",
         );
+        // Ensure cwd is restored even if merge failed partway through (#608).
+        // mergeMilestoneToMain may have chdir'd but then thrown, leaving us
+        // in an indeterminate location.
+        if (originalBasePath) {
+          basePath = originalBasePath;
+          try { process.chdir(basePath); } catch { /* best-effort */ }
+        }
+      }
+    } else if (currentMilestoneId && !isInAutoWorktree(basePath)) {
+      // Branch isolation mode (#603): no worktree, but we may be on a milestone/* branch.
+      // Squash-merge back to the integration branch (or main) before stopping.
+      try {
+        const currentBranch = getCurrentBranch(basePath);
+        const milestoneBranch = autoWorktreeBranch(currentMilestoneId);
+        if (currentBranch === milestoneBranch) {
+          const roadmapPath = resolveMilestoneFile(basePath, currentMilestoneId, "ROADMAP");
+          if (roadmapPath) {
+            const roadmapContent = readFileSync(roadmapPath, "utf-8");
+            // mergeMilestoneToMain handles: auto-commit, checkout integration branch,
+            // squash merge, commit, optional push, branch deletion.
+            const mergeResult = mergeMilestoneToMain(basePath, currentMilestoneId, roadmapContent);
+            gitService = new GitServiceImpl(basePath, loadEffectiveGSDPreferences()?.preferences?.git ?? {});
+            ctx.ui.notify(
+              `Milestone ${currentMilestoneId} merged (branch mode).${mergeResult.pushed ? " Pushed to remote." : ""}`,
+              "info",
+            );
+          }
+        }
+      } catch (err) {
+        ctx.ui.notify(
+          `Milestone merge failed (branch mode): ${err instanceof Error ? err.message : String(err)}`,
+          "warning",
+        );
       }
     }
     sendDesktopNotification("GSD", `Milestone ${mid} complete!`, "success", "milestone");
@@ -1718,6 +1856,10 @@ async function dispatchNextUnit(
         startedAt: currentUnit.startedAt,
         finishedAt: Date.now(),
       });
+      // Cap to last 200 entries to prevent unbounded growth (#611)
+      if (completedUnits.length > 200) {
+        completedUnits = completedUnits.slice(-200);
+      }
       clearUnitRuntimeRecord(basePath, currentUnit.type, currentUnit.id);
       unitDispatchCount.delete(`${currentUnit.type}/${currentUnit.id}`);
       unitRecoveryCount.delete(`${currentUnit.type}/${currentUnit.id}`);
@@ -1758,7 +1900,7 @@ async function dispatchNextUnit(
   // Pi appends entries incrementally via appendFileSync, so on crash the
   // session file survives with every tool call up to the crash point.
   const sessionFile = ctx.sessionManager.getSessionFile();
-  writeLock(basePath, unitType, unitId, completedUnits.length, sessionFile);
+  writeLock(lockBase(), unitType, unitId, completedUnits.length, sessionFile);
 
   // On crash recovery, prepend the full recovery briefing
   // On retry (stuck detection), prepend deep diagnostic from last attempt
@@ -1918,6 +2060,16 @@ async function dispatchNextUnit(
     if (!runtime) return;
     if (Date.now() - runtime.lastProgressAt < idleTimeoutMs) return;
 
+    // Agent has tool calls currently executing (await_job, long bash, etc.) —
+    // not idle, just waiting for tool completion.
+    if (inFlightTools.size > 0) {
+      writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnit.startedAt, {
+        lastProgressAt: Date.now(),
+        lastProgressKind: "tool-in-flight",
+      });
+      return;
+    }
+
     // Before triggering recovery, check if the agent is actually producing
     // work on disk.  `git status --porcelain` is cheap and catches any
     // staged/unstaged/untracked changes the agent made since lastProgressAt.