gsd-pi 2.44.0-dev.0b97ffd → 2.44.0-dev.73f2fd5

package/src/resources/extensions/gsd/tests/mcp-status.test.ts

@@ -0,0 +1,103 @@
+import test, { describe } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  formatMcpStatusReport,
+  formatMcpServerDetail,
+  type McpServerStatus,
+} from "../commands-mcp-status.ts";
+
+// ─── formatMcpStatusReport ──────────────────────────────────────────────────
+
+describe("formatMcpStatusReport", () => {
+  test("returns no-servers message when list is empty", () => {
+    const result = formatMcpStatusReport([]);
+    assert.match(result, /no mcp servers configured/i);
+  });
+
+  test("lists all servers with connection status", () => {
+    const servers: McpServerStatus[] = [
+      { name: "railway", transport: "stdio", connected: true, toolCount: 5, error: undefined },
+      { name: "linear", transport: "http", connected: false, toolCount: 0, error: undefined },
+    ];
+    const result = formatMcpStatusReport(servers);
+    assert.match(result, /railway/);
+    assert.match(result, /linear/);
+    assert.match(result, /connected/i);
+    assert.match(result, /disconnected/i);
+    assert.match(result, /5 tools/);
+  });
+
+  test("shows error state for servers with errors", () => {
+    const servers: McpServerStatus[] = [
+      { name: "broken", transport: "stdio", connected: false, toolCount: 0, error: "Connection refused" },
+    ];
+    const result = formatMcpStatusReport(servers);
+    assert.match(result, /error/i);
+    assert.match(result, /Connection refused/);
+  });
+
+  test("includes server count in header", () => {
+    const servers: McpServerStatus[] = [
+      { name: "a", transport: "stdio", connected: true, toolCount: 3, error: undefined },
+      { name: "b", transport: "http", connected: true, toolCount: 2, error: undefined },
+    ];
+    const result = formatMcpStatusReport(servers);
+    assert.match(result, /2/);
+  });
+});
+
+// ─── formatMcpServerDetail ──────────────────────────────────────────────────
+
+describe("formatMcpServerDetail", () => {
+  test("shows server name and transport", () => {
+    const result = formatMcpServerDetail({
+      name: "railway",
+      transport: "stdio",
+      connected: true,
+      toolCount: 3,
+      tools: ["railway_list_projects", "railway_deploy", "railway_logs"],
+      error: undefined,
+    });
+    assert.match(result, /railway/);
+    assert.match(result, /stdio/);
+  });
+
+  test("lists individual tools when available", () => {
+    const result = formatMcpServerDetail({
+      name: "railway",
+      transport: "stdio",
+      connected: true,
+      toolCount: 2,
+      tools: ["railway_list_projects", "railway_deploy"],
+      error: undefined,
+    });
+    assert.match(result, /railway_list_projects/);
+    assert.match(result, /railway_deploy/);
+  });
+
+  test("shows error message for failed servers", () => {
+    const result = formatMcpServerDetail({
+      name: "broken",
+      transport: "stdio",
+      connected: false,
+      toolCount: 0,
+      tools: [],
+      error: "spawn ENOENT",
+    });
+    assert.match(result, /error/i);
+    assert.match(result, /spawn ENOENT/);
+  });
+
+  test("shows disconnected status with no tools", () => {
+    const result = formatMcpServerDetail({
+      name: "offline",
+      transport: "http",
+      connected: false,
+      toolCount: 0,
+      tools: [],
+      error: undefined,
+    });
+    assert.match(result, /disconnected/i);
+  });
+});

package/src/resources/extensions/gsd/tests/merge-conflict-stops-loop.test.ts

