@opengsd/gsd-pi 1.2.0-dev.5457a158 → 1.2.0-dev.6ccd27b3

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,9 +4,8 @@ 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 { getWorkflowDatabaseStatus, openWorkflowDatabase, } from "../db-workspace.js";
 import { getAutoWorktreePath } from "../auto-worktree.js";
 import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { worktreesDirs } from "../worktree-placement.js";
@@ -62,16 +61,46 @@ export function resolveWorkflowToolBasePath(ctx, scope) {
     return cwd;
 }
 export { resolveProjectRootDbPath } from "../db-workspace.js";
+function sqliteProviderHint(status, nodeVersion) {
+    if (status.provider)
+        return `Provider: ${status.provider}.`;
+    const major = Number.parseInt(nodeVersion.split(".")[0] ?? "", 10);
+    if (Number.isFinite(major) && major < 22) {
+        return (`No SQLite provider available. Upgrade Node to >= 22.0.0 (current: v${nodeVersion}), ` +
+            "use the packaged GSD runtime, or install/restore better-sqlite3 in this runtime.");
+    }
+    return ("No SQLite provider available. Use a Node build with node:sqlite enabled, " +
+        "run the packaged GSD runtime, or install/restore better-sqlite3 in this runtime.");
+}
+function dbOpenPhaseHint(status) {
+    if (status.lastPhase === "open")
+        return "The database file could not be opened";
+    if (status.lastPhase === "initSchema")
+        return "The database schema could not be initialized";
+    if (status.lastPhase === "vacuum-recovery")
+        return "Corruption recovery (VACUUM) failed";
+    if (status.attempted)
+        return "The database could not be opened";
+    return "The database provider could not be loaded";
+}
+export function formatWorkflowDatabaseOpenFailure(result, status, nodeVersion = process.versions.node) {
+    if (result.reason === "missing-gsd-dir") {
+        return `ensureDbOpen failed — no .gsd directory found at ${result.location.projectGsd}`;
+    }
+    if (result.reason === "missing-database") {
+        return `ensureDbOpen failed — no GSD database found at ${result.location.projectDb}`;
+    }
+    const resolvedStatus = status ?? getWorkflowDatabaseStatus();
+    const detail = result.error?.message ?? resolvedStatus.lastError?.message ?? "";
+    const detailSuffix = detail ? ` (${detail})` : "";
+    return (`ensureDbOpen failed for ${result.location.projectDb}: ` +
+        `${dbOpenPhaseHint(resolvedStatus)}${detailSuffix}. ${sqliteProviderHint(resolvedStatus, nodeVersion)}`);
+}
 export async function ensureDbOpen(basePath = safeWorkspaceCwd()) {
     const result = openWorkflowDatabase(basePath);
     if (result.ok)
         return true;
-    if (result.reason === "missing-gsd-dir") {
-        logWarning("bootstrap", "ensureDbOpen failed — no .gsd directory found");
-    }
-    else {
-        logWarning("bootstrap", `ensureDbOpen failed: ${result.error?.message ?? "open failed"}`);
-    }
+    logWarning("bootstrap", formatWorkflowDatabaseOpenFailure(result));
     return false;
 }
 export function registerDynamicTools(pi) {
@@ -79,18 +108,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);
 }