gsd-pi 2.76.0-dev.355e107a0 → 2.76.0-dev.479ad0e78

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

@@ -30,6 +30,13 @@ function stuckStatePath(basePath) {
 function loadStuckState(basePath) {
     try {
         const data = JSON.parse(readFileSync(stuckStatePath(basePath), "utf-8"));
+        // Only load state written by a DIFFERENT process (real session restart).
+        // If the PID matches the current process, this state was written by an earlier
+        // autoLoop call in the same process (e.g., a test that completed before this
+        // one), not by a crashed session — skip it to prevent test state pollution.
+        if (data.pid === process.pid) {
+            return { recentUnits: [], stuckRecoveryAttempts: 0 };
+        }
         return {
             recentUnits: Array.isArray(data.recentUnits) ? data.recentUnits : [],
             stuckRecoveryAttempts: typeof data.stuckRecoveryAttempts === "number" ? data.stuckRecoveryAttempts : 0,
@@ -45,6 +52,7 @@ function saveStuckState(basePath, state) {
         const filePath = stuckStatePath(basePath);
         mkdirSync(join(gsdRoot(basePath), "runtime"), { recursive: true });
         writeFileSync(filePath, JSON.stringify({
+            pid: process.pid,
             recentUnits: state.recentUnits.slice(-20), // keep last 20 entries
             stuckRecoveryAttempts: state.stuckRecoveryAttempts,
             updatedAt: new Date().toISOString(),
@@ -497,6 +505,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
             consecutiveCooldowns = 0;
             recentErrorMessages.length = 0;
             deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-end", data: { iteration } });
+            saveStuckState(s.basePath, loopState); // persist across session restarts (#4382)
             debugLog("autoLoop", { phase: "iteration-complete", iteration });
             finishTurn("completed");
         }

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

@@ -48,7 +48,11 @@ export function resetSessionTimeoutState() {
  * Exported for testing as _resolveReportBasePath.
  */
 export function _resolveReportBasePath(s) {
-    return s.originalBasePath || s.basePath;
+    // Strip /.gsd/worktrees/ suffix when basePath is itself a worktree path and
+    // originalBasePath is falsy — prevents reports landing in the worktree (#3729).
+    const resolved = s.originalBasePath || s.basePath;
+    const markerIdx = resolved.indexOf("/.gsd/worktrees/");
+    return markerIdx !== -1 ? resolved.slice(0, markerIdx) : resolved;
 }
 /**
  * Resolve the authoritative project base for dispatch guards.
@@ -56,7 +60,12 @@ export function _resolveReportBasePath(s) {
  * unit is running inside an auto worktree.
  */
 export function _resolveDispatchGuardBasePath(s) {
-    return s.originalBasePath || s.basePath;
+    // Strip /.gsd/worktrees/ suffix when basePath is itself a worktree path and
+    // originalBasePath is falsy — prevents guard checks running against the
+    // worktree instead of the project root (#3729).
+    const resolved = s.originalBasePath || s.basePath;
+    const markerIdx = resolved.indexOf("/.gsd/worktrees/");
+    return markerIdx !== -1 ? resolved.slice(0, markerIdx) : resolved;
 }
 const PLAN_V2_GATE_PHASES = new Set([
     "executing",

package/dist/resources/extensions/gsd/auto/run-unit.js

@@ -26,15 +26,24 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     let sessionResult;
     let sessionTimeoutHandle;
     const mySessionSwitchGeneration = ++sessionSwitchGeneration;
+    // #3731: Cancellation controller for newSession(). When the session-creation
+    // timeout fires, we abort this controller so that the still-in-flight
+    // newSession() discards itself after await this.abort() completes, preventing
+    // it from capturing the (now-root) process.cwd() and rebuilding the tool
+    // runtime with the wrong cwd.
+    const sessionAbortController = new AbortController();
     _setSessionSwitchInFlight(true);
     try {
-        const sessionPromise = s.cmdCtx.newSession().finally(() => {
+        const sessionPromise = s.cmdCtx.newSession({ abortSignal: sessionAbortController.signal }).finally(() => {
             if (sessionSwitchGeneration === mySessionSwitchGeneration) {
                 _setSessionSwitchInFlight(false);
             }
         });
         const timeoutPromise = new Promise((resolve) => {
-            sessionTimeoutHandle = setTimeout(() => resolve({ cancelled: true }), NEW_SESSION_TIMEOUT_MS);
+            sessionTimeoutHandle = setTimeout(() => {
+                sessionAbortController.abort();
+                resolve({ cancelled: true });
+            }, NEW_SESSION_TIMEOUT_MS);
         });
         sessionResult = await Promise.race([sessionPromise, timeoutPromise]);
     }

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

@@ -150,7 +150,12 @@ export class AutoSession {
         this.unitLifetimeDispatches.clear();
     }
     get lockBasePath() {
-        return this.originalBasePath || this.basePath;
+        // Prefer originalBasePath (project root); fall back to basePath.
+        // Strip /.gsd/worktrees/ suffix if basePath is itself a worktree path
+        // to avoid reading/writing the lock inside the worktree (#3729).
+        const resolved = this.originalBasePath || this.basePath;
+        const markerIdx = resolved.indexOf("/.gsd/worktrees/");
+        return markerIdx !== -1 ? resolved.slice(0, markerIdx) : resolved;
     }
     reset() {
         this.clearTimers();

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

@@ -11,7 +11,7 @@ import { appendEvent } from "./workflow-events.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
-import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
@@ -510,6 +510,24 @@ export function writeBlockerPlaceholder(unitType, unitId, base, reason) {
                 logWarning("recovery", `appendEvent failed for slice recovery: ${e instanceof Error ? e.message : String(e)}`);
             }
         }
+        // Insert a placeholder complete slice so deriveState sees activeMilestoneSlices.length > 0
+        // and exits the pre-planning phase. Without this, activeMilestoneSlices stays empty
+        // after the blocker ROADMAP.md is written, causing deriveState to return phase:'pre-planning'
+        // indefinitely and re-dispatching plan-milestone in an infinite loop (#4378).
+        if (unitType === "plan-milestone" && mid) {
+            try {
+                insertSlice({ id: "S00-blocker", milestoneId: mid, title: "Blocker placeholder — planning failed", status: "complete", sequence: 0 });
+            }
+            catch (e) {
+                logWarning("recovery", `insertSlice placeholder failed for plan-milestone recovery: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            try {
+                appendEvent(base, { cmd: "plan-milestone", params: { milestoneId: mid }, ts, actor: "system", trigger_reason: "blocker-placeholder-recovery" });
+            }
+            catch (e) {
+                logWarning("recovery", `appendEvent failed for plan-milestone recovery: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
     }
     return diagnoseExpectedArtifact(unitType, unitId, base);
 }

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

@@ -1174,6 +1174,17 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         s.stepMode = requestedStepMode;
         s.cmdCtx = ctx;
         s.basePath = base;
+        // ── Resume worktree: if the paused session was inside a milestone worktree,
+        // apply that path as the dispatch basePath immediately (#3723).
+        // This ensures the dispatch loop runs from the worktree directory even when
+        // enterMilestone guard conditions differ between the original and resumed
+        // session (e.g. isolation mode changed, detectWorktreeName differs across
+        // process restarts).  We guard with existsSync so a stale or deleted
+        // worktree directory safely falls back to the project root.
+        const resumeWorktreePath = freshStartAssessment.pausedSession?.worktreePath;
+        if (resumeWorktreePath && existsSync(resumeWorktreePath)) {
+            s.basePath = resumeWorktreePath;
+        }
         // Ensure the workflow-logger audit log is pinned to the project root
         // even when auto-mode is entered via a path that bypasses the
         // bootstrap/dynamic-tools ensureDbOpen() → setLogBasePath() chain

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

@@ -45,6 +45,7 @@ const BASELINE_PATTERNS = [
     // ── GSD state directory (symlink to external storage) ──
     ".gsd",
     ".gsd-id",
+    ".mcp.json",
     ".bg-shell/",
     // ── OS junk ──
     ".DS_Store",

package/dist/resources/extensions/gsd/gsd-db.js

@@ -2396,7 +2396,10 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
           SELECT path, artifact_type, milestone_id, slice_id, task_id, full_content, imported_at
           FROM wt.artifacts
         `).run());
-                // Merge milestones — worktree may have updated status/planning fields
+                // Merge milestones — worktree may have updated status/planning fields.
+                // Never downgrade status: complete > active > pre-planning (#4372).
+                // A stale worktree may carry an older 'active' status for a milestone
+                // that the main DB has already marked 'complete'; preserve the higher status.
                 merged.milestones = countChanges(adapter.prepare(`
           INSERT OR REPLACE INTO milestones (
             id, title, status, depends_on, created_at, completed_at,
@@ -2404,11 +2407,25 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
             verification_contract, verification_integration, verification_operational, verification_uat,
             definition_of_done, requirement_coverage, boundary_map_markdown
           )
-          SELECT id, title, status, depends_on, created_at, completed_at,
-                 vision, success_criteria, key_risks, proof_strategy,
-                 verification_contract, verification_integration, verification_operational, verification_uat,
-                 definition_of_done, requirement_coverage, boundary_map_markdown
-          FROM wt.milestones
+          SELECT w.id, w.title,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.status ELSE w.status
+                 END,
+                 w.depends_on,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.created_at ELSE w.created_at
+                 END,
+                 CASE
+                   WHEN m.status IN ('complete', 'done') AND w.status NOT IN ('complete', 'done')
+                   THEN m.completed_at ELSE w.completed_at
+                 END,
+                 w.vision, w.success_criteria, w.key_risks, w.proof_strategy,
+                 w.verification_contract, w.verification_integration, w.verification_operational, w.verification_uat,
+                 w.definition_of_done, w.requirement_coverage, w.boundary_map_markdown
+          FROM wt.milestones w
+          LEFT JOIN milestones m ON m.id = w.id
         `).run());
                 // Merge slices — preserve worktree progress but never downgrade completed status (#2558).
                 // ADR-011 Phase 1: carry is_sketch + sketch_scope so reconcile doesn't

package/dist/resources/extensions/gsd/worktree-resolver.js

@@ -16,8 +16,30 @@ import { existsSync, unlinkSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { debugLog } from "./debug-logger.js";
-import { MergeConflictError } from "./git-service.js";
 import { emitJournalEvent } from "./journal.js";
+// ─── Path Helpers ──────────────────────────────────────────────────────────
+/**
+ * Worktree marker segment — present in any path produced by worktreePath().
+ * Used to strip the worktree suffix and recover the project root (#3729).
+ */
+const WORKTREE_MARKER = "/.gsd/worktrees/";
+/**
+ * Resolve the project root from session path state.
+ *
+ * Prefers `originalBasePath` (always the project root when set), but falls
+ * back to `basePath` when `originalBasePath` is falsy (e.g. fresh AutoSession
+ * with default empty string). If `basePath` itself is inside a worktree
+ * directory (contains `/.gsd/worktrees/`), strip that suffix to recover the
+ * actual project root — preventing double-nested worktree paths (#3729).
+ */
+export function resolveProjectRoot(originalBasePath, basePath) {
+    let resolved = originalBasePath || basePath;
+    const markerIdx = resolved.indexOf(WORKTREE_MARKER);
+    if (markerIdx !== -1) {
+        resolved = resolved.slice(0, markerIdx);
+    }
+    return resolved;
+}
 // ─── WorktreeResolver ──────────────────────────────────────────────────────
 export class WorktreeResolver {
     s;
@@ -33,11 +55,11 @@ export class WorktreeResolver {
     }
     /** Original project root — always the non-worktree path. */
     get projectRoot() {
-        return this.s.originalBasePath || this.s.basePath;
+        return resolveProjectRoot(this.s.originalBasePath, this.s.basePath);
     }
     /** Path for auto.lock file — same as the old lockBase(). */
     get lockPath() {
-        return this.s.originalBasePath || this.s.basePath;
+        return resolveProjectRoot(this.s.originalBasePath, this.s.basePath);
     }
     // ── Private Helpers ────────────────────────────────────────────────────
     rebuildGitService() {
@@ -99,7 +121,10 @@ export class WorktreeResolver {
             });
             return;
         }
-        const basePath = this.s.originalBasePath || this.s.basePath;
+        // Resolve the project root for worktree operations via shared helper.
+        // Handles the case where originalBasePath is falsy and basePath is itself
+        // a worktree path — prevents double-nested worktree paths (#3729).
+        const basePath = resolveProjectRoot(this.s.originalBasePath, this.s.basePath);
         debugLog("WorktreeResolver", {
             action: "enterMilestone",
             milestoneId,
@@ -429,11 +454,13 @@ export class WorktreeResolver {
                     /* best-effort */
                 }
             }
-            // Re-throw MergeConflictError so the auto loop can detect real code
-            // conflicts and stop instead of retrying forever (#2330).
-            if (err instanceof MergeConflictError) {
-                throw err;
-            }
+            // Restore state before re-throwing so callers always get a consistent
+            // session (#4380).
+            this.restoreToProjectRoot();
+            // Re-throw: MergeConflictError stops the auto loop (#2330); non-conflict
+            // errors (permission denied, filesystem failures) must also propagate so
+            // broken states are diagnosable (#4380).
+            throw err;
         }
         // Always restore basePath and rebuild — whether merge succeeded or failed
         this.restoreToProjectRoot();
@@ -500,6 +527,8 @@ export class WorktreeResolver {
                 error: msg,
             });
             ctx.notify(`Milestone merge failed (branch mode): ${msg}`, "warning");
+            // Re-throw all errors so callers can apply their own recovery logic (#4380).
+            throw err;
         }
     }
     // ── Merge and Enter Next ───────────────────────────────────────────────
@@ -516,7 +545,18 @@ export class WorktreeResolver {
             currentMilestoneId,
             nextMilestoneId,
         });
-        this.mergeAndExit(currentMilestoneId, ctx);
+        try {
+            this.mergeAndExit(currentMilestoneId, ctx);
+        }
+        catch (err) {
+            // mergeAndExit emits a warning and restores state when it fails during
+            // merge/cleanup. But if it throws before recovery runs (e.g., in
+            // validateMilestoneId or emitJournalEvent), basePath won't be restored
+            // to projectRoot — re-throw so we don't enter the next milestone with
+            // the current one unmerged.
+            if (this.s.basePath !== this.projectRoot)
+                throw err;
+        }
         this.enterMilestone(nextMilestoneId, ctx);
     }
 }