gsd-pi 2.67.0-dev.1cd1e0f → 2.67.0-dev.2367d7e

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)

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/system-context.js

@@ -141,7 +141,7 @@ export async function buildBeforeAgentStartResult(event, ctx) {
     warnDeprecatedAgentInstructions();
     const injection = await buildGuidedExecuteContextInjection(event.prompt, process.cwd());
     // Re-inject forensics context on follow-up turns (#2941)
-    const forensicsInjection = !injection ? buildForensicsContextInjection(process.cwd()) : null;
+    const forensicsInjection = !injection ? buildForensicsContextInjection(process.cwd(), event.prompt) : null;
     const worktreeBlock = buildWorktreeContextBlock();
     const fullSystem = `${event.systemPrompt}\n\n[SYSTEM CONTEXT — GSD]\n\n${systemContent}${preferenceBlock}${knowledgeBlock}${codebaseBlock}${memoryBlock}${newSkillsBlock}${worktreeBlock}`;
     stopContextTimer({
@@ -425,7 +425,7 @@ function oneLine(text) {
  * Check for an active forensics session and return the prompt content
  * so it can be re-injected on follow-up turns.
  */
-function buildForensicsContextInjection(basePath) {
+export function buildForensicsContextInjection(basePath, prompt) {
     const marker = readForensicsMarker(basePath);
     if (!marker)
         return null;
@@ -435,6 +435,11 @@ function buildForensicsContextInjection(basePath) {
         clearForensicsMarker(basePath);
         return null;
     }
+    const trimmed = prompt.trim().toLowerCase().replace(/[.!?,]+$/g, "");
+    if (trimmed && !RESUME_INTENT_PATTERNS.test(trimmed)) {
+        clearForensicsMarker(basePath);
+        return null;
+    }
     return marker.promptContent;
 }
 /**