gsd-pi 2.33.1-dev.ee47f1b → 2.34.0-dev.0150ae9

package/dist/bundled-resource-path.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Resolve bundled raw resource files from the package root.
+ *
+ * Both `src/*.ts` and compiled `dist/*.js` entry points need to load the same
+ * raw `.ts` resource modules via jiti. Those modules are shipped under
+ * `src/resources/**`, not next to the compiled entry point.
+ */
+export declare function resolveBundledSourceResource(importUrl: string, ...segments: string[]): string;

package/dist/bundled-resource-path.js

@@ -0,0 +1,14 @@
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Resolve bundled raw resource files from the package root.
+ *
+ * Both `src/*.ts` and compiled `dist/*.js` entry points need to load the same
+ * raw `.ts` resource modules via jiti. Those modules are shipped under
+ * `src/resources/**`, not next to the compiled entry point.
+ */
+export function resolveBundledSourceResource(importUrl, ...segments) {
+    const moduleDir = dirname(fileURLToPath(importUrl));
+    const packageRoot = resolve(moduleDir, "..");
+    return join(packageRoot, "src", "resources", ...segments);
+}

package/dist/headless-query.js

@@ -15,14 +15,14 @@
  */
 import { createJiti } from '@mariozechner/jiti';
 import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-const __dirname = dirname(fileURLToPath(import.meta.url));
+import { resolveBundledSourceResource } from './bundled-resource-path.js';
 const jiti = createJiti(fileURLToPath(import.meta.url), { interopDefault: true, debug: false });
