gsd-pi 2.65.0-dev.5c8557b → 2.65.0-dev.6cc5110

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,7 +19,7 @@ export function getSessionId(): string {
 // ─── Event Types ─────────────────────────────────────────────────────────
 
 export interface WorkflowEvent {
-  cmd: string;           // e.g. "complete_task"
+  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)

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

@@ -370,12 +370,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);

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

@@ -7,12 +7,20 @@ import {
   transaction,
   updateTaskStatus,
   updateSliceStatus,
+  updateMilestoneStatus,
   getSliceTasks,
+  insertMilestone,
+  _getAdapter,
+  getMilestoneSlices,
   insertVerificationEvidence,
   upsertDecision,
   openDatabase,
+  setTaskBlockerDiscovered,
 } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
+import { invalidateStateCache } from "./state.js";
+import { clearPathCache } from "./paths.js";
+import { clearParseCache } from "./files.js";
 import { writeManifest } from "./workflow-manifest.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { acquireSyncLock, releaseSyncLock } from "./sync-lock.js";
@@ -73,7 +81,15 @@ function replayEvents(events: WorkflowEvent[]): void {
   transaction(() => {
   for (const event of events) {
     const p = event.params;
-    switch (event.cmd) {
+    // Normalize cmd format: completion tools write hyphens ("complete-task"),
+    // legacy logs use underscores ("complete_task"). Accept both formats.
+    // Type guard: malformed event lines with non-string cmd are skipped.
+    if (typeof event.cmd !== "string") {
+      logWarning("reconcile", `Event with non-string cmd skipped: ${JSON.stringify(event.cmd)}`);
+      continue;
+    }
+    const cmd = event.cmd.replace(/-/g, "_");
+    switch (cmd) {
       case "complete_task": {
         const milestoneId = p["milestoneId"] as string;
         const sliceId = p["sliceId"] as string;
@@ -89,13 +105,11 @@ function replayEvents(events: WorkflowEvent[]): void {
         break;
       }
       case "report_blocker": {
-        // report_blocker marks the task with blocker_discovered = 1
-        // The DB helper updateTaskStatus doesn't handle blockers,
-        // so we just update status to "blocked" as a best-effort replay.
         const milestoneId = p["milestoneId"] as string;
         const sliceId = p["sliceId"] as string;
         const taskId = p["taskId"] as string;
         updateTaskStatus(milestoneId, sliceId, taskId, "blocked");
+        setTaskBlockerDiscovered(milestoneId, sliceId, taskId, true);
         break;
       }
       case "record_verification": {
@@ -120,9 +134,66 @@ function replayEvents(events: WorkflowEvent[]): void {
         replaySliceComplete(milestoneId, sliceId, event.ts);
         break;
       }
+      case "complete_milestone": {
+        const milestoneId = p["milestoneId"] as string;
+        if (!milestoneId) break;
+        // Invariant check: only mark complete if all slices are closed.
+        // Without this guard, a reordered/partial event stream could close
+        // a milestone while work is still incomplete.
+        const mSlices = getMilestoneSlices(milestoneId);
+        const allClosed = mSlices.length === 0 || mSlices.every(s => isClosedStatus(s.status));
+        if (allClosed) {
+          updateMilestoneStatus(milestoneId, "complete", event.ts);
+        } else {
+          logWarning("reconcile", `Skipping complete_milestone replay for ${milestoneId}: not all slices are closed`);
+        }
+        break;
+      }
+      case "plan_milestone": {
+        // Replay milestone creation — uses INSERT OR IGNORE (gsd-db's insertMilestone is safe)
+        const mId = p["milestoneId"] as string;
+        if (mId) {
+          insertMilestone({ id: mId, title: (p["title"] as string) ?? mId });
+        }
+        break;
+      }
       case "plan_slice": {
-        // plan_slice events are informational — slice should already exist.
-        // No DB mutation needed during replay (the slice was inserted at plan time).
+        // Replay slice creation — strict INSERT OR IGNORE to avoid overwriting
+        // progressed status. insertSlice() uses ON CONFLICT DO UPDATE which
+        // could downgrade a completed slice back to pending.
+        const milestoneId = p["milestoneId"] as string;
+        const sliceId = p["sliceId"] as string;
+        if (milestoneId && sliceId) {
+          const adapter = _getAdapter();
+          if (adapter) {
+            adapter.prepare(
+              `INSERT OR IGNORE INTO slices (milestone_id, id, title, status, created_at)
+               VALUES (:mid, :sid, :title, 'pending', :ts)`,
+            ).run({ ":mid": milestoneId, ":sid": sliceId, ":title": (p["title"] as string) ?? sliceId, ":ts": event.ts });
+          }
+        }
+        break;
+      }
+      case "plan_task": {
+        // Replay task creation — strict INSERT OR IGNORE to avoid overwriting
+        // progressed status. insertTask() uses ON CONFLICT DO UPDATE which
+        // could downgrade a done/in-progress task back to pending.
+        const milestoneId = p["milestoneId"] as string;
+        const sliceId = p["sliceId"] as string;
+        const taskId = p["taskId"] as string;
+        if (milestoneId && sliceId && taskId) {
+          const adapter = _getAdapter();
+          if (adapter) {
+            adapter.prepare(
+              `INSERT OR IGNORE INTO tasks (milestone_id, slice_id, id, title, status, created_at)
+               VALUES (:mid, :sid, :tid, :title, 'pending', :ts)`,
+            ).run({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId, ":title": (p["title"] as string) ?? taskId, ":ts": event.ts });
+          }
+        }
+        break;
+      }
+      case "replan_slice": {
+        // Informational — replan events don't mutate DB during replay
         break;
       }
       case "save_decision": {
@@ -140,7 +211,7 @@ function replayEvents(events: WorkflowEvent[]): void {
         break;
       }
       default:
-        // Unknown commands are silently skipped during replay
+        logWarning("reconcile", `Unknown event cmd during replay: "${event.cmd}" — skipped`);
         break;
     }
   }
@@ -158,26 +229,42 @@ export function extractEntityKey(
   event: WorkflowEvent,
 ): { type: string; id: string } | null {
   const p = event.params;
+  // Normalize cmd format: accept both hyphens and underscores
+  if (typeof event.cmd !== "string") return null;
+  const cmd = event.cmd.replace(/-/g, "_");
 
-  switch (event.cmd) {
+  switch (cmd) {
     case "complete_task":
     case "start_task":
     case "report_blocker":
     case "record_verification":
+    case "plan_task":
       return typeof p["taskId"] === "string"
         ? { type: "task", id: p["taskId"] }
         : null;
 
     case "complete_slice":
+    case "replan_slice":
       return typeof p["sliceId"] === "string"
         ? { type: "slice", id: p["sliceId"] }
         : null;
 
+    case "complete_milestone":
+      return typeof p["milestoneId"] === "string"
+        ? { type: "milestone", id: p["milestoneId"] }
+        : null;
+
     case "plan_slice":
       return typeof p["sliceId"] === "string"
         ? { type: "slice_plan", id: p["sliceId"] }
         : null;
 
+    case "complete_milestone":
+    case "plan_milestone":
+      return typeof p["milestoneId"] === "string"
+        ? { type: "milestone", id: p["milestoneId"] }
+        : null;
+
     case "save_decision":
       if (typeof p["scope"] === "string" && typeof p["decision"] === "string") {
         return { type: "decision", id: `${p["scope"]}:${p["decision"]}` };
@@ -360,6 +447,14 @@ function _reconcileWorktreeLogsInner(
   const merged = indexed.map(({ e }) => e);
 
   // Step 7: Write merged event log FIRST (so crash recovery can re-derive DB state)
+  // Guard: detect concurrent appendEvent calls between our read (step 1) and
+  // this rewrite. If the log grew, re-read and retry to avoid dropping events.
+  const preWriteEvents = readEvents(mainLogPath);
+  if (preWriteEvents.length > mainEvents.length) {
+    logWarning("reconcile", `Event log grew during reconcile (${mainEvents.length} → ${preWriteEvents.length}), retrying with fresh read`);
+    return _reconcileWorktreeLogsInner(mainBasePath, worktreeBasePath);
+  }
+
   const baseEvents = mainEvents.slice(0, forkPoint + 1);
   const mergedLog = baseEvents.concat(merged);
   const logContent = mergedLog.map((e) => JSON.stringify(e)).join("\n") + (mergedLog.length > 0 ? "\n" : "");
@@ -377,6 +472,12 @@ function _reconcileWorktreeLogsInner(
     logWarning("reconcile", "manifest write failed (non-fatal)", { error: (err as Error).message });
   }
 
+  // Step 10: Invalidate caches so deriveState() sees post-reconcile DB state.
+  // Use targeted invalidation (not invalidateAllCaches) to avoid wiping artifacts table.
+  invalidateStateCache();
+  clearPathCache();
+  clearParseCache();
+
   return { autoMerged: merged.length, conflicts: [] };
 }
 

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

@@ -58,8 +58,17 @@ let cachedRegistry: TemplateRegistry | null = null;
 export function loadRegistry(): TemplateRegistry {
   if (cachedRegistry) return cachedRegistry;
 
-  const content = readFileSync(registryPath, "utf-8");
-  cachedRegistry = JSON.parse(content) as TemplateRegistry;
+  if (!existsSync(registryPath)) {
+    cachedRegistry = { version: 1, templates: {} };
+    return cachedRegistry;
+  }
+
+  try {
+    const content = readFileSync(registryPath, "utf-8");
+    cachedRegistry = JSON.parse(content) as TemplateRegistry;
+  } catch {
+    cachedRegistry = { version: 1, templates: {} };
+  }
   return cachedRegistry;
 }
 

package/src/resources/extensions/gsd/worktree-manager.ts

@@ -89,7 +89,9 @@ function normalizePathForComparison(path: string): string {
  */
 export function resolveGitDir(basePath: string): string {
   const gitPath = join(basePath, ".git");
-  if (!existsSync(gitPath)) return join(basePath, ".git");
+  if (!existsSync(gitPath)) return gitPath;
+  // In a normal repo .git is a directory — skip the file read (#3597)
+  if (lstatSync(gitPath).isDirectory()) return gitPath;
   try {
     const content = readFileSync(gitPath, "utf-8").trim();
     if (content.startsWith("gitdir: ")) {
@@ -98,7 +100,7 @@ export function resolveGitDir(basePath: string): string {
   } catch (e) {
     logWarning("worktree", `.git file read failed: ${(e as Error).message}`);
   }
-  return join(basePath, ".git");
+  return gitPath;
 }
 
 export function worktreesDir(basePath: string): string {

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

@@ -42,6 +42,16 @@ function getService(basePath: string): GitServiceImpl {
   return cachedService;
 }
 
+/**
+ * Clear the cached GitServiceImpl. For testing only — forces the next
+ * getService() call to re-read preferences and create a fresh instance.
+ * @internal
+ */
+export function _resetServiceCache(): void {
+  cachedService = null;
+  cachedBasePath = null;
+}
+
 /**
  * Set the active milestone ID on the cached GitServiceImpl.
  * This enables integration branch resolution in getMainBranch().

package/src/resources/extensions/shared/interview-ui.ts

@@ -300,7 +300,7 @@ export async function showInterviewRound(
 			// instead of being trapped in a re-asking loop (bug #2715).
 			// Only auto-open if the user hasn't already provided notes —
 			// otherwise Enter from notes mode loops back here endlessly.
-			if (!isMultiSelect(currentIdx) && states[currentIdx].cursorIndex === noneOrDoneIdx(currentIdx) && !states[currentIdx].notes) {
+			if (!isMultiSelect(currentIdx) && states[currentIdx].cursorIndex === noneOrDoneIdx(currentIdx) && !states[currentIdx].notes && !states[currentIdx].notesVisible) {
 				states[currentIdx].notesVisible = true;
 				focusNotes = true;
 				loadStateToEditor();

package/src/resources/extensions/shared/tests/interview-notes-loop.test.ts

@@ -109,25 +109,23 @@ describe("interview-ui notes loop regression (#3502)", () => {
 		assert.equal(answer.selected, "None of the above");
 	});
 
-	it("still auto-opens notes when selecting 'None of the above' with no prior notes", async () => {
+	it("Enter on empty notes advances instead of re-opening (notesVisible guard)", async () => {
 		// Press Down twice to "None of the above", Enter to select
-		// Then immediately Enter again (empty notes) — this should re-open notes
-		// because the guard only skips when notes are non-empty.
-		// Type something on second open, then Enter to proceed.
+		// Then immediately Enter again (empty notes) — notesVisible is already
+		// true from auto-open, so the guard prevents re-opening and Enter
+		// advances to review. The notes remain empty.
 		const result = await runWithInputs(questions, [
 			DOWN,        // cursor → 1
 			DOWN,        // cursor → 2 (None of the above)
-			ENTER,       // commit → auto-opens notes
-			ENTER,       // empty notes → goNextOrSubmit → should re-open notes (empty guard)
-			"o", "k",    // type "ok"
-			ENTER,       // now notes = "ok" → should advance to review
-			ENTER,       // submit
+			ENTER,       // commit → auto-opens notes (notesVisible = true)
+			ENTER,       // empty notes → notesVisible prevents re-open → advances to review
+			ENTER,       // submit from review screen
 		]);
 
 		assert.ok(result, "should return a result");
 		const answer = result.answers.q1;
 		assert.ok(answer, "answer for q1 should exist");
-		assert.equal(answer.notes, "ok");
+		assert.equal(answer.notes, "");
 	});
 
 	it("normal option selection is unaffected", async () => {