gsd-pi 2.43.0 → 2.44.0-dev.62b5d6c

package/src/resources/extensions/gsd/auto-dispatch.ts

@@ -12,7 +12,9 @@
 import type { GSDState } from "./types.js";
 import type { GSDPreferences } from "./preferences.js";
 import type { UatType } from "./files.js";
-import { loadFile, extractUatType, loadActiveOverrides, parseRoadmap } from "./files.js";
+import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
+import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
+
 import {
   resolveMilestoneFile,
   resolveMilestonePath,
@@ -170,12 +172,19 @@ export const DISPATCH_RULES: DispatchRule[] = [
       if (!prefs?.uat_dispatch) return null;
 
       const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
-      const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-      if (!roadmapContent) return null;
 
-      const roadmap = parseRoadmap(roadmapContent);
-      for (const slice of roadmap.slices.filter(s => s.done)) {
-        const resultFile = resolveSliceFile(basePath, mid, slice.id, "UAT-RESULT");
+      // DB-first: get completed slices from DB
+      let completedSliceIds: string[];
+      if (isDbAvailable()) {
+        completedSliceIds = getMilestoneSlices(mid)
+          .filter(s => s.status === "complete")
+          .map(s => s.id);
+      } else {
+        return null;
+      }
+
+      for (const sliceId of completedSliceIds) {
+        const resultFile = resolveSliceFile(basePath, mid, sliceId, "UAT-RESULT");
         if (!resultFile) continue;
         const content = await loadFile(resultFile);
         if (!content) continue;
@@ -184,7 +193,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
         if (verdict && verdict !== "pass" && verdict !== "passed") {
           return {
             action: "stop" as const,
-            reason: `UAT verdict for ${slice.id} is "${verdict}" — blocking progression until resolved.\nReview the UAT result and update the verdict to PASS, or re-run /gsd auto after fixing.`,
+            reason: `UAT verdict for ${sliceId} is "${verdict}" — blocking progression until resolved.\nReview the UAT result and update the verdict to PASS, or re-run /gsd auto after fixing.`,
             level: "warning" as const,
           };
         }
@@ -501,15 +510,19 @@ export const DISPATCH_RULES: DispatchRule[] = [
       // Safety guard (#1368): verify all roadmap slices have SUMMARY files before
       // allowing milestone validation. If any slice lacks a summary, the milestone
       // is not genuinely complete — something skipped earlier slices.
-      const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
-      const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-      if (roadmapContent) {
-        const roadmap = parseRoadmap(roadmapContent);
+      let sliceIds: string[];
+      if (isDbAvailable()) {
+        sliceIds = getMilestoneSlices(mid).map(s => s.id);
+      } else {
+        sliceIds = [];
+      }
+
+      if (sliceIds.length > 0) {
         const missingSlices: string[] = [];
-        for (const slice of roadmap.slices) {
-          const summaryPath = resolveSliceFile(basePath, mid, slice.id, "SUMMARY");
+        for (const sid of sliceIds) {
+          const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
           if (!summaryPath || !existsSync(summaryPath)) {
-            missingSlices.push(slice.id);
+            missingSlices.push(sid);
           }
         }
         if (missingSlices.length > 0) {
@@ -558,15 +571,19 @@ export const DISPATCH_RULES: DispatchRule[] = [
       if (state.phase !== "completing-milestone") return null;
 
       // Safety guard (#1368): verify all roadmap slices have SUMMARY files.
-      const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
-      const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-      if (roadmapContent) {
-        const roadmap = parseRoadmap(roadmapContent);
+      let sliceIds: string[];
+      if (isDbAvailable()) {
+        sliceIds = getMilestoneSlices(mid).map(s => s.id);
+      } else {
+        sliceIds = [];
+      }
+
+      if (sliceIds.length > 0) {
         const missingSlices: string[] = [];
-        for (const slice of roadmap.slices) {
-          const summaryPath = resolveSliceFile(basePath, mid, slice.id, "SUMMARY");
+        for (const sid of sliceIds) {
+          const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
           if (!summaryPath || !existsSync(summaryPath)) {
-            missingSlices.push(slice.id);
+            missingSlices.push(sid);
           }
         }
         if (missingSlices.length > 0) {

package/src/resources/extensions/gsd/auto-post-unit.ts

@@ -17,6 +17,7 @@ import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
 import {
   resolveSliceFile,
+  resolveSlicePath,
   resolveTaskFile,
   resolveMilestoneFile,
   resolveTasksDir,
@@ -37,7 +38,8 @@ import { writeUnitRuntimeRecord, clearUnitRuntimeRecord } from "./unit-runtime.j
 import { runGSDDoctor, rebuildState, summarizeDoctorIssues } from "./doctor.js";
 import { recordHealthSnapshot, checkHealEscalation } from "./doctor-proactive.js";
 import { syncStateToProjectRoot } from "./auto-worktree-sync.js";
-import { isDbAvailable } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter } from "./gsd-db.js";
+import { renderPlanCheckboxes } from "./markdown-renderer.js";
 import { consumeSignal } from "./session-status-io.js";
 import {
   checkPostUnitHooks,
@@ -55,12 +57,135 @@ import {
   unitVerb,
   hideFooter,
 } from "./auto-dashboard.js";
-import { existsSync, unlinkSync } from "node:fs";
+import { existsSync, unlinkSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { uncheckTaskInPlan } from "./undo.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { _resetHasChangesCache } from "./native-git-bridge.js";
 
+// ─── Rogue File Detection ──────────────────────────────────────────────────
+
+export interface RogueFileWrite {
+  path: string;
+  unitType: string;
+  unitId: string;
+}
+
+/**
+ * Detect summary files written directly to disk without the LLM calling
+ * the completion tool. A "rogue" file is one that exists on disk but has
+ * no corresponding DB row with status "complete".
+ *
+ * This is a safety-net diagnostic (D003). The existing migrateFromMarkdown()
+ * in postUnitPostVerification() eventually ingests rogue files, but explicit
+ * detection provides immediate diagnostics so operators know the prompt failed.
+ */
+export function detectRogueFileWrites(
+  unitType: string,
+  unitId: string,
+  basePath: string,
+): RogueFileWrite[] {
+  if (!isDbAvailable()) return [];
+
+  const parts = unitId.split("/");
+  const rogues: RogueFileWrite[] = [];
+
+  if (unitType === "execute-task") {
+    const [mid, sid, tid] = parts;
+    if (!mid || !sid || !tid) return [];
+
+    const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+    if (!summaryPath || !existsSync(summaryPath)) return [];
+
+    const dbRow = getTask(mid, sid, tid);
+    if (!dbRow || dbRow.status !== "complete") {
+      rogues.push({ path: summaryPath, unitType, unitId });
+    }
+  } else if (unitType === "complete-slice") {
+    const [mid, sid] = parts;
+    if (!mid || !sid) return [];
+
+    const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
+    if (!summaryPath || !existsSync(summaryPath)) return [];
+
+    const dbRow = getSlice(mid, sid);
+    if (!dbRow || dbRow.status !== "complete") {
+      rogues.push({ path: summaryPath, unitType, unitId });
+    }
+  } else if (unitType === "plan-milestone") {
+    const [mid] = parts;
+    if (!mid) return [];
+
+    const roadmapPath = resolveMilestoneFile(basePath, mid, "ROADMAP");
+    if (!roadmapPath || !existsSync(roadmapPath)) return [];
+
+    const dbRow = getMilestone(mid);
+    const hasPlanningState = !!dbRow && (
+      String(dbRow.title || "").trim().length > 0 ||
+      String(dbRow.vision || "").trim().length > 0 ||
+      String(dbRow.requirement_coverage || "").trim().length > 0 ||
+      String(dbRow.boundary_map_markdown || "").trim().length > 0
+    );
+
+    if (!hasPlanningState) {
+      rogues.push({ path: roadmapPath, unitType, unitId });
+    }
+  } else if (unitType === "plan-slice" || unitType === "replan-slice") {
+    const [mid, sid] = parts;
+    if (!mid || !sid) return [];
+
+    const planPath = resolveSliceFile(basePath, mid, sid, "PLAN");
+    if (!planPath || !existsSync(planPath)) return [];
+
+    const dbRow = getSlice(mid, sid);
+    const hasPlanningState = !!dbRow && (
+      String(dbRow.title || "").trim().length > 0 ||
+      String(dbRow.demo || "").trim().length > 0 ||
+      String(dbRow.risk || "").trim().length > 0 ||
+      String(dbRow.depends || "").trim().length > 0
+    );
+
+    if (!hasPlanningState) {
+      rogues.push({ path: planPath, unitType, unitId });
+    }
+
+    // Also check for rogue REPLAN.md
+    const replanPath = resolveSliceFile(basePath, mid, sid, "REPLAN");
+    if (replanPath && existsSync(replanPath) && !hasPlanningState) {
+      rogues.push({ path: replanPath, unitType, unitId });
+    }
+  } else if (unitType === "reassess-roadmap") {
+    const [mid, sid] = parts;
+    if (!mid || !sid) return [];
+
+    const assessPath = resolveSliceFile(basePath, mid, sid, "ASSESSMENT");
+    if (!assessPath || !existsSync(assessPath)) return [];
+
+    // Assessment file exists on disk — check if DB knows about it via the artifacts table
+    const adapter = _getAdapter();
+    if (adapter) {
+      const row = adapter.prepare(
+        `SELECT 1 FROM artifacts WHERE path LIKE :pattern AND artifact_type = 'ASSESSMENT' LIMIT 1`,
+      ).get({ ":pattern": `%${sid}-ASSESSMENT.md` });
+      if (!row) {
+        rogues.push({ path: assessPath, unitType, unitId });
+      }
+    }
+  } else if (unitType === "plan-task") {
+    const [mid, sid, tid] = parts;
+    if (!mid || !sid || !tid) return [];
+
+    const taskPlanPath = resolveTaskFile(basePath, mid, sid, tid, "PLAN");
+    if (!taskPlanPath || !existsSync(taskPlanPath)) return [];
+
+    const dbRow = getTask(mid, sid, tid);
+    if (!dbRow) {
+      rogues.push({ path: taskPlanPath, unitType, unitId });
+    }
+  }
+
+  return rogues;
+}
+
 /** Throttle STATE.md rebuilds — at most once per 30 seconds */
 const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
 
@@ -355,6 +480,17 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
       }
     }
 
+    // Rogue file detection — safety net for LLM bypassing completion tools (D003)
+    try {
+      const rogueFiles = detectRogueFileWrites(s.currentUnit.type, s.currentUnit.id, s.basePath);
+      for (const rogue of rogueFiles) {
+        process.stderr.write(`gsd-rogue: detected rogue file write: ${rogue.path} (unit: ${rogue.unitId})\n`);
+        ctx.ui.notify(`Rogue file write detected: ${rogue.path}`, "warning");
+      }
+    } catch (e) {
+      debugLog("postUnit", { phase: "rogue-detection", error: String(e) });
+    }
+
     // Artifact verification
     let triggerArtifactVerified = false;
     if (!s.currentUnit.type.startsWith("hook/")) {
@@ -422,16 +558,6 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
 export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"continue" | "step-wizard" | "stopped"> {
   const { s, ctx, pi, buildSnapshotOpts, lockBase, stopAuto, pauseAuto, updateProgressWidget } = pctx;
 
-  // ── DB dual-write ──
-  if (isDbAvailable()) {
-    try {
-      const { migrateFromMarkdown } = await import("./md-importer.js");
-      migrateFromMarkdown(s.basePath);
-    } catch (err) {
-      process.stderr.write(`gsd-db: re-import failed: ${(err as Error).message}\n`);
-    }
-  }
-
   // ── Post-unit hooks ──
   if (s.currentUnit && !s.stepMode) {
     const hookUnit = checkPostUnitHooks(s.currentUnit.type, s.currentUnit.id, s.basePath);
@@ -474,9 +600,18 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
           const parts = trigger.unitId.split("/");
           const [mid, sid, tid] = parts;
 
-          // 1. Uncheck [x] → [ ] in PLAN.md
+          // 1. Reset task status in DB and re-render plan checkboxes
           if (mid && sid && tid) {
-            uncheckTaskInPlan(s.basePath, mid, sid, tid);
+            try {
+              updateTaskStatus(mid, sid, tid, "pending");
+              await renderPlanCheckboxes(s.basePath, mid, sid);
+            } catch (dbErr) {
+              // DB unavailable — fail explicitly rather than silently reverting to markdown mutation.
+              // Use 'gsd recover' to rebuild DB state from disk if needed.
+              process.stderr.write(
+                `gsd: retry state-reset failed (DB unavailable): ${(dbErr as Error).message}. Run 'gsd recover' to reconcile.\n`,
+              );
+            }
           }
 
           // 2. Delete SUMMARY.md for the task