gsd-pi 2.65.0-dev.5c8557b → 2.65.0-dev.800ece0

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

@@ -186,8 +186,10 @@ export async function handleReassessRoadmap(
         });
       }
 
-      // Insert new slices
-      for (const added of params.sliceChanges.added) {
+      // Insert new slices — assign sequence after existing slices (#3356)
+      const existingCount = getMilestoneSlices(params.milestoneId).length;
+      for (let i = 0; i < params.sliceChanges.added.length; i++) {
+        const added = params.sliceChanges.added[i]!;
         insertSlice({
           id: added.sliceId,
           milestoneId: params.milestoneId,
@@ -196,6 +198,7 @@ export async function handleReassessRoadmap(
           risk: added.risk,
           depends: added.depends,
           demo: added.demo ?? "",
+          sequence: existingCount + i + 1,
         });
       }
 

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

@@ -0,0 +1,152 @@
+// GSD — reopen-milestone tool handler
+
+/**
+ * reopen-milestone handler — the core operation behind gsd_milestone_reopen.
+ *
+ * Resets a closed milestone back to "active", all of its slices to
+ * "in_progress", and all tasks to "pending". Cleans up stale filesystem
+ * artifacts so the DB-filesystem reconciler does not auto-correct
+ * entities back to "complete".
+ */
+
+import {
+  getMilestone,
+  getMilestoneSlices,
+  getSliceTasks,
+  updateMilestoneStatus,
+  updateSliceStatus,
+  updateTaskStatus,
+  transaction,
+} from "../gsd-db.js";
+import { invalidateStateCache } from "../state.js";
+import { isClosedStatus } from "../status-guards.js";
+import { renderAllProjections } from "../workflow-projections.js";
+import { writeManifest } from "../workflow-manifest.js";
+import { appendEvent } from "../workflow-events.js";
+import { logWarning } from "../workflow-logger.js";
+import { debugLog } from "../debug-logger.js";
+import { existsSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { resolveMilestonePath, resolveSlicePath, resolveTasksDir, clearPathCache } from "../paths.js";
+
+export interface ReopenMilestoneParams {
+  milestoneId: string;
+  reason?: string;
+  /** Optional caller-provided identity for audit trail */
+  actorName?: string;
+  /** Optional caller-provided reason this action was triggered */
+  triggerReason?: string;
+}
+
+export interface ReopenMilestoneResult {
+  milestoneId: string;
+  slicesReset: number;
+  tasksReset: number;
+}
+
+export async function handleReopenMilestone(
+  params: ReopenMilestoneParams,
+  basePath: string,
+): Promise<ReopenMilestoneResult | { error: string }> {
+  // ── Validate required fields ────────────────────────────────────────────
+  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 slicesResetCount = 0;
+  let tasksResetCount = 0;
+
+  transaction(() => {
+    const milestone = getMilestone(params.milestoneId);
+    if (!milestone) {
+      guardError = `milestone not found: ${params.milestoneId}`;
+      return;
+    }
+    if (!isClosedStatus(milestone.status)) {
+      guardError = `milestone ${params.milestoneId} is not closed (status: ${milestone.status}) — nothing to reopen`;
+      return;
+    }
+
+    updateMilestoneStatus(params.milestoneId, "active", null);
+
+    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 };
+  }
+
+  // ── Invalidate caches ────────────────────────────────────────────────────
+  invalidateStateCache();
+
+  // ── Clean up stale filesystem artifacts (M12 fix) ────────────────────────
+  // Without this, the DB-filesystem reconciler sees SUMMARY.md files and
+  // auto-corrects entities back to "complete", making reopen a no-op (#3161).
+  try {
+    const milestoneDir = resolveMilestonePath(basePath, params.milestoneId);
+    if (milestoneDir) {
+      const milestoneSummary = join(milestoneDir, `${params.milestoneId}-SUMMARY.md`);
+      if (existsSync(milestoneSummary)) unlinkSync(milestoneSummary);
+    }
+
+    const slices = getMilestoneSlices(params.milestoneId);
+    for (const slice of slices) {
+      const sliceDir = resolveSlicePath(basePath, params.milestoneId, slice.id);
+      if (sliceDir) {
+        const sliceSummary = join(sliceDir, `${slice.id}-SUMMARY.md`);
+        if (existsSync(sliceSummary)) unlinkSync(sliceSummary);
+        const sliceUat = join(sliceDir, `${slice.id}-UAT.md`);
+        if (existsSync(sliceUat)) unlinkSync(sliceUat);
+      }
+
+      const tasksDir = resolveTasksDir(basePath, params.milestoneId, slice.id);
+      if (tasksDir) {
+        const tasks = getSliceTasks(params.milestoneId, slice.id);
+        for (const task of tasks) {
+          const taskSummary = join(tasksDir, `${task.id}-SUMMARY.md`);
+          if (existsSync(taskSummary)) unlinkSync(taskSummary);
+        }
+      }
+    }
+  } catch (err) { debugLog("reopen-milestone-cleanup-failed", { milestoneId: params.milestoneId, error: String(err) }); }
+  clearPathCache();
+
+  // ── Post-mutation hook ───────────────────────────────────────────────────
+  try {
+    await renderAllProjections(basePath, params.milestoneId);
+    writeManifest(basePath);
+    appendEvent(basePath, {
+      cmd: "reopen-milestone",
+      params: {
+        milestoneId: params.milestoneId,
+        reason: params.reason ?? null,
+        slicesReset: slicesResetCount,
+        tasksReset: tasksResetCount,
+      },
+      ts: new Date().toISOString(),
+      actor: "agent",
+      actor_name: params.actorName,
+      trigger_reason: params.triggerReason,
+    });
+  } catch (hookErr) {
+    logWarning("tool", `reopen-milestone post-mutation hook warning: ${(hookErr as Error).message}`);
+  }
+
+  return {
+    milestoneId: params.milestoneId,
+    slicesReset: slicesResetCount,
+    tasksReset: tasksResetCount,
+  };
+}

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

@@ -25,6 +25,9 @@ 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 { existsSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { resolveTasksDir, resolveSlicePath, clearPathCache } from "../paths.js";
 
 export interface ReopenSliceParams {
   milestoneId: string;
@@ -96,6 +99,30 @@ export async function handleReopenSlice(
   // ── Invalidate caches ────────────────────────────────────────────────────
   invalidateStateCache();
 
+  // ── Clean up stale filesystem artifacts (M12 fix) ────────────────────────
+  // Without this, the DB-filesystem reconciler sees SUMMARY.md files and
+  // auto-corrects tasks back to "complete", making reopen a no-op (#3161).
+  try {
+    const tasksDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
+    if (tasksDir) {
+      const tasks = getSliceTasks(params.milestoneId, params.sliceId);
+      for (const task of tasks) {
+        const summaryPath = join(tasksDir, `${task.id}-SUMMARY.md`);
+        if (existsSync(summaryPath)) unlinkSync(summaryPath);
+      }
+    }
+    const sliceDir = resolveSlicePath(basePath, params.milestoneId, params.sliceId);
+    if (sliceDir) {
+      const sliceSummary = join(sliceDir, `${params.sliceId}-SUMMARY.md`);
+      if (existsSync(sliceSummary)) unlinkSync(sliceSummary);
+      const sliceUat = join(sliceDir, `${params.sliceId}-UAT.md`);
+      if (existsSync(sliceUat)) unlinkSync(sliceUat);
+    }
+  } catch (cleanupErr) {
+    logWarning("tool", `reopen-slice artifact cleanup warning: ${(cleanupErr as Error).message}`);
+  }
+  clearPathCache();
+
   // ── Post-mutation hook ───────────────────────────────────────────────────
   try {
     await renderAllProjections(basePath, params.milestoneId);

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

@@ -23,6 +23,9 @@ 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 { existsSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { resolveTasksDir, clearPathCache } from "../paths.js";
 
 export interface ReopenTaskParams {
   milestoneId: string;
@@ -100,6 +103,20 @@ export async function handleReopenTask(
   // ── Invalidate caches ────────────────────────────────────────────────────
   invalidateStateCache();
 
+  // ── Clean up stale filesystem artifacts (M12 fix) ────────────────────────
+  // Without this, the DB-filesystem reconciler sees the SUMMARY.md and
+  // auto-corrects the task back to "complete", making reopen a no-op (#3161).
+  try {
+    const tasksDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
+    if (tasksDir) {
+      const summaryPath = join(tasksDir, `${params.taskId}-SUMMARY.md`);
+      if (existsSync(summaryPath)) unlinkSync(summaryPath);
+    }
+  } catch (cleanupErr) {
+    logWarning("tool", `reopen-task artifact cleanup warning: ${(cleanupErr as Error).message}`);
+  }
+  clearPathCache();
+
   // ── Post-mutation hook ───────────────────────────────────────────────────
   try {
     await renderAllProjections(basePath, params.milestoneId);

package/src/resources/extensions/gsd/triage-resolution.ts

@@ -10,7 +10,8 @@
  * Also provides detectFileOverlap() for surfacing downstream impact on quick tasks.
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
+import { atomicWriteSync } from "./atomic-write.js";
 import { join } from "node:path";
 import { createRequire } from "node:module";
 import { gsdRoot, milestonesDir } from "./paths.js";
@@ -65,10 +66,10 @@ export function executeInject(
     const filesSection = content.indexOf("## Files Likely Touched");
     if (filesSection !== -1) {
       const updated = content.slice(0, filesSection) + newTask + "\n\n" + content.slice(filesSection);
-      writeFileSync(planPath, updated, "utf-8");
+      atomicWriteSync(planPath, updated, "utf-8");
     } else {
       // No Files section — append at end
-      writeFileSync(planPath, content.trimEnd() + "\n\n" + newTask + "\n", "utf-8");
+      atomicWriteSync(planPath, content.trimEnd() + "\n\n" + newTask + "\n", "utf-8");
     }
 
     return newId;
@@ -105,7 +106,7 @@ export function executeReplan(
       `will detect it and enter the replanning-slice phase.`,
     ].join("\n");
 
-    writeFileSync(triggerPath, content, "utf-8");
+    atomicWriteSync(triggerPath, content, "utf-8");
 
     // Also write replan_triggered_at column for DB-backed detection
     try {
@@ -183,7 +184,7 @@ export function executeBacktrack(
       `3. Resume auto-mode — the state machine will re-enter discussion for the target`,
     ].join("\n");
 
-    writeFileSync(triggerPath, content, "utf-8");
+    atomicWriteSync(triggerPath, content, "utf-8");
 
     // If we have a valid target, also reset that milestone's completion status
     // so deriveState() will re-enter it as the active milestone.
@@ -194,7 +195,7 @@ export function executeBacktrack(
           // Write a regression marker so the state machine knows this milestone
           // needs re-discussion, not just re-execution
           const regressionPath = join(targetDir, `${targetMilestoneId}-REGRESSION.md`);
-          writeFileSync(regressionPath, [
+          atomicWriteSync(regressionPath, [
             `# Milestone Regression`,
             ``,
             `**From:** ${currentMilestoneId}`,
@@ -361,7 +362,7 @@ export function ensureDeferMilestoneDir(
       ``,
     ].join("\n");
 
-    writeFileSync(
+    atomicWriteSync(
       join(msDir, `${targetMilestone}-CONTEXT-DRAFT.md`),
       draftContent,
       "utf-8",
@@ -479,15 +480,18 @@ export function executeTriageResolutions(
     }
   }
 
-  // Also process deferred captures that target milestone IDs — create
-  // milestone directories so deriveState() discovers them.
-  const deferred = loadAllCaptures(basePath).filter(
-    c => c.status === "resolved" && !c.executed && c.classification === "defer",
+  // Also process deferred and milestone-class captures (#3542).
+  // A defer/milestone capture's "action" is the triage decision itself —
+  // once classified and resolved, the capture is done. The target milestone
+  // picks up the work naturally from its planning context.
+  const deferrable = loadAllCaptures(basePath).filter(
+    c => c.status === "resolved" && !c.executed &&
+      (c.classification === "defer" || (c.classification as string) === "milestone"),
   );
-  if (deferred.length > 0) {
-    // Group deferred captures by target milestone
+  if (deferrable.length > 0) {
+    // Group captures that reference a specific milestone — create dirs as needed.
     const byMilestone = new Map<string, CaptureEntry[]>();
-    for (const cap of deferred) {
+    for (const cap of deferrable) {
       const target = cap.resolution?.match(/\b(M\d{3}(?:-[a-z0-9]{6})?)\b/)?.[1];
       if (target) {
         const list = byMilestone.get(target) ?? [];
@@ -502,12 +506,28 @@ export function executeTriageResolutions(
         if (created) {
           result.deferredMilestones++;
           result.actions.push(`Created milestone ${milestoneId} for ${captures.length} deferred capture(s)`);
-          for (const cap of captures) {
-            markCaptureExecuted(basePath, cap.id);
-          }
         }
       }
     }
+    // Stamp ALL defer/milestone captures as executed (#3542 gaps 1-3).
+    // Previously only captures that triggered dir creation were stamped.
+    // Captures without a milestone ID in resolution text, or targeting an
+    // existing directory, were silently dropped — never stamped.
+    for (const cap of deferrable) {
+      if (!cap.executed) {
+        markCaptureExecuted(basePath, cap.id);
+      }
+    }
+  }
+
+  // Mark note captures as executed — they're informational only, no action
+  // needed. Without this they stay in "resolved but not executed" limbo (#3578).
+  const notes = loadAllCaptures(basePath).filter(
+    c => c.status === "resolved" && !c.executed && c.classification === "note",
+  );
+  for (const cap of notes) {
+    markCaptureExecuted(basePath, cap.id);
+    result.actions.push(`Note acknowledged: ${cap.id} — "${cap.text}"`);
   }
 
   if (actionable.length === 0) return result;

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

@@ -453,6 +453,8 @@ export interface ParallelConfig {
   budget_ceiling?: number;
   merge_strategy: MergeStrategy;
   auto_merge: AutoMergeMode;
+  /** Optional model override for parallel milestone workers (e.g. "claude-haiku-4-5"). */
+  worker_model?: string;
 }
 
 // ─── Reactive Task Execution Types ───────────────────────────────────────
@@ -479,6 +481,8 @@ export interface ReactiveExecutionConfig {
   max_parallel: number;
   /** Isolation mode for parallel tasks within a slice. Currently only "same-tree" is supported. */
   isolation_mode: "same-tree";
+  /** Optional model override for subagents spawned during parallel execution. */
+  subagent_model?: string;
 }
 
 /** Per-slice reactive execution runtime state, persisted to disk. */

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

@@ -4,9 +4,10 @@
 // handleResetSlice: Reset a slice and all its tasks, re-rendering plan + roadmap.
 
 import type { ExtensionCommandContext, ExtensionAPI } from "@gsd/pi-coding-agent";
-import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "node:fs";
+import { existsSync, readFileSync, unlinkSync, readdirSync } from "node:fs";
 import { join, basename } from "node:path";
 import { nativeRevertCommit, nativeRevertAbort } from "./native-git-bridge.js";
+import { atomicWriteSync } from "./atomic-write.js";
 import { parseUnitId } from "./unit-id.js";
 import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
@@ -393,7 +394,7 @@ export function uncheckTaskInPlan(basePath: string, mid: string, sid: string, ti
   const regex = new RegExp(`^(\\s*-\\s*)\\[x\\](\\s*\\**${tid}\\**[:\\s])`, "mi");
   if (regex.test(content)) {
     content = content.replace(regex, "$1[ ]$2");
-    writeFileSync(planFile, content, "utf-8");
+    atomicWriteSync(planFile, content);
     return true;
   }
   return false;

package/src/resources/extensions/gsd/workflow-events.ts

@@ -19,10 +19,11 @@ export function getSessionId(): string {
 // ─── Event Types ─────────────────────────────────────────────────────────
 
 export interface WorkflowEvent {
-  cmd: string;           // e.g. "complete_task"
+  v?: number;              // schema version — omitted in v1 (legacy), 2 for current format
+  cmd: string;             // e.g. "complete-task" (canonical: hyphens; legacy: underscores — both accepted by replay)
   params: Record<string, unknown>;
-  ts: string;            // ISO 8601
-  hash: string;          // content hash (hex, 16 chars)
+  ts: string;              // ISO 8601
+  hash: string;            // content hash (hex, 16 chars)
   actor: "agent" | "system";
   actor_name?: string;      // e.g. "executor-agent-01" — caller-provided identity
   trigger_reason?: string;  // e.g. "plan-phase complete" — caller-provided causation
@@ -46,6 +47,7 @@ export function appendEvent(
     .slice(0, 16);
 
   const fullEvent: WorkflowEvent = {
+    v: 2,
     ...event,
     hash,
     session_id: ENGINE_SESSION_ID,

package/src/resources/extensions/gsd/workflow-logger.ts

@@ -295,7 +295,7 @@ function _sanitizeForAudit(entry: LogEntry): LogEntry {
   };
   if (entry.context) {
     // Allowlist: only persist known-safe structured keys
-    const SAFE_KEYS = new Set(["fn", "tool", "mid", "sid", "tid", "worktree"]);
+    const SAFE_KEYS = new Set(["fn", "tool", "mid", "sid", "tid", "worktree", "id", "error", "count"]);
     const filtered: Record<string, string> = {};
     for (const [k, v] of Object.entries(entry.context)) {
       if (SAFE_KEYS.has(k)) {

package/src/resources/extensions/gsd/workflow-projections.ts

@@ -16,6 +16,7 @@ import { atomicWriteSync } from "./atomic-write.js";
 import { join } from "node:path";
 import { mkdirSync, existsSync } from "node:fs";
 import { logWarning } from "./workflow-logger.js";
+import { isClosedStatus } from "./status-guards.js";
 import { deriveState } from "./state.js";
 import type { GSDState } from "./types.js";
 
@@ -55,7 +56,7 @@ export function renderPlanContent(sliceRow: SliceRow, taskRows: TaskRow[]): stri
   lines.push("## Tasks");
 
   for (const task of taskRows) {
-    const checkbox = task.status === "done" || task.status === "complete" ? "[x]" : "[ ]";
+    const checkbox = isClosedStatus(task.status) ? "[x]" : "[ ]";
     lines.push(`- ${checkbox} **${task.id}: ${task.title}** \u2014 ${task.description}`);
 
     // Estimate subline (always present if non-empty)
@@ -125,7 +126,7 @@ export function renderRoadmapContent(milestoneRow: MilestoneRow, sliceRows: Slic
   lines.push("|----|-------|------|---------|------|------------|");
 
   for (const slice of sliceRows) {
-    const done = slice.status === "done" || slice.status === "complete" ? "\u2705" : "\u2B1C";
+    const done = isClosedStatus(slice.status) ? "\u2705" : "\u2B1C";
 
     // depends is already parsed to string[] by rowToSlice
     let depends = "\u2014";
@@ -370,12 +371,10 @@ export async function renderAllProjections(basePath: string, milestoneId: string
   const sliceRows = getMilestoneSlices(milestoneId);
 
   for (const slice of sliceRows) {
-    // Render PLAN.md for each slice
-    try {
-      renderPlanProjection(basePath, milestoneId, slice.id);
-    } catch (err) {
-      logWarning("projection", `renderPlanProjection failed for ${milestoneId}/${slice.id}: ${(err as Error).message}`);
-    }
+    // PLAN.md is rendered by the authoritative markdown-renderer.js in
+    // plan-slice/replan-slice tools. Do NOT overwrite it here — the simplified
+    // projection is missing key sections (Must-Haves, Verification, Files
+    // Likely Touched) and corrupts multi-line task descriptions (#3651).
 
     // Render SUMMARY.md for each completed task
     const taskRows = getSliceTasks(milestoneId, slice.id);