@opengsd/gsd-pi 1.2.0-dev.5457a158 → 1.2.0-dev.822c9439

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

@@ -18,6 +18,7 @@ import { ensureGsdSymlink, isInheritedRepo, validateProjectId } from "./repo-ide
 import { migrateToExternalState, recoverFailedMigration } from "./migrate-external.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
 import { gsdRoot, resolveMilestoneFile } from "./paths.js";
+import { milestoneEntryBlockedGuidance } from "./guidance.js";
 import { invalidateAllCaches } from "./cache.js";
 import { writeLock, clearLock, readCrashLock, isLockProcessAlive } from "./crash-recovery.js";
 import { acquireSessionLock, releaseSessionLock, updateSessionLock, } from "./session-lock.js";
@@ -741,12 +742,14 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
     // phase-specific planning model for a discuss turn (#2829).
     //
     // Precedence:
-    // 1) Explicit session override via /gsd model (this session)
-    // 2) Current session model from settings/session restore (if provider ready)
-    // 3) GSD model preferences from PREFERENCES.md (validated against live auth)
+    // 1) Explicit session override via /gsd model or /gsd auto --model (this session)
+    // 2) GSD model preferences from PREFERENCES.md (validated against live auth)
+    // 3) Current session model from settings/session restore (if provider ready)
     //
-    // This preserves #3517 defaults while honoring explicit runtime model
-    // selection for subsequent /gsd runs in the same session.
+    // PREFERENCES.md wins over the ambient session default (#3517) so /gsd auto
+    // does not stick on claude-code/claude-sonnet-4-6 when the user configured
+    // models via /gsd workflow-preferences or PREFERENCES.md. Custom providers
+    // still skip PREFERENCES.md entirely (#4122).
     //
     // Exception (#4122): when the session provider is a custom provider declared
     // in ~/.gsd/agent/models.json (Ollama, vLLM, OpenAI-compatible proxy, etc.),
@@ -758,7 +761,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
     const sessionProviderIsCustom = isCustomProvider(ctx.model?.provider);
     const preferredModel = sessionProviderIsCustom
         ? null
-        : resolveDefaultSessionModel(ctx.model?.provider);
+        : resolveDefaultSessionModel(ctx.model?.provider, base);
     // Validate the preferred model against the live registry + provider auth so
     // an unconfigured PREFERENCES.md entry (no API key / OAuth) can't become the
     // start-model snapshot. Without this, every subsequent unit would try to
@@ -781,8 +784,8 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         : null;
     const startThinkingSnapshot = pi.getThinkingLevel();
     const startModelSnapshot = manualSessionOverride
-        ?? currentSessionModel
         ?? validatedPreferredModel
