gsd-pi 2.51.0 → 2.52.0-dev.655ad8a

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

@@ -1,73 +1,84 @@
 /**
  * terminated-transient.test.ts — Regression test for #2309.
  *
- * classifyProviderError should treat 'terminated' errors (process killed,
+ * classifyError 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";
+import { classifyError, isTransient } from "../error-classifier.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");
+  const result = classifyError("terminated");
+  assert.equal(isTransient(result), true, "'terminated' should be transient");
+  assert.equal(result.kind, "connection", "'terminated' matches connection");
+  assert.ok("retryAfterMs" in result && result.retryAfterMs > 0, "'terminated' should have a retry delay");
+  assert.equal("retryAfterMs" in result && result.retryAfterMs, 15_000, "'terminated' should use 15s backoff");
 });
 
-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: 'connection reset by peer' errors should be classified as transient (network)", () => {
+  const result = classifyError("connection reset by peer");
+  assert.equal(isTransient(result), true, "'connection reset by peer' should be transient");
+  assert.equal(result.kind, "network", "'connection reset by peer' matches NETWORK_RE (connection.*reset) before CONNECTION_RE");
+  assert.equal("retryAfterMs" in result && result.retryAfterMs, 3_000, "network errors use 3s backoff");
 });
 
 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");
+  const result = classifyError("other side closed the connection");
+  assert.equal(isTransient(result), true, "'other side closed' should be transient");
+  assert.equal(result.kind, "connection", "'other side closed' matches CONNECTION_RE");
 });
 
 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");
+  const result = classifyError("fetch failed: network error");
+  assert.equal(isTransient(result), true, "'fetch failed' should be transient");
+  assert.equal(result.kind, "network", "'fetch failed' matches NETWORK_RE");
+  assert.equal("retryAfterMs" in result && result.retryAfterMs, 3_000, "network errors use 3s backoff");
 });
 
 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");
+  const result = classifyError("ECONNREFUSED: connection refused");
+  assert.equal(isTransient(result), true, "'connection refused' should be transient");
+  assert.equal(result.kind, "network", "'ECONNREFUSED' matches NETWORK_RE (same-model retry)");
 });
 
 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");
+  const authResult = classifyError("unauthorized: invalid API key");
+  assert.equal(isTransient(authResult), false, "auth errors should stay permanent");
+  assert.equal(authResult.kind, "permanent", "auth errors are permanent");
+  assert.equal("retryAfterMs" in authResult, false, "permanent errors have no retryAfterMs");
 });
 
 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");
+  const rlResult = classifyError("rate limit exceeded (429)");
+  assert.equal(isTransient(rlResult), true, "rate limits are still transient");
+  assert.equal(rlResult.kind, "rate-limit", "rate limits are flagged as rate-limit kind");
 });
 
 // --- #2572: stream-truncation JSON parse errors should be transient ---
 
 test("#2572: 'Expected double-quoted property name' (truncated stream) is transient", () => {
-  const result = classifyProviderError("Expected double-quoted property name in JSON at position 23 (line 1 column 24)");
-  assert.equal(result.isTransient, true, "truncated-stream JSON parse error should be transient");
-  assert.equal(result.isRateLimit, false, "not a rate limit");
-  assert.equal(result.suggestedDelayMs, 15_000, "should use 15s backoff like connection errors");
+  const result = classifyError("Expected double-quoted property name in JSON at position 23 (line 1 column 24)");
+  assert.equal(isTransient(result), true, "truncated-stream JSON parse error should be transient");
+  assert.equal(result.kind, "stream", "JSON parse errors are stream kind");
+  assert.equal("retryAfterMs" in result && result.retryAfterMs, 15_000, "should use 15s backoff");
 });
 
 test("#2572: 'Unexpected end of JSON input' (truncated stream) is transient", () => {
-  const result = classifyProviderError("Unexpected end of JSON input");
-  assert.equal(result.isTransient, true, "'Unexpected end of JSON input' should be transient");
+  const result = classifyError("Unexpected end of JSON input");
+  assert.equal(isTransient(result), true, "'Unexpected end of JSON input' should be transient");
+  assert.equal(result.kind, "stream", "JSON parse errors are stream kind");
 });
 
 test("#2572: 'Unexpected token' in JSON (truncated stream) is transient", () => {
-  const result = classifyProviderError("Unexpected token < in JSON at position 0");
-  assert.equal(result.isTransient, true, "'Unexpected token in JSON' should be transient");
+  const result = classifyError("Unexpected token < in JSON at position 0");
+  assert.equal(isTransient(result), true, "'Unexpected token in JSON' should be transient");
+  assert.equal(result.kind, "stream", "JSON parse errors are stream kind");
 });
 
 test("#2572: 'SyntaxError' with JSON context (truncated stream) is transient", () => {
-  const result = classifyProviderError("SyntaxError: JSON.parse: unexpected character at line 1 column 1");
-  assert.equal(result.isTransient, true, "'SyntaxError...JSON' should be transient");
+  const result = classifyError("SyntaxError: JSON.parse: unexpected character at line 1 column 1");
+  assert.equal(isTransient(result), true, "'SyntaxError...JSON' should be transient");
+  assert.equal(result.kind, "stream", "JSON parse errors are stream kind");
 });

package/src/resources/extensions/gsd/tests/token-cost-display.test.ts

@@ -63,13 +63,13 @@ test("show_token_cost defaults to undefined (disabled) when not set", () => {
   assert.equal(preferences.show_token_cost, undefined);
 });
 
-test("empty preferences.md does not enable show_token_cost", () => {
+test("empty PREFERENCES.md does not enable show_token_cost", () => {
   const prefs = parsePreferencesMarkdown("---\nversion: 1\n---\n");
   assert.ok(prefs);
   assert.equal(prefs.show_token_cost, undefined);
 });
 
-test("preferences.md with show_token_cost: true enables the preference", () => {
+test("PREFERENCES.md with show_token_cost: true enables the preference", () => {
   const prefs = parsePreferencesMarkdown("---\nshow_token_cost: true\n---\n");
   assert.ok(prefs);
   assert.equal(prefs.show_token_cost, true);

package/src/resources/extensions/gsd/tests/vacuous-truth-slices.test.ts

@@ -0,0 +1,115 @@
+/**
+ * Regression test for #2667: deriveStateFromDb must NOT treat an empty
+ * slice array as "all slices done" due to JavaScript's vacuous-truth
+ * behavior of Array.prototype.every on an empty array.
+ *
+ * [].every(predicate) === true in JavaScript. Without a length > 0 guard,
+ * this causes a premature phase transition to validating-milestone when
+ * the DB returns 0 slices (e.g. after a worktree DB wipe).
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { deriveStateFromDb, invalidateStateCache } from "../state.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+} from "../gsd-db.ts";
+
+test("deriveStateFromDb does NOT skip to validating when slice array is empty (#2667)", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-vacuous-truth-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+
+  try {
+    // Set up a milestone with a roadmap that references slices,
+    // but the DB has NO slice rows (simulating a worktree DB wipe)
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      [
+        "# M001: Test Milestone",
+        "",
+        "## Slices",
+        "",
+        "### S01 — First Slice",
+        "Do something.",
+        "",
+        "### S02 — Second Slice",
+        "Do another thing.",
+      ].join("\n"),
+    );
+
+    openDatabase(":memory:");
+    // Milestone exists but NO slices inserted — simulates DB wipe
+    insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
+
+    invalidateStateCache();
+    const state = await deriveStateFromDb(base);
+
+    // The phase must NOT be "validating-milestone" or "completing-milestone"
+    // because no slices have been executed — the empty array should not
+    // trigger the "all slices done" code path.
+    assert.notEqual(
+      state.phase,
+      "validating-milestone",
+      "empty slice array must not trigger validating-milestone (vacuous truth)",
+    );
+    assert.notEqual(
+      state.phase,
+      "completing-milestone",
+      "empty slice array must not trigger completing-milestone (vacuous truth)",
+    );
+
+    closeDatabase();
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("deriveStateFromDb correctly reaches validating when all slices are done (#2667 guard)", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-vacuous-truth-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+
+  try {
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      [
+        "# M001: Test Milestone",
+        "",
+        "## Slices",
+        "",
+        "### S01 — First Slice",
+        "Do something.",
+      ].join("\n"),
+    );
+
+    // Write a slice summary so the filesystem recognizes it as complete
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md"),
+      "# S01 Summary\n\nDone.",
+    );
+
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "First Slice", status: "complete", risk: "low", depends: [] });
+
+    invalidateStateCache();
+    const state = await deriveStateFromDb(base);
+
+    // With one slice that IS complete, phase should advance
+    assert.ok(
+      state.phase === "validating-milestone" || state.phase === "completing-milestone",
+      `expected validating or completing phase, got "${state.phase}"`,
+    );
+
+    closeDatabase();
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/validate-milestone-write-order.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, existsSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import { handleValidateMilestone } from "../tools/validate-milestone.js";
+import { openDatabase, closeDatabase, _getAdapter, insertMilestone } from "../gsd-db.js";
+import { clearPathCache } from "../paths.js";
+import { clearParseCache } from "../files.js";
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-val-handler-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  return base;
+}
+
+const VALID_PARAMS = {
+  milestoneId: "M001",
+  verdict: "pass" as const,
+  remediationRound: 0,
+  successCriteriaChecklist: "- [x] All pass",
+  sliceDeliveryAudit: "| S01 | delivered |",
+  crossSliceIntegration: "No issues",
+  requirementCoverage: "All covered",
+  verdictRationale: "Everything checks out",
+};
+
+describe("handleValidateMilestone write ordering (#2725)", () => {
+  let base: string;
+
+  afterEach(() => {
+    clearPathCache();
+    clearParseCache();
+    try { closeDatabase(); } catch { /* */ }
+    if (base) {
+      try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
+    }
+  });
+
+  it("writes DB row and disk file on success", async () => {
+    base = makeTmpBase();
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({ id: "M001" });
+
+    const result = await handleValidateMilestone(VALID_PARAMS, base);
+    assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
+
+    // DB row exists
+    const adapter = _getAdapter()!;
+    const row = adapter.prepare(
+      `SELECT status, scope FROM assessments WHERE milestone_id = 'M001' AND scope = 'milestone-validation'`,
+    ).get() as { status: string; scope: string } | undefined;
+    assert.ok(row, "assessment row should exist in DB");
+    assert.equal(row!.status, "pass");
+
+    // Disk file exists
+    const filePath = join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
+    assert.ok(existsSync(filePath), "VALIDATION.md should exist on disk");
+  });
+
+  it("rolls back DB row when disk write fails", async () => {
+    base = makeTmpBase();
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({ id: "M001" });
+
+    // Force disk write failure by replacing the milestone directory with a
+    // regular file. saveFile() will fail because it cannot write inside a
+    // non-directory. This works cross-platform (chmod is ignored on Windows).
+    const milestoneDir = join(base, ".gsd", "milestones", "M001");
+    rmSync(milestoneDir, { recursive: true, force: true });
+    writeFileSync(milestoneDir, "not-a-directory");
+
+    const result = await handleValidateMilestone(VALID_PARAMS, base);
+
+    // Should return error
+    assert.ok("error" in result, "should return error when disk write fails");
+    assert.ok(result.error.includes("disk render failed"));
+
+    // DB row should have been rolled back (deleted)
+    const adapter = _getAdapter()!;
+    const row = adapter.prepare(
+      `SELECT * FROM assessments WHERE milestone_id = 'M001' AND scope = 'milestone-validation'`,
+    ).get();
+    assert.equal(row, undefined, "assessment row should be deleted after disk-write rollback");
+  });
+});

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

