@opengsd/gsd-pi 1.4.0 → 1.5.0-dev.4fb2d460

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

@@ -280,6 +280,15 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
                 files: leak.files.map((file) => ({ path: file.path, status: file.status })),
             });
             ctx.ui.notify(message, "error");
+            try {
+                deps.checkpointWorkflowDatabase?.();
+            }
+            catch (err) {
+                debugLog("autoLoop", {
+                    phase: "root-write-leak-checkpoint-failed",
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
             await deps.stopAuto(ctx, pi, "Root-write leak during isolated auto-mode", {
                 preserveCompletedMilestoneBranch: true,
             });

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

@@ -21,7 +21,8 @@ import { createWorktreeSafetyModule } from "../worktree-safety.js";
 import { repairAutoWorktreeSafetyFailure } from "../auto-worktree-repair.js";
 import { resolveManifest } from "../unit-context-manifest.js";
 import { preDispatchHealthGate, recordHealthSnapshot, } from "../doctor-proactive.js";
-import { checkResourcesStale, autoWorktreeBranch, mergeMilestoneToMain } from "../auto-worktree.js";
+import { autoWorktreeBranch } from "../auto-worktree-branch-lifecycle.js";
+import { checkResourcesStale } from "../auto-worktree-resource-version.js";
 import { getSessionLockStatus } from "../session-lock.js";
 import { resolveUokFlags } from "../uok/flags.js";
 import { emitJournalEvent as _emitJournalEvent } from "../journal.js";
@@ -31,7 +32,7 @@ import { getPriorSliceCompletionBlocker } from "../dispatch-guard.js";
 import { GitServiceImpl } from "../git-service.js";
 import { WorktreeStateProjection } from "../worktree-state-projection.js";
 import { WorktreeLifecycle } from "../worktree-lifecycle.js";
-import { createMilestoneMergeTransaction } from "../milestone-merge-transaction.js";
+import { createDefaultMilestoneMergeTransaction } from "../milestone-merge-transaction.js";
 import { createWorkspace, scopeMilestone } from "../workspace.js";
 import { supportsStructuredQuestions } from "../workflow-mcp.js";
 import { getRegisteredToolSnapshot, getToolBaselineSnapshot } from "../auto-model-selection.js";
@@ -560,7 +561,7 @@ export class AutoOrchestrator {
                 return new GitServiceImpl(basePath, gitConfig);
             },
             worktreeProjection: new WorktreeStateProjection(),
-            mergeMilestoneToMain: createMilestoneMergeTransaction(mergeMilestoneToMain),
+            mergeMilestone: createDefaultMilestoneMergeTransaction(),
         });
     }
     rebuildScope(rawPath, milestoneId) {

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

@@ -345,7 +345,8 @@ export async function runPreDispatch(ic, loopState) {
             if (stop)
                 return stop;
         }
-        // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
+        // PR creation (auto_pr) is handled by the publication handoff in
+        // the milestone merge transaction (#2302).
         deps.invalidateAllCaches();
         state = await deps.deriveState(s.canonicalProjectRoot);
         mid = state.activeMilestone?.id;
@@ -430,7 +431,8 @@ export async function runPreDispatch(ic, loopState) {
                 const stop = await _runMilestoneMergeOnceWithStashRestore(ic, s.currentMilestoneId);
                 if (stop)
                     return stop;
-                // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
+                // PR creation (auto_pr) is handled by the publication handoff in
+                // the milestone merge transaction (#2302).
             }
             const unmappedActive = countUnmappedActiveRequirements();
             const completionStopReason = formatCompletePhaseNextAction(unmappedActive);
@@ -506,7 +508,8 @@ export async function runPreDispatch(ic, loopState) {
             const stop = await _runMilestoneMergeOnceWithStashRestore(ic, s.currentMilestoneId);
             if (stop)
                 return stop;
-            // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
+            // PR creation (auto_pr) is handled by the publication handoff in
+            // the milestone merge transaction (#2302).
         }
         deps.sendDesktopNotification("GSD", `Milestone ${mid} complete!`, "success", "milestone", basename(s.originalBasePath || s.basePath));
         deps.logCmuxEvent(prefs, `Milestone ${mid} complete.`, "success");

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

@@ -6,7 +6,7 @@ import { debugLog } from "../debug-logger.js";
 import { logWarning } from "../workflow-logger.js";
 import { resolveAutoSupervisorConfig } from "../preferences.js";
 import { readUnitRuntimeRecord } from "../unit-runtime.js";
-import { consumeAutoWakeup } from "./schedule-wakeup.js";
+import { clearAutoWakeup, consumeAutoWakeup } from "./schedule-wakeup.js";
 import { applyUnitSkillVisibility } from "../skill-scope.js";
 const UNIT_FAILSAFE_BUFFER_MS = 30_000;
 const UNIT_FAILSAFE_RECHECK_MS = 30_000;
@@ -192,7 +192,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     const UNIT_HARD_TIMEOUT_MS = Math.max(UNIT_FAILSAFE_BUFFER_MS, ((supervisor.hard_timeout_minutes ?? 30) * 60 * 1000) + UNIT_FAILSAFE_BUFFER_MS);
     const freshProgressMs = Math.max(UNIT_FAILSAFE_BUFFER_MS, ((supervisor.idle_timeout_minutes ?? 10) * 60 * 1000) + UNIT_FAILSAFE_BUFFER_MS);
     let unitTimeoutHandle;
-    let result;
+    let result = { status: "cancelled" };
     try {
         const awaitAgentEndWithTimeout = (agentEndPromise) => {
             const timeoutResult = new Promise((resolve) => {
@@ -297,6 +297,9 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     finally {
         if (unitTimeoutHandle)
             clearTimeout(unitTimeoutHandle);
+        if (result.status !== "completed") {
+            clearAutoWakeup(s.basePath, unitType, unitId);
+        }
         ctx.ui.setWorkingMessage?.(undefined);
         setVisibleSkills?.(undefined);
     }

package/dist/resources/extensions/gsd/auto/schedule-wakeup.js

@@ -13,6 +13,9 @@ export function consumeAutoWakeup(basePath, unitType, unitId) {
     pendingWakeups.delete(key);
     return wakeup;
 }
+export function clearAutoWakeup(basePath, unitType, unitId) {
+    pendingWakeups.delete(wakeupKey(basePath, unitType, unitId));
+}
 export function _resetAutoWakeupsForTest() {
     pendingWakeups.clear();
 }

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

@@ -17,7 +17,7 @@ import { isDbAvailable, getTask } from "../gsd-db.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, floorThinkingLevelForUnit, } from "../auto-model-selection.js";
 import { isSuspiciousGhostCompletion } from "../auto-unit-closeout.js";
@@ -246,17 +246,13 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     s.currentDispatchedModelId = s.currentUnitModel
         ? `${s.currentUnitModel.provider ?? ""}/${s.currentUnitModel.id ?? ""}`
         : null;
-    const compatibilityError = getUnitWorkflowDispatchReadinessError({
-        provider: s.currentUnitModel?.provider ?? ctx.model?.provider,
+    const compatibilityError = getUnitWorkflowDispatchReadinessErrorForModel({
+        model: s.currentUnitModel,
+        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?.baseUrl ?? ctx.model?.baseUrl,
         activeTools: typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [],
     });
     const workflowMcpPrepModel = s.currentUnitModel;

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

@@ -8,7 +8,7 @@
 import { gsdRoot, resolveDir, resolveFile, resolveMilestonePath, resolveMilestoneFile, resolveSliceFile, relMilestoneFile, relSliceFile, buildTaskFileName, resolveSlicePath, resolveTasksDir, dirIsMetaOnlyLegacyMilestone, } 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");

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

@@ -7,10 +7,10 @@ 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 { getUnitWorkflowDispatchReadinessError } from "./tool-contract.js";
+import { getUnitWorkflowDispatchReadinessErrorForModel } from "./tool-contract.js";
 export function parseDirectDispatchPhase(raw) {
     const tokens = raw.trim().split(/\s+/).filter(Boolean);
     if (tokens.length === 0)
@@ -213,13 +213,12 @@ export async function dispatchDirectPhase(ctx, pi, phase, base, opts = {}) {
             ctx.ui.notify(`Unknown phase "${phase}". Valid phases: research, plan, execute, complete, validate, reassess, uat, replan.`, "warning");
             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) {
@@ -232,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";
@@ -596,7 +597,7 @@ export const DISPATCH_RULES = [
         },
     },
     {
-        name: "uat-verdict-gate (non-PASS blocks progression)",
+        name: "uat-verdict-gate (non-PASS observed; closeout enforces)",
         match: async ({ mid, basePath, prefs }) => {
             // Only applies when UAT dispatch is enabled
             if (!prefs?.uat_dispatch)
@@ -611,9 +612,9 @@ export const DISPATCH_RULES = [
                     continue;
                 const { verdict, uatType } = result;
                 if (!isAcceptableUatVerdict(verdict, uatType)) {
-                    // Do not hard-stop auto-mode on non-PASS verdicts. Allow progression
-                    // so follow-up slices can remediate, while complete-milestone still
-                    // enforces manual UAT PASS sign-off before closure.
+                    // Observe non-PASS verdicts without hard-stopping auto-mode. Allow
+                    // progression so follow-up slices can remediate, while
+                    // complete-milestone still enforces manual UAT PASS sign-off before closure.
                     continue;
                 }
             }
@@ -902,9 +903,19 @@ export const DISPATCH_RULES = [
             const sliceContextFile = resolveSliceFile(basePath, mid, state.activeSlice.id, "CONTEXT");
             if (sliceContextFile && existsSync(sliceContextFile))
                 return null; // discussion already done, proceed
+            const closedSliceIds = getClosedSliceIds(mid);
+            const justClosedSliceId = closedSliceIds[closedSliceIds.length - 1];
+            let priorVerdictWarning = "";
+            if (justClosedSliceId) {
+                const prior = await readUatGateVerdict(basePath, mid, justClosedSliceId);
+                if (prior && !isAcceptableUatVerdict(prior.verdict, prior.uatType)) {
+                    priorVerdictWarning =
+                        ` Note: the slice just closed (${justClosedSliceId}) recorded a non-PASS UAT verdict (${prior.verdict.toUpperCase()}); review before continuing.`;
+                }
+            }
             return {
                 action: "stop",
-                reason: `Slice ${state.activeSlice.id} requires discussion before planning (require_slice_discussion is enabled). Run /gsd discuss to discuss this slice, then /gsd auto to resume.`,
+                reason: `Slice ${state.activeSlice.id} requires discussion before planning (require_slice_discussion is enabled). Run /gsd discuss to discuss this slice, then /gsd auto to resume.${priorVerdictWarning}`,
                 level: "warning",
             };
         },
@@ -1490,6 +1501,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,
@@ -1541,7 +1565,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
@@ -1562,7 +1586,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

@@ -326,7 +326,7 @@ export function floorThinkingLevelForUnit(unitType, level) {
     return EXECUTE_TASK_MIN_THINKING_LEVEL;
 }
 export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode = true, basePath, availableModelIds, preferredModelId) {
-    const explicitConfig = resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds, preferredModelId);
+    const explicitConfig = resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds, preferredModelId, true);
     if (explicitConfig) {
         return {
             ...explicitConfig,
@@ -338,23 +338,45 @@ export function resolvePreferredModelConfig(unitType, autoModeStartModel, isAuto
     if (!isAutoMode)
         return undefined;
     const routingConfig = resolveDynamicRoutingConfig();
-    if (!routingConfig.enabled || !routingConfig.tier_models)
+    if (!routingConfig.enabled)
         return undefined;
-    // Don't synthesize a routing config for flat-rate providers (#3453).
-    // 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 &&
+    // Only an explicit flat-rate opt-out suppresses synthesized routing.
+    // `dynamic_routing.enabled: true` is user intent to run routing even when
+    // the start provider is a flat-rate subscription. Applied ahead of both the
+    // tier-pin and profile-derived synthesis paths so the opt-out is uniform.
+    if (routingConfig.allow_flat_rate_providers === false &&
         autoModeStartModel &&
         isFlatRateProvider(autoModeStartModel.provider, autoModeStartModel.flatRateCtx)) {
         return undefined;
     }
-    const ceilingModel = routingConfig.tier_models.heavy
-        ?? (autoModeStartModel ? `${autoModeStartModel.provider}/${autoModeStartModel.id}` : undefined);
-    if (!ceilingModel)
+    // With explicit `tier_models` pins, synthesize a heavy-tier ceiling that
+    // dynamic routing downgrades from per unit.
+    if (routingConfig.tier_models) {
+        const ceilingModel = routingConfig.tier_models.heavy
+            ?? (autoModeStartModel ? `${autoModeStartModel.provider}/${autoModeStartModel.id}` : undefined);
+        if (!ceilingModel)
+            return undefined;
+        return {
+            primary: ceilingModel,
+            fallbacks: [],
+            source: "synthesized",
+        };
+    }
+    // No `tier_models` pins: fall back to the token-profile's per-phase model so
+    // profile tier resolution survives. `skipProfileDefaults` is left false here
+    // (unlike the explicit-detection call above) precisely because we WANT the
+    // profile defaults this time — they are the routing ceiling, not a hard
+    // user selection. Labeling the result `synthesized` (not `explicit`) keeps
+    // dynamic routing and fallbacks enabled downstream. Without this branch,
+    // `resolvePreferredModelConfig` returns undefined for profile-only configs
+    // and auto dispatch bleeds the start model onto every unit, silently
+    // discarding the profile (#1115: routing/fallbacks disabled when a
+    // token_profile is set but no tier_models are pinned).
+    const profileConfig = resolveModelWithFallbacksForUnit(unitType, basePath, availableModelIds, preferredModelId, false);
+    if (!profileConfig)
         return undefined;
     return {
-        primary: ceilingModel,
-        fallbacks: [],
+        ...profileConfig,
         source: "synthesized",
     };
 }
@@ -510,15 +532,11 @@ autoModeStartThinkingLevel) {
                 ]));
             }
         }
-        // Disable routing for flat-rate providers like GitHub Copilot (#3453).
-        // All models cost the same per request, so downgrading to a cheaper
-        // model provides no cost benefit — it only degrades quality.
+        // Disable routing for flat-rate providers only when the user explicitly
+        // opts out with dynamic_routing.allow_flat_rate_providers: false.
         // Fail-closed: if primary model can't be resolved, fall back to
         // provider-level signals rather than allowing unwanted downgrades.
-        // 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) {
+        if (routingConfig.enabled && routingConfig.allow_flat_rate_providers === false) {
             const primaryModel = resolveModelId(modelConfig.primary, routingEligibleModels, ctx.model?.provider);
             if (primaryModel) {
                 const primaryFlatRateCtx = buildFlatRateContext(primaryModel.provider, ctx, prefs);

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

@@ -12,12 +12,13 @@ import { hasVerdict, extractVerdict } from "./verdict-parser.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
 import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, relTaskFile, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile, } from "./paths.js";
 import { resolveInlineLevel, loadEffectiveGSDPreferences } from "./preferences.js";
+import { createRepositoryRegistryFromPreferences } from "./repository-registry.js";
 import { isContextModeEnabled } from "./preferences-types.js";
 import { parseRoadmap } from "./parsers-legacy.js";
-import { join } from "node:path";
+import { join, relative, sep } from "node:path";
 import { existsSync } from "node:fs";
 import { computeBudgets, resolveExecutorContextWindow, truncateAtSectionBoundary } from "./context-budget.js";
-import { getPendingGatesForTurn } from "./gsd-db.js";
+import { getGateResults, getPendingGatesForTurn } from "./gsd-db.js";
 import { assertGateCoverage, getGatesForTurn, } from "./gate-registry.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
 import { readPhaseAnchor, formatAnchorForPrompt } from "./phase-anchor.js";
@@ -295,6 +296,37 @@ function formatExecutorConstraints(sessionContextWindow, modelRegistry, sessionP
         `- Keep individual tasks completable within a single context window — if a task needs more context than fits, split it`,
     ].join("\n");
 }
+/**
+ * Builds the Declared Repositories block for parent-workspace planners.
+ * Returns "" for single-repo projects so the common-case prompt is unchanged;
+ * only parent mode with declared child repos gets the registry list and the
+ * targetRepositories assignment instruction.
+ */
+export function buildRepoRegistryBlock(base) {
+    let registry;
+    try {
+        registry = createRepositoryRegistryFromPreferences(base, loadEffectiveGSDPreferences(base)?.preferences);
+    }
+    catch {
+        return "";
+    }
+    const hasChildRepo = registry.repositories.some((repo) => repo.id !== "project");
+    if (registry.mode !== "parent" || !hasChildRepo)
+        return "";
+    const lines = registry.repositories.map((repo) => {
+        const relPath = relative(registry.projectRoot, repo.root).split(sep).join("/") || ".";
+        const role = repo.role ? ` — ${repo.role}` : "";
+        const root = repo.id === "project" ? " (root)" : ` (${relPath})`;
+        return `- \`${repo.id}\`${root}${role}`;
+    });
+    return [
+        "### Declared Repositories",
+        "",
+        ...lines,
+        "",
+        "This is a parent workspace. Assign each task's `targetRepositories` to the repository id(s) it touches (from the list above). Omit `targetRepositories` to inherit the slice-wide default from `gsd_plan_slice`; set it explicitly when a task differs (e.g. `[\"project\"]` for parent-root work).",
+    ].join("\n");
+}
 /**
  * Returns a markdown bullet list of known context file paths for the given
  * milestone (and optionally slice). Falls back to a generic tool-agnostic
@@ -2174,6 +2206,7 @@ async function renderSlicePrompt(options) {
         inlinedContext,
         dependencySummaries: depContent,
         sourceFilePaths: buildSourceFilePaths(base, mid, sid),
+        repoRegistry: buildRepoRegistryBlock(base),
         executorContextConstraints,
         commitInstruction,
         skillActivation: buildSkillActivationBlock({
@@ -2906,6 +2939,47 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
         inlined.push(outstandingBlock);
         trackPromptContext(contextTelemetry, "outstanding-items", "inline", outstandingBlock);
     }
+    const persistedGateFlags = [];
+    try {
+        const gateLabels = {
+            Q3: "Threat Surface",
+            Q4: "Requirement Impact",
+        };
+        for (const sid of seenValSlices) {
+            for (const gate of getGateResults(mid, sid, "slice")) {
+                if (gate.gate_id !== "Q3" && gate.gate_id !== "Q4")
+                    continue;
+                const findings = gate.findings.trim();
+                const rationale = gate.rationale.trim();
+                const verdict = gate.verdict ?? "";
+                const hasNonPassVerdict = verdict !== "" && verdict !== "pass" && verdict !== "omitted";
+                if (!findings && !hasNonPassVerdict)
+                    continue;
+                const displayVerdict = verdict || gate.status;
+                const detail = findings || rationale || "_No findings text recorded; reconcile the persisted non-pass verdict._";
+                persistedGateFlags.push(`- **${sid} / ${gate.gate_id} (${gateLabels[gate.gate_id]}) / ${displayVerdict}:** ${detail}`);
+                if (findings && rationale)
+                    persistedGateFlags.push(`  - Rationale: ${rationale}`);
+            }
+        }
+    }
+    catch (err) {
+        logWarning("prompt", `buildValidateMilestonePrompt persisted gate flags lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (persistedGateFlags.length > 0) {
+        const persistedGateFlagsBlock = [
+            "### Persisted Slice-Level Gate Flags (from quality_gates)",
+            "",
+            "These slice gates recorded findings or non-pass verdicts during execution. Reconcile each against the milestone-level evidence before returning MV03/MV04 verdicts.",
+            "",
+            ...persistedGateFlags,
+        ].join("\n");
+        inlined.push(persistedGateFlagsBlock);
+        trackPromptContext(contextTelemetry, "persisted-slice-gate-flags", "inline", persistedGateFlagsBlock);
+    }
+    else {
+        trackPromptContext(contextTelemetry, "persisted-slice-gate-flags", "skipped", null, "none");
+    }
     // Inline existing VALIDATION file if this is a re-validation round
     const validationPath = resolveMilestoneFile(base, mid, "VALIDATION");
     const validationRel = relMilestoneFile(base, mid, "VALIDATION");

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

@@ -149,12 +149,56 @@ export function refreshRecoveryDbForArtifact(unitType, unitId, basePath) {
         };
     }
     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 };
 }

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

@@ -27,9 +27,10 @@ import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
 import { nativeIsRepo, nativeInit, nativeAddAll, nativeCommit, nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchList, nativeBranchExists, nativeBranchListMerged, nativeBranchDelete, nativeWorktreeRemove, nativeCommitCountBetween, nativeHasChanges, } from "./native-git-bridge.js";
 import { GitServiceImpl } from "./git-service.js";
 import { captureIntegrationBranch, detectWorktreeName, setActiveMilestoneId, } from "./worktree.js";
-import { getAutoWorktreePath } from "./auto-worktree.js";
+import { getAutoWorktreePath } from "./auto-worktree-path-resolution.js";
 import { checkoutBranchWithStashGuard } from "./worktree-git-recovery.js";
-import { readResourceVersion, cleanStaleRuntimeUnits } from "./auto-worktree.js";
+import { cleanStaleRuntimeUnits } from "./auto-worktree-runtime-cleanup.js";
+import { readResourceVersion } from "./auto-worktree-resource-version.js";
 import { worktreePath as getWorktreeDir, isInsideWorktreesDir } from "./worktree-manager.js";
 import { emitWorktreeOrphaned } from "./worktree-telemetry.js";
 import { queryJournal } from "./journal.js";
@@ -1409,7 +1410,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         }
         // Snapshot installed skills
         if (resolveSkillDiscoveryMode(base) !== "off") {
-            snapshotSkills();
+            snapshotSkills({ cwd: s.basePath });
         }
         setAutoActiveStatus(ctx, s.stepMode ? "next" : "auto");
         ctx.ui.setWidget("gsd-health", undefined);
@@ -1435,15 +1436,16 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             ? `${s.autoModeStartModel.provider}/${s.autoModeStartModel.id}`
             : ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "default";
         // Flat-rate providers (e.g. GitHub Copilot, claude-code, user-declared
-        // subscription proxies, externalCli CLIs) suppress routing at dispatch
-        // time (#3453) — reflect that in the banner.  Thread the same
+        // subscription proxies, externalCli CLIs) suppress routing only when the
+        // user explicitly opts out with allow_flat_rate_providers: false. Reflect
+        // that in the banner. Thread the same
         // FlatRateContext used by selectAndApplyModel so user-declared
         // flat-rate providers and externalCli auto-detection are respected.
         const { isFlatRateProvider, buildFlatRateContext } = await import("./auto-model-selection.js");
         const bannerPrefs = loadEffectiveGSDPreferencesWithRegistry(ctx.modelRegistry, base, resolveProfileAnchorProvider(ctx.model?.provider, s.autoModeStartModel?.provider), s.autoModeStartModel ? `${s.autoModeStartModel.provider}/${s.autoModeStartModel.id}` : undefined)?.preferences;
         const effectiveProvider = s.autoModeStartModel?.provider ?? ctx.model?.provider;
         const effectivelyEnabled = routingConfig.enabled
-            && (routingConfig.allow_flat_rate_providers
+            && (routingConfig.allow_flat_rate_providers !== false
                 || !(effectiveProvider && isFlatRateProvider(effectiveProvider, buildFlatRateContext(effectiveProvider, ctx, bannerPrefs))));
         // The actual ceiling may come from tier_models.heavy, not the start model.
         const effectiveCeiling = (routingConfig.enabled && routingConfig.tier_models?.heavy)

package/dist/resources/extensions/gsd/auto-timeout-recovery.js

@@ -56,6 +56,8 @@ export async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rct
                 lastProgressAt: Date.now(),
                 progressCount: (runtime?.progressCount ?? 0) + 1,
                 lastProgressKind: reason === "idle" ? "idle-recovery-retry" : "hard-recovery-retry",
+                // This steering retry is a fresh chance for the same unit to save a valid result.
+                harnessAbort: undefined,
             });
             const steeringLines = isEscalation
                 ? [
@@ -151,6 +153,8 @@ export async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rct
             lastProgressAt: Date.now(),
             progressCount: (runtime?.progressCount ?? 0) + 1,
             lastProgressKind: reason === "idle" ? "idle-recovery-retry" : "hard-recovery-retry",
+            // This steering retry is a fresh chance for the same unit to save a valid result.
+            harnessAbort: undefined,
         });
         const steeringLines = isEscalation
             ? [