gsd-pi 2.44.0-dev.d25d507 → 2.45.0-dev.1afbdaa

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,

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

@@ -2,6 +2,9 @@ import { clearParseCache } from "../files.js";
 import { transaction, getSlice, getTask, insertTask, upsertTaskPlanning } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderTaskPlanFromDb } from "../markdown-renderer.js";
+import { renderAllProjections } from "../workflow-projections.js";
+import { writeManifest } from "../workflow-manifest.js";
+import { appendEvent } from "../workflow-events.js";
 function isNonEmptyString(value) {
     return typeof value === "string" && value.trim().length > 0;
 }
@@ -51,9 +54,16 @@ export async function handlePlanTask(rawParams, basePath) {
     if (!parentSlice) {
         return { error: `missing parent slice: ${params.milestoneId}/${params.sliceId}` };
     }
+    if (parentSlice.status === "complete" || parentSlice.status === "done") {
+        return { error: `cannot plan task in a closed slice: ${params.sliceId} (status: ${parentSlice.status})` };
+    }
+    const existingTask = getTask(params.milestoneId, params.sliceId, params.taskId);
+    if (existingTask && (existingTask.status === "complete" || existingTask.status === "done")) {
+        return { error: `cannot re-plan task ${params.taskId}: it is already complete — use gsd_task_reopen first` };
+    }
     try {
         transaction(() => {
-            if (!getTask(params.milestoneId, params.sliceId, params.taskId)) {
+            if (!existingTask) {
                 insertTask({
                     id: params.taskId,
                     sliceId: params.sliceId,
@@ -71,6 +81,7 @@ export async function handlePlanTask(rawParams, basePath) {
                 inputs: params.inputs,
                 expectedOutput: params.expectedOutput,
                 observabilityImpact: params.observabilityImpact ?? "",
+                fullPlanMd: params.fullPlanMd,
             });
         });
     }
@@ -81,6 +92,22 @@ export async function handlePlanTask(rawParams, basePath) {
         const renderResult = await renderTaskPlanFromDb(basePath, params.milestoneId, params.sliceId, params.taskId);
         invalidateStateCache();
         clearParseCache();
+        // ── Post-mutation hook: projections, manifest, event log ─────────────
+        try {
+            await renderAllProjections(basePath, params.milestoneId);
+            writeManifest(basePath);
+            appendEvent(basePath, {
+                cmd: "plan-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: plan-task post-mutation hook warning: ${hookErr.message}\n`);
+        }
         return {
             milestoneId: params.milestoneId,
             sliceId: params.sliceId,

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

@@ -1,7 +1,10 @@
 import { clearParseCache } from "../files.js";
-import { transaction, getMilestone, getMilestoneSlices, insertSlice, updateSliceFields, insertAssessment, deleteSlice, } from "../gsd-db.js";
+import { transaction, getMilestone, getMilestoneSlices, getSlice, insertSlice, updateSliceFields, insertAssessment, deleteSlice, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb, renderAssessmentFromDb } from "../markdown-renderer.js";
+import { renderAllProjections } from "../workflow-projections.js";
+import { writeManifest } from "../workflow-manifest.js";
+import { appendEvent } from "../workflow-events.js";
 import { join } from "node:path";
 function isNonEmptyString(value) {
     return typeof value === "string" && value.trim().length > 0;
@@ -58,11 +61,22 @@ export async function handleReassessRoadmap(rawParams, basePath) {
     catch (err) {
         return { error: `validation failed: ${err.message}` };
     }
-    // ── Verify milestone exists ───────────────────────────────────────
+    // ── Verify milestone exists and is active ────────────────────────
     const milestone = getMilestone(params.milestoneId);
     if (!milestone) {
         return { error: `milestone not found: ${params.milestoneId}` };
     }
+    if (milestone.status === "complete" || milestone.status === "done") {
+        return { error: `cannot reassess a closed milestone: ${params.milestoneId} (status: ${milestone.status})` };
+    }
+    // ── Verify completedSliceId is actually complete ──────────────────
+    const completedSlice = getSlice(params.milestoneId, params.completedSliceId);
+    if (!completedSlice) {
+        return { error: `completedSliceId not found: ${params.milestoneId}/${params.completedSliceId}` };
+    }
+    if (completedSlice.status !== "complete" && completedSlice.status !== "done") {
+        return { error: `completedSliceId ${params.completedSliceId} is not complete (status: ${completedSlice.status}) — reassess can only be called after a slice finishes` };
+    }
     // ── Structural enforcement ────────────────────────────────────────
     const existingSlices = getMilestoneSlices(params.milestoneId);
     const completedSliceIds = new Set();
@@ -139,6 +153,22 @@ export async function handleReassessRoadmap(rawParams, basePath) {
         // ── Invalidate caches ─────────────────────────────────────────
         invalidateStateCache();
         clearParseCache();
+        // ── Post-mutation hook: projections, manifest, event log ─────
+        try {
+            await renderAllProjections(basePath, params.milestoneId);
+            writeManifest(basePath);
+            appendEvent(basePath, {
+                cmd: "reassess-roadmap",
+                params: { milestoneId: params.milestoneId, completedSliceId: params.completedSliceId },
+                ts: new Date().toISOString(),
+                actor: "agent",
+                actor_name: params.actorName,
+                trigger_reason: params.triggerReason,
+            });
+        }
+        catch (hookErr) {
+            process.stderr.write(`gsd: reassess-roadmap post-mutation hook warning: ${hookErr.message}\n`);
+        }
         return {
             milestoneId: params.milestoneId,
             completedSliceId: params.completedSliceId,