@opengsd/gsd-pi 1.5.0-dev.553dc518 → 1.5.0-dev.c4c8885f

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-be3c5dc39486dc24
+d89940a8e727f2ea

package/dist/resources/extensions/ask-user-questions.js

@@ -209,7 +209,7 @@ export default function AskUserQuestions(pi) {
             "For single-select: each question must have 2-3 options. Put the recommended option first with '(Recommended)' suffix. Do not include an 'Other' or 'None of the above' option - the client adds one automatically.",
             "For multi-select: set allowMultiple: true. The user can pick any number of options. No 'None of the above' is added.",
             "When options involve code patterns, config choices, or architecture decisions, add a 'preview' field with markdown content (code blocks, lists, headers, etc.). The preview renders in a side-by-side panel when the option is highlighted.",
-            "Preview content is rendered in a fixed-height panel (max ~20 lines visible). Keep previews concise — show the most relevant snippet, not exhaustive examples. Longer content is truncated with a '+N lines hidden' indicator.",
+            "Preview content is rendered in a fixed-height panel (max ~20 lines visible). Keep previews concise — show the most relevant snippet, not exhaustive examples. Longer content stays fully accessible: the user scrolls it with PgUp/PgDn, with '▲/▼ N more' indicators marking hidden rows.",
         ],
         parameters: AskUserQuestionsParams,
         async execute(_toolCallId, params, signal, _onUpdate, ctx) {

package/dist/resources/extensions/browser-tools/engine/managed-gsd-browser.js

@@ -4,8 +4,6 @@ import { Type } from "@sinclair/typebox";
 import { BROWSER_CONTRACT_TOOL_NAMES } from "../../shared/browser-contract.js";
 import { resolveGsdBrowserMcpLaunchConfig } from "../../shared/gsd-browser-cli.js";
 import { buildMcpChildEnv } from "../../mcp-client/manager.js";
-const connections = new Map();
-const pendingConnections = new Map();
 const DEFAULT_MAX_LINES = 2_000;
 const DEFAULT_MAX_BYTES = 50 * 1024;
 const MCP_CALL_TIMEOUT_MS = 60_000;
@@ -297,6 +295,103 @@ function buildConnectionKey(launch) {
         env: launch.env ?? {},
     });
 }
