gsd-pi 2.82.0-dev.dfbc5f58f → 2.82.0-dev.e7a7f1ed5

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -10,6 +10,7 @@ import { shouldIgnoreAgentEndForActiveUnit } from "../auto/unit-runner-events.js
 import { resolveModelId } from "../auto-model-selection.js";
 import { resolveProjectRoot } from "../worktree.js";
 import { clearDiscussionFlowState } from "./write-gate.js";
+import { clearGuidedUnitContext } from "../guided-unit-context.js";
 import { resumeAutoAfterProviderDelay } from "./provider-error-resume.js";
 import { classifyError, createRetryState, resetRetryState, isTransient, } from "../error-classifier.js";
 import { blockModel, isModelBlocked } from "../blocked-models.js";
@@ -60,6 +61,11 @@ export function isUserInitiatedAbortMessage(message) {
         return false;
     return /\b(?:claude code process aborted by user|request aborted by user|process aborted by user)\b/i.test(message);
 }
+export function shouldDeferTransientErrorToCoreRetry(cls, rawErrorMsg) {
+    if (!isTransient(cls) || cls.kind === "rate-limit")
+        return false;
+    return !/retry failed after \d+ attempts:/i.test(rawErrorMsg);
+}
 function isBareClaudeCodeSessionSwitchAbortMarker(message) {
     if (!message)
         return false;
@@ -153,6 +159,13 @@ export function resolveAgentEndErrorDisplay(rawErrorMsg, content) {
     }
     return rawErrorMsg;
 }
