gsd-pi 2.28.0-dev.e19bf89 → 2.29.0-dev.23d50d0

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

@@ -11,6 +11,7 @@ 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,
@@ -204,6 +205,13 @@ export function estimateTimeRemaining(): string | null {
 
 // ─── Slice Progress Cache ─────────────────────────────────────────────────────
 
+/** Cached task detail for the widget task checklist */
+interface CachedTaskDetail {
+  id: string;
+  title: string;
+  done: boolean;
+}
+
 /** Cached slice progress for the widget — avoid async in render */
 let cachedSliceProgress: {
   done: number;
@@ -211,6 +219,8 @@ let cachedSliceProgress: {
   milestoneId: string;
   /** Real task progress for the active slice, if its plan file exists */
   activeSliceTasks: { done: number; total: number } | null;
+  /** Full task list for the active slice checklist */
+  taskDetails: CachedTaskDetail[] | null;
 } | null = null;
 
 export function updateSliceProgressCache(base: string, mid: string, activeSid?: string): void {
@@ -221,6 +231,7 @@ export function updateSliceProgressCache(base: string, mid: string, activeSid?:
     const roadmap = parseRoadmap(content);
 
     let activeSliceTasks: { done: number; total: number } | null = null;
+    let taskDetails: CachedTaskDetail[] | null = null;
     if (activeSid) {
       try {
         const planFile = resolveSliceFile(base, mid, activeSid, "PLAN");
@@ -231,6 +242,7 @@ export function updateSliceProgressCache(base: string, mid: string, activeSid?:
             done: plan.tasks.filter(t => t.done).length,
             total: plan.tasks.length,
           };
+          taskDetails = plan.tasks.map(t => ({ id: t.id, title: t.title, done: t.done }));
         }
       } catch {
         // Non-fatal — just omit task count
@@ -242,13 +254,19 @@ export function updateSliceProgressCache(base: string, mid: string, activeSid?:
       total: roadmap.slices.length,
       milestoneId: mid,
       activeSliceTasks,
+      taskDetails,
     };
   } catch {
     // Non-fatal — widget just won't show progress bar
   }
 }
 
-export function getRoadmapSlicesSync(): { done: number; total: number; activeSliceTasks: { done: number; total: number } | null } | null {
+export function getRoadmapSlicesSync(): {
+  done: number;
+  total: number;
+  activeSliceTasks: { done: number; total: number } | null;
+  taskDetails: CachedTaskDetail[] | null;
+} | null {
   return cachedSliceProgress;
 }
 
@@ -349,87 +367,84 @@ export function updateProgressWidget(
         const lines: string[] = [];
         const pad = INDENT.base;
 
-        // ── Line 1: Top bar ───────────────────────────────────────────────
+        // ── Top bar ─────────────────────────────────────────────────────
         lines.push(...ui.bar());
 
+        // ── Header: GSD AUTO ... elapsed ────────────────────────────────
         const dot = pulseBright
           ? theme.fg("accent", GLYPH.statusActive)
           : theme.fg("dim", GLYPH.statusPending);
         const elapsed = formatAutoElapsed(accessors.getAutoStartTime());
         const modeTag = accessors.isStepMode() ? "NEXT" : "AUTO";
-        const headerLeft = `${pad}${dot} ${theme.fg("accent", theme.bold("GSD"))}  ${theme.fg("success", modeTag)}`;
+        const headerLeft = `${pad}${dot} ${theme.fg("accent", theme.bold("GSD"))} ${theme.fg("success", modeTag)}`;
         const headerRight = elapsed ? theme.fg("dim", elapsed) : "";
         lines.push(rightAlign(headerLeft, headerRight, width));
 
-        lines.push("");
-
-        if (mid) {
-          lines.push(truncateToWidth(`${pad}${theme.fg("dim", mid.title)}`, width));
-        }
-
+        // ── Context: project · slice · action (merged into one line) ────
+        const contextParts: string[] = [];
+        if (mid) contextParts.push(theme.fg("dim", mid.title));
         if (slice && unitType !== "research-milestone" && unitType !== "plan-milestone") {
-          lines.push(truncateToWidth(
-            `${pad}${theme.fg("text", theme.bold(`${slice.id}: ${slice.title}`))}`,
-            width,
-          ));
+          contextParts.push(theme.fg("text", theme.bold(`${slice.id}: ${slice.title}`)));
         }
-
-        lines.push("");
-
         const isHook = unitType.startsWith("hook/");
         const target = isHook
           ? (unitId.split("/").pop() ?? unitId)
           : (task ? `${task.id}: ${task.title}` : unitId);
-        const actionLeft = `${pad}${theme.fg("accent", "▸")} ${theme.fg("accent", verb)}  ${theme.fg("text", target)}`;
+        contextParts.push(`${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)}`;
-        lines.push(rightAlign(actionLeft, phaseBadge, width));
-        lines.push("");
-
-        if (mid) {
-          const roadmapSlices = getRoadmapSlicesSync();
-          if (roadmapSlices) {
-            const { done, total, activeSliceTasks } = roadmapSlices;
-            const barWidth = Math.max(8, Math.min(24, Math.floor(width * 0.3)));
-            const pct = total > 0 ? done / total : 0;
-            const filled = Math.round(pct * barWidth);
-            const bar = theme.fg("success", "█".repeat(filled))
-              + 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);
-              meta += theme.fg("dim", `  ·  task ${taskNum}/${activeSliceTasks.total}`);
-            }
-
-            // ETA estimate
-            const eta = estimateTimeRemaining();
-            if (eta) {
-              meta += theme.fg("dim", `  ·  ${eta}`);
-            }
+        const contextLine = contextParts.join(theme.fg("dim", " · "));
+        lines.push(rightAlign(`${pad}${contextLine}`, phaseBadge, width));
+
+        // ── Two-column body ─────────────────────────────────────────────
+        // Left: progress, ETA, next, stats (fixed)  |  Right: task checklist (fixed, adjacent)
+        // Both columns sit left-to-center; empty space is on the right.
+        const divider = theme.fg("dim", "│");
+        const minTwoColWidth = 100;
+        const rightColFixed = 44;
+        const colGap = 5; // breathing room between columns
+        // Left column takes remaining space — no truncation on wide terminals
+        const useTwoCol = width >= minTwoColWidth;
+        const rightColWidth = useTwoCol ? rightColFixed : 0;
+        const leftColWidth = useTwoCol ? width - rightColWidth - colGap : width;
+
+        const roadmapSlices = mid ? getRoadmapSlicesSync() : null;
+
+        // Build left column: progress bar, ETA, next step, token stats
+        const leftLines: string[] = [];
+
+        if (roadmapSlices) {
+          const { done, total, activeSliceTasks } = roadmapSlices;
+          const barWidth = Math.max(6, Math.min(18, Math.floor(leftColWidth * 0.4)));
+          const pct = total > 0 ? done / total : 0;
+          const filled = Math.round(pct * barWidth);
+          const bar = theme.fg("success", "█".repeat(filled))
+            + theme.fg("dim", "░".repeat(barWidth - filled));
+
+          let meta = theme.fg("dim", `${done}/${total} slices`);
+          if (activeSliceTasks && activeSliceTasks.total > 0) {
+            const taskNum = isHook
+              ? Math.max(activeSliceTasks.done, 1)
+              : Math.min(activeSliceTasks.done + 1, activeSliceTasks.total);
+            meta += theme.fg("dim", ` · task ${taskNum}/${activeSliceTasks.total}`);
+          }
+          leftLines.push(truncateToWidth(`${pad}${bar} ${meta}`, leftColWidth));
 
-            lines.push(truncateToWidth(`${pad}${bar}  ${meta}`, width));
+          const eta = estimateTimeRemaining();
+          if (eta) {
+            leftLines.push(truncateToWidth(`${pad}${theme.fg("dim", eta)}`, leftColWidth));
           }
         }
 
-        lines.push("");
-
         if (next) {
-          lines.push(truncateToWidth(
+          leftLines.push(truncateToWidth(
             `${pad}${theme.fg("dim", "→")} ${theme.fg("dim", `then ${next}`)}`,
-            width,
+            leftColWidth,
           ));
         }
 
-        // ── Footer info (pwd, tokens, cost, context, model) ──────────────
-        lines.push("");
-        lines.push(truncateToWidth(theme.fg("dim", `${pad}${widgetPwd}`), width, theme.fg("dim", "…")));
-
-        // Token stats from current unit session + cumulative cost from metrics
+        // Token stats
         {
           const cmdCtx = accessors.getCmdCtx();
           let totalInput = 0, totalOutput = 0;
@@ -464,7 +479,6 @@ export function updateProgressWidget(
           if (totalOutput) sp.push(`↓${formatWidgetTokens(totalOutput)}`);
           if (totalCacheRead) sp.push(`R${formatWidgetTokens(totalCacheRead)}`);
           if (totalCacheWrite) sp.push(`W${formatWidgetTokens(totalCacheWrite)}`);
-          // Cache hit rate for current unit
           if (totalCacheRead + totalInput > 0) {
             const hitRate = Math.round((totalCacheRead / (totalCacheRead + totalInput)) * 100);
             sp.push(`\u26A1${hitRate}%`);
@@ -483,33 +497,134 @@ export function updateProgressWidget(
             sp.push(cxDisplay);
           }
 
-          const sLeft = sp.map(p => p.includes("\x1b[") ? p : theme.fg("dim", p))
+          const tokenLine = sp.map(p => p.includes("\x1b[") ? p : theme.fg("dim", p))
             .join(theme.fg("dim", " "));
+          leftLines.push(truncateToWidth(`${pad}${tokenLine}`, leftColWidth));
 
           const modelId = cmdCtx?.model?.id ?? "";
           const modelProvider = cmdCtx?.model?.provider ?? "";
-          const modelPhase = phaseLabel ? theme.fg("dim", `[${phaseLabel}] `) : "";
           const modelDisplay = modelProvider && modelId
             ? `${modelProvider}/${modelId}`
             : modelId;
-          const sRight = modelDisplay
-            ? `${modelPhase}${theme.fg("dim", modelDisplay)}`
-            : "";
-          lines.push(rightAlign(`${pad}${sLeft}`, sRight, width));
+          if (modelDisplay) {
+            leftLines.push(truncateToWidth(`${pad}${theme.fg("dim", modelDisplay)}`, leftColWidth));
+          }
 
-          // Dynamic routing savings summary
+          // Dynamic routing savings
           if (mLedger && mLedger.units.some(u => u.tier)) {
             const savings = formatTierSavings(mLedger.units);
             if (savings) {
-              lines.push(truncateToWidth(theme.fg("dim", `${pad}${savings}`), width));
+              leftLines.push(truncateToWidth(`${pad}${theme.fg("dim", savings)}`, leftColWidth));
+            }
+          }
+        }
+
+        // Build right column: task checklist (pegged to right edge)
+        const rightLines: string[] = [];
+        const taskDetails = roadmapSlices?.taskDetails ?? null;
+        const maxVisibleTasks = 8;
+        const rpad = " ";
+
+        if (useTwoCol) {
+          if (taskDetails && taskDetails.length > 0) {
+            const visibleTasks = taskDetails.slice(0, maxVisibleTasks);
+            for (const t of visibleTasks) {
+              const isCurrent = task && t.id === task.id;
+              const glyph = t.done
+                ? theme.fg("success", GLYPH.statusDone)
+                : isCurrent
+                  ? theme.fg("accent", "▸")
+                  : theme.fg("dim", " ");
+              const label = isCurrent
+                ? theme.fg("text", `${t.id}: ${t.title}`)
+                : t.done
+                  ? theme.fg("dim", `${t.id}: ${t.title}`)
+                  : theme.fg("text", `${t.id}: ${t.title}`);
+              rightLines.push(truncateToWidth(`${rpad}${glyph} ${label}`, rightColWidth));
+            }
+            if (taskDetails.length > maxVisibleTasks) {
+              rightLines.push(truncateToWidth(
+                `${rpad}${theme.fg("dim", `  …+${taskDetails.length - maxVisibleTasks} more`)}`,
+                rightColWidth,
+              ));
+            }
+          } else if (roadmapSlices?.activeSliceTasks) {
+            const { done: tDone, total: tTotal } = roadmapSlices.activeSliceTasks;
+            rightLines.push(`${rpad}${theme.fg("dim", `${tDone}/${tTotal} tasks`)}`);
+          }
+        } else {
+          // Narrow single-column: task list goes into left column
+          if (taskDetails && taskDetails.length > 0) {
+            for (const t of taskDetails.slice(0, maxVisibleTasks)) {
+              const isCurrent = task && t.id === task.id;
+              const glyph = t.done
+                ? theme.fg("success", GLYPH.statusDone)
+                : isCurrent
+                  ? theme.fg("accent", "▸")
+                  : theme.fg("dim", " ");
+              const label = isCurrent
+                ? theme.fg("text", `${t.id}: ${t.title}`)
+                : t.done
+                  ? theme.fg("dim", `${t.id}: ${t.title}`)
+                  : theme.fg("text", `${t.id}: ${t.title}`);
+              leftLines.push(truncateToWidth(`${pad}${glyph} ${label}`, leftColWidth));
+            }
+          }
+          // Add progress bar inline
+          if (roadmapSlices) {
+            const { done, total, activeSliceTasks } = roadmapSlices;
+            const barWidth = Math.max(6, Math.min(18, Math.floor(leftColWidth * 0.4)));
+            const pct = total > 0 ? done / total : 0;
+            const filled = Math.round(pct * barWidth);
+            const bar = theme.fg("success", "█".repeat(filled))
+              + theme.fg("dim", "░".repeat(barWidth - filled));
+            let meta = theme.fg("dim", `${done}/${total} slices`);
+            if (activeSliceTasks && activeSliceTasks.total > 0) {
+              const taskNum = isHook
+                ? Math.max(activeSliceTasks.done, 1)
+                : Math.min(activeSliceTasks.done + 1, activeSliceTasks.total);
+              meta += theme.fg("dim", ` · task ${taskNum}/${activeSliceTasks.total}`);
+            }
+            const eta = estimateTimeRemaining();
+            if (eta) meta += theme.fg("dim", ` · ${eta}`);
+            leftLines.push(truncateToWidth(`${pad}${bar} ${meta}`, leftColWidth));
+          }
+          if (next) {
+            leftLines.push(truncateToWidth(
+              `${pad}${theme.fg("dim", "→")} ${theme.fg("dim", `then ${next}`)}`,
+              leftColWidth,
+            ));
+          }
+        }
+
+        // Compose columns
+        if (useTwoCol) {
+          const maxRows = Math.max(leftLines.length, rightLines.length);
+          if (maxRows > 0) {
+            lines.push(""); // spacer before columns
+            for (let i = 0; i < maxRows; i++) {
+              const left = padToWidth(leftLines[i] ?? "", leftColWidth);
+              const gap = " ".repeat(colGap - 2); // colGap minus divider and its trailing space
+              const right = rightLines[i] ?? "";
+              lines.push(truncateToWidth(`${left}${gap}${divider} ${right}`, width));
             }
           }
+        } else {
+          // Narrow single-column: just stack
+          if (leftLines.length > 0) {
+            lines.push("");
+            for (const l of leftLines) lines.push(l);
+          }
         }
 
+        // ── Footer: pwd + hints ─────────────────────────────────────────
+        lines.push("");
         const hintParts: string[] = [];
         hintParts.push("esc pause");
         hintParts.push(process.platform === "darwin" ? "⌃⌥G dashboard" : "Ctrl+Alt+G dashboard");
-        lines.push(...ui.hints(hintParts));
+        const hintStr = theme.fg("dim", hintParts.join(" | "));
+        const pwdStr = theme.fg("dim", widgetPwd);
+        lines.push(rightAlign(`${pad}${pwdStr}`, hintStr, width));
 
         lines.push(...ui.bar());
 
@@ -535,6 +650,31 @@ export function updateProgressWidget(
  * 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,
@@ -583,6 +723,11 @@ function buildProgressTextLines(
   }
 
   if (next) lines.push(`  Next: ${next}`);
+
+  // Model health indicator
+  const health = getModelHealthIndicator();
+  lines.push(`  Health: ${health.emoji} ${health.label}`);
+
   lines.push(`  ${widgetPwd}`);
 
   return lines;
@@ -597,3 +742,10 @@ function rightAlign(left: string, right: string, width: number): string {
   const gap = Math.max(1, width - leftVis - rightVis);
   return truncateToWidth(left + " ".repeat(gap) + right, width);
 }
+
+/** Pad a string with trailing spaces to fill exactly `colWidth` (ANSI-aware). */
+function padToWidth(s: string, colWidth: number): string {
+  const vis = visibleWidth(s);
+  if (vis >= colWidth) return truncateToWidth(s, colWidth);
+  return s + " ".repeat(colWidth - vis);
+}

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

@@ -126,8 +126,8 @@ const DISPATCH_RULES: DispatchRule[] = [
   {
     name: "reassess-roadmap (post-completion)",
     match: async ({ state, mid, midTitle, basePath, prefs }) => {
-      // Phase skip: skip reassess when preference or profile says so
-      if (prefs?.phases?.skip_reassess) return null;
+      // Reassess is opt-in: only fire when explicitly enabled
+      if (!prefs?.phases?.reassess_after_slice) return null;
       const needsReassess = await checkNeedsReassessment(basePath, mid, state);
       if (!needsReassess) return null;
       return {

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

@@ -35,6 +35,7 @@ import {
 import { writeUnitRuntimeRecord, clearUnitRuntimeRecord } from "./unit-runtime.js";
 import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences } from "./preferences.js";
 import { runGSDDoctor, rebuildState, summarizeDoctorIssues } from "./doctor.js";
+import { COMPLETION_TRANSITION_CODES } from "./doctor-types.js";
 import { recordHealthSnapshot, checkHealEscalation } from "./doctor-proactive.js";
 import { syncStateToProjectRoot } from "./auto-worktree-sync.js";
 import { resetRewriteCircuitBreaker } from "./auto-dispatch.js";
@@ -154,13 +155,17 @@ export async function postUnitPreVerification(pctx: PostUnitContext): Promise<"d
         ctx.ui.notify(`Post-hook: applied ${report.fixesApplied.length} fix(es).`, "info");
       }
 
-      // Proactive health tracking
-      const summary = summarizeDoctorIssues(report.issues);
+      // Proactive health tracking — exclude completion-transition codes at task level
+      // since they are expected after the last task and resolved by complete-slice
+      const issuesForHealth = effectiveFixLevel === "task"
+        ? report.issues.filter(i => !COMPLETION_TRANSITION_CODES.has(i.code))
+        : report.issues;
+      const summary = summarizeDoctorIssues(issuesForHealth);
       recordHealthSnapshot(summary.errors, summary.warnings, report.fixesApplied.length);
 
       // Check if we should escalate to LLM-assisted heal
       if (summary.errors > 0) {
-        const unresolvedErrors = report.issues
+        const unresolvedErrors = issuesForHealth
           .filter(i => i.severity === "error" && !i.fixable)
           .map(i => ({ code: i.code, message: i.message, unitId: i.unitId }));
         const escalation = checkHealEscalation(summary.errors, unresolvedErrors);
@@ -171,7 +176,7 @@ export async function postUnitPreVerification(pctx: PostUnitContext): Promise<"d
           );
           try {
             const { formatDoctorIssuesForPrompt, formatDoctorReport } = await import("./doctor.js");
-            const { dispatchDoctorHeal } = await import("./commands.js");
+            const { dispatchDoctorHeal } = await import("./commands-handlers.js");
             const actionable = report.issues.filter(i => i.severity === "error");
             const reportText = formatDoctorReport(report, { scope: doctorScope, includeWarnings: true });
             const structuredIssues = formatDoctorIssuesForPrompt(actionable);
@@ -197,10 +202,13 @@ export async function postUnitPreVerification(pctx: PostUnitContext): Promise<"d
       }
     }
 
-    // Prune dead bg-shell processes
+    // Prune dead bg-shell processes and kill non-persistent live ones.
+    // Without killing live processes between units, dev servers spawned during
+    // one task keep ports bound, causing conflicts in subsequent tasks (#1209).
     try {
-      const { pruneDeadProcesses } = await import("../bg-shell/process-manager.js");
+      const { pruneDeadProcesses, killSessionProcesses } = await import("../bg-shell/process-manager.js");
       pruneDeadProcesses();
+      killSessionProcesses();
     } catch {
       // Non-fatal
     }
@@ -323,6 +331,45 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
     }
   }
 
+  // ── Mechanical completion (ADR-003) ──
+  // After task execution, attempt mechanical slice and milestone completion
+  // instead of dispatching LLM sessions for complete-slice / validate-milestone.
+  if (s.currentUnit?.type === "execute-task" && !s.stepMode) {
+    try {
+      const [mid, sid] = s.currentUnit.id.split("/");
+      if (mid && sid) {
+        const state = await deriveState(s.basePath);
+        if (state.phase === "summarizing" && state.activeSlice?.id === sid) {
+          const { mechanicalSliceCompletion } = await import("./mechanical-completion.js");
+          const ok = await mechanicalSliceCompletion(s.basePath, mid, sid);
+          if (ok) {
+            invalidateAllCaches();
+            autoCommitCurrentBranch(s.basePath, "mechanical-completion", `${mid}/${sid}`);
+            ctx.ui.notify(`Mechanical completion: ${sid} summary + roadmap updated.`, "info");
+
+            // Re-derive state — check if milestone is now ready for validation
+            invalidateAllCaches();
+            const postSliceState = await deriveState(s.basePath);
+            if (postSliceState.phase === "validating-milestone" || postSliceState.phase === "completing-milestone") {
+              const { aggregateMilestoneVerification, generateMilestoneSummary } = await import("./mechanical-completion.js");
+              const validation = await aggregateMilestoneVerification(s.basePath, mid);
+              if (validation.verdict !== "failed") {
+                await generateMilestoneSummary(s.basePath, mid);
+                invalidateAllCaches();
+                autoCommitCurrentBranch(s.basePath, "mechanical-milestone-completion", mid);
+                ctx.ui.notify(`Mechanical completion: ${mid} validation + summary written.`, "info");
+              }
+            }
+          }
+          // If !ok, summarizing phase persists → dispatch rule fires as LLM fallback
+        }
+      }
+    } catch (err) {
+      process.stderr.write(`gsd-mechanical: completion failed: ${(err as Error).message}\n`);
+      // Non-fatal — fall through to normal dispatch
+    }
+  }
+
   // ── Post-unit hooks ──
   if (s.currentUnit && !s.stepMode) {
     const hookUnit = checkPostUnitHooks(s.currentUnit.type, s.currentUnit.id, s.basePath);

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

@@ -589,14 +589,18 @@ export async function buildPlanMilestonePrompt(mid: string, midTitle: string, ba
   const { inlinePriorMilestoneSummary } = await import("./files.js");
   const priorSummaryInline = await inlinePriorMilestoneSummary(mid, base);
   if (priorSummaryInline) inlined.push(priorSummaryInline);
-  if (inlineLevel !== "minimal") {
-    const projectInline = await inlineProjectFromDb(base);
-    if (projectInline) inlined.push(projectInline);
-    const requirementsInline = await inlineRequirementsFromDb(base, undefined, inlineLevel);
-    if (requirementsInline) inlined.push(requirementsInline);
-    const decisionsInline = await inlineDecisionsFromDb(base, mid, undefined, inlineLevel);
-    if (decisionsInline) inlined.push(decisionsInline);
-  }
+  // Build source file paths for the planner to read on demand (reduces inlining)
+  const sourcePaths: string[] = [];
+  if (existsSync(resolveGsdRootFile(base, "PROJECT")))
+    sourcePaths.push(`- **Project**: \`${relGsdRootFile("PROJECT")}\``);
+  if (existsSync(resolveGsdRootFile(base, "REQUIREMENTS")))
+    sourcePaths.push(`- **Requirements**: \`${relGsdRootFile("REQUIREMENTS")}\``);
+  if (existsSync(resolveGsdRootFile(base, "DECISIONS")))
+    sourcePaths.push(`- **Decisions**: \`${relGsdRootFile("DECISIONS")}\``);
+  const sourceFilePaths = sourcePaths.length > 0
+    ? sourcePaths.join("\n")
+    : "_No project/requirements/decisions files found._";
+
   const knowledgeInlinePM = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
   if (knowledgeInlinePM) inlined.push(knowledgeInlinePM);
   inlined.push(inlineTemplate("roadmap", "Roadmap"));
@@ -615,6 +619,7 @@ export async function buildPlanMilestonePrompt(mid: string, midTitle: string, ba
 
   const outputRelPath = relMilestoneFile(base, mid, "ROADMAP");
   const secretsOutputPath = join(base, relMilestoneFile(base, mid, "SECRETS"));
+  const researchOutputRelPath = relMilestoneFile(base, mid, "RESEARCH");
   return loadPrompt("plan-milestone", {
     workingDirectory: base,
     milestoneId: mid, milestoneTitle: midTitle,
@@ -624,6 +629,9 @@ export async function buildPlanMilestonePrompt(mid: string, midTitle: string, ba
     outputPath: join(base, outputRelPath),
     secretsOutputPath,
     inlinedContext,
+    sourceFilePaths,
+    researchOutputPath: join(base, researchOutputRelPath),
+    ...buildSkillDiscoveryVars(),
   });
 }
 
@@ -686,12 +694,16 @@ export async function buildPlanSlicePrompt(
   inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
   const researchInline = await inlineFileOptional(researchPath, researchRel, "Slice Research");
   if (researchInline) inlined.push(researchInline);
-  if (inlineLevel !== "minimal") {
-    const decisionsInline = await inlineDecisionsFromDb(base, mid, undefined, inlineLevel);
-    if (decisionsInline) inlined.push(decisionsInline);
-    const requirementsInline = await inlineRequirementsFromDb(base, sid, inlineLevel);
-    if (requirementsInline) inlined.push(requirementsInline);
-  }
+  // Build source file paths for the planner to read on demand (reduces inlining)
+  const sliceSourcePaths: string[] = [];
+  if (existsSync(resolveGsdRootFile(base, "REQUIREMENTS")))
+    sliceSourcePaths.push(`- **Requirements**: \`${relGsdRootFile("REQUIREMENTS")}\``);
+  if (existsSync(resolveGsdRootFile(base, "DECISIONS")))
+    sliceSourcePaths.push(`- **Decisions**: \`${relGsdRootFile("DECISIONS")}\``);
+  const sliceSourceFilePaths = sliceSourcePaths.length > 0
+    ? sliceSourcePaths.join("\n")
+    : "_No requirements/decisions files found._";
+
   const knowledgeInlinePS = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
   if (knowledgeInlinePS) inlined.push(knowledgeInlinePS);
   inlined.push(inlineTemplate("plan", "Slice Plan"));
@@ -726,6 +738,7 @@ export async function buildPlanSlicePrompt(
     dependencySummaries: depContent,
     executorContextConstraints,
     commitInstruction,
+    sourceFilePaths: sliceSourceFilePaths,
   });
 }