@opengsd/gsd-pi 1.5.0 → 1.6.0-dev.aa7f94e8

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

@@ -29,7 +29,7 @@ import type { MinimalModelRegistry } from "../context-budget.js";
 import { parseUnitId } from "../unit-id.js";
 import { createCheckpoint, cleanupCheckpoint, rollbackToCheckpoint } from "../safety/git-checkpoint.js";
 import { resolveSafetyHarnessConfig } from "../safety/safety-harness.js";
-import { getUnitWorkflowDispatchReadinessError } from "../tool-contract.js";
+import { getUnitWorkflowDispatchReadinessErrorForModel } from "../tool-contract.js";
 import { prepareWorkflowMcpForProject } from "../workflow-mcp-auto-prep.js";
 import {
   applyThinkingLevelForModel,
@@ -343,17 +343,13 @@ export async function runUnitPhase(
     ? `${(s.currentUnitModel as any).provider ?? ""}/${(s.currentUnitModel as any).id ?? ""}`
     : null;
 
-  const compatibilityError = getUnitWorkflowDispatchReadinessError({
-    provider: s.currentUnitModel?.provider ?? ctx.model?.provider,
+  const compatibilityError = getUnitWorkflowDispatchReadinessErrorForModel({
+    model: s.currentUnitModel as any,
+    fallbackModel: ctx.model,
+    getProviderAuthMode: (provider) => ctx.modelRegistry.getProviderAuthMode(provider),
     projectRoot: s.basePath,
     surface: "auto-mode",
     unitType,
-    authMode: s.currentUnitModel?.provider
-      ? ctx.modelRegistry.getProviderAuthMode(s.currentUnitModel.provider)
-      : ctx.model?.provider
-        ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider)
-        : undefined,
-    baseUrl: (s.currentUnitModel as any)?.baseUrl ?? ctx.model?.baseUrl,
     activeTools: typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [],
   });
   const workflowMcpPrepModel = s.currentUnitModel;

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";
@@ -55,7 +56,7 @@ import { normalizeWorktreePathForCompare } from "./worktree-root.js";
 import { isDbAvailable, getTask, getSlice, getMilestone, getMilestoneSlices, updateTaskStatus, _getAdapter, getVerificationEvidence } from "./gsd-db.js";
 import { getWorkflowDatabasePath, refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
 import { renderPlanCheckboxes, renderRoadmapFromDb, roadmapRenderMarksSliceDone } from "./markdown-renderer.js";
-import { consumeSignal } from "./session-status-io.js";
+import { awaitWorkerResume, consumeSignal } from "./session-status-io.js";
 import {
   checkPostUnitHooks,
   consumeHookFailure,
@@ -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)."
@@ -1278,8 +1279,27 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
         return "dispatched";
       }
       if (signal.signal === "pause") {
-        await pauseAuto(ctx, pi);
-        return "dispatched";
+        // A worker `pause` is a *temporary* coordination request: the docs
+        // contract (docs/user-docs/parallel-orchestration.md) is "finish current
+        // unit, wait" followed by a matching `resume`. Only the interactive
+        // dashboard runtime owns a resumer — unattended `gsd headless auto` does
+        // not — so a terminal pauseAuto() here strands the worker at exit 10
+        // (BLOCKED) after its first unit, with nothing able to lift it (#1273).
+        // Wait for the coordinator to resume (or stop) us instead. If no resumer
+        // lifts the pause within the window, degrade to in-process serialization
+        // and continue the dispatch loop rather than halting the run forever.
+        const resumeOutcome = await awaitWorkerResume(s.basePath, milestoneLock);
+        if (resumeOutcome === "stop") {
+          await stopAuto(ctx, pi);
+          return "dispatched";
+        }
+        if (resumeOutcome === "timeout") {
+          logWarning(
+            "parallel",
+            `pause signal for ${milestoneLock} was not resumed (no headless resumer, #1273); continuing dispatch`,
+          );
+        }
+        // "resume" or "timeout": fall through and continue post-unit processing.
       }
     }
   }
@@ -2398,7 +2418,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);