+function combineAbortSignals(poolSignal, callerSignal) {
+    if (!callerSignal)
+        return poolSignal;
+    if (typeof AbortSignal.any === "function") {
+        return AbortSignal.any([poolSignal, callerSignal]);
+    }
+    const controller = new AbortController();
+    const abort = () => {
+        if (!controller.signal.aborted)
+            controller.abort();
+    };
+    if (poolSignal.aborted || callerSignal.aborted) {
+        abort();
+    }
+    else {
+        poolSignal.addEventListener("abort", abort, { once: true });
+        callerSignal.addEventListener("abort", abort, { once: true });
+    }
+    return controller.signal;
+}
+export class ManagedGsdBrowserConnectionPool {
+    connections = new Map();
+    pendingConnections = new Map();
+    connect;
+    closeConnection;
+    generation = 0;
+    closing = false;
+    constructor(connect, closeConnection) {
+        this.connect = connect;
+        this.closeConnection = closeConnection;
+    }
+    get activeCount() {
+        return this.connections.size;
+    }
+    get pendingCount() {
+        return this.pendingConnections.size;
+    }
+    getOrConnect(launch, signal) {
+        if (this.closing) {
+            return Promise.reject(new Error("gsd-browser connection pool is closing"));
+        }
+        const key = buildConnectionKey(launch);
+        const existing = this.connections.get(key);
+        if (existing)
+            return Promise.resolve(existing);
+        const pending = this.pendingConnections.get(key);
+        if (pending)
+            return pending.promise;
+        const generation = this.generation;
+        const abortController = new AbortController();
+        const connectionSignal = combineAbortSignals(abortController.signal, signal);
+        const connectionPromise = this.connect(launch, connectionSignal)
+            .then(async (connection) => {
+            if (this.closing || this.generation !== generation) {
+                await this.closeConnection(connection);
+                throw new Error("gsd-browser connection closed during startup");
+            }
+            this.connections.set(key, connection);
+            return connection;
+        })
+            .finally(() => {
+            if (this.pendingConnections.get(key)?.promise === connectionPromise) {
+                this.pendingConnections.delete(key);
+            }
+        });
+        this.pendingConnections.set(key, { promise: connectionPromise, abortController });
+        return connectionPromise;
+    }
+    async closeAll() {
+        this.closing = true;
+        this.generation += 1;
+        const activeConnections = Array.from(this.connections.values());
+        const pendingConnections = Array.from(this.pendingConnections.values());
+        this.connections.clear();
+        this.pendingConnections.clear();
+        for (const pending of pendingConnections) {
+            pending.abortController.abort();
+        }
+        const closingActive = activeConnections.map((connection) => this.closeConnection(connection));
+        const closingPending = pendingConnections.map(async (pending) => {
+            try {
+                const connection = await pending.promise;
+                await this.closeConnection(connection);
+            }
+            catch {
+                // Failed or invalidated connection attempts have already cleaned up.
+            }
+        });
+        try {
+            await Promise.allSettled([...closingActive, ...closingPending]);
+        }
+        finally {
+            this.closing = false;
+            this.generation += 1;
+        }
+    }
+}
 async function connectManagedGsdBrowser(launch, signal) {
     const client = new Client({ name: "gsd-pi-browser-tools", version: "1.0.0" });
     const transport = new StdioClientTransport({
@@ -326,27 +421,26 @@ async function connectManagedGsdBrowser(launch, signal) {
         throw error;
     }
 }
+async function closeManagedGsdBrowserConnection(connection) {
+    try {
+        await connection.client.close();
+    }
+    catch {
+        // Best-effort cleanup.
+    }
+    try {
+        await connection.transport.close();
+    }
+    catch {
+        // Best-effort cleanup.
+    }
+}
+const connectionPool = new ManagedGsdBrowserConnectionPool(connectManagedGsdBrowser, closeManagedGsdBrowserConnection);
 async function getOrConnectManagedGsdBrowser(ctx, signal) {
     const launch = resolveGsdBrowserMcpLaunchConfig(resolveProjectRoot(ctx), process.env, {
         sessionSuffix: resolveManagedSessionSuffix(ctx),
     });
-    const key = buildConnectionKey(launch);
-    const existing = connections.get(key);
-    if (existing)
-        return existing;
-    const pending = pendingConnections.get(key);
-    if (pending)
-        return pending;
-    const connectionPromise = connectManagedGsdBrowser(launch, signal);
-    pendingConnections.set(key, connectionPromise);
-    try {
-        const connection = await connectionPromise;
-        connections.set(key, connection);
-        return connection;
-    }
-    finally {
-        pendingConnections.delete(key);
-    }
+    return connectionPool.getOrConnect(launch, signal);
 }
 function isUnknownMcpToolError(error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -609,23 +703,7 @@ export function registerManagedGsdBrowserTools(pi) {
     }
 }
 export async function closeManagedGsdBrowser() {
-    const closing = Array.from(connections.entries()).map(async ([key, connection]) => {
-        try {
-            await connection.client.close();
-        }
-        catch {
-            // Best-effort cleanup.
-        }
-        try {
-            await connection.transport.close();
-        }
-        catch {
-            // Best-effort cleanup.
-        }
-        connections.delete(key);
-    });
-    await Promise.allSettled(closing);
-    pendingConnections.clear();
+    await connectionPool.closeAll();
 }
 export async function _resetManagedGsdBrowserForTest() {
     await closeManagedGsdBrowser();

package/dist/resources/extensions/gsd/activity-log.js

@@ -115,7 +115,7 @@ export function saveActivityLog(ctx, basePath, unitType, unitId) {
         }
         state.nextSeq += 1;
         state.lastSnapshotKeyByUnit.set(unitKey, key);
-        if (isUnifiedAuditEnabled()) {
+        if (isUnifiedAuditEnabled(basePath)) {
             emitUokAuditEvent(basePath, buildAuditEnvelope({
                 traceId: `activity:${unitType}:${unitId}`,
                 turnId: unitId,

package/dist/resources/extensions/gsd/auto/orchestrator.js

@@ -999,16 +999,22 @@ export class AutoOrchestrator {
                 this.postAdvanceRecord(skipped);
                 return skipped;
             }
-            // Stuck-loop detection: when the window is saturated with copies of
-            // `nextKey` (count >= STUCK_WINDOW_SIZE), consult the Dispatch History
-            // module's full detect-stuck rule set for the verdict instead of the old
-            // bare saturation count. This keeps the saturation threshold (the window
-            // deliberately records benign idempotent repeats, so earlier-firing
-            // rules would false-positive on pause/resume re-advances) while gaining
-            // retry-budget suppression and diagnosable rule reasons. A saturated
-            // window with no verdict means the dispatch ledger says we are inside
-            // the unit's retry-backoff budget — let the retry proceed.
-            const stuckVerdict = matchingCount >= STUCK_WINDOW_SIZE ? this.dispatchHistory.detectStuck() : null;
+            // Stuck-loop detection: consult the Dispatch History module's full
+            // detect-stuck rule set once the window is *full* — not only when a
+            // single key saturates it. Gating on a single key's saturation count
+            // (matchingCount >= STUCK_WINDOW_SIZE) let two-unit oscillations slip
+            // through forever: an execute-task ↔ complete-slice loop (a slice gate
+            // that keeps reopening the same task, #1225) fills the window with two
+            // alternating keys, so neither key ever reaches the saturation count and
+            // detect-stuck's oscillation/repeat rules were never even invoked. Firing
+            // on window saturation instead covers both shapes. Consecutive same-key
+            // re-advances (the benign pause/resume churn the old count gate guarded
+            // against) are already short-circuited above by the idempotency skip, and
+            // legitimate retry backoff is still suppressed inside detect-stuck via the
+            // dispatch ledger — a saturated window with no verdict means we are inside
+            // the unit's retry-backoff budget, so let the retry proceed.
+            const windowSaturated = this.dispatchHistory.getRecentWindow().length >= STUCK_WINDOW_SIZE;
+            const stuckVerdict = windowSaturated ? this.dispatchHistory.detectStuck() : null;
             if (stuckVerdict) {
                 // #442: before declaring a stuck loop, verify the unit didn't actually
                 // complete on disk (stale DB) and recover if so — legacy graduated

package/dist/resources/extensions/gsd/auto-artifact-paths.js

@@ -5,10 +5,10 @@
 // resolveExpectedArtifactPath and diagnoseExpectedArtifact moved here from
 // auto-recovery.ts (Phase 5 dead-code cleanup). The artifact verification
 // function was removed entirely — callers now query WorkflowEngine directly.
-import { gsdRoot, resolveDir, resolveFile, resolveMilestonePath, resolveMilestoneFile, resolveSliceFile, relMilestoneFile, relSliceFile, buildTaskFileName, resolveSlicePath, resolveTasksDir, dirIsMetaOnlyLegacyMilestone, } from "./paths.js";
+import { gsdRoot, resolveDir, resolveFile, resolveMilestonePath, resolveMilestoneFile, resolveSliceFile, relMilestoneFile, relSliceFile, buildTaskFileName, 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(base, mid, suffix) {
     const existing = resolveProjectedMilestoneFile(base, mid, suffix) ?? resolveProjectMilestoneFile(base, mid, suffix);
@@ -193,8 +193,17 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
                 ?? 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");
@@ -299,7 +308,7 @@ export function resolveSliceResearchLocation(basePath, mid, sid) {
     if (canonicalPath && existsSync(canonicalPath)) {
         return {
             absolutePath: canonicalPath,
-            relativePath: relative(basePath, canonicalPath),
+            relativePath: relative(normalizeRealPath(basePath), canonicalPath),
         };
     }
     return { absolutePath: null, relativePath: null };

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

@@ -7,7 +7,7 @@ import { loadFile } from "./files.js";
 import { isDbAvailable, getClosedSliceIds } from "./gsd-db.js";
 import { resolveSliceFile, relSliceFile, } from "./paths.js";
 import { buildResearchSlicePrompt, buildResearchMilestonePrompt, buildPlanSlicePrompt, buildPlanMilestonePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReassessRoadmapPrompt, buildRunUatPrompt, buildReplanSlicePrompt, } from "./auto-prompts.js";
-import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { loadEffectiveGSDPreferences, renderLanguageDirectiveForPrompt } from "./preferences.js";
 import { pauseAuto } from "./auto.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 import { getUnitWorkflowDispatchReadinessErrorForModel } from "./tool-contract.js";
@@ -231,5 +231,10 @@ export async function dispatchDirectPhase(ctx, pi, phase, base, opts = {}) {
         ctx.ui.notify("Session creation cancelled.", "warning");
         return;
     }
-    pi.sendMessage({ customType: "gsd-dispatch", content: prompt, display: false }, { triggerTurn: true });
+    // 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: dispatchContent, display: false }, { triggerTurn: true });
 }

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

@@ -1,5 +1,6 @@
 // Project/App: gsd-pi
 // File Purpose: Declarative auto-mode dispatch rules and dispatch resolver.
+import { renderLanguageDirectiveForPrompt } from "./preferences.js";
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
 import { getUatBrowserToolSupportError } from "./uat-policy.js";
 import { isDbAvailable, getMilestoneSlices, getMilestoneSliceSummaries, getClosedSliceIds, getPendingGatesForTurn, markPendingGatesOmittedForTurn, getMilestone, insertArtifact, insertAssessment, setSliceSketchFlag, transaction, getAssessment, getSliceRunUatAssessment, } from "./gsd-db.js";
@@ -11,8 +12,9 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, readdir
 import { logWarning, logError } from "./workflow-logger.js";
 import { dirname, join, sep } from "node:path";
 import { hasImplementationArtifacts } from "./milestone-implementation-evidence.js";
-import { buildDiscussMilestonePrompt, buildDiscussProjectPrompt, buildDiscussRequirementsPrompt, buildResearchDecisionPrompt, buildResearchProjectPrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildRefineSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, buildParallelResearchSlicesPrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
-import { resolveModelWithFallbacksForUnit, resolveThinkingLevelForUnit } from "./preferences-models.js";
+import { buildDiscussMilestonePrompt, buildDiscussProjectPrompt, buildDiscussRequirementsPrompt, buildResearchDecisionPrompt, buildResearchProjectPrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildRefineSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, buildParallelResearchSlicesPrompt, checkNeedsReassessment, loadRoadmapCompletedSliceCandidates, } from "./auto-prompts.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";
@@ -141,12 +143,21 @@ export async function readUatGateVerdict(basePath, mid, sliceId) {
         if (assessmentScope === "roadmap") {
             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),
+                };
+            }
         }
     }
     if (uatContent) {
@@ -290,11 +301,20 @@ function stringField(row, key) {
 function stripGsdPrefix(path) {
     return path.startsWith(".gsd/") ? path.slice(".gsd/".length) : path;
 }
-function persistSliceAssessmentBackfill(assessmentRelPath, mid, sliceId, content) {
+// 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, mid, sliceId, content, fabricated) {
     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";
@@ -342,18 +362,24 @@ function backfillMissingAssessmentsFromSummaries(basePath, mid) {
             "---",
             `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.message}`);
@@ -533,7 +559,7 @@ export const DISPATCH_RULES = [
     {
         name: "run-uat (post-completion)",
         match: async ({ state, mid, basePath, prefs, sessionProvider, sessionAuthMode, activeTools, 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;
@@ -1167,8 +1193,15 @@ export const DISPATCH_RULES = [
             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
@@ -1228,7 +1261,13 @@ export const DISPATCH_RULES = [
                     action: "dispatch",
                     unitType: "reactive-execute",
                     unitId: `${mid}/${sid}/reactive+${batchSuffix}`,
-                    prompt: await buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, selected, basePath, subagentModel, { sessionContextWindow, modelRegistry, sessionProvider, subagentThinking }),
+                    prompt: await buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, selected, basePath, subagentModel, {
+                        sessionContextWindow,
+                        modelRegistry,
+                        sessionProvider,
+                        subagentThinking,
+                        subagentModelFallbacks: subagentModelConfig?.fallbacks,
+                    }),
                 };
             }
             catch (err) {
@@ -1500,6 +1539,19 @@ export const DISPATCH_RULES = [
     },
 ];
 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, prefs) {
+    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 ─────────────────────────────────────────────────────────────
 /**
  * Evaluate dispatch rules in order. Returns the first matching action,
@@ -1551,7 +1603,7 @@ export async function resolveDispatch(ctx) {
                 level: "error",
             };
         }
-        return action;
+        return applyLanguageDirectiveToDispatch(action, ctx.prefs);
     }
     catch (err) {
         // Registry not initialized — fall back to inline loop
@@ -1572,7 +1624,7 @@ export async function resolveDispatch(ctx) {
                     matchedRule: rule.name,
                 };
             }
-            return action;
+            return applyLanguageDirectiveToDispatch(action, ctx.prefs);
         }
     }
     // No rule matched — unhandled phase.

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

@@ -219,10 +219,37 @@ function buildModelPolicyBlockReasons(policyDenyReasons, availableModels, routin
             reason: `configured model(s) did not resolve against policy-eligible registry [${eligibleSummary}]`,
         }];
 }
-function isModelUnavailable(basePath, provider, id) {
+export function isModelUnavailable(basePath, provider, id) {
     return isModelBlocked(basePath, provider, id) ||
         isModelTemporarilyUnavailable(basePath, provider, id);
 }
+/** Apply `auto_supervisor.model`, walking configured fallbacks on unavailability (#1229). */
+export async function applySupervisorModelIfConfigured(ctx, pi, basePath) {
+    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) {
     const key = pi;
     const baseline = TOOL_BASELINE.get(key);

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

@@ -17,7 +17,7 @@ import { logWarning, logError } from "./workflow-logger.js";
 import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { isAwaitingUserInput } from "./consent-question.js";
-import { resolveSliceFile, resolveSlicePath, relSlicePath, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, resolveFile, relMilestoneFile, relSliceFile, relTaskFile, } from "./paths.js";
+import { resolveSliceFile, resolveSlicePath, relSlicePath, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, resolveFile, relMilestoneFile, relSliceFile, relTaskFile, normalizeRealPath, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { rebuildState } from "./doctor.js";
 import { parseUnitId } from "./unit-id.js";
@@ -770,7 +770,7 @@ function describeArtifactVerificationFailure(unitType, unitId, basePath, agentEn
     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)."
@@ -1987,7 +1987,8 @@ export async function postUnitPostVerification(pctx) {
             persistHookState(s.basePath);
             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}:` +
+            const message = `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);