gsd-pi 2.26.0 → 2.27.0

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

@@ -0,0 +1,229 @@
+/**
+ * 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 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, uatContent, 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/src/resources/extensions/gsd/auto-dispatch.ts

@@ -242,27 +242,40 @@ const DISPATCH_RULES: DispatchRule[] = [
     },
   },
   {
-    name: "executing → execute-task",
-    match: async ({ state, mid, 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 sid = state.activeSlice!.id;
       const sTitle = state.activeSlice!.title;
       const tid = state.activeTask.id;
-      const tTitle = state.activeTask.title;
 
-      // Guard: refuse to dispatch execute-task when the task plan file is missing.
-      // This prevents the agent from running blind after a failed plan-slice that
-      // wrote S{sid}-PLAN.md but omitted the individual T{tid}-PLAN.md files.
-      // (See issue #739 — missing task plan caused runaway execution and EPIPE crash.)
+      // 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: "stop",
-          reason: `Task plan ${tid}-PLAN.md is missing for ${mid}/${sid}/${tid}. Re-run plan-slice to regenerate task plans, or create the file manually and resume.`,
-          level: "error",
+          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 sid = state.activeSlice!.id;
+      const sTitle = state.activeSlice!.title;
+      const tid = state.activeTask.id;
+      const tTitle = state.activeTask.title;
+
       return {
         action: "dispatch",
         unitType: "execute-task",

package/src/resources/extensions/gsd/auto-model-selection.ts

@@ -0,0 +1,179 @@
+/**
+ * Model selection and dynamic routing for auto-mode unit dispatch.
+ * Handles complexity-based routing, model resolution across providers,
+ * and fallback chains.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
+import type { GSDPreferences } from "./preferences.js";
+import { resolveModelWithFallbacksForUnit, resolveDynamicRoutingConfig } from "./preferences.js";
+import { classifyUnitComplexity, tierLabel } from "./complexity-classifier.js";
+import { resolveModelForComplexity } from "./model-router.js";
+import { getLedger, getProjectTotals } from "./metrics.js";
+import { unitPhaseLabel } from "./auto-dashboard.js";
+
+export interface ModelSelectionResult {
+  /** Routing metadata for metrics recording */
+  routing: { tier: string; modelDowngraded: boolean } | null;
+}
+
+/**
+ * Select and apply the appropriate model for a unit dispatch.
+ * Handles: per-unit-type model preferences, dynamic complexity routing,
+ * provider/model resolution, fallback chains, and start-model re-application.
+ *
+ * Returns routing metadata for metrics tracking.
+ */
+export async function selectAndApplyModel(
+  ctx: ExtensionContext,
+  pi: ExtensionAPI,
+  unitType: string,
+  unitId: string,
+  basePath: string,
+  prefs: GSDPreferences | undefined,
+  verbose: boolean,
+  autoModeStartModel: { provider: string; id: string } | null,
+): Promise<ModelSelectionResult> {
+  const modelConfig = resolveModelWithFallbacksForUnit(unitType);
+  let routing: { tier: string; modelDowngraded: boolean } | null = null;
+
+  if (modelConfig) {
+    const availableModels = ctx.modelRegistry.getAvailable();
+
+    // ─── Dynamic Model Routing ─────────────────────────────────────────
+    const routingConfig = resolveDynamicRoutingConfig();
+    let effectiveModelConfig = modelConfig;
+    let routingTierLabel = "";
+
+    if (routingConfig.enabled) {
+      let budgetPct: number | undefined;
+      if (routingConfig.budget_pressure !== false) {
+        const budgetCeiling = prefs?.budget_ceiling;
+        if (budgetCeiling !== undefined && budgetCeiling > 0) {
+          const currentLedger = getLedger();
+          const totalCost = currentLedger ? getProjectTotals(currentLedger.units).cost : 0;
+          budgetPct = totalCost / budgetCeiling;
+        }
+      }
+
+      const isHook = unitType.startsWith("hook/");
+      const shouldClassify = !isHook || routingConfig.hooks !== false;
+
+      if (shouldClassify) {
+        const classification = classifyUnitComplexity(unitType, unitId, basePath, budgetPct);
+        const availableModelIds = availableModels.map(m => m.id);
+        const routingResult = resolveModelForComplexity(classification, modelConfig, routingConfig, availableModelIds);
+
+        if (routingResult.wasDowngraded) {
+          effectiveModelConfig = {
+            primary: routingResult.modelId,
+            fallbacks: routingResult.fallbacks,
+          };
+          if (verbose) {
+            ctx.ui.notify(
+              `Dynamic routing [${tierLabel(classification.tier)}]: ${routingResult.modelId} (${classification.reason})`,
+              "info",
+            );
+          }
+        }
+        routingTierLabel = ` [${tierLabel(classification.tier)}]`;
+        routing = { tier: classification.tier, modelDowngraded: routingResult.wasDowngraded };
+      }
+    }
+
+    const modelsToTry = [effectiveModelConfig.primary, ...effectiveModelConfig.fallbacks];
+
+    for (const modelId of modelsToTry) {
+      const model = resolveModelId(modelId, availableModels, ctx.model?.provider);
+
+      if (!model) {
+        if (verbose) ctx.ui.notify(`Model ${modelId} not found, trying fallback.`, "info");
+        continue;
+      }
+
+      // Warn if the ID is ambiguous across providers
+      if (!modelId.includes("/")) {
+        const providers = availableModels.filter(m => m.id === modelId).map(m => m.provider);
+        if (providers.length > 1 && model.provider !== ctx.model?.provider) {
+          ctx.ui.notify(
+            `Model ID "${modelId}" exists in multiple providers (${providers.join(", ")}). ` +
+            `Resolved to ${model.provider}. Use "provider/model" format for explicit targeting.`,
+            "warning",
+          );
+        }
+      }
+
+      const ok = await pi.setModel(model, { persist: false });
+      if (ok) {
+        const fallbackNote = modelId === effectiveModelConfig.primary
+          ? ""
+          : ` (fallback from ${effectiveModelConfig.primary})`;
+        const phase = unitPhaseLabel(unitType);
+        ctx.ui.notify(`Model [${phase}]${routingTierLabel}: ${model.provider}/${model.id}${fallbackNote}`, "info");
+        break;
+      } else {
+        const nextModel = modelsToTry[modelsToTry.indexOf(modelId) + 1];
+        if (nextModel) {
+          if (verbose) ctx.ui.notify(`Failed to set model ${modelId}, trying ${nextModel}...`, "info");
+        } else {
+          ctx.ui.notify(`All preferred models unavailable for ${unitType}. Using default.`, "warning");
+        }
+      }
+    }
+  } else if (autoModeStartModel) {
+    // No model preference for this unit type — re-apply the model captured
+    // at auto-mode start to prevent bleed from shared global settings.json (#650).
+    const availableModels = ctx.modelRegistry.getAvailable();
+    const startModel = availableModels.find(
+      m => m.provider === autoModeStartModel.provider && m.id === autoModeStartModel.id,
+    );
+    if (startModel) {
+      const ok = await pi.setModel(startModel, { persist: false });
+      if (!ok) {
+        const byId = availableModels.find(m => m.id === autoModeStartModel.id);
+        if (byId) await pi.setModel(byId, { persist: false });
+      }
+    }
+  }
+
+  return { routing };
+}
+
+/**
+ * Resolve a model ID string to a model object from the available models list.
+ * Handles formats: "provider/model", "bare-id", "org/model-name" (OpenRouter).
+ */
+function resolveModelId<T extends { id: string; provider: string }>(
+  modelId: string,
+  availableModels: T[],
+  currentProvider: string | undefined,
+): T | undefined {
+  const slashIdx = modelId.indexOf("/");
+
+  if (slashIdx !== -1) {
+    const maybeProvider = modelId.substring(0, slashIdx);
+    const id = modelId.substring(slashIdx + 1);
+
+    const knownProviders = new Set(availableModels.map(m => m.provider.toLowerCase()));
+    if (knownProviders.has(maybeProvider.toLowerCase())) {
+      const match = availableModels.find(
+        m => m.provider.toLowerCase() === maybeProvider.toLowerCase()
+          && m.id.toLowerCase() === id.toLowerCase(),
+      );
+      if (match) return match;
+    }
+
+    // Try matching the full string as a model ID (OpenRouter-style)
+    const lower = modelId.toLowerCase();
+    return availableModels.find(
+      m => m.id.toLowerCase() === lower
+        || `${m.provider}/${m.id}`.toLowerCase() === lower,
+    );
+  }
+
+  // Bare ID — prefer current provider, then first available
+  const exactProviderMatch = availableModels.find(
+    m => m.id === modelId && m.provider === currentProvider,
+  );
+  return exactProviderMatch ?? availableModels.find(m => m.id === modelId);
+}

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

