gsd-pi 2.52.0-dev.585e355 → 2.52.0

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -337,7 +337,7 @@ async function configureGit(ctx, prefs) {
     const gitBooleanFields = [
         { key: "auto_push", label: "Auto-push commits after committing", defaultVal: false },
         { key: "push_branches", label: "Push milestone branches to remote", defaultVal: false },
-        { key: "snapshots", label: "Create WIP snapshot commits during long tasks", defaultVal: true },
+        { key: "snapshots", label: "Create WIP snapshot commits during long tasks", defaultVal: false },
     ];
     for (const field of gitBooleanFields) {
         const current = git[field.key];
@@ -361,7 +361,7 @@ async function configureGit(ctx, prefs) {
     }
     // pre_merge_check
     const currentPreMerge = git.pre_merge_check !== undefined ? String(git.pre_merge_check) : "";
-    const preMergeChoice = await ctx.ui.select(`Pre-merge check${currentPreMerge ? ` (current: ${currentPreMerge})` : " (default: auto)"}:`, ["true", "false", "auto", "(keep current)"]);
+    const preMergeChoice = await ctx.ui.select(`Pre-merge check${currentPreMerge ? ` (current: ${currentPreMerge})` : " (default: false)"}:`, ["true", "false", "auto", "(keep current)"]);
     if (preMergeChoice && preMergeChoice !== "(keep current)") {
         if (preMergeChoice === "auto") {
             git.pre_merge_check = "auto";
@@ -487,7 +487,7 @@ export async function configureMode(ctx, prefs) {
     if (modeStr && modeStr !== "(keep current)") {
         if (modeStr.startsWith("solo")) {
             prefs.mode = "solo";
-            ctx.ui.notify("Mode: solo — defaults: auto_push=true, push_branches=false, pre_merge_check=auto, merge_strategy=squash, isolation=worktree, unique_milestone_ids=false", "info");
+            ctx.ui.notify("Mode: solo — defaults: auto_push=true, push_branches=false, pre_merge_check=false, merge_strategy=squash, isolation=worktree, unique_milestone_ids=false", "info");
         }
         else if (modeStr.startsWith("team")) {
             prefs.mode = "team";

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -126,8 +126,8 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
   - `auto_push`: boolean — automatically push commits to the remote after committing. Default: `false`.
   - `push_branches`: boolean — push the milestone branch to the remote after commits. Default: `false`.
   - `remote`: string — git remote name to push to. Default: `"origin"`.
-  - `snapshots`: boolean — create snapshot commits (WIP saves) during long-running tasks. Default: `true`.
-  - `pre_merge_check`: boolean or `"auto"` — run pre-merge checks before merging a worktree back to the integration branch. `true` always runs, `false` never runs, `"auto"` runs when CI is detected. Default: `"auto"`.
+  - `snapshots`: boolean — create snapshot commits (WIP saves) during long-running tasks. Default: `false`.
+  - `pre_merge_check`: boolean or `"auto"` — run pre-merge checks before merging a worktree back to the integration branch. `true` always runs, `false` never runs, `"auto"` runs when CI is detected. Default: `false`.
   - `commit_type`: string — override the conventional commit type prefix. Must be one of: `feat`, `fix`, `refactor`, `docs`, `test`, `chore`, `perf`, `ci`, `build`, `style`. Default: inferred from diff content.
   - `main_branch`: string — the primary branch name for new git repos (e.g., `"main"`, `"master"`, `"trunk"`). Also used by `getMainBranch()` as the preferred branch when auto-detection is ambiguous. Default: `"main"`.
   - `merge_strategy`: `"squash"` or `"merge"` — controls how worktree branches are merged back. `"squash"` combines all commits into one; `"merge"` preserves individual commits. Default: `"squash"`.

package/dist/resources/extensions/gsd/git-service.js

@@ -446,12 +446,11 @@ export class GitServiceImpl {
     }
     /**
      * Create a snapshot ref for the given label (typically a slice branch name).
-     * Enabled by default; opt out with prefs.snapshots === false.
-     * Ref path: refs/gsd/snapshots/<label>/<timestamp>
+     * Gated on prefs.snapshots === true. Ref path: refs/gsd/snapshots/<label>/<timestamp>
      * The ref points at HEAD, capturing the current commit before destructive operations.
      */
     createSnapshot(label) {
-        if (this.prefs.snapshots === false)
+        if (this.prefs.snapshots !== true)
             return;
         const now = new Date();
         const ts = now.getFullYear().toString()
@@ -471,7 +470,7 @@ export class GitServiceImpl {
      * Stub: to be implemented in T03.
      */
     runPreMergeCheck() {
-        if (this.prefs.pre_merge_check === false) {
+        if (this.prefs.pre_merge_check === false || this.prefs.pre_merge_check === undefined) {
             return { passed: true, skipped: true };
         }
         // Determine command: explicit string or auto-detect from package.json

package/dist/resources/extensions/gsd/markdown-renderer.js

@@ -8,7 +8,6 @@
 // Critical invariant: rendered markdown must round-trip through
 // parseRoadmap(), parsePlan(), parseSummary() in files.ts.
 import { readFileSync, existsSync, mkdirSync } from "node:fs";
-import { isClosedStatus } from "./status-guards.js";
 import { join, relative } from "node:path";
 import { createRequire } from "node:module";
 import { getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getTask, getSlice, getArtifact, insertArtifact, getGateResults, } from "./gsd-db.js";
@@ -263,7 +262,7 @@ function renderSlicePlanMarkdown(slice, tasks, gates = []) {
     lines.push("## Tasks");
     lines.push("");
     for (const task of tasks) {
-        const done = isClosedStatus(task.status) ? "x" : " ";
+        const done = task.status === "done" || task.status === "complete" ? "x" : " ";
         const estimate = task.estimate.trim() ? ` \`est:${task.estimate.trim()}\`` : "";
         lines.push(`- [${done}] **${task.id}: ${task.title || task.id}**${estimate}`);
         if (task.description.trim()) {
@@ -436,7 +435,7 @@ export async function renderPlanCheckboxes(basePath, milestoneId, sliceId) {
     // Apply checkbox patches for each task
     let updated = content;
     for (const task of tasks) {
-        const isDone = isClosedStatus(task.status);
+        const isDone = task.status === "done" || task.status === "complete";
         const tid = task.id;
         if (isDone) {
             // Set [x]
@@ -661,7 +660,7 @@ export function detectStaleRenders(basePath) {
                     const content = readFileSync(planPath, "utf-8");
                     const parsed = parsePlan(content);
                     for (const task of tasks) {
-                        const isDoneInDb = isClosedStatus(task.status);
+                        const isDoneInDb = task.status === "done" || task.status === "complete";
                         const planTask = parsed.tasks.find((t) => t.id === task.id);
                         if (!planTask)
                             continue;
@@ -685,7 +684,7 @@ export function detectStaleRenders(basePath) {
             }
             // Check missing task summary files
             for (const task of tasks) {
-                if (isClosedStatus(task.status) && task.full_summary_md) {
+                if ((task.status === "done" || task.status === "complete") && task.full_summary_md) {
                     const slicePath = resolveSlicePath(basePath, milestone.id, slice.id);
                     if (slicePath) {
                         const tasksDir = join(slicePath, "tasks");

package/dist/resources/extensions/gsd/preferences-types.js

@@ -11,7 +11,7 @@ export const MODE_DEFAULTS = {
         git: {
             auto_push: true,
             push_branches: false,
-            pre_merge_check: "auto",
+            pre_merge_check: false,
             merge_strategy: "squash",
             isolation: "none",
         },

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

@@ -6,7 +6,6 @@ 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';
@@ -204,6 +203,12 @@ 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)
@@ -287,7 +292,7 @@ export async function deriveStateFromDb(basePath) {
             parkedMilestoneIds.add(m.id);
             continue;
         }
-        if (isClosedStatus(m.status)) {
+        if (isStatusDone(m.status)) {
             completeMilestoneIds.add(m.id);
             continue;
         }
@@ -299,7 +304,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 => isClosedStatus(s.status))) {
+        if (slices.length > 0 && slices.every(s => isStatusDone(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
@@ -318,7 +323,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 && !isClosedStatus(m.status)) {
+        if (slices.length === 0 && !isStatusDone(m.status)) {
             // Check disk for ghost detection
             if (isGhostMilestone(basePath, m.id))
                 continue;
@@ -339,7 +344,7 @@ export async function deriveStateFromDb(basePath) {
             continue;
         }
         // Not complete — determine if it should be active
-        const allSlicesDone = slices.length > 0 && slices.every(s => isClosedStatus(s.status));
+        const allSlicesDone = slices.length > 0 && slices.every(s => isStatusDone(s.status));
         // Get title — prefer DB, fall back to context file extraction
         let title = stripMilestonePrefix(m.title) || m.id;
         if (title === m.id) {
@@ -479,7 +484,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 => isClosedStatus(s.status));
+    const allSlicesDone = activeMilestoneSlices.length > 0 && activeMilestoneSlices.every(s => isStatusDone(s.status));
     if (allSlicesDone) {
         const validationFile = resolveMilestoneFile(basePath, activeMilestone.id, "VALIDATION");
         const validationContent = validationFile ? await loadFile(validationFile) : null;
@@ -509,14 +514,14 @@ export async function deriveStateFromDb(basePath) {
     }
     // ── Find active slice (first incomplete with deps satisfied) ─────────
     const sliceProgress = {
-        done: activeMilestoneSlices.filter(s => isClosedStatus(s.status)).length,
+        done: activeMilestoneSlices.filter(s => isStatusDone(s.status)).length,
         total: activeMilestoneSlices.length,
     };
-    const doneSliceIds = new Set(activeMilestoneSlices.filter(s => isClosedStatus(s.status)).map(s => s.id));
+    const doneSliceIds = new Set(activeMilestoneSlices.filter(s => isStatusDone(s.status)).map(s => s.id));
     let activeSlice = null;
     let activeSliceRow = null;
     for (const s of activeMilestoneSlices) {
-        if (isClosedStatus(s.status))
+        if (isStatusDone(s.status))
             continue;
         if (s.depends.every(dep => doneSliceIds.has(dep))) {
             activeSlice = { id: s.id, title: s.title };
@@ -556,7 +561,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 (isClosedStatus(t.status))
+        if (isStatusDone(t.status))
             continue;
         const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
         if (summaryPath && existsSync(summaryPath)) {
@@ -576,10 +581,10 @@ export async function deriveStateFromDb(basePath) {
         tasks = getSliceTasks(activeMilestone.id, activeSlice.id);
     }
     const taskProgress = {
-        done: tasks.filter(t => isClosedStatus(t.status)).length,
+        done: tasks.filter(t => isStatusDone(t.status)).length,
         total: tasks.length,
     };
-    const activeTaskRow = tasks.find(t => !isClosedStatus(t.status));
+    const activeTaskRow = tasks.find(t => !isStatusDone(t.status));
     if (!activeTaskRow && tasks.length > 0) {
         // All tasks done but slice not marked complete → summarizing
         return {
@@ -634,7 +639,7 @@ export async function deriveStateFromDb(basePath) {
         };
     }
     // ── Blocker detection: check completed tasks for blocker_discovered ──
-    const completedTasks = tasks.filter(t => isClosedStatus(t.status));
+    const completedTasks = tasks.filter(t => isStatusDone(t.status));
     let blockerTaskId = null;
     for (const ct of completedTasks) {
         if (ct.blocker_discovered) {

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

@@ -9,7 +9,6 @@ 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";
@@ -90,7 +89,7 @@ export async function handleCompleteMilestone(params, basePath) {
             guardError = `milestone not found: ${params.milestoneId}`;
             return;
         }
-        if (isClosedStatus(milestone.status)) {
+        if (milestone.status === "complete" || milestone.status === "done") {
             guardError = `milestone ${params.milestoneId} is already complete`;
             return;
         }
@@ -100,7 +99,7 @@ export async function handleCompleteMilestone(params, basePath) {
             guardError = `no slices found for milestone ${params.milestoneId}`;
             return;
         }
-        const incompleteSlices = slices.filter(s => !isClosedStatus(s.status));
+        const incompleteSlices = slices.filter(s => s.status !== "complete" && s.status !== "done");
         if (incompleteSlices.length > 0) {
             const incompleteIds = incompleteSlices.map(s => `${s.id} (status: ${s.status})`).join(", ");
             guardError = `incomplete slices: ${incompleteIds}`;
@@ -109,7 +108,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 => !isClosedStatus(t.status));
+            const incompleteTasks = tasks.filter(t => t.status !== "complete" && t.status !== "done");
             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,7 +8,6 @@
  */
 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";
@@ -180,12 +179,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 && isClosedStatus(milestone.status)) {
+        if (milestone && (milestone.status === "complete" || milestone.status === "done")) {
             guardError = `cannot complete slice in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
             return;
         }
         const slice = getSlice(params.milestoneId, params.sliceId);
-        if (slice && isClosedStatus(slice.status)) {
+        if (slice && (slice.status === "complete" || slice.status === "done")) {
             guardError = `slice ${params.sliceId} is already complete — use gsd_slice_reopen first if you need to redo it`;
             return;
         }
@@ -195,7 +194,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 => !isClosedStatus(t.status));
+        const incompleteTasks = tasks.filter(t => t.status !== "complete" && t.status !== "done");
         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,7 +8,6 @@
  */
 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";
@@ -123,17 +122,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 && isClosedStatus(milestone.status)) {
+        if (milestone && (milestone.status === "complete" || milestone.status === "done")) {
             guardError = `cannot complete task in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
             return;
         }
         const slice = getSlice(params.milestoneId, params.sliceId);
-        if (slice && isClosedStatus(slice.status)) {
+        if (slice && (slice.status === "complete" || slice.status === "done")) {
             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 && isClosedStatus(existingTask.status)) {
+        if (existingTask && (existingTask.status === "complete" || existingTask.status === "done")) {
             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,12 +1,22 @@
 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");
@@ -142,7 +152,7 @@ export async function handlePlanMilestone(rawParams, basePath) {
     try {
         transaction(() => {
             const existingMilestone = getMilestone(params.milestoneId);
-            if (existingMilestone && isClosedStatus(existingMilestone.status)) {
+            if (existingMilestone && (existingMilestone.status === "complete" || existingMilestone.status === "done")) {
                 guardError = `cannot re-plan milestone ${params.milestoneId}: it is already complete`;
                 return;
             }
@@ -154,7 +164,7 @@ export async function handlePlanMilestone(rawParams, basePath) {
                         guardError = `depends_on references unknown milestone: ${depId}`;
                         return;
                     }
-                    if (!isClosedStatus(dep.status)) {
+                    if (dep.status !== "complete" && dep.status !== "done") {
                         guardError = `depends_on milestone ${depId} is not yet complete (status: ${dep.status})`;
                         return;
                     }

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

@@ -1,12 +1,22 @@
 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");
@@ -103,7 +113,7 @@ export async function handlePlanSlice(rawParams, basePath) {
                 guardError = `milestone not found: ${params.milestoneId}`;
                 return;
             }
-            if (isClosedStatus(parentMilestone.status)) {
+            if (parentMilestone.status === "complete" || parentMilestone.status === "done") {
                 guardError = `cannot plan slice in a closed milestone: ${params.milestoneId} (status: ${parentMilestone.status})`;
                 return;
             }
@@ -112,7 +122,7 @@ export async function handlePlanSlice(rawParams, basePath) {
                 guardError = `missing parent slice: ${params.milestoneId}/${params.sliceId}`;
                 return;
             }
-            if (isClosedStatus(parentSlice.status)) {
+            if (parentSlice.status === "complete" || parentSlice.status === "done") {
                 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,12 +1,22 @@
 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");
@@ -51,12 +61,12 @@ export async function handlePlanTask(rawParams, basePath) {
                 guardError = `missing parent slice: ${params.milestoneId}/${params.sliceId}`;
                 return;
             }
-            if (isClosedStatus(parentSlice.status)) {
+            if (parentSlice.status === "complete" || parentSlice.status === "done") {
                 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 && isClosedStatus(existingTask.status)) {
+            if (existingTask && (existingTask.status === "complete" || existingTask.status === "done")) {
                 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,13 +1,14 @@
-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");
@@ -75,7 +76,7 @@ export async function handleReassessRoadmap(rawParams, basePath) {
                 guardError = `milestone not found: ${params.milestoneId}`;
                 return;
             }
-            if (isClosedStatus(milestone.status)) {
+            if (milestone.status === "complete" || milestone.status === "done") {
                 guardError = `cannot reassess a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
                 return;
             }
@@ -85,7 +86,7 @@ export async function handleReassessRoadmap(rawParams, basePath) {
                 guardError = `completedSliceId not found: ${params.milestoneId}/${params.completedSliceId}`;
                 return;
             }
-            if (!isClosedStatus(completedSlice.status)) {
+            if (completedSlice.status !== "complete" && completedSlice.status !== "done") {
                 guardError = `completedSliceId ${params.completedSliceId} is not complete (status: ${completedSlice.status}) — reassess can only be called after a slice finishes`;
                 return;
             }
@@ -93,7 +94,7 @@ export async function handleReassessRoadmap(rawParams, basePath) {
             const existingSlices = getMilestoneSlices(params.milestoneId);
             const completedSliceIds = new Set();
             for (const slice of existingSlices) {
-                if (isClosedStatus(slice.status)) {
+                if (slice.status === "complete" || slice.status === "done") {
                     completedSliceIds.add(slice.id);
                 }
             }

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

@@ -11,7 +11,6 @@
 // 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";
@@ -32,8 +31,8 @@ export async function handleReopenSlice(params, basePath) {
             guardError = `milestone not found: ${params.milestoneId}`;
             return;
         }
-        if (isClosedStatus(milestone.status)) {
-            guardError = `cannot reopen slice in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
+        if (milestone.status === "complete" || milestone.status === "done") {
+            guardError = `cannot reopen slice inside a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
             return;
         }
         const slice = getSlice(params.milestoneId, params.sliceId);
@@ -41,7 +40,7 @@ export async function handleReopenSlice(params, basePath) {
             guardError = `slice not found: ${params.milestoneId}/${params.sliceId}`;
             return;
         }
-        if (!isClosedStatus(slice.status)) {
+        if (slice.status !== "complete" && slice.status !== "done") {
             guardError = `slice ${params.sliceId} is not complete (status: ${slice.status}) — nothing to reopen`;
             return;
         }

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

@@ -10,7 +10,6 @@
 // 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";
@@ -33,7 +32,7 @@ export async function handleReopenTask(params, basePath) {
             guardError = `milestone not found: ${params.milestoneId}`;
             return;
         }
-        if (isClosedStatus(milestone.status)) {
+        if (milestone.status === "complete" || milestone.status === "done") {
             guardError = `cannot reopen task in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
             return;
         }
@@ -42,8 +41,8 @@ export async function handleReopenTask(params, basePath) {
             guardError = `slice not found: ${params.milestoneId}/${params.sliceId}`;
             return;
         }
-        if (isClosedStatus(slice.status)) {
-            guardError = `cannot reopen task in a closed slice: ${params.sliceId} (status: ${slice.status}) — use gsd_slice_reopen first`;
+        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`;
             return;
         }
         const task = getTask(params.milestoneId, params.sliceId, params.taskId);
@@ -51,7 +50,7 @@ export async function handleReopenTask(params, basePath) {
             guardError = `task not found: ${params.milestoneId}/${params.sliceId}/${params.taskId}`;
             return;
         }
-        if (!isClosedStatus(task.status)) {
+        if (task.status !== "complete" && task.status !== "done") {
             guardError = `task ${params.taskId} is not complete (status: ${task.status}) — nothing to reopen`;
             return;
         }

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

@@ -1,12 +1,13 @@
 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");
@@ -58,7 +59,7 @@ export async function handleReplanSlice(rawParams, basePath) {
                 guardError = `missing parent slice: ${params.milestoneId}/${params.sliceId}`;
                 return;
             }
-            if (isClosedStatus(parentSlice.status)) {
+            if (parentSlice.status === "complete" || parentSlice.status === "done") {
                 guardError = `cannot replan a closed slice: ${params.sliceId} (status: ${parentSlice.status})`;
                 return;
             }
@@ -68,7 +69,7 @@ export async function handleReplanSlice(rawParams, basePath) {
                 guardError = `blockerTaskId not found: ${params.milestoneId}/${params.sliceId}/${params.blockerTaskId}`;
                 return;
             }
-            if (!isClosedStatus(blockerTask.status)) {
+            if (blockerTask.status !== "complete" && blockerTask.status !== "done") {
                 guardError = `blockerTaskId ${params.blockerTaskId} is not complete (status: ${blockerTask.status}) — the blocker task must be finished before a replan is triggered`;
                 return;
             }
@@ -76,7 +77,7 @@ export async function handleReplanSlice(rawParams, basePath) {
             const existingTasks = getSliceTasks(params.milestoneId, params.sliceId);
             const completedTaskIds = new Set();
             for (const task of existingTasks) {
-                if (isClosedStatus(task.status)) {
+                if (task.status === "complete" || task.status === "done") {
                     completedTaskIds.add(task.id);
                 }
             }

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

@@ -75,17 +75,15 @@ export function resolveRtkBinaryPath(options = {}) {
     }
     return resolveSystemRtkPath(options.pathValue ?? getPathValue(env), platform);
 }
-export function rewriteCommandWithRtk(command, options = {}) {
-    const env = options.env ?? process.env;
+export function rewriteCommandWithRtk(command, env = process.env) {
     if (!command.trim())
         return command;
     if (!isRtkEnabled(env))
         return command;
-    const binaryPath = options.binaryPath ?? resolveRtkBinaryPath({ env });
+    const binaryPath = resolveRtkBinaryPath({ env });
     if (!binaryPath)
         return command;
-    const run = options.spawnSyncImpl ?? spawnSync;
-    const result = run(binaryPath, ["rewrite", command], {
+    const result = spawnSync(binaryPath, ["rewrite", command], {
         encoding: "utf-8",
         env: buildRtkEnv(env),
         stdio: ["ignore", "pipe", "ignore"],