+export function isTerminalDeletedWorktreeProviderError(message) {
+    if (!message)
+        return false;
+    if (!/\bdoes not exist\b/i.test(message))
+        return false;
+    return /[/\\]\.gsd[/\\](?:projects[/\\][^/\\]+[/\\])?worktrees[/\\][^/\\\s"']+/i.test(message);
+}
 async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit) {
     retryState.consecutiveTransientCount += 1;
     const baseRetryAfterMs = "retryAfterMs" in cls ? cls.retryAfterMs : 15_000;
@@ -190,8 +203,10 @@ export async function handleAgentEnd(pi, event, ctx) {
     // falsely report files as missing — producing a spurious "ready signal
     // rejected" loop even though the files are on disk.
     clearPathCache();
+    const basePath = resolveAgentEndBasePath();
+    clearGuidedUnitContext(basePath);
     try {
-        if (await checkDeepProjectSetupAfterTurn(event, ctx, resolveAgentEndBasePath())) {
+        if (await checkDeepProjectSetupAfterTurn(event, ctx, basePath)) {
             return;
         }
     }
@@ -199,22 +214,22 @@ export async function handleAgentEnd(pi, event, ctx) {
         const message = err instanceof Error ? err.message : String(err);
         logWarning("bootstrap", `checkDeepProjectSetupAfterTurn failed: ${message}`);
     }
-    if (checkAutoStartAfterDiscuss()) {
-        clearDiscussionFlowState(resolveAgentEndBasePath() ?? process.cwd());
+    if (checkAutoStartAfterDiscuss(basePath)) {
+        clearDiscussionFlowState(basePath ?? process.cwd());
         return;
     }
     // #4573 — When the LLM emits "Milestone X ready." but the required files
     // are missing, `checkAutoStartAfterDiscuss` returns false silently. Surface
     // that and nudge the LLM to complete the writes before the user hits the
     // downstream "All milestones complete" warning loop.
-    if (maybeHandleReadyPhraseWithoutFiles(event))
+    if (maybeHandleReadyPhraseWithoutFiles(event, basePath))
         return;
     // #4573 — Empty-turn recovery: if the LLM announced intent in prose but
     // emitted no tool calls, nudge it to execute. Fires only when auto-mode is
     // active or a discussion autostart is pending (non-auto interactive discuss
     // is user-driven). Runs before `isAutoActive` early return so pending
     // discussions (where isAutoActive may be false) still get recovered.
-    if (maybeHandleEmptyIntentTurn(event, isAutoActive()))
+    if (maybeHandleEmptyIntentTurn(event, isAutoActive(), basePath))
         return;
     if (!isAutoActive())
         return;
@@ -295,6 +310,12 @@ export async function handleAgentEnd(pi, event, ctx) {
         // the assistant message text content for display purposes only.
         // Classification still uses rawErrorMsg to avoid false positives from prose.
         const displayMsg = resolveAgentEndErrorDisplay(rawErrorMsg, "content" in lastMsg ? lastMsg.content : undefined);
+        if (isAutoCompletionStopInProgress() &&
+            isTerminalDeletedWorktreeProviderError(`${rawErrorMsg}\n${displayMsg}`)) {
+            resetRetryState(retryState);
+            logWarning("bootstrap", `Ignoring stale deleted-worktree provider error during terminal completion reroot: ${displayMsg || rawErrorMsg}`);
+            return;
+        }
         const errorDetail = displayMsg ? `: ${displayMsg}` : "";
         const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
         // ── 1. Classify using rawErrorMsg to avoid prose false-positives ────
@@ -378,7 +399,7 @@ export async function handleAgentEnd(pi, event, ctx) {
         // Core retries transient failures in-session after this handler.
         // Keep that behavior for non-rate-limit classes to avoid pause/retry races,
         // but let rate-limit continue into model fallback logic below (#4373).
-        if (isTransient(cls) && cls.kind !== "rate-limit") {
+        if (shouldDeferTransientErrorToCoreRetry(cls, rawErrorMsg)) {
             return;
         }
         // Cap rate-limit backoff for CLI-style providers (openai-codex, google-gemini-cli)

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -24,6 +24,7 @@ import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { extractSubagentAgentClasses } from "./subagent-input.js";
 import { approvalGateIdForUnit, isExplicitApprovalResponse, shouldPauseForUserApprovalQuestion } from "../user-input-boundary.js";
 import { resolveSkillManifest } from "../skill-manifest.js";
+import { getGuidedUnitContext } from "../guided-unit-context.js";
 let approvalQuestionAbortInFlight = false;
 async function loadWelcomeScreenModule() {
     const candidates = [];
@@ -675,7 +676,8 @@ export function registerHooks(pi, ecosystemHandlers) {
         // subagent dispatch. Closes the b23 bug class where a discuss-milestone
         // turn used the host Edit tool to modify user source files.
         const dash = getAutoRuntimeSnapshot();
-        const activeUnitType = dash.currentUnit?.type;
+        const guidedUnit = getGuidedUnitContext(discussionBasePath);
+        const activeUnitType = dash.currentUnit?.type ?? guidedUnit?.unitType;
         if (activeUnitType) {
             const manifest = resolveManifest(activeUnitType);
             if (manifest) {
@@ -694,7 +696,7 @@ export function registerHooks(pi, ecosystemHandlers) {
                     // Subagent inputs use { agent }, { tasks: [{ agent }] }, or { chain: [{ agent }] }.
                     agentClasses = extractSubagentAgentClasses(event.input);
                 }
-                const planningGuard = shouldBlockPlanningUnit(event.toolName, planningInput, dash.basePath || discussionBasePath, activeUnitType, manifest.tools, agentClasses);
+                const planningGuard = shouldBlockPlanningUnit(event.toolName, planningInput, dash.basePath || guidedUnit?.basePath || discussionBasePath, activeUnitType, manifest.tools, agentClasses);
                 if (planningGuard.block)
                     return planningGuard;
             }

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -571,10 +571,15 @@ async function configureModels(ctx, prefs) {
     ];
     const models = prefs.models ?? {};
     const availableModels = ctx.modelRegistry.getAvailable();
-    if (availableModels.length > 0) {
+    const getAllWithDiscovered = ctx.modelRegistry.getAllWithDiscovered;
+    const availableProviders = new Set(availableModels.map((m) => m.provider));
+    const selectableModels = typeof getAllWithDiscovered === "function"
+        ? getAllWithDiscovered().filter((m) => availableProviders.has(m.provider))
+        : availableModels;
+    if (selectableModels.length > 0) {
         // Group models by provider, sorted alphabetically
         const byProvider = new Map();
-        for (const m of availableModels) {
+        for (const m of selectableModels) {
             let group = byProvider.get(m.provider);
             if (!group) {
                 group = [];

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

@@ -23,7 +23,8 @@
 import { emitJournalEvent, queryJournal, } from "./journal.js";
 import { readFileSync, unlinkSync, existsSync } from "node:fs";
 import { join } from "node:path";
-import { findStaleWorkerForProject, getAllAutoWorkers, markWorkerCrashed, } from "./db/auto-workers.js";
+import { findStaleWorkerForProject, getAllAutoWorkers, markWorkerCrashed, markWorkerStopping, } from "./db/auto-workers.js";
+import { forceReleaseLeasesForWorker } from "./db/milestone-leases.js";
 import { markLatestActiveForWorkerCanceled } from "./db/unit-dispatches.js";
 import { getRuntimeKv, setRuntimeKv, deleteRuntimeKv } from "./db/runtime-kv.js";
 import { _getAdapter, isDbAvailable } from "./gsd-db.js";
@@ -182,10 +183,21 @@ export function clearLock(basePath) {
         return;
     try {
         const projectRoot = normalizeRealPath(basePath);
-        const worker = findActiveWorkerForCurrentProcess(projectRoot);
-        if (!worker)
+        const staleWorker = findStaleWorkerForProject(projectRoot);
+        if (staleWorker) {
+            markWorkerCrashed(staleWorker.worker_id);
+            forceReleaseLeasesForWorker(staleWorker.worker_id);
+            deleteRuntimeKv("worker", staleWorker.worker_id, SESSION_FILE_KV_KEY);
             return;
-        deleteRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY);
+        }
+        const worker = findActiveWorkerForCurrentProcess(projectRoot);
+        if (worker)
+            deleteRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY);
+        const stale = findStaleWorkerForProject(projectRoot);
+        if (stale) {
+            markWorkerStopping(stale.worker_id);
+            deleteRuntimeKv("worker", stale.worker_id, SESSION_FILE_KV_KEY);
+        }
     }
     catch {
         // Best-effort.

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

@@ -193,6 +193,30 @@ export function releaseMilestoneLease(workerId, milestoneId, fencingToken) {
         return changes === 1;
     });
 }
+/**
+ * Force-release all held leases for a worker.
+ *
+ * Used by crash recovery once PID liveness has confirmed the worker is dead.
+ * No fencing token is required because this path is cleanup-only for a
+ * non-running process.
+ */
+export function forceReleaseLeasesForWorker(workerId) {
+    if (!isDbAvailable())
+        return 0;
+    const db = _getAdapter();
+    let changes = 0;
+    transaction(() => {
+        const result = db.prepare(`UPDATE milestone_leases
+       SET status = 'released'
+       WHERE worker_id = :worker_id
+         AND status = 'held'`).run({ ":worker_id": workerId });
+        changes =
+            typeof result.changes === "number"
+                ? result.changes
+                : 0;
+    });
+    return changes;
+}
 /**
  * Read current lease row for diagnostics. Returns null if no row exists.
  */

package/dist/resources/extensions/gsd/doctor-git-checks.js

@@ -7,7 +7,7 @@ import { parseRoadmap as parseLegacyRoadmap } from "./parsers-legacy.js";
 import { isDbAvailable, getMilestone } from "./gsd-db.js";
 import { resolveMilestoneFile } from "./paths.js";
 import { deriveState, isMilestoneComplete } from "./state.js";
-import { listWorktrees, resolveGitDir, worktreesDir } from "./worktree-manager.js";
+import { createWorktree, listWorktrees, resolveGitDir, worktreesDir } from "./worktree-manager.js";
 import { abortAndReset } from "./git-self-heal.js";
 import { RUNTIME_EXCLUSION_PATHS, resolveMilestoneIntegrationBranch, writeIntegrationBranch } from "./git-service.js";
 import { nativeIsRepo, nativeWorktreeList, nativeWorktreeRemove, nativeBranchList, nativeBranchDelete, nativeLsFiles, nativeRmCached, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeAddTracked, nativeCommit } from "./native-git-bridge.js";
@@ -50,6 +50,21 @@ function isSameOrNestedPath(candidate, container) {
     return normalizedCandidate === normalizedContainer ||
         normalizedCandidate.startsWith(`${normalizedContainer}/`);
 }
+function hasProjectContentOnDisk(dirPath) {
+    try {
+        for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+            if (entry.name === ".git" || entry.name === ".gsd")
+                continue;
+            if (entry.name === ".DS_Store")
+                continue;
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
 function getSnapshotDiffCheckFailure(basePath) {
     const failures = [];
     for (const args of [["--cached"], []]) {
@@ -104,6 +119,36 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
                 const isComplete = milestoneEntry
                     ? await isCompletedMilestoneTerminal(basePath, milestoneId)
                     : false;
+                if (!isComplete && !hasProjectContentOnDisk(wt.path) && hasProjectContentOnDisk(basePath)) {
+                    issues.push({
+                        severity: "error",
+                        code: "worktree_empty_with_project_content",
+                        scope: "milestone",
+                        unitId: milestoneId,
+                        message: `Worktree ${wt.path} has no project content, but project root ${basePath} does. Run doctor --fix to recreate the worktree.`,
+                        fixable: true,
+                    });
+                    if (shouldFix("worktree_empty_with_project_content")) {
+                        try {
+                            nativeWorktreeRemove(basePath, wt.path, true);
+                            const recreated = createWorktree(basePath, milestoneId, {
+                                branch: wt.branch,
+                                reuseExistingBranch: true,
+                            });
+                            const reset = spawnSync("git", ["reset", "--hard"], {
+                                cwd: recreated.path,
+                                encoding: "utf-8",
+                            });
+                            if (reset.status !== 0) {
+                                throw new Error(reset.stderr || reset.error?.message || "git reset --hard failed");
+                            }
+                            fixesApplied.push(`recreated empty worktree ${wt.path}`);
+                        }
+                        catch {
+                            fixesApplied.push(`failed to recreate empty worktree ${wt.path}`);
+                        }
+                    }
+                }
                 if (isComplete) {
                     issues.push({
                         severity: "warning",

package/dist/resources/extensions/gsd/git-service.js

@@ -237,6 +237,8 @@ export function readIntegrationBranch(basePath, milestoneId) {
         return null;
     }
 }
+/** Re-export for backward compatibility — canonical definitions in branch-patterns.ts */
+export { QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
 /**
  * Persist the integration branch for a milestone.
  *
@@ -247,9 +249,11 @@ export function readIntegrationBranch(basePath, milestoneId) {
  *
  * The file is committed immediately so the metadata is persisted in git.
  */
-/** Re-export for backward compatibility — canonical definitions in branch-patterns.ts */
-export { QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
 export function writeIntegrationBranch(basePath, milestoneId, branch) {
+    // Never persist milestone branches as integration targets.
+    // They are ephemeral execution branches and can cause self-diff corruption.
+    if (branch.startsWith("milestone/"))
+        return;
     // Don't record slice branches as the integration target
     if (SLICE_BRANCH_RE.test(branch))
         return;

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

@@ -54,18 +54,19 @@ const providerLoader = createSqliteProviderLoader({
     writeStderr: (message) => process.stderr.write(message),
 });
 export const SCHEMA_VERSION = 28;
-function initSchema(db, fileBacked) {
+function initSchema(db, fileBacked, dbPath) {
+    const conservativeFilePragmas = fileBacked && _isLikelyWslDrvFsPathForTest(dbPath);
     if (fileBacked)
-        db.exec("PRAGMA journal_mode=WAL");
+        db.exec(conservativeFilePragmas ? "PRAGMA journal_mode=DELETE" : "PRAGMA journal_mode=WAL");
     if (fileBacked)
         db.exec("PRAGMA busy_timeout = 5000");
     if (fileBacked)
-        db.exec("PRAGMA synchronous = NORMAL");
+        db.exec(conservativeFilePragmas ? "PRAGMA synchronous = FULL" : "PRAGMA synchronous = NORMAL");
     if (fileBacked)
         db.exec("PRAGMA auto_vacuum = INCREMENTAL");
     if (fileBacked)
         db.exec("PRAGMA cache_size = -8000"); // 8 MB page cache
-    if (fileBacked && process.platform !== "darwin")
+    if (fileBacked && !conservativeFilePragmas && process.platform !== "darwin")
         db.exec("PRAGMA mmap_size = 67108864"); // 64 MB mmap
     db.exec("PRAGMA temp_store = MEMORY");
     db.exec("PRAGMA foreign_keys = ON");
@@ -99,6 +100,19 @@ function initSchema(db, fileBacked) {
     }
     migrateSchema(db);
 }
+export function _isLikelyWslDrvFsPathForTest(dbPath) {
+    if (!dbPath || process.platform !== "linux")
+        return false;
+    const drvFsPathPattern = /^\/mnt\/[a-z](?:\/|$)/i;
+    if (drvFsPathPattern.test(dbPath))
+        return true;
+    try {
+        return drvFsPathPattern.test(realpathSync(dbPath));
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Create the FTS5 virtual table for memories plus the triggers that keep it
  * in sync with the base table. FTS5 may be unavailable on stripped-down
@@ -504,7 +518,7 @@ export function openDatabase(path) {
     const adapter = createDbAdapter(rawDb);
     const fileBacked = path !== ":memory:";
     try {
-        initSchema(adapter, fileBacked);
+        initSchema(adapter, fileBacked, path);
     }
     catch (err) {
         // Corrupt freelist: DDL fails with "malformed" but VACUUM can rebuild.
@@ -512,7 +526,7 @@ export function openDatabase(path) {
         if (fileBacked && err instanceof Error && err.message?.includes("malformed")) {
             try {
                 adapter.exec("VACUUM");
-                initSchema(adapter, fileBacked);
+                initSchema(adapter, fileBacked, path);
                 process.stderr.write("gsd-db: recovered corrupt database via VACUUM\n");
             }
             catch (retryErr) {

package/dist/resources/extensions/gsd/guided-flow-queue.js

@@ -18,6 +18,7 @@ import { nativeAddPaths, nativeCommit } from "./native-git-bridge.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { saveQueueOrder } from "./queue-order.js";
 import { findMilestoneIds, nextMilestoneId } from "./milestone-ids.js";
+import { isFutureMilestoneStatus } from "./status-guards.js";
 // ─── Queue Entry Point ──────────────────────────────────────────────────────
 /**
  * Queue future milestones via conversational intake.
@@ -48,7 +49,7 @@ export async function showQueue(ctx, pi, basePath) {
         return;
     }
     // ── Count pending milestones ────────────────────────────────────────
-    const pendingMilestones = state.registry.filter(m => m.status === "pending" || m.status === "active");
+    const pendingMilestones = state.registry.filter(m => isFutureMilestoneStatus(m.status) || m.status === "active");
     const completeCount = state.registry.filter(m => m.status === "complete").length;
     const parkedCount = state.registry.filter(m => m.status === "parked").length;
     // ── If multiple pending milestones, show queue management hub ──────
@@ -140,7 +141,7 @@ export async function showQueueAdd(ctx, pi, basePath, state) {
     const activePart = state.activeMilestone
         ? `Currently executing: ${state.activeMilestone.id} — ${state.activeMilestone.title} (phase: ${state.phase}).`
         : "No milestone currently active.";
-    const pendingCount = state.registry.filter(m => m.status === "pending").length;
+    const pendingCount = state.registry.filter(m => isFutureMilestoneStatus(m.status)).length;
     const completeCount = state.registry.filter(m => m.status === "complete").length;
     const preamble = [
         `Queuing new work onto an existing GSD project.`,
@@ -223,7 +224,7 @@ export async function buildExistingMilestonesContext(basePath, milestoneIds, sta
         }
         // For active/pending/parked milestones, include the roadmap if it exists
         // (shows what's planned but not yet built)
-        if (status === "active" || status === "pending" || status === "parked") {
+        if (status === "active" || isFutureMilestoneStatus(status) || status === "parked") {
             const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
             if (roadmapFile) {
                 const content = await loadFile(roadmapFile);