gsd-pi 2.33.1 → 2.34.0-dev.0150ae9

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

@@ -1,224 +0,0 @@
-/**
- * Direct phase dispatch — handles manual /gsd dispatch commands.
- * Resolves phase name → unit type + prompt, creates a session, and sends the message.
- */
-
-import type {
-  ExtensionAPI,
-  ExtensionCommandContext,
-} from "@gsd/pi-coding-agent";
-
-import { deriveState } from "./state.js";
-import { loadFile, parseRoadmap } from "./files.js";
-import {
-  resolveMilestoneFile, resolveSliceFile, relSliceFile,
-} from "./paths.js";
-import {
-  buildResearchSlicePrompt,
-  buildResearchMilestonePrompt,
-  buildPlanSlicePrompt,
-  buildPlanMilestonePrompt,
-  buildExecuteTaskPrompt,
-  buildCompleteSlicePrompt,
-  buildCompleteMilestonePrompt,
-  buildReassessRoadmapPrompt,
-  buildRunUatPrompt,
-  buildReplanSlicePrompt,
-} from "./auto-prompts.js";
-import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { pauseAuto } from "./auto.js";
-
-export async function dispatchDirectPhase(
-  ctx: ExtensionCommandContext,
-  pi: ExtensionAPI,
-  phase: string,
-  base: string,
-): Promise<void> {
-  const state = await deriveState(base);
-  const mid = state.activeMilestone?.id;
-  const midTitle = state.activeMilestone?.title ?? "";
-
-  if (!mid) {
-    ctx.ui.notify("Cannot dispatch: no active milestone.", "warning");
-    return;
-  }
-
-  const normalized = phase.toLowerCase();
-  let unitType: string;
-  let unitId: string;
-  let prompt: string;
-
-  switch (normalized) {
-    case "research":
-    case "research-milestone":
-    case "research-slice": {
-      const isSlice = normalized === "research-slice" || (normalized === "research" && state.phase !== "pre-planning");
-      if (isSlice) {
-        const sid = state.activeSlice?.id;
-        const sTitle = state.activeSlice?.title ?? "";
-        if (!sid) {
-          ctx.ui.notify("Cannot dispatch research-slice: no active slice.", "warning");
-          return;
-        }
-
-        // When require_slice_discussion is enabled, pause auto-mode before
-        // each new slice so the user can discuss requirements first (#789).
-        const sliceContextFile = resolveSliceFile(base, mid, sid, "CONTEXT");
-        const requireDiscussion = loadEffectiveGSDPreferences()?.preferences?.phases?.require_slice_discussion;
-        if (requireDiscussion && !sliceContextFile) {
-          ctx.ui.notify(
-            `Slice ${sid} requires discussion before planning. Run /gsd discuss to discuss this slice, then /gsd auto to resume.`,
-            "info",
-          );
-          await pauseAuto(ctx, pi);
-          return;
-        }
-
-        unitType = "research-slice";
-        unitId = `${mid}/${sid}`;
-        prompt = await buildResearchSlicePrompt(mid, midTitle, sid, sTitle, base);
-      } else {
-        unitType = "research-milestone";
-        unitId = mid;
-        prompt = await buildResearchMilestonePrompt(mid, midTitle, base);
-      }
-      break;
-    }
-
-    case "plan":
-    case "plan-milestone":
-    case "plan-slice": {
-      const isSlice = normalized === "plan-slice" || (normalized === "plan" && state.phase !== "pre-planning");
-      if (isSlice) {
-        const sid = state.activeSlice?.id;
-        const sTitle = state.activeSlice?.title ?? "";
-        if (!sid) {
-          ctx.ui.notify("Cannot dispatch plan-slice: no active slice.", "warning");
-          return;
-        }
-        unitType = "plan-slice";
-        unitId = `${mid}/${sid}`;
-        prompt = await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, base);
-      } else {
-        unitType = "plan-milestone";
-        unitId = mid;
-        prompt = await buildPlanMilestonePrompt(mid, midTitle, base);
-      }
-      break;
-    }
-
-    case "execute":
-    case "execute-task": {
-      const sid = state.activeSlice?.id;
-      const sTitle = state.activeSlice?.title ?? "";
-      const tid = state.activeTask?.id;
-      const tTitle = state.activeTask?.title ?? "";
-      if (!sid) {
-        ctx.ui.notify("Cannot dispatch execute-task: no active slice.", "warning");
-        return;
-      }
-      if (!tid) {
-        ctx.ui.notify("Cannot dispatch execute-task: no active task.", "warning");
-        return;
-      }
-      unitType = "execute-task";
-      unitId = `${mid}/${sid}/${tid}`;
-      prompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base);
-      break;
-    }
-
-    case "complete":
-    case "complete-slice":
-    case "complete-milestone": {
-      const isSlice = normalized === "complete-slice" || (normalized === "complete" && state.phase === "summarizing");
-      if (isSlice) {
-        const sid = state.activeSlice?.id;
-        const sTitle = state.activeSlice?.title ?? "";
-        if (!sid) {
-          ctx.ui.notify("Cannot dispatch complete-slice: no active slice.", "warning");
-          return;
-        }
-        unitType = "complete-slice";
-        unitId = `${mid}/${sid}`;
-        prompt = await buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, base);
-      } else {
-        unitType = "complete-milestone";
-        unitId = mid;
-        prompt = await buildCompleteMilestonePrompt(mid, midTitle, base);
-      }
-      break;
-    }
-
-    case "reassess":
-    case "reassess-roadmap": {
-      const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-      const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-      if (!roadmapContent) {
-        ctx.ui.notify("Cannot dispatch reassess-roadmap: no roadmap found.", "warning");
-        return;
-      }
-      const roadmap = parseRoadmap(roadmapContent);
-      const completedSlices = roadmap.slices.filter(s => s.done);
-      if (completedSlices.length === 0) {
-        ctx.ui.notify("Cannot dispatch reassess-roadmap: no completed slices.", "warning");
-        return;
-      }
-      const completedSliceId = completedSlices[completedSlices.length - 1].id;
-      unitType = "reassess-roadmap";
-      unitId = `${mid}/${completedSliceId}`;
-      prompt = await buildReassessRoadmapPrompt(mid, midTitle, completedSliceId, base);
-      break;
-    }
-
-    case "uat":
-    case "run-uat": {
-      const sid = state.activeSlice?.id;
-      if (!sid) {
-        ctx.ui.notify("Cannot dispatch run-uat: no active slice.", "warning");
-        return;
-      }
-      const uatFile = resolveSliceFile(base, mid, sid, "UAT");
-      if (!uatFile) {
-        ctx.ui.notify("Cannot dispatch run-uat: no UAT file found.", "warning");
-        return;
-      }
-      const uatPath = relSliceFile(base, mid, sid, "UAT");
-      unitType = "run-uat";
-      unitId = `${mid}/${sid}`;
-      prompt = await buildRunUatPrompt(mid, sid, uatPath, base);
-      break;
-    }
-
-    case "replan":
-    case "replan-slice": {
-      const sid = state.activeSlice?.id;
-      const sTitle = state.activeSlice?.title ?? "";
-      if (!sid) {
-        ctx.ui.notify("Cannot dispatch replan-slice: no active slice.", "warning");
-        return;
-      }
-      unitType = "replan-slice";
-      unitId = `${mid}/${sid}`;
-      prompt = await buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base);
-      break;
-    }
-
-    default:
-      ctx.ui.notify(
-        `Unknown phase "${phase}". Valid phases: research, plan, execute, complete, reassess, uat, replan.`,
-        "warning",
-      );
-      return;
-  }
-
-  ctx.ui.notify(`Dispatching ${unitType} for ${unitId}...`, "info");
-  const result = await ctx.newSession();
-  if (result.cancelled) {
-    ctx.ui.notify("Session creation cancelled.", "warning");
-    return;
-  }
-  pi.sendMessage(
-    { customType: "gsd-dispatch", content: prompt, display: false },
-    { triggerTurn: true },
-  );
-}

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

