gsd-pi 2.52.0 → 2.53.0-dev.07ffe51

package/dist/resources/extensions/gsd/state.js

@@ -6,6 +6,7 @@ import { parseSummary, loadFile, parseRequirementCounts, parseContextDependsOn,
 import { resolveMilestoneFile, resolveSlicePath, resolveSliceFile, resolveTaskFile, resolveTasksDir, resolveGsdRootFile, gsdRoot, } from './paths.js';
 import { findMilestoneIds } from './milestone-ids.js';
 import { loadQueueOrder, sortByQueueOrder } from './queue-order.js';
+import { isClosedStatus } from './status-guards.js';
 import { nativeBatchParseGsdFiles } from './native-parser-bridge.js';
 import { join, resolve } from 'path';
 import { existsSync, readdirSync } from 'node:fs';
@@ -39,19 +40,13 @@ export function isMilestoneComplete(roadmap) {
     return roadmap.slices.length > 0 && roadmap.slices.every(s => s.done);
 }
 /**
- * Check whether a VALIDATION file's verdict is terminal (pass or needs-attention).
- * A non-terminal verdict (needs-remediation) means validation must re-run
- * after remediation slices are executed.
+ * Check whether a VALIDATION file's verdict is terminal.
+ * Any successfully extracted verdict (pass, needs-attention, needs-remediation,
+ * fail, etc.) means validation completed. Only return false when no verdict
+ * could be parsed — i.e. extractVerdict() returns undefined (#2769).
  */
 export function isValidationTerminal(validationContent) {
-    const v = extractVerdict(validationContent);
-    if (!v)
-        return false;
-    // 'pass' and 'needs-attention' are always terminal.
-    // 'needs-remediation' is treated as terminal to prevent infinite loops
-    // when no remediation slices exist in the roadmap (#832). The validation
-    // report is preserved on disk for manual review.
-    return v === 'pass' || v === 'needs-attention' || v === 'needs-remediation';
+    return extractVerdict(validationContent) != null;
 }
 const CACHE_TTL_MS = 100;
 let _stateCache = null;
@@ -203,12 +198,6 @@ function extractContextTitle(content, fallback) {
     return stripMilestonePrefix(h1.slice(2).trim()) || fallback;
 }
 // ─── DB-backed State Derivation ────────────────────────────────────────────
-/**
- * Helper: check if a DB status counts as "done" (handles K002 ambiguity).
- */
-function isStatusDone(status) {
-    return status === 'complete' || status === 'done';
-}
 /**
  * Derive GSD state from the milestones/slices/tasks DB tables.
  * Flag files (PARKED, VALIDATION, CONTINUE, REPLAN, REPLAN-TRIGGER, CONTEXT-DRAFT)
@@ -292,7 +281,7 @@ export async function deriveStateFromDb(basePath) {
             parkedMilestoneIds.add(m.id);
             continue;
         }
-        if (isStatusDone(m.status)) {
+        if (isClosedStatus(m.status)) {
             completeMilestoneIds.add(m.id);
             continue;
         }
@@ -304,7 +293,7 @@ export async function deriveStateFromDb(basePath) {
         }
         // Check roadmap: all slices done means milestone is complete
         const slices = getMilestoneSlices(m.id);
-        if (slices.length > 0 && slices.every(s => isStatusDone(s.status))) {
+        if (slices.length > 0 && slices.every(s => isClosedStatus(s.status))) {
             // All slices done but no summary — still counts as complete for dep resolution
             // if a summary file exists
             // Note: without summary file, the milestone is in validating/completing state, not complete
@@ -323,7 +312,7 @@ export async function deriveStateFromDb(basePath) {
         }
         // Ghost milestone check: no slices in DB AND no substantive files on disk
         const slices = getMilestoneSlices(m.id);
-        if (slices.length === 0 && !isStatusDone(m.status)) {
+        if (slices.length === 0 && !isClosedStatus(m.status)) {
             // Check disk for ghost detection
             if (isGhostMilestone(basePath, m.id))
                 continue;
@@ -344,7 +333,7 @@ export async function deriveStateFromDb(basePath) {
             continue;
         }
         // Not complete — determine if it should be active
-        const allSlicesDone = slices.length > 0 && slices.every(s => isStatusDone(s.status));
+        const allSlicesDone = slices.length > 0 && slices.every(s => isClosedStatus(s.status));
         // Get title — prefer DB, fall back to context file extraction
         let title = stripMilestonePrefix(m.title) || m.id;
         if (title === m.id) {
@@ -484,7 +473,7 @@ export async function deriveStateFromDb(basePath) {
     // Guard: [].every() === true (vacuous truth). Without the length check,
     // an empty slice array causes a premature phase transition to
     // validating-milestone. See: https://github.com/gsd-build/gsd-2/issues/2667
-    const allSlicesDone = activeMilestoneSlices.length > 0 && activeMilestoneSlices.every(s => isStatusDone(s.status));
+    const allSlicesDone = activeMilestoneSlices.length > 0 && activeMilestoneSlices.every(s => isClosedStatus(s.status));
     if (allSlicesDone) {
         const validationFile = resolveMilestoneFile(basePath, activeMilestone.id, "VALIDATION");
         const validationContent = validationFile ? await loadFile(validationFile) : null;
@@ -514,14 +503,14 @@ export async function deriveStateFromDb(basePath) {
     }
     // ── Find active slice (first incomplete with deps satisfied) ─────────
     const sliceProgress = {
-        done: activeMilestoneSlices.filter(s => isStatusDone(s.status)).length,
+        done: activeMilestoneSlices.filter(s => isClosedStatus(s.status)).length,
         total: activeMilestoneSlices.length,
     };
-    const doneSliceIds = new Set(activeMilestoneSlices.filter(s => isStatusDone(s.status)).map(s => s.id));
+    const doneSliceIds = new Set(activeMilestoneSlices.filter(s => isClosedStatus(s.status)).map(s => s.id));
     let activeSlice = null;
     let activeSliceRow = null;
     for (const s of activeMilestoneSlices) {
-        if (isStatusDone(s.status))
+        if (isClosedStatus(s.status))
             continue;
         if (s.depends.every(dep => doneSliceIds.has(dep))) {
             activeSlice = { id: s.id, title: s.title };
@@ -561,7 +550,7 @@ export async function deriveStateFromDb(basePath) {
     // causing the dispatcher to re-dispatch the same completed task forever.
     let reconciled = false;
     for (const t of tasks) {
-        if (isStatusDone(t.status))
+        if (isClosedStatus(t.status))
             continue;
         const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
         if (summaryPath && existsSync(summaryPath)) {
@@ -581,10 +570,10 @@ export async function deriveStateFromDb(basePath) {
         tasks = getSliceTasks(activeMilestone.id, activeSlice.id);
     }
     const taskProgress = {
-        done: tasks.filter(t => isStatusDone(t.status)).length,
+        done: tasks.filter(t => isClosedStatus(t.status)).length,
         total: tasks.length,
     };
-    const activeTaskRow = tasks.find(t => !isStatusDone(t.status));
+    const activeTaskRow = tasks.find(t => !isClosedStatus(t.status));
     if (!activeTaskRow && tasks.length > 0) {
         // All tasks done but slice not marked complete → summarizing
         return {
@@ -639,7 +628,7 @@ export async function deriveStateFromDb(basePath) {
         };
     }
     // ── Blocker detection: check completed tasks for blocker_discovered ──
-    const completedTasks = tasks.filter(t => isStatusDone(t.status));
+    const completedTasks = tasks.filter(t => isClosedStatus(t.status));
     let blockerTaskId = null;
     for (const ct of completedTasks) {
         if (ct.blocker_discovered) {

package/dist/resources/extensions/gsd/status-guards.js

@@ -0,0 +1,12 @@
+/**
+ * Status predicates for GSD state-machine guards.
+ *
+ * The DB stores status as free-form strings. Two values indicate
+ * "closed": "complete" (canonical) and "done" (legacy / alias).
+ * Every inline `status === "complete" || status === "done"` should
+ * use isClosedStatus() instead.
+ */
+/** Returns true when a milestone, slice, or task status indicates closure. */
+export function isClosedStatus(status) {
+    return status === "complete" || status === "done";
+}

package/dist/resources/extensions/gsd/tools/complete-milestone.js

@@ -9,6 +9,7 @@ import { join } from "node:path";
 import { mkdirSync } from "node:fs";
 import { transaction, getMilestone, getMilestoneSlices, getSliceTasks, 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";
@@ -89,7 +90,7 @@ export async function handleCompleteMilestone(params, basePath) {
             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;
         }
@@ -99,7 +100,7 @@ export async function handleCompleteMilestone(params, basePath) {
             guardError = `no slices found for milestone ${params.milestoneId}`;
             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}`;
@@ -108,7 +109,7 @@ export async function handleCompleteMilestone(params, basePath) {
         // 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/dist/resources/extensions/gsd/tools/complete-slice.js

@@ -8,6 +8,7 @@
  */
 import { join } from "node:path";
 import { mkdirSync } from "node:fs";
+import { isClosedStatus } from "../status-guards.js";
 import { transaction, insertMilestone, insertSlice, getSlice, getSliceTasks, getMilestone, updateSliceStatus, setSliceSummaryMd, } from "../gsd-db.js";
 import { resolveSlicePath, clearPathCache } from "../paths.js";
 import { checkOwnership, sliceUnitKey } from "../unit-ownership.js";
@@ -179,12 +180,12 @@ export async function handleCompleteSlice(params, basePath) {
         // 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;
         }
@@ -194,7 +195,7 @@ export async function handleCompleteSlice(params, basePath) {
             guardError = `no tasks found for slice ${params.sliceId} in milestone ${params.milestoneId}`;
             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/dist/resources/extensions/gsd/tools/complete-task.js

@@ -8,6 +8,7 @@
  */
 import { join } from "node:path";
 import { mkdirSync } from "node:fs";
+import { isClosedStatus } from "../status-guards.js";
 import { transaction, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, getMilestone, getSlice, getTask, updateTaskStatus, setTaskSummaryMd, deleteVerificationEvidence, } from "../gsd-db.js";
 import { resolveSliceFile, resolveTasksDir, clearPathCache } from "../paths.js";
 import { checkOwnership, taskUnitKey } from "../unit-ownership.js";
@@ -122,17 +123,17 @@ export async function handleCompleteTask(params, basePath) {
         // 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/dist/resources/extensions/gsd/tools/plan-milestone.js

@@ -1,22 +1,12 @@
 import { clearParseCache } from "../files.js";
+import { isClosedStatus } from "../status-guards.js";
+import { isNonEmptyString, validateStringArray } from "../validation.js";
 import { transaction, getMilestone, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
-function isNonEmptyString(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}
-function validateStringArray(value, field) {
-    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) {
     if (!Array.isArray(value)) {
         throw new Error("keyRisks must be an array");
@@ -152,7 +142,7 @@ export async function handlePlanMilestone(rawParams, basePath) {
     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;
             }
@@ -164,7 +154,7 @@ export async function handlePlanMilestone(rawParams, basePath) {
                         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/dist/resources/extensions/gsd/tools/plan-slice.js

@@ -1,22 +1,12 @@
 import { clearParseCache } from "../files.js";
+import { isClosedStatus } from "../status-guards.js";
+import { isNonEmptyString } from "../validation.js";
 import { transaction, getMilestone, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
-function isNonEmptyString(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}
-function validateStringArray(value, field) {
-    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) {
     if (!Array.isArray(value) || value.length === 0) {
         throw new Error("tasks must be a non-empty array");
@@ -113,7 +103,7 @@ export async function handlePlanSlice(rawParams, basePath) {
                 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;
             }
@@ -122,7 +112,7 @@ export async function handlePlanSlice(rawParams, basePath) {
                 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/dist/resources/extensions/gsd/tools/plan-task.js

@@ -1,22 +1,12 @@
 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";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
-function isNonEmptyString(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}
-function validateStringArray(value, field) {
-    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) {
     if (!isNonEmptyString(params?.milestoneId))
         throw new Error("milestoneId is required");
@@ -61,12 +51,12 @@ export async function handlePlanTask(rawParams, basePath) {
                 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/dist/resources/extensions/gsd/tools/reassess-roadmap.js

@@ -1,14 +1,13 @@
+import { join } from "node:path";
 import { clearParseCache } from "../files.js";
+import { isClosedStatus } from "../status-guards.js";
+import { isNonEmptyString } from "../validation.js";
 import { transaction, getMilestone, getMilestoneSlices, getSlice, insertSlice, updateSliceFields, insertAssessment, deleteSlice, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb, renderAssessmentFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
-import { join } from "node:path";
-function isNonEmptyString(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}
 function validateParams(params) {
     if (!isNonEmptyString(params?.milestoneId))
         throw new Error("milestoneId is required");
@@ -76,7 +75,7 @@ export async function handleReassessRoadmap(rawParams, basePath) {
                 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;
             }
@@ -86,7 +85,7 @@ export async function handleReassessRoadmap(rawParams, basePath) {
                 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;
             }
@@ -94,7 +93,7 @@ export async function handleReassessRoadmap(rawParams, basePath) {
             const existingSlices = getMilestoneSlices(params.milestoneId);
             const completedSliceIds = new Set();
             for (const slice of existingSlices) {
-                if (slice.status === "complete" || slice.status === "done") {
+                if (isClosedStatus(slice.status)) {
                     completedSliceIds.add(slice.id);
                 }
             }

package/dist/resources/extensions/gsd/tools/reopen-slice.js

@@ -11,6 +11,7 @@
 // Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 import { getMilestone, getSlice, getSliceTasks, updateSliceStatus, updateTaskStatus, 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";
@@ -31,8 +32,8 @@ export async function handleReopenSlice(params, basePath) {
             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;
         }
         const slice = getSlice(params.milestoneId, params.sliceId);
@@ -40,7 +41,7 @@ export async function handleReopenSlice(params, basePath) {
             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/dist/resources/extensions/gsd/tools/reopen-task.js

@@ -10,6 +10,7 @@
 // Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 import { getMilestone, getSlice, getTask, updateTaskStatus, 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";
@@ -32,7 +33,7 @@ export async function handleReopenTask(params, basePath) {
             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;
         }
@@ -41,8 +42,8 @@ export async function handleReopenTask(params, basePath) {
             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;
         }
         const task = getTask(params.milestoneId, params.sliceId, params.taskId);
@@ -50,7 +51,7 @@ export async function handleReopenTask(params, basePath) {
             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/dist/resources/extensions/gsd/tools/replan-slice.js

@@ -1,13 +1,12 @@
 import { clearParseCache } from "../files.js";
 import { transaction, getSlice, getSliceTasks, getTask, insertTask, upsertTaskPlanning, insertReplanHistory, 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";
 import { appendEvent } from "../workflow-events.js";
-function isNonEmptyString(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}
 function validateParams(params) {
     if (!isNonEmptyString(params?.milestoneId))
         throw new Error("milestoneId is required");
@@ -59,7 +58,7 @@ export async function handleReplanSlice(rawParams, basePath) {
                 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;
             }
@@ -69,7 +68,7 @@ export async function handleReplanSlice(rawParams, basePath) {
                 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;
             }
@@ -77,7 +76,7 @@ export async function handleReplanSlice(rawParams, basePath) {
             const existingTasks = getSliceTasks(params.milestoneId, params.sliceId);
             const completedTaskIds = new Set();
             for (const task of existingTasks) {
-                if (task.status === "complete" || task.status === "done") {
+                if (isClosedStatus(task.status)) {
                     completedTaskIds.add(task.id);
                 }
             }

package/dist/resources/extensions/gsd/validation.js

@@ -0,0 +1,21 @@
+/**
+ * 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) {
+    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, field) {
+    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;
+}

package/dist/resources/extensions/shared/rtk.js

@@ -4,6 +4,7 @@ import { homedir } from "node:os";
 import { delimiter, join } from "node:path";
 const GSD_RTK_PATH_ENV = "GSD_RTK_PATH";
 const GSD_RTK_DISABLED_ENV = "GSD_RTK_DISABLED";
+const GSD_RTK_REWRITE_TIMEOUT_MS_ENV = "GSD_RTK_REWRITE_TIMEOUT_MS";
 const RTK_TELEMETRY_DISABLED_ENV = "RTK_TELEMETRY_DISABLED";
 const RTK_REWRITE_TIMEOUT_MS = 5_000;
 function isTruthy(value) {
@@ -12,6 +13,13 @@ function isTruthy(value) {
     const normalized = value.trim().toLowerCase();
     return normalized === "1" || normalized === "true" || normalized === "yes";
 }
+function getRewriteTimeoutMs(env = process.env) {
+    const configured = Number.parseInt(env[GSD_RTK_REWRITE_TIMEOUT_MS_ENV] ?? "", 10);
+    if (Number.isFinite(configured) && configured > 0) {
+        return configured;
+    }
+    return RTK_REWRITE_TIMEOUT_MS;
+}
 export function isRtkEnabled(env = process.env) {
     return !isTruthy(env[GSD_RTK_DISABLED_ENV]);
 }
@@ -75,19 +83,21 @@ export function resolveRtkBinaryPath(options = {}) {
     }
     return resolveSystemRtkPath(options.pathValue ?? getPathValue(env), platform);
 }
-export function rewriteCommandWithRtk(command, env = process.env) {
+export function rewriteCommandWithRtk(command, options = {}) {
+    const env = options.env ?? process.env;
     if (!command.trim())
         return command;
     if (!isRtkEnabled(env))
         return command;
-    const binaryPath = resolveRtkBinaryPath({ env });
+    const binaryPath = options.binaryPath ?? resolveRtkBinaryPath({ env });
     if (!binaryPath)
         return command;
-    const result = spawnSync(binaryPath, ["rewrite", command], {
+    const run = options.spawnSyncImpl ?? spawnSync;
+    const result = run(binaryPath, ["rewrite", command], {
         encoding: "utf-8",
         env: buildRtkEnv(env),
         stdio: ["ignore", "pipe", "ignore"],
-        timeout: RTK_REWRITE_TIMEOUT_MS,
+        timeout: getRewriteTimeoutMs(env),
         // .cmd/.bat wrappers (used by fake-rtk in tests) require shell:true on Windows
         shell: /\.(cmd|bat)$/i.test(binaryPath),
     });

package/dist/rtk.js

@@ -175,7 +175,9 @@ function resolveSystemRtkPath(pathValue, platform = process.platform) {
 export function resolveRtkBinaryPath(options = {}) {
     const env = options.env ?? process.env;
     const platform = options.platform ?? process.platform;
-    const explicitPath = options.binaryPath ?? env[GSD_RTK_PATH_ENV];
+    if (options.binaryPath)
+        return options.binaryPath;
+    const explicitPath = env[GSD_RTK_PATH_ENV];
     if (explicitPath && existsSync(explicitPath)) {
         return explicitPath;
     }

package/dist/web/standalone/.next/BUILD_ID

@@ -1 +1 @@
-vlgS2rkXjxeKhgXhdp4lh
+Q5pfrfJIvgUKR3LJLVB0T