@opengsd/gsd-pi 1.5.0 → 1.6.0

package/src/resources/extensions/gsd/auto-artifact-paths.ts

@@ -19,10 +19,11 @@ import {
   resolveSlicePath,
   resolveTasksDir,
   dirIsMetaOnlyLegacyMilestone,
+  normalizeRealPath,
 } from "./paths.js";
 import { milestoneIdToPhaseNum } from "./layout-policy.js";
 import { parseUnitId } from "./unit-id.js";
-import { dirname, join, relative } from "node:path";
+import { basename, dirname, join, relative } from "node:path";
 import { existsSync } from "node:fs";
 
 function resolveMilestoneArtifactPath(
@@ -221,8 +222,17 @@ export function resolveExpectedArtifactPath(
         ?? resolveProjectSlicePath(base, mid, sid!)
         ?? resolveSlicePath(base, mid, sid!);
       if (!slicePath || !tid) return null;
-      const tasksDir = resolveTasksDir(base, mid, sid!) ?? slicePath;
-      return join(tasksDir, buildTaskFileName(tid, "SUMMARY"));
+      // Legacy layout: slice dirs live under slices/<SID>/ and task summaries
+      // live in a tasks/ subdir. Flat-phase layout: slicePath IS the phase dir
+      // and task summaries live beside the plan files at the phase root. A
+      // tasks/ subdir may still exist in flat-phase for auxiliary task-scoped
+      // artifacts (e.g. T01-VERIFY.json gate outputs) — its mere existence must
+      // NOT redirect summary resolution into tasks/ (#1208).
+      const isLegacySlice = basename(dirname(slicePath)) === "slices";
+      const summaryDir = isLegacySlice
+        ? (resolveTasksDir(base, mid, sid!) ?? slicePath)
+        : slicePath;
+      return join(summaryDir, buildTaskFileName(tid, "SUMMARY"));
     }
     case "complete-slice": {
       return resolveSliceArtifactPath(base, mid, sid!, "SUMMARY");
@@ -345,7 +355,7 @@ export function resolveSliceResearchLocation(
   if (canonicalPath && existsSync(canonicalPath)) {
     return {
       absolutePath: canonicalPath,
-      relativePath: relative(basePath, canonicalPath),
+      relativePath: relative(normalizeRealPath(basePath), canonicalPath),
     };
   }
 

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

@@ -27,11 +27,11 @@ import {
   buildRunUatPrompt,
   buildReplanSlicePrompt,
 } from "./auto-prompts.js";
-import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { loadEffectiveGSDPreferences, renderLanguageDirectiveForPrompt } from "./preferences.js";
 import type { MinimalModelRegistry } from "./context-budget.js";
 import { pauseAuto } from "./auto.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
-import { getUnitWorkflowDispatchReadinessError } from "./tool-contract.js";
+import { getUnitWorkflowDispatchReadinessErrorForModel } from "./tool-contract.js";
 
 export function parseDirectDispatchPhase(raw: string): { phase: string; milestoneId?: string } {
   const tokens = raw.trim().split(/\s+/).filter(Boolean);
@@ -266,13 +266,12 @@ export async function dispatchDirectPhase(
       return;
   }
 
-  const compatibilityError = getUnitWorkflowDispatchReadinessError({
-    provider: ctx.model?.provider,
+  const compatibilityError = getUnitWorkflowDispatchReadinessErrorForModel({
+    model: ctx.model,
+    getProviderAuthMode: (provider) => ctx.modelRegistry.getProviderAuthMode(provider),
     projectRoot,
     surface: "direct phase dispatch",
     unitType,
-    authMode: ctx.model?.provider ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider) : undefined,
-    baseUrl: ctx.model?.baseUrl,
     activeTools: typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [],
   });
   if (compatibilityError) {
@@ -287,8 +286,15 @@ export async function dispatchDirectPhase(
     ctx.ui.notify("Session creation cancelled.", "warning");
     return;
   }
+  // Inject the configured response language into the dispatched prompt content
+  // — the new session's system prompt does not carry the preferences block, so
+  // the language setting would otherwise never reach the unit (#1210).
+  const languageDirective = renderLanguageDirectiveForPrompt(
+    loadEffectiveGSDPreferences(dispatchBase)?.preferences,
+  );
+  const dispatchContent = languageDirective ? `${languageDirective}\n\n${prompt}` : prompt;
   pi.sendMessage(
-    { customType: "gsd-dispatch", content: prompt, display: false },
+    { customType: "gsd-dispatch", content: dispatchContent, display: false },
     { triggerTurn: true },
   );
 }

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

@@ -14,6 +14,7 @@
 
 import type { GSDState, TaskIO } from "./types.js";
 import type { GSDPreferences } from "./preferences.js";
+import { renderLanguageDirectiveForPrompt } from "./preferences.js";
 import type { MinimalModelRegistry } from "./context-budget.js";
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
 import { getUatBrowserToolSupportError, type UatType } from "./uat-policy.js";
@@ -78,9 +79,10 @@ import {
   buildGateEvaluatePrompt,
   buildParallelResearchSlicesPrompt,
   checkNeedsReassessment,
-  checkNeedsRunUat,
+  loadRoadmapCompletedSliceCandidates,
 } from "./auto-prompts.js";
-import { resolveModelWithFallbacksForUnit, resolveThinkingLevelForUnit } from "./preferences-models.js";
+import { checkNeedsRunUat } from "./uat-dispatch.js";
+import { normalizeModelFieldConfig, resolveModelWithFallbacksForUnit, resolveThinkingLevelForUnit } from "./preferences-models.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { selectReactiveDispatchBatch } from "./uok/execution-graph.js";
 import { getMilestonePipelineVariant } from "./milestone-scope-classifier.js";
@@ -307,12 +309,21 @@ export async function readUatGateVerdict(
       return null;
     }
 
-    const assessmentVerdict = extractVerdict(assessmentContent);
-    if (assessmentVerdict) {
-      return {
-        verdict: assessmentVerdict,
-        uatType: uatType ?? extractUatType(assessmentContent),
-      };
+    // Backfilled assessments (#1258) are placeholders created during milestone
+    // validation for completed slices that never produced a real UAT ASSESSMENT
+    // (e.g. artifact-driven UAT that was never dispatched). Their fabricated
+    // verdict must not be treated as a genuine UAT sign-off — otherwise "never
+    // checked" is silently read as "passed". Skip the placeholder and fall
+    // through to the authoritative run-uat DB row (which stays null unless a
+    // real UAT was actually recorded).
+    if (assessmentScope !== BACKFILL_ASSESSMENT_SCOPE) {
+      const assessmentVerdict = extractVerdict(assessmentContent);
+      if (assessmentVerdict) {
+        return {
+          verdict: assessmentVerdict,
+          uatType: uatType ?? extractUatType(assessmentContent),
+        };
+      }
     }
   }
 
@@ -488,17 +499,28 @@ function stripGsdPrefix(path: string): string {
   return path.startsWith(".gsd/") ? path.slice(".gsd/".length) : path;
 }
 
+// Scope marker for assessments fabricated by the milestone-validation backfill
+// (#1258). It keeps these placeholders distinguishable from genuine `run-uat`
+// sign-offs so `readUatGateVerdict` never mistakes "never checked" for "passed".
+const BACKFILL_ASSESSMENT_SCOPE = "backfill";
+
 function persistSliceAssessmentBackfill(
   assessmentRelPath: string,
   mid: string,
   sliceId: string,
   content: string,
+  fabricated: boolean,
 ): void {
   const artifactPath = stripGsdPrefix(assessmentRelPath);
   const existingAssessment =
     getAssessment(assessmentRelPath) ??
     getAssessment(artifactPath);
-  const scope = stringField(existingAssessment, "scope") ?? "run-uat";
+  // A newly fabricated placeholder is filed under a distinct scope; a pre-existing
+  // on-disk ASSESSMENT keeps its real scope (default `run-uat`) so genuine
+  // sign-offs are still honored.
+  const scope = fabricated
+    ? BACKFILL_ASSESSMENT_SCOPE
+    : stringField(existingAssessment, "scope") ?? "run-uat";
   const status = stringField(existingAssessment, "status") ??
     extractVerdict(content)?.toLowerCase() ??
     "unknown";
@@ -547,19 +569,25 @@ function backfillMissingAssessmentsFromSummaries(basePath: string, mid: string):
       "---",
       `sliceId: ${sliceId}`,
       "verdict: PASS",
+      // Distinguishing marker (#1258): this ASSESSMENT was fabricated to satisfy
+      // the per-slice artifact requirement, NOT produced by a real UAT run. It
+      // must not be read as a genuine UAT sign-off.
+      "backfilled: true",
+      "verified: false",
       `date: ${now}`,
       "---",
       "",
       `# Assessment — ${sliceId}`,
       "",
       "Auto-created during milestone validation because this completed slice had a SUMMARY but no ASSESSMENT artifact.",
+      "This is a placeholder: no UAT was executed for this slice, so its verdict is not an independent sign-off.",
       "No additional reassessment changes were detected in this backfill step.",
       "",
     ].join("\n") : readFileSync(assessmentPath, "utf-8");
 
     if (isDbAvailable()) {
       try {
-        persistSliceAssessmentBackfill(assessmentRelPath, mid, sliceId, content);
+        persistSliceAssessmentBackfill(assessmentRelPath, mid, sliceId, content, didCreateAssessment);
       } catch (err) {
         logWarning("dispatch", `failed to backfill assessment DB rows for ${mid}/${sliceId}: ${(err as Error).message}`);
       }
@@ -768,7 +796,12 @@ export const DISPATCH_RULES: DispatchRule[] = [
       registeredTools,
       sessionBaseUrl,
     }) => {
-      const needsRunUat = await checkNeedsRunUat(basePath, mid, state, prefs);
+      const needsRunUat = await checkNeedsRunUat(
+        basePath,
+        mid,
+        prefs,
+        await loadRoadmapCompletedSliceCandidates(basePath, mid),
+      );
       if (!needsRunUat) return null;
       const { sliceId, uatType } = needsRunUat;
 
@@ -1427,8 +1460,15 @@ export const DISPATCH_RULES: DispatchRule[] = [
       const sTitle = state.activeSlice.title;
       if (resolveSliceFile(basePath, mid, sid, "REACTIVE-BLOCKER")) return null;
       const maxParallel = reactiveConfig?.max_parallel ?? 2;
-      const subagentModel = reactiveConfig?.subagent_model ?? resolveModelWithFallbacksForUnit("subagent")?.primary;
-      const subagentThinking = resolveThinkingLevelForUnit("subagent");
+      // `subagent_model` accepts the phase-bucket object form (#1229); honor the
+      // full primary→fallbacks chain in the dispatch prompt (the reactive
+      // subagent model is embedded there rather than set as the session model).
+      const subagentModelConfig = normalizeModelFieldConfig(reactiveConfig?.subagent_model)
+        ?? resolveModelWithFallbacksForUnit("subagent");
+      const subagentModel = subagentModelConfig?.primary;
+      // Prefer the per-field `thinking` carried on `reactive_execution.subagent_model`'s
+      // object form over the phase-bucket `subagent` level (#1269).
+      const subagentThinking = subagentModelConfig?.thinking ?? resolveThinkingLevelForUnit("subagent");
       // Default-on safety threshold: only activate reactive dispatch when at
       // least N tasks are ready. Users who explicitly enabled reactive_execution
       // keep the legacy threshold of 2 (matches the prior "any parallelism is
@@ -1517,7 +1557,13 @@ export const DISPATCH_RULES: DispatchRule[] = [
             selected,
             basePath,
             subagentModel,
-            { sessionContextWindow, modelRegistry, sessionProvider, subagentThinking },
+            {
+              sessionContextWindow,
+              modelRegistry,
+              sessionProvider,
+              subagentThinking,
+              subagentModelFallbacks: subagentModelConfig?.fallbacks,
+            },
           ),
         };
       } catch (err) {
@@ -1834,6 +1880,21 @@ export const DISPATCH_RULES: DispatchRule[] = [
 
 import { getRegistry } from "./rule-registry.js";
 
+/**
+ * Prepend the configured response-language directive to a dispatched unit
+ * prompt so auto-execution units respond in the language set in PREFERENCES.md
+ * (#1210). No-op for non-dispatch actions or when no language is configured.
+ */
+function applyLanguageDirectiveToDispatch(
+  action: DispatchAction,
+  prefs: GSDPreferences | undefined,
+): DispatchAction {
+  if (action.action !== "dispatch" || !action.prompt) return action;
+  const directive = renderLanguageDirectiveForPrompt(prefs);
+  if (!directive) return action;
+  return { ...action, prompt: `${directive}\n\n${action.prompt}` };
+}
+
 // ─── Resolver ─────────────────────────────────────────────────────────────
 
 /**
@@ -1896,7 +1957,7 @@ export async function resolveDispatch(
         level: "error",
       };
     }
-    return action;
+    return applyLanguageDirectiveToDispatch(action, ctx.prefs);
   } catch (err) {
     // Registry not initialized — fall back to inline loop
     logWarning("dispatch", `registry dispatch failed, falling back to inline rules: ${err instanceof Error ? err.message : String(err)}`);
@@ -1918,7 +1979,7 @@ export async function resolveDispatch(
           matchedRule: rule.name,
         };
       }
-      return action;
+      return applyLanguageDirectiveToDispatch(action, ctx.prefs);
     }
   }
 

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

@@ -273,7 +273,7 @@ function buildModelPolicyBlockReasons(
   }];
 }
 
-function isModelUnavailable(
+export function isModelUnavailable(
   basePath: string,
   provider: string | undefined,
   id: string | undefined,
@@ -282,6 +282,38 @@ function isModelUnavailable(
     isModelTemporarilyUnavailable(basePath, provider, id);
 }
 
+/** Apply `auto_supervisor.model`, walking configured fallbacks on unavailability (#1229). */
+export async function applySupervisorModelIfConfigured(
+  ctx: ExtensionContext,
+  pi: ExtensionAPI,
+  basePath: string,
+): Promise<void> {
+  const modelConfig = resolveModelWithFallbacksForUnit("supervisor", basePath);
+  if (!modelConfig) return;
+
+  const availableModels = ctx.modelRegistry.getAvailable();
+  for (const candidate of [modelConfig.primary, ...modelConfig.fallbacks]) {
+    const match = resolveModelId(candidate, availableModels, ctx.model?.provider);
+    if (!match) continue;
+    if (isModelUnavailable(basePath, match.provider, match.id)) continue;
+    try {
+      if (await pi.setModel(match, { persist: false })) {
+        // Prefer the per-field `thinking` from `auto_supervisor.model`'s object
+        // form over the session level so a configured supervisor level actually
+        // applies (#1269).
+        applyThinkingLevelForModel(pi, modelConfig.thinking ?? pi.getThinkingLevel(), match, ctx);
+        return;
+      }
+    } catch (err) {
+      // Non-fatal — try the next fallback.
+      logWarning(
+        "dispatch",
+        `supervisor model set failed for ${candidate}: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+  }
+}
+
 function restoreToolBaseline(pi: ExtensionAPI): void {
   const key = pi as unknown as object;
   const baseline = TOOL_BASELINE.get(key);

package/src/resources/extensions/gsd/auto-post-unit.ts

@@ -30,6 +30,7 @@ import {
   relMilestoneFile,
   relSliceFile,
   relTaskFile,
+  normalizeRealPath,
 } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { rebuildState } from "./doctor.js";
@@ -960,7 +961,7 @@ function describeArtifactVerificationFailure(
   if (!artifactPath) {
     return `Artifact verification failed: ${unitType} "${unitId}" has no resolvable artifact path.`;
   }
-  const relPath = relative(basePath, artifactPath);
+  const relPath = relative(normalizeRealPath(basePath), artifactPath);
   if (!existsSync(artifactPath)) {
     const completionToolHint = unitType === "execute-task" && !hasTaskCompletionToolCall(agentEndMessages)
       ? " No completion tool call detected (`gsd_task_complete`/alias)."
@@ -2398,7 +2399,8 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
       const verdict = gateBlock.verdict ? ` verdict=${gateBlock.verdict};` : "";
       const artifact = gateBlock.artifact ? ` artifact=${gateBlock.artifact};` : "";
       const message =
-        `Post-unit gate "${gateBlock.hookName}" blocked ${gateBlock.triggerUnitType} ${gateBlock.triggerUnitId}:` +
+        `Post-unit gate "${gateBlock.hookName}" blocked ${gateBlock.triggerUnitType} ${gateBlock.triggerUnitId} ` +
+        `(detected on completion of ${s.currentUnit.type} ${s.currentUnit.id}):` +
         `${verdict}${artifact} ${gateBlock.reason}. Run /gsd status to inspect, then /gsd auto after recovery.`;
       ctx.ui.notify(message, "warning");
       await pauseAuto(ctx, pi);

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

@@ -11,7 +11,7 @@
 
 import { loadFile, parseContinue, parseSummary, loadActiveOverrides, formatOverridesSection, parseTaskPlanFile } from "./files.js";
 import type { Override } from "./files.js";
-import { hasVerdict, extractVerdict } from "./verdict-parser.js";
+import { extractVerdict } from "./verdict-parser.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
 import {
   resolveMilestoneFile, resolveSliceFile, resolveSlicePath,
@@ -60,11 +60,8 @@ import { debugLog } from "./debug-logger.js";
 import { buildSkillActivationBlock, buildSkillDiscoveryVars } from "./skill-activation.js";
 import { findMilestoneIds } from "./milestone-ids.js";
 import { buildRunUatPresentationForType, RUN_UAT_TOOL_PRESENTATION_PLAN_ID } from "./tool-presentation-plan.js";
-import {
-  classifyUatContentForRun,
-  shouldDispatchUatForContent,
-  type UatType,
-} from "./uat-policy.js";
+import { classifyUatContentForRun } from "./uat-policy.js";
+import { checkNeedsRunUat as resolveNeedsRunUat, type UatDispatchCandidate } from "./uat-dispatch.js";
 import { buildWebAppUatGuidanceBlock } from "./web-app-uat.js";
 
 export { buildSkillActivationBlock, buildSkillDiscoveryVars };
@@ -1514,116 +1511,43 @@ export async function checkNeedsReassessment(
   return { sliceId: lastDone };
 }
 
-/**
- * Check if the most recently completed slice needs a UAT run.
- * Returns { sliceId, uatType } if UAT should be dispatched, null otherwise.
- *
- * Skips when:
- * - No roadmap or no completed slices
- * - uat_dispatch is not enabled and the UAT spec does not require runtime/browser evidence
- * - No UAT file exists for the slice
- * - UAT result file already exists (idempotent — already ran)
- */
-/**
- * Resolve the effective UAT mode for the dispatch gate the same way
- * `buildRunUatPrompt` does: classify the UAT body with the slice's SUMMARY as
- * supplemental context, so a `browser-executable` UAT whose slice references a
- * self-contained harness (`npm run test:uat`, `search-uat.mjs`, `npx
- * playwright test`) is promoted to `runtime-executable` for the gate too.
- *
- * Without this, `checkNeedsRunUat` returns `browser-executable` while the
- * prompt instructs runtime-only execution, causing the dispatch gate to
- * require browser tools / warm up the browser daemon (or stop dispatch when
- * browser MCP is unavailable) for UAT runs that never touch the browser. See
- * cursor[bot] review on PR #696 for the M007/S01 regression.
- */
-async function resolveRunUatEffectiveType(
+
+export function getRoadmapCompletedSliceCandidates(
+  roadmapContent: string,
+): UatDispatchCandidate[] {
+  return parseRoadmap(roadmapContent)
+    .slices.filter((slice) => slice.done)
+    .map((slice) => ({ sliceId: slice.id }))
+    .reverse();
+}
+
+
+export async function loadRoadmapCompletedSliceCandidates(
   base: string,
   mid: string,
-  sliceId: string,
-  uatContent: string,
-): Promise<UatType> {
-  let summaryContent = "";
-  try {
-    const summaryPath = resolveSliceFile(base, mid, sliceId, "SUMMARY");
-    if (summaryPath) {
-      summaryContent = (await loadFile(summaryPath)) ?? "";
-    }
-  } catch (err) {
-    logWarning(
-      "prompt",
-      `resolveRunUatEffectiveType SUMMARY load failed: ${err instanceof Error ? err.message : String(err)}`,
-    );
-  }
-  return classifyUatContentForRun(uatContent, summaryContent).effectiveType;
+): Promise<UatDispatchCandidate[]> {
+  const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+  const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
+  return roadmapContent ? getRoadmapCompletedSliceCandidates(roadmapContent) : [];
 }
 
+/**
+ * Back-compat wrapper for callers that import UAT dispatch checks from the
+ * prompt module. UAT dispatch architecture lives in `uat-dispatch.ts`; the
+ * `state` parameter is intentionally ignored because DB/roadmap artifacts are
+ * the source of truth for completed-slice discovery.
+ */
 export async function checkNeedsRunUat(
   base: string, mid: string, state: GSDState, prefs: GSDPreferences | undefined,
-): Promise<{ sliceId: string; uatType: UatType } | null> {
-  // DB primary path — fall through to file-based when DB has no data for this milestone
-  try {
-    const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
-    if (isDbAvailable()) {
-      const slices = getMilestoneSlices(mid);
-      if (slices.length > 0) {
-        const completedSlices = slices.filter(s => s.status === "complete");
-        if (completedSlices.length === 0) return null;
-        for (const completed of [...completedSlices].reverse()) {
-          const sid = completed.id;
-          const uatFile = resolveSliceFile(base, mid, sid, "UAT");
-          if (!uatFile) continue;
-          const uatContent = await loadFile(uatFile);
-          if (!uatContent) continue;
-          // If the UAT file already contains a verdict, UAT has been run — skip
-          if (hasVerdict(uatContent)) continue;
-          // Also check the ASSESSMENT file — the run-uat prompt writes the verdict
-          // there (via gsd_uat_result_save), not into the
-          // UAT spec file. Without this check the unit re-dispatches indefinitely.
-          const assessmentFile = resolveSliceFile(base, mid, sid, "ASSESSMENT");
-          if (assessmentFile) {
-            const assessmentContent = await loadFile(assessmentFile);
-            if (assessmentContent && hasVerdict(assessmentContent)) continue;
-          }
-          if (!shouldDispatchUatForContent(uatContent, prefs)) continue;
-          const uatType = await resolveRunUatEffectiveType(base, mid, sid, uatContent);
-          return { sliceId: sid, uatType };
-        }
-        return null;
-      }
-    }
-  } catch (err) {
-    logWarning("prompt", `checkNeedsRunUat DB lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-  }
+): Promise<Awaited<ReturnType<typeof resolveNeedsRunUat>>> {
+  void state;
 
-  // File-based fallback using roadmap checkboxes
-  const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
-  if (!roadmapPath) return null;
-  const roadmapContent = await loadFile(roadmapPath);
-  if (!roadmapContent) return null;
-  const parsed = parseRoadmap(roadmapContent);
-  const completedFileSlices = parsed.slices.filter(s => s.done);
-  if (completedFileSlices.length === 0) return null;
-  for (const completed of [...completedFileSlices].reverse()) {
-    const uatSid = completed.id;
-    const uatFileFb = resolveSliceFile(base, mid, uatSid, "UAT");
-    if (!uatFileFb) continue;
-    const uatContentFb = await loadFile(uatFileFb);
-    if (!uatContentFb) continue;
-    // If the UAT file already contains a verdict, UAT has been run — skip
-    if (hasVerdict(uatContentFb)) continue;
-    // Also check the ASSESSMENT file for the file-based fallback path (same
-    // reason as the DB path above — verdict lives in ASSESSMENT, not UAT).
-    const assessmentFileFb = resolveSliceFile(base, mid, uatSid, "ASSESSMENT");
-    if (assessmentFileFb) {
-      const assessmentContentFb = await loadFile(assessmentFileFb);
-      if (assessmentContentFb && hasVerdict(assessmentContentFb)) continue;
-    }
-    if (!shouldDispatchUatForContent(uatContentFb, prefs)) continue;
-    const uatType = await resolveRunUatEffectiveType(base, mid, uatSid, uatContentFb);
-    return { sliceId: uatSid, uatType };
-  }
-  return null;
+  return resolveNeedsRunUat(
+    base,
+    mid,
+    prefs,
+    await loadRoadmapCompletedSliceCandidates(base, mid),
+  );
 }
 
 // ─── Prompt Builders ──────────────────────────────────────────────────────
@@ -3909,9 +3833,15 @@ export async function buildReassessRoadmapPrompt(
  * that instructs the coordinator how to dispatch a `subagent` call. Either or
  * both may be absent (ADR-026 / #508).
  */
-function subagentCallSuffix(model?: string, thinking?: string): string {
+function subagentCallSuffix(model?: string, thinking?: string, fallbacks?: string[]): string {
   const parts: string[] = [];
-  if (model) parts.push(`model: "${model}"`);
+  if (model) {
+    let modelHint = `model: "${model}"`;
+    if (fallbacks && fallbacks.length > 0) {
+      modelHint += ` (fallbacks, in order: ${fallbacks.map((f) => `"${f}"`).join(", ")})`;
+    }
+    parts.push(modelHint);
+  }
   if (thinking) parts.push(`thinking: "${thinking}"`);
   return parts.length > 0 ? ` with ${parts.join(" and ")}` : "";
 }
@@ -3922,7 +3852,13 @@ export async function buildReactiveExecutePrompt(
   subagentModel?: string,
   // Reasoning effort travels inside opts here (not as a positional param) so
   // existing positional `opts` callers don't shift (#508).
-  opts?: { sessionContextWindow?: number; modelRegistry?: MinimalModelRegistry; sessionProvider?: string; subagentThinking?: string },
+  opts?: {
+    sessionContextWindow?: number;
+    modelRegistry?: MinimalModelRegistry;
+    sessionProvider?: string;
+    subagentThinking?: string;
+    subagentModelFallbacks?: string[];
+  },
 ): Promise<string> {
   const { loadSliceTaskIO, deriveTaskGraph, graphMetrics } = await import("./reactive-graph.js");
 
@@ -4019,7 +3955,11 @@ export async function buildReactiveExecutePrompt(
       `When done, say: "Task ${tid} complete."`,
     ].join("\n");
 
-    const modelSuffix = subagentCallSuffix(subagentModel, opts?.subagentThinking);
+    const modelSuffix = subagentCallSuffix(
+      subagentModel,
+      opts?.subagentThinking,
+      opts?.subagentModelFallbacks,
+    );
     subagentSections.push([
       `### ${tid}: ${tTitle}`,
       "",

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

@@ -234,12 +234,56 @@ export function refreshRecoveryDbForArtifact(
   }
 
   if (!isClosedStatus(task.status)) {
-    return {
-      ok: false,
-      fatal: true,
-      reason: "execute-task-artifact-db-mismatch",
-      message: `Stuck recovery found execute-task ${unitId} artifacts, but the DB task status is still '${task.status}' after refresh.`,
-    };
+    // The artifact was already confirmed on disk by verifyExpectedArtifact
+    // upstream (Gate 1 accepts a checked disk checkbox as proof of completion),
+    // but the DB task row is still open. A bare refreshWorkflowDatabaseFromDisk
+    // never promotes the disk checkbox into task status (the checkbox is
+    // rendered *from* the DB, never *into* it), so this divergence can never
+    // self-heal. Promote the task to align the DB with disk instead of failing
+    // shut — otherwise the lowest-pending derivation re-picks the same task
+    // forever and execute-task hard-stops with "state did not advance" (#1204).
+    // Mirrors the promotion pattern used by the context-exhaustion and
+    // reactive-execute-blocker recovery paths.
+    const ts = new Date().toISOString();
+    // Only the DB promotion is load-bearing: if it throws, nothing advanced
+    // and failing shut is correct. The plan checkbox rewrite and cache clears
+    // are best-effort follow-ups — a throw there must NOT abort recovery, or
+    // the DB is left complete without ever emitting the stuck-artifact-recovery
+    // event (#1221), stranding worktree reconciliation.
+    try {
+      updateTaskStatus(mid, sid, tid, "complete", ts);
+    } catch (e) {
+      return {
+        ok: false,
+        fatal: true,
+        reason: "execute-task-artifact-db-promote-failed",
+        message: `Stuck recovery found execute-task ${unitId} artifacts, but promoting the DB task status from '${task.status}' failed: ${getErrorMessage(e)}`,
+      };
+    }
+    try {
+      const artifactBase = resolveArtifactVerificationBase(unitId, basePath);
+      const planPath = resolveExpectedArtifactPath("plan-slice", `${mid}/${sid}`, artifactBase);
+      if (planPath && existsSync(planPath)) {
+        const planContent = readFileSync(planPath, "utf-8");
+        const updatedPlan = planContent.replace(
+          new RegExp(`^(\\s*-\\s+)\\[ \\]\\s+\\*\\*${tid}:`, "m"),
+          `$1[x] **${tid}:`,
+        );
+        if (updatedPlan !== planContent) {
+          atomicWriteSync(planPath, updatedPlan);
+        }
+      }
+      clearPathCache();
+      clearParseCache();
+    } catch (e) {
+      logWarning("recovery", `stuck-artifact plan checkbox sync failed after DB promotion of ${unitId}: ${getErrorMessage(e)}`);
+    }
+    // Append event so worktree reconciliation can replay this recovery completion.
+    try {
+      appendEvent(basePath, { cmd: "complete-task", params: { milestoneId: mid, sliceId: sid, taskId: tid }, ts, actor: "system", trigger_reason: "stuck-artifact-recovery" });
+    } catch (e) {
+      logWarning("recovery", `appendEvent failed for stuck-artifact task promotion: ${getErrorMessage(e)}`);
+    }
   }
 
   return { ok: true };