gsd-pi 2.74.0 → 2.75.0-dev.fd2382b9f

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

@@ -45,6 +45,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 +66,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 +93,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}`;
@@ -753,13 +756,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-dispatch.js

@@ -9,7 +9,8 @@
  * without modifying orchestration code.
  */
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
-import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted, getMilestone } from "./gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted, getMilestone, updateMilestoneStatus } from "./gsd-db.js";
+import { isClosedStatus } from "./status-guards.js";
 import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
 import { gsdRoot, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relSliceFile, buildMilestoneFileName, } from "./paths.js";
 import { parseRoadmap } from "./parsers-legacy.js";
@@ -17,8 +18,10 @@ 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";
 function missingSliceStop(mid, phase) {
     return {
         action: "stop",
@@ -109,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 }) => {
@@ -236,20 +259,20 @@ export const DISPATCH_RULES = [
     },
     {
         name: "needs-discussion → discuss-milestone",
-        match: async ({ state, mid, midTitle, basePath }) => {
+        match: async ({ state, mid, midTitle, basePath, structuredQuestionsAvailable }) => {
             if (state.phase !== "needs-discussion")
                 return null;
             return {
                 action: "dispatch",
                 unitType: "discuss-milestone",
                 unitId: mid,
-                prompt: await buildDiscussMilestonePrompt(mid, midTitle, basePath),
+                prompt: await buildDiscussMilestonePrompt(mid, midTitle, basePath, structuredQuestionsAvailable),
             };
         },
     },
     {
         name: "pre-planning (no context) → discuss-milestone",
-        match: async ({ state, mid, midTitle, basePath }) => {
+        match: async ({ state, mid, midTitle, basePath, structuredQuestionsAvailable }) => {
             if (state.phase !== "pre-planning")
                 return null;
             const contextFile = resolveMilestoneFile(basePath, mid, "CONTEXT");
@@ -260,7 +283,7 @@ export const DISPATCH_RULES = [
                 action: "dispatch",
                 unitType: "discuss-milestone",
                 unitId: mid,
-                prompt: await buildDiscussMilestonePrompt(mid, midTitle, basePath),
+                prompt: await buildDiscussMilestonePrompt(mid, midTitle, basePath, structuredQuestionsAvailable),
             };
         },
     },
@@ -332,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",
@@ -368,6 +397,58 @@ 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 }) => {
+            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 } : undefined),
+                };
+            }
+            return {
+                action: "dispatch",
+                unitType: "refine-slice",
+                unitId: `${mid}/${sid}`,
+                prompt: await buildRefineSlicePrompt(mid, midTitle, sid, sTitle, basePath),
+            };
+        },
+    },
     {
         name: "planning → plan-slice",
         match: async ({ state, mid, midTitle, basePath }) => {
@@ -461,7 +542,15 @@ export const DISPATCH_RULES = [
                 // Only activate reactive dispatch when >1 task is ready
                 if (readyIds.length <= 1)
                     return null;
-                const selected = chooseNonConflictingSubset(readyIds, graph, maxParallel, new Set());
+                const uokFlags = resolveUokFlags(prefs);
+                const selected = uokFlags.executionGraph
+                    ? selectReactiveDispatchBatch({
+                        graph,
+                        readyIds,
+                        maxParallel,
+                        inFlightOutputs: new Set(),
+                    }).selected
+                    : chooseNonConflictingSubset(readyIds, graph, maxParallel, new Set());
                 if (selected.length <= 1)
                     return null;
                 // Log graph metrics for observability
@@ -590,6 +679,33 @@ export const DISPATCH_RULES = [
         match: async ({ state, mid, midTitle, basePath }) => {
             if (state.phase !== "completing-milestone")
                 return null;
+            // Defense-in-depth (#4324): skip dispatch if the DB already marks
+            // this milestone as complete. Prevents re-enqueue when the legacy
+            // filesystem state-derivation path runs (e.g. transient DB
+            // unavailability) and produces a stale completing-milestone phase.
+            if (isDbAvailable()) {
+                const milestone = getMilestone(mid);
+                if (milestone && isClosedStatus(milestone.status)) {
+                    return { action: "skip" };
+                }
+            }
+            // Reconciliation guard (#4324): when the SUMMARY file already exists
+            // on disk but the DB says the milestone is not complete, the DB is
+            // out of sync (e.g. journal reset, partial merge, crash recovery).
+            // Reconcile the DB status directly instead of re-dispatching the
+            // tool, which would overwrite the richer on-disk SUMMARY with a
+            // thinner regenerated version — causing silent data loss.
+            const existingSummary = resolveMilestoneFile(basePath, mid, "SUMMARY");
+            if (existingSummary && isDbAvailable()) {
+                try {
+                    updateMilestoneStatus(mid, "complete", new Date().toISOString());
+                    logWarning("dispatch", `Milestone ${mid} has SUMMARY on disk but DB status was not complete — reconciled DB to complete (#4324)`);
+                }
+                catch (err) {
+                    logWarning("dispatch", `Failed to reconcile milestone ${mid} status: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                return { action: "skip" };
+            }
             // Safety guard (#2675): block completion when VALIDATION verdict is
             // needs-remediation. The state machine treats needs-remediation as
             // terminal (to prevent validate-milestone loops per #832), but

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

@@ -6,7 +6,7 @@
  * (auto.ts, auto-timeout-recovery.ts, agent-end-recovery.ts, tests)
  * continue to work without changes.
  */
-export { autoLoop } from "./auto/loop.js";
+export { autoLoop, runUokKernelLoop, runLegacyAutoLoop } from "./auto/loop.js";
 export { isInfrastructureError, INFRA_ERROR_CODES } from "./auto/infra-errors.js";
 export { resolveAgentEnd, resolveAgentEndCancelled, isSessionSwitchInFlight, _resetPendingResolve, _setActiveSession } from "./auto/resolve.js";
 export { detectStuck } from "./auto/detect-stuck.js";

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

@@ -4,12 +4,14 @@
  * and fallback chains.
  */
 import { resolveModelWithFallbacksForUnit, resolveDynamicRoutingConfig } from "./preferences.js";
-import { classifyUnitComplexity, tierLabel } from "./complexity-classifier.js";
+import { classifyUnitComplexity, extractTaskMetadata, tierLabel } from "./complexity-classifier.js";
 import { resolveModelForComplexity, escalateTier, getEligibleModels, loadCapabilityOverrides, adjustToolSet } from "./model-router.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { unitPhaseLabel } from "./auto-dashboard.js";
 import { getSessionModelOverride } from "./session-model-override.js";
 import { logWarning } from "./workflow-logger.js";
+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)
@@ -22,8 +24,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)
@@ -46,6 +53,7 @@ export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, p
 isAutoMode = true, 
 /** Explicit /gsd model pin captured at bootstrap for long-running auto loops. */
 sessionModelOverride) {
+    const uokFlags = resolveUokFlags(prefs);
     const effectiveSessionModelOverride = sessionModelOverride === undefined
         ? getSessionModelOverride(ctx.sessionManager.getSessionId())
         : (sessionModelOverride ?? undefined);
@@ -67,6 +75,9 @@ sessionModelOverride) {
     let appliedModel = null;
     if (modelConfig) {
         const availableModels = ctx.modelRegistry.getAvailable();
+        const modelPolicyTraceId = `model:${ctx.sessionManager.getSessionId()}:${Date.now()}`;
+        const modelPolicyTurnId = `${unitType}:${unitId}`;
+        let policyAllowedModelKeys = null;
         // ─── Dynamic Model Routing ─────────────────────────────────────────
         // Dynamic routing (complexity-based downgrading) only applies in auto-mode.
         // Interactive/guided-flow dispatches use the user's session model directly,
@@ -75,15 +86,43 @@ sessionModelOverride) {
         if (!isAutoMode) {
             routingConfig.enabled = false;
         }
+        // burn-max defaults to quality-first dispatch (no downgrade routing).
+        if (prefs?.token_profile === "burn-max") {
+            routingConfig.enabled = false;
+        }
         let effectiveModelConfig = modelConfig;
         let routingTierLabel = "";
+        let routingEligibleModels = availableModels;
+        const taskMetadataForPolicy = unitType === "execute-task"
+            ? extractTaskMetadata(unitId, basePath)
+            : undefined;
+        if (uokFlags.modelPolicy) {
+            const policy = applyModelPolicyFilter(availableModels, {
+                basePath,
+                traceId: modelPolicyTraceId,
+                turnId: modelPolicyTurnId,
+                unitType,
+                taskMetadata: taskMetadataForPolicy,
+                currentProvider: ctx.model?.provider,
+                allowCrossProvider: routingConfig.cross_provider !== false,
+                requiredTools: pi.getActiveTools(),
+            });
+            routingEligibleModels = policy.eligible;
+            policyAllowedModelKeys = new Set(policy.eligible.map((m) => `${m.provider.toLowerCase()}/${m.id.toLowerCase()}`));
+            if (routingEligibleModels.length === 0) {
+                throw new Error(`Model policy denied all candidate models for ${unitType}/${unitId}`);
+            }
+        }
         // Disable routing for flat-rate providers like GitHub Copilot (#3453).
         // All models cost the same per request, so downgrading to a cheaper
         // 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) {
-            const primaryModel = resolveModelId(modelConfig.primary, availableModels, ctx.model?.provider);
+        // 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);
                 if (isFlatRateProvider(primaryModel.provider, primaryFlatRateCtx)) {
@@ -110,8 +149,8 @@ sessionModelOverride) {
             const isHook = unitType.startsWith("hook/");
             const shouldClassify = !isHook || routingConfig.hooks !== false;
             if (shouldClassify) {
-                let classification = classifyUnitComplexity(unitType, unitId, basePath, budgetPct);
-                const availableModelIds = availableModels.map(m => m.id);
+                let classification = classifyUnitComplexity(unitType, unitId, basePath, budgetPct, taskMetadataForPolicy);
+                const availableModelIds = routingEligibleModels.map(m => m.id);
                 // Escalate tier on retry when escalate_on_failure is enabled (default: true)
                 if (retryContext?.isRetry &&
                     retryContext.previousTier &&
@@ -191,13 +230,25 @@ sessionModelOverride) {
             }
         }
         const modelsToTry = [effectiveModelConfig.primary, ...effectiveModelConfig.fallbacks];
+        let attemptedPolicyEligible = false;
         for (const modelId of modelsToTry) {
-            const model = resolveModelId(modelId, availableModels, ctx.model?.provider);
+            const resolutionPool = uokFlags.modelPolicy ? routingEligibleModels : availableModels;
+            const model = resolveModelId(modelId, resolutionPool, ctx.model?.provider);
             if (!model) {
                 if (verbose)
                     ctx.ui.notify(`Model ${modelId} not found, trying fallback.`, "info");
                 continue;
             }
+            if (policyAllowedModelKeys) {
+                const key = `${model.provider.toLowerCase()}/${model.id.toLowerCase()}`;
+                if (!policyAllowedModelKeys.has(key)) {
+                    if (verbose) {
+                        ctx.ui.notify(`Model policy denied ${model.provider}/${model.id}; trying fallback.`, "warning");
+                    }
+                    continue;
+                }
+                attemptedPolicyEligible = true;
+            }
             // Warn if the ID is ambiguous across providers
             if (!modelId.includes("/")) {
                 const providers = availableModels.filter(m => m.id === modelId).map(m => m.provider);
@@ -255,6 +306,9 @@ sessionModelOverride) {
                 }
             }
         }
+        if (uokFlags.modelPolicy && policyAllowedModelKeys && !attemptedPolicyEligible) {
+            throw new Error(`Model policy denied dispatch for ${unitType}/${unitId} before prompt send`);
+        }
     }
     else if (autoModeStartModel) {
         // No model preference for this unit type — re-apply the model captured
@@ -359,10 +413,10 @@ export function isFlatRateProvider(provider, opts) {
  */
 export function buildFlatRateContext(provider, ctx, prefs) {
     let authMode;
-    const getAuthMode = ctx?.modelRegistry?.getProviderAuthMode;
-    if (typeof getAuthMode === "function") {
+    const registry = ctx?.modelRegistry;
+    if (registry && typeof registry.getProviderAuthMode === "function") {
         try {
-            const mode = getAuthMode(provider);
+            const mode = registry.getProviderAuthMode(provider);
             if (mode === "apiKey" || mode === "oauth" || mode === "externalCli" || mode === "none") {
                 authMode = mode;
             }