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

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -9,6 +9,7 @@
 import { EventStream } from "@gsd/pi-ai";
 import { execSync } from "node:child_process";
 import { PartialMessageBuilder, ZERO_USAGE, mapUsage } from "./partial-builder.js";
+import { buildWorkflowMcpServers } from "../gsd/workflow-mcp.js";
 // ---------------------------------------------------------------------------
 // Stream factory
 // ---------------------------------------------------------------------------
@@ -197,6 +198,7 @@ export function buildFinalClaudeCodeContent(blocks, lastThinkingContent, lastTex
  * beta flags, and other configuration without mocking the full SDK.
  */
 export function buildSdkOptions(modelId, prompt) {
+    const mcpServers = buildWorkflowMcpServers();
     return {
         pathToClaudeCodeExecutable: getClaudePath(),
         model: modelId,
@@ -207,6 +209,7 @@ export function buildSdkOptions(modelId, prompt) {
         allowDangerouslySkipPermissions: true,
         settingSources: ["project"],
         systemPrompt: { type: "preset", preset: "claude_code" },
+        ...(mcpServers ? { mcpServers } : {}),
         betas: modelId.includes("sonnet") ? ["context-1m-2025-08-07"] : [],
     };
 }

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

@@ -27,6 +27,7 @@ import { isDbAvailable, getMilestoneSlices } from "../gsd-db.js";
 import { resetEvidence } from "../safety/evidence-collector.js";
 import { createCheckpoint, cleanupCheckpoint, rollbackToCheckpoint } from "../safety/git-checkpoint.js";
 import { resolveSafetyHarnessConfig } from "../safety/safety-harness.js";
+import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit, } from "../workflow-mcp.js";
 // ─── generateMilestoneReport ──────────────────────────────────────────────────
 /**
  * Resolve the base path for milestone reports.
@@ -886,6 +887,22 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     s.currentDispatchedModelId = s.currentUnitModel
         ? `${s.currentUnitModel.provider ?? ""}/${s.currentUnitModel.id ?? ""}`
         : null;
+    const compatibilityError = getWorkflowTransportSupportError(s.currentUnitModel?.provider ?? ctx.model?.provider, getRequiredWorkflowToolsForAutoUnit(unitType), {
+        projectRoot: s.basePath,
+        surface: "auto-mode",
+        unitType,
+        authMode: s.currentUnitModel?.provider
+            ? ctx.modelRegistry.getProviderAuthMode(s.currentUnitModel.provider)
+            : ctx.model?.provider
+                ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider)
+                : undefined,
+        baseUrl: s.currentUnitModel?.baseUrl ?? ctx.model?.baseUrl,
+    });
+    if (compatibilityError) {
+        ctx.ui.notify(compatibilityError, "error");
+        await deps.stopAuto(ctx, pi, compatibilityError);
+        return { action: "break", reason: "workflow-capability" };
+    }
     // Progress widget + preconditions — deferred to after model selection so the
     // widget's first render tick shows the correct model (#2899).
     deps.updateProgressWidget(ctx, unitType, unitId, state);

package/dist/resources/extensions/gsd/auto-direct-dispatch.js

@@ -10,6 +10,7 @@ import { resolveMilestoneFile, resolveSliceFile, relSliceFile, } from "./paths.j
 import { buildResearchSlicePrompt, buildResearchMilestonePrompt, buildPlanSlicePrompt, buildPlanMilestonePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildReassessRoadmapPrompt, buildRunUatPrompt, buildReplanSlicePrompt, } from "./auto-prompts.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { pauseAuto } from "./auto.js";
+import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit, } from "./workflow-mcp.js";
 export async function dispatchDirectPhase(ctx, pi, phase, base) {
     const state = await deriveState(base);
     const mid = state.activeMilestone?.id;
@@ -202,6 +203,17 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             ctx.ui.notify(`Unknown phase "${phase}". Valid phases: research, plan, execute, complete, reassess, uat, replan.`, "warning");
             return;
     }
+    const compatibilityError = getWorkflowTransportSupportError(ctx.model?.provider, getRequiredWorkflowToolsForAutoUnit(unitType), {
+        projectRoot: base,
+        surface: "direct phase dispatch",
+        unitType,
+        authMode: ctx.model?.provider ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider) : undefined,
+        baseUrl: ctx.model?.baseUrl,
+    });
+    if (compatibilityError) {
+        ctx.ui.notify(compatibilityError, "error");
+        return;
+    }
     ctx.ui.notify(`Dispatching ${unitType} for ${unitId}...`, "info");
     const result = await ctx.newSession();
     if (result.cancelled) {

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

@@ -5,11 +5,7 @@ import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { ensureDbOpen } from "./dynamic-tools.js";
 import { StringEnum } from "@gsd/pi-ai";
 import { logError } from "../workflow-logger.js";
-import { shouldBlockContextArtifactSave } from "./write-gate.js";
-const SUPPORTED_SUMMARY_ARTIFACT_TYPES = ["SUMMARY", "RESEARCH", "CONTEXT", "ASSESSMENT", "CONTEXT-DRAFT"];
-export function isSupportedSummaryArtifactType(artifactType) {
-    return SUPPORTED_SUMMARY_ARTIFACT_TYPES.includes(artifactType);
-}
+import { executeCompleteMilestone, executePlanMilestone, executePlanSlice, executeReplanSlice, executeReassessRoadmap, executeSaveGateResult, executeSliceComplete, executeSummarySave, executeTaskComplete, executeValidateMilestone, } from "../tools/workflow-tool-executors.js";
 /**
  * Register an alias tool that shares the same execute function as its canonical counterpart.
  * The alias description and promptGuidelines direct the LLM to prefer the canonical name.
@@ -272,59 +268,7 @@ export function registerDbTools(pi) {
     registerAlias(pi, requirementSaveTool, "gsd_save_requirement", "gsd_requirement_save");
     // ─── gsd_summary_save (formerly gsd_save_summary) ──────────────────────
     const summarySaveExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const dbAvailable = await ensureDbOpen();
-        if (!dbAvailable) {
-            return {
-                content: [{ type: "text", text: "Error: GSD database is not available. Cannot save artifact." }],
-                details: { operation: "save_summary", error: "db_unavailable" },
-            };
-        }
-        if (!isSupportedSummaryArtifactType(params.artifact_type)) {
-            return {
-                content: [{ type: "text", text: `Error: Invalid artifact_type "${params.artifact_type}". Must be one of: ${SUPPORTED_SUMMARY_ARTIFACT_TYPES.join(", ")}` }],
-                details: { operation: "save_summary", error: "invalid_artifact_type" },
-            };
-        }
-        const contextGuard = shouldBlockContextArtifactSave(params.artifact_type, params.milestone_id ?? null, params.slice_id ?? null);
-        if (contextGuard.block) {
-            return {
-                content: [{ type: "text", text: `Error saving artifact: ${contextGuard.reason ?? "context write blocked"}` }],
-                details: { operation: "save_summary", error: "context_write_blocked" },
-            };
-        }
-        try {
-            let relativePath;
-            if (params.task_id && params.slice_id) {
-                relativePath = `milestones/${params.milestone_id}/slices/${params.slice_id}/tasks/${params.task_id}-${params.artifact_type}.md`;
-            }
-            else if (params.slice_id) {
-                relativePath = `milestones/${params.milestone_id}/slices/${params.slice_id}/${params.slice_id}-${params.artifact_type}.md`;
-            }
-            else {
-                relativePath = `milestones/${params.milestone_id}/${params.milestone_id}-${params.artifact_type}.md`;
-            }
-            const { saveArtifactToDb } = await import("../db-writer.js");
-            await saveArtifactToDb({
-                path: relativePath,
-                artifact_type: params.artifact_type,
-                content: params.content,
-                milestone_id: params.milestone_id,
-                slice_id: params.slice_id,
-                task_id: params.task_id,
-            }, process.cwd());
-            return {
-                content: [{ type: "text", text: `Saved ${params.artifact_type} artifact to ${relativePath}` }],
-                details: { operation: "save_summary", path: relativePath, artifact_type: params.artifact_type },
-            };
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            logError("tool", `gsd_summary_save tool failed: ${msg}`, { tool: "gsd_summary_save", error: String(err) });
-            return {
-                content: [{ type: "text", text: `Error saving artifact: ${msg}` }],
-                details: { operation: "save_summary", error: msg },
-            };
-        }
+        return executeSummarySave(params, process.cwd());
     };
     const summarySaveTool = {
         name: "gsd_summary_save",
@@ -452,39 +396,7 @@ export function registerDbTools(pi) {
     registerAlias(pi, milestoneGenerateIdTool, "gsd_generate_milestone_id", "gsd_milestone_generate_id");
     // ─── gsd_plan_milestone (gsd_milestone_plan alias) ─────────────────────
     const planMilestoneExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const dbAvailable = await ensureDbOpen();
-        if (!dbAvailable) {
-            return {
-                content: [{ type: "text", text: "Error: GSD database is not available. Cannot plan milestone." }],
-                details: { operation: "plan_milestone", error: "db_unavailable" },
-            };
-        }
-        try {
-            const { handlePlanMilestone } = await import("../tools/plan-milestone.js");
-            const result = await handlePlanMilestone(params, process.cwd());
-            if ("error" in result) {
-                return {
-                    content: [{ type: "text", text: `Error planning milestone: ${result.error}` }],
-                    details: { operation: "plan_milestone", error: result.error },
-                };
-            }
-            return {
-                content: [{ type: "text", text: `Planned milestone ${result.milestoneId}` }],
-                details: {
-                    operation: "plan_milestone",
-                    milestoneId: result.milestoneId,
-                    roadmapPath: result.roadmapPath,
-                },
-            };
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            logError("tool", `plan_milestone tool failed: ${msg}`, { tool: "gsd_plan_milestone", error: String(err) });
-            return {
-                content: [{ type: "text", text: `Error planning milestone: ${msg}` }],
-                details: { operation: "plan_milestone", error: msg },
-            };
-        }
+        return executePlanMilestone(params, process.cwd());
     };
     const planMilestoneTool = {
         name: "gsd_plan_milestone",
@@ -541,41 +453,7 @@ export function registerDbTools(pi) {
     registerAlias(pi, planMilestoneTool, "gsd_milestone_plan", "gsd_plan_milestone");
     // ─── gsd_plan_slice (gsd_slice_plan alias) ─────────────────────────────
     const planSliceExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const dbAvailable = await ensureDbOpen();
-        if (!dbAvailable) {
-            return {
-                content: [{ type: "text", text: "Error: GSD database is not available. Cannot plan slice." }],
-                details: { operation: "plan_slice", error: "db_unavailable" },
-            };
-        }
-        try {
-            const { handlePlanSlice } = await import("../tools/plan-slice.js");
-            const result = await handlePlanSlice(params, process.cwd());
-            if ("error" in result) {
-                return {
-                    content: [{ type: "text", text: `Error planning slice: ${result.error}` }],
-                    details: { operation: "plan_slice", error: result.error },
-                };
-            }
-            return {
-                content: [{ type: "text", text: `Planned slice ${result.sliceId} (${result.milestoneId})` }],
-                details: {
-                    operation: "plan_slice",
-                    milestoneId: result.milestoneId,
-                    sliceId: result.sliceId,
-                    planPath: result.planPath,
-                    taskPlanPaths: result.taskPlanPaths,
-                },
-            };
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            logError("tool", `plan_slice tool failed: ${msg}`, { tool: "gsd_plan_slice", error: String(err) });
-            return {
-                content: [{ type: "text", text: `Error planning slice: ${msg}` }],
-                details: { operation: "plan_slice", error: msg },
-            };
-        }
+        return executePlanSlice(params, process.cwd());
     };
     const planSliceTool = {
         name: "gsd_plan_slice",
@@ -682,44 +560,7 @@ export function registerDbTools(pi) {
     registerAlias(pi, planTaskTool, "gsd_task_plan", "gsd_plan_task");
     // ─── gsd_task_complete (gsd_complete_task alias) ────────────────────────
     const taskCompleteExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const dbAvailable = await ensureDbOpen();
-        if (!dbAvailable) {
-            return {
-                content: [{ type: "text", text: "Error: GSD database is not available. Cannot complete task." }],
-                details: { operation: "complete_task", error: "db_unavailable" },
-            };
-        }
-        try {
-            // Coerce string items to objects for verificationEvidence (#3541).
-            const coerced = { ...params };
-            coerced.verificationEvidence = (params.verificationEvidence ?? []).map((v) => typeof v === "string" ? { command: v, exitCode: -1, verdict: "unknown (coerced from string)", durationMs: 0 } : v);
-            const { handleCompleteTask } = await import("../tools/complete-task.js");
-            const result = await handleCompleteTask(coerced, process.cwd());
-            if ("error" in result) {
-                return {
-                    content: [{ type: "text", text: `Error completing task: ${result.error}` }],
-                    details: { operation: "complete_task", error: result.error },
-                };
-            }
-            return {
-                content: [{ type: "text", text: `Completed task ${result.taskId} (${result.sliceId}/${result.milestoneId})` }],
-                details: {
-                    operation: "complete_task",
-                    taskId: result.taskId,
-                    sliceId: result.sliceId,
-                    milestoneId: result.milestoneId,
-                    summaryPath: result.summaryPath,
-                },
-            };
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            logError("tool", `complete_task tool failed: ${msg}`, { tool: "gsd_task_complete", error: String(err) });
-            return {
-                content: [{ type: "text", text: `Error completing task: ${msg}` }],
-                details: { operation: "complete_task", error: msg },
-            };
-        }
+        return executeTaskComplete(params, process.cwd());
     };
     const taskCompleteTool = {
         name: "gsd_task_complete",
@@ -764,90 +605,7 @@ export function registerDbTools(pi) {
     registerAlias(pi, taskCompleteTool, "gsd_complete_task", "gsd_task_complete");
     // ─── gsd_slice_complete (gsd_complete_slice alias) ─────────────────────
     const sliceCompleteExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const dbAvailable = await ensureDbOpen();
-        if (!dbAvailable) {
-            return {
-                content: [{ type: "text", text: "Error: GSD database is not available. Cannot complete slice." }],
-                details: { operation: "complete_slice", error: "db_unavailable" },
-            };
-        }
-        try {
-            // Coerce string items to objects for fields where LLMs sometimes pass
-            // plain strings instead of the expected { key, value } shape (#3541).
-            // Parses "key — value" or "key - value" format when possible.
-            const splitPair = (s) => {
-                const m = s.match(/^(.+?)\s*(?:—|-)\s+(.+)$/);
-                return m ? [m[1].trim(), m[2].trim()] : [s.trim(), ""];
-            };
-            const coerced = { ...params };
-            // Coerce simple string-array fields: LLMs sometimes pass a plain string
-            // instead of a single-element array (#3585).
-            const wrapArray = (v) => v == null ? [] : Array.isArray(v) ? v : [v];
-            coerced.provides = wrapArray(params.provides);
-            coerced.keyFiles = wrapArray(params.keyFiles);
-            coerced.keyDecisions = wrapArray(params.keyDecisions);
-            coerced.patternsEstablished = wrapArray(params.patternsEstablished);
-            coerced.observabilitySurfaces = wrapArray(params.observabilitySurfaces);
-            coerced.requirementsSurfaced = wrapArray(params.requirementsSurfaced);
-            coerced.drillDownPaths = wrapArray(params.drillDownPaths);
-            coerced.affects = wrapArray(params.affects);
-            coerced.filesModified = wrapArray(params.filesModified).map((f) => {
-                if (typeof f !== "string")
-                    return f;
-                const [path, description] = splitPair(f);
-                return { path, description };
-            });
-            coerced.requires = wrapArray(params.requires).map((r) => {
-                if (typeof r !== "string")
-                    return r;
-                const [slice, provides] = splitPair(r);
-                return { slice, provides };
-            });
-            coerced.requirementsAdvanced = wrapArray(params.requirementsAdvanced).map((r) => {
-                if (typeof r !== "string")
-                    return r;
-                const [id, how] = splitPair(r);
-                return { id, how };
-            });
-            coerced.requirementsValidated = wrapArray(params.requirementsValidated).map((r) => {
-                if (typeof r !== "string")
-                    return r;
-                const [id, proof] = splitPair(r);
-                return { id, proof };
-            });
-            coerced.requirementsInvalidated = wrapArray(params.requirementsInvalidated).map((r) => {
-                if (typeof r !== "string")
-                    return r;
-                const [id, what] = splitPair(r);
-                return { id, what };
-            });
-            const { handleCompleteSlice } = await import("../tools/complete-slice.js");
-            const result = await handleCompleteSlice(coerced, process.cwd());
-            if ("error" in result) {
-                return {
-                    content: [{ type: "text", text: `Error completing slice: ${result.error}` }],
-                    details: { operation: "complete_slice", error: result.error },
-                };
-            }
-            return {
-                content: [{ type: "text", text: `Completed slice ${result.sliceId} (${result.milestoneId})` }],
-                details: {
-                    operation: "complete_slice",
-                    sliceId: result.sliceId,
-                    milestoneId: result.milestoneId,
-                    summaryPath: result.summaryPath,
-                    uatPath: result.uatPath,
-                },
-            };
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            logError("tool", `complete_slice tool failed: ${msg}`, { tool: "gsd_slice_complete", error: String(err) });
-            return {
-                content: [{ type: "text", text: `Error completing slice: ${msg}` }],
-                details: { operation: "complete_slice", error: msg },
-            };
-        }
+        return executeSliceComplete(params, process.cwd());
     };
     const sliceCompleteTool = {
         name: "gsd_slice_complete",
@@ -1004,42 +762,7 @@ export function registerDbTools(pi) {
     });
     // ─── gsd_complete_milestone ────────────────────────────────────────────
     const milestoneCompleteExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const dbAvailable = await ensureDbOpen();
-        if (!dbAvailable) {
-            return {
-                content: [{ type: "text", text: "Error: GSD database is not available. Cannot complete milestone." }],
-                details: { operation: "complete_milestone", error: "db_unavailable" },
-            };
-        }
-        try {
-            // ── Input sanitization: normalize markdown parameters (#3013) ──────
-            const { sanitizeCompleteMilestoneParams } = await import("./sanitize-complete-milestone.js");
-            const sanitized = sanitizeCompleteMilestoneParams(params);
-            const { handleCompleteMilestone } = await import("../tools/complete-milestone.js");
-            const result = await handleCompleteMilestone(sanitized, process.cwd());
-            if ("error" in result) {
-                return {
-                    content: [{ type: "text", text: `Error completing milestone: ${result.error}` }],
-                    details: { operation: "complete_milestone", error: result.error },
-                };
-            }
-            return {
-                content: [{ type: "text", text: `Completed milestone ${result.milestoneId}. Summary written to ${result.summaryPath}` }],
-                details: {
-                    operation: "complete_milestone",
-                    milestoneId: result.milestoneId,
-                    summaryPath: result.summaryPath,
-                },
-            };
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            logError("tool", `complete_milestone tool failed: ${msg}`, { tool: "gsd_complete_milestone", error: String(err) });
-            return {
-                content: [{ type: "text", text: `Error completing milestone: ${msg}` }],
-                details: { operation: "complete_milestone", error: msg },
-            };
-        }
+        return executeCompleteMilestone(params, process.cwd());
     };
     const milestoneCompleteTool = {
         name: "gsd_complete_milestone",
@@ -1076,40 +799,7 @@ export function registerDbTools(pi) {
     registerAlias(pi, milestoneCompleteTool, "gsd_milestone_complete", "gsd_complete_milestone");
     // ─── gsd_validate_milestone (gsd_milestone_validate alias) ─────────────
     const milestoneValidateExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const dbAvailable = await ensureDbOpen();
-        if (!dbAvailable) {
-            return {
-                content: [{ type: "text", text: "Error: GSD database is not available. Cannot validate milestone." }],
-                details: { operation: "validate_milestone", error: "db_unavailable" },
-            };
-        }
-        try {
-            const { handleValidateMilestone } = await import("../tools/validate-milestone.js");
-            const result = await handleValidateMilestone(params, process.cwd());
-            if ("error" in result) {
-                return {
-                    content: [{ type: "text", text: `Error validating milestone: ${result.error}` }],
-                    details: { operation: "validate_milestone", error: result.error },
-                };
-            }
-            return {
-                content: [{ type: "text", text: `Validated milestone ${result.milestoneId} — verdict: ${result.verdict}. Written to ${result.validationPath}` }],
-                details: {
-                    operation: "validate_milestone",
-                    milestoneId: result.milestoneId,
-                    verdict: result.verdict,
-                    validationPath: result.validationPath,
-                },
-            };
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            logError("tool", `validate_milestone tool failed: ${msg}`, { tool: "gsd_validate_milestone", error: String(err) });
-            return {
-                content: [{ type: "text", text: `Error validating milestone: ${msg}` }],
-                details: { operation: "validate_milestone", error: msg },
-            };
-        }
+        return executeValidateMilestone(params, process.cwd());
     };
     const milestoneValidateTool = {
         name: "gsd_validate_milestone",
@@ -1141,41 +831,7 @@ export function registerDbTools(pi) {
     registerAlias(pi, milestoneValidateTool, "gsd_milestone_validate", "gsd_validate_milestone");
     // ─── gsd_replan_slice (gsd_slice_replan alias) ─────────────────────────
     const replanSliceExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const dbAvailable = await ensureDbOpen();
-        if (!dbAvailable) {
-            return {
-                content: [{ type: "text", text: "Error: GSD database is not available. Cannot replan slice." }],
-                details: { operation: "replan_slice", error: "db_unavailable" },
-            };
-        }
-        try {
-            const { handleReplanSlice } = await import("../tools/replan-slice.js");
-            const result = await handleReplanSlice(params, process.cwd());
-            if ("error" in result) {
-                return {
-                    content: [{ type: "text", text: `Error replanning slice: ${result.error}` }],
-                    details: { operation: "replan_slice", error: result.error },
-                };
-            }
-            return {
-                content: [{ type: "text", text: `Replanned slice ${result.sliceId} (${result.milestoneId})` }],
-                details: {
-                    operation: "replan_slice",
-                    milestoneId: result.milestoneId,
-                    sliceId: result.sliceId,
-                    replanPath: result.replanPath,
-                    planPath: result.planPath,
-                },
-            };
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            logError("tool", `replan_slice tool failed: ${msg}`, { tool: "gsd_replan_slice", error: String(err) });
-            return {
-                content: [{ type: "text", text: `Error replanning slice: ${msg}` }],
-                details: { operation: "replan_slice", error: msg },
-            };
-        }
+        return executeReplanSlice(params, process.cwd());
     };
     const replanSliceTool = {
         name: "gsd_replan_slice",
@@ -1214,41 +870,7 @@ export function registerDbTools(pi) {
     registerAlias(pi, replanSliceTool, "gsd_slice_replan", "gsd_replan_slice");
     // ─── gsd_reassess_roadmap (gsd_roadmap_reassess alias) ─────────────────
     const reassessRoadmapExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const dbAvailable = await ensureDbOpen();
-        if (!dbAvailable) {
-            return {
-                content: [{ type: "text", text: "Error: GSD database is not available. Cannot reassess roadmap." }],
-                details: { operation: "reassess_roadmap", error: "db_unavailable" },
-            };
-        }
-        try {
-            const { handleReassessRoadmap } = await import("../tools/reassess-roadmap.js");
-            const result = await handleReassessRoadmap(params, process.cwd());
-            if ("error" in result) {
-                return {
-                    content: [{ type: "text", text: `Error reassessing roadmap: ${result.error}` }],
-                    details: { operation: "reassess_roadmap", error: result.error },
-                };
-            }
-            return {
-                content: [{ type: "text", text: `Reassessed roadmap for milestone ${result.milestoneId} after ${result.completedSliceId}` }],
-                details: {
-                    operation: "reassess_roadmap",
-                    milestoneId: result.milestoneId,
-                    completedSliceId: result.completedSliceId,
-                    assessmentPath: result.assessmentPath,
-                    roadmapPath: result.roadmapPath,
-                },
-            };
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            logError("tool", `reassess_roadmap tool failed: ${msg}`, { tool: "gsd_reassess_roadmap", error: String(err) });
-            return {
-                content: [{ type: "text", text: `Error reassessing roadmap: ${msg}` }],
-                details: { operation: "reassess_roadmap", error: msg },
-            };
-        }
+        return executeReassessRoadmap(params, process.cwd());
     };
     const reassessRoadmapTool = {
         name: "gsd_reassess_roadmap",
@@ -1292,53 +914,7 @@ export function registerDbTools(pi) {
     registerAlias(pi, reassessRoadmapTool, "gsd_roadmap_reassess", "gsd_reassess_roadmap");
     // ─── gsd_save_gate_result ──────────────────────────────────────────────
     const saveGateResultExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
-        const dbAvailable = await ensureDbOpen();
-        if (!dbAvailable) {
-            return {
-                content: [{ type: "text", text: "Error: GSD database is not available." }],
-                details: { operation: "save_gate_result", error: "db_unavailable" },
-            };
-        }
-        const validGates = ["Q3", "Q4", "Q5", "Q6", "Q7", "Q8"];
-        if (!validGates.includes(params.gateId)) {
-            return {
-                content: [{ type: "text", text: `Error: Invalid gateId "${params.gateId}". Must be one of: ${validGates.join(", ")}` }],
-                details: { operation: "save_gate_result", error: "invalid_gate_id" },
-            };
-        }
-        const validVerdicts = ["pass", "flag", "omitted"];
-        if (!validVerdicts.includes(params.verdict)) {
-            return {
-                content: [{ type: "text", text: `Error: Invalid verdict "${params.verdict}". Must be one of: ${validVerdicts.join(", ")}` }],
-                details: { operation: "save_gate_result", error: "invalid_verdict" },
-            };
-        }
-        try {
-            const { saveGateResult } = await import("../gsd-db.js");
-            const { invalidateStateCache } = await import("../state.js");
-            saveGateResult({
-                milestoneId: params.milestoneId,
-                sliceId: params.sliceId,
-                gateId: params.gateId,
-                taskId: params.taskId ?? "",
-                verdict: params.verdict,
-                rationale: params.rationale,
-                findings: params.findings ?? "",
-            });
-            invalidateStateCache();
-            return {
-                content: [{ type: "text", text: `Gate ${params.gateId} result saved: verdict=${params.verdict}` }],
-                details: { operation: "save_gate_result", gateId: params.gateId, verdict: params.verdict },
-            };
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            logError("tool", `gsd_save_gate_result failed: ${msg}`, { tool: "gsd_save_gate_result", error: String(err) });
-            return {
-                content: [{ type: "text", text: `Error saving gate result: ${msg}` }],
-                details: { operation: "save_gate_result", error: msg },
-            };
-        }
+        return executeSaveGateResult(params, process.cwd());
     };
     const saveGateResultTool = {
         name: "gsd_save_gate_result",

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

@@ -64,12 +64,9 @@ export function resolveProjectRootDbPath(basePath) {
     }
     return join(basePath, ".gsd", "gsd.db");
 }
-export async function ensureDbOpen() {
+export async function ensureDbOpen(basePath = process.cwd()) {
     try {
         const db = await import("../gsd-db.js");
-        if (db.isDbAvailable())
-            return true;
-        const basePath = process.cwd();
         const dbPath = resolveProjectRootDbPath(basePath);
         const gsdDir = join(basePath, ".gsd");
         // Derive the project root from the DB path (strip .gsd/gsd.db)