gsd-pi 2.52.0-dev.585e355 → 2.52.0

package/src/resources/extensions/gsd/markdown-renderer.ts

@@ -9,7 +9,6 @@
 // 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 {
@@ -338,7 +337,7 @@ function renderSlicePlanMarkdown(slice: SliceRow, tasks: TaskRow[], gates: GateR
   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()) {
@@ -574,7 +573,7 @@ export async function renderPlanCheckboxes(
   // 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) {
@@ -858,7 +857,7 @@ export function detectStaleRenders(basePath: string): StaleEntry[] {
           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: { id: string }) => t.id === task.id);
             if (!planTask) continue;
 
@@ -881,7 +880,7 @@ export function detectStaleRenders(basePath: string): StaleEntry[] {
 
       // 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/src/resources/extensions/gsd/preferences-types.ts

@@ -33,7 +33,7 @@ export const MODE_DEFAULTS: Record<WorkflowMode, Partial<GSDPreferences>> = {
     git: {
       auto_push: true,
       push_branches: false,
-      pre_merge_check: "auto",
+      pre_merge_check: false,
       merge_strategy: "squash",
       isolation: "none",
     },

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

@@ -36,7 +36,6 @@ import {
 
 import { findMilestoneIds } from './milestone-ids.js';
 import { loadQueueOrder, sortByQueueOrder } from './queue-order.js';
-import { isClosedStatus } from './status-guards.js';
 import { nativeBatchParseGsdFiles, type BatchParsedFile } from './native-parser-bridge.js';
 
 import { join, resolve } from 'path';
@@ -273,6 +272,13 @@ function extractContextTitle(content: string | null, fallback: string): string {
 
 // ─── DB-backed State Derivation ────────────────────────────────────────────
 
+/**
+ * Helper: check if a DB status counts as "done" (handles K002 ambiguity).
+ */
+function isStatusDone(status: string): boolean {
+  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)
@@ -362,7 +368,7 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
       continue;
     }
 
-    if (isClosedStatus(m.status)) {
+    if (isStatusDone(m.status)) {
       completeMilestoneIds.add(m.id);
       continue;
     }
@@ -376,7 +382,7 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
 
     // 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
@@ -398,7 +404,7 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
 
     // 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;
     }
@@ -421,7 +427,7 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
     }
 
     // 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;
@@ -576,7 +582,7 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
   // 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;
@@ -609,19 +615,19 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
 
   // ── 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)
+    activeMilestoneSlices.filter(s => isStatusDone(s.status)).map(s => s.id)
   );
 
   let activeSlice: ActiveRef | null = null;
   let activeSliceRow: SliceRow | null = null;
 
   for (const s of activeMilestoneSlices) {
-    if (isClosedStatus(s.status)) continue;
+    if (isStatusDone(s.status)) continue;
     if (s.depends.every(dep => doneSliceIds.has(dep))) {
       activeSlice = { id: s.id, title: s.title };
       activeSliceRow = s;
@@ -664,7 +670,7 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
   // causing the dispatcher to re-dispatch the same completed task forever.
   let reconciled = false;
   for (const t of tasks) {
-    if (isClosedStatus(t.status)) continue;
+    if (isStatusDone(t.status)) continue;
     const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
     if (summaryPath && existsSync(summaryPath)) {
       try {
@@ -687,11 +693,11 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
   }
 
   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
@@ -752,7 +758,7 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
   }
 
   // ── 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: string | null = null;
   for (const ct of completedTasks) {
     if (ct.blocker_discovered) {

package/src/resources/extensions/gsd/tests/git-service.test.ts

@@ -635,11 +635,11 @@ describe('git-service', async () => {
   // S05: Enhanced features — snapshots, pre-merge checks
   // ═══════════════════════════════════════════════════════════════════════
 
-  // ─── createSnapshot: default (enabled) ─────────────────────────────────
+  // ─── createSnapshot: prefs enabled ─────────────────────────────────────
 
-  test('createSnapshot: enabled by default when prefs omitted', () => {
+  test('createSnapshot: enabled', () => {
     const repo = initBranchTestRepo();
-    const svc = new GitServiceImpl(repo);
+    const svc = new GitServiceImpl(repo, { snapshots: true });
 
     // Create a branch with a commit
     run("git checkout -b gsd/M001/S01", repo);
@@ -675,39 +675,6 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
-  // ─── runPreMergeCheck: default (auto-detect) ──────────────────────────
-
-  test('runPreMergeCheck: auto-detects when prefs omitted', () => {
-    const repo = initBranchTestRepo();
-    createFile(repo, "package.json", JSON.stringify({
-      name: "test-default",
-      scripts: { test: 'node -e "process.exit(0)"' },
-    }));
-    run("git add -A", repo);
-    run('git commit -m "add package.json"', repo);
-
-    // No pre_merge_check pref set — should auto-detect and run
-    const svc = new GitServiceImpl(repo);
-    const result: PreMergeCheckResult = svc.runPreMergeCheck();
-
-    assert.deepStrictEqual(result.passed, true, "runPreMergeCheck auto-detects and passes when prefs omitted");
-    assert.ok(!result.skipped, "runPreMergeCheck is not skipped when prefs omitted and package.json exists");
-
-    rmSync(repo, { recursive: true, force: true });
-  });
-
-  test('runPreMergeCheck: gracefully skips when prefs omitted and no package.json', () => {
-    const repo = initBranchTestRepo();
-    // No package.json — auto-detect should skip gracefully
-    const svc = new GitServiceImpl(repo);
-    const result: PreMergeCheckResult = svc.runPreMergeCheck();
-
-    assert.deepStrictEqual(result.passed, true, "runPreMergeCheck passes when no package.json (skip)");
-    assert.deepStrictEqual(result.skipped, true, "runPreMergeCheck skips when no test runner detected");
-
-    rmSync(repo, { recursive: true, force: true });
-  });
-
   // ─── runPreMergeCheck: pass ────────────────────────────────────────────
 
   test('runPreMergeCheck: pass', () => {

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

@@ -59,7 +59,7 @@ test("solo mode applies correct defaults", () => {
   const result = applyModeDefaults("solo", { mode: "solo" });
   assert.equal(result.git?.auto_push, true);
   assert.equal(result.git?.push_branches, false);
-  assert.equal(result.git?.pre_merge_check, "auto");
+  assert.equal(result.git?.pre_merge_check, false);
   assert.equal(result.git?.merge_strategy, "squash");
   assert.equal(result.git?.isolation, "none");
   assert.equal(result.unique_milestone_ids, false);

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

@@ -17,7 +17,6 @@ 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";
@@ -135,7 +134,7 @@ export async function handleCompleteMilestone(
       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;
     }
@@ -147,7 +146,7 @@ export async function handleCompleteMilestone(
       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}`;
@@ -157,7 +156,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 => !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/src/resources/extensions/gsd/tools/complete-slice.ts

@@ -11,7 +11,6 @@ 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,
@@ -226,13 +225,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 && 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;
     }
@@ -244,7 +243,7 @@ export async function handleCompleteSlice(
       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/src/resources/extensions/gsd/tools/complete-task.ts

@@ -11,7 +11,6 @@ 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,
@@ -160,19 +159,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 && 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/src/resources/extensions/gsd/tools/plan-milestone.ts

@@ -1,6 +1,4 @@
 import { clearParseCache } from "../files.js";
-import { isClosedStatus } from "../status-guards.js";
-import { isNonEmptyString, validateStringArray } from "../validation.js";
 import {
   transaction,
   getMilestone,
@@ -56,6 +54,20 @@ 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");
@@ -184,7 +196,7 @@ export async function handlePlanMilestone(
   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;
       }
@@ -197,7 +209,7 @@ export async function handlePlanMilestone(
             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/src/resources/extensions/gsd/tools/plan-slice.ts

@@ -1,6 +1,4 @@
 import { clearParseCache } from "../files.js";
-import { isClosedStatus } from "../status-guards.js";
-import { isNonEmptyString, validateStringArray } from "../validation.js";
 import {
   transaction,
   getMilestone,
@@ -52,6 +50,20 @@ 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");
@@ -145,7 +157,7 @@ export async function handlePlanSlice(
         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;
       }
@@ -155,7 +167,7 @@ export async function handlePlanSlice(
         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/src/resources/extensions/gsd/tools/plan-task.ts

@@ -1,6 +1,4 @@
 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";
@@ -34,6 +32,20 @@ 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");
@@ -77,13 +89,13 @@ export async function handlePlanTask(
         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/src/resources/extensions/gsd/tools/reassess-roadmap.ts

@@ -1,7 +1,4 @@
-import { join } from "node:path";
 import { clearParseCache } from "../files.js";
-import { isClosedStatus } from "../status-guards.js";
-import { isNonEmptyString } from "../validation.js";
 import {
   transaction,
   getMilestone,
@@ -17,6 +14,7 @@ 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;
@@ -49,6 +47,9 @@ 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");
@@ -124,7 +125,7 @@ export async function handleReassessRoadmap(
         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;
       }
@@ -135,7 +136,7 @@ export async function handleReassessRoadmap(
         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;
       }
@@ -144,7 +145,7 @@ export async function handleReassessRoadmap(
       const existingSlices = getMilestoneSlices(params.milestoneId);
       const completedSliceIds = new Set<string>();
       for (const slice of existingSlices) {
-        if (isClosedStatus(slice.status)) {
+        if (slice.status === "complete" || slice.status === "done") {
           completedSliceIds.add(slice.id);
         }
       }

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

@@ -20,7 +20,6 @@ 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,8 +62,8 @@ export async function handleReopenSlice(
       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;
     }
 
@@ -73,7 +72,7 @@ export async function handleReopenSlice(
       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/src/resources/extensions/gsd/tools/reopen-task.ts

@@ -18,7 +18,6 @@ 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";
@@ -64,7 +63,7 @@ export async function handleReopenTask(
       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;
     }
@@ -74,8 +73,8 @@ export async function handleReopenTask(
       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;
     }
 
@@ -84,7 +83,7 @@ export async function handleReopenTask(
       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/src/resources/extensions/gsd/tools/replan-slice.ts

@@ -10,8 +10,6 @@ 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";
@@ -50,6 +48,10 @@ 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");
@@ -102,7 +104,7 @@ export async function handleReplanSlice(
         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;
       }
@@ -113,7 +115,7 @@ export async function handleReplanSlice(
         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;
       }
@@ -122,7 +124,7 @@ export async function handleReplanSlice(
       const existingTasks = getSliceTasks(params.milestoneId, params.sliceId);
       const completedTaskIds = new Set<string>();
       for (const task of existingTasks) {
-        if (isClosedStatus(task.status)) {
+        if (task.status === "complete" || task.status === "done") {
           completedTaskIds.add(task.id);
         }
       }