gsd-pi 2.52.0 → 2.53.0-dev.07ffe51

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;
+    },
+  );
+});

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

@@ -17,6 +17,7 @@ import {
   updateMilestoneStatus,
 } from "../gsd-db.js";
 import { resolveMilestonePath, clearPathCache } from "../paths.js";
+import { isClosedStatus } from "../status-guards.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -134,7 +135,7 @@ export async function handleCompleteMilestone(
       guardError = `milestone not found: ${params.milestoneId}`;
       return;
     }
-    if (milestone.status === "complete" || milestone.status === "done") {
+    if (isClosedStatus(milestone.status)) {
       guardError = `milestone ${params.milestoneId} is already complete`;
       return;
     }
@@ -146,7 +147,7 @@ export async function handleCompleteMilestone(
       return;
     }
 
-    const incompleteSlices = slices.filter(s => s.status !== "complete" && s.status !== "done");
+    const incompleteSlices = slices.filter(s => !isClosedStatus(s.status));
     if (incompleteSlices.length > 0) {
       const incompleteIds = incompleteSlices.map(s => `${s.id} (status: ${s.status})`).join(", ");
       guardError = `incomplete slices: ${incompleteIds}`;
@@ -156,7 +157,7 @@ export async function handleCompleteMilestone(
     // Deep check: verify all tasks in all slices are complete
     for (const slice of slices) {
       const tasks = getSliceTasks(params.milestoneId, slice.id);
-      const incompleteTasks = tasks.filter(t => t.status !== "complete" && t.status !== "done");
+      const incompleteTasks = tasks.filter(t => !isClosedStatus(t.status));
       if (incompleteTasks.length > 0) {
         const ids = incompleteTasks.map(t => `${t.id} (status: ${t.status})`).join(", ");
         guardError = `slice ${slice.id} has incomplete tasks: ${ids}`;

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

@@ -11,6 +11,7 @@ import { join } from "node:path";
 import { mkdirSync } from "node:fs";
 
 import type { CompleteSliceParams } from "../types.js";
+import { isClosedStatus } from "../status-guards.js";
 import {
   transaction,
   insertMilestone,
@@ -225,13 +226,13 @@ export async function handleCompleteSlice(
     // Milestone/slice not existing is OK — insertMilestone/insertSlice below will auto-create.
     // Only block if they exist and are closed.
     const milestone = getMilestone(params.milestoneId);
-    if (milestone && (milestone.status === "complete" || milestone.status === "done")) {
+    if (milestone && isClosedStatus(milestone.status)) {
       guardError = `cannot complete slice in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
       return;
     }
 
     const slice = getSlice(params.milestoneId, params.sliceId);
-    if (slice && (slice.status === "complete" || slice.status === "done")) {
+    if (slice && isClosedStatus(slice.status)) {
       guardError = `slice ${params.sliceId} is already complete — use gsd_slice_reopen first if you need to redo it`;
       return;
     }
@@ -243,7 +244,7 @@ export async function handleCompleteSlice(
       return;
     }
 
-    const incompleteTasks = tasks.filter(t => t.status !== "complete" && t.status !== "done");
+    const incompleteTasks = tasks.filter(t => !isClosedStatus(t.status));
     if (incompleteTasks.length > 0) {
       const incompleteIds = incompleteTasks.map(t => `${t.id} (status: ${t.status})`).join(", ");
       guardError = `incomplete tasks: ${incompleteIds}`;

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

@@ -11,6 +11,7 @@ import { join } from "node:path";
 import { mkdirSync, existsSync } from "node:fs";
 
 import type { CompleteTaskParams } from "../types.js";
+import { isClosedStatus } from "../status-guards.js";
 import {
   transaction,
   insertMilestone,
@@ -159,19 +160,19 @@ export async function handleCompleteTask(
     // Milestone/slice not existing is OK — insertMilestone/insertSlice below will auto-create.
     // Only block if they exist and are closed.
     const milestone = getMilestone(params.milestoneId);
-    if (milestone && (milestone.status === "complete" || milestone.status === "done")) {
+    if (milestone && isClosedStatus(milestone.status)) {
       guardError = `cannot complete task in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
       return;
     }
 
     const slice = getSlice(params.milestoneId, params.sliceId);
-    if (slice && (slice.status === "complete" || slice.status === "done")) {
+    if (slice && isClosedStatus(slice.status)) {
       guardError = `cannot complete task in a closed slice: ${params.sliceId} (status: ${slice.status})`;
       return;
     }
 
     const existingTask = getTask(params.milestoneId, params.sliceId, params.taskId);
-    if (existingTask && (existingTask.status === "complete" || existingTask.status === "done")) {
+    if (existingTask && isClosedStatus(existingTask.status)) {
       guardError = `task ${params.taskId} is already complete — use gsd_task_reopen first if you need to redo it`;
       return;
     }

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

@@ -1,4 +1,6 @@
 import { clearParseCache } from "../files.js";
+import { isClosedStatus } from "../status-guards.js";
+import { isNonEmptyString, validateStringArray } from "../validation.js";
 import {
   transaction,
   getMilestone,
@@ -54,20 +56,6 @@ export interface PlanMilestoneResult {
   roadmapPath: string;
 }
 
-function isNonEmptyString(value: unknown): value is string {
-  return typeof value === "string" && value.trim().length > 0;
-}
-
-function validateStringArray(value: unknown, field: string): string[] {
-  if (!Array.isArray(value)) {
-    throw new Error(`${field} must be an array`);
-  }
-  if (value.some((item) => !isNonEmptyString(item))) {
-    throw new Error(`${field} must contain only non-empty strings`);
-  }
-  return value;
-}
-
 function validateRiskEntries(value: unknown): Array<{ risk: string; whyItMatters: string }> {
   if (!Array.isArray(value)) {
     throw new Error("keyRisks must be an array");
@@ -196,7 +184,7 @@ export async function handlePlanMilestone(
   try {
     transaction(() => {
       const existingMilestone = getMilestone(params.milestoneId);
-      if (existingMilestone && (existingMilestone.status === "complete" || existingMilestone.status === "done")) {
+      if (existingMilestone && isClosedStatus(existingMilestone.status)) {
         guardError = `cannot re-plan milestone ${params.milestoneId}: it is already complete`;
         return;
       }
@@ -209,7 +197,7 @@ export async function handlePlanMilestone(
             guardError = `depends_on references unknown milestone: ${depId}`;
             return;
           }
-          if (dep.status !== "complete" && dep.status !== "done") {
+          if (!isClosedStatus(dep.status)) {
             guardError = `depends_on milestone ${depId} is not yet complete (status: ${dep.status})`;
             return;
           }

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

@@ -1,4 +1,6 @@
 import { clearParseCache } from "../files.js";
+import { isClosedStatus } from "../status-guards.js";
+import { isNonEmptyString, validateStringArray } from "../validation.js";
 import {
   transaction,
   getMilestone,
@@ -50,20 +52,6 @@ export interface PlanSliceResult {
   taskPlanPaths: string[];
 }
 
-function isNonEmptyString(value: unknown): value is string {
-  return typeof value === "string" && value.trim().length > 0;
-}
-
-function validateStringArray(value: unknown, field: string): string[] {
-  if (!Array.isArray(value)) {
-    throw new Error(`${field} must be an array`);
-  }
-  if (value.some((item) => !isNonEmptyString(item))) {
-    throw new Error(`${field} must contain only non-empty strings`);
-  }
-  return value;
-}
-
 function validateTasks(value: unknown): PlanSliceTaskInput[] {
   if (!Array.isArray(value) || value.length === 0) {
     throw new Error("tasks must be a non-empty array");
@@ -157,7 +145,7 @@ export async function handlePlanSlice(
         guardError = `milestone not found: ${params.milestoneId}`;
         return;
       }
-      if (parentMilestone.status === "complete" || parentMilestone.status === "done") {
+      if (isClosedStatus(parentMilestone.status)) {
         guardError = `cannot plan slice in a closed milestone: ${params.milestoneId} (status: ${parentMilestone.status})`;
         return;
       }
@@ -167,7 +155,7 @@ export async function handlePlanSlice(
         guardError = `missing parent slice: ${params.milestoneId}/${params.sliceId}`;
         return;
       }
-      if (parentSlice.status === "complete" || parentSlice.status === "done") {
+      if (isClosedStatus(parentSlice.status)) {
         guardError = `cannot re-plan slice ${params.sliceId}: it is already complete — use gsd_slice_reopen first`;
         return;
       }

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

@@ -1,4 +1,6 @@
 import { clearParseCache } from "../files.js";
+import { isClosedStatus } from "../status-guards.js";
+import { isNonEmptyString, validateStringArray } from "../validation.js";
 import { transaction, getSlice, getTask, insertTask, upsertTaskPlanning } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderTaskPlanFromDb } from "../markdown-renderer.js";
@@ -32,20 +34,6 @@ export interface PlanTaskResult {
   taskPlanPath: string;
 }
 
-function isNonEmptyString(value: unknown): value is string {
-  return typeof value === "string" && value.trim().length > 0;
-}
-
-function validateStringArray(value: unknown, field: string): string[] {
-  if (!Array.isArray(value)) {
-    throw new Error(`${field} must be an array`);
-  }
-  if (value.some((item) => !isNonEmptyString(item))) {
-    throw new Error(`${field} must contain only non-empty strings`);
-  }
-  return value;
-}
-
 function validateParams(params: PlanTaskParams): PlanTaskParams {
   if (!isNonEmptyString(params?.milestoneId)) throw new Error("milestoneId is required");
   if (!isNonEmptyString(params?.sliceId)) throw new Error("sliceId is required");
@@ -89,13 +77,13 @@ export async function handlePlanTask(
         guardError = `missing parent slice: ${params.milestoneId}/${params.sliceId}`;
         return;
       }
-      if (parentSlice.status === "complete" || parentSlice.status === "done") {
+      if (isClosedStatus(parentSlice.status)) {
         guardError = `cannot plan task in a closed slice: ${params.sliceId} (status: ${parentSlice.status})`;
         return;
       }
 
       const existingTask = getTask(params.milestoneId, params.sliceId, params.taskId);
-      if (existingTask && (existingTask.status === "complete" || existingTask.status === "done")) {
+      if (existingTask && isClosedStatus(existingTask.status)) {
         guardError = `cannot re-plan task ${params.taskId}: it is already complete — use gsd_task_reopen first`;
         return;
       }

package/src/resources/extensions/gsd/tools/reassess-roadmap.ts

@@ -1,4 +1,7 @@
+import { join } from "node:path";
 import { clearParseCache } from "../files.js";
+import { isClosedStatus } from "../status-guards.js";
+import { isNonEmptyString } from "../validation.js";
 import {
   transaction,
   getMilestone,
@@ -14,7 +17,6 @@ import { renderRoadmapFromDb, renderAssessmentFromDb } from "../markdown-rendere
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
-import { join } from "node:path";
 
 export interface SliceChangeInput {
   sliceId: string;
@@ -47,9 +49,6 @@ export interface ReassessRoadmapResult {
   roadmapPath: string;
 }
 
-function isNonEmptyString(value: unknown): value is string {
-  return typeof value === "string" && value.trim().length > 0;
-}
 
 function validateParams(params: ReassessRoadmapParams): ReassessRoadmapParams {
   if (!isNonEmptyString(params?.milestoneId)) throw new Error("milestoneId is required");
@@ -125,7 +124,7 @@ export async function handleReassessRoadmap(
         guardError = `milestone not found: ${params.milestoneId}`;
         return;
       }
-      if (milestone.status === "complete" || milestone.status === "done") {
+      if (isClosedStatus(milestone.status)) {
         guardError = `cannot reassess a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
         return;
       }
@@ -136,7 +135,7 @@ export async function handleReassessRoadmap(
         guardError = `completedSliceId not found: ${params.milestoneId}/${params.completedSliceId}`;
         return;
       }
-      if (completedSlice.status !== "complete" && completedSlice.status !== "done") {
+      if (!isClosedStatus(completedSlice.status)) {
         guardError = `completedSliceId ${params.completedSliceId} is not complete (status: ${completedSlice.status}) — reassess can only be called after a slice finishes`;
         return;
       }
@@ -145,7 +144,7 @@ export async function handleReassessRoadmap(
       const existingSlices = getMilestoneSlices(params.milestoneId);
       const completedSliceIds = new Set<string>();
       for (const slice of existingSlices) {
-        if (slice.status === "complete" || slice.status === "done") {
+        if (isClosedStatus(slice.status)) {
           completedSliceIds.add(slice.id);
         }
       }

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

@@ -20,6 +20,7 @@ import {
   transaction,
 } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
+import { isClosedStatus } from "../status-guards.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
@@ -62,8 +63,8 @@ export async function handleReopenSlice(
       guardError = `milestone not found: ${params.milestoneId}`;
       return;
     }
-    if (milestone.status === "complete" || milestone.status === "done") {
-      guardError = `cannot reopen slice inside a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
+    if (isClosedStatus(milestone.status)) {
+      guardError = `cannot reopen slice in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
       return;
     }
 
@@ -72,7 +73,7 @@ export async function handleReopenSlice(
       guardError = `slice not found: ${params.milestoneId}/${params.sliceId}`;
       return;
     }
-    if (slice.status !== "complete" && slice.status !== "done") {
+    if (!isClosedStatus(slice.status)) {
       guardError = `slice ${params.sliceId} is not complete (status: ${slice.status}) — nothing to reopen`;
       return;
     }

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

@@ -18,6 +18,7 @@ import {
   transaction,
 } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
+import { isClosedStatus } from "../status-guards.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
@@ -63,7 +64,7 @@ export async function handleReopenTask(
       guardError = `milestone not found: ${params.milestoneId}`;
       return;
     }
-    if (milestone.status === "complete" || milestone.status === "done") {
+    if (isClosedStatus(milestone.status)) {
       guardError = `cannot reopen task in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
       return;
     }
@@ -73,8 +74,8 @@ export async function handleReopenTask(
       guardError = `slice not found: ${params.milestoneId}/${params.sliceId}`;
       return;
     }
-    if (slice.status === "complete" || slice.status === "done") {
-      guardError = `cannot reopen task inside a closed slice: ${params.sliceId} (status: ${slice.status}) — use gsd_slice_reopen first`;
+    if (isClosedStatus(slice.status)) {
+      guardError = `cannot reopen task in a closed slice: ${params.sliceId} (status: ${slice.status}) — use gsd_slice_reopen first`;
       return;
     }
 
@@ -83,7 +84,7 @@ export async function handleReopenTask(
       guardError = `task not found: ${params.milestoneId}/${params.sliceId}/${params.taskId}`;
       return;
     }
-    if (task.status !== "complete" && task.status !== "done") {
+    if (!isClosedStatus(task.status)) {
       guardError = `task ${params.taskId} is not complete (status: ${task.status}) — nothing to reopen`;
       return;
     }

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

@@ -10,6 +10,8 @@ import {
   deleteTask,
 } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
+import { isClosedStatus } from "../status-guards.js";
+import { isNonEmptyString } from "../validation.js";
 import { renderPlanFromDb, renderReplanFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
@@ -48,10 +50,6 @@ export interface ReplanSliceResult {
   planPath: string;
 }
 
-function isNonEmptyString(value: unknown): value is string {
-  return typeof value === "string" && value.trim().length > 0;
-}
-
 function validateParams(params: ReplanSliceParams): ReplanSliceParams {
   if (!isNonEmptyString(params?.milestoneId)) throw new Error("milestoneId is required");
   if (!isNonEmptyString(params?.sliceId)) throw new Error("sliceId is required");
@@ -104,7 +102,7 @@ export async function handleReplanSlice(
         guardError = `missing parent slice: ${params.milestoneId}/${params.sliceId}`;
         return;
       }
-      if (parentSlice.status === "complete" || parentSlice.status === "done") {
+      if (isClosedStatus(parentSlice.status)) {
         guardError = `cannot replan a closed slice: ${params.sliceId} (status: ${parentSlice.status})`;
         return;
       }
@@ -115,7 +113,7 @@ export async function handleReplanSlice(
         guardError = `blockerTaskId not found: ${params.milestoneId}/${params.sliceId}/${params.blockerTaskId}`;
         return;
       }
-      if (blockerTask.status !== "complete" && blockerTask.status !== "done") {
+      if (!isClosedStatus(blockerTask.status)) {
         guardError = `blockerTaskId ${params.blockerTaskId} is not complete (status: ${blockerTask.status}) — the blocker task must be finished before a replan is triggered`;
         return;
       }
@@ -124,7 +122,7 @@ export async function handleReplanSlice(
       const existingTasks = getSliceTasks(params.milestoneId, params.sliceId);
       const completedTaskIds = new Set<string>();
       for (const task of existingTasks) {
-        if (task.status === "complete" || task.status === "done") {
+        if (isClosedStatus(task.status)) {
           completedTaskIds.add(task.id);
         }
       }

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

@@ -0,0 +1,23 @@
+/**
+ * Shared input-validation primitives for GSD tool handlers.
+ */
+
+/** Type guard: value is a string with at least one non-whitespace character. */
+export function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+/**
+ * Validate that `value` is an array of non-empty strings.
+ * Throws with a message referencing `field` on failure.
+ * Returns the validated array (narrowed to string[]).
+ */
+export function validateStringArray(value: unknown, field: string): string[] {
+  if (!Array.isArray(value)) {
+    throw new Error(`${field} must be an array`);
+  }
+  if (value.some((item) => !isNonEmptyString(item))) {
+    throw new Error(`${field} must contain only non-empty strings`);
+  }
+  return value;
+}