@@ -0,0 +1,74 @@
+/**
+ * Pre-dispatch observability checks for auto-mode units.
+ * Validates plan/summary file quality and builds repair instructions
+ * for the agent to fix gaps before proceeding with the unit.
+ */
+
+import type { ExtensionContext } from "@gsd/pi-coding-agent";
+import {
+  validatePlanBoundary,
+  validateExecuteBoundary,
+  validateCompleteBoundary,
+  formatValidationIssues,
+} from "./observability-validator.js";
+import type { ValidationIssue } from "./observability-validator.js";
+
+export async function collectObservabilityWarnings(
+  ctx: ExtensionContext,
+  basePath: string,
+  unitType: string,
+  unitId: string,
+): Promise<ValidationIssue[]> {
+  // Hook units have custom artifacts — skip standard observability checks
+  if (unitType.startsWith("hook/")) return [];
+
+  const parts = unitId.split("/");
+  const mid = parts[0];
+  const sid = parts[1];
+  const tid = parts[2];
+
+  if (!mid || !sid) return [];
+
+  let issues = [] as Awaited<ReturnType<typeof validatePlanBoundary>>;
+
+  if (unitType === "plan-slice") {
+    issues = await validatePlanBoundary(basePath, mid, sid);
+  } else if (unitType === "execute-task" && tid) {
+    issues = await validateExecuteBoundary(basePath, mid, sid, tid);
+  } else if (unitType === "complete-slice") {
+    issues = await validateCompleteBoundary(basePath, mid, sid);
+  }
+
+  if (issues.length > 0) {
+    ctx.ui.notify(
+      `Observability check (${unitType}) found ${issues.length} warning${issues.length === 1 ? "" : "s"}:\n${formatValidationIssues(issues)}`,
+      "warning",
+    );
+  }
+
+  return issues;
+}
+
+export function buildObservabilityRepairBlock(issues: ValidationIssue[]): string {
+  if (issues.length === 0) return "";
+  const items = issues.map(issue => {
+    const fileName = issue.file.split("/").pop() || issue.file;
+    let line = `- **${fileName}**: ${issue.message}`;
+    if (issue.suggestion) line += ` → ${issue.suggestion}`;
+    return line;
+  });
+  return [
+    "",
+    "---",
+    "",
+    "## Pre-flight: Observability gaps to fix FIRST",
+    "",
+    "The following issues were detected in plan/summary files for this unit.",
+    "**Read each flagged file, apply the fix described, then proceed with the unit.**",
+    "",
+    ...items,
+    "",
+    "---",
+    "",
+  ].join("\n");
+}

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

@@ -642,7 +642,6 @@ export async function buildPlanSlicePrompt(
   const commitInstruction = commitDocsEnabled
     ? `Commit: \`docs(${sid}): add slice plan\``
     : "Do not commit — planning docs are not tracked in git for this project.";
-
   return loadPrompt("plan-slice", {
     workingDirectory: base,
     milestoneId: mid, sliceId: sid, sliceTitle: sTitle,