gsd-pi 2.67.0-dev.1cd1e0f → 2.67.0-dev.2142d3e

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

@@ -1,6 +1,7 @@
 // GSD2 — Read-only query tools exposing DB state to the LLM via the WAL connection
 import { Type } from "@sinclair/typebox";
-import { logWarning } from "../workflow-logger.js";
+import { ensureDbOpen } from "./dynamic-tools.js";
+import { executeMilestoneStatus } from "../tools/workflow-tool-executors.js";
 export function registerQueryTools(pi) {
     pi.registerTool({
         name: "gsd_milestone_status",
@@ -16,72 +17,14 @@ export function registerQueryTools(pi) {
             milestoneId: Type.String({ description: "Milestone ID to query (e.g. M001)" }),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            try {
-                // Open the DB if not already open — safe for read-only use since
-                // ensureDbOpen() only creates/migrates when .gsd/ has content (#3644).
-                const { ensureDbOpen } = await import("./dynamic-tools.js");
-                const dbAvailable = await ensureDbOpen();
-                const { getMilestone, getSliceStatusSummary, getSliceTaskCounts, _getAdapter, } = await import("../gsd-db.js");
-                if (!dbAvailable) {
-                    return {
-                        content: [{ type: "text", text: "Error: GSD database is not available." }],
-                        details: { operation: "milestone_status", error: "db_unavailable" },
-                    };
-                }
-                // Wrap all reads in a single transaction for snapshot consistency.
-                // SQLite WAL mode guarantees reads within a transaction see a single
-                // consistent snapshot, preventing torn reads from concurrent writes.
-                const adapter = _getAdapter();
-                adapter.exec("BEGIN"); // eslint-disable-line -- SQLite exec, not child_process
-                try {
-                    const milestone = getMilestone(params.milestoneId);
-                    if (!milestone) {
-                        adapter.exec("COMMIT"); // eslint-disable-line
-                        return {
-                            content: [{ type: "text", text: `Milestone ${params.milestoneId} not found in database.` }],
-                            details: { operation: "milestone_status", milestoneId: params.milestoneId, found: false },
-                        };
-                    }
-                    const sliceStatuses = getSliceStatusSummary(params.milestoneId);
-                    const slices = sliceStatuses.map((s) => {
-                        const counts = getSliceTaskCounts(params.milestoneId, s.id);
-                        return {
-                            id: s.id,
-                            status: s.status,
-                            taskCounts: counts,
-                        };
-                    });
-                    adapter.exec("COMMIT"); // eslint-disable-line
-                    const result = {
-                        milestoneId: milestone.id,
-                        title: milestone.title,
-                        status: milestone.status,
-                        createdAt: milestone.created_at,
-                        completedAt: milestone.completed_at,
-                        sliceCount: slices.length,
-                        slices,
-                    };
-                    return {
-                        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-                        details: { operation: "milestone_status", milestoneId: milestone.id, sliceCount: slices.length },
-                    };
-                }
-                catch (txErr) {
-                    try {
-                        adapter.exec("ROLLBACK");
-                    }
-                    catch { /* swallow */ } // eslint-disable-line
-                    throw txErr;
-                }
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                logWarning("tool", `gsd_milestone_status tool failed: ${msg}`);
+            const dbAvailable = await ensureDbOpen();
+            if (!dbAvailable) {
                 return {
-                    content: [{ type: "text", text: `Error querying milestone status: ${msg}` }],
-                    details: { operation: "milestone_status", error: msg },
+                    content: [{ type: "text", text: "Error: GSD database is not available. Cannot read milestone status." }],
+                    details: { operation: "milestone_status", error: "db_unavailable" },
                 };
             }
+            return executeMilestoneStatus(params);
         },
     });
 }

package/dist/resources/extensions/gsd/bootstrap/write-gate.js

@@ -1,3 +1,5 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 const MILESTONE_CONTEXT_RE = /M\d+(?:-[a-z0-9]{6})?-CONTEXT\.md$/;
 const CONTEXT_MILESTONE_RE = /(?:^|[/\\])(M\d+(?:-[a-z0-9]{6})?)-CONTEXT\.md$/i;
 const DEPTH_VERIFICATION_MILESTONE_RE = /depth_verification[_-](M\d+(?:-[a-z0-9]{6})?)/i;
@@ -57,6 +59,61 @@ const GATE_SAFE_TOOLS = new Set([
     "search-the-web", "resolve_library", "get_library_docs", "fetch_page",
     "search_and_read",
 ]);
+function shouldPersistWriteGateSnapshot(env = process.env) {
+    return env.GSD_PERSIST_WRITE_GATE_STATE === "1";
+}
+function writeGateSnapshotPath(basePath = process.cwd()) {
+    return join(basePath, ".gsd", "runtime", "write-gate-state.json");
+}
+function currentWriteGateSnapshot() {
+    return {
+        verifiedDepthMilestones: [...verifiedDepthMilestones].sort(),
+        activeQueuePhase,
+        pendingGateId,
+    };
+}
+function persistWriteGateSnapshot(basePath = process.cwd()) {
+    if (!shouldPersistWriteGateSnapshot())
+        return;
+    const path = writeGateSnapshotPath(basePath);
+    mkdirSync(join(basePath, ".gsd", "runtime"), { recursive: true });
+    const tempPath = `${path}.tmp`;
+    writeFileSync(tempPath, JSON.stringify(currentWriteGateSnapshot(), null, 2), "utf-8");
+    renameSync(tempPath, path);
+}
+function clearPersistedWriteGateSnapshot(basePath = process.cwd()) {
+    if (!shouldPersistWriteGateSnapshot())
+        return;
+    const path = writeGateSnapshotPath(basePath);
+    try {
+        unlinkSync(path);
+    }
+    catch {
+        // swallow
+    }
+}
+function normalizeWriteGateSnapshot(value) {
+    const record = value && typeof value === "object" ? value : {};
+    const verified = Array.isArray(record.verifiedDepthMilestones)
+        ? record.verifiedDepthMilestones.filter((item) => typeof item === "string")
+        : [];
+    return {
+        verifiedDepthMilestones: [...new Set(verified)].sort(),
+        activeQueuePhase: record.activeQueuePhase === true,
+        pendingGateId: typeof record.pendingGateId === "string" ? record.pendingGateId : null,
+    };
+}
+export function loadWriteGateSnapshot(basePath = process.cwd()) {
+    const path = writeGateSnapshotPath(basePath);
+    if (!existsSync(path))
+        return currentWriteGateSnapshot();
+    try {
+        return normalizeWriteGateSnapshot(JSON.parse(readFileSync(path, "utf-8")));
+    }
+    catch {
+        return currentWriteGateSnapshot();
+    }
+}
 export function isDepthVerified() {
     return verifiedDepthMilestones.size > 0;
 }
@@ -68,25 +125,34 @@ export function isMilestoneDepthVerified(milestoneId) {
         return false;
     return verifiedDepthMilestones.has(milestoneId);
 }
+export function isMilestoneDepthVerifiedInSnapshot(snapshot, milestoneId) {
+    if (!milestoneId)
+        return false;
+    return snapshot.verifiedDepthMilestones.includes(milestoneId);
+}
 export function isQueuePhaseActive() {
     return activeQueuePhase;
 }
 export function setQueuePhaseActive(active) {
     activeQueuePhase = active;
+    persistWriteGateSnapshot();
 }
 export function resetWriteGateState() {
     verifiedDepthMilestones.clear();
     pendingGateId = null;
+    persistWriteGateSnapshot();
 }
 export function clearDiscussionFlowState() {
     verifiedDepthMilestones.clear();
     activeQueuePhase = false;
     pendingGateId = null;
+    clearPersistedWriteGateSnapshot();
 }
-export function markDepthVerified(milestoneId) {
+export function markDepthVerified(milestoneId, basePath = process.cwd()) {
     if (!milestoneId)
         return;
     verifiedDepthMilestones.add(milestoneId);
+    persistWriteGateSnapshot(basePath);
 }
 /**
  * Check whether a question ID matches a recognized gate pattern.
@@ -114,12 +180,14 @@ function extractContextMilestoneId(inputPath) {
  */
 export function setPendingGate(gateId) {
     pendingGateId = gateId;
+    persistWriteGateSnapshot();
 }
 /**
  * Clear the pending gate (called when the user confirms).
  */
 export function clearPendingGate() {
     pendingGateId = null;
+    persistWriteGateSnapshot();
 }
 /**
  * Get the currently pending gate, if any.
@@ -134,8 +202,11 @@ export function getPendingGate() {
  * Returns { block: true, reason } if the tool should be blocked.
  * Read-only tools and ask_user_questions itself are always allowed.
  */
-export function shouldBlockPendingGate(toolName, _milestoneId, _queuePhaseActive) {
-    if (!pendingGateId)
+export function shouldBlockPendingGate(toolName, milestoneId, queuePhaseActive) {
+    return shouldBlockPendingGateInSnapshot(currentWriteGateSnapshot(), toolName, milestoneId, queuePhaseActive);
+}
+export function shouldBlockPendingGateInSnapshot(snapshot, toolName, _milestoneId, _queuePhaseActive) {
+    if (!snapshot.pendingGateId)
         return { block: false };
     if (GATE_SAFE_TOOLS.has(toolName))
         return { block: false };
@@ -145,7 +216,7 @@ export function shouldBlockPendingGate(toolName, _milestoneId, _queuePhaseActive
     return {
         block: true,
         reason: [
-            `HARD BLOCK: Discussion gate "${pendingGateId}" has not been confirmed by the user.`,
+            `HARD BLOCK: Discussion gate "${snapshot.pendingGateId}" has not been confirmed by the user.`,
             `You MUST re-call ask_user_questions with the gate question before making any other tool calls.`,
             `If the previous ask_user_questions call failed, errored, was cancelled, or the user's response`,
             `did not match a provided option, you MUST re-ask — never rationalize past the block.`,
@@ -157,8 +228,11 @@ export function shouldBlockPendingGate(toolName, _milestoneId, _queuePhaseActive
  * Check whether a bash command should be blocked because a discussion gate is pending.
  * Read-only bash commands are allowed; mutating commands are blocked.
  */
-export function shouldBlockPendingGateBash(command, _milestoneId, _queuePhaseActive) {
-    if (!pendingGateId)
+export function shouldBlockPendingGateBash(command, milestoneId, queuePhaseActive) {
+    return shouldBlockPendingGateBashInSnapshot(currentWriteGateSnapshot(), command, milestoneId, queuePhaseActive);
+}
+export function shouldBlockPendingGateBashInSnapshot(snapshot, command, _milestoneId, _queuePhaseActive) {
+    if (!snapshot.pendingGateId)
         return { block: false };
     // Allow read-only bash commands
     if (BASH_READ_ONLY_RE.test(command))
@@ -166,7 +240,7 @@ export function shouldBlockPendingGateBash(command, _milestoneId, _queuePhaseAct
     return {
         block: true,
         reason: [
-            `HARD BLOCK: Discussion gate "${pendingGateId}" has not been confirmed by the user.`,
+            `HARD BLOCK: Discussion gate "${snapshot.pendingGateId}" has not been confirmed by the user.`,
             `You MUST re-call ask_user_questions with the gate question before running mutating commands.`,
             `If the previous ask_user_questions call failed, errored, was cancelled, or the user's response`,
             `did not match a provided option, you MUST re-ask — never rationalize past the block.`,
@@ -232,6 +306,9 @@ export function shouldBlockContextWrite(toolName, inputPath, milestoneId, _queue
  * require the milestone to be depth-verified first.
  */
 export function shouldBlockContextArtifactSave(artifactType, milestoneId, sliceId) {
+    return shouldBlockContextArtifactSaveInSnapshot(currentWriteGateSnapshot(), artifactType, milestoneId, sliceId);
+}
+export function shouldBlockContextArtifactSaveInSnapshot(snapshot, artifactType, milestoneId, sliceId) {
     if (artifactType !== "CONTEXT")
         return { block: false };
     if (sliceId)
@@ -245,7 +322,7 @@ export function shouldBlockContextArtifactSave(artifactType, milestoneId, sliceI
             ].join(" "),
         };
     }
-    if (isMilestoneDepthVerified(milestoneId))
+    if (isMilestoneDepthVerifiedInSnapshot(snapshot, milestoneId))
         return { block: false };
     return {
         block: true,
@@ -271,6 +348,9 @@ export function shouldBlockContextArtifactSave(artifactType, milestoneId, sliceI
  * @returns { block, reason } — block=true if the call should be rejected.
  */
 export function shouldBlockQueueExecution(toolName, input, queuePhaseActive) {
+    return shouldBlockQueueExecutionInSnapshot(currentWriteGateSnapshot(), toolName, input, queuePhaseActive);
+}
+export function shouldBlockQueueExecutionInSnapshot(snapshot, toolName, input, queuePhaseActive = snapshot.activeQueuePhase) {
     if (!queuePhaseActive)
         return { block: false };
     // Always-safe tools (read-only, discussion, planning)

package/dist/resources/extensions/gsd/commands/handlers/core.js

@@ -168,6 +168,42 @@ function sortModelsForSelection(models, currentModel) {
         return a.id.localeCompare(b.id);
     });
 }
+function buildProviderModelGroups(models, currentModel) {
+    const byProvider = new Map();
+    for (const model of sortModelsForSelection(models, currentModel)) {
+        let group = byProvider.get(model.provider);
+        if (!group) {
+            group = [];
+            byProvider.set(model.provider, group);
+        }
+        group.push(model);
+    }
+    return byProvider;
+}
+async function selectModelByProvider(title, models, ctx, currentModel) {
+    const byProvider = buildProviderModelGroups(models, currentModel);
+    const providerOptions = Array.from(byProvider.entries()).map(([provider, group]) => `${provider} (${group.length} model${group.length === 1 ? "" : "s"})`);
+    providerOptions.push("(cancel)");
+    const providerChoice = await ctx.ui.select(`${title} — choose provider:`, providerOptions);
+    if (!providerChoice || typeof providerChoice !== "string" || providerChoice === "(cancel)")
+        return undefined;
+    const providerName = providerChoice.replace(/ \(\d+ models?\)$/, "");
+    const providerModels = byProvider.get(providerName);
+    if (!providerModels || providerModels.length === 0)
+        return undefined;
+    const optionToModel = new Map();
+    const modelOptions = providerModels.map((model) => {
+        const isCurrent = currentModel && model.provider === currentModel.provider && model.id === currentModel.id;
+        const label = `${isCurrent ? "* " : ""}${model.id}`;
+        optionToModel.set(label, model);
+        return label;
+    });
+    modelOptions.push("(cancel)");
+    const modelChoice = await ctx.ui.select(`${title} — ${providerName}:`, modelOptions);
+    if (!modelChoice || typeof modelChoice !== "string" || modelChoice === "(cancel)")
+        return undefined;
+    return optionToModel.get(modelChoice);
+}
 async function resolveRequestedModel(query, ctx) {
     const { resolveModelId } = await import("../../auto-model-selection.js");
     const models = ctx.modelRegistry.getAvailable();
@@ -181,18 +217,7 @@ async function resolveRequestedModel(query, ctx) {
         return partialMatches[0];
     if (partialMatches.length === 0 || !ctx.hasUI)
         return undefined;
-    const sorted = sortModelsForSelection(partialMatches, ctx.model);
-    const optionToModel = new Map();
-    const options = sorted.map((model) => {
-        const label = `${model.provider}/${model.id}`;
-        optionToModel.set(label, model);
-        return label;
-    });
-    options.push("(cancel)");
-    const choice = await ctx.ui.select(`Multiple models match "${query}" — choose one:`, options);
-    if (!choice || typeof choice !== "string" || choice === "(cancel)")
-        return undefined;
-    return optionToModel.get(choice);
+    return selectModelByProvider(`Multiple models match "${query}"`, partialMatches, ctx, ctx.model);
 }
 async function handleModel(trimmedArgs, ctx, pi) {
     const availableModels = ctx.modelRegistry.getAvailable();
@@ -212,18 +237,7 @@ async function handleModel(trimmedArgs, ctx, pi) {
             ctx.ui.notify(`Current model: ${current}\nUsage: /gsd model <provider/model|model-id>`, "info");
             return;
         }
-        const optionToModel = new Map();
-        const options = sortModelsForSelection(availableModels, ctx.model).map((model) => {
-            const isCurrent = ctx.model && model.provider === ctx.model.provider && model.id === ctx.model.id;
-            const label = `${isCurrent ? "* " : ""}${model.provider}/${model.id}`;
-            optionToModel.set(label, model);
-            return label;
-        });
-        options.push("(cancel)");
-        const choice = await ctx.ui.select("Select session model:", options);
-        if (!choice || typeof choice !== "string" || choice === "(cancel)")
-            return;
-        targetModel = optionToModel.get(choice);
+        targetModel = await selectModelByProvider("Select session model:", availableModels, ctx, ctx.model);
     }
     else {
         targetModel = await resolveRequestedModel(trimmed, ctx);

package/dist/resources/extensions/gsd/commands/index.js

@@ -5,7 +5,14 @@ export function registerGSDCommand(pi) {
         getArgumentCompletions: getGsdArgumentCompletions,
         handler: async (args, ctx) => {
             const { handleGSDCommand } = await import("./dispatcher.js");
-            await handleGSDCommand(args, ctx, pi);
+            const { setStderrLoggingEnabled } = await import("../workflow-logger.js");
+            const previousStderrSetting = setStderrLoggingEnabled(false);
+            try {
+                await handleGSDCommand(args, ctx, pi);
+            }
+            finally {
+                setStderrLoggingEnabled(previousStderrSetting);
+            }
         },
     });
 }

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

@@ -34,6 +34,7 @@ import { findMilestoneIds, nextMilestoneId, reserveMilestoneId, getReservedMiles
 import { parkMilestone, discardMilestone } from "./milestone-actions.js";
 import { selectAndApplyModel } from "./auto-model-selection.js";
 import { DISCUSS_TOOLS_ALLOWLIST } from "./constants.js";
+import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForGuidedUnit, } from "./workflow-mcp.js";
 import { runPreparation, formatCodebaseBrief, formatPriorContextBrief, formatEcosystemBrief, } from "./preparation.js";
 // ─── Preparation result storage ─────────────────────────────────────────────
 // Stores the most recent preparation result for injection into discuss prompts.
@@ -259,6 +260,21 @@ async function dispatchWorkflow(pi, note, customType = "gsd-run", ctx, unitType)
                 routing: result.routing,
             });
         }
+        const compatibilityError = getWorkflowTransportSupportError(result.appliedModel?.provider ?? ctx.model?.provider, getRequiredWorkflowToolsForGuidedUnit(unitType), {
+            projectRoot: process.cwd(),
+            surface: "guided flow",
+            unitType,
+            authMode: result.appliedModel?.provider
+                ? ctx.modelRegistry.getProviderAuthMode(result.appliedModel.provider)
+                : ctx.model?.provider
+                    ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider)
+                    : undefined,
+            baseUrl: result.appliedModel?.baseUrl ?? ctx.model?.baseUrl,
+        });
+        if (compatibilityError) {
+            ctx.ui.notify(compatibilityError, "error");
+            return;
+        }
     }
     // Scope tools for discuss flows (#2949).
     // Providers with grammar-based constrained decoding (xAI/Grok) return

package/dist/resources/extensions/gsd/init-wizard.js

@@ -187,6 +187,20 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
     }
     // ── Step 9: Bootstrap .gsd/ ────────────────────────────────────────────────
     bootstrapGsdDirectory(basePath, prefs, signals);
+    // Initialize SQLite database so GSD starts in full-capability mode (#3880).
+    // Without this, isDbAvailable() returns false and GSD enters degraded
+    // markdown-only mode until a tool handler happens to call ensureDbOpen().
+    let dbReady = false;
+    try {
+        const { ensureDbOpen } = await import("./bootstrap/dynamic-tools.js");
+        dbReady = await ensureDbOpen(basePath);
+    }
+    catch {
+        // Swallowed — warning surfaced below
+    }
+    if (!dbReady) {
+        ctx.ui.notify("Warning: database initialization failed — GSD will run in degraded mode until the next /gsd invocation.", "warning");
+    }
     // Ensure .gitignore
     ensureGitignore(basePath);
     untrackRuntimeFiles(basePath);
@@ -201,6 +215,25 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
     catch {
         // Non-fatal — codebase map generation failure should never block project init
     }
+    // Write initial STATE.md so it exists before the first /gsd invocation.
+    // The explicit /gsd init path (ops.ts) returns without entering showSmartEntry(),
+    // which would otherwise generate STATE.md at guided-flow.ts:1358.
+    let stateReady = false;
+    try {
+        const { deriveState } = await import("./state.js");
+        const { buildStateMarkdown } = await import("./doctor.js");
+        const { saveFile } = await import("./files.js");
+        const { resolveGsdRootFile } = await import("./paths.js");
+        const state = await deriveState(basePath);
+        await saveFile(resolveGsdRootFile(basePath, "STATE"), buildStateMarkdown(state));
+        stateReady = true;
+    }
+    catch {
+        // Swallowed — warning surfaced below
+    }
+    if (!stateReady) {
+        ctx.ui.notify("Warning: initial STATE.md generation failed — it will be created on the next /gsd invocation.", "warning");
+    }
     ctx.ui.notify("GSD initialized. Starting your first milestone...", "info");
     return { completed: true, bootstrapped: true };
 }
@@ -348,6 +381,7 @@ function bootstrapGsdDirectory(basePath, prefs, signals) {
     assertSafeDirectory(basePath);
     const gsd = gsdRoot(basePath);
     mkdirSync(join(gsd, "milestones"), { recursive: true });
+    mkdirSync(join(gsd, "runtime"), { recursive: true });
     // Write PREFERENCES.md from wizard answers
     const preferencesContent = buildPreferencesFile(prefs);
     writeFileSync(join(gsd, "PREFERENCES.md"), preferencesContent, "utf-8");