gsd-pi 2.44.0 → 2.45.0-dev.1afbdaa

package/dist/resources/extensions/gsd/session-lock.js

@@ -169,7 +169,6 @@ export function acquireSessionLock(basePath) {
         unitType: "starting",
         unitId: "bootstrap",
         unitStartedAt: new Date().toISOString(),
-        completedUnits: 0,
     };
     let lockfile;
     try {
@@ -314,7 +313,7 @@ function acquireFallbackLock(basePath, lp, lockData) {
  * Update the lock file metadata (called on each unit dispatch).
  * Does NOT re-acquire the OS lock — just updates the JSON content.
  */
-export function updateSessionLock(basePath, unitType, unitId, completedUnits, sessionFile) {
+export function updateSessionLock(basePath, unitType, unitId, sessionFile) {
     if (_lockedPath !== basePath && _lockedPath !== null)
         return;
     const lp = lockPath(basePath);
@@ -325,7 +324,6 @@ export function updateSessionLock(basePath, unitType, unitId, completedUnits, se
             unitType,
             unitId,
             unitStartedAt: new Date().toISOString(),
-            completedUnits,
             sessionFile,
         };
         atomicWriteSync(lp, JSON.stringify(data, null, 2));

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

@@ -4,12 +4,12 @@
 import { parseRoadmap, parsePlan, } from './parsers-legacy.js';
 import { parseSummary, loadFile, parseRequirementCounts, parseContextDependsOn, } from './files.js';
 import { resolveMilestoneFile, resolveSlicePath, resolveSliceFile, resolveTaskFile, resolveTasksDir, resolveGsdRootFile, gsdRoot, } from './paths.js';
-import { findMilestoneIds } from './milestone-ids.js';
+import { milestoneIdSort, findMilestoneIds } from './milestone-ids.js';
 import { nativeBatchParseGsdFiles } from './native-parser-bridge.js';
 import { join, resolve } from 'path';
 import { existsSync, readdirSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
-import { isDbAvailable, getAllMilestones, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, } from './gsd-db.js';
+import { isDbAvailable, getAllMilestones, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, } from './gsd-db.js';
 /**
  * A "ghost" milestone directory contains only META.json (and no substantive
  * files like CONTEXT, CONTEXT-DRAFT, ROADMAP, or SUMMARY).  These appear when
@@ -57,6 +57,10 @@ export function isValidationTerminal(validationContent) {
 }
 const CACHE_TTL_MS = 100;
 let _stateCache = null;
+// ── Telemetry counters for derive-path observability ────────────────────────
+let _telemetry = { dbDeriveCount: 0, markdownDeriveCount: 0 };
+export function getDeriveTelemetry() { return { ..._telemetry }; }
+export function resetDeriveTelemetry() { _telemetry = { dbDeriveCount: 0, markdownDeriveCount: 0 }; }
 /**
  * Invalidate the deriveState() cache. Call this whenever planning files on disk
  * may have changed (unit completion, merges, file writes).
@@ -141,14 +145,17 @@ export async function deriveState(basePath) {
             const stopDbTimer = debugTime("derive-state-db");
             result = await deriveStateFromDb(basePath);
             stopDbTimer({ phase: result.phase, milestone: result.activeMilestone?.id });
+            _telemetry.dbDeriveCount++;
         }
         else {
             // DB open but empty hierarchy tables — pre-migration project, use filesystem
             result = await _deriveStateImpl(basePath);
+            _telemetry.markdownDeriveCount++;
         }
     }
     else {
         result = await _deriveStateImpl(basePath);
+        _telemetry.markdownDeriveCount++;
     }
     stopTimer({ phase: result.phase, milestone: result.activeMilestone?.id });
     debugCount("deriveStateCalls");
@@ -192,7 +199,45 @@ function isStatusDone(status) {
  */
 export async function deriveStateFromDb(basePath) {
     const requirements = parseRequirementCounts(await loadFile(resolveGsdRootFile(basePath, "REQUIREMENTS")));
-    const allMilestones = getAllMilestones();
+    let allMilestones = getAllMilestones();
+    // Incremental disk→DB sync: milestone directories created outside the DB
+    // write path (via /gsd queue, manual mkdir, or complete-milestone writing the
+    // next CONTEXT.md) are never inserted by the initial migration guard in
+    // auto-start.ts because that guard only runs when gsd.db doesn't exist yet.
+    // Reconcile here so deriveStateFromDb never silently misses queued milestones.
+    // insertMilestone uses INSERT OR IGNORE, so this is safe to call every time.
+    const dbIdSet = new Set(allMilestones.map(m => m.id));
+    const diskIds = findMilestoneIds(basePath);
+    let synced = false;
+    for (const diskId of diskIds) {
+        if (!dbIdSet.has(diskId) && !isGhostMilestone(basePath, diskId)) {
+            insertMilestone({ id: diskId, status: 'active' });
+            synced = true;
+        }
+    }
+    if (synced)
+        allMilestones = getAllMilestones();
+    // Reconcile: discover milestones that exist on disk but are missing from
+    // the DB. This happens when milestones were created before the DB migration
+    // or were manually added to the filesystem. Without this, disk-only
+    // milestones are invisible after migration (#2416).
+    const dbMilestoneIds = new Set(allMilestones.map(m => m.id));
+    const diskMilestoneIds = findMilestoneIds(basePath);
+    for (const diskId of diskMilestoneIds) {
+        if (!dbMilestoneIds.has(diskId)) {
+            // Synthesize a minimal MilestoneRow for the disk-only milestone.
+            // Title and status will be resolved from disk files in the loop below.
+            allMilestones.push({
+                id: diskId,
+                title: diskId,
+                status: 'active',
+                depends_on: [],
+                created_at: new Date().toISOString(),
+            });
+        }
+    }
+    // Re-sort so milestones are in canonical order after injection
+    allMilestones.sort((a, b) => milestoneIdSort(a.id, b.id));
     // Parallel worker isolation: when locked, filter to just the locked milestone
     const milestoneLock = process.env.GSD_MILESTONE_LOCK;
     const milestones = milestoneLock

package/dist/resources/extensions/gsd/sync-lock.js

@@ -0,0 +1,89 @@
+// GSD Extension — Advisory Sync Lock
+// Prevents concurrent worktree syncs from colliding via a simple file lock.
+// Stale locks (mtime > 60s) are auto-overridden. Lock acquisition waits up
+// to 5 seconds then skips non-fatally.
+import { existsSync, statSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { atomicWriteSync } from "./atomic-write.js";
+const STALE_THRESHOLD_MS = 60_000; // 60 seconds
+const DEFAULT_TIMEOUT_MS = 5_000; // 5 seconds
+const SPIN_INTERVAL_MS = 100; // 100ms polling interval
+// SharedArrayBuffer for synchronous sleep via Atomics.wait
+const SLEEP_BUFFER = new SharedArrayBuffer(4);
+const SLEEP_VIEW = new Int32Array(SLEEP_BUFFER);
+function lockFilePath(basePath) {
+    return join(basePath, ".gsd", "sync.lock");
+}
+function sleepSync(ms) {
+    Atomics.wait(SLEEP_VIEW, 0, 0, ms);
+}
+/**
+ * Acquire an advisory sync lock for the given basePath.
+ * Returns { acquired: true } on success, { acquired: false } after timeout.
+ *
+ * - Creates lock file at {basePath}/.gsd/sync.lock with JSON { pid, acquired_at }
+ * - If lock exists and mtime > 60s (stale), overrides it
+ * - If lock exists and not stale, spins up to timeoutMs before giving up
+ */
+export function acquireSyncLock(basePath, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const lp = lockFilePath(basePath);
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        // Check if lock file exists
+        if (existsSync(lp)) {
+            // Check staleness
+            try {
+                const stat = statSync(lp);
+                const age = Date.now() - stat.mtimeMs;
+                if (age > STALE_THRESHOLD_MS) {
+                    // Stale lock — override it
+                    try {
+                        unlinkSync(lp);
+                    }
+                    catch { /* race: already removed */ }
+                }
+                else {
+                    // Lock is held and not stale — wait or give up
+                    if (Date.now() >= deadline) {
+                        return { acquired: false };
+                    }
+                    sleepSync(SPIN_INTERVAL_MS);
+                    continue;
+                }
+            }
+            catch {
+                // stat failed (file removed between exists check and stat) — try to acquire
+            }
+        }
+        // Lock file does not exist (or was just removed) — try to write it
+        try {
+            const lockData = {
+                pid: process.pid,
+                acquired_at: new Date().toISOString(),
+            };
+            atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
+            return { acquired: true };
+        }
+        catch {
+            // Write failed (race condition with another process) — retry or give up
+            if (Date.now() >= deadline) {
+                return { acquired: false };
+            }
+            sleepSync(SPIN_INTERVAL_MS);
+        }
+    }
+}
+/**
+ * Release the advisory sync lock. No-op if lock file does not exist.
+ */
+export function releaseSyncLock(basePath) {
+    const lp = lockFilePath(basePath);
+    try {
+        if (existsSync(lp)) {
+            unlinkSync(lp);
+        }
+    }
+    catch {
+        // Non-fatal — lock may have been released by another process
+    }
+}

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

@@ -7,10 +7,13 @@
  */
 import { join } from "node:path";
 import { mkdirSync } from "node:fs";
-import { transaction, getMilestoneSlices, _getAdapter, } from "../gsd-db.js";
+import { transaction, getMilestone, getMilestoneSlices, getSliceTasks, _getAdapter, } from "../gsd-db.js";
 import { resolveMilestonePath, clearPathCache } from "../paths.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
+import { renderAllProjections } from "../workflow-projections.js";
+import { writeManifest } from "../workflow-manifest.js";
+import { appendEvent } from "../workflow-events.js";
 function renderMilestoneSummaryMarkdown(params) {
     const now = new Date().toISOString();
     const keyDecisionsYaml = params.keyDecisions.length > 0
@@ -72,25 +75,56 @@ export async function handleCompleteMilestone(params, basePath) {
     if (!params.title || typeof params.title !== "string" || params.title.trim() === "") {
         return { error: "title is required and must be a non-empty string" };
     }
-    // ── Verify all slices are complete ───────────────────────────────────────
-    const slices = getMilestoneSlices(params.milestoneId);
-    if (slices.length === 0) {
-        return { error: `no slices found for milestone ${params.milestoneId}` };
+    // ── Verify that verification passed ─────────────────────────────────────
+    if (params.verificationPassed !== true) {
+        return { error: "verification did not pass — milestone completion blocked. verificationPassed must be explicitly set to true after all verification steps succeed" };
     }
-    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(", ");
-        return { error: `incomplete slices: ${incompleteIds}` };
-    }
-    // ── DB writes inside a transaction ──────────────────────────────────────
+    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     const completedAt = new Date().toISOString();
+    let guardError = null;
     transaction(() => {
+        // State machine preconditions (inside txn for atomicity)
+        const milestone = getMilestone(params.milestoneId);
+        if (!milestone) {
+            guardError = `milestone not found: ${params.milestoneId}`;
+            return;
+        }
+        if (milestone.status === "complete" || milestone.status === "done") {
+            guardError = `milestone ${params.milestoneId} is already complete`;
+            return;
+        }
+        // Verify all slices are complete
+        const slices = getMilestoneSlices(params.milestoneId);
+        if (slices.length === 0) {
+            guardError = `no slices found for milestone ${params.milestoneId}`;
+            return;
+        }
+        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}`;
+            return;
+        }
+        // Deep check: verify all tasks in all slices are complete
+        for (const slice of slices) {
+            const tasks = getSliceTasks(params.milestoneId, slice.id);
+            const incompleteTasks = tasks.filter(t => t.status !== "complete" && t.status !== "done");
+            if (incompleteTasks.length > 0) {
+                const ids = incompleteTasks.map(t => `${t.id} (status: ${t.status})`).join(", ");
+                guardError = `slice ${slice.id} has incomplete tasks: ${ids}`;
+                return;
+            }
+        }
+        // All guards passed — perform write
         const adapter = _getAdapter();
         adapter.prepare(`UPDATE milestones SET status = 'complete', completed_at = :completed_at WHERE id = :mid`).run({
             ":completed_at": completedAt,
             ":mid": params.milestoneId,
         });
     });
+    if (guardError) {
+        return { error: guardError };
+    }
     // ── Filesystem operations (outside transaction) ─────────────────────────
     const summaryMd = renderMilestoneSummaryMarkdown(params);
     let summaryPath;
@@ -121,6 +155,22 @@ export async function handleCompleteMilestone(params, basePath) {
     invalidateStateCache();
     clearPathCache();
     clearParseCache();
+    // ── Post-mutation hook: projections, manifest, event log ───────────────
+    try {
+        await renderAllProjections(basePath, params.milestoneId);
+        writeManifest(basePath);
+        appendEvent(basePath, {
+            cmd: "complete-milestone",
+            params: { milestoneId: params.milestoneId },
+            ts: new Date().toISOString(),
+            actor: "agent",
+            actor_name: params.actorName,
+            trigger_reason: params.triggerReason,
+        });
+    }
+    catch (hookErr) {
+        process.stderr.write(`gsd: complete-milestone post-mutation hook warning: ${hookErr.message}\n`);
+    }
     return {
         milestoneId: params.milestoneId,
         summaryPath,

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

@@ -8,11 +8,15 @@
  */
 import { join } from "node:path";
 import { mkdirSync } from "node:fs";
-import { transaction, insertMilestone, insertSlice, getSliceTasks, updateSliceStatus, _getAdapter, } from "../gsd-db.js";
+import { transaction, insertMilestone, insertSlice, getSlice, getSliceTasks, getMilestone, updateSliceStatus, _getAdapter, } from "../gsd-db.js";
 import { resolveSlicePath, clearPathCache } from "../paths.js";
+import { checkOwnership, sliceUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapCheckboxes } from "../markdown-renderer.js";
+import { renderAllProjections } from "../workflow-projections.js";
+import { writeManifest } from "../workflow-manifest.js";
+import { appendEvent } from "../workflow-events.js";
 /**
  * Render slice summary markdown matching the template format.
  * YAML frontmatter uses snake_case keys for parseSummary() compatibility.
@@ -162,23 +166,48 @@ export async function handleCompleteSlice(params, basePath) {
     if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
         return { error: "milestoneId is required and must be a non-empty string" };
     }
-    // ── Verify all tasks are complete ───────────────────────────────────────
-    const tasks = getSliceTasks(params.milestoneId, params.sliceId);
-    if (tasks.length === 0) {
-        return { error: `no tasks found for slice ${params.sliceId} in milestone ${params.milestoneId}` };
+    // ── Ownership check (opt-in: only enforced when claim file exists) ──────
+    const ownershipErr = checkOwnership(basePath, sliceUnitKey(params.milestoneId, params.sliceId), params.actorName);
+    if (ownershipErr) {
+        return { error: ownershipErr };
     }
-    const incompleteTasks = tasks.filter(t => t.status !== "complete");
-    if (incompleteTasks.length > 0) {
-        const incompleteIds = incompleteTasks.map(t => `${t.id} (status: ${t.status})`).join(", ");
-        return { error: `incomplete tasks: ${incompleteIds}` };
-    }
-    // ── DB writes inside a transaction ──────────────────────────────────────
+    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     const completedAt = new Date().toISOString();
+    let guardError = null;
     transaction(() => {
+        // State machine preconditions (inside txn for atomicity).
+        // Milestone/slice not existing is OK — insertMilestone/insertSlice below will auto-create.
+        // Only block if they exist and are closed.
+        const milestone = getMilestone(params.milestoneId);
+        if (milestone && (milestone.status === "complete" || milestone.status === "done")) {
+            guardError = `cannot complete slice in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
+            return;
+        }
+        const slice = getSlice(params.milestoneId, params.sliceId);
+        if (slice && (slice.status === "complete" || slice.status === "done")) {
+            guardError = `slice ${params.sliceId} is already complete — use gsd_slice_reopen first if you need to redo it`;
+            return;
+        }
+        // Verify all tasks are complete
+        const tasks = getSliceTasks(params.milestoneId, params.sliceId);
+        if (tasks.length === 0) {
+            guardError = `no tasks found for slice ${params.sliceId} in milestone ${params.milestoneId}`;
+            return;
+        }
+        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}`;
+            return;
+        }
+        // All guards passed — perform writes
         insertMilestone({ id: params.milestoneId });
         insertSlice({ id: params.sliceId, milestoneId: params.milestoneId });
         updateSliceStatus(params.milestoneId, params.sliceId, "complete", completedAt);
     });
+    if (guardError) {
+        return { error: guardError };
+    }
     // ── Filesystem operations (outside transaction) ─────────────────────────
     // If disk render fails, roll back the DB status so deriveState() and
     // verifyExpectedArtifact() stay consistent (both say "not done").
@@ -235,6 +264,22 @@ export async function handleCompleteSlice(params, basePath) {
     invalidateStateCache();
     clearPathCache();
     clearParseCache();
+    // ── Post-mutation hook: projections, manifest, event log ───────────────
+    try {
+        await renderAllProjections(basePath, params.milestoneId);
+        writeManifest(basePath);
+        appendEvent(basePath, {
+            cmd: "complete-slice",
+            params: { milestoneId: params.milestoneId, sliceId: params.sliceId },
+            ts: new Date().toISOString(),
+            actor: "agent",
+            actor_name: params.actorName,
+            trigger_reason: params.triggerReason,
+        });
+    }
+    catch (hookErr) {
+        process.stderr.write(`gsd: complete-slice post-mutation hook warning: ${hookErr.message}\n`);
+    }
     return {
         sliceId: params.sliceId,
         milestoneId: params.milestoneId,

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

@@ -8,11 +8,15 @@
  */
 import { join } from "node:path";
 import { mkdirSync } from "node:fs";
-import { transaction, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, _getAdapter, } from "../gsd-db.js";
+import { transaction, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, getMilestone, getSlice, getTask, _getAdapter, } from "../gsd-db.js";
 import { resolveSliceFile, resolveTasksDir, clearPathCache } from "../paths.js";
+import { checkOwnership, taskUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanCheckboxes } from "../markdown-renderer.js";
+import { renderAllProjections } from "../workflow-projections.js";
+import { writeManifest } from "../workflow-manifest.js";
+import { appendEvent } from "../workflow-events.js";
 /**
  * Render task summary markdown matching the template format.
  * YAML frontmatter uses snake_case keys for parseSummary() compatibility.
@@ -105,9 +109,34 @@ export async function handleCompleteTask(params, basePath) {
     if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
         return { error: "milestoneId is required and must be a non-empty string" };
     }
-    // ── DB writes inside a transaction ──────────────────────────────────────
+    // ── Ownership check (opt-in: only enforced when claim file exists) ──────
+    const ownershipErr = checkOwnership(basePath, taskUnitKey(params.milestoneId, params.sliceId, params.taskId), params.actorName);
+    if (ownershipErr) {
+        return { error: ownershipErr };
+    }
+    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     const completedAt = new Date().toISOString();
+    let guardError = null;
     transaction(() => {
+        // State machine preconditions (inside txn for atomicity).
+        // Milestone/slice not existing is OK — insertMilestone/insertSlice below will auto-create.
+        // Only block if they exist and are closed.
+        const milestone = getMilestone(params.milestoneId);
+        if (milestone && (milestone.status === "complete" || milestone.status === "done")) {
+            guardError = `cannot complete task in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
+            return;
+        }
+        const slice = getSlice(params.milestoneId, params.sliceId);
+        if (slice && (slice.status === "complete" || slice.status === "done")) {
+            guardError = `cannot complete task in a closed slice: ${params.sliceId} (status: ${slice.status})`;
+            return;
+        }
+        const existingTask = getTask(params.milestoneId, params.sliceId, params.taskId);
+        if (existingTask && (existingTask.status === "complete" || existingTask.status === "done")) {
+            guardError = `task ${params.taskId} is already complete — use gsd_task_reopen first if you need to redo it`;
+            return;
+        }
+        // All guards passed — perform writes
         insertMilestone({ id: params.milestoneId });
         insertSlice({ id: params.sliceId, milestoneId: params.milestoneId });
         insertTask({
@@ -138,6 +167,9 @@ export async function handleCompleteTask(params, basePath) {
             });
         }
     });
+    if (guardError) {
+        return { error: guardError };
+    }
     // ── Filesystem operations (outside transaction) ─────────────────────────
     // If disk render fails, roll back the DB status so deriveState() and
     // verifyExpectedArtifact() stay consistent (both say "not done").
@@ -195,6 +227,22 @@ export async function handleCompleteTask(params, basePath) {
     invalidateStateCache();
     clearPathCache();
     clearParseCache();
+    // ── Post-mutation hook: projections, manifest, event log ───────────────
+    try {
+        await renderAllProjections(basePath, params.milestoneId);
+        writeManifest(basePath);
+        appendEvent(basePath, {
+            cmd: "complete-task",
+            params: { milestoneId: params.milestoneId, sliceId: params.sliceId, taskId: params.taskId },
+            ts: new Date().toISOString(),
+            actor: "agent",
+            actor_name: params.actorName,
+            trigger_reason: params.triggerReason,
+        });
+    }
+    catch (hookErr) {
+        process.stderr.write(`gsd: complete-task post-mutation hook warning: ${hookErr.message}\n`);
+    }
     return {
         taskId: params.taskId,
         sliceId: params.sliceId,

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

@@ -1,7 +1,10 @@
 import { clearParseCache } from "../files.js";
-import { transaction, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "../gsd-db.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;
 }
@@ -142,6 +145,23 @@ export async function handlePlanMilestone(rawParams, basePath) {
     catch (err) {
         return { error: `validation failed: ${err.message}` };
     }
+    // ── State machine preconditions ─────────────────────────────────────────
+    const existingMilestone = getMilestone(params.milestoneId);
+    if (existingMilestone && (existingMilestone.status === "complete" || existingMilestone.status === "done")) {
+        return { error: `cannot re-plan milestone ${params.milestoneId}: it is already complete` };
+    }
+    // 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) {
+                return { error: `depends_on references unknown milestone: ${depId}` };
+            }
+            if (dep.status !== "complete" && dep.status !== "done") {
+                return { error: `depends_on milestone ${depId} is not yet complete (status: ${dep.status})` };
+            }
+        }
+    }
     try {
         transaction(() => {
             insertMilestone({
@@ -198,6 +218,22 @@ export async function handlePlanMilestone(rawParams, basePath) {
     }
     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) {
+        process.stderr.write(`gsd: plan-milestone post-mutation hook warning: ${hookErr.message}\n`);
+    }
     return {
         milestoneId: params.milestoneId,
         roadmapPath,

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

@@ -1,7 +1,10 @@
 import { clearParseCache } from "../files.js";
-import { transaction, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, } from "../gsd-db.js";
+import { transaction, getMilestone, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, } 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;
 }
@@ -99,10 +102,20 @@ export async function handlePlanSlice(rawParams, basePath) {
     catch (err) {
         return { error: `validation failed: ${err.message}` };
     }
+    const parentMilestone = getMilestone(params.milestoneId);
+    if (!parentMilestone) {
+        return { error: `milestone not found: ${params.milestoneId}` };
+    }
+    if (parentMilestone.status === "complete" || parentMilestone.status === "done") {
+        return { error: `cannot plan slice in a closed milestone: ${params.milestoneId} (status: ${parentMilestone.status})` };
+    }
     const parentSlice = getSlice(params.milestoneId, params.sliceId);
     if (!parentSlice) {
         return { error: `missing parent slice: ${params.milestoneId}/${params.sliceId}` };
     }
+    if (parentSlice.status === "complete" || parentSlice.status === "done") {
+        return { error: `cannot re-plan slice ${params.sliceId}: it is already complete — use gsd_slice_reopen first` };
+    }
     try {
         transaction(() => {
             upsertSlicePlanning(params.milestoneId, params.sliceId, {
@@ -129,6 +142,7 @@ export async function handlePlanSlice(rawParams, basePath) {
                     inputs: task.inputs,
                     expectedOutput: task.expectedOutput,
                     observabilityImpact: task.observabilityImpact ?? "",
+                    fullPlanMd: task.fullPlanMd,
                 });
             }
         });
@@ -140,6 +154,22 @@ export async function handlePlanSlice(rawParams, basePath) {
         const renderResult = await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
         invalidateStateCache();
         clearParseCache();
+        // ── Post-mutation hook: projections, manifest, event log ─────────────
+        try {
+            await renderAllProjections(basePath, params.milestoneId);
+            writeManifest(basePath);
+            appendEvent(basePath, {
+                cmd: "plan-slice",
+                params: { milestoneId: params.milestoneId, sliceId: params.sliceId },
+                ts: new Date().toISOString(),
+                actor: "agent",
+                actor_name: params.actorName,
+                trigger_reason: params.triggerReason,
+            });
+        }
+        catch (hookErr) {
+            process.stderr.write(`gsd: plan-slice post-mutation hook warning: ${hookErr.message}\n`);
+        }
         return {
             milestoneId: params.milestoneId,
             sliceId: params.sliceId,