gsd-pi 2.71.0 → 2.72.0-dev.de4c4b3

package/packages/mcp-server/src/server.ts

@@ -55,46 +55,80 @@ function textContent(text: string): { content: Array<{ type: 'text'; text: strin
 // gsd_query filesystem reader
 // ---------------------------------------------------------------------------
 
-async function readProjectState(projectDir: string, _query: string): Promise<Record<string, unknown>> {
+/**
+ * Normalized query categories for {@link readProjectState}.
+ *
+ * Maps user-supplied query strings (or empty) to the set of fields we return.
+ * Accepts common synonyms so the MCP client can pass intuitive values.
+ */
+const QUERY_FIELDS = {
+  all: ['state', 'project', 'requirements', 'milestones'] as const,
+  state: ['state'] as const,
+  status: ['state'] as const,
+  project: ['project'] as const,
+  requirements: ['requirements'] as const,
+  milestones: ['milestones'] as const,
+} as const;
+
+type QueryCategory = keyof typeof QUERY_FIELDS;
+type ProjectStateField = (typeof QUERY_FIELDS)[QueryCategory][number];
+
+function normalizeQuery(query: string | undefined): QueryCategory {
+  const key = (query ?? 'all').trim().toLowerCase();
+  if (key in QUERY_FIELDS) return key as QueryCategory;
+  return 'all';
+}
+
+async function readProjectState(projectDir: string, query: string | undefined): Promise<Record<string, unknown>> {
   const gsdDir = join(resolve(projectDir), '.gsd');
-  const result: Record<string, unknown> = { projectDir: resolve(projectDir) };
+  const category = normalizeQuery(query);
+  const wanted = new Set<ProjectStateField>(QUERY_FIELDS[category]);
 
-  // STATE.md — current execution state
-  try {
-    result.state = await readFile(join(gsdDir, 'STATE.md'), 'utf-8');
-  } catch {
-    result.state = null;
+  const result: Record<string, unknown> = {
+    projectDir: resolve(projectDir),
+    query: category,
+  };
+
+  if (wanted.has('state')) {
+    try {
+      result.state = await readFile(join(gsdDir, 'STATE.md'), 'utf-8');
+    } catch {
+      result.state = null;
+    }
   }
 
-  // PROJECT.md — project description
-  try {
-    result.project = await readFile(join(gsdDir, 'PROJECT.md'), 'utf-8');
-  } catch {
-    result.project = null;
+  if (wanted.has('project')) {
+    try {
+      result.project = await readFile(join(gsdDir, 'PROJECT.md'), 'utf-8');
+    } catch {
+      result.project = null;
+    }
   }
 
-  // REQUIREMENTS.md — requirement contract
-  try {
-    result.requirements = await readFile(join(gsdDir, 'REQUIREMENTS.md'), 'utf-8');
-  } catch {
-    result.requirements = null;
+  if (wanted.has('requirements')) {
+    try {
+      result.requirements = await readFile(join(gsdDir, 'REQUIREMENTS.md'), 'utf-8');
+    } catch {
+      result.requirements = null;
+    }
   }
 
-  // List milestones with basic metadata
-  const milestonesDir = join(gsdDir, 'milestones');
-  try {
-    const entries = await readdir(milestonesDir, { withFileTypes: true });
-    const milestones: Array<{ id: string; hasRoadmap: boolean; hasSummary: boolean }> = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const mDir = join(milestonesDir, entry.name);
-      const hasRoadmap = await fileExists(join(mDir, `${entry.name}-ROADMAP.md`));
-      const hasSummary = await fileExists(join(mDir, `${entry.name}-SUMMARY.md`));
-      milestones.push({ id: entry.name, hasRoadmap, hasSummary });
+  if (wanted.has('milestones')) {
+    const milestonesDir = join(gsdDir, 'milestones');
+    try {
+      const entries = await readdir(milestonesDir, { withFileTypes: true });
+      const milestones: Array<{ id: string; hasRoadmap: boolean; hasSummary: boolean }> = [];
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const mDir = join(milestonesDir, entry.name);
+        const hasRoadmap = await fileExists(join(mDir, `${entry.name}-ROADMAP.md`));
+        const hasSummary = await fileExists(join(mDir, `${entry.name}-SUMMARY.md`));
+        milestones.push({ id: entry.name, hasRoadmap, hasSummary });
+      }
+      result.milestones = milestones;
+    } catch {
+      result.milestones = [];
     }
-    result.milestones = milestones;
-  } catch {
-    result.milestones = [];
   }
 
   return result;
@@ -128,8 +162,25 @@ interface ElicitRequestFormParams {
   };
 }
 
+/**
+ * Handler extra — the second argument passed by McpServer.tool handlers.
+ * Contains an AbortSignal scoped to the JSON-RPC request (cancelled when
+ * the client cancels the `tools/call`) plus other per-request metadata.
+ * Tools that can actually be stopped mid-flight should honour `signal`.
+ */
+export interface McpToolExtra {
+  signal?: AbortSignal;
+  requestId?: string | number;
+  sendNotification?: (notification: unknown) => void | Promise<void>;
+}
+
 interface McpServerInstance {
-  tool(name: string, description: string, params: Record<string, unknown>, handler: (args: Record<string, unknown>) => Promise<unknown>): unknown;
+  tool(
+    name: string,
+    description: string,
+    params: Record<string, unknown>,
+    handler: (args: Record<string, unknown>, extra?: McpToolExtra) => Promise<unknown>,
+  ): unknown;
   server: {
     elicitInput(
       params: AskUserQuestionsElicitRequest | ElicitRequestFormParams,
@@ -302,7 +353,12 @@ export async function createMcpServer(sessionManager: SessionManager): Promise<{
   );
 
   // -----------------------------------------------------------------------
-  // gsd_execute — start a new GSD auto-mode session
+  // gsd_execute — start a new GSD auto-mode session.
+  //
+  // If the JSON-RPC request is aborted while the session is starting (or
+  // immediately after), we cancel the session so we don't leak a background
+  // RpcClient process. Once the session is running the caller should use
+  // `gsd_cancel` to stop it via sessionId.
   // -----------------------------------------------------------------------
   server.tool(
     'gsd_execute',
@@ -313,12 +369,20 @@ export async function createMcpServer(sessionManager: SessionManager): Promise<{
       model: z.string().optional().describe('Model ID override'),
       bare: z.boolean().optional().describe('Run in bare mode (skip user config)'),
     },
-    async (args: Record<string, unknown>) => {
+    async (args: Record<string, unknown>, extra?: McpToolExtra) => {
       const { projectDir, command, model, bare } = args as {
         projectDir: string; command?: string; model?: string; bare?: boolean;
       };
       try {
         const sessionId = await sessionManager.startSession(projectDir, { command, model, bare });
+
+        // If the client aborted while startSession was running, cancel the
+        // newly-created session rather than leaving an orphaned process.
+        if (extra?.signal?.aborted) {
+          await sessionManager.cancelSession(sessionId).catch(() => { /* swallow */ });
+          return errorContent('gsd_execute aborted by client before returning');
+        }
+
         return jsonContent({ sessionId, status: 'started' });
       } catch (err) {
         return errorContent(err instanceof Error ? err.message : String(err));
@@ -411,17 +475,25 @@ export async function createMcpServer(sessionManager: SessionManager): Promise<{
   );
 
   // -----------------------------------------------------------------------
-  // gsd_query — read project state from filesystem (no session needed)
+  // gsd_query — read project state from filesystem (no session needed).
+  //
+  // `query` is optional: when omitted the tool returns all fields (STATE.md,
+  // PROJECT.md, requirements, milestone listing). Accepted narrow values:
+  // "state" / "status", "project", "requirements", "milestones", "all".
+  // Unknown values fall back to "all" for forward-compatibility.
   // -----------------------------------------------------------------------
   server.tool(
     'gsd_query',
-    'Query GSD project state from the filesystem. Returns STATE.md, PROJECT.md, requirements, and milestone listing. Does not require an active session.',
+    'Query GSD project state from the filesystem. By default returns STATE.md, PROJECT.md, requirements, and milestone listing. Pass `query` to narrow the response (accepted: "state"/"status", "project", "requirements", "milestones", "all"). Does not require an active session.',
     {
       projectDir: z.string().describe('Absolute path to the project directory'),
-      query: z.string().describe('What to query (e.g. "status", "milestones", "requirements")'),
+      query: z
+        .enum(['all', 'state', 'status', 'project', 'requirements', 'milestones'])
+        .optional()
+        .describe('Narrow the response to a single field (default: "all")'),
     },
     async (args: Record<string, unknown>) => {
-      const { projectDir, query } = args as { projectDir: string; query: string };
+      const { projectDir, query } = args as { projectDir: string; query?: string };
       try {
         const state = await readProjectState(projectDir, query);
         return jsonContent(state);

package/packages/mcp-server/src/workflow-tools.test.ts

@@ -384,6 +384,116 @@ describe("workflow MCP tools", () => {
     }
   });
 
+  it("gsd_requirement_save opens the DB before inline requirement writes", async () => {
+    const base = makeTmpBase();
+    try {
+      const server = makeMockServer();
+      registerWorkflowTools(server as any);
+      const requirementTool = server.tools.find((t) => t.name === "gsd_requirement_save");
+      assert.ok(requirementTool, "requirement tool should be registered");
+
+      closeDatabase();
+
+      const result = await requirementTool!.handler({
+        projectDir: base,
+        class: "operability",
+        description: "Inline MCP requirement save regression",
+        why: "Reproduce missing ensureDbOpen in workflow-tools",
+        source: "user",
+        status: "active",
+        primary_owner: "M010/S10",
+        validation: "n/a",
+      });
+
+      assert.match((result as any).content[0].text as string, /Saved requirement R\d+/);
+      assert.ok(existsSync(join(base, ".gsd", "REQUIREMENTS.md")), "REQUIREMENTS.md should be written to disk");
+      const row = _getAdapter()!
+        .prepare("SELECT id, class, description FROM requirements WHERE description = ?")
+        .get("Inline MCP requirement save regression") as Record<string, unknown> | undefined;
+      assert.ok(row, "requirement should be written to the database");
+      assert.equal(row["class"], "operability");
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  it("gsd_plan_task reopens the DB before inline task planning writes", async () => {
+    const base = makeTmpBase();
+    try {
+      const server = makeMockServer();
+      registerWorkflowTools(server as any);
+      const milestoneTool = server.tools.find((t) => t.name === "gsd_plan_milestone");
+      const sliceTool = server.tools.find((t) => t.name === "gsd_plan_slice");
+      const taskTool = server.tools.find((t) => t.name === "gsd_plan_task");
+      assert.ok(milestoneTool, "milestone planning tool should be registered");
+      assert.ok(sliceTool, "slice planning tool should be registered");
+      assert.ok(taskTool, "task planning tool should be registered");
+
+      await milestoneTool!.handler({
+        projectDir: base,
+        milestoneId: "M010",
+        title: "Inline task planning DB reopen",
+        vision: "Seed a slice, close the DB, then plan another task inline.",
+        slices: [
+          {
+            sliceId: "S10",
+            title: "Inline task planning",
+            risk: "medium",
+            depends: [],
+            demo: "Inline gsd_plan_task reopens the DB after it was closed.",
+            goal: "Preserve MCP task planning after the DB adapter is closed.",
+            successCriteria: "The second task plan persists after a closed DB is reopened.",
+            proofLevel: "integration",
+            integrationClosure: "The inline MCP handler reopens the DB before planning.",
+            observabilityImpact: "workflow-tools MCP tests cover the inline reopen path.",
+          },
+        ],
+      });
+      await sliceTool!.handler({
+        projectDir: base,
+        milestoneId: "M010",
+        sliceId: "S10",
+        goal: "Create the initial slice plan before closing the DB.",
+        tasks: [
+          {
+            taskId: "T10",
+            title: "Seed existing task",
+            description: "Create the initial task plan before closing the DB.",
+            estimate: "5m",
+            files: ["packages/mcp-server/src/workflow-tools.ts"],
+            verify: "node --test",
+            inputs: ["M010-ROADMAP.md"],
+            expectedOutput: ["T10-PLAN.md"],
+          },
+        ],
+      });
+
+      closeDatabase();
+
+      const result = await taskTool!.handler({
+        projectDir: base,
+        milestoneId: "M010",
+        sliceId: "S10",
+        taskId: "T11",
+        title: "Reopen and plan",
+        description: "Exercise the inline plan-task path after the DB was closed.",
+        estimate: "5m",
+        files: ["packages/mcp-server/src/workflow-tools.ts"],
+        verify: "node --test",
+        inputs: ["M010-ROADMAP.md", "S10-PLAN.md"],
+        expectedOutput: ["T11-PLAN.md"],
+      });
+
+      assert.match((result as any).content[0].text as string, /Planned task T11/);
+      assert.ok(
+        existsSync(join(base, ".gsd", "milestones", "M010", "slices", "S10", "tasks", "T11-PLAN.md")),
+        "T11 plan should be written after reopening the DB",
+      );
+    } finally {
+      cleanup(base);
+    }
+  });
+
   it("gsd_replan_slice and gsd_slice_replan work end-to-end", async () => {
     const base = makeTmpBase();
     try {

package/packages/mcp-server/src/workflow-tools.ts

@@ -244,6 +244,10 @@ type WorkflowWriteGateModule = {
   ) => { block: boolean; reason?: string };
 };
 
+type WorkflowDbBootstrapModule = {
+  ensureDbOpen: (basePath?: string) => Promise<boolean>;
+};
+
 let workflowToolExecutorsPromise: Promise<WorkflowToolExecutors> | null = null;
 let workflowExecutionQueue: Promise<void> = Promise.resolve();
 let workflowWriteGatePromise: Promise<WorkflowWriteGateModule> | null = null;
@@ -506,6 +510,22 @@ async function runSerializedWorkflowOperation<T>(fn: () => Promise<T>): Promise<
   }
 }
 
+async function runSerializedWorkflowDbOperation<T>(
+  projectDir: string,
+  fn: () => Promise<T>,
+): Promise<T> {
+  return runSerializedWorkflowOperation(async () => {
+    const { ensureDbOpen } = await importLocalModule<WorkflowDbBootstrapModule>(
+      "../../../src/resources/extensions/gsd/bootstrap/dynamic-tools.js",
+    );
+    const dbAvailable = await ensureDbOpen(projectDir);
+    if (!dbAvailable) {
+      throw new Error("GSD database is not available");
+    }
+    return fn();
+  });
+}
+
 async function enforceWorkflowWriteGate(
   toolName: string,
   projectDir: string,
@@ -767,7 +787,7 @@ const saveGateResultParams = {
   projectDir: projectDirParam,
   milestoneId: z.string().describe("Milestone ID (e.g. M001)"),
   sliceId: z.string().describe("Slice ID (e.g. S01)"),
-  gateId: z.enum(["Q3", "Q4", "Q5", "Q6", "Q7", "Q8"]).describe("Gate ID"),
+  gateId: z.enum(["Q3", "Q4", "Q5", "Q6", "Q7", "Q8", "MV01", "MV02", "MV03", "MV04"]).describe("Gate ID"),
   taskId: z.string().optional().describe("Task ID for task-scoped gates"),
   verdict: z.enum(["pass", "flag", "omitted"]).describe("Gate verdict"),
   rationale: z.string().describe("One-sentence justification"),
@@ -969,7 +989,7 @@ export function registerWorkflowTools(server: McpToolServer): void {
       const parsed = parseWorkflowArgs(decisionSaveSchema, args);
       const { projectDir, ...params } = parsed;
       await enforceWorkflowWriteGate("gsd_decision_save", projectDir);
-      const result = await runSerializedWorkflowOperation(async () => {
+      const result = await runSerializedWorkflowDbOperation(projectDir, async () => {
         const { saveDecisionToDb } = await importLocalModule<any>("../../../src/resources/extensions/gsd/db-writer.js");
         return saveDecisionToDb(params, projectDir);
       });
@@ -985,7 +1005,7 @@ export function registerWorkflowTools(server: McpToolServer): void {
       const parsed = parseWorkflowArgs(decisionSaveSchema, args);
       const { projectDir, ...params } = parsed;
       await enforceWorkflowWriteGate("gsd_decision_save", projectDir);
-      const result = await runSerializedWorkflowOperation(async () => {
+      const result = await runSerializedWorkflowDbOperation(projectDir, async () => {
         const { saveDecisionToDb } = await importLocalModule<any>("../../../src/resources/extensions/gsd/db-writer.js");
         return saveDecisionToDb(params, projectDir);
       });
@@ -1001,7 +1021,7 @@ export function registerWorkflowTools(server: McpToolServer): void {
       const parsed = parseWorkflowArgs(requirementUpdateSchema, args);
       const { projectDir, id, ...updates } = parsed;
       await enforceWorkflowWriteGate("gsd_requirement_update", projectDir);
-      await runSerializedWorkflowOperation(async () => {
+      await runSerializedWorkflowDbOperation(projectDir, async () => {
         const { updateRequirementInDb } = await importLocalModule<any>("../../../src/resources/extensions/gsd/db-writer.js");
         return updateRequirementInDb(id, updates, projectDir);
       });
@@ -1017,7 +1037,7 @@ export function registerWorkflowTools(server: McpToolServer): void {
       const parsed = parseWorkflowArgs(requirementUpdateSchema, args);
       const { projectDir, id, ...updates } = parsed;
       await enforceWorkflowWriteGate("gsd_requirement_update", projectDir);
-      await runSerializedWorkflowOperation(async () => {
+      await runSerializedWorkflowDbOperation(projectDir, async () => {
         const { updateRequirementInDb } = await importLocalModule<any>("../../../src/resources/extensions/gsd/db-writer.js");
         return updateRequirementInDb(id, updates, projectDir);
       });
@@ -1033,7 +1053,7 @@ export function registerWorkflowTools(server: McpToolServer): void {
       const parsed = parseWorkflowArgs(requirementSaveSchema, args);
       const { projectDir, ...params } = parsed;
       await enforceWorkflowWriteGate("gsd_requirement_save", projectDir);
-      const result = await runSerializedWorkflowOperation(async () => {
+      const result = await runSerializedWorkflowDbOperation(projectDir, async () => {
         const { saveRequirementToDb } = await importLocalModule<any>("../../../src/resources/extensions/gsd/db-writer.js");
         return saveRequirementToDb(params, projectDir);
       });
@@ -1049,7 +1069,7 @@ export function registerWorkflowTools(server: McpToolServer): void {
       const parsed = parseWorkflowArgs(requirementSaveSchema, args);
       const { projectDir, ...params } = parsed;
       await enforceWorkflowWriteGate("gsd_requirement_save", projectDir);
-      const result = await runSerializedWorkflowOperation(async () => {
+      const result = await runSerializedWorkflowDbOperation(projectDir, async () => {
         const { saveRequirementToDb } = await importLocalModule<any>("../../../src/resources/extensions/gsd/db-writer.js");
         return saveRequirementToDb(params, projectDir);
       });
@@ -1064,7 +1084,7 @@ export function registerWorkflowTools(server: McpToolServer): void {
     async (args: Record<string, unknown>) => {
       const { projectDir } = parseWorkflowArgs(milestoneGenerateIdSchema, args);
       await enforceWorkflowWriteGate("gsd_milestone_generate_id", projectDir);
-      const id = await runSerializedWorkflowOperation(async () => {
+      const id = await runSerializedWorkflowDbOperation(projectDir, async () => {
         const {
           claimReservedId,
           findMilestoneIds,
@@ -1092,7 +1112,7 @@ export function registerWorkflowTools(server: McpToolServer): void {
     async (args: Record<string, unknown>) => {
       const { projectDir } = parseWorkflowArgs(milestoneGenerateIdSchema, args);
       await enforceWorkflowWriteGate("gsd_milestone_generate_id", projectDir);
-      const id = await runSerializedWorkflowOperation(async () => {
+      const id = await runSerializedWorkflowDbOperation(projectDir, async () => {
         const {
           claimReservedId,
           findMilestoneIds,
@@ -1147,7 +1167,7 @@ export function registerWorkflowTools(server: McpToolServer): void {
       const parsed = parseWorkflowArgs(planTaskSchema, args);
       const { projectDir, ...params } = parsed;
       await enforceWorkflowWriteGate("gsd_plan_task", projectDir, params.milestoneId);
-      const result = await runSerializedWorkflowOperation(async () => {
+      const result = await runSerializedWorkflowDbOperation(projectDir, async () => {
         const { handlePlanTask } = await importLocalModule<any>("../../../src/resources/extensions/gsd/tools/plan-task.js");
         return handlePlanTask(params, projectDir);
       });
@@ -1168,7 +1188,7 @@ export function registerWorkflowTools(server: McpToolServer): void {
       const parsed = parseWorkflowArgs(planTaskSchema, args);
       const { projectDir, ...params } = parsed;
       await enforceWorkflowWriteGate("gsd_plan_task", projectDir, params.milestoneId);
-      const result = await runSerializedWorkflowOperation(async () => {
+      const result = await runSerializedWorkflowDbOperation(projectDir, async () => {
         const { handlePlanTask } = await importLocalModule<any>("../../../src/resources/extensions/gsd/tools/plan-task.js");
         return handlePlanTask(params, projectDir);
       });
@@ -1228,7 +1248,7 @@ export function registerWorkflowTools(server: McpToolServer): void {
     async (args: Record<string, unknown>) => {
       const { projectDir, milestoneId, sliceId, reason } = parseWorkflowArgs(skipSliceSchema, args);
       await enforceWorkflowWriteGate("gsd_skip_slice", projectDir, milestoneId);
-      await runSerializedWorkflowOperation(async () => {
+      await runSerializedWorkflowDbOperation(projectDir, async () => {
         const { getSlice, updateSliceStatus } = await importLocalModule<any>("../../../src/resources/extensions/gsd/gsd-db.js");
         const { invalidateStateCache } = await importLocalModule<any>("../../../src/resources/extensions/gsd/state.js");
         const { rebuildState } = await importLocalModule<any>("../../../src/resources/extensions/gsd/doctor.js");

package/packages/pi-ai/dist/providers/amazon-bedrock.js

@@ -84,7 +84,7 @@ export const streamBedrock = (model, context, options = {}) => {
                 messages: convertMessages(context, model, cacheRetention),
                 system: buildSystemPrompt(context.systemPrompt, model, cacheRetention),
                 inferenceConfig: { maxTokens: options.maxTokens, temperature: options.temperature },
-                toolConfig: convertToolConfig(context.tools, options.toolChoice),
+                toolConfig: convertToolConfig(context.tools, options.toolChoice, model, cacheRetention),
                 additionalModelRequestFields: buildAdditionalModelRequestFields(model, options),
             };
             const nextCommandInput = await options?.onPayload?.(commandInput, model);
@@ -497,7 +497,7 @@ function convertMessages(context, model, cacheRetention) {
     }
     return result;
 }
-function convertToolConfig(tools, toolChoice) {
+function convertToolConfig(tools, toolChoice, model, cacheRetention) {
     if (!tools?.length || toolChoice === "none")
         return undefined;
     const bedrockTools = tools.map((tool) => ({
@@ -507,6 +507,15 @@ function convertToolConfig(tools, toolChoice) {
             inputSchema: { json: tool.parameters },
         },
     }));
+    // Add cachePoint after last tool for supported models
+    if (cacheRetention !== "none" && supportsPromptCaching(model)) {
+        bedrockTools.push({
+            cachePoint: {
+                type: CachePointType.DEFAULT,
+                ...(cacheRetention === "long" ? { ttl: CacheTTL.ONE_HOUR } : {}),
+            },
+        });
+    }
     let bedrockToolChoice;
     switch (toolChoice) {
         case "auto":