gsd-pi 2.75.0-next.9c0ec0ba1 → 2.76.0-dev.b072ebb73

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

@@ -9,6 +9,7 @@ import { getCurrentBranch } from "./worktree.js";
 import { getActiveHook } from "./post-unit-hooks.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { getErrorMessage } from "./error-utils.js";
+import { nativeIsRepo } from "./native-git-bridge.js";
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { execFileSync } from "node:child_process";
@@ -45,6 +46,7 @@ export function unitVerb(unitType) {
         case "research-slice": return "researching";
         case "plan-milestone":
         case "plan-slice": return "planning";
+        case "refine-slice": return "refining";
         case "execute-task": return "executing";
         case "complete-slice": return "completing";
         case "replan-slice": return "replanning";
@@ -65,6 +67,7 @@ export function unitPhaseLabel(unitType) {
         case "research-slice": return "RESEARCH";
         case "plan-milestone": return "PLAN";
         case "plan-slice": return "PLAN";
+        case "refine-slice": return "REFINE";
         case "execute-task": return "EXECUTE";
         case "complete-slice": return "COMPLETE";
         case "replan-slice": return "REPLAN";
@@ -91,6 +94,7 @@ function peekNext(unitType, state) {
         case "plan-milestone": return "plan or execute first slice";
         case "research-slice": return `plan ${sid}`;
         case "plan-slice": return "execute first task";
+        case "refine-slice": return "execute first task";
         case "execute-task": return `continue ${sid}`;
         case "complete-slice": return "reassess roadmap";
         case "replan-slice": return `re-execute ${sid}`;
@@ -253,6 +257,10 @@ let cachedLastCommit = null;
 let lastCommitFetchedAt = 0;
 function refreshLastCommit(basePath) {
     try {
+        if (!nativeIsRepo(basePath)) {
+            cachedLastCommit = null;
+            return;
+        }
         const raw = execFileSync("git", ["log", "-1", "--format=%cr|%s"], {
             cwd: basePath,
             encoding: "utf-8",
@@ -266,12 +274,15 @@ function refreshLastCommit(basePath) {
                 message: raw.slice(sep + 1),
             };
         }
-        lastCommitFetchedAt = Date.now();
     }
     catch (err) {
         // Non-fatal — just skip last commit display
+        cachedLastCommit = null;
         logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
     }
+    finally {
+        lastCommitFetchedAt = Date.now();
+    }
 }
 function getLastCommit(basePath) {
     // Refresh at most every 15 seconds
@@ -280,6 +291,19 @@ function getLastCommit(basePath) {
     }
     return cachedLastCommit;
 }
+export function _resetLastCommitCacheForTests() {
+    cachedLastCommit = null;
+    lastCommitFetchedAt = 0;
+}
+export function _refreshLastCommitForTests(basePath) {
+    refreshLastCommit(basePath);
+}
+export function _getLastCommitForTests(basePath) {
+    return getLastCommit(basePath);
+}
+export function _getLastCommitFetchedAtForTests() {
+    return lastCommitFetchedAt;
+}
 // ─── Footer Factory ───────────────────────────────────────────────────────────
 /**
  * Footer factory used by auto-mode.
@@ -753,13 +777,18 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                     }
                     if (cumulativeCost)
                         sp.push(theme.fg("warning", `$${cumulativeCost.toFixed(2)}`));
-                    const cxDisplay = `${cxPct}%/${formatWidgetTokens(cxWindow)}`;
-                    if (cxPctVal > 90)
-                        sp.push(theme.fg("error", cxDisplay));
-                    else if (cxPctVal > 70)
-                        sp.push(theme.fg("warning", cxDisplay));
-                    else
-                        sp.push(cxDisplay);
+                    const CX_BAR_WIDTH = 8;
+                    const cxBarFilled = Math.min(CX_BAR_WIDTH, Math.max(0, Math.round((cxPctVal / 100) * CX_BAR_WIDTH)));
+                    const cxBarColor = cxPctVal > 90 ? "error" : cxPctVal > 70 ? "warning" : "success";
+                    const cxBar = theme.fg(cxBarColor, "━".repeat(cxBarFilled)) +
+                        theme.fg("dim", "─".repeat(CX_BAR_WIDTH - cxBarFilled));
+                    const cxPctText = `${cxPct}%/${formatWidgetTokens(cxWindow)}`;
+                    const cxColorized = cxPctVal > 90
+                        ? theme.fg("error", cxPctText)
+                        : cxPctVal > 70
+                            ? theme.fg("warning", cxPctText)
+                            : cxPctText;
+                    sp.push(`${cxBar} ${cxColorized}`);
                     const statsLine = sp.map(p => p.includes("\x1b[") ? p : theme.fg("dim", p))
                         .join(theme.fg("dim", "  "));
                     if (statsLine) {

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

@@ -68,7 +68,10 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
                 }
                 unitType = "plan-slice";
                 unitId = `${mid}/${sid}`;
-                prompt = await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, base);
+                prompt = await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, base, undefined, {
+                    sessionContextWindow: ctx.model?.contextWindow,
+                    modelRegistry: ctx.modelRegistry,
+                });
             }
             else {
                 unitType = "plan-milestone";
@@ -93,7 +96,10 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             }
             unitType = "execute-task";
             unitId = `${mid}/${sid}/${tid}`;
-            prompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base);
+            prompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, {
+                sessionContextWindow: ctx.model?.contextWindow,
+                modelRegistry: ctx.modelRegistry,
+            });
             break;
         }
         case "complete":

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

@@ -18,7 +18,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { logWarning, logError } from "./workflow-logger.js";
 import { join } from "node:path";
 import { hasImplementationArtifacts } from "./auto-recovery.js";
-import { buildDiscussMilestonePrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, buildParallelResearchSlicesPrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
+import { buildDiscussMilestonePrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildRefineSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, buildParallelResearchSlicesPrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
 import { resolveModelWithFallbacksForUnit } from "./preferences-models.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { selectReactiveDispatchBatch } from "./uok/execution-graph.js";
@@ -112,6 +112,26 @@ export function isVerificationNotApplicable(value) {
 }
 // ─── Rules ────────────────────────────────────────────────────────────────
 export const DISPATCH_RULES = [
+    {
+        // ADR-011 Phase 2: pause-for-escalation must evaluate FIRST so phase-
+        // agnostic rules (rewrite-docs gate, UAT checks, reassess) cannot bypass
+        // the user's pending decision. Only fires for continueWithDefault=false
+        // escalations (those set escalation_pending=1); awaiting-review artifacts
+        // never enter the 'escalating-task' phase.
+        name: "escalating-task → pause-for-escalation",
+        match: async ({ state, mid }) => {
+            if (state.phase !== "escalating-task")
+                return null;
+            if (!state.activeSlice)
+                return missingSliceStop(mid, state.phase);
+            return {
+                action: "stop",
+                reason: state.nextAction ||
+                    `${mid}: task escalation awaits user resolution. Run /gsd escalate list to see pending items.`,
+                level: "info",
+            };
+        },
+    },
     {
         name: "rewrite-docs (override gate)",
         match: async ({ mid, midTitle, state, basePath, session }) => {
@@ -335,6 +355,12 @@ export const DISPATCH_RULES = [
             // Only dispatch parallel if 2+ slices are ready
             if (researchReadySlices.length < 2)
                 return null;
+            // #4414: If a previous parallel-research attempt escalated to a blocker
+            // placeholder, skip this rule and fall through to per-slice research
+            // (or other rules) rather than re-dispatching the same failing unit.
+            const parallelBlocker = resolveMilestoneFile(basePath, mid, "PARALLEL-BLOCKER");
+            if (parallelBlocker)
+                return null;
             return {
                 action: "dispatch",
                 unitType: "research-slice",
@@ -371,9 +397,61 @@ export const DISPATCH_RULES = [
             };
         },
     },
+    {
+        // ADR-011: sketch-then-refine. When `refining` phase fires, expand the
+        // sketch into a full plan using the prior slice's SUMMARY and the current
+        // codebase. If the user flipped `progressive_planning` off mid-milestone
+        // while a slice is still `is_sketch=1`, fall through to a standard
+        // plan-slice so the loop doesn't dead-end.
+        //
+        // Note on the flag-OFF downgrade: plan-slice does not explicitly clear
+        // `is_sketch`. After it writes PLAN.md, the auto-heal in state.ts's
+        // `deriveStateFromDb` (via `autoHealSketchFlags`) flips the flag on the
+        // next iteration. That implicit coupling is the sole mechanism that
+        // reconciles `is_sketch=1` on the plan-slice path — do not remove the
+        // auto-heal without either adding an explicit `setSliceSketchFlag(..., false)`
+        // call here or doing so inside the plan-slice tool handler.
+        name: "refining → refine-slice",
+        match: async ({ state, mid, midTitle, basePath, prefs, sessionContextWindow, modelRegistry }) => {
+            if (state.phase !== "refining")
+                return null;
+            if (!state.activeSlice)
+                return missingSliceStop(mid, state.phase);
+            const sid = state.activeSlice.id;
+            const sTitle = state.activeSlice.title;
+            const progressiveOn = prefs?.phases?.progressive_planning === true;
+            if (!progressiveOn) {
+                // Graceful downgrade: treat the sketch as a normal slice needing a plan,
+                // but forward the stored sketch_scope as a SOFT hint so the scope
+                // signal isn't silently lost. The planner may expand beyond it.
+                let softScopeHint = "";
+                try {
+                    const { isDbAvailable, getSlice } = await import("./gsd-db.js");
+                    if (isDbAvailable()) {
+                        softScopeHint = getSlice(mid, sid)?.sketch_scope ?? "";
+                    }
+                }
+                catch {
+                    softScopeHint = "";
+                }
+                return {
+                    action: "dispatch",
+                    unitType: "plan-slice",
+                    unitId: `${mid}/${sid}`,
+                    prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { ...(softScopeHint ? { softScopeHint } : {}), sessionContextWindow, modelRegistry }),
+                };
+            }
+            return {
+                action: "dispatch",
+                unitType: "refine-slice",
+                unitId: `${mid}/${sid}`,
+                prompt: await buildRefineSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry }),
+            };
+        },
+    },
     {
         name: "planning → plan-slice",
-        match: async ({ state, mid, midTitle, basePath }) => {
+        match: async ({ state, mid, midTitle, basePath, sessionContextWindow, modelRegistry }) => {
             if (state.phase !== "planning")
                 return null;
             if (!state.activeSlice)
@@ -384,7 +462,7 @@ export const DISPATCH_RULES = [
                 action: "dispatch",
                 unitType: "plan-slice",
                 unitId: `${mid}/${sid}`,
-                prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath),
+                prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry }),
             };
         },
     },
@@ -433,7 +511,7 @@ export const DISPATCH_RULES = [
     },
     {
         name: "executing → reactive-execute (parallel dispatch)",
-        match: async ({ state, mid, midTitle, basePath, prefs }) => {
+        match: async ({ state, mid, midTitle, basePath, prefs, sessionContextWindow, modelRegistry }) => {
             if (state.phase !== "executing" || !state.activeTask)
                 return null;
             if (!state.activeSlice)
@@ -496,7 +574,7 @@ export const DISPATCH_RULES = [
                     action: "dispatch",
                     unitType: "reactive-execute",
                     unitId: `${mid}/${sid}/reactive+${batchSuffix}`,
-                    prompt: await buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, selected, basePath, subagentModel),
+                    prompt: await buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, selected, basePath, subagentModel, { sessionContextWindow, modelRegistry }),
                 };
             }
             catch (err) {
@@ -508,7 +586,7 @@ export const DISPATCH_RULES = [
     },
     {
         name: "executing → execute-task (recover missing task plan → plan-slice)",
-        match: async ({ state, mid, midTitle, basePath }) => {
+        match: async ({ state, mid, midTitle, basePath, sessionContextWindow, modelRegistry }) => {
             if (state.phase !== "executing" || !state.activeTask)
                 return null;
             if (!state.activeSlice)
@@ -527,7 +605,7 @@ export const DISPATCH_RULES = [
                     action: "dispatch",
                     unitType: "plan-slice",
                     unitId: `${mid}/${sid}`,
-                    prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath),
+                    prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry }),
                 };
             }
             return null;
@@ -535,7 +613,7 @@ export const DISPATCH_RULES = [
     },
     {
         name: "executing → execute-task",
-        match: async ({ state, mid, basePath }) => {
+        match: async ({ state, mid, basePath, sessionContextWindow, modelRegistry }) => {
             if (state.phase !== "executing" || !state.activeTask)
                 return null;
             if (!state.activeSlice)
@@ -548,7 +626,7 @@ export const DISPATCH_RULES = [
                 action: "dispatch",
                 unitType: "execute-task",
                 unitId: `${mid}/${sid}/${tid}`,
-                prompt: await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, basePath),
+                prompt: await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, basePath, { sessionContextWindow, modelRegistry }),
             };
         },
     },

package/dist/resources/extensions/gsd/auto-model-selection.js

@@ -14,8 +14,12 @@ import { resolveUokFlags } from "./uok/flags.js";
 import { applyModelPolicyFilter } from "./uok/model-policy.js";
 export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode = true) {
     const explicitConfig = resolveModelWithFallbacksForUnit(unitType);
-    if (explicitConfig)
-        return explicitConfig;
+    if (explicitConfig) {
+        return {
+            ...explicitConfig,
+            source: "explicit",
+        };
+    }
     // In interactive mode, don't synthesize a routing-based model config.
     // The user's session model (/model) should be used as-is (#3962).
     if (!isAutoMode)
@@ -24,8 +28,13 @@ export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAuto
     if (!routingConfig.enabled || !routingConfig.tier_models)
         return undefined;
     // Don't synthesize a routing config for flat-rate providers (#3453).
-    if (autoModeStartModel && isFlatRateProvider(autoModeStartModel.provider, autoModeStartModel.flatRateCtx))
+    // Users can opt into routing for flat-rate subscriptions (e.g. claude-code)
+    // via dynamic_routing.allow_flat_rate_providers (#4386).
+    if (!routingConfig.allow_flat_rate_providers &&
+        autoModeStartModel &&
+        isFlatRateProvider(autoModeStartModel.provider, autoModeStartModel.flatRateCtx)) {
         return undefined;
+    }
     const ceilingModel = routingConfig.tier_models.heavy
         ?? (autoModeStartModel ? `${autoModeStartModel.provider}/${autoModeStartModel.id}` : undefined);
     if (!ceilingModel)
@@ -33,6 +42,7 @@ export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAuto
     return {
         primary: ceilingModel,
         fallbacks: [],
+        source: "synthesized",
     };
 }
 /**
@@ -85,6 +95,11 @@ sessionModelOverride) {
         if (prefs?.token_profile === "burn-max") {
             routingConfig.enabled = false;
         }
+        if (modelConfig.source === "explicit") {
+            // Explicit per-phase model preferences express hard user intent.
+            // Dynamic routing may only treat synthesized tier ceilings as downgradeable.
+            routingConfig.enabled = false;
+        }
         let effectiveModelConfig = modelConfig;
         let routingTierLabel = "";
         let routingEligibleModels = availableModels;
@@ -113,7 +128,10 @@ sessionModelOverride) {
         // model provides no cost benefit — it only degrades quality.
         // Fail-closed: if primary model can't be resolved, fall back to
         // provider-level signals rather than allowing unwanted downgrades.
-        if (routingConfig.enabled) {
+        // Opt-in: dynamic_routing.allow_flat_rate_providers skips the bypass so
+        // claude-code subscribers can still get intelligent per-task selection
+        // across their subscription (#4386).
+        if (routingConfig.enabled && !routingConfig.allow_flat_rate_providers) {
             const primaryModel = resolveModelId(modelConfig.primary, routingEligibleModels, ctx.model?.provider);
             if (primaryModel) {
                 const primaryFlatRateCtx = buildFlatRateContext(primaryModel.provider, ctx, prefs);
@@ -142,7 +160,7 @@ sessionModelOverride) {
             const shouldClassify = !isHook || routingConfig.hooks !== false;
             if (shouldClassify) {
                 let classification = classifyUnitComplexity(unitType, unitId, basePath, budgetPct, taskMetadataForPolicy);
-                const availableModelIds = routingEligibleModels.map(m => m.id);
+                const availableModelIds = routingEligibleModels.map(m => `${m.provider}/${m.id}`);
                 // Escalate tier on retry when escalate_on_failure is enabled (default: true)
                 if (retryContext?.isRetry &&
                     retryContext.previousTier &&
@@ -202,6 +220,7 @@ sessionModelOverride) {
                     effectiveModelConfig = {
                         primary: routingResult.modelId,
                         fallbacks: routingResult.fallbacks,
+                        source: modelConfig.source,
                     };
                     // Always notify on model downgrade — users should see when their
                     // model selection is overridden, not just in verbose mode (#3962).
@@ -374,7 +393,9 @@ export function resolveModelId(modelId, availableModels, currentProvider) {
         if (providerMatch)
             return providerMatch;
     }
-    // Prefer "anthropic" as the canonical provider for Anthropic models
+    // Prefer "anthropic" as the canonical provider for Anthropic models.
+    // Transport-specific tiebreaker (ADR-012): intentionally keys on provider,
+    // not api — we want the plain Anthropic transport when multiple are available.
     const anthropicMatch = candidates.find(m => m.provider === "anthropic");
     if (anthropicMatch)
         return anthropicMatch;

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -66,7 +66,7 @@ function enqueueSidecar(s, ctx, entry, debugExtra, notification) {
  *  next actual task commit via `smartStage()`. */
 const LIFECYCLE_ONLY_UNITS = new Set([
     "research-milestone", "discuss-milestone", "discuss-slice", "plan-milestone",
-    "validate-milestone", "research-slice", "plan-slice",
+    "validate-milestone", "research-slice", "plan-slice", "refine-slice",
     "replan-slice", "complete-slice", "run-uat",
     "reassess-roadmap", "rewrite-docs",
 ]);
@@ -139,7 +139,7 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
             rogues.push({ path: roadmapPath, unitType, unitId });
         }
     }
-    else if (unitType === "plan-slice" || unitType === "replan-slice") {
+    else if (unitType === "plan-slice" || unitType === "refine-slice" || unitType === "replan-slice") {
         if (!mid || !sid)
             return [];
         const planPath = resolveSliceFile(basePath, mid, sid, "PLAN");
@@ -611,7 +611,7 @@ export async function postUnitPreVerification(pctx, opts) {
                 try {
                     const { milestone: mid, slice: sid } = parseUnitId(s.currentUnit.id);
                     if (mid && sid) {
-                        const regenerated = regenerateIfMissing(s.basePath, mid, sid, "PLAN");
+                        const regenerated = await regenerateIfMissing(s.basePath, mid, sid, "PLAN");
                         if (regenerated) {
                             // Re-check after regeneration
                             triggerArtifactVerified = verifyExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
@@ -855,9 +855,11 @@ export async function postUnitPostVerification(pctx) {
             debugLog("postUnit", { phase: "capture-protection-error", error: String(e) });
         }
     }
-    // ── Pre-execution checks (after plan-slice completes) ──
+    // ── Pre-execution checks (after plan-slice or ADR-011 refine-slice completes) ──
+    // Both emit the same PLAN.md + task artifacts via gsd_plan_slice, so the
+    // same structural validation applies to both.
     if (s.currentUnit &&
-        s.currentUnit.type === "plan-slice") {
+        (s.currentUnit.type === "plan-slice" || s.currentUnit.type === "refine-slice")) {
         const currentUnit = s.currentUnit;
         let preExecPauseNeeded = false;
         await runSafely("postUnitPostVerification", "pre-execution-checks", async () => {