@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.0b870afa

package/dist/resources/extensions/gsd/tools/exec-tool.js

@@ -4,6 +4,7 @@ import { EXEC_DEFAULTS, runExecSandbox, } from "../exec-sandbox.js";
 import { realpathSync } from "node:fs";
 import path from "node:path";
 import { isContextModeEnabled } from "../preferences-types.js";
+import { projectRootFromWorktreePath } from "../worktree-root.js";
 import { contextModeDisabledResult } from "./context-mode-tool-result.js";
 const UAT_EXEC_INTENTS = [
     "uat-artifact-check",
@@ -141,14 +142,10 @@ function normalizeScanPath(value) {
 }
 function parseWorktreeBase(baseDir) {
     const normalizedBase = normalizeScanPath(baseDir);
-    const marker = "/.gsd/worktrees/";
-    const markerIndex = normalizedBase.indexOf(marker);
-    if (markerIndex <= 0)
+    const originalRoot = projectRootFromWorktreePath(normalizedBase);
+    if (!originalRoot)
         return null;
-    return {
-        originalRoot: normalizedBase.slice(0, markerIndex),
-        worktreeRoot: normalizedBase,
-    };
+    return { originalRoot, worktreeRoot: normalizedBase };
 }
 function pathInside(parent, target) {
     const parentWithSep = parent.endsWith("/") ? parent : `${parent}/`;
@@ -234,7 +231,7 @@ function scriptReferencesOriginalRootFromWorktree(script, baseDir) {
         return false;
     const normalizedScript = script.replace(/\\/g, "/");
     return comparablePathVariants(parsed.originalRoot).some((originalRoot) => {
-        const originalRootPattern = new RegExp(`${escapeRegExp(originalRoot)}(?=$|[\\s'"\\\`;)&|<>]|/(?!\\.gsd/worktrees(?:/|$)))`);
+        const originalRootPattern = new RegExp(`${escapeRegExp(originalRoot)}(?=$|[\\s'"\\\`;)&|<>]|/(?!\\.gsd(?:-worktrees|/worktrees)(?:/|$)))`);
         return originalRootPattern.test(normalizedScript);
     });
 }
@@ -345,6 +342,7 @@ function formatResult(result) {
             exit_code: result.exit_code,
             signal: result.signal,
             timed_out: result.timed_out,
+            force_resolved: result.force_resolved,
             duration_ms: result.duration_ms,
             stdout_bytes: result.stdout_bytes,
             stderr_bytes: result.stderr_bytes,
@@ -358,6 +356,10 @@ function formatResult(result) {
     };
 }
 function formatExit(result) {
+    // force_resolved means a non-closing (D-state) child was force-resolved past its
+    // hard deadline rather than observed exiting; distinguish it from a clean timeout.
+    if (result.force_resolved)
+        return "timeout(force-killed)";
     if (result.timed_out)
         return "timeout";
     if (result.signal)

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

@@ -1,15 +1,7 @@
 // Project/App: gsd-pi
 // File Purpose: Plans milestone roadmap state through DB-backed workflow tools.
-import { clearParseCache } from "../files.js";
-import { isClosedStatus } from "../status-guards.js";
 import { isNonEmptyString, validateStringArray, validateTitle } from "../validation.js";
-import { transaction, getMilestone, getMilestoneSlices, getSlice, 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";
-import { logWarning } from "../workflow-logger.js";
+import { persistMilestonePlan } from "../milestone-planning-persistence.js";
 function validateRiskEntries(value) {
     if (!Array.isArray(value)) {
         throw new Error("keyRisks must be an array");
@@ -43,10 +35,16 @@ function validateProofStrategy(value) {
         return { riskOrUnknown, retireIn, whatWillBeProven };
     });
 }
+const SLICE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9-]*$/;
 function validateSlices(value) {
     if (!Array.isArray(value) || value.length === 0) {
         throw new Error("slices must be a non-empty array");
     }
+    // Pre-collect all slice IDs so depends cross-validation can reference the full set.
+    const allSliceIds = new Set(value
+        .filter((e) => !!e && typeof e === "object")
+        .map(e => e.sliceId)
+        .filter((id) => isNonEmptyString(id)));
     const seen = new Set();
     return value.map((entry, index) => {
         if (!entry || typeof entry !== "object") {
@@ -84,8 +82,13 @@ function validateSlices(value) {
             throw new Error(`slices[${index}].title is invalid: ${titleIssue}`);
         if (!isNonEmptyString(risk))
             throw new Error(`slices[${index}].risk must be a non-empty string`);
-        if (!Array.isArray(depends) || depends.some((item) => !isNonEmptyString(item))) {
-            throw new Error(`slices[${index}].depends must be an array of non-empty strings`);
+        if (!Array.isArray(depends) || depends.some((item) => !isNonEmptyString(item) || !SLICE_ID_RE.test(item))) {
+            throw new Error(`slices[${index}].depends must be an array of valid slice IDs (e.g. "S01")`);
+        }
+        for (const dep of depends) {
+            if (!allSliceIds.has(dep)) {
+                throw new Error(`slices[${index}].depends references unknown slice "${dep}" — check that it is defined in the same milestone`);
+            }
         }
         if (!isNonEmptyString(demo))
             throw new Error(`slices[${index}].demo must be a non-empty string`);
@@ -160,136 +163,5 @@ export async function handlePlanMilestone(rawParams, basePath) {
     catch (err) {
         return { error: `validation failed: ${err.message}` };
     }
-    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
-    // Guards must be inside the transaction so the state they check cannot
-    // change between the read and the write (#2723).
-    let guardError = null;
-    try {
-        transaction(() => {
-            const existingMilestone = getMilestone(params.milestoneId);
-            if (existingMilestone && isClosedStatus(existingMilestone.status)) {
-                guardError = `cannot re-plan milestone ${params.milestoneId}: it is already complete`;
-                return;
-            }
-            // Guard: refuse to re-plan a milestone that would drop completed slices (#2960).
-            // Allow re-planning when all completed slices are still present in the
-            // incoming plan — their status is preserved below (#2558). Block only when
-            // the new plan omits a completed slice, which could shadow completed work.
-            const existingSlices = getMilestoneSlices(params.milestoneId);
-            const completedSlices = existingSlices.filter(s => isClosedStatus(s.status));
-            if (completedSlices.length > 0) {
-                const incomingSliceIds = new Set(params.slices.map(s => s.sliceId));
-                const droppedCompleted = completedSlices.filter(s => !incomingSliceIds.has(s.id));
-                if (droppedCompleted.length > 0) {
-                    guardError = `cannot re-plan milestone ${params.milestoneId}: ${droppedCompleted.length} completed slice(s) would be dropped (${droppedCompleted.map(s => s.id).join(", ")}). Use gsd_reassess_roadmap to modify the roadmap.`;
-                    return;
-                }
-            }
-            // Validate depends_on: all dependencies must exist and be complete
-            if (params.dependsOn && params.dependsOn.length > 0) {
-                for (const depId of params.dependsOn) {
-                    const dep = getMilestone(depId);
-                    if (!dep) {
-                        guardError = `depends_on references unknown milestone: ${depId}`;
-                        return;
-                    }
-                    if (!isClosedStatus(dep.status)) {
-                        guardError = `depends_on milestone ${depId} is not yet complete (status: ${dep.status})`;
-                        return;
-                    }
-                }
-            }
-            insertMilestone({
-                id: params.milestoneId,
-                title: params.title,
-                status: params.status ?? "active",
-                depends_on: params.dependsOn ?? [],
-            });
-            upsertMilestonePlanning(params.milestoneId, {
-                title: params.title,
-                status: params.status ?? "active",
-                depends_on: params.dependsOn ?? [],
-                vision: params.vision,
-                successCriteria: params.successCriteria,
-                keyRisks: params.keyRisks,
-                proofStrategy: params.proofStrategy,
-                verificationContract: params.verificationContract,
-                verificationIntegration: params.verificationIntegration,
-                verificationOperational: params.verificationOperational,
-                verificationUat: params.verificationUat,
-                definitionOfDone: params.definitionOfDone,
-                requirementCoverage: params.requirementCoverage,
-                boundaryMapMarkdown: params.boundaryMapMarkdown,
-            });
-            for (let i = 0; i < params.slices.length; i++) {
-                const slice = params.slices[i];
-                // Preserve completed/done status on re-plan (#2558).
-                // Without this, a re-plan after milestone transition would reset
-                // already-completed slices back to "pending".
-                const existing = getSlice(params.milestoneId, slice.sliceId);
-                const status = existing && (existing.status === "complete" || existing.status === "done")
-                    ? existing.status
-                    : "pending";
-                insertSlice({
-                    id: slice.sliceId,
-                    milestoneId: params.milestoneId,
-                    title: slice.title,
-                    status,
-                    risk: slice.risk,
-                    depends: slice.depends,
-                    demo: slice.demo,
-                    sequence: i + 1, // Preserve agent-ordered sequence (#3356)
-                    // ADR-011: pass undefined through so ON CONFLICT preserves existing values
-                    // when the caller omitted the fields on a re-plan.
-                    isSketch: slice.isSketch,
-                    sketchScope: slice.sketchScope,
-                });
-                upsertSlicePlanning(params.milestoneId, slice.sliceId, {
-                    goal: slice.goal,
-                    successCriteria: slice.successCriteria,
-                    proofLevel: slice.proofLevel,
-                    integrationClosure: slice.integrationClosure,
-                    observabilityImpact: slice.observabilityImpact,
-                });
-            }
-        });
-    }
-    catch (err) {
-        return { error: `db write failed: ${err.message}` };
-    }
-    if (guardError) {
-        return { error: guardError };
-    }
-    let roadmapPath;
-    try {
-        const renderResult = await renderRoadmapFromDb(basePath, params.milestoneId);
-        roadmapPath = renderResult.roadmapPath;
-    }
-    catch (renderErr) {
-        logWarning("tool", `plan_milestone — render failed (DB rows preserved for debugging): ${renderErr.message}`);
-        invalidateStateCache();
-        return { error: `render failed: ${renderErr.message}` };
-    }
-    invalidateStateCache();
-    clearParseCache();
-    // ── Post-mutation hook: projections, manifest, event log ───────────────
-    try {
-        await renderAllProjections(basePath, params.milestoneId);
-        writeManifest(basePath);
-        appendEvent(basePath, {
-            cmd: "plan-milestone",
-            params: { milestoneId: params.milestoneId },
-            ts: new Date().toISOString(),
-            actor: "agent",
-            actor_name: params.actorName,
-            trigger_reason: params.triggerReason,
-        });
-    }
-    catch (hookErr) {
-        logWarning("tool", `plan-milestone post-mutation hook warning: ${hookErr.message}`);
-    }
-    return {
-        milestoneId: params.milestoneId,
-        roadmapPath,
-    };
+    return persistMilestonePlan(params, basePath);
 }

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

@@ -7,12 +7,13 @@ import { getGateIdsForTurn } from "../gate-registry.js";
 import { transaction, getMilestone, getSlice, getSliceTasks, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, updateSliceStatus, setSliceSketchFlag, deleteTask, deleteArtifactByPath, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
 import { validatePathOnlyPlanningFields, validatePlanningPathScope } from "../planning-path-scope.js";
-import { checkFilePathConsistency, checkTaskOrdering } from "../pre-execution-checks.js";
+import { runTaskPathChecks } from "../pre-execution-checks.js";
+import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { buildTaskFileName, gsdProjectionRoot } from "../paths.js";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { createRepositoryRegistryFromPreferences, defaultRepositoryTargets } from "../repository-registry.js";
@@ -193,11 +194,16 @@ function validateTaskPathsBeforePersist(params, basePath, defaultTargets, allowe
     const additionalRoots = allowedRoots
         .map((root) => resolve(root))
         .filter((root) => root !== baseRoot);
-    const context = additionalRoots.length > 0 ? { additionalRoots } : undefined;
-    const checks = [
-        ...checkFilePathConsistency(taskRows, basePath, context),
-        ...checkTaskOrdering(taskRows, basePath, context),
-    ];
+    const resolvedCanonicalRoot = resolve(resolveWorktreeProjectRoot(basePath));
+    const canonicalProjectRoot = resolvedCanonicalRoot !== baseRoot ? resolvedCanonicalRoot : undefined;
+    const hasContext = additionalRoots.length > 0 || canonicalProjectRoot !== undefined;
+    const context = hasContext
+        ? {
+            ...(additionalRoots.length > 0 ? { additionalRoots } : {}),
+            ...(canonicalProjectRoot !== undefined ? { canonicalProjectRoot } : {}),
+        }
+        : undefined;
+    const checks = runTaskPathChecks(taskRows, basePath, context);
     const blocking = checks.filter((check) => !check.passed && check.blocking);
     if (blocking.length === 0)
         return null;
@@ -361,7 +367,7 @@ export async function handlePlanSlice(rawParams, basePath) {
         clearParseCache();
         // ── Post-mutation hook: projections, manifest, event log ─────────────
         try {
-            await renderAllProjections(basePath, params.milestoneId);
+            await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
             writeManifest(basePath);
             appendEvent(basePath, {
                 cmd: "plan-slice",

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

@@ -4,7 +4,7 @@ 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 { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -110,7 +110,7 @@ export async function handlePlanTask(rawParams, basePath) {
         clearParseCache();
         // ── Post-mutation hook: projections, manifest, event log ─────────────
         try {
-            await renderAllProjections(basePath, params.milestoneId);
+            await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
             writeManifest(basePath);
             appendEvent(basePath, {
                 cmd: "plan-task",

package/dist/resources/extensions/gsd/tools/reassess-roadmap.js

@@ -6,7 +6,7 @@ import { isNonEmptyString } from "../validation.js";
 import { transaction, getMilestone, getMilestoneSlices, getSlice, insertSlice, updateSliceFields, insertAssessment, deleteAssessmentByScope, deleteSlice, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb, renderAssessmentFromDb } from "../markdown-renderer.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -31,6 +31,7 @@ function validateParams(params) {
     if (!Array.isArray(params.sliceChanges.removed)) {
         throw new Error("sliceChanges.removed must be an array");
     }
+    const SLICE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9-]*$/;
     // Validate each modified slice
     for (let i = 0; i < params.sliceChanges.modified.length; i++) {
         const s = params.sliceChanges.modified[i];
@@ -40,6 +41,11 @@ function validateParams(params) {
             throw new Error(`sliceChanges.modified[${i}].sliceId is required`);
         if (!isNonEmptyString(s.title))
             throw new Error(`sliceChanges.modified[${i}].title is required`);
+        if (s.depends !== undefined) {
+            if (!Array.isArray(s.depends) || s.depends.some((item) => !isNonEmptyString(item) || !SLICE_ID_RE.test(item))) {
+                throw new Error(`sliceChanges.modified[${i}].depends must be an array of valid slice IDs (e.g. "S01")`);
+            }
+        }
     }
     // Validate each added slice
     for (let i = 0; i < params.sliceChanges.added.length; i++) {
@@ -50,6 +56,11 @@ function validateParams(params) {
             throw new Error(`sliceChanges.added[${i}].sliceId is required`);
         if (!isNonEmptyString(s.title))
             throw new Error(`sliceChanges.added[${i}].title is required`);
+        if (s.depends !== undefined) {
+            if (!Array.isArray(s.depends) || s.depends.some((item) => !isNonEmptyString(item) || !SLICE_ID_RE.test(item))) {
+                throw new Error(`sliceChanges.added[${i}].depends must be an array of valid slice IDs (e.g. "S01")`);
+            }
+        }
     }
     return params;
 }
@@ -111,6 +122,34 @@ export async function handleReassessRoadmap(rawParams, basePath) {
                     return;
                 }
             }
+            // Cross-milestone depends validation — effective slice ID set after this reassessment
+            const removedIds = new Set(params.sliceChanges.removed);
+            const effectiveSliceIds = new Set(existingSlices.map(s => s.id).filter(id => !removedIds.has(id)));
+            for (const added of params.sliceChanges.added) {
+                effectiveSliceIds.add(added.sliceId);
+            }
+            for (let i = 0; i < params.sliceChanges.modified.length; i++) {
+                const mod = params.sliceChanges.modified[i];
+                if (mod.depends !== undefined) {
+                    for (const dep of mod.depends) {
+                        if (!effectiveSliceIds.has(dep)) {
+                            guardError = `sliceChanges.modified[${i}].depends references unknown slice "${dep}" — check that it is defined in this milestone`;
+                            return;
+                        }
+                    }
+                }
+            }
+            for (let i = 0; i < params.sliceChanges.added.length; i++) {
+                const added = params.sliceChanges.added[i];
+                if (added.depends !== undefined) {
+                    for (const dep of added.depends) {
+                        if (!effectiveSliceIds.has(dep)) {
+                            guardError = `sliceChanges.added[${i}].depends references unknown slice "${dep}" — check that it is defined in this milestone`;
+                            return;
+                        }
+                    }
+                }
+            }
             // Record assessment
             insertAssessment({
                 path: assessmentRelPath,
@@ -195,7 +234,7 @@ export async function handleReassessRoadmap(rawParams, basePath) {
         clearParseCache();
         // ── Post-mutation hook: projections, manifest, event log ─────
         try {
-            await renderAllProjections(basePath, params.milestoneId);
+            await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
             writeManifest(basePath);
             appendEvent(basePath, {
                 cmd: "reassess-roadmap",

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

@@ -7,10 +7,9 @@
  * artifacts so the DB-filesystem reconciler does not auto-correct
  * entities back to "complete".
  */
-import { getMilestone, getMilestoneSlices, getSliceTasks, reopenMilestoneStatus, updateSliceStatus, updateTaskStatus, transaction, } from "../gsd-db.js";
+import { getMilestoneSlices, getSliceTasks, reopenMilestoneCascade, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
-import { isClosedStatus } from "../status-guards.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -23,35 +22,18 @@ export async function handleReopenMilestone(params, basePath) {
     if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
         return { error: "milestoneId is required and must be a non-empty string" };
     }
-    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
-    let guardError = null;
-    let slicesResetCount = 0;
-    let tasksResetCount = 0;
-    transaction(() => {
-        const milestone = getMilestone(params.milestoneId);
-        if (!milestone) {
-            guardError = `milestone not found: ${params.milestoneId}`;
-            return;
+    // ── Atomic reopen cascade (guards + writes in one transaction) ───────────
+    const outcome = reopenMilestoneCascade(params.milestoneId);
+    if (!outcome.ok) {
+        switch (outcome.reason) {
+            case "milestone-not-found":
+                return { error: `milestone not found: ${params.milestoneId}` };
+            case "milestone-not-closed":
+                return { error: `milestone ${params.milestoneId} is not closed (status: ${outcome.status}) — nothing to reopen` };
         }
-        if (!isClosedStatus(milestone.status)) {
-            guardError = `milestone ${params.milestoneId} is not closed (status: ${milestone.status}) — nothing to reopen`;
-            return;
-        }
-        reopenMilestoneStatus(params.milestoneId);
-        const slices = getMilestoneSlices(params.milestoneId);
-        slicesResetCount = slices.length;
-        for (const slice of slices) {
-            updateSliceStatus(params.milestoneId, slice.id, "in_progress");
-            const tasks = getSliceTasks(params.milestoneId, slice.id);
-            tasksResetCount += tasks.length;
-            for (const task of tasks) {
-                updateTaskStatus(params.milestoneId, slice.id, task.id, "pending");
-            }
-        }
-    });
-    if (guardError) {
-        return { error: guardError };
     }
+    const slicesResetCount = outcome.slicesReset;
+    const tasksResetCount = outcome.tasksReset;
     // ── Invalidate caches ────────────────────────────────────────────────────
     invalidateStateCache();
     // ── Clean up stale filesystem artifacts (M12 fix) ────────────────────────
@@ -92,7 +74,7 @@ export async function handleReopenMilestone(params, basePath) {
     clearPathCache();
     // ── Post-mutation hook ───────────────────────────────────────────────────
     try {
-        await renderAllProjections(basePath, params.milestoneId);
+        await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
         writeManifest(basePath);
         appendEvent(basePath, {
             cmd: "reopen-milestone",

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

@@ -9,10 +9,9 @@
  */
 // GSD — reopen-slice tool handler
 // Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
-import { getMilestone, getSlice, getSliceTasks, updateSliceStatus, updateTaskStatus, transaction, } from "../gsd-db.js";
+import { getSliceTasks, reopenSliceCascade, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
-import { isClosedStatus } from "../status-guards.js";
-import { renderAllProjections } from "../workflow-projections.js";
+import { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -27,39 +26,21 @@ export async function handleReopenSlice(params, basePath) {
     if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
         return { error: "milestoneId is required and must be a non-empty string" };
     }
-    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
-    let guardError = null;
-    let tasksResetCount = 0;
-    transaction(() => {
-        const milestone = getMilestone(params.milestoneId);
-        if (!milestone) {
-            guardError = `milestone not found: ${params.milestoneId}`;
-            return;
+    // ── Atomic reopen cascade (guards + writes in one transaction) ───────────
+    const outcome = reopenSliceCascade(params.milestoneId, params.sliceId);
+    if (!outcome.ok) {
+        switch (outcome.reason) {
+            case "milestone-not-found":
+                return { error: `milestone not found: ${params.milestoneId}` };
+            case "milestone-closed":
+                return { error: `cannot reopen slice in a closed milestone: ${params.milestoneId} (status: ${outcome.status})` };
+            case "slice-not-found":
+                return { error: `slice not found: ${params.milestoneId}/${params.sliceId}` };
+            case "slice-not-complete":
+                return { error: `slice ${params.sliceId} is not complete (status: ${outcome.status}) — nothing to reopen` };
         }
-        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);
-        if (!slice) {
-            guardError = `slice not found: ${params.milestoneId}/${params.sliceId}`;
-            return;
-        }
-        if (!isClosedStatus(slice.status)) {
-            guardError = `slice ${params.sliceId} is not complete (status: ${slice.status}) — nothing to reopen`;
-            return;
-        }
-        // Fetch tasks inside txn so the list is consistent with the slice status check
-        const tasks = getSliceTasks(params.milestoneId, params.sliceId);
-        tasksResetCount = tasks.length;
-        updateSliceStatus(params.milestoneId, params.sliceId, "in_progress");
-        for (const task of tasks) {
-            updateTaskStatus(params.milestoneId, params.sliceId, task.id, "pending");
-        }
-    });
-    if (guardError) {
-        return { error: guardError };
     }
+    const tasksResetCount = outcome.tasksReset;
     // ── Invalidate caches ────────────────────────────────────────────────────
     invalidateStateCache();
     // ── Clean up stale filesystem artifacts (M12 fix) ────────────────────────
@@ -91,7 +72,7 @@ export async function handleReopenSlice(params, basePath) {
     clearPathCache();
     // ── Post-mutation hook ───────────────────────────────────────────────────
     try {
-        await renderAllProjections(basePath, params.milestoneId);
+        await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
         writeManifest(basePath);
         appendEvent(basePath, {
             cmd: "reopen-slice",

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

@@ -11,7 +11,7 @@
 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 { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -83,7 +83,7 @@ export async function handleReopenTask(params, basePath) {
     clearPathCache();
     // ── Post-mutation hook ───────────────────────────────────────────────────
     try {
-        await renderAllProjections(basePath, params.milestoneId);
+        await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
         writeManifest(basePath);
         appendEvent(basePath, {
             cmd: "reopen-task",

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

@@ -4,7 +4,7 @@ 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 { flushWorkflowProjections } from "../projection-flush.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
@@ -162,7 +162,7 @@ export async function handleReplanSlice(rawParams, basePath) {
         clearParseCache();
         // ── Post-mutation hook: projections, manifest, event log ─────
         try {
-            await renderAllProjections(basePath, params.milestoneId);
+            await flushWorkflowProjections(basePath, { milestoneId: params.milestoneId });
             writeManifest(basePath);
             appendEvent(basePath, {
                 cmd: "replan-slice",

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

@@ -9,8 +9,7 @@
  * This function performs DB writes only. The MCP wrapper in
  * bootstrap/db-tools.ts handles state-cache invalidation and STATE.md rebuild.
  */
-import { getSlice, getSliceTasks, isDbAvailable, transaction, updateSliceStatus, updateTaskStatus, } from "../gsd-db.js";
-import { isClosedStatus } from "../status-guards.js";
+import { isDbAvailable, skipSliceCascade, } from "../gsd-db.js";
 /**
  * Mark a slice as "skipped" and cascade the skip to every non-closed task in
  * that slice. Runs as a single transaction so slice status and task statuses
@@ -39,40 +38,23 @@ export function handleSkipSlice(params) {
     if (!isDbAvailable()) {
         throw new Error("handleSkipSlice: GSD database is not available");
     }
-    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ────
-    let guardError = null;
-    let guardCode = null;
-    let wasAlreadySkipped = false;
-    let tasksSkipped = 0;
-    transaction(() => {
-        const slice = getSlice(params.milestoneId, params.sliceId);
-        if (!slice) {
-            guardError = `Slice ${params.sliceId} not found in milestone ${params.milestoneId}`;
-            guardCode = "slice_not_found";
-            return;
+    // ── Atomic skip cascade (guards + writes in one transaction) ────────────
+    const outcome = skipSliceCascade(params.milestoneId, params.sliceId);
+    if (!outcome.ok) {
+        switch (outcome.reason) {
+            case "slice-not-found":
+                return {
+                    ...base,
+                    error: `Slice ${params.sliceId} not found in milestone ${params.milestoneId}`,
+                    errorCode: "slice_not_found",
+                };
+            case "slice-already-complete":
+                return {
+                    ...base,
+                    error: `Slice ${params.sliceId} is already complete — cannot skip.`,
+                    errorCode: "already_complete",
+                };
         }
-        if (slice.status === "complete" || slice.status === "done") {
-            guardError = `Slice ${params.sliceId} is already complete — cannot skip.`;
-            guardCode = "already_complete";
-            return;
-        }
-        wasAlreadySkipped = slice.status === "skipped";
-        if (!wasAlreadySkipped) {
-            updateSliceStatus(params.milestoneId, params.sliceId, "skipped");
-        }
-        // Cascade: mark every non-closed task as skipped so milestone completion
-        // doesn't trip the deep-task guard (#4375). Closed tasks (complete/done/
-        // skipped) are left untouched — we never downgrade.
-        const tasks = getSliceTasks(params.milestoneId, params.sliceId);
-        for (const task of tasks) {
-            if (!isClosedStatus(task.status)) {
-                updateTaskStatus(params.milestoneId, params.sliceId, task.id, "skipped");
-                tasksSkipped++;
-            }
-        }
-    });
-    if (guardError) {
-        return { ...base, error: guardError, errorCode: guardCode ?? undefined };
     }
-    return { ...base, tasksSkipped, wasAlreadySkipped };
+    return { ...base, tasksSkipped: outcome.tasksSkipped, wasAlreadySkipped: outcome.wasAlreadySkipped };
 }