+const gsdExtensionPath = (...segments) => resolveBundledSourceResource(import.meta.url, 'extensions', 'gsd', ...segments);
 async function loadExtensionModules() {
-    const stateModule = await jiti.import(join(__dirname, 'resources/extensions/gsd/state.ts'), {});
-    const dispatchModule = await jiti.import(join(__dirname, 'resources/extensions/gsd/auto-dispatch.ts'), {});
-    const sessionModule = await jiti.import(join(__dirname, 'resources/extensions/gsd/session-status-io.ts'), {});
-    const prefsModule = await jiti.import(join(__dirname, 'resources/extensions/gsd/preferences.ts'), {});
+    const stateModule = await jiti.import(gsdExtensionPath('state.ts'), {});
+    const dispatchModule = await jiti.import(gsdExtensionPath('auto-dispatch.ts'), {});
+    const sessionModule = await jiti.import(gsdExtensionPath('session-status-io.ts'), {});
+    const prefsModule = await jiti.import(gsdExtensionPath('preferences.ts'), {});
     return {
         deriveState: stateModule.deriveState,
         resolveDispatch: dispatchModule.resolveDispatch,

package/dist/resources/extensions/gsd/auto/session.js

@@ -19,17 +19,12 @@
 export const MAX_UNIT_DISPATCHES = 3;
 export const STUB_RECOVERY_THRESHOLD = 2;
 export const MAX_LIFETIME_DISPATCHES = 6;
-export const MAX_CONSECUTIVE_SKIPS = 3;
-export const DISPATCH_GAP_TIMEOUT_MS = 5_000;
-export const MAX_SKIP_DEPTH = 20;
 export const NEW_SESSION_TIMEOUT_MS = 30_000;
-export const DISPATCH_HANG_TIMEOUT_MS = 60_000;
 // ─── AutoSession ─────────────────────────────────────────────────────────────
 export class AutoSession {
     // ── Lifecycle ────────────────────────────────────────────────────────────
     active = false;
     paused = false;
-    pausedForSecrets = false;
     stepMode = false;
     verbose = false;
     cmdCtx = null;
@@ -41,14 +36,11 @@ export class AutoSession {
     unitDispatchCount = new Map();
     unitLifetimeDispatches = new Map();
     unitRecoveryCount = new Map();
-    unitConsecutiveSkips = new Map();
-    completedKeySet = new Set();
     // ── Timers ───────────────────────────────────────────────────────────────
     unitTimeoutHandle = null;
     wrapupWarningHandle = null;
     idleWatchdogHandle = null;
     continueHereHandle = null;
-    dispatchGapHandle = null;
     // ── Current unit ─────────────────────────────────────────────────────────
     currentUnit = null;
     currentUnitRouting = null;
@@ -66,12 +58,8 @@ export class AutoSession {
     pausedSessionFile = null;
     resourceVersionOnStart = null;
     lastStateRebuildAt = 0;
-    // ── Guards ───────────────────────────────────────────────────────────────
-    handlingAgentEnd = false;
-    pendingAgentEndRetry = false;
-    dispatching = false;
-    skipDepth = 0;
-    recentlyEvictedKeys = new Set();
+    // ── Sidecar queue ─────────────────────────────────────────────────────
+    sidecarQueue = [];
     // ── Metrics ──────────────────────────────────────────────────────────────
     autoStartTime = 0;
     lastPromptCharCount;
@@ -79,6 +67,26 @@ export class AutoSession {
     pendingQuickTasks = [];
     // ── Signal handler ───────────────────────────────────────────────────────
     sigtermHandler = null;
+    // ── Loop promise state ──────────────────────────────────────────────────
+    /**
+     * True only while runUnit is rotating into a fresh session. agent_end events
+     * emitted from the previous session's abort during this window must be
+     * ignored; they do not belong to the new unit.
+     */
+    sessionSwitchInFlight = false;
+    /**
+     * One-shot resolver for the current unit's agent_end promise.
+     * Non-null only while a unit is in-flight (between sendMessage and agent_end).
+     * Scoped to the session to prevent concurrent session corruption.
+     */
+    pendingResolve = null;
+    /**
+     * Queue for agent_end events that arrive when no pendingResolve exists.
+     * This happens when error-recovery sendMessage retries produce agent_end
+     * events between loop iterations. The next runUnit drains this queue
+     * instead of waiting for a new event.
+     */
+    pendingAgentEndQueue = [];
     // ── Methods ──────────────────────────────────────────────────────────────
     clearTimers() {
         if (this.unitTimeoutHandle) {
@@ -97,15 +105,10 @@ export class AutoSession {
             clearInterval(this.continueHereHandle);
             this.continueHereHandle = null;
         }
-        if (this.dispatchGapHandle) {
-            clearTimeout(this.dispatchGapHandle);
-            this.dispatchGapHandle = null;
-        }
     }
     resetDispatchCounters() {
         this.unitDispatchCount.clear();
         this.unitLifetimeDispatches.clear();
-        this.unitConsecutiveSkips.clear();
     }
     get lockBasePath() {
         return this.originalBasePath || this.basePath;
@@ -123,7 +126,6 @@ export class AutoSession {
         // Lifecycle
         this.active = false;
         this.paused = false;
-        this.pausedForSecrets = false;
         this.stepMode = false;
         this.verbose = false;
         this.cmdCtx = null;
@@ -135,9 +137,6 @@ export class AutoSession {
         this.unitDispatchCount.clear();
         this.unitLifetimeDispatches.clear();
         this.unitRecoveryCount.clear();
-        this.unitConsecutiveSkips.clear();
-        // Note: completedKeySet is intentionally NOT cleared — it persists
-        // across restarts to prevent re-dispatching completed units.
         // Unit
         this.currentUnit = null;
         this.currentUnitRouting = null;
@@ -155,19 +154,18 @@ export class AutoSession {
         this.pausedSessionFile = null;
         this.resourceVersionOnStart = null;
         this.lastStateRebuildAt = 0;
-        // Guards
-        this.handlingAgentEnd = false;
-        this.pendingAgentEndRetry = false;
-        this.dispatching = false;
-        this.skipDepth = 0;
-        this.recentlyEvictedKeys.clear();
         // Metrics
         this.autoStartTime = 0;
         this.lastPromptCharCount = undefined;
         this.lastBaselineCharCount = undefined;
         this.pendingQuickTasks = [];
+        this.sidecarQueue = [];
         // Signal handler
         this.sigtermHandler = null;
+        // Loop promise state
+        this.sessionSwitchInFlight = false;
+        this.pendingResolve = null;
+        this.pendingAgentEndQueue = [];
     }
     toJSON() {
         return {
@@ -178,10 +176,7 @@ export class AutoSession {
             currentMilestoneId: this.currentMilestoneId,
             currentUnit: this.currentUnit,
             completedUnits: this.completedUnits.length,
-            completedKeySet: this.completedKeySet.size,
             unitDispatchCount: Object.fromEntries(this.unitDispatchCount),
-            dispatching: this.dispatching,
-            skipDepth: this.skipDepth,
         };
     }
 }

package/dist/resources/extensions/gsd/auto-dashboard.js

@@ -7,42 +7,47 @@
  */
 import { getCurrentBranch } from "./worktree.js";
 import { getActiveHook } from "./post-unit-hooks.js";
-import { getLedger, getProjectTotals, formatCost, formatTierSavings } from "./metrics.js";
-import { getHealthTrend, getConsecutiveErrorUnits } from "./doctor-proactive.js";
+import { getLedger, getProjectTotals, formatTierSavings } from "./metrics.js";
 import { resolveMilestoneFile, resolveSliceFile, } from "./paths.js";
 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";
 // ─── Unit Description Helpers ─────────────────────────────────────────────────
-/** Canonical verb and phase label for each known unit type. */
-const UNIT_TYPE_INFO = {
-    "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) {
     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) {
     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, state) {
     // Show active hook info in progress display
     const activeHookState = getActiveHook();
@@ -237,12 +242,6 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
     }
     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;
@@ -288,11 +287,7 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                     lines.push(truncateToWidth(`${pad}${theme.fg("text", theme.bold(`${slice.id}: ${slice.title}`))}`, width));
                 }
                 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)}`;
@@ -309,10 +304,7 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                             + theme.fg("dim", "░".repeat(barWidth - filled));
                         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}`);
                         }
                         // ETA estimate
@@ -374,8 +366,6 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                     }
                     if (cumulativeCost)
                         sp.push(`$${cumulativeCost.toFixed(3)}`);
-                    else if (autoTotals?.apiRequests)
-                        sp.push(`${autoTotals.apiRequests} reqs`);
                     const cxDisplay = cxPct === "?"
                         ? `?/${formatWidgetTokens(cxWindow)}`
                         : `${cxPct}%/${formatWidgetTokens(cxWindow)}`;
@@ -429,76 +419,6 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
         };
     });
 }
