@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.8e6112e9

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

@@ -25,7 +25,7 @@ import { clearActivityLogState } from "./activity-log.js";
 import { synthesizeCrashRecovery, getDeepDiagnostic, readActiveMilestoneId, } from "./session-forensics.js";
 import { writeLock, clearLock, clearStaleWorkerLock, readCrashLock, isLockProcessAlive, formatCrashInfo, emitCrashRecoveredUnitEnd, emitOpenUnitEndForUnit, } from "./crash-recovery.js";
 import { acquireSessionLock, getSessionLockStatus, releaseSessionLock, updateSessionLock, } from "./session-lock.js";
-import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, getIsolationMode, } from "./preferences.js";
+import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, getIsolationMode, resolveEffectiveUnitIsolationMode, } from "./preferences.js";
 import { playNotificationBell, sendDesktopNotification } from "./notifications.js";
 import { getBudgetAlertLevel, getNewBudgetAlertLevel, getBudgetEnforcementAction, resolveCompactionThresholdPercent, shouldRerootStepSessionForContext, } from "./auto-budget.js";
 import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, isToolInvocationError, isQueuedUserMessageSkip, isDeterministicPolicyError, } from "./auto-tool-tracking.js";
@@ -54,6 +54,7 @@ import { getPriorSliceCompletionBlocker } from "./dispatch-guard.js";
 import { createAutoWorktree, teardownAutoWorktree, isInAutoWorktree, getAutoWorktreePath, mergeMilestoneToMain, autoWorktreeBranch, checkResourcesStale, escapeStaleWorktree, } from "./auto-worktree.js";
 import { pruneQueueOrder } from "./queue-order.js";
 import { startCommandPolling as _startCommandPolling, isRemoteConfigured } from "../remote-questions/manager.js";
+import { createMilestoneMergeTransaction } from "./milestone-merge-transaction.js";
 import { debugLog, isDebugEnabled, writeDebugSummary } from "./debug-logger.js";
 import { reconcileMergeState, verifyExpectedArtifact, } from "./auto-recovery.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
@@ -67,6 +68,7 @@ import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { updateProgressWidget as _updateProgressWidget, setCompletionProgressWidget, setAutoOutcomeWidget, setAutoActiveStatus, updateSliceProgressCache, clearSliceProgressCache, unitVerb, } from "./auto-dashboard.js";
 import { registerSigtermHandler as _registerSigtermHandler, deregisterSigtermHandler as _deregisterSigtermHandler, } from "./auto-supervisor.js";
 import { isDbAvailable, getMilestone, getMilestoneSlices, } from "./gsd-db.js";
+import { closeWorkflowDatabase } from "./db-workspace.js";
 import { markLatestActiveForWorkerCanceled } from "./db/unit-dispatches.js";
 import { writeUnitRuntimeRecord } from "./unit-runtime.js";
 import { countPendingCaptures } from "./captures.js";
@@ -109,12 +111,13 @@ void initTokenCounter().catch((err) => {
     logWarning("engine", `token counter warm-up failed: ${err instanceof Error ? err.message : String(err)}`);
 });
 export { STUB_RECOVERY_THRESHOLD, NEW_SESSION_TIMEOUT_MS, } from "./auto/session.js";
-import { autoSession as s } from "./auto-runtime-state.js";
+import { autoSession as s, getAutoRuntimeSnapshot } from "./auto-runtime-state.js";
 import { gsdHome } from "./gsd-home.js";
 import { createWorkspace, scopeMilestone } from "./workspace.js";
 import { registerAutoWorker, markWorkerStopping, } from "./db/auto-workers.js";
 import { releaseMilestoneLease } from "./db/milestone-leases.js";
 import { normalizeRealPath } from "./paths.js";
+import { formatStopNoticePrefix, isBlockedStopReason, stopNoticeDisplayReason, } from "./stop-notice.js";
 // ── ENCAPSULATION INVARIANT ─────────────────────────────────────────────────
 // ALL mutable auto-mode state lives in the AutoSession class (auto/session.ts).
 // This file must NOT declare module-level `let` or `var` variables for state.
@@ -135,17 +138,7 @@ export function formatAutoStopNotification(prefix, totals, unitCount) {
         `Session: ${formatCost(totals.cost)} · ${formatTokenCount(totals.tokens.total)} tokens · ${unitCount} units`,
     ].join("\n");
 }