@@ -110,6 +110,16 @@ test("isValidationTerminal returns true for verdict: passed (#1429)", () => {
   assert.equal(isValidationTerminal(content), true);
 });
 
+test("isValidationTerminal returns true for verdict: fail (#2769)", () => {
+  const content = "---\nverdict: fail\nremediation_round: 1\n---\n\n# Validation";
+  assert.equal(isValidationTerminal(content), true);
+});
+
+test("isValidationTerminal returns true for any arbitrary verdict string (#2769)", () => {
+  const content = "---\nverdict: custom-verdict\nremediation_round: 0\n---\n\n# Validation";
+  assert.equal(isValidationTerminal(content), true);
+});
+
 test("isValidationTerminal returns false for missing frontmatter", () => {
   const content = "# Validation\nNo frontmatter here.";
   assert.equal(isValidationTerminal(content), false);
@@ -327,14 +337,14 @@ test("verifyExpectedArtifact rejects VALIDATION with missing verdict field", ()
   }
 });
 
-test("verifyExpectedArtifact rejects VALIDATION with unrecognized verdict", () => {
+test("verifyExpectedArtifact accepts VALIDATION with any extracted verdict", () => {
   const base = makeTmpBase();
   try {
     writeValidation(base, "M001", "---\nverdict: unknown-value\nremediation_round: 0\n---\n\n# Validation");
     clearPathCache();
     clearParseCache();
     const result = verifyExpectedArtifact("validate-milestone", "M001", base);
-    assert.equal(result, false, "VALIDATION with unrecognized verdict should fail verification");
+    assert.equal(result, true, "VALIDATION with any extracted verdict should pass verification");
   } finally {
     cleanup(base);
   }

package/src/resources/extensions/gsd/tests/validation-gate-patterns.test.ts

@@ -0,0 +1,124 @@
+/**
+ * Unit tests for the milestone completion validation gate pattern matching.
+ *
+ * The gate in auto-dispatch accepts two evidence formats:
+ *   1. Structured template: content contains "Operational" AND ("MET" or "N/A")
+ *   2. Prose evidence: matches /[Oo]perational[\s:][^\n]*(?:pass|verified|...)/i
+ *
+ * These tests exercise the exact same expressions used in auto-dispatch.ts
+ * to ensure both formats are correctly recognized, and that content without
+ * operational evidence is properly rejected.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// ─── Replicate the gate matching logic from auto-dispatch.ts ─────────────────
+
+/**
+ * Returns true when validation content contains acceptable operational
+ * verification evidence (structured or prose).  Mirrors the inline checks
+ * in the "execute → complete-milestone" dispatch rule.
+ */
+function hasOperationalEvidence(validationContent: string): boolean {
+  const structuredMatch =
+    validationContent.includes("Operational") &&
+    (validationContent.includes("MET") || validationContent.includes("N/A"));
+  const proseMatch =
+    /[Oo]perational[\s:][^\n]*(?:pass|verified|confirmed|met|complete|true|yes|addressed|covered|n\/a|not\s+applicable)/i.test(
+      validationContent,
+    );
+  return structuredMatch || proseMatch;
+}
+
+// ─── Structured format ───────────────────────────────────────────────────────
+
+test("structured: Operational + MET passes", () => {
+  const content = `| Criteria       | Status |
+| Operational    | MET    |
+| Functional     | MET    |`;
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test("structured: Operational + N/A passes", () => {
+  const content = `| Criteria       | Status |
+| Operational    | N/A    |
+| Functional     | MET    |`;
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test("structured: Operational present with MET on another row still passes (includes is content-wide)", () => {
+  // The structured check uses .includes() across the entire content,
+  // so "MET" on the Functional row satisfies the condition alongside
+  // "Operational" anywhere in the document.
+  const content = `| Criteria       | Status  |
+| Operational    | PENDING |
+| Functional     | MET     |`;
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test("structured: Operational alone without any MET or N/A anywhere fails", () => {
+  const content = `| Criteria       | Status  |
+| Operational    | PENDING |
+| Functional     | PENDING |`;
+  assert.ok(!hasOperationalEvidence(content));
+});
+
+// ─── Prose format ────────────────────────────────────────────────────────────
+
+test('prose: "Operational: verified" passes', () => {
+  const content = `## Validation Report
+Operational: verified — all endpoints responsive.
+Functional: tests pass.`;
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test('prose: "Operational checks confirmed" passes', () => {
+  const content = `## Validation Report
+Operational checks confirmed by smoke test suite.`;
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test('prose: "Operational — pass" passes', () => {
+  const content = `Operational — pass (all services healthy)`;
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test('prose: "operational: addressed" passes (case-insensitive)', () => {
+  const content = `operational: addressed in CI pipeline run #42.`;
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test('prose: "Operational: not applicable" passes', () => {
+  const content = `Operational: not applicable for this library-only change.`;
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test('prose: "Operational: n/a" passes', () => {
+  const content = `Operational: n/a — no runtime components.`;
+  assert.ok(hasOperationalEvidence(content));
+});
+
+test('prose: "Operational: complete" passes', () => {
+  const content = `Operational: complete — all health checks green.`;
+  assert.ok(hasOperationalEvidence(content));
+});
+
+// ─── Rejection cases ─────────────────────────────────────────────────────────
+
+test("no operational evidence: unrelated content fails", () => {
+  const content = `## Validation Report
+All functional tests pass.
+Code coverage at 92%.`;
+  assert.ok(!hasOperationalEvidence(content));
+});
+
+test("no operational evidence: word 'operational' buried without qualifying keyword fails", () => {
+  const content = `## Validation Report
+The operational aspects were not evaluated in this round.`;
+  assert.ok(!hasOperationalEvidence(content));
+});
+
+test("no operational evidence: empty content fails", () => {
+  assert.ok(!hasOperationalEvidence(""));
+});

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

@@ -0,0 +1,72 @@
+// GSD — validation unit tests
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { isNonEmptyString, validateStringArray } from '../validation.ts';
+
+// ─── isNonEmptyString ────────────────────────────────────────────────────────
+
+test('isNonEmptyString: "hello" returns true', () => {
+  assert.equal(isNonEmptyString('hello'), true);
+});
+
+test('isNonEmptyString: " " (whitespace only) returns false', () => {
+  assert.equal(isNonEmptyString(' '), false);
+});
+
+test('isNonEmptyString: "" (empty string) returns false', () => {
+  assert.equal(isNonEmptyString(''), false);
+});
+
+test('isNonEmptyString: null returns false', () => {
+  assert.equal(isNonEmptyString(null), false);
+});
+
+test('isNonEmptyString: undefined returns false', () => {
+  assert.equal(isNonEmptyString(undefined), false);
+});
+
+test('isNonEmptyString: 42 (number) returns false', () => {
+  assert.equal(isNonEmptyString(42), false);
+});
+
+// ─── validateStringArray ─────────────────────────────────────────────────────
+
+test('validateStringArray: ["a", "b"] returns ["a", "b"]', () => {
+  assert.deepEqual(validateStringArray(['a', 'b'], 'items'), ['a', 'b']);
+});
+
+test('validateStringArray: [] (empty array) returns []', () => {
+  assert.deepEqual(validateStringArray([], 'items'), []);
+});
+
+test('validateStringArray: "not an array" throws with "must be an array"', () => {
+  assert.throws(
+    () => validateStringArray('not an array', 'items'),
+    (err: Error) => {
+      assert.ok(err.message.includes('must be an array'));
+      return true;
+    },
+  );
+});
+
+test('validateStringArray: ["a", 42] throws with "must contain only non-empty strings"', () => {
+  assert.throws(
+    () => validateStringArray(['a', 42], 'items'),
+    (err: Error) => {
+      assert.ok(err.message.includes('must contain only non-empty strings'));
+      return true;
+    },
+  );
+});
+
+test('validateStringArray: ["a", ""] throws with "must contain only non-empty strings"', () => {
+  assert.throws(
+    () => validateStringArray(['a', ''], 'items'),
+    (err: Error) => {
+      assert.ok(err.message.includes('must contain only non-empty strings'));
+      return true;
+    },
+  );
+});