-// ─── 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() {
-    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, phaseLabel, unitId, mid, slice, task, next, accessors, tierBadge, widgetPwd) {
-    const mode = accessors.isStepMode() ? "step" : "auto";
-    const elapsed = formatAutoElapsed(accessors.getAutoStartTime());
-    const tierStr = tierBadge ? ` [${tierBadge}]` : "";
-    const lines = [];
-    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 = [];
-        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. */
 function rightAlign(left, right, width) {

package/dist/resources/extensions/gsd/auto-direct-dispatch.js

@@ -147,10 +147,15 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
                 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;
         }
         case "replan":

package/dist/resources/extensions/gsd/auto-dispatch.js

@@ -8,36 +8,24 @@
  * data structure that is inspectable, testable per-rule, and extensible
  * without modifying orchestration code.
  */
-import { loadFile, loadActiveOverrides, parseRoadmap } from "./files.js";
+import { loadFile, loadActiveOverrides } from "./files.js";
 import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relSliceFile, buildMilestoneFileName, } from "./paths.js";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
+function missingSliceStop(mid, phase) {
+    return {
+        action: "stop",
+        reason: `${mid}: phase "${phase}" has no active slice — run /gsd doctor.`,
+        level: "error",
+    };
+}
 // ─── Rewrite Circuit Breaker ──────────────────────────────────────────────
 const MAX_REWRITE_ATTEMPTS = 3;
 let rewriteAttemptCount = 0;
 export function resetRewriteCircuitBreaker() {
     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) {
-    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) {
-    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) {
-    return typeof v === "object" && v !== null && "action" in v;
-}
 // ─── Rules ────────────────────────────────────────────────────────────────
 const DISPATCH_RULES = [
     {
@@ -67,10 +55,10 @@ const DISPATCH_RULES = [
         match: async ({ state, mid, midTitle, basePath }) => {
             if (state.phase !== "summarizing")
                 return null;
-            const sliceRef = requireSlice(state);
-            if (isStopAction(sliceRef))
-                return sliceRef;
-            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",
@@ -79,57 +67,28 @@ const DISPATCH_RULES = [
             };
         },
     },
-    {
-        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",
-                        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",
-                    };
-                }
-            }
-            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),
+                prompt: await buildRunUatPrompt(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)
+            if (prefs?.phases?.skip_reassess || !prefs?.phases?.reassess_after_slice)
                 return null;
             const needsReassess = await checkNeedsReassessment(basePath, mid, state);
             if (!needsReassess)
@@ -160,7 +119,7 @@ const DISPATCH_RULES = [
             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 {
@@ -210,10 +169,10 @@ const DISPATCH_RULES = [
             // 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;
-            const { sid, sTitle } = sliceRef;
+            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
@@ -235,10 +194,10 @@ const DISPATCH_RULES = [
         match: async ({ state, mid, midTitle, basePath }) => {
             if (state.phase !== "planning")
                 return null;
-            const sliceRef = requireSlice(state);
-            if (isStopAction(sliceRef))
-                return sliceRef;
-            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",
@@ -252,10 +211,10 @@ const DISPATCH_RULES = [
         match: async ({ state, mid, midTitle, basePath }) => {
             if (state.phase !== "replanning-slice")
                 return null;
-            const sliceRef = requireSlice(state);
-            if (isStopAction(sliceRef))
-                return sliceRef;
-            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",
@@ -269,10 +228,10 @@ const DISPATCH_RULES = [
         match: async ({ state, mid, midTitle, basePath }) => {
             if (state.phase !== "executing" || !state.activeTask)
                 return null;
-            const sliceRef = requireSlice(state);
-            if (isStopAction(sliceRef))
-                return sliceRef;
-            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
             // missing, the planner created S##-PLAN.md with task entries but never
@@ -296,10 +255,10 @@ const DISPATCH_RULES = [
         match: async ({ state, mid, basePath }) => {
             if (state.phase !== "executing" || !state.activeTask)
                 return null;
-            const sliceRef = requireSlice(state);
-            if (isStopAction(sliceRef))
-                return sliceRef;
-            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;
             return {
@@ -357,6 +316,18 @@ const DISPATCH_RULES = [
             };
         },
     },
+    {
+        name: "complete → stop",
+        match: async ({ state }) => {
+            if (state.phase !== "complete")
+                return null;
+            return {
+                action: "stop",
+                reason: "All milestones complete.",
+                level: "info",
+            };
+        },
+    },
 ];
 // ─── Resolver ─────────────────────────────────────────────────────────────
 /**
@@ -378,5 +349,5 @@ export async function resolveDispatch(ctx) {
 }
 /** Exposed for testing — returns the rule names in evaluation order. */
 export function getDispatchRuleNames() {
-    return DISPATCH_RULES.map(r => r.name);
+    return DISPATCH_RULES.map((r) => r.name);
 }