-function isBlockedStopReason(reason) {
-    return /^Blocked:\s*/i.test(reason ?? "");
-}
-function formatAutoStopDisplayReason(reason) {
-    return (reason ?? "").replace(/^Blocked:\s*/i, "").trim();
-}
-export function formatAutoStopNotificationPrefix(reason) {
-    const displayReason = formatAutoStopDisplayReason(reason);
-    const prefix = isBlockedStopReason(reason) ? "Auto-mode blocked" : "Auto-mode stopped";
-    return displayReason ? `${prefix} — ${displayReason}` : prefix;
-}
+export { formatStopNoticePrefix as formatAutoStopNotificationPrefix } from "./stop-notice.js";
 function clearSessionModelOverrideForCommandSession(ctx) {
     const sessionId = s.cmdCtx?.sessionManager?.getSessionId?.() ??
         ctx?.sessionManager?.getSessionId?.();
@@ -344,14 +337,11 @@ export function startAutoDetached(ctx, pi, base, verboseMode, options) {
 export function shouldUseWorktreeIsolation(basePath) {
     return getIsolationMode(basePath) === "worktree";
 }
-function resolveEffectiveUnitIsolationMode(configuredMode, isolationDegraded) {
-    return configuredMode === "worktree" && isolationDegraded ? "branch" : configuredMode;
-}
-export function _resolveEffectiveUnitIsolationModeForTest(configuredMode, isolationDegraded) {
-    return resolveEffectiveUnitIsolationMode(configuredMode, isolationDegraded);
+export function _resolveEffectiveUnitIsolationModeForTest(configuredMode, isolationDegraded, strandedRecoveryIsolationMode = null) {
+    return resolveEffectiveUnitIsolationMode(configuredMode, isolationDegraded, strandedRecoveryIsolationMode);
 }
 function getEffectiveUnitIsolationMode(basePath) {
-    return resolveEffectiveUnitIsolationMode(getIsolationMode(basePath), s.isolationDegraded);
+    return resolveEffectiveUnitIsolationMode(getIsolationMode(basePath), s.isolationDegraded, s.strandedRecoveryIsolationMode);
 }
 /** Crash recovery prompt — set by startAuto, consumed by the main loop */
 /** Pending verification retry — set when gate fails with retries remaining, consumed by autoLoop */
@@ -463,6 +453,7 @@ function stopAutoCommandPolling() {
 }
 export function getAutoDashboardData() {
     const ledger = getLedger();
+    const runtimeSnapshot = getAutoRuntimeSnapshot();
     const totals = ledger ? getProjectTotals(ledger.units) : null;
     const sessionId = s.cmdCtx?.sessionManager?.getSessionId?.() ?? null;
     const rtkSavings = sessionId && s.basePath
@@ -495,6 +486,7 @@ export function getAutoDashboardData() {
         pendingCaptureCount,
         rtkSavings,
         rtkEnabled,
+        toolSurface: runtimeSnapshot.toolSurface,
     };
 }
 // ─── Public API ───────────────────────────────────────────────────────────────
@@ -520,6 +512,16 @@ export function _warnIfWorktreeMissingForTest(worktreePath, milestoneId) {
     }
     return false;
 }
+export function anchorProcessCwdForAutoResume(basePath) {
+    try {
+        process.chdir(basePath);
+        return true;
+    }
+    catch (err) {
+        logWarning("session", `resume cwd anchor failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts", basePath });
+        return false;
+    }
+}
 export function isAutoPaused() {
     return s.paused;
 }
@@ -565,6 +567,13 @@ export function getAutoModeStartModel() {
 export function setCurrentDispatchedModelId(model) {
     s.currentDispatchedModelId = model ? `${model.provider}/${model.id}` : null;
 }
+/**
+ * Update the active unit model after runtime recovery switches models mid-unit.
+ * The next session restore path reads this field before dispatching again.
+ */
+export function setCurrentUnitModelForRecovery(model) {
+    s.currentUnitModel = model;
+}
 // Tool tracking — delegates to auto-tool-tracking.ts
 export function markToolStart(toolCallId, toolName) {
     _markToolStart(toolCallId, s.active, toolName);
@@ -631,6 +640,35 @@ export function stopAutoRemote(projectRoot) {
         return { found: false, error: err.message };
     }
 }
+/**
+ * Force-stop a remote auto-mode session before stealing its lock.
+ * The normal stop path stays SIGTERM-only so cooperative sessions can clean up;
+ * this path is only for the explicit "Force start" action.
+ */
+export function forceStopAutoRemote(projectRoot) {
+    const lock = readCrashLock(projectRoot);
+    if (!lock)
+        return { found: false };
+    if (lock.pid === process.pid) {
+        clearLock(projectRoot);
+        return { found: false };
+    }
+    if (!isLockProcessAlive(lock)) {
+        clearLock(projectRoot);
+        return { found: false };
+    }
+    try {
+        process.kill(lock.pid, "SIGTERM");
+        if (isLockProcessAlive(lock)) {
+            process.kill(lock.pid, "SIGKILL");
+        }
+        clearLock(projectRoot);
+        return { found: true, pid: lock.pid };
+    }
+    catch (err) {
+        return { found: false, error: err.message };
+    }
+}
 /**
  * Check if a remote auto-mode session is running (from a different process).
  * Reads the crash lock, checks PID liveness, and returns session details.
@@ -723,6 +761,9 @@ function pauseAutoUnitIdentityMatches(expected) {
         s.currentUnit.id === expected.id &&
         s.currentUnit.startedAt === expected.startedAt;
 }
+function shouldPreserveCoordinationForPause(errorContext) {
+    return errorContext?.category === "provider" && errorContext.isTransient === true;
+}
 function setLifecycleOutcome(ctx, input) {
     if (!ctx?.hasUI)
         return;
@@ -989,8 +1030,8 @@ export async function stopAuto(ctx, pi, reason, options = {}) {
     if (!s.active && !s.paused)
         return;
     const loadedPreferences = loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences;
-    const stopNotificationPrefix = formatAutoStopNotificationPrefix(reason);
-    const displayReason = formatAutoStopDisplayReason(reason);
+    const stopNotificationPrefix = formatStopNoticePrefix(reason);
+    const displayReason = stopNoticeDisplayReason(reason);
     const isHeadlessStop = process.env.GSD_HEADLESS === "1";
     const completionStopRequested = Boolean(options.completionWidget);
     const preserveCloseoutTranscript = !isHeadlessStop && (options.preserveCloseoutTranscript ?? completionStopRequested);
@@ -1003,12 +1044,13 @@ export async function stopAuto(ctx, pi, reason, options = {}) {
     // worktree was active, and whether the current milestone was merged before
     // stopAuto. The unmerged-work warning is only meaningful for real worktrees.
     try {
-        const { emitAutoExit, normalizeAutoExitReason } = await import("./worktree-telemetry.js");
+        const { autoExitReasonForTerminalOutcome, emitAutoExit, normalizeAutoExitReason, } = await import("./worktree-telemetry.js");
         // Normalize the free-form reason to a closed set so the telemetry
         // aggregator buckets stably. Raw detail is preserved in the phases.ts
         // notification and the notify'd error string.
         const rawReason = reason ?? "stop";
-        const normalizedReason = normalizeAutoExitReason(rawReason);
+        const normalizedReason = autoExitReasonForTerminalOutcome(options.terminalOutcome)
+            ?? normalizeAutoExitReason(rawReason);
         const telemetryBase = s.originalBasePath || s.basePath;
         emitAutoExit(telemetryBase, {
             reason: normalizedReason,
@@ -1184,8 +1226,7 @@ export async function stopAuto(ctx, pi, reason, options = {}) {
         // ── Step 6: DB cleanup ──
         if (isDbAvailable()) {
             try {
-                const { closeDatabase } = await import("./gsd-db.js");
-                closeDatabase();
+                closeWorkflowDatabase();
             }
             catch (e) {
                 debugLog("db-close-failed", {
@@ -1557,7 +1598,7 @@ export async function pauseAuto(ctx, _pi, _errorContext, options = {}) {
         releaseSessionLock(lockBase());
         clearLock(lockBase());
     }
-    if (s.workerId) {
+    if (s.workerId && !shouldPreserveCoordinationForPause(_errorContext)) {
         try {
             if (s.currentMilestoneId && s.milestoneLeaseToken) {
                 releaseMilestoneLease(s.workerId, s.currentMilestoneId, s.milestoneLeaseToken);
@@ -1622,7 +1663,7 @@ export function buildWorktreeLifecycleDeps() {
     //   C4 (#5627) — GitServiceImpl constructor → gitServiceFactory
     //
     // Final WorktreeLifecycleDeps shape: 3 fields (gitServiceFactory,
-    // worktreeProjection, mergeMilestoneToMain). Down from 18 at slice-7
+    // worktreeProjection, mergeMilestoneToMain transaction runner). Down from 18 at slice-7
     // closure.
     return {
         gitServiceFactory: (basePath) => {
@@ -1630,7 +1671,7 @@ export function buildWorktreeLifecycleDeps() {
             return new GitServiceImpl(basePath, gitConfig);
         },
         worktreeProjection: new WorktreeStateProjection(),
-        mergeMilestoneToMain,
+        mergeMilestoneToMain: createMilestoneMergeTransaction(mergeMilestoneToMain),
     };
 }
 function buildLifecycle() {
@@ -1832,7 +1873,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     if (freshStartAssessment.classification === "running") {
         const pid = freshStartAssessment.lock?.pid;
         ctx.ui.notify(pid
-            ? `Another auto-mode session (PID ${pid}) appears to be running.\nStop it with \`kill ${pid}\` before starting a new session.`
+            ? `Another auto-mode session (PID ${pid}) appears to be running.\nRun \`/gsd stop\` for graceful shutdown, or choose "Force start" from \`/gsd auto\` to terminate it.`
             : "Another auto-mode session appears to be running.", "error");
         return;
     }
@@ -2002,6 +2043,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         }
         // ADR-016 phase 2 / B3 (#5621): paused-resume worktree-path adoption.
         buildLifecycle().resumeFromPausedSession(base, resumeWorktreePath);
+        anchorProcessCwdForAutoResume(s.basePath || base);
         // Rebuild scope now that s.basePath reflects the actual worktree (or project root).
         rebuildScope(s.basePath, s.currentMilestoneId);
         // Ensure the workflow-logger audit log is pinned to the project root

package/dist/resources/extensions/gsd/blocked-models.js

@@ -9,12 +9,16 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { withFileLockSync } from "./file-lock.js";
+const temporaryBlockedModels = new Map();
 function blockedModelsPath(basePath) {
     return join(gsdRoot(basePath), "runtime", "blocked-models.json");
 }
 function modelKey(provider, id) {
     return `${provider.toLowerCase()}/${id.toLowerCase()}`;
 }
+function temporaryModelKey(basePath, provider, id) {
+    return `${basePath}:${modelKey(provider, id)}`;
+}
 function readFileSafe(path) {
     if (!existsSync(path))
         return { version: 1, blocked: [] };
@@ -41,6 +45,30 @@ export function isModelBlocked(basePath, provider, id) {
     const target = modelKey(provider, id);
     return loadBlockedModels(basePath).some((e) => modelKey(e.provider, e.id) === target);
 }
+export function blockModelUntil(basePath, provider, id, blockedUntil, reason) {
+    const key = temporaryModelKey(basePath, provider, id);
+    if (blockedUntil <= Date.now()) {
+        temporaryBlockedModels.delete(key);
+        return;
+    }
+    temporaryBlockedModels.set(key, { provider, id, reason, blockedUntil });
+}
+export function isModelTemporarilyUnavailable(basePath, provider, id, now = Date.now()) {
+    if (!provider || !id)
+        return false;
+    const key = temporaryModelKey(basePath, provider, id);
+    const entry = temporaryBlockedModels.get(key);
+    if (!entry)
+        return false;
+    if (entry.blockedUntil <= now) {
+        temporaryBlockedModels.delete(key);
+        return false;
+    }
+    return true;
+}
+export function clearTemporaryModelBlocksForTest() {
+    temporaryBlockedModels.clear();
+}
 export function blockModel(basePath, provider, id, reason) {
     const path = blockedModelsPath(basePath);
     mkdirSync(dirname(path), { recursive: true });

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -2,7 +2,7 @@
 import { logWarning } from "../workflow-logger.js";
 import { checkDeepProjectSetupAfterTurn, checkAutoStartAfterDiscuss, maybeHandleReadyPhraseWithoutFiles, maybeHandleEmptyIntentTurn, resetEmptyTurnCounter, } from "../guided-flow.js";
 import { clearPathCache } from "../paths.js";
-import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, isAutoCompletionStopInProgress, pauseAuto, setCurrentDispatchedModelId, } from "../auto.js";
+import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, isAutoCompletionStopInProgress, pauseAuto, setCurrentDispatchedModelId, setCurrentUnitModelForRecovery, } from "../auto.js";
 import { getNextFallbackModel, resolveModelWithFallbacksForUnit } from "../preferences.js";
 import { pauseAutoForProviderError } from "../provider-error-pause.js";
 import { isSessionSwitchAbortGraceActive, isSessionSwitchInFlight, resolveAgentEnd, resolveAgentEndCancelled, } from "../auto/resolve.js";
@@ -13,9 +13,10 @@ import { clearDiscussionFlowState } from "./write-gate.js";
 import { clearGuidedUnitContext } from "../guided-unit-context.js";
 import { resumeAutoAfterProviderDelay } from "./provider-error-resume.js";
 import { classifyError, createRetryState, resetRetryState, isTransient, } from "../error-classifier.js";
-import { blockModel, isModelBlocked } from "../blocked-models.js";
+import { blockModel, blockModelUntil, isModelBlocked, isModelTemporarilyUnavailable } from "../blocked-models.js";
 import { getProjectGSDPreferencesPath } from "../preferences.js";
-import { formatProviderErrorGuidance, resolveProviderErrorGuidance, } from "../provider-error-guidance.js";
+import { resolveProviderErrorGuidance } from "../provider-error-guidance.js";
+import { formatGuidance } from "../guidance.js";
 const retryState = createRetryState();
 const MAX_NETWORK_RETRIES = 2;
 function isObjectRecord(value) {
@@ -95,9 +96,12 @@ async function tryProviderModelFallback(params) {
             if (!nextModelId)
                 break;
             const candidate = resolveModelId(nextModelId, availableModels, rejectedProvider);
-            if (candidate && !isModelBlocked(basePath, candidate.provider, candidate.id)) {
+            if (candidate &&
+                !isModelBlocked(basePath, candidate.provider, candidate.id) &&
+                !isModelTemporarilyUnavailable(basePath, candidate.provider, candidate.id)) {
                 const ok = await pi.setModel(candidate, { persist: false });
                 if (ok) {
+                    setCurrentUnitModelForRecovery(candidate);
                     setCurrentDispatchedModelId({ provider: candidate.provider, id: candidate.id });
                     switchedNotify(`${candidate.provider}/${candidate.id}`);
                     pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
@@ -110,11 +114,13 @@ async function tryProviderModelFallback(params) {
     const sessionModel = getAutoModeStartModel();
     if (sessionModel &&
         !(sessionModel.provider === rejectedProvider && sessionModel.id === rejectedId) &&
-        !isModelBlocked(basePath, sessionModel.provider, sessionModel.id)) {
+        !isModelBlocked(basePath, sessionModel.provider, sessionModel.id) &&
+        !isModelTemporarilyUnavailable(basePath, sessionModel.provider, sessionModel.id)) {
         const startModel = availableModels.find((m) => m.provider === sessionModel.provider && m.id === sessionModel.id);
         if (startModel) {
             const ok = await pi.setModel(startModel, { persist: false });
             if (ok) {
+                setCurrentUnitModelForRecovery(startModel);
                 setCurrentDispatchedModelId({ provider: startModel.provider, id: startModel.id });
                 switchedNotify(`${startModel.provider}/${startModel.id}`);
                 pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
@@ -486,7 +492,7 @@ export async function handleAgentEnd(pi, event, ctx) {
                 preferencesPath: dash.basePath ? getProjectGSDPreferencesPath(dash.basePath) : undefined,
                 hasConfiguredFallbacks: (modelConfig?.fallbacks.length ?? 0) > 0,
             });
-            const guidanceText = formatProviderErrorGuidance(guidance);
+            const guidanceText = formatGuidance(guidance);
             await pauseForProviderModelRejection(ctx, pi, {
                 errorDetail,
                 rawErrorMsg,
@@ -532,6 +538,10 @@ export async function handleAgentEnd(pi, event, ctx) {
             if (currentProvider === "openai-codex" || currentProvider === "google-gemini-cli") {
                 cls.retryAfterMs = Math.min(cls.retryAfterMs, 30_000);
             }
+            const dash = getAutoDashboardData();
+            if (dash.basePath && ctx.model?.provider && ctx.model?.id) {
+                blockModelUntil(dash.basePath, ctx.model.provider, ctx.model.id, Date.now() + cls.retryAfterMs, rawErrorMsg || displayMsg || "rate limit");
+            }
         }
         // ── 2. Decide & Act ──────────────────────────────────────────────────
         // --- Network errors: same-model retry with backoff ---
@@ -571,9 +581,14 @@ export async function handleAgentEnd(pi, event, ctx) {
                         retryState.networkRetryCount = 0;
                         retryState.currentRetryModelId = undefined;
                         const modelToSet = resolveModelId(nextModelId, availableModels, ctx.model?.provider);
-                        if (modelToSet) {
+                        const modelUnavailable = dash.basePath && modelToSet
+                            ? isModelBlocked(dash.basePath, modelToSet.provider, modelToSet.id) ||
+                                isModelTemporarilyUnavailable(dash.basePath, modelToSet.provider, modelToSet.id)
+                            : false;
+                        if (modelToSet && !modelUnavailable) {
                             const ok = await pi.setModel(modelToSet, { persist: false });
                             if (ok) {
+                                setCurrentUnitModelForRecovery(modelToSet);
                                 setCurrentDispatchedModelId({ provider: modelToSet.provider, id: modelToSet.id });
                                 ctx.ui.notify(`Model error${errorDetail}. Switched to fallback: ${nextModelId} and resuming.`, "warning");
                                 pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
@@ -586,11 +601,17 @@ export async function handleAgentEnd(pi, event, ctx) {
             // Try restoring session model
             const sessionModel = getAutoModeStartModel();
             if (sessionModel) {
-                if (ctx.model?.id !== sessionModel.id || ctx.model?.provider !== sessionModel.provider) {
+                const dash = getAutoDashboardData();
+                const sessionModelUnavailable = dash.basePath
+                    ? isModelBlocked(dash.basePath, sessionModel.provider, sessionModel.id) ||
+                        isModelTemporarilyUnavailable(dash.basePath, sessionModel.provider, sessionModel.id)
+                    : false;
+                if (!sessionModelUnavailable && (ctx.model?.id !== sessionModel.id || ctx.model?.provider !== sessionModel.provider)) {
                     const startModel = ctx.modelRegistry.getAvailable().find((m) => m.provider === sessionModel.provider && m.id === sessionModel.id);
                     if (startModel) {
                         const ok = await pi.setModel(startModel, { persist: false });
                         if (ok) {
+                            setCurrentUnitModelForRecovery(startModel);
                             setCurrentDispatchedModelId({ provider: startModel.provider, id: startModel.id });
                             retryState.networkRetryCount = 0;
                             retryState.currentRetryModelId = undefined;

package/dist/resources/extensions/gsd/bootstrap/db-tools.js

@@ -10,6 +10,7 @@ import { logError } from "../workflow-logger.js";
 import { getErrorMessage } from "../error-utils.js";
 import { incrementLegacyTelemetry } from "../legacy-telemetry.js";
 import { prepareSaveGateResultArguments } from "../tools/save-gate-result-args.js";
+import { aliasesForWorkflowTool } from "../workflow-tool-surface.js";
 async function loadWorkflowExecutors() {
     return importWorkflowExecutorsModule();
 }
@@ -41,6 +42,13 @@ function registerAlias(pi, toolDef, aliasName, canonicalName) {
         execute,
     });
 }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- toolDef shape matches ToolDefinition but varies by schema
+function registerWorkflowTool(pi, toolDef) {
+    pi.registerTool(toolDef);
+    for (const alias of aliasesForWorkflowTool(toolDef.name)) {
+        registerAlias(pi, toolDef, alias, toolDef.name);
+    }
+}
 function requirementRootWriteGuard(operation, basePath) {
     const guard = shouldBlockRootArtifactSaveInSnapshot(loadWriteGateSnapshot(basePath), "REQUIREMENTS");
     if (!guard.block)
@@ -155,8 +163,7 @@ export function registerDbTools(pi) {
             return new Text(text, 0, 0);
         },
     };
-    pi.registerTool(decisionSaveTool);
-    registerAlias(pi, decisionSaveTool, "gsd_save_decision", "gsd_decision_save");
+    registerWorkflowTool(pi, decisionSaveTool);
     // ─── gsd_requirement_update (formerly gsd_update_requirement) ───────────
     const requirementUpdateExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const basePath = resolveCtxCwd(_ctx);
@@ -241,8 +248,7 @@ export function registerDbTools(pi) {
             return new Text(text, 0, 0);
         },
     };
-    pi.registerTool(requirementUpdateTool);
-    registerAlias(pi, requirementUpdateTool, "gsd_update_requirement", "gsd_requirement_update");
+    registerWorkflowTool(pi, requirementUpdateTool);
     // ─── gsd_requirement_save ─────────────────────────────────────────────
     const requirementSaveExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const basePath = resolveCtxCwd(_ctx);
@@ -340,8 +346,7 @@ export function registerDbTools(pi) {
             return new Text(text, 0, 0);
         },
     };
-    pi.registerTool(requirementSaveTool);
-    registerAlias(pi, requirementSaveTool, "gsd_save_requirement", "gsd_requirement_save");
+    registerWorkflowTool(pi, requirementSaveTool);
     // ─── gsd_summary_save (formerly gsd_save_summary) ──────────────────────
     const summarySaveExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         try {
@@ -397,8 +402,7 @@ export function registerDbTools(pi) {
             return new Text(text, 0, 0);
         },
     };
-    pi.registerTool(summarySaveTool);
-    registerAlias(pi, summarySaveTool, "gsd_save_summary", "gsd_summary_save");
+    registerWorkflowTool(pi, summarySaveTool);
     // ─── gsd_uat_result_save ─────────────────────────────────────────────────
     const uatResultSaveExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executeUatResultSave } = await loadWorkflowExecutors();
@@ -480,7 +484,7 @@ export function registerDbTools(pi) {
             return new Text(theme.fg("success", `UAT ${d?.sliceId ?? ""}: ${d?.verdict ?? "saved"}`), 0, 0);
         },
     };
-    pi.registerTool(uatResultSaveTool);
+    registerWorkflowTool(pi, uatResultSaveTool);
     // ─── gsd_milestone_generate_id (formerly gsd_generate_milestone_id) ────
     const milestoneGenerateIdExecute = async (_toolCallId, _params, _signal, _onUpdate, _ctx) => {
         try {
@@ -566,8 +570,7 @@ export function registerDbTools(pi) {
             return new Text(text, 0, 0);
         },
     };
-    pi.registerTool(milestoneGenerateIdTool);
-    registerAlias(pi, milestoneGenerateIdTool, "gsd_generate_milestone_id", "gsd_milestone_generate_id");
+    registerWorkflowTool(pi, milestoneGenerateIdTool);
     // ─── gsd_plan_milestone (gsd_milestone_plan alias) ─────────────────────
     const planMilestoneExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executePlanMilestone } = await loadWorkflowExecutors();
@@ -633,8 +636,7 @@ export function registerDbTools(pi) {
         }),
         execute: planMilestoneExecute,
     };
-    pi.registerTool(planMilestoneTool);
-    registerAlias(pi, planMilestoneTool, "gsd_milestone_plan", "gsd_plan_milestone");
+    registerWorkflowTool(pi, planMilestoneTool);
     // ─── gsd_plan_slice (gsd_slice_plan alias) ─────────────────────────────
     const planSliceExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executePlanSlice } = await loadWorkflowExecutors();
@@ -678,8 +680,7 @@ export function registerDbTools(pi) {
         }),
         execute: planSliceExecute,
     };
-    pi.registerTool(planSliceTool);
-    registerAlias(pi, planSliceTool, "gsd_slice_plan", "gsd_plan_slice");
+    registerWorkflowTool(pi, planSliceTool);
     // ─── gsd_plan_task (gsd_task_plan alias) ───────────────────────────────
     const planTaskExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const basePath = resolveCtxCwd(_ctx);
@@ -748,8 +749,7 @@ export function registerDbTools(pi) {
         }),
         execute: planTaskExecute,
     };
-    pi.registerTool(planTaskTool);
-    registerAlias(pi, planTaskTool, "gsd_task_plan", "gsd_plan_task");
+    registerWorkflowTool(pi, planTaskTool);
     // ─── gsd_task_complete (gsd_complete_task alias) ────────────────────────
     const taskCompleteExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executeTaskComplete } = await loadWorkflowExecutors();
@@ -809,8 +809,7 @@ export function registerDbTools(pi) {
         }),
         execute: taskCompleteExecute,
     };
-    pi.registerTool(taskCompleteTool);
-    registerAlias(pi, taskCompleteTool, "gsd_complete_task", "gsd_task_complete");
+    registerWorkflowTool(pi, taskCompleteTool);
     // ─── gsd_slice_complete (gsd_complete_slice alias) ─────────────────────
     const sliceCompleteExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executeSliceComplete } = await loadWorkflowExecutors();
@@ -875,8 +874,7 @@ export function registerDbTools(pi) {
         }),
         execute: sliceCompleteExecute,
     };
-    pi.registerTool(sliceCompleteTool);
-    registerAlias(pi, sliceCompleteTool, "gsd_complete_slice", "gsd_slice_complete");
+    registerWorkflowTool(pi, sliceCompleteTool);
     // ─── gsd_skip_slice (#3477 / #3487) ───────────────────────────────────
     const skipSliceExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const basePath = resolveCtxCwd(_ctx);
@@ -941,7 +939,7 @@ export function registerDbTools(pi) {
             };
         }
     };
-    pi.registerTool({
+    registerWorkflowTool(pi, {
         name: "gsd_skip_slice",
         label: "Skip Slice",
         description: "Mark a slice as skipped so auto-mode advances past it without executing. " +
@@ -1000,8 +998,7 @@ export function registerDbTools(pi) {
         }),
         execute: milestoneCompleteExecute,
     };
-    pi.registerTool(milestoneCompleteTool);
-    registerAlias(pi, milestoneCompleteTool, "gsd_milestone_complete", "gsd_complete_milestone");
+    registerWorkflowTool(pi, milestoneCompleteTool);
     // ─── gsd_validate_milestone (gsd_milestone_validate alias) ─────────────
     const milestoneValidateExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executeValidateMilestone } = await loadWorkflowExecutors();
@@ -1035,8 +1032,7 @@ export function registerDbTools(pi) {
         }),
         execute: milestoneValidateExecute,
     };