@@ -1,409 +0,0 @@
-/**
- * Auto-mode Dispatch Table — declarative phase → unit mapping.
- *
- * Each rule maps a GSD state to the unit type, unit ID, and prompt builder
- * that should be dispatched. Rules are evaluated in order; the first match wins.
- *
- * This replaces the 130-line if-else chain in dispatchNextUnit with a
- * data structure that is inspectable, testable per-rule, and extensible
- * without modifying orchestration code.
- */
-
-import type { GSDState } from "./types.js";
-import type { GSDPreferences } from "./preferences.js";
-import { loadFile, loadActiveOverrides, parseRoadmap } 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";
-
-// ─── Types ────────────────────────────────────────────────────────────────
-
-export type DispatchAction =
-  | { action: "dispatch"; unitType: string; unitId: string; prompt: string }
-  | { action: "stop"; reason: string; level: "info" | "warning" | "error" }
-  | { action: "skip" };
-
-export interface DispatchContext {
-  basePath: string;
-  mid: string;
-  midTitle: string;
-  state: GSDState;
-  prefs: GSDPreferences | undefined;
-}
-
-interface DispatchRule {
-  /** Human-readable name for debugging and test identification */
-  name: string;
-  /** Return a DispatchAction if this rule matches, null to fall through */
-  match: (ctx: DispatchContext) => Promise<DispatchAction | null>;
-}
-
-// ─── Rewrite Circuit Breaker ──────────────────────────────────────────────
-
-const MAX_REWRITE_ATTEMPTS = 3;
-let rewriteAttemptCount = 0;
-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[] = [
-  {
-    name: "rewrite-docs (override gate)",
-    match: async ({ mid, midTitle, state, basePath }) => {
-      const pendingOverrides = await loadActiveOverrides(basePath);
-      if (pendingOverrides.length === 0) return null;
-      if (rewriteAttemptCount >= MAX_REWRITE_ATTEMPTS) {
-        const { resolveAllOverrides } = await import("./files.js");
-        await resolveAllOverrides(basePath);
-        rewriteAttemptCount = 0;
-        return null;
-      }
-      rewriteAttemptCount++;
-      const unitId = state.activeSlice ? `${mid}/${state.activeSlice.id}` : mid;
-      return {
-        action: "dispatch",
-        unitType: "rewrite-docs",
-        unitId,
-        prompt: await buildRewriteDocsPrompt(mid, midTitle, state.activeSlice, basePath, pendingOverrides),
-      };
-    },
-  },
-  {
-    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;
-      return {
-        action: "dispatch",
-        unitType: "complete-slice",
-        unitId: `${mid}/${sid}`,
-        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;
-      return {
-        action: "dispatch",
-        unitType: "run-uat",
-        unitId: `${mid}/${sliceId}`,
-        prompt: await buildRunUatPrompt(
-          mid, sliceId, relSliceFile(basePath, mid, sliceId, "UAT"), basePath,
-        ),
-      };
-    },
-  },
-  {
-    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;
-      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),
-      };
-    },
-  },
-  {
-    name: "needs-discussion → stop",
-    match: async ({ state, mid, midTitle }) => {
-      if (state.phase !== "needs-discussion") return null;
-      return {
-        action: "stop",
-        reason: `${mid}: ${midTitle} has draft context from a prior discussion — needs its own discussion before planning.\nRun /gsd to discuss.`,
-        level: "warning",
-      };
-    },
-  },
-  {
-    name: "pre-planning (no context) → stop",
-    match: async ({ state, mid, basePath }) => {
-      if (state.phase !== "pre-planning") return null;
-      const contextFile = resolveMilestoneFile(basePath, mid, "CONTEXT");
-      const hasContext = !!(contextFile && await loadFile(contextFile));
-      if (hasContext) return null; // fall through to next rule
-      return {
-        action: "stop",
-        reason: "No context or roadmap yet. Run /gsd to discuss first.",
-        level: "warning",
-      };
-    },
-  },
-  {
-    name: "pre-planning (no research) → research-milestone",
-    match: async ({ state, mid, midTitle, basePath, prefs }) => {
-      if (state.phase !== "pre-planning") return null;
-      // Phase skip: skip research when preference or profile says so
-      if (prefs?.phases?.skip_research) return null;
-      const researchFile = resolveMilestoneFile(basePath, mid, "RESEARCH");
-      if (researchFile) return null; // has research, fall through
-      return {
-        action: "dispatch",
-        unitType: "research-milestone",
-        unitId: mid,
-        prompt: await buildResearchMilestonePrompt(mid, midTitle, basePath),
-      };
-    },
-  },
-  {
-    name: "pre-planning (has research) → plan-milestone",
-    match: async ({ state, mid, midTitle, basePath }) => {
-      if (state.phase !== "pre-planning") return null;
-      return {
-        action: "dispatch",
-        unitType: "plan-milestone",
-        unitId: mid,
-        prompt: await buildPlanMilestonePrompt(mid, midTitle, basePath),
-      };
-    },
-  },
-  {
-    name: "planning (no research, not S01) → research-slice",
-    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;
-      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");
-      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),
-      };
-    },
-  },
-  {
-    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;
-      return {
-        action: "dispatch",
-        unitType: "plan-slice",
-        unitId: `${mid}/${sid}`,
-        prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath),
-      };
-    },
-  },
-  {
-    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;
-      return {
-        action: "dispatch",
-        unitType: "replan-slice",
-        unitId: `${mid}/${sid}`,
-        prompt: await buildReplanSlicePrompt(mid, midTitle, sid, sTitle, basePath),
-      };
-    },
-  },
-  {
-    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;
-      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
-      // wrote the tasks/ directory files. Dispatch plan-slice to regenerate
-      // them rather than hard-stopping — fixes the infinite-loop described in
-      // issue #909.
-      const taskPlanPath = resolveTaskFile(basePath, mid, sid, tid, "PLAN");
-      if (!taskPlanPath || !existsSync(taskPlanPath)) {
-        return {
-          action: "dispatch",
-          unitType: "plan-slice",
-          unitId: `${mid}/${sid}`,
-          prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath),
-        };
-      }
-
-      return null;
-    },
-  },
-  {
-    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;
-      const tid = state.activeTask.id;
-      const tTitle = state.activeTask.title;
-
-      return {
-        action: "dispatch",
-        unitType: "execute-task",
-        unitId: `${mid}/${sid}/${tid}`,
-        prompt: await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, basePath),
-      };
-    },
-  },
-  {
-    name: "validating-milestone → validate-milestone",
-    match: async ({ state, mid, midTitle, basePath, prefs }) => {
-      if (state.phase !== "validating-milestone") return null;
-      // Skip preference: write a minimal pass-through VALIDATION file
-      if (prefs?.phases?.skip_milestone_validation) {
-        const mDir = resolveMilestonePath(basePath, mid);
-        if (mDir) {
-          if (!existsSync(mDir)) mkdirSync(mDir, { recursive: true });
-          const validationPath = join(mDir, buildMilestoneFileName(mid, "VALIDATION"));
-          const content = [
-            "---",
-            "verdict: pass",
-            "remediation_round: 0",
-            "---",
-            "",
-            "# Milestone Validation (skipped by preference)",
-            "",
-            "Milestone validation was skipped via `skip_milestone_validation` preference.",
-          ].join("\n");
-          writeFileSync(validationPath, content, "utf-8");
-        }
-        return { action: "skip" };
-      }
-      return {
-        action: "dispatch",
-        unitType: "validate-milestone",
-        unitId: mid,
-        prompt: await buildValidateMilestonePrompt(mid, midTitle, basePath),
-      };
-    },
-  },
-  {
-    name: "completing-milestone → complete-milestone",
-    match: async ({ state, mid, midTitle, basePath }) => {
-      if (state.phase !== "completing-milestone") return null;
-      return {
-        action: "dispatch",
-        unitType: "complete-milestone",
-        unitId: mid,
-        prompt: await buildCompleteMilestonePrompt(mid, midTitle, basePath),
-      };
-    },
-  },
-];
-
-// ─── Resolver ─────────────────────────────────────────────────────────────
-
-/**
- * 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> {
-  for (const rule of DISPATCH_RULES) {
-    const result = await rule.match(ctx);
-    if (result) return result;
-  }
-
-  // No rule matched — unhandled phase
-  return {
-    action: "stop",
-    reason: `Unhandled phase "${ctx.state.phase}" — run /gsd doctor to diagnose.`,
-    level: "info",
-  };
-}
-
-/** Exposed for testing — returns the rule names in evaluation order. */
-export function getDispatchRuleNames(): string[] {
-  return DISPATCH_RULES.map(r => r.name);
-}