gsd-pi 2.75.0 → 2.76.0-dev.4100bd590

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,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";
@@ -111,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 }) => {
@@ -238,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");
@@ -262,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),
             };
         },
     },
@@ -334,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",
@@ -370,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)
@@ -383,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 }),
             };
         },
     },
@@ -432,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)
@@ -495,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) {
@@ -507,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)
@@ -526,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;
@@ -534,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)
@@ -547,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 }),
             };
         },
     },
@@ -600,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

@@ -12,10 +12,15 @@ 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";
+import { isModelBlocked } from "./blocked-models.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 +29,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 +43,7 @@ export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAuto
     return {
         primary: ceilingModel,
         fallbacks: [],
+        source: "synthesized",
     };
 }
 /**
@@ -85,6 +96,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 +129,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 +161,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 +221,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).
@@ -241,6 +261,14 @@ sessionModelOverride) {
                 }
                 attemptedPolicyEligible = true;
             }
+            // Skip models the provider has previously rejected for this account
+            // (issue #4513).  The block is persisted in .gsd/runtime/blocked-models.json
+            // so it survives /gsd auto restarts — without this, the same dead model
+            // gets reselected after every restart.
+            if (isModelBlocked(basePath, model.provider, model.id)) {
+                ctx.ui.notify(`Skipping blocked model ${model.provider}/${model.id} (provider rejected it for this account).`, "warning");
+                continue;
+            }
             // Warn if the ID is ambiguous across providers
             if (!modelId.includes("/")) {
                 const providers = availableModels.filter(m => m.id === modelId).map(m => m.provider);
@@ -306,19 +334,25 @@ sessionModelOverride) {
         // 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) {
-                    const fallbackOk = await pi.setModel(byId, { persist: false });
-                    if (fallbackOk)
-                        appliedModel = byId;
+        const startBlocked = isModelBlocked(basePath, autoModeStartModel.provider, autoModeStartModel.id);
+        if (startBlocked) {
+            ctx.ui.notify(`Auto-mode start model ${autoModeStartModel.provider}/${autoModeStartModel.id} is blocked for this account. Using current session model instead.`, "warning");
+        }
+        else {
+            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 && !isModelBlocked(basePath, m.provider, m.id));
+                    if (byId) {
+                        const fallbackOk = await pi.setModel(byId, { persist: false });
+                        if (fallbackOk)
+                            appliedModel = byId;
+                    }
+                }
+                else {
+                    appliedModel = startModel;
                 }
-            }
-            else {
-                appliedModel = startModel;
             }
         }
     }
@@ -374,7 +408,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

@@ -1,14 +1,14 @@
 /**
- * Post-unit processing for handleAgentEnd — auto-commit, doctor run,
+ * Post-unit processing for auto-loop — auto-commit, doctor run,
  * state rebuild, worktree sync, DB dual-write, hooks, triage, and
  * quick-task dispatch.
  *
- * Split into two functions called sequentially by handleAgentEnd with
+ * Split into two functions called sequentially by auto-loop with
  * the verification gate between them:
  *   1. postUnitPreVerification() — commit, doctor, state rebuild, worktree sync, artifact verification
  *   2. postUnitPostVerification() — DB dual-write, hooks, triage, quick-tasks
  *
- * Extracted from handleAgentEnd() in auto.ts.
+ * Extracted from the pre-loop agent_end handler in auto.ts.
  */
 import { deriveState } from "./state.js";
 import { logWarning, logError } from "./workflow-logger.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 () => {