gsd-pi 2.63.0 → 2.64.0-dev.9c14bd0

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

@@ -0,0 +1,201 @@
+// GSD2 — Tests for gsd_milestone_status read-only query tool
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import { registerQueryTools } from "../bootstrap/query-tools.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  _getAdapter,
+} from "../gsd-db.ts";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function makeMockPi() {
+  const tools: any[] = [];
+  return {
+    registerTool: (tool: any) => tools.push(tool),
+    tools,
+  } as any;
+}
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-query-tool-test-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* swallow */ }
+}
+
+function openTestDb(base: string): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+}
+
+async function executeToolInDir(tool: any, params: Record<string, unknown>, dir: string) {
+  const originalCwd = process.cwd();
+  try {
+    process.chdir(dir);
+    return await tool.execute("test-call-id", params, undefined, undefined, undefined);
+  } finally {
+    process.chdir(originalCwd);
+  }
+}
+
+// ─── Seed helpers ─────────────────────────────────────────────────────────────
+
+function seedMilestone(milestoneId: string, title: string, status = "active"): void {
+  const db = _getAdapter();
+  if (!db) throw new Error("DB not open");
+  db.prepare(
+    "INSERT OR REPLACE INTO milestones (id, title, status, created_at) VALUES (?, ?, ?, ?)",
+  ).run(milestoneId, title, status, new Date().toISOString());
+}
+
+function seedSlice(milestoneId: string, sliceId: string, status: string): void {
+  const db = _getAdapter();
+  if (!db) throw new Error("DB not open");
+  db.prepare(
+    "INSERT OR REPLACE INTO slices (milestone_id, id, title, status, created_at) VALUES (?, ?, ?, ?, ?)",
+  ).run(milestoneId, sliceId, `Slice ${sliceId}`, status, new Date().toISOString());
+}
+
+function seedTask(milestoneId: string, sliceId: string, taskId: string, status: string): void {
+  const db = _getAdapter();
+  if (!db) throw new Error("DB not open");
+  db.prepare(
+    "INSERT OR REPLACE INTO tasks (milestone_id, slice_id, id, title, status) VALUES (?, ?, ?, ?, ?)",
+  ).run(milestoneId, sliceId, taskId, `Task ${taskId}`, status);
+}
+
+// ─── Registration ─────────────────────────────────────────────────────────────
+
+test("registerQueryTools registers gsd_milestone_status tool", () => {
+  const pi = makeMockPi();
+  registerQueryTools(pi);
+  assert.equal(pi.tools.length, 1, "Should register exactly one tool");
+  assert.equal(pi.tools[0].name, "gsd_milestone_status");
+});
+
+test("gsd_milestone_status has promptGuidelines mentioning prohibited alternatives", () => {
+  const pi = makeMockPi();
+  registerQueryTools(pi);
+  const tool = pi.tools[0];
+  assert.ok(Array.isArray(tool.promptGuidelines), "promptGuidelines must be an array");
+  assert.ok(tool.promptGuidelines.length >= 1, "Must have at least one guideline");
+  const joined = tool.promptGuidelines.join(" ");
+  assert.match(joined, /sqlite3|better-sqlite3/, "Guidelines must mention prohibited alternatives");
+});
+
+// ─── Happy path: milestone with slices and tasks ──────────────────────────────
+
+test("gsd_milestone_status returns milestone metadata and slice statuses", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M001", "Test Milestone");
+    seedSlice("M001", "S01", "complete");
+    seedSlice("M001", "S02", "active");
+    seedTask("M001", "S01", "T01", "done");
+    seedTask("M001", "S01", "T02", "done");
+    seedTask("M001", "S02", "T01", "pending");
+
+    const pi = makeMockPi();
+    registerQueryTools(pi);
+    const tool = pi.tools[0];
+
+    const result = await executeToolInDir(tool, { milestoneId: "M001" }, base);
+    const parsed = JSON.parse(result.content[0].text);
+
+    assert.equal(parsed.milestoneId, "M001");
+    assert.equal(parsed.title, "Test Milestone");
+    assert.equal(parsed.status, "active");
+    assert.equal(parsed.sliceCount, 2);
+    assert.equal(parsed.slices.length, 2);
+
+    const s01 = parsed.slices.find((s: any) => s.id === "S01");
+    assert.ok(s01, "S01 should be in slices");
+    assert.equal(s01.status, "complete");
+    assert.equal(s01.taskCounts.total, 2);
+    assert.equal(s01.taskCounts.done, 2);
+
+    const s02 = parsed.slices.find((s: any) => s.id === "S02");
+    assert.ok(s02, "S02 should be in slices");
+    assert.equal(s02.status, "active");
+    assert.equal(s02.taskCounts.pending, 1);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+// ─── Milestone with no slices ─────────────────────────────────────────────────
+
+test("gsd_milestone_status returns empty slices array for milestone with no slices", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    seedMilestone("M002", "Empty Milestone");
+
+    const pi = makeMockPi();
+    registerQueryTools(pi);
+    const tool = pi.tools[0];
+
+    const result = await executeToolInDir(tool, { milestoneId: "M002" }, base);
+    const parsed = JSON.parse(result.content[0].text);
+
+    assert.equal(parsed.milestoneId, "M002");
+    assert.equal(parsed.sliceCount, 0);
+    assert.deepEqual(parsed.slices, []);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+// ─── Missing milestone ────────────────────────────────────────────────────────
+
+test("gsd_milestone_status returns not-found for missing milestone", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+
+    const pi = makeMockPi();
+    registerQueryTools(pi);
+    const tool = pi.tools[0];
+
+    const result = await executeToolInDir(tool, { milestoneId: "M999" }, base);
+    assert.match(result.content[0].text, /M999.*not found/i);
+    assert.equal(result.details.found, false);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+// ─── DB unavailable ───────────────────────────────────────────────────────────
+
+test("gsd_milestone_status handles missing DB gracefully", async () => {
+  // Create a directory without .gsd/ to ensure ensureDbOpen has nothing to open
+  const base = join(tmpdir(), `gsd-no-db-${randomUUID()}`);
+  mkdirSync(base, { recursive: true });
+  closeDatabase(); // ensure no prior DB is open
+  try {
+    const pi = makeMockPi();
+    registerQueryTools(pi);
+    const tool = pi.tools[0];
+
+    const result = await executeToolInDir(tool, { milestoneId: "M001" }, base);
+    assert.match(result.content[0].text, /GSD database is not available/);
+    assert.equal(result.details.error, "db_unavailable");
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/plan-milestone-title.test.ts

@@ -38,8 +38,9 @@ test("upsertMilestonePlanning updates title when DB row pre-exists with empty ti
 
     // Step 3: upsertMilestonePlanning should update the title
     upsertMilestonePlanning("M099", {
+      title: "My Important Milestone",
       vision: "Test vision",
-    }, "My Important Milestone");
+    });
     const afterUpsert = getMilestone("M099");
     assert.ok(afterUpsert);
     assert.equal(

package/src/resources/extensions/gsd/tests/plan-milestone.test.ts

@@ -4,7 +4,7 @@ import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-import { openDatabase, closeDatabase, getMilestone, getMilestoneSlices, updateSliceStatus } from '../gsd-db.ts';
+import { openDatabase, closeDatabase, getMilestone, getMilestoneSlices, getSlice, updateSliceStatus, deleteSlice, insertMilestone } from '../gsd-db.ts';
 import { handlePlanMilestone } from '../tools/plan-milestone.ts';
 import { parseRoadmap } from '../parsers-legacy.ts';
 
@@ -198,33 +198,97 @@ test('handlePlanMilestone reruns idempotently and updates existing planning stat
   }
 });
 
-// Regression: #2960 — plan-milestone must refuse to overwrite completed slices
-test('handlePlanMilestone refuses to re-plan a milestone with completed slices (#2960)', async () => {
+test('handlePlanMilestone preserves completed slice status on re-plan (#2558)', async () => {
   const base = makeTmpBase();
   const dbPath = join(base, '.gsd', 'gsd.db');
   openDatabase(dbPath);
 
   try {
-    // First plan succeeds
+    // Initial plan — both slices start as "pending"
     const first = await handlePlanMilestone(validParams(), base);
-    assert.ok(!('error' in first), `initial plan should succeed: ${'error' in first ? first.error : ''}`);
+    assert.ok(!('error' in first), `unexpected error: ${'error' in first ? first.error : ''}`);
 
-    // Mark S01 as complete
-    updateSliceStatus('M001', 'S01', 'complete');
+    // Mark S01 as complete (simulates work done in a worktree)
+    updateSliceStatus('M001', 'S01', 'complete', new Date().toISOString());
 
-    // Second plan should fail — S01 is already complete
-    const second = await handlePlanMilestone({
+    const s01Before = getSlice('M001', 'S01');
+    assert.equal(s01Before?.status, 'complete', 'S01 should be complete before re-plan');
+
+    // Re-plan the same milestone — S01 must stay "complete", S02 stays "pending"
+    const second = await handlePlanMilestone(validParams(), base);
+    assert.ok(!('error' in second), `unexpected error: ${'error' in second ? second.error : ''}`);
+
+    const s01After = getSlice('M001', 'S01');
+    assert.equal(s01After?.status, 'complete', 'S01 status must be preserved as complete after re-plan');
+
+    const s02After = getSlice('M001', 'S02');
+    assert.equal(s02After?.status, 'pending', 'S02 should remain pending');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('plan-milestone re-plan preserves completed status and updates slice fields (#2558)', async () => {
+  const base = makeTmpBase();
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+
+  try {
+    // Initial plan — both slices start as "pending"
+    const first = await handlePlanMilestone(validParams(), base);
+    assert.ok(!('error' in first), `unexpected error: ${'error' in first ? first.error : ''}`);
+
+    // Mark S01 as complete (simulates work done in worktree, then reconciled)
+    updateSliceStatus('M001', 'S01', 'complete', new Date().toISOString());
+    assert.equal(getSlice('M001', 'S01')?.status, 'complete');
+
+    // Re-plan with updated title for S01.
+    // The handler must:
+    //   1. NOT downgrade S01 from "complete" to "pending"
+    //   2. Update S01's non-status fields (title, risk, depends, demo)
+    //   3. Keep S02 as "pending"
+    const updatedParams = {
       ...validParams(),
-      vision: 'Should not overwrite',
-    }, base);
-    assert.ok('error' in second, 'should refuse to re-plan when slices are completed');
-    assert.match(second.error, /cannot re-plan/i);
-    assert.match(second.error, /S01/);
+      slices: [
+        { ...validParams().slices[0], title: 'Updated S01 title', risk: 'high' },
+        validParams().slices[1],
+      ],
+    };
+    const second = await handlePlanMilestone(updatedParams, base);
+    assert.ok(!('error' in second), `unexpected error: ${'error' in second ? second.error : ''}`);
 
-    // Verify the completed slice was not overwritten
-    const slices = getMilestoneSlices('M001');
-    const s01 = slices.find(s => s.id === 'S01');
-    assert.equal(s01?.status, 'complete', 'S01 should still be complete');
+    const s01After = getSlice('M001', 'S01');
+    assert.equal(s01After?.status, 'complete', 'completed slice status must survive re-plan');
+    assert.equal(s01After?.title, 'Updated S01 title', 'title should update on re-plan');
+    assert.equal(s01After?.risk, 'high', 'risk should update on re-plan');
+
+    const s02After = getSlice('M001', 'S02');
+    assert.equal(s02After?.status, 'pending', 'pending slice stays pending');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanMilestone promotes pre-existing queued milestone to active (#3022)', async () => {
+  const base = makeTmpBase();
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+
+  try {
+    // Simulate ensureMilestoneDbRow: pre-create row with status "queued"
+    // (this is what gsd_milestone_generate_id does)
+    insertMilestone({ id: 'M001', status: 'queued' });
+
+    const before = getMilestone('M001');
+    assert.equal(before?.status, 'queued', 'pre-condition: milestone should start as queued');
+
+    // Now plan the milestone — status should be promoted to "active"
+    const result = await handlePlanMilestone(validParams(), base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    const after = getMilestone('M001');
+    assert.equal(after?.status, 'active', 'milestone status should be promoted from queued to active');
+    assert.equal(after?.title, 'DB-backed planning', 'milestone title should be set');
   } finally {
     cleanup(base);
   }

package/src/resources/extensions/gsd/tests/post-exec-retry-bypass.test.ts

@@ -0,0 +1,312 @@
+/**
+ * post-exec-retry-bypass.test.ts — Tests for post-execution blocking failure retry bypass.
+ *
+ * Verifies that when post-execution checks fail (postExecBlockingFailure is true),
+ * the retry system is bypassed and auto-mode pauses immediately. Post-execution
+ * failures are cross-task consistency issues — retrying the same task won't fix them.
+ */
+
+import { describe, test, mock, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { tmpdir } from "node:os";
+import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+import { runPostUnitVerification, type VerificationContext } from "../auto-verification.ts";
+import { AutoSession } from "../auto/session.ts";
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask } from "../gsd-db.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import { _clearGsdRootCache } from "../paths.ts";
+
+// ─── Test Fixtures ───────────────────────────────────────────────────────────
+
+let tempDir: string;
+let dbPath: string;
+let originalCwd: string;
+
+function makeMockCtx() {
+  return {
+    ui: {
+      notify: mock.fn(),
+      setStatus: () => {},
+      setWidget: () => {},
+      setFooter: () => {},
+    },
+    model: { id: "test-model" },
+  } as any;
+}
+
+function makeMockPi() {
+  return {
+    sendMessage: mock.fn(),
+    setModel: mock.fn(async () => true),
+  } as any;
+}
+
+function makeMockSession(basePath: string, currentUnit?: { type: string; id: string }): AutoSession {
+  const s = new AutoSession();
+  s.basePath = basePath;
+  s.active = true;
+  // verificationRetryCount is readonly but initialized as an empty Map in AutoSession
+  s.pendingVerificationRetry = null;
+  if (currentUnit) {
+    s.currentUnit = {
+      type: currentUnit.type,
+      id: currentUnit.id,
+      startedAt: Date.now(),
+    };
+  }
+  return s;
+}
+
+function setupTestEnvironment(): void {
+  originalCwd = process.cwd();
+  tempDir = join(tmpdir(), `post-exec-retry-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(tempDir, { recursive: true });
+
+  const gsdDir = join(tempDir, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  const milestonesDir = join(gsdDir, "milestones", "M001", "slices", "S01", "tasks");
+  mkdirSync(milestonesDir, { recursive: true });
+
+  process.chdir(tempDir);
+  _clearGsdRootCache();
+
+  dbPath = join(gsdDir, "gsd.db");
+  openDatabase(dbPath);
+}
+
+function cleanupTestEnvironment(): void {
+  try {
+    process.chdir(originalCwd);
+  } catch {
+    // Ignore
+  }
+  try {
+    closeDatabase();
+  } catch {
+    // Ignore
+  }
+  try {
+    rmSync(tempDir, { recursive: true, force: true });
+  } catch {
+    // Ignore
+  }
+}
+
+function writePreferences(prefs: Record<string, unknown>): void {
+  const yamlLines = Object.entries(prefs).map(([k, v]) => `${k}: ${JSON.stringify(v)}`);
+  const prefsContent = `---
+${yamlLines.join("\n")}
+---
+
+# GSD Preferences
+`;
+  writeFileSync(join(tempDir, ".gsd", "PREFERENCES.md"), prefsContent);
+  invalidateAllCaches();
+  _clearGsdRootCache();
+}
+
+/**
+ * Create a task in DB that will pass basic verification but allows us to test the flow.
+ */
+function createBasicTask(): void {
+  insertMilestone({ id: "M001" });
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "Test Slice",
+    risk: "low",
+  });
+
+  // Create a simple task
+  insertTask({
+    id: "T01",
+    sliceId: "S01",
+    milestoneId: "M001",
+    title: "Basic task",
+    status: "pending",
+    planning: {
+      description: "A basic task for testing",
+      estimate: "1h",
+      files: [],
+      verify: "echo pass", // Simple verification that always passes
+      inputs: [],
+      expectedOutput: ["output.ts"],
+      observabilityImpact: "",
+    },
+    sequence: 0,
+  });
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("Post-execution blocking failure retry bypass", () => {
+  beforeEach(() => {
+    setupTestEnvironment();
+  });
+
+  afterEach(() => {
+    cleanupTestEnvironment();
+  });
+
+  test("skips verification when unit type is not execute-task", async () => {
+    createBasicTask();
+    writePreferences({
+      enhanced_verification: true,
+      enhanced_verification_post: true,
+      verification_auto_fix: true,
+      verification_max_retries: 3,
+    });
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "plan-slice", id: "M001/S01" });
+
+    const vctx: VerificationContext = { s, ctx, pi };
+    const result = await runPostUnitVerification(vctx, pauseAutoMock);
+
+    // Non-execute-task units should return "continue" immediately
+    assert.equal(result, "continue");
+    assert.equal(pauseAutoMock.mock.callCount(), 0);
+  });
+
+  test("returns continue when verification passes", async () => {
+    createBasicTask();
+    writePreferences({
+      enhanced_verification: true,
+      enhanced_verification_post: true,
+      verification_auto_fix: true,
+      verification_max_retries: 3,
+    });
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "execute-task", id: "M001/S01/T01" });
+
+    const vctx: VerificationContext = { s, ctx, pi };
+    const result = await runPostUnitVerification(vctx, pauseAutoMock);
+
+    // When verification passes, should return "continue" and not call pauseAuto
+    assert.equal(result, "continue");
+    assert.equal(pauseAutoMock.mock.callCount(), 0);
+    
+    // Retry state should be cleared
+    assert.equal(s.pendingVerificationRetry, null);
+  });
+
+  test("verification retry count is cleared on success", async () => {
+    createBasicTask();
+    writePreferences({
+      enhanced_verification: true,
+      enhanced_verification_post: true,
+      verification_auto_fix: true,
+      verification_max_retries: 3,
+    });
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "execute-task", id: "M001/S01/T01" });
+    
+    // Pre-set some retry state
+    s.verificationRetryCount.set("M001/S01/T01", 2);
+
+    const vctx: VerificationContext = { s, ctx, pi };
+    const result = await runPostUnitVerification(vctx, pauseAutoMock);
+
+    // On success, retry count should be cleared
+    assert.equal(result, "continue");
+    assert.equal(s.verificationRetryCount.has("M001/S01/T01"), false);
+  });
+
+  test("post-exec failure notification mentions cross-task consistency", async () => {
+    // This test verifies that the notification for post-exec failures includes
+    // the appropriate message about cross-task consistency issues.
+    // The actual post-exec failure would require specific file/output state
+    // that's harder to set up in a unit test, but we can verify the code path exists.
+    
+    createBasicTask();
+    writePreferences({
+      enhanced_verification: true,
+      enhanced_verification_post: true,
+      verification_auto_fix: true,
+      verification_max_retries: 3,
+    });
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "execute-task", id: "M001/S01/T01" });
+
+    const vctx: VerificationContext = { s, ctx, pi };
+    const result = await runPostUnitVerification(vctx, pauseAutoMock);
+
+    // The verification should pass with our simple "echo pass" task
+    // This test mainly confirms the wiring is correct
+    assert.equal(result, "continue");
+  });
+});
+
+describe("Post-execution retry behavior", () => {
+  beforeEach(() => {
+    setupTestEnvironment();
+  });
+
+  afterEach(() => {
+    cleanupTestEnvironment();
+  });
+
+  test("when autofix is disabled, failure pauses immediately without retry", async () => {
+    // Create a task with a verify command that will fail
+    insertMilestone({ id: "M001" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Test Slice",
+      risk: "low",
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Failing task",
+      status: "pending",
+      planning: {
+        description: "Task with failing verification",
+        estimate: "1h",
+        files: [],
+        verify: "exit 1", // This will fail
+        inputs: [],
+        expectedOutput: [],
+        observabilityImpact: "",
+      },
+      sequence: 0,
+    });
+
+    writePreferences({
+      enhanced_verification: true,
+      enhanced_verification_post: true,
+      verification_auto_fix: false, // Autofix disabled
+      verification_max_retries: 3,
+    });
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, { type: "execute-task", id: "M001/S01/T01" });
+
+    const vctx: VerificationContext = { s, ctx, pi };
+    const result = await runPostUnitVerification(vctx, pauseAutoMock);
+
+    // When autofix is disabled and verification fails, should pause
+    assert.equal(result, "pause");
+    assert.equal(pauseAutoMock.mock.callCount(), 1);
+    
+    // Should NOT set up a retry
+    assert.equal(s.pendingVerificationRetry, null);
+  });
+});