gsd-pi 2.33.1 → 2.34.0-dev.6769913

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

@@ -11,7 +11,6 @@ import type { GSDState } from "./types.js";
 import { getCurrentBranch } from "./worktree.js";
 import { getActiveHook } from "./post-unit-hooks.js";
 import { getLedger, getProjectTotals, formatCost, formatTokenCount, formatTierSavings } from "./metrics.js";
-import { getHealthTrend, getConsecutiveErrorUnits } from "./doctor-proactive.js";
 import {
   resolveMilestoneFile,
   resolveSliceFile,
@@ -20,7 +19,6 @@ import { parseRoadmap, parsePlan } from "./files.js";
 import { readFileSync, existsSync } from "node:fs";
 import { truncateToWidth, visibleWidth } from "@gsd/pi-tui";
 import { makeUI, GLYPH, INDENT } from "../shared/mod.js";
-import { parseUnitId } from "./unit-id.js";
 
 // ─── Dashboard Data ───────────────────────────────────────────────────────────
 
@@ -49,34 +47,40 @@ export interface AutoDashboardData {
 
 // ─── Unit Description Helpers ─────────────────────────────────────────────────
 
-/** Canonical verb and phase label for each known unit type. */
-const UNIT_TYPE_INFO: Record<string, { verb: string; phaseLabel: string }> = {
-  "research-milestone": { verb: "researching",  phaseLabel: "RESEARCH" },
-  "research-slice":     { verb: "researching",  phaseLabel: "RESEARCH" },
-  "plan-milestone":     { verb: "planning",     phaseLabel: "PLAN" },
-  "plan-slice":         { verb: "planning",     phaseLabel: "PLAN" },
-  "execute-task":       { verb: "executing",    phaseLabel: "EXECUTE" },
-  "complete-slice":     { verb: "completing",   phaseLabel: "COMPLETE" },
-  "replan-slice":       { verb: "replanning",   phaseLabel: "REPLAN" },
-  "rewrite-docs":       { verb: "rewriting",    phaseLabel: "REWRITE" },
-  "reassess-roadmap":   { verb: "reassessing",  phaseLabel: "REASSESS" },
-  "run-uat":            { verb: "running UAT",  phaseLabel: "UAT" },
-};
-
 export function unitVerb(unitType: string): string {
   if (unitType.startsWith("hook/")) return `hook: ${unitType.slice(5)}`;
-  return UNIT_TYPE_INFO[unitType]?.verb ?? unitType;
+  switch (unitType) {
+    case "research-milestone":
+    case "research-slice": return "researching";
+    case "plan-milestone":
+    case "plan-slice": return "planning";
+    case "execute-task": return "executing";
+    case "complete-slice": return "completing";
+    case "replan-slice": return "replanning";
+    case "rewrite-docs": return "rewriting";
+    case "reassess-roadmap": return "reassessing";
+    case "run-uat": return "running UAT";
+    default: return unitType;
+  }
 }
 
 export function unitPhaseLabel(unitType: string): string {
   if (unitType.startsWith("hook/")) return "HOOK";
-  return UNIT_TYPE_INFO[unitType]?.phaseLabel ?? unitType.toUpperCase();
+  switch (unitType) {
+    case "research-milestone": return "RESEARCH";
+    case "research-slice": return "RESEARCH";
+    case "plan-milestone": return "PLAN";
+    case "plan-slice": return "PLAN";
+    case "execute-task": return "EXECUTE";
+    case "complete-slice": return "COMPLETE";
+    case "replan-slice": return "REPLAN";
+    case "rewrite-docs": return "REWRITE";
+    case "reassess-roadmap": return "REASSESS";
+    case "run-uat": return "UAT";
+    default: return unitType.toUpperCase();
+  }
 }
 
-/**
- * Describe the expected next step after the current unit completes.
- * Unit types here mirror the keys in UNIT_TYPE_INFO above.
- */
 function peekNext(unitType: string, state: GSDState): string {
   // Show active hook info in progress display
   const activeHookState = getActiveHook();
@@ -305,16 +309,6 @@ export function updateProgressWidget(
   }
   if (cachedBranch) widgetPwd = `${widgetPwd} (${cachedBranch})`;
 
-  // Set a string-array fallback first — this is the only version RPC mode will
-  // see, since the factory widget set below is not supported in RPC mode.
-  const progressText = buildProgressTextLines(
-    verb, phaseLabel, unitId, mid, slice, task, next,
-    accessors, tierBadge, widgetPwd,
-  );
-  ctx.ui.setWidget("gsd-progress", progressText);
-
-  // Set the factory-based widget — in TUI mode this replaces the string-array
-  // version with a dynamic, animated widget. In RPC mode this call is a no-op.
   ctx.ui.setWidget("gsd-progress", (tui, theme) => {
     let pulseBright = true;
     let cachedLines: string[] | undefined;
@@ -372,11 +366,7 @@ export function updateProgressWidget(
 
         lines.push("");
 
-        const isHook = unitType.startsWith("hook/");
-        const hookParsed = isHook ? parseUnitId(unitId) : undefined;
-        const target = isHook
-          ? (hookParsed!.task ?? hookParsed!.slice ?? unitId)
-          : (task ? `${task.id}: ${task.title}` : unitId);
+        const target = task ? `${task.id}: ${task.title}` : unitId;
         const actionLeft = `${pad}${theme.fg("accent", "▸")} ${theme.fg("accent", verb)}  ${theme.fg("text", target)}`;
         const tierTag = tierBadge ? theme.fg("dim", `[${tierBadge}] `) : "";
         const phaseBadge = `${tierTag}${theme.fg("dim", phaseLabel)}`;
@@ -396,10 +386,7 @@ export function updateProgressWidget(
             let meta = theme.fg("dim", `${done}/${total} slices`);
 
             if (activeSliceTasks && activeSliceTasks.total > 0) {
-              // For hooks, show the trigger task number (done), not the next task (done + 1)
-              const taskNum = isHook
-                ? Math.max(activeSliceTasks.done, 1)
-                : Math.min(activeSliceTasks.done + 1, activeSliceTasks.total);
+              const taskNum = Math.min(activeSliceTasks.done + 1, activeSliceTasks.total);
               meta += theme.fg("dim", `  ·  task ${taskNum}/${activeSliceTasks.total}`);
             }
 
@@ -467,7 +454,6 @@ export function updateProgressWidget(
             sp.push(`\u26A1${hitRate}%`);
           }
           if (cumulativeCost) sp.push(`$${cumulativeCost.toFixed(3)}`);
-          else if (autoTotals?.apiRequests) sp.push(`${autoTotals.apiRequests} reqs`);
 
           const cxDisplay = cxPct === "?"
             ? `?/${formatWidgetTokens(cxWindow)}`
@@ -526,95 +512,6 @@ export function updateProgressWidget(
   });
 }
 
-// ─── Text Fallback for RPC Mode ───────────────────────────────────────────
-
-/**
- * Build a compact string-array representation of the progress widget.
- * Used as a fallback when the factory-based widget cannot render (RPC mode).
- */
-// ─── Model Health Indicator ───────────────────────────────────────────────────
-
-/**
- * Compute a traffic-light health indicator from observable signals.
- * 🟢 progressing well — no errors, trend stable/improving
- * 🟡 struggling — some errors or degrading trend
- * 🔴 stuck — consecutive errors, likely needs attention
- */
-export function getModelHealthIndicator(): { emoji: string; label: string } {
-  const trend = getHealthTrend();
-  const consecutiveErrors = getConsecutiveErrorUnits();
-
-  if (consecutiveErrors >= 3) {
-    return { emoji: "🔴", label: "stuck" };
-  }
-  if (consecutiveErrors >= 1 || trend === "degrading") {
-    return { emoji: "🟡", label: "struggling" };
-  }
-  if (trend === "improving") {
-    return { emoji: "🟢", label: "progressing well" };
-  }
-  // stable or unknown
-  return { emoji: "🟢", label: "progressing" };
-}
-
-function buildProgressTextLines(
-  verb: string,
-  phaseLabel: string,
-  unitId: string,
-  mid: { id: string; title: string } | null,
-  slice: { id: string; title: string } | null,
-  task: { id: string; title: string } | null,
-  next: string,
-  accessors: WidgetStateAccessors,
-  tierBadge: string | undefined,
-  widgetPwd: string,
-): string[] {
-  const mode = accessors.isStepMode() ? "step" : "auto";
-  const elapsed = formatAutoElapsed(accessors.getAutoStartTime());
-  const tierStr = tierBadge ? ` [${tierBadge}]` : "";
-
-  const lines: string[] = [];
-  lines.push(`[GSD ${mode}] ${verb} ${unitId}${tierStr}${elapsed ? ` — ${elapsed}` : ""}`);
-
-  if (mid) lines.push(`  Milestone: ${mid.id} — ${mid.title}`);
-  if (slice) lines.push(`  Slice: ${slice.id} — ${slice.title}`);
-  if (task) lines.push(`  Task: ${task.id} — ${task.title}`);
-
-  // Progress bar
-  const sp = cachedSliceProgress;
-  if (sp && sp.total > 0) {
-    const pct = Math.round((sp.done / sp.total) * 100);
-    const taskInfo = sp.activeSliceTasks
-      ? ` (tasks: ${sp.activeSliceTasks.done}/${sp.activeSliceTasks.total})`
-      : "";
-    lines.push(`  Progress: ${sp.done}/${sp.total} slices (${pct}%)${taskInfo}`);
-  }
-
-  // Cost / tokens
-  const ledger = getLedger();
-  const totals = ledger ? getProjectTotals(ledger.units) : null;
-  if (totals) {
-    const parts: string[] = [];
-    if (totals.tokens.input || totals.tokens.output) {
-      parts.push(`tokens: ${formatWidgetTokens(totals.tokens.input)}↑ ${formatWidgetTokens(totals.tokens.output)}↓`);
-    }
-    if (totals.cost > 0) {
-      parts.push(`cost: ${formatCost(totals.cost)}`);
-    }
-    if (parts.length > 0) lines.push(`  ${parts.join(" — ")}`);
-  }
-
-  if (next) lines.push(`  Next: ${next}`);
-
-  // Model health indicator
-  const health = getModelHealthIndicator();
-  lines.push(`  Health: ${health.emoji} ${health.label}`);
-
-  lines.push(`  ${widgetPwd}`);
-
-  return lines;
-}
-
 // ─── Right-align Helper ───────────────────────────────────────────────────────
 
 /** Right-align helper: build a line with left content and right content. */

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

@@ -182,10 +182,15 @@ export async function dispatchDirectPhase(
         ctx.ui.notify("Cannot dispatch run-uat: no UAT file found.", "warning");
         return;
       }
+      const uatContent = await loadFile(uatFile);
+      if (!uatContent) {
+        ctx.ui.notify("Cannot dispatch run-uat: UAT file is empty.", "warning");
+        return;
+      }
       const uatPath = relSliceFile(base, mid, sid, "UAT");
       unitType = "run-uat";
       unitId = `${mid}/${sid}`;
-      prompt = await buildRunUatPrompt(mid, sid, uatPath, base);
+      prompt = await buildRunUatPrompt(mid, sid, uatPath, uatContent, base);
       break;
     }
 

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

@@ -11,10 +11,15 @@
 
 import type { GSDState } from "./types.js";
 import type { GSDPreferences } from "./preferences.js";
-import { loadFile, loadActiveOverrides, parseRoadmap } from "./files.js";
+import type { UatType } from "./files.js";
+import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
 import {
-  resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile,
-  relSliceFile, buildMilestoneFileName,
+  resolveMilestoneFile,
+  resolveMilestonePath,
+  resolveSliceFile,
+  resolveTaskFile,
+  relSliceFile,
+  buildMilestoneFileName,
 } from "./paths.js";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
@@ -38,7 +43,13 @@ import {
 // ─── Types ────────────────────────────────────────────────────────────────
 
 export type DispatchAction =
-  | { action: "dispatch"; unitType: string; unitId: string; prompt: string }
+  | {
+      action: "dispatch";
+      unitType: string;
+      unitId: string;
+      prompt: string;
+      pauseAfterDispatch?: boolean;
+    }
   | { action: "stop"; reason: string; level: "info" | "warning" | "error" }
   | { action: "skip" };
 
@@ -57,6 +68,14 @@ interface DispatchRule {
   match: (ctx: DispatchContext) => Promise<DispatchAction | null>;
 }
 
+function missingSliceStop(mid: string, phase: string): DispatchAction {
+  return {
+    action: "stop",
+    reason: `${mid}: phase "${phase}" has no active slice — run /gsd doctor.`,
+    level: "error",
+  };
+}
+
 // ─── Rewrite Circuit Breaker ──────────────────────────────────────────────
 
 const MAX_REWRITE_ATTEMPTS = 3;
@@ -65,28 +84,6 @@ export function resetRewriteCircuitBreaker(): void {
   rewriteAttemptCount = 0;
 }
 
-/**
- * Guard for accessing activeSlice/activeTask in dispatch rules.
- * Returns a stop action if the expected ref is null (corrupt state).
- */
-function requireSlice(state: GSDState): { sid: string; sTitle: string } | DispatchAction {
-  if (!state.activeSlice) {
-    return { action: "stop", reason: `Phase "${state.phase}" but no active slice — run /gsd doctor.`, level: "error" };
-  }
-  return { sid: state.activeSlice.id, sTitle: state.activeSlice.title };
-}
-
-function requireTask(state: GSDState): { sid: string; sTitle: string; tid: string; tTitle: string } | DispatchAction {
-  if (!state.activeSlice || !state.activeTask) {
-    return { action: "stop", reason: `Phase "${state.phase}" but no active slice/task — run /gsd doctor.`, level: "error" };
-  }
-  return { sid: state.activeSlice.id, sTitle: state.activeSlice.title, tid: state.activeTask.id, tTitle: state.activeTask.title };
-}
-
-function isStopAction(v: unknown): v is DispatchAction {
-  return typeof v === "object" && v !== null && "action" in v;
-}
-
 // ─── Rules ────────────────────────────────────────────────────────────────
 
 const DISPATCH_RULES: DispatchRule[] = [
@@ -107,7 +104,13 @@ const DISPATCH_RULES: DispatchRule[] = [
         action: "dispatch",
         unitType: "rewrite-docs",
         unitId,
-        prompt: await buildRewriteDocsPrompt(mid, midTitle, state.activeSlice, basePath, pendingOverrides),
+        prompt: await buildRewriteDocsPrompt(
+          mid,
+          midTitle,
+          state.activeSlice,
+          basePath,
+          pendingOverrides,
+        ),
       };
     },
   },
@@ -115,74 +118,63 @@ const DISPATCH_RULES: DispatchRule[] = [
     name: "summarizing → complete-slice",
     match: async ({ state, mid, midTitle, basePath }) => {
       if (state.phase !== "summarizing") return null;
-      const sliceRef = requireSlice(state);
-      if (isStopAction(sliceRef)) return sliceRef as DispatchAction;
-      const { sid, sTitle } = sliceRef;
+      if (!state.activeSlice) return missingSliceStop(mid, state.phase);
+      const sid = state.activeSlice!.id;
+      const sTitle = state.activeSlice!.title;
       return {
         action: "dispatch",
         unitType: "complete-slice",
         unitId: `${mid}/${sid}`,
-        prompt: await buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, basePath),
+        prompt: await buildCompleteSlicePrompt(
+          mid,
+          midTitle,
+          sid,
+          sTitle,
+          basePath,
+        ),
       };
     },
   },
-  {
-    name: "uat-verdict-gate (non-PASS blocks progression)",
-    match: async ({ mid, basePath, prefs }) => {
-      // Only applies when UAT dispatch is enabled
-      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");
-        if (!resultFile) continue;
-        const content = await loadFile(resultFile);
-        if (!content) continue;
-        const verdictMatch = content.match(/verdict:\s*([\w-]+)/i);
-        const verdict = verdictMatch?.[1]?.toLowerCase();
-        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.`,
-            level: "warning" as const,
-          };
-        }
-      }
-      return null;
-    },
-  },
   {
     name: "run-uat (post-completion)",
     match: async ({ state, mid, basePath, prefs }) => {
       const needsRunUat = await checkNeedsRunUat(basePath, mid, state, prefs);
       if (!needsRunUat) return null;
-      const { sliceId } = needsRunUat;
+      const { sliceId, uatType } = needsRunUat;
+      const uatFile = resolveSliceFile(basePath, mid, sliceId, "UAT")!;
+      const uatContent = await loadFile(uatFile);
       return {
         action: "dispatch",
         unitType: "run-uat",
         unitId: `${mid}/${sliceId}`,
         prompt: await buildRunUatPrompt(
-          mid, sliceId, relSliceFile(basePath, mid, sliceId, "UAT"), basePath,
+          mid,
+          sliceId,
+          relSliceFile(basePath, mid, sliceId, "UAT"),
+          uatContent ?? "",
+          basePath,
         ),
+        pauseAfterDispatch: uatType !== "artifact-driven",
       };
     },
   },
   {
     name: "reassess-roadmap (post-completion)",
     match: async ({ state, mid, midTitle, basePath, prefs }) => {
-      // Reassess is opt-in: only fire when explicitly enabled
-      if (!prefs?.phases?.reassess_after_slice) return null;
+      if (prefs?.phases?.skip_reassess || !prefs?.phases?.reassess_after_slice)
+        return null;
       const needsReassess = await checkNeedsReassessment(basePath, mid, state);
       if (!needsReassess) return null;
       return {
         action: "dispatch",
         unitType: "reassess-roadmap",
         unitId: `${mid}/${needsReassess.sliceId}`,
-        prompt: await buildReassessRoadmapPrompt(mid, midTitle, needsReassess.sliceId, basePath),
+        prompt: await buildReassessRoadmapPrompt(
+          mid,
+          midTitle,
+          needsReassess.sliceId,
+          basePath,
+        ),
       };
     },
   },
@@ -202,7 +194,7 @@ const DISPATCH_RULES: DispatchRule[] = [
     match: async ({ state, mid, basePath }) => {
       if (state.phase !== "pre-planning") return null;
       const contextFile = resolveMilestoneFile(basePath, mid, "CONTEXT");
-      const hasContext = !!(contextFile && await loadFile(contextFile));
+      const hasContext = !!(contextFile && (await loadFile(contextFile)));
       if (hasContext) return null; // fall through to next rule
       return {
         action: "stop",
@@ -244,21 +236,32 @@ const DISPATCH_RULES: DispatchRule[] = [
     match: async ({ state, mid, midTitle, basePath, prefs }) => {
       if (state.phase !== "planning") return null;
       // Phase skip: skip research when preference or profile says so
-      if (prefs?.phases?.skip_research || prefs?.phases?.skip_slice_research) return null;
-      const sliceRef = requireSlice(state);
-      if (isStopAction(sliceRef)) return sliceRef as DispatchAction;
-      const { sid, sTitle } = sliceRef;
+      if (prefs?.phases?.skip_research || prefs?.phases?.skip_slice_research)
+        return null;
+      if (!state.activeSlice) return missingSliceStop(mid, state.phase);
+      const sid = state.activeSlice!.id;
+      const sTitle = state.activeSlice!.title;
       const researchFile = resolveSliceFile(basePath, mid, sid, "RESEARCH");
       if (researchFile) return null; // has research, fall through
       // Skip slice research for S01 when milestone research already exists —
       // the milestone research already covers the same ground for the first slice.
-      const milestoneResearchFile = resolveMilestoneFile(basePath, mid, "RESEARCH");
+      const milestoneResearchFile = resolveMilestoneFile(
+        basePath,
+        mid,
+        "RESEARCH",
+      );
       if (milestoneResearchFile && sid === "S01") return null; // fall through to plan-slice
       return {
         action: "dispatch",
         unitType: "research-slice",
         unitId: `${mid}/${sid}`,
-        prompt: await buildResearchSlicePrompt(mid, midTitle, sid, sTitle, basePath),
+        prompt: await buildResearchSlicePrompt(
+          mid,
+          midTitle,
+          sid,
+          sTitle,
+          basePath,
+        ),
       };
     },
   },
@@ -266,14 +269,20 @@ const DISPATCH_RULES: DispatchRule[] = [
     name: "planning → plan-slice",
     match: async ({ state, mid, midTitle, basePath }) => {
       if (state.phase !== "planning") return null;
-      const sliceRef = requireSlice(state);
-      if (isStopAction(sliceRef)) return sliceRef as DispatchAction;
-      const { sid, sTitle } = sliceRef;
+      if (!state.activeSlice) return missingSliceStop(mid, state.phase);
+      const sid = state.activeSlice!.id;
+      const sTitle = state.activeSlice!.title;
       return {
         action: "dispatch",
         unitType: "plan-slice",
         unitId: `${mid}/${sid}`,
-        prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath),
+        prompt: await buildPlanSlicePrompt(
+          mid,
+          midTitle,
+          sid,
+          sTitle,
+          basePath,
+        ),
       };
     },
   },
@@ -281,14 +290,20 @@ const DISPATCH_RULES: DispatchRule[] = [
     name: "replanning-slice → replan-slice",
     match: async ({ state, mid, midTitle, basePath }) => {
       if (state.phase !== "replanning-slice") return null;
-      const sliceRef = requireSlice(state);
-      if (isStopAction(sliceRef)) return sliceRef as DispatchAction;
-      const { sid, sTitle } = sliceRef;
+      if (!state.activeSlice) return missingSliceStop(mid, state.phase);
+      const sid = state.activeSlice!.id;
+      const sTitle = state.activeSlice!.title;
       return {
         action: "dispatch",
         unitType: "replan-slice",
         unitId: `${mid}/${sid}`,
-        prompt: await buildReplanSlicePrompt(mid, midTitle, sid, sTitle, basePath),
+        prompt: await buildReplanSlicePrompt(
+          mid,
+          midTitle,
+          sid,
+          sTitle,
+          basePath,
+        ),
       };
     },
   },
@@ -296,9 +311,9 @@ const DISPATCH_RULES: DispatchRule[] = [
     name: "executing → execute-task (recover missing task plan → plan-slice)",
     match: async ({ state, mid, midTitle, basePath }) => {
       if (state.phase !== "executing" || !state.activeTask) return null;
-      const sliceRef = requireSlice(state);
-      if (isStopAction(sliceRef)) return sliceRef as DispatchAction;
-      const { sid, sTitle } = sliceRef;
+      if (!state.activeSlice) return missingSliceStop(mid, state.phase);
+      const sid = state.activeSlice!.id;
+      const sTitle = state.activeSlice!.title;
       const tid = state.activeTask.id;
 
       // Guard: if the slice plan exists but the individual task plan files are
@@ -312,7 +327,13 @@ const DISPATCH_RULES: DispatchRule[] = [
           action: "dispatch",
           unitType: "plan-slice",
           unitId: `${mid}/${sid}`,
-          prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath),
+          prompt: await buildPlanSlicePrompt(
+            mid,
+            midTitle,
+            sid,
+            sTitle,
+            basePath,
+          ),
         };
       }
 
@@ -323,9 +344,9 @@ const DISPATCH_RULES: DispatchRule[] = [
     name: "executing → execute-task",
     match: async ({ state, mid, basePath }) => {
       if (state.phase !== "executing" || !state.activeTask) return null;
-      const sliceRef = requireSlice(state);
-      if (isStopAction(sliceRef)) return sliceRef as DispatchAction;
-      const { sid, sTitle } = sliceRef;
+      if (!state.activeSlice) return missingSliceStop(mid, state.phase);
+      const sid = state.activeSlice!.id;
+      const sTitle = state.activeSlice!.title;
       const tid = state.activeTask.id;
       const tTitle = state.activeTask.title;
 
@@ -333,7 +354,14 @@ const DISPATCH_RULES: DispatchRule[] = [
         action: "dispatch",
         unitType: "execute-task",
         unitId: `${mid}/${sid}/${tid}`,
-        prompt: await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, basePath),
+        prompt: await buildExecuteTaskPrompt(
+          mid,
+          sid,
+          sTitle,
+          tid,
+          tTitle,
+          basePath,
+        ),
       };
     },
   },
@@ -346,7 +374,10 @@ const DISPATCH_RULES: DispatchRule[] = [
         const mDir = resolveMilestonePath(basePath, mid);
         if (mDir) {
           if (!existsSync(mDir)) mkdirSync(mDir, { recursive: true });
-          const validationPath = join(mDir, buildMilestoneFileName(mid, "VALIDATION"));
+          const validationPath = join(
+            mDir,
+            buildMilestoneFileName(mid, "VALIDATION"),
+          );
           const content = [
             "---",
             "verdict: pass",
@@ -381,6 +412,17 @@ const DISPATCH_RULES: DispatchRule[] = [
       };
     },
   },
+  {
+    name: "complete → stop",
+    match: async ({ state }) => {
+      if (state.phase !== "complete") return null;
+      return {
+        action: "stop",
+        reason: "All milestones complete.",
+        level: "info",
+      };
+    },
+  },
 ];
 
 // ─── Resolver ─────────────────────────────────────────────────────────────
@@ -389,7 +431,9 @@ const DISPATCH_RULES: DispatchRule[] = [
  * Evaluate dispatch rules in order. Returns the first matching action,
  * or a "stop" action if no rule matches (unhandled phase).
  */
-export async function resolveDispatch(ctx: DispatchContext): Promise<DispatchAction> {
+export async function resolveDispatch(
+  ctx: DispatchContext,
+): Promise<DispatchAction> {
   for (const rule of DISPATCH_RULES) {
     const result = await rule.match(ctx);
     if (result) return result;
@@ -405,5 +449,5 @@ export async function resolveDispatch(ctx: DispatchContext): Promise<DispatchAct
 
 /** Exposed for testing — returns the rule names in evaluation order. */
 export function getDispatchRuleNames(): string[] {
-  return DISPATCH_RULES.map(r => r.name);
+  return DISPATCH_RULES.map((r) => r.name);
 }