+        ?? currentSessionModel
         ?? null;
     try {
         // Validate GSD_PROJECT_ID early so the user gets immediate feedback
@@ -1270,11 +1273,8 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 if (enterResult.reason === "lease-conflict") {
                     ctx.ui.notify(`Cannot enter milestone ${s.currentMilestoneId}: lease is held by another worker.`, "error");
                 }
-                else if (enterResult.reason === "creation-failed") {
-                    ctx.ui.notify(`Cannot enter milestone ${s.currentMilestoneId}: worktree/branch creation failed. Isolation is degraded.`, "error");
-                }
-                else if (enterResult.reason === "isolation-degraded") {
-                    ctx.ui.notify(`Cannot enter milestone ${s.currentMilestoneId}: isolation is degraded from a prior worktree failure. Close processes locking the worktree and retry, or run /gsd doctor fix.`, "error");
+                else if (enterResult.reason === "creation-failed" || enterResult.reason === "isolation-degraded") {
+                    ctx.ui.notify(milestoneEntryBlockedGuidance(s.currentMilestoneId, enterResult.reason), "error");
                 }
                 else if (enterResult.reason === "invalid-milestone-id") {
                     ctx.ui.notify(`Cannot enter milestone ${s.currentMilestoneId}: milestone id is invalid.`, "error");

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

@@ -36,17 +36,17 @@ export function isSuspiciousGhostCompletion(ctx, startedAt, maxElapsedMs = GHOST
         activity.assistantMessages === 0);
 }
 /**
- * Snapshot metrics, save activity log, and fire-and-forget memory extraction
- * for a completed unit. Returns the activity log file path (if any).
+ * Snapshot metrics, save activity log, extract memories, and record the git
+ * transaction for a completed auto-mode unit.
  */
-export async function closeoutUnit(ctx, basePath, unitType, unitId, startedAt, opts) {
-    const modelId = ctx.model?.id ?? "unknown";
-    snapshotUnitMetrics(ctx, unitType, unitId, startedAt, modelId, opts);
-    const activityFile = saveActivityLog(ctx, basePath, unitType, unitId);
+export async function closeoutAutoUnit(request) {
+    const modelId = request.ctx.model?.id ?? "unknown";
+    snapshotUnitMetrics(request.ctx, request.unitType, request.unitId, request.startedAt, modelId, request.opts);
+    const activityFile = saveActivityLog(request.ctx, request.basePath, request.unitType, request.unitId);
     if (activityFile) {
         try {
-            const { buildMemoryLLMCall, extractMemoriesFromUnit } = await import('./memory-extractor.js');
-            const llmCallFn = buildMemoryLLMCall(ctx);
+            const { buildMemoryLLMCall, extractMemoriesFromUnit } = await import("./memory-extractor.js");
+            const llmCallFn = buildMemoryLLMCall(request.ctx);
             if (llmCallFn) {
                 // Awaited: a fire-and-forget here lets memory-extractor writes land in
                 // .gsd/ after closeoutUnit returns but before the milestone merge
@@ -55,10 +55,10 @@ export async function closeoutUnit(ctx, basePath, unitType, unitId, startedAt, o
                 // bounded by the extractor's LLM call, which is the acceptable price
                 // for not racing the merge boundary.
                 try {
-                    await extractMemoriesFromUnit(activityFile, unitType, unitId, llmCallFn);
+                    await extractMemoriesFromUnit(activityFile, request.unitType, request.unitId, llmCallFn);
                 }
                 catch (err) {
-                    logWarning("engine", `memory extraction failed for ${unitType}/${unitId}: ${err.message}`);
+                    logWarning("engine", `memory extraction failed for ${request.unitType}/${request.unitId}: ${err.message}`);
                 }
             }
         }
@@ -66,22 +66,46 @@ export async function closeoutUnit(ctx, basePath, unitType, unitId, startedAt, o
             logWarning("engine", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
-    if (opts?.traceId && opts.turnId && opts.gitAction && opts.gitStatus) {
+    const gitTransaction = resolveGitTransactionOptions(request.opts);
+    if (gitTransaction) {
         writeTurnGitTransaction({
-            basePath,
-            traceId: opts.traceId,
-            turnId: opts.turnId,
-            unitType,
-            unitId,
+            basePath: request.basePath,
+            traceId: gitTransaction.traceId,
+            turnId: gitTransaction.turnId,
+            unitType: request.unitType,
+            unitId: request.unitId,
             stage: "record",
-            action: opts.gitAction,
-            push: opts.gitPush === true,
-            status: opts.gitStatus,
-            error: opts.gitError,
+            action: gitTransaction.gitAction,
+            push: gitTransaction.gitPush === true,
+            status: gitTransaction.gitStatus,
+            error: gitTransaction.gitError,
             metadata: {
                 activityFile,
             },
         });
     }
-    return activityFile ?? undefined;
+    return {
+        ...(activityFile ? { activityFile } : {}),
+        gitTransactionRecorded: Boolean(gitTransaction),
+    };
+}
+function resolveGitTransactionOptions(opts) {
+    if (!opts?.traceId || !opts.turnId || !opts.gitAction || !opts.gitStatus)
+        return null;
+    return {
+        traceId: opts.traceId,
+        turnId: opts.turnId,
+        gitAction: opts.gitAction,
+        gitStatus: opts.gitStatus,
+        gitPush: opts.gitPush,
+        gitError: opts.gitError,
+    };
+}
+/**
+ * Compatibility wrapper for existing auto-loop callers. New code should prefer
+ * closeoutAutoUnit so the closeout request and result stay explicit.
+ */
+export async function closeoutUnit(ctx, basePath, unitType, unitId, startedAt, opts) {
+    const result = await closeoutAutoUnit({ ctx, basePath, unitType, unitId, startedAt, opts });
+    return result.activityFile;
 }

package/dist/resources/extensions/gsd/auto-unit-tool-scope.js

@@ -1,6 +1,7 @@
 import { parseUnitId } from "./unit-id.js";
 import { AUTO_UNIT_SCOPED_TOOLS, getForbiddenGsdToolReason, } from "./unit-tool-contracts.js";
-import { WORKFLOW_TOOL_ALIAS_PAIRS, canonicalWorkflowSurfaceToolName, isWorkflowSurfaceAliasTool, stripMcpToolPrefix, } from "./workflow-tool-surface.js";
+import { WORKFLOW_TOOL_ALIAS_PAIRS, isWorkflowSurfaceAliasTool, stripMcpToolPrefix, } from "./workflow-tool-surface.js";
+import { canonicalWorkflowToolName } from "./engine-hook-contract.js";
 export { AUTO_UNIT_SCOPED_TOOLS, RUN_UAT_BROWSER_TOOL_NAMES, } from "./unit-tool-contracts.js";
 // Scope-class membership is declared per unit in the Unit Registry (ADR-033).
 // EXECUTE_TASK_UNIT_TYPES = scopeClass "execute-task"; the section-close gate
@@ -22,9 +23,9 @@ const SCOPED_GSD_LIFECYCLE_TOOLS = new Set([
     .map(canonicalWorkflowToolName));
 export const GSD_PHASE_SCOPE_DISPLAY_REASON = "This GSD phase only allows its scoped workflow tools.";
 export const GSD_SECTION_CLOSE_GATE_DISPLAY_REASON = "Gates here close by writing summary sections — gsd_save_gate_result isn't needed.";
-export function canonicalWorkflowToolName(toolName) {
-    return canonicalWorkflowSurfaceToolName(toolName);
-}
+// Normalizer seam lives in engine-hook-contract.ts; re-exported here for
+// existing scope importers.
+export { canonicalWorkflowToolName };
 export function isWorkflowAliasTool(toolName) {
     return isWorkflowSurfaceAliasTool(toolName);
 }

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

@@ -1,7 +1,7 @@
 // Project/App: gsd-pi
 // File Purpose: Post-unit verification gate for GSD auto-mode units.
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { gsdProjectionRoot, resolveSlicePath, resolveMilestoneFile } from "./paths.js";
+import { gsdProjectionRoot, resolveSlicePath } from "./paths.js";
 import { resolveMilestoneValidationVerdict } from "./milestone-validation-verdict.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 import { parseUnitId } from "./unit-id.js";
@@ -9,8 +9,6 @@ import { isDbAvailable, getTask, getSliceTasks, getMilestoneSlices } from "./gsd
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { isClosedStatus } from "./status-guards.js";
 import { loadFile } from "./files.js";
-import { parseRoadmap } from "./parsers-legacy.js";
-import { isMilestoneComplete } from "./state.js";
 import { runVerificationGate, runVerificationGateForTargets, formatFailureContext, captureRuntimeErrors, runDependencyAudit, } from "./verification-gate.js";
 import { writeVerificationJSON } from "./verification-evidence.js";
 import { logWarning } from "./workflow-logger.js";
@@ -25,6 +23,7 @@ import { getSlice } from "./gsd-db.js";
 import { getLedger } from "./metrics.js";
 import { getUnitCostSpikeAction, resolveUnitCostSpikeMultiplier } from "./auto-budget.js";
 import { formatPostUnitStatusCard } from "./auto-status-message.js";
+import { detectWebApp } from "./web-app-uat.js";
 function getCurrentUnitCostStats(unitId) {
     const ledger = getLedger();
     if (!ledger || !Array.isArray(ledger.units) || ledger.units.length === 0) {
@@ -274,32 +273,15 @@ async function runValidateMilestonePostCheck(vctx, pauseAuto) {
  * DB-backed projects are authoritative (#4094 peer review); falls back to
  * roadmap parsing only when the DB is unavailable.
  */
-async function countIncompleteSlices(basePath, milestoneId) {
-    if (isDbAvailable()) {
-        const slices = getMilestoneSlices(milestoneId);
-        if (slices.length === 0) {
-            // No DB rows — treat as "unknown", do not pause.
-            return 1;
-        }
-        return slices.filter((slice) => !isClosedStatus(slice.status)).length;
-    }
-    // Filesystem fallback: parse the roadmap markdown.
-    try {
-        const roadmapFile = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
-        if (!roadmapFile)
-            return 1;
-        const roadmapContent = await loadFile(roadmapFile);
-        if (!roadmapContent)
-            return 1;
-        const roadmap = parseRoadmap(roadmapContent);
-        if (roadmap.slices.length === 0)
-            return 1;
-        return isMilestoneComplete(roadmap) ? 0 : 1;
-    }
-    catch {
-        // Parsing failures should not cause false-positive pauses.
+async function countIncompleteSlices(_basePath, milestoneId) {
+    // DB-authoritative (ADR-017): no markdown fallback. DB unavailable or no
+    // rows means "unknown" — do not pause.
+    if (!isDbAvailable())
         return 1;
-    }
+    const slices = getMilestoneSlices(milestoneId);
+    if (slices.length === 0)
+        return 1;
+    return slices.filter((slice) => !isClosedStatus(slice.status)).length;
 }
 /**
  * Run the verification gate for the current execute-task unit.
@@ -636,14 +618,25 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
             s.pendingVerificationRetry = null;
             return "continue";
         }
+        else if (verdict.reason === "no-host-checks" &&
+            taskAlreadyComplete &&
+            detectWebApp(s.basePath) &&
+            !result.runtimeErrors?.some((e) => e.blocking)) {
+            s.verificationRetryCount.delete(retryKey);
+            s.verificationRetryFailureHashes.delete(retryKey);
+            s.pendingVerificationRetry = null;
+            ctx.ui.notify("No task-level host verification command was found for a completed browser-facing task; continuing so slice UAT can verify the UI with browser tools.", "warning");
+            return "continue";
+        }
         else if (verdict.reason === "no-host-checks") {
             s.verificationRetryCount.delete(retryKey);
             s.verificationRetryFailureHashes.delete(retryKey);
             s.pendingVerificationRetry = null;
-            ctx.ui.notify("Verification gate FAILED — no runnable host-owned verification checks were discovered. Pausing for human review.", "error");
+            const pauseMessage = `Verification failed: ${verdict.failureContext}`;
+            ctx.ui.notify(`Verification gate FAILED — ${verdict.failureContext}`, "error");
             process.stderr.write(`verification-gate: ${verdict.failureContext}\n`);
             await pauseAuto(ctx, pi, {
-                message: "Verification failed: no runnable host-owned verification checks were discovered.",
+                message: pauseMessage,
                 category: "unknown",
             });
             return "pause";

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

@@ -800,6 +800,14 @@ function _resolveIntegrationBranchForReuse(basePath, milestoneId) {
         return null;
     }
 }
+function safeCwd(fallback) {
+    try {
+        return process.cwd();
+    }
+    catch {
+        return fallback;
+    }
+}
 /**
  * When reusing an existing milestone branch, fast-forward it onto the
  * integration branch when that's safe (branch is a strict ancestor of
@@ -949,7 +957,7 @@ export function teardownAutoWorktree(originalBasePath, milestoneId, opts = {}) {
     originalBasePath = resolveWorktreeProjectRoot(originalBasePath);
     const branch = autoWorktreeBranch(milestoneId);
     const { preserveBranch = false, preserveWorktree = false } = opts;
-    const previousCwd = process.cwd();
+    const previousCwd = safeCwd(originalBasePath);
     // Wrap the entire teardown body in a single try/finally so activeWorkspace
     // is ALWAYS cleared — even if process.chdir throws (e.g. originalBasePath
     // was deleted before teardown ran). Previously the finally only covered
@@ -1901,6 +1909,11 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
         }
         catch (err) {
             logWarning("worktree", `chdir to project root after merge failed: ${err instanceof Error ? err.message : String(err)}`);
+            debugLog("mergeMilestoneToMain", {
+                phase: "post-merge-chdir-failed",
+                target: originalBasePath_,
+                error: err instanceof Error ? err.message : String(err),
+            });
         }
     };
     let shouldCleanup = false;

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

@@ -557,6 +557,13 @@ export function getAutoModeStartModel() {
 export function setCurrentDispatchedModelId(model) {
     s.currentDispatchedModelId = model ? `${model.provider}/${model.id}` : null;
 }
+/**
+ * Update the active unit model after runtime recovery switches models mid-unit.
+ * The next session restore path reads this field before dispatching again.
+ */
+export function setCurrentUnitModelForRecovery(model) {
+    s.currentUnitModel = model;
+}
 // Tool tracking — delegates to auto-tool-tracking.ts
 export function markToolStart(toolCallId, toolName) {
     _markToolStart(toolCallId, s.active, toolName);
@@ -623,6 +630,35 @@ export function stopAutoRemote(projectRoot) {
         return { found: false, error: err.message };
     }
 }
+/**
+ * Force-stop a remote auto-mode session before stealing its lock.
+ * The normal stop path stays SIGTERM-only so cooperative sessions can clean up;
+ * this path is only for the explicit "Force start" action.
+ */
+export function forceStopAutoRemote(projectRoot) {
+    const lock = readCrashLock(projectRoot);
+    if (!lock)
+        return { found: false };
+    if (lock.pid === process.pid) {
+        clearLock(projectRoot);
+        return { found: false };
+    }
+    if (!isLockProcessAlive(lock)) {
+        clearLock(projectRoot);
+        return { found: false };
+    }
+    try {
+        process.kill(lock.pid, "SIGTERM");
+        if (isLockProcessAlive(lock)) {
+            process.kill(lock.pid, "SIGKILL");
+        }
+        clearLock(projectRoot);
+        return { found: true, pid: lock.pid };
+    }
+    catch (err) {
+        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.
@@ -1824,7 +1860,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     if (freshStartAssessment.classification === "running") {
         const pid = freshStartAssessment.lock?.pid;
         ctx.ui.notify(pid
-            ? `Another auto-mode session (PID ${pid}) appears to be running.\nStop it with \`kill ${pid}\` before starting a new session.`
+            ? `Another auto-mode session (PID ${pid}) appears to be running.\nRun \`/gsd stop\` for graceful shutdown, or choose "Force start" from \`/gsd auto\` to terminate it.`
             : "Another auto-mode session appears to be running.", "error");
         return;
     }

package/dist/resources/extensions/gsd/blocked-models.js

@@ -9,12 +9,16 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { withFileLockSync } from "./file-lock.js";
+const temporaryBlockedModels = new Map();
 function blockedModelsPath(basePath) {
     return join(gsdRoot(basePath), "runtime", "blocked-models.json");
 }
 function modelKey(provider, id) {
     return `${provider.toLowerCase()}/${id.toLowerCase()}`;
 }
+function temporaryModelKey(basePath, provider, id) {
+    return `${basePath}:${modelKey(provider, id)}`;
+}
 function readFileSafe(path) {
     if (!existsSync(path))
         return { version: 1, blocked: [] };
@@ -41,6 +45,30 @@ export function isModelBlocked(basePath, provider, id) {
     const target = modelKey(provider, id);
     return loadBlockedModels(basePath).some((e) => modelKey(e.provider, e.id) === target);
 }
+export function blockModelUntil(basePath, provider, id, blockedUntil, reason) {
+    const key = temporaryModelKey(basePath, provider, id);
+    if (blockedUntil <= Date.now()) {
+        temporaryBlockedModels.delete(key);
+        return;
+    }
+    temporaryBlockedModels.set(key, { provider, id, reason, blockedUntil });
+}
+export function isModelTemporarilyUnavailable(basePath, provider, id, now = Date.now()) {
+    if (!provider || !id)
+        return false;
+    const key = temporaryModelKey(basePath, provider, id);
+    const entry = temporaryBlockedModels.get(key);
+    if (!entry)
+        return false;
+    if (entry.blockedUntil <= now) {
+        temporaryBlockedModels.delete(key);
+        return false;
+    }
+    return true;
+}
+export function clearTemporaryModelBlocksForTest() {
+    temporaryBlockedModels.clear();
+}
 export function blockModel(basePath, provider, id, reason) {
     const path = blockedModelsPath(basePath);
     mkdirSync(dirname(path), { recursive: true });

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

@@ -2,7 +2,7 @@
 import { logWarning } from "../workflow-logger.js";
 import { checkDeepProjectSetupAfterTurn, checkAutoStartAfterDiscuss, maybeHandleReadyPhraseWithoutFiles, maybeHandleEmptyIntentTurn, resetEmptyTurnCounter, } from "../guided-flow.js";
 import { clearPathCache } from "../paths.js";
-import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, isAutoCompletionStopInProgress, pauseAuto, setCurrentDispatchedModelId, } from "../auto.js";
+import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, isAutoCompletionStopInProgress, pauseAuto, setCurrentDispatchedModelId, setCurrentUnitModelForRecovery, } from "../auto.js";
 import { getNextFallbackModel, resolveModelWithFallbacksForUnit } from "../preferences.js";
 import { pauseAutoForProviderError } from "../provider-error-pause.js";
 import { isSessionSwitchAbortGraceActive, isSessionSwitchInFlight, resolveAgentEnd, resolveAgentEndCancelled, } from "../auto/resolve.js";
@@ -13,7 +13,7 @@ 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";
+import { blockModel, blockModelUntil, isModelBlocked, isModelTemporarilyUnavailable } from "../blocked-models.js";
 import { getProjectGSDPreferencesPath } from "../preferences.js";
 import { resolveProviderErrorGuidance } from "../provider-error-guidance.js";
 import { formatGuidance } from "../guidance.js";
@@ -96,9 +96,12 @@ async function tryProviderModelFallback(params) {
             if (!nextModelId)
                 break;
             const candidate = resolveModelId(nextModelId, availableModels, rejectedProvider);
-            if (candidate && !isModelBlocked(basePath, candidate.provider, candidate.id)) {
+            if (candidate &&
+                !isModelBlocked(basePath, candidate.provider, candidate.id) &&
+                !isModelTemporarilyUnavailable(basePath, candidate.provider, candidate.id)) {
                 const ok = await pi.setModel(candidate, { persist: false });
                 if (ok) {
+                    setCurrentUnitModelForRecovery(candidate);
                     setCurrentDispatchedModelId({ provider: candidate.provider, id: candidate.id });
                     switchedNotify(`${candidate.provider}/${candidate.id}`);
                     pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
@@ -111,11 +114,13 @@ async function tryProviderModelFallback(params) {
     const sessionModel = getAutoModeStartModel();
     if (sessionModel &&
         !(sessionModel.provider === rejectedProvider && sessionModel.id === rejectedId) &&
-        !isModelBlocked(basePath, sessionModel.provider, sessionModel.id)) {
+        !isModelBlocked(basePath, sessionModel.provider, sessionModel.id) &&
+        !isModelTemporarilyUnavailable(basePath, sessionModel.provider, sessionModel.id)) {
         const startModel = availableModels.find((m) => m.provider === sessionModel.provider && m.id === sessionModel.id);
         if (startModel) {
             const ok = await pi.setModel(startModel, { persist: false });
             if (ok) {
+                setCurrentUnitModelForRecovery(startModel);
                 setCurrentDispatchedModelId({ provider: startModel.provider, id: startModel.id });
                 switchedNotify(`${startModel.provider}/${startModel.id}`);
                 pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
@@ -533,6 +538,10 @@ export async function handleAgentEnd(pi, event, ctx) {
             if (currentProvider === "openai-codex" || currentProvider === "google-gemini-cli") {
                 cls.retryAfterMs = Math.min(cls.retryAfterMs, 30_000);
             }
+            const dash = getAutoDashboardData();
+            if (dash.basePath && ctx.model?.provider && ctx.model?.id) {
+                blockModelUntil(dash.basePath, ctx.model.provider, ctx.model.id, Date.now() + cls.retryAfterMs, rawErrorMsg || displayMsg || "rate limit");
+            }
         }
         // ── 2. Decide & Act ──────────────────────────────────────────────────
         // --- Network errors: same-model retry with backoff ---
@@ -572,9 +581,14 @@ export async function handleAgentEnd(pi, event, ctx) {
                         retryState.networkRetryCount = 0;
                         retryState.currentRetryModelId = undefined;
                         const modelToSet = resolveModelId(nextModelId, availableModels, ctx.model?.provider);
-                        if (modelToSet) {
+                        const modelUnavailable = dash.basePath && modelToSet
+                            ? isModelBlocked(dash.basePath, modelToSet.provider, modelToSet.id) ||
+                                isModelTemporarilyUnavailable(dash.basePath, modelToSet.provider, modelToSet.id)
+                            : false;
+                        if (modelToSet && !modelUnavailable) {
                             const ok = await pi.setModel(modelToSet, { persist: false });
                             if (ok) {
+                                setCurrentUnitModelForRecovery(modelToSet);
                                 setCurrentDispatchedModelId({ provider: modelToSet.provider, id: modelToSet.id });
                                 ctx.ui.notify(`Model error${errorDetail}. Switched to fallback: ${nextModelId} and resuming.`, "warning");
                                 pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
@@ -587,11 +601,17 @@ export async function handleAgentEnd(pi, event, ctx) {
             // Try restoring session model
             const sessionModel = getAutoModeStartModel();
             if (sessionModel) {
-                if (ctx.model?.id !== sessionModel.id || ctx.model?.provider !== sessionModel.provider) {
+                const dash = getAutoDashboardData();
+                const sessionModelUnavailable = dash.basePath
+                    ? isModelBlocked(dash.basePath, sessionModel.provider, sessionModel.id) ||
+                        isModelTemporarilyUnavailable(dash.basePath, sessionModel.provider, sessionModel.id)
+                    : false;
+                if (!sessionModelUnavailable && (ctx.model?.id !== sessionModel.id || ctx.model?.provider !== sessionModel.provider)) {
                     const startModel = ctx.modelRegistry.getAvailable().find((m) => m.provider === sessionModel.provider && m.id === sessionModel.id);
                     if (startModel) {
                         const ok = await pi.setModel(startModel, { persist: false });
                         if (ok) {
+                            setCurrentUnitModelForRecovery(startModel);
                             setCurrentDispatchedModelId({ provider: startModel.provider, id: startModel.id });
                             retryState.networkRetryCount = 0;
                             retryState.currentRetryModelId = undefined;

package/dist/resources/extensions/gsd/bootstrap/dynamic-tools.js

@@ -4,7 +4,6 @@ import { existsSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { createBashTool, createEditTool, createReadTool, createWriteTool } from "@gsd/pi-coding-agent";
-import { DEFAULT_BASH_TIMEOUT_SECS } from "../constants.js";
 import { logWarning } from "../workflow-logger.js";
 import { openWorkflowDatabase } from "../db-workspace.js";
 import { getAutoWorktreePath } from "../auto-worktree.js";
@@ -79,18 +78,36 @@ export function registerDynamicTools(pi) {
     const baseBash = createBashTool(fallbackRoot, {
         spawnHook: (ctx) => ctx,
     });
+    // The auto-mode stalled-tool watchdog only exists in GSD/auto-mode, so the
+    // watchdog verbiage is injected here (the GSD-registered tool) rather than in
+    // core bash.ts, which is reused by non-GSD embeddings that have no watchdog.
+    const WATCHDOG_DETAIL = "Genuine hangs are caught by the auto-mode stalled-tool watchdog (stalled: 5m / idle: 10m / soft: 20m / hard: 30m).";
+    const gsdBashDescription = `${baseBash.description} ${WATCHDOG_DETAIL}`;
+    const gsdBashParameters = (() => {
+        const params = baseBash.parameters;
+        if (!params?.properties?.timeout)
+            return params;
+        return {
+            ...params,
+            properties: {
+                ...params.properties,
+                timeout: {
+                    ...params.properties.timeout,
+                    description: `${params.properties.timeout.description} ${WATCHDOG_DETAIL}`,
+                },
+            },
+        };
+    })();
     const dynamicBash = {
         ...baseBash,
+        description: gsdBashDescription,
+        parameters: gsdBashParameters,
         execute: async (toolCallId, params, signal, onUpdate, ctx) => {
             const basePath = resolveCtxCwd(ctx);
             const fresh = createBashTool(basePath, {
                 spawnHook: (spawnCtx) => ({ ...spawnCtx, cwd: basePath }),
             });
-            const paramsWithTimeout = {
-                ...params,
-                timeout: params.timeout ?? DEFAULT_BASH_TIMEOUT_SECS,
-            };
-            return fresh.execute(toolCallId, paramsWithTimeout, signal, onUpdate, ctx);
+            return fresh.execute(toolCallId, params, signal, onUpdate, ctx);
         },
     };
     pi.registerTool(dynamicBash);

package/dist/resources/extensions/gsd/bootstrap/exec-tools.js

@@ -114,8 +114,8 @@ export function registerExecTools(pi) {
         ],
         parameters: Type.Object({
             query: Type.Optional(Type.String({ description: "Substring matched against id and purpose (case-insensitive)." })),
-            runtime: Type.Optional(Type.Union([Type.Literal("bash"), Type.Literal("node"), Type.Literal("python")], {
-                description: "Restrict to one runtime.",
+            runtime: Type.Optional(Type.String({
+                description: "Restrict to one runtime: bash, node, or python.",
             })),
             failing_only: Type.Optional(Type.Boolean({ description: "Only non-zero exit codes and timeouts." })),
             limit: Type.Optional(Type.Number({ description: "Max results (default 20, cap 200)", minimum: 1, maximum: 200 })),

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

@@ -13,6 +13,7 @@ import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
 import { writeCrashLog } from "./crash-log.js";
 import { logWarning } from "../workflow-logger.js";
+import { UNIT_TOOL_CONTRACTS } from "../unit-tool-contracts.js";
 // Static import so cmux event listeners are registered synchronously during
 // extension bootstrap. Prior implementation used `void import().then()` which
 // queued listener registration as a microtask — any CMUX_CHANNELS emit fired
@@ -30,6 +31,9 @@ const EPIPE_STORM_THRESHOLD = 100;
 const EPIPE_STORM_WINDOW_MS = 10_000;
 let epipeCount = 0;
 let epipeWindowStart = 0;
+export const CRITICAL_GSD_WORKFLOW_TOOL_NAMES = [...new Set(Object.values(UNIT_TOOL_CONTRACTS)
+        .flatMap((contract) => contract.requiredWorkflowTools)
+        .filter((toolName) => toolName.startsWith("gsd_")))].sort();
 /** Write to stderr without ever re-throwing — stderr can EPIPE too, which would
  *  re-enter this handler and re-loop. */
 function safeStderr(msg) {
@@ -121,6 +125,20 @@ export function installEpipeGuard() {
         process.on("unhandledRejection", _gsdRejectionGuard);
     }
 }
+function assertCriticalGsdWorkflowToolsRegistered(pi) {
+    if (typeof pi.getAllTools !== "function")
+        return;
+    const registered = new Set(pi.getAllTools().map((tool) => tool.name));
+    const missing = CRITICAL_GSD_WORKFLOW_TOOL_NAMES.filter((toolName) => !registered.has(toolName));
+    if (missing.length === 0)
+        return;
+    const message = [
+        `Critical GSD workflow tool registration failed; missing required tool(s): ${missing.join(", ")}.`,
+        "Check earlier bootstrap warnings for the registration slot that failed.",
+    ].join(" ");
+    logWarning("bootstrap", message);
+    throw new Error(message);
+}
 export function registerGsdExtension(pi) {
     // Note: registerGSDCommand is called by index.ts before this function,
     // so we intentionally skip it here to avoid double-registration.
@@ -186,4 +204,5 @@ export function registerGsdExtension(pi) {
             logWarning("bootstrap", `Failed to register ${name}: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
+    assertCriticalGsdWorkflowToolsRegistered(pi);
 }