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

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

@@ -17,12 +17,19 @@ import {
   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";
 
 export interface CompleteTaskResult {
   taskId: string;
@@ -131,10 +138,43 @@ export async function handleCompleteTask(
     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: string | null = 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({
@@ -167,6 +207,10 @@ export async function handleCompleteTask(
     }
   });
 
+  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").
@@ -236,6 +280,24 @@ export async function handleCompleteTask(
   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 as Error).message}\n`,
+    );
+  }
+
   return {
     taskId: params.taskId,
     sliceId: params.sliceId,

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

@@ -1,6 +1,7 @@
 import { clearParseCache } from "../files.js";
 import {
   transaction,
+  getMilestone,
   insertMilestone,
   insertSlice,
   upsertMilestonePlanning,
@@ -9,6 +10,9 @@ import {
 } 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";
 
 export interface PlanMilestoneSliceInput {
   sliceId: string;
@@ -28,6 +32,10 @@ export interface PlanMilestoneParams {
   title: string;
   status?: string;
   dependsOn?: string[];
+  /** Optional caller-provided identity for audit trail */
+  actorName?: string;
+  /** Optional caller-provided reason this action was triggered */
+  triggerReason?: string;
   vision: string;
   successCriteria: string[];
   keyRisks: Array<{ risk: string; whyItMatters: string }>;
@@ -181,6 +189,25 @@ export async function handlePlanMilestone(
     return { error: `validation failed: ${(err as Error).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({
@@ -242,6 +269,24 @@ export async function handlePlanMilestone(
   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 as Error).message}\n`,
+    );
+  }
+
   return {
     milestoneId: params.milestoneId,
     roadmapPath,

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

@@ -1,6 +1,7 @@
 import { clearParseCache } from "../files.js";
 import {
   transaction,
+  getMilestone,
   getSlice,
   insertTask,
   upsertSlicePlanning,
@@ -9,6 +10,9 @@ import {
 } 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";
 
 export interface PlanSliceTaskInput {
   taskId: string;
@@ -20,6 +24,7 @@ export interface PlanSliceTaskInput {
   inputs: string[];
   expectedOutput: string[];
   observabilityImpact?: string;
+  fullPlanMd?: string;
 }
 
 export interface PlanSliceParams {
@@ -31,6 +36,10 @@ export interface PlanSliceParams {
   integrationClosure: string;
   observabilityImpact: string;
   tasks: PlanSliceTaskInput[];
+  /** Optional caller-provided identity for audit trail */
+  actorName?: string;
+  /** Optional caller-provided reason this action was triggered */
+  triggerReason?: string;
 }
 
 export interface PlanSliceResult {
@@ -135,10 +144,21 @@ export async function handlePlanSlice(
     return { error: `validation failed: ${(err as Error).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(() => {
@@ -167,6 +187,7 @@ export async function handlePlanSlice(
           inputs: task.inputs,
           expectedOutput: task.expectedOutput,
           observabilityImpact: task.observabilityImpact ?? "",
+          fullPlanMd: task.fullPlanMd,
         });
       }
     });
@@ -178,6 +199,25 @@ export async function handlePlanSlice(
     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 as Error).message}\n`,
+      );
+    }
+
     return {
       milestoneId: params.milestoneId,
       sliceId: params.sliceId,

package/src/resources/extensions/gsd/tools/plan-task.ts

@@ -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";
 
 export interface PlanTaskParams {
   milestoneId: string;
@@ -15,6 +18,11 @@ export interface PlanTaskParams {
   inputs: string[];
   expectedOutput: string[];
   observabilityImpact?: string;
+  fullPlanMd?: string;
+  /** Optional caller-provided identity for audit trail */
+  actorName?: string;
+  /** Optional caller-provided reason this action was triggered */
+  triggerReason?: string;
 }
 
 export interface PlanTaskResult {
@@ -73,10 +81,18 @@ export async function handlePlanTask(
   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,
@@ -94,6 +110,7 @@ export async function handlePlanTask(
         inputs: params.inputs,
         expectedOutput: params.expectedOutput,
         observabilityImpact: params.observabilityImpact ?? "",
+        fullPlanMd: params.fullPlanMd,
       });
     });
   } catch (err) {
@@ -104,6 +121,25 @@ export async function handlePlanTask(
     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 as Error).message}\n`,
+      );
+    }
+
     return {
       milestoneId: params.milestoneId,
       sliceId: params.sliceId,

package/src/resources/extensions/gsd/tools/reassess-roadmap.ts

@@ -3,6 +3,7 @@ import {
   transaction,
   getMilestone,
   getMilestoneSlices,
+  getSlice,
   insertSlice,
   updateSliceFields,
   insertAssessment,
@@ -10,6 +11,9 @@ import {
 } 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";
 
 export interface SliceChangeInput {
@@ -30,6 +34,10 @@ export interface ReassessRoadmapParams {
     added: SliceChangeInput[];
     removed: string[];
   };
+  /** Optional caller-provided identity for audit trail */
+  actorName?: string;
+  /** Optional caller-provided reason this action was triggered */
+  triggerReason?: string;
 }
 
 export interface ReassessRoadmapResult {
@@ -96,11 +104,23 @@ export async function handleReassessRoadmap(
     return { error: `validation failed: ${(err as Error).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);
@@ -191,6 +211,24 @@ export async function handleReassessRoadmap(
     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 as Error).message}\n`,
+      );
+    }
+
     return {
       milestoneId: params.milestoneId,
       completedSliceId: params.completedSliceId,

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

@@ -0,0 +1,125 @@
+/**
+ * reopen-slice handler — the core operation behind gsd_slice_reopen.
+ *
+ * Resets a completed slice back to "in_progress" and resets ALL of its
+ * tasks back to "pending". This is intentional — if you're reopening a
+ * slice, you're re-doing the work. Partial resets create ambiguous state.
+ *
+ * The parent milestone must still be open (not complete).
+ */
+
+// 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 { invalidateStateCache } from "../state.js";
+import { renderAllProjections } from "../workflow-projections.js";
+import { writeManifest } from "../workflow-manifest.js";
+import { appendEvent } from "../workflow-events.js";
+
+export interface ReopenSliceParams {
+  milestoneId: string;
+  sliceId: string;
+  reason?: string;
+  /** Optional caller-provided identity for audit trail */
+  actorName?: string;
+  /** Optional caller-provided reason this action was triggered */
+  triggerReason?: string;
+}
+
+export interface ReopenSliceResult {
+  milestoneId: string;
+  sliceId: string;
+  tasksReset: number;
+}
+
+export async function handleReopenSlice(
+  params: ReopenSliceParams,
+  basePath: string,
+): Promise<ReopenSliceResult | { error: string }> {
+  // ── Validate required fields ────────────────────────────────────────────
+  if (!params.sliceId || typeof params.sliceId !== "string" || params.sliceId.trim() === "") {
+    return { error: "sliceId is required and must be a non-empty string" };
+  }
+  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: string | null = null;
+  let tasksResetCount = 0;
+
+  transaction(() => {
+    const milestone = getMilestone(params.milestoneId);
+    if (!milestone) {
+      guardError = `milestone not found: ${params.milestoneId}`;
+      return;
+    }
+    if (milestone.status === "complete" || milestone.status === "done") {
+      guardError = `cannot reopen slice inside a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
+      return;
+    }
+
+    const slice = getSlice(params.milestoneId, params.sliceId);
+    if (!slice) {
+      guardError = `slice not found: ${params.milestoneId}/${params.sliceId}`;
+      return;
+    }
+    if (slice.status !== "complete" && slice.status !== "done") {
+      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 };
+  }
+
+  // ── Invalidate caches ────────────────────────────────────────────────────
+  invalidateStateCache();
+
+  // ── Post-mutation hook ───────────────────────────────────────────────────
+  try {
+    await renderAllProjections(basePath, params.milestoneId);
+    writeManifest(basePath);
+    appendEvent(basePath, {
+      cmd: "reopen-slice",
+      params: {
+        milestoneId: params.milestoneId,
+        sliceId: params.sliceId,
+        reason: params.reason ?? null,
+        tasksReset: tasksResetCount,
+      },
+      ts: new Date().toISOString(),
+      actor: "agent",
+      actor_name: params.actorName,
+      trigger_reason: params.triggerReason,
+    });
+  } catch (hookErr) {
+    process.stderr.write(
+      `gsd: reopen-slice post-mutation hook warning: ${(hookErr as Error).message}\n`,
+    );
+  }
+
+  return {
+    milestoneId: params.milestoneId,
+    sliceId: params.sliceId,
+    tasksReset: tasksResetCount,
+  };
+}

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

@@ -0,0 +1,129 @@
+/**
+ * reopen-task handler — the core operation behind gsd_task_reopen.
+ *
+ * Resets a completed task back to "pending" so it can be re-done
+ * without manual SQL surgery. The parent slice and milestone must
+ * still be open (not complete) — you cannot reopen tasks inside a
+ * closed slice.
+ */
+
+// GSD — reopen-task tool handler
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import {
+  getMilestone,
+  getSlice,
+  getTask,
+  updateTaskStatus,
+  transaction,
+} from "../gsd-db.js";
+import { invalidateStateCache } from "../state.js";
+import { renderAllProjections } from "../workflow-projections.js";
+import { writeManifest } from "../workflow-manifest.js";
+import { appendEvent } from "../workflow-events.js";
+
+export interface ReopenTaskParams {
+  milestoneId: string;
+  sliceId: string;
+  taskId: string;
+  reason?: string;
+  /** Optional caller-provided identity for audit trail */
+  actorName?: string;
+  /** Optional caller-provided reason this action was triggered */
+  triggerReason?: string;
+}
+
+export interface ReopenTaskResult {
+  milestoneId: string;
+  sliceId: string;
+  taskId: string;
+}
+
+export async function handleReopenTask(
+  params: ReopenTaskParams,
+  basePath: string,
+): Promise<ReopenTaskResult | { error: string }> {
+  // ── Validate required fields ────────────────────────────────────────────
+  if (!params.taskId || typeof params.taskId !== "string" || params.taskId.trim() === "") {
+    return { error: "taskId is required and must be a non-empty string" };
+  }
+  if (!params.sliceId || typeof params.sliceId !== "string" || params.sliceId.trim() === "") {
+    return { error: "sliceId is required and must be a non-empty string" };
+  }
+  if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
+    return { error: "milestoneId is required and must be a non-empty string" };
+  }
+
+  // ── Guards + DB write inside a single transaction (prevents TOCTOU) ────
+  let guardError: string | null = null;
+
+  transaction(() => {
+    const milestone = getMilestone(params.milestoneId);
+    if (!milestone) {
+      guardError = `milestone not found: ${params.milestoneId}`;
+      return;
+    }
+    if (milestone.status === "complete" || milestone.status === "done") {
+      guardError = `cannot reopen task 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 (slice.status === "complete" || slice.status === "done") {
+      guardError = `cannot reopen task inside a closed slice: ${params.sliceId} (status: ${slice.status}) — use gsd_slice_reopen first`;
+      return;
+    }
+
+    const task = getTask(params.milestoneId, params.sliceId, params.taskId);
+    if (!task) {
+      guardError = `task not found: ${params.milestoneId}/${params.sliceId}/${params.taskId}`;
+      return;
+    }
+    if (task.status !== "complete" && task.status !== "done") {
+      guardError = `task ${params.taskId} is not complete (status: ${task.status}) — nothing to reopen`;
+      return;
+    }
+
+    updateTaskStatus(params.milestoneId, params.sliceId, params.taskId, "pending");
+  });
+
+  if (guardError) {
+    return { error: guardError };
+  }
+
+  // ── Invalidate caches ────────────────────────────────────────────────────
+  invalidateStateCache();
+
+  // ── Post-mutation hook ───────────────────────────────────────────────────
+  try {
+    await renderAllProjections(basePath, params.milestoneId);
+    writeManifest(basePath);
+    appendEvent(basePath, {
+      cmd: "reopen-task",
+      params: {
+        milestoneId: params.milestoneId,
+        sliceId: params.sliceId,
+        taskId: params.taskId,
+        reason: params.reason ?? null,
+      },
+      ts: new Date().toISOString(),
+      actor: "agent",
+      actor_name: params.actorName,
+      trigger_reason: params.triggerReason,
+    });
+  } catch (hookErr) {
+    process.stderr.write(
+      `gsd: reopen-task post-mutation hook warning: ${(hookErr as Error).message}\n`,
+    );
+  }
+
+  return {
+    milestoneId: params.milestoneId,
+    sliceId: params.sliceId,
+    taskId: params.taskId,
+  };
+}