@@ -0,0 +1,66 @@
+/**
+ * merge-conflict-stops-loop.test.ts — #2330
+ *
+ * When a squash merge has real code conflicts (not just .gsd/ files),
+ * the merge retries forever because MergeConflictError is caught
+ * silently in mergeAndExit. This test verifies that:
+ * 1. worktree-resolver re-throws MergeConflictError for code conflicts
+ * 2. auto/phases.ts wraps mergeAndExit calls to stop the loop on conflict
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertTrue, report } = createTestContext();
+
+const resolverPath = join(import.meta.dirname, "..", "worktree-resolver.ts");
+const resolverSrc = readFileSync(resolverPath, "utf-8");
+
+const phasesPath = join(import.meta.dirname, "..", "auto", "phases.ts");
+const phasesSrc = readFileSync(phasesPath, "utf-8");
+
+console.log("\n=== #2330: Merge conflict stops auto loop ===");
+
+// ── Test 1: worktree-resolver re-throws MergeConflictError ──────────────
+
+const methodStart = resolverSrc.indexOf("Worktree-mode merge:");
+assertTrue(methodStart > 0, "worktree-resolver has _mergeWorktreeMode method");
+
+const methodBody = resolverSrc.slice(methodStart, methodStart + 5000);
+const rethrowsConflict =
+  methodBody.includes("MergeConflictError") &&
+  methodBody.includes("throw err");
+
+assertTrue(
+  rethrowsConflict,
+  "worktree-resolver._mergeWorktreeMode re-throws MergeConflictError (#2330)",
+);
+
+// ── Test 2: auto/phases.ts imports and uses MergeConflictError ──────────
+
+assertTrue(
+  phasesSrc.includes("MergeConflictError") && phasesSrc.includes("mergeAndExit"),
+  "auto/phases.ts handles MergeConflictError from mergeAndExit (#2330)",
+);
+
+// ── Test 3: The handler stops the loop (doesn't just warn) ──────────────
+
+// Find the instanceof MergeConflictError check (not the import line)
+const instanceofIdx = phasesSrc.indexOf("instanceof MergeConflictError");
+assertTrue(instanceofIdx > 0, "auto/phases.ts has instanceof MergeConflictError check");
+
+if (instanceofIdx > 0) {
+  const afterHandler = phasesSrc.slice(instanceofIdx, instanceofIdx + 500);
+  const stopsLoop =
+    afterHandler.includes("stopAuto") ||
+    afterHandler.includes('action: "break"') ||
+    afterHandler.includes("reason: \"merge-conflict\"");
+
+  assertTrue(
+    stopsLoop,
+    "auto/phases.ts stops the loop when merge conflict is detected (#2330)",
+  );
+}
+
+report();

package/src/resources/extensions/gsd/tests/preferences.test.ts

@@ -15,6 +15,7 @@ import {
   applyModeDefaults,
   getIsolationMode,
   parsePreferencesMarkdown,
+  _resetParseWarningFlag,
 } from "../preferences.ts";
 import type { GSDPreferences, GSDModelConfigV2, GSDPhaseModelConfig } from "../preferences.ts";
 
@@ -352,3 +353,29 @@ test("handles empty models config", () => {
   assert.notEqual(prefs, null);
   assert.equal(prefs!.models, undefined);
 });
+
+// ── Warn-once for unrecognized format (#2373) ────────────────────────────────
+
+test("unrecognized format warning is emitted at most once (#2373)", () => {
+  const warnings: string[] = [];
+  const origWarn = console.warn;
+  console.warn = (...args: unknown[]) => warnings.push(args.join(" "));
+  try {
+    // Reset internal warned flag so the test starts clean
+    _resetParseWarningFlag();
+
+    const unrecognized = "This is just plain text with no frontmatter or headings.";
+
+    // Call multiple times — simulates repeated preference loads
+    parsePreferencesMarkdown(unrecognized);
+    parsePreferencesMarkdown(unrecognized);
+    parsePreferencesMarkdown(unrecognized);
+
+    const relevant = warnings.filter(w => w.includes("unrecognized format"));
+    assert.equal(relevant.length, 1, `expected exactly 1 warning, got ${relevant.length}: ${JSON.stringify(relevant)}`);
+  } finally {
+    console.warn = origWarn;
+    // Reset so other tests aren't affected by the flag state
+    _resetParseWarningFlag();
+  }
+});

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -147,12 +147,12 @@ test("plan-slice prompt no longer frames direct PLAN writes as the source of tru
   assert.match(prompt, /Do \*\*not\*\* rely on direct `PLAN\.md` writes as the source of truth/i);
 });
 
-test("plan-slice prompt explicitly names gsd_plan_slice and gsd_plan_task as DB-backed planning tools", () => {
+test("plan-slice prompt explicitly names gsd_plan_slice as DB-backed planning tool", () => {
   const prompt = readPrompt("plan-slice");
   assert.match(prompt, /gsd_plan_slice/);
   assert.match(prompt, /gsd_plan_task/);
-  // The prompt should describe these as the canonical write path
-  assert.match(prompt, /DB-backed tools are the canonical write path/i);
+  // The prompt should describe the DB-backed tool as the canonical write path
+  assert.match(prompt, /DB-backed tool is the canonical write path/i);
 });
 
 test("plan-slice prompt does not instruct direct file writes as a primary step", () => {
@@ -161,14 +161,18 @@ test("plan-slice prompt does not instruct direct file writes as a primary step",
   assert.doesNotMatch(prompt, /^\d+\.\s+Write `?\{\{outputPath\}\}`?\s*$/m);
 });
 
-test("plan-slice prompt instructs calling gsd_plan_task for each task", () => {
+test("plan-slice prompt clarifies gsd_plan_slice handles task persistence", () => {
   const prompt = readPrompt("plan-slice");
-  assert.match(prompt, /call `gsd_plan_task` for each task/i);
+  // gsd_plan_slice persists tasks in its transaction — no separate gsd_plan_task calls needed
+  assert.match(prompt, /gsd_plan_task/);
+  assert.match(prompt, /gsd_plan_slice` handles task persistence/i);
 });
 
-test("replan-slice prompt requires DB-backed planning state when available", () => {
+test("replan-slice prompt uses gsd_replan_slice as canonical DB-backed tool", () => {
   const prompt = readPrompt("replan-slice");
-  assert.match(prompt, /DB-backed planning tool exists for this phase, use it as the source of truth/i);
+  assert.match(prompt, /gsd_replan_slice/);
+  // Degraded fallback (direct file writes) was removed — DB tools are always available
+  assert.doesNotMatch(prompt, /Degraded fallback/i);
 });
 
 test("reassess-roadmap prompt references gsd_reassess_roadmap tool", () => {

package/src/resources/extensions/gsd/tests/stop-auto-merge-back.test.ts

@@ -0,0 +1,67 @@
+/**
+ * stop-auto-merge-back.test.ts — Regression test for #2317.
+ *
+ * When auto-mode stops after a milestone is complete, stopAuto should trigger
+ * merge-back (mergeAndExit) instead of just exiting the worktree with
+ * preserveBranch: true. Otherwise milestone code stays stranded on the
+ * worktree branch and never reaches main.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// ─── Source analysis: stopAuto calls mergeAndExit for complete milestones ────
+
+const autoSrcPath = join(import.meta.dirname, "..", "auto.ts");
+const autoSrc = readFileSync(autoSrcPath, "utf-8");
+
+test("#2317: stopAuto should check milestone completion status before choosing exit strategy", () => {
+  // stopAuto Step 4 should NOT unconditionally call exitMilestone(preserveBranch: true).
+  // It should check if the milestone is complete and call mergeAndExit instead.
+
+  // Find the Step 4 section
+  const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
+  assert.ok(step4Idx !== -1, "Step 4 comment exists in stopAuto");
+
+  // Extract a reasonable window around Step 4 (up to Step 5)
+  const step5Idx = autoSrc.indexOf("Step 5:", step4Idx);
+  const step4Block = autoSrc.slice(step4Idx, step5Idx);
+
+  // The fix: Step 4 should call mergeAndExit when milestone is complete
+  assert.ok(
+    step4Block.includes("mergeAndExit"),
+    "Step 4 should call mergeAndExit for completed milestones",
+  );
+});
+
+test("#2317: stopAuto should detect milestone completion via SUMMARY file or DB", () => {
+  const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
+  const step5Idx = autoSrc.indexOf("Step 5:", step4Idx);
+  const step4Block = autoSrc.slice(step4Idx, step5Idx);
+
+  // Should check completion status — either via SUMMARY file, DB getMilestone, or phase
+  const checksCompletion =
+    step4Block.includes("SUMMARY") ||
+    step4Block.includes("getMilestone") ||
+    step4Block.includes("complete") ||
+    step4Block.includes("isMilestoneComplete");
+
+  assert.ok(
+    checksCompletion,
+    "Step 4 should check if milestone is complete before deciding exit strategy",
+  );
+});
+
+test("#2317: stopAuto still preserves branch for incomplete milestones", () => {
+  const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
+  const step5Idx = autoSrc.indexOf("Step 5:", step4Idx);
+  const step4Block = autoSrc.slice(step4Idx, step5Idx);
+
+  // preserveBranch should still be used as fallback for non-complete milestones
+  assert.ok(
+    step4Block.includes("preserveBranch"),
+    "Step 4 should still preserve branch for incomplete milestones (fallback path)",
+  );
+});

package/src/resources/extensions/gsd/tests/terminated-transient.test.ts

@@ -0,0 +1,49 @@
+/**
+ * terminated-transient.test.ts — Regression test for #2309.
+ *
+ * classifyProviderError should treat 'terminated' errors (process killed,
+ * connection reset) as transient with auto-resume, not permanent.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { classifyProviderError } from "../provider-error-pause.ts";
+
+test("#2309: 'terminated' errors should be classified as transient", () => {
+  const result = classifyProviderError("terminated");
+  assert.equal(result.isTransient, true, "'terminated' should be transient");
+  assert.equal(result.isRateLimit, false, "'terminated' is not a rate limit");
+  assert.ok(result.suggestedDelayMs > 0, "'terminated' should have a retry delay");
+});
+
+test("#2309: 'connection reset' errors should be classified as transient", () => {
+  const result = classifyProviderError("connection reset by peer");
+  assert.equal(result.isTransient, true, "'connection reset' should be transient");
+});
+
+test("#2309: 'other side closed' errors should be classified as transient", () => {
+  const result = classifyProviderError("other side closed the connection");
+  assert.equal(result.isTransient, true, "'other side closed' should be transient");
+});
+
+test("#2309: 'fetch failed' errors should be classified as transient", () => {
+  const result = classifyProviderError("fetch failed: network error");
+  assert.equal(result.isTransient, true, "'fetch failed' should be transient");
+});
+
+test("#2309: 'connection refused' errors should be classified as transient", () => {
+  const result = classifyProviderError("ECONNREFUSED: connection refused");
+  assert.equal(result.isTransient, true, "'connection refused' should be transient");
+});
+
+test("#2309: permanent errors are still permanent", () => {
+  const authResult = classifyProviderError("unauthorized: invalid API key");
+  assert.equal(authResult.isTransient, false, "auth errors should stay permanent");
+  assert.equal(authResult.suggestedDelayMs, 0, "permanent errors have no delay");
+});
+
+test("#2309: rate limits are still transient", () => {
+  const rlResult = classifyProviderError("rate limit exceeded (429)");
+  assert.equal(rlResult.isTransient, true, "rate limits are still transient");
+  assert.equal(rlResult.isRateLimit, true, "rate limits are flagged as rate limits");
+});

package/src/resources/extensions/gsd/tests/tool-naming.test.ts

@@ -34,6 +34,7 @@ const RENAME_MAP: Array<{ canonical: string; alias: string }> = [
   { canonical: "gsd_replan_slice", alias: "gsd_slice_replan" },
   { canonical: "gsd_reassess_roadmap", alias: "gsd_roadmap_reassess" },
   { canonical: "gsd_complete_milestone", alias: "gsd_milestone_complete" },
+  { canonical: "gsd_validate_milestone", alias: "gsd_milestone_validate" },
 ];
 
 // ─── Registration count ──────────────────────────────────────────────────────
@@ -43,7 +44,7 @@ console.log('\n── Tool naming: registration count ──');
 const pi = makeMockPi();
 registerDbTools(pi);
 
-assert.deepStrictEqual(pi.tools.length, 24, 'Should register exactly 24 tools (12 canonical + 12 aliases)');
+assert.deepStrictEqual(pi.tools.length, 26, 'Should register exactly 26 tools (13 canonical + 13 aliases)');
 
 // ─── Both names exist for each pair ──────────────────────────────────────────
 

package/src/resources/extensions/gsd/tools/plan-slice.ts

@@ -20,6 +20,7 @@ export interface PlanSliceTaskInput {
   inputs: string[];
   expectedOutput: string[];
   observabilityImpact?: string;
+  fullPlanMd?: string;
 }
 
 export interface PlanSliceParams {
@@ -167,6 +168,7 @@ export async function handlePlanSlice(
           inputs: task.inputs,
           expectedOutput: task.expectedOutput,
           observabilityImpact: task.observabilityImpact ?? "",
+          fullPlanMd: task.fullPlanMd,
         });
       }
     });

package/src/resources/extensions/gsd/tools/plan-task.ts

@@ -15,6 +15,7 @@ export interface PlanTaskParams {
   inputs: string[];
   expectedOutput: string[];
   observabilityImpact?: string;
+  fullPlanMd?: string;
 }
 
 export interface PlanTaskResult {
@@ -94,6 +95,7 @@ export async function handlePlanTask(
         inputs: params.inputs,
         expectedOutput: params.expectedOutput,
         observabilityImpact: params.observabilityImpact ?? "",
+        fullPlanMd: params.fullPlanMd,
       });
     });
   } catch (err) {

package/src/resources/extensions/gsd/tools/replan-slice.ts

@@ -21,6 +21,7 @@ export interface ReplanSliceTaskInput {
   verify: string;
   inputs: string[];
   expectedOutput: string[];
+  fullPlanMd?: string;
 }
 
 export interface ReplanSliceParams {
@@ -136,6 +137,7 @@ export async function handleReplanSlice(
             verify: updatedTask.verify || "",
             inputs: updatedTask.inputs || [],
             expectedOutput: updatedTask.expectedOutput || [],
+            fullPlanMd: updatedTask.fullPlanMd,
           });
         } else {
           // Insert new task then set planning fields
@@ -154,6 +156,7 @@ export async function handleReplanSlice(
             verify: updatedTask.verify || "",
             inputs: updatedTask.inputs || [],
             expectedOutput: updatedTask.expectedOutput || [],
+            fullPlanMd: updatedTask.fullPlanMd,
           });
         }
       }

package/src/resources/extensions/gsd/tools/validate-milestone.ts

@@ -0,0 +1,127 @@
+/**
+ * validate-milestone handler — the core operation behind gsd_validate_milestone.
+ *
+ * Persists milestone validation results to the assessments table,
+ * renders VALIDATION.md to disk, and invalidates caches.
+ */
+
+import { join } from "node:path";
+
+import {
+  transaction,
+  _getAdapter,
+} from "../gsd-db.js";
+import { resolveMilestonePath, clearPathCache } from "../paths.js";
+import { saveFile, clearParseCache } from "../files.js";
+import { invalidateStateCache } from "../state.js";
+
+export interface ValidateMilestoneParams {
+  milestoneId: string;
+  verdict: "pass" | "needs-attention" | "needs-remediation";
+  remediationRound: number;
+  successCriteriaChecklist: string;
+  sliceDeliveryAudit: string;
+  crossSliceIntegration: string;
+  requirementCoverage: string;
+  verdictRationale: string;
+  remediationPlan?: string;
+}
+
+export interface ValidateMilestoneResult {
+  milestoneId: string;
+  verdict: string;
+  validationPath: string;
+}
+
+function renderValidationMarkdown(params: ValidateMilestoneParams): string {
+  let md = `---
+verdict: ${params.verdict}
+remediation_round: ${params.remediationRound}
+---
+
+# Milestone Validation: ${params.milestoneId}
+
+## Success Criteria Checklist
+${params.successCriteriaChecklist}
+
+## Slice Delivery Audit
+${params.sliceDeliveryAudit}
+
+## Cross-Slice Integration
+${params.crossSliceIntegration}
+
+## Requirement Coverage
+${params.requirementCoverage}
+
+## Verdict Rationale
+${params.verdictRationale}
+`;
+
+  if (params.verdict === "needs-remediation" && params.remediationPlan) {
+    md += `\n## Remediation Plan\n${params.remediationPlan}\n`;
+  }
+
+  return md;
+}
+
+export async function handleValidateMilestone(
+  params: ValidateMilestoneParams,
+  basePath: string,
+): Promise<ValidateMilestoneResult | { error: string }> {
+  if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
+    return { error: "milestoneId is required and must be a non-empty string" };
+  }
+  const validVerdicts = ["pass", "needs-attention", "needs-remediation"];
+  if (!validVerdicts.includes(params.verdict)) {
+    return { error: `verdict must be one of: ${validVerdicts.join(", ")}` };
+  }
+
+  // ── Filesystem render ──────────────────────────────────────────────────
+  const validationMd = renderValidationMarkdown(params);
+
+  let validationPath: string;
+  const milestoneDir = resolveMilestonePath(basePath, params.milestoneId);
+  if (milestoneDir) {
+    validationPath = join(milestoneDir, `${params.milestoneId}-VALIDATION.md`);
+  } else {
+    const gsdDir = join(basePath, ".gsd");
+    const manualDir = join(gsdDir, "milestones", params.milestoneId);
+    validationPath = join(manualDir, `${params.milestoneId}-VALIDATION.md`);
+  }
+
+  try {
+    await saveFile(validationPath, validationMd);
+  } catch (renderErr) {
+    process.stderr.write(
+      `gsd-db: validate_milestone — disk render failed: ${(renderErr as Error).message}\n`,
+    );
+    return { error: `disk render failed: ${(renderErr as Error).message}` };
+  }
+
+  // ── DB write — store in assessments table ──────────────────────────────
+  const validatedAt = new Date().toISOString();
+
+  transaction(() => {
+    const adapter = _getAdapter()!;
+    adapter.prepare(
+      `INSERT OR REPLACE INTO assessments (path, milestone_id, slice_id, task_id, status, scope, full_content, created_at)
+       VALUES (:path, :mid, NULL, NULL, :verdict, 'milestone-validation', :content, :created_at)`,
+    ).run({
+      ":path": validationPath,
+      ":mid": params.milestoneId,
+      ":verdict": params.verdict,
+      ":content": validationMd,
+      ":created_at": validatedAt,
+    });
+  });
+
+  invalidateStateCache();
+  clearPathCache();
+  clearParseCache();
+
+  return {
+    milestoneId: params.milestoneId,
+    verdict: params.verdict,
+    validationPath,
+  };
+}