-    pi.registerTool(milestoneValidateTool);
-    registerAlias(pi, milestoneValidateTool, "gsd_milestone_validate", "gsd_validate_milestone");
+    registerWorkflowTool(pi, milestoneValidateTool);
     // ─── gsd_replan_slice (gsd_slice_replan alias) ─────────────────────────
     const replanSliceExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executeReplanSlice } = await loadWorkflowExecutors();
@@ -1078,8 +1074,7 @@ export function registerDbTools(pi) {
         }),
         execute: replanSliceExecute,
     };
-    pi.registerTool(replanSliceTool);
-    registerAlias(pi, replanSliceTool, "gsd_slice_replan", "gsd_replan_slice");
+    registerWorkflowTool(pi, replanSliceTool);
     // ─── gsd_reassess_roadmap (gsd_roadmap_reassess alias) ─────────────────
     const reassessRoadmapExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executeReassessRoadmap } = await loadWorkflowExecutors();
@@ -1126,8 +1121,7 @@ export function registerDbTools(pi) {
         }),
         execute: reassessRoadmapExecute,
     };
-    pi.registerTool(reassessRoadmapTool);
-    registerAlias(pi, reassessRoadmapTool, "gsd_roadmap_reassess", "gsd_reassess_roadmap");
+    registerWorkflowTool(pi, reassessRoadmapTool);
     // ─── gsd_task_reopen (gsd_reopen_task alias) ───────────────────────────
     // Single-writer v3, Stream 3: reversibility tools for closed units.
     const reopenTaskExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
@@ -1190,8 +1184,7 @@ export function registerDbTools(pi) {
         }),
         execute: reopenTaskExecute,
     };
-    pi.registerTool(reopenTaskTool);
-    registerAlias(pi, reopenTaskTool, "gsd_reopen_task", "gsd_task_reopen");
+    registerWorkflowTool(pi, reopenTaskTool);
     // ─── gsd_slice_reopen (gsd_reopen_slice alias) ─────────────────────────
     const reopenSliceExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const basePath = resolveCtxCwd(_ctx);
@@ -1253,8 +1246,7 @@ export function registerDbTools(pi) {
         }),
         execute: reopenSliceExecute,
     };
-    pi.registerTool(reopenSliceTool);
-    registerAlias(pi, reopenSliceTool, "gsd_reopen_slice", "gsd_slice_reopen");
+    registerWorkflowTool(pi, reopenSliceTool);
     // ─── gsd_milestone_reopen (gsd_reopen_milestone alias) ─────────────────
     const reopenMilestoneExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const basePath = resolveCtxCwd(_ctx);
@@ -1314,8 +1306,7 @@ export function registerDbTools(pi) {
         }),
         execute: reopenMilestoneExecute,
     };
-    pi.registerTool(reopenMilestoneTool);
-    registerAlias(pi, reopenMilestoneTool, "gsd_reopen_milestone", "gsd_milestone_reopen");
+    registerWorkflowTool(pi, reopenMilestoneTool);
     // ─── gsd_save_gate_result ──────────────────────────────────────────────
     const saveGateResultExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         const { executeSaveGateResult } = await loadWorkflowExecutors();
@@ -1378,5 +1369,5 @@ export function registerDbTools(pi) {
             return new Text(theme.fg(color, `${d.gateId}: ${d.verdict}`), 0, 0);
         },
     };
-    pi.registerTool(saveGateResultTool);
+    registerWorkflowTool(pi, saveGateResultTool);
 }