package/src/resources/extensions/gsd/worktree-resolver.ts

@@ -17,6 +17,7 @@ import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import type { AutoSession } from "./auto/session.js";
 import { debugLog } from "./debug-logger.js";
+import { MergeConflictError } from "./git-service.js";
 
 // ─── Dependency Interface ──────────────────────────────────────────────────
 
@@ -433,6 +434,12 @@ export class WorktreeResolver {
           /* best-effort */
         }
       }
+
+      // Re-throw MergeConflictError so the auto loop can detect real code
+      // conflicts and stop instead of retrying forever (#2330).
+      if (err instanceof MergeConflictError) {
+        throw err;
+      }
     }
 
     // Always restore basePath and rebuild — whether merge succeeded or failed

package/src/resources/extensions/mcp-client/index.ts

@@ -213,6 +213,26 @@ function formatToolList(serverName: string, tools: McpToolSchema[]): string {
 	return lines.join("\n");
 }
 
+// ─── Status helper (consumed by /gsd mcp) ─────────────────────────────────────
+
+/**
+ * Return the live connection status for a named MCP server.
+ * Safe to call even when the server has never been connected.
+ */
+export function getConnectionStatus(name: string): {
+	connected: boolean;
+	tools: string[];
+	error?: string;
+} {
+	const conn = connections.get(name);
+	const cached = toolCache.get(name);
+	return {
+		connected: !!conn,
+		tools: cached ? cached.map((t) => t.name) : [],
+		error: undefined,
+	};
+}
+
 // ─── Extension ────────────────────────────────────────────────────────────────
 
 export default function (pi: ExtensionAPI) {