gsd-pi 2.80.0-dev.0aaa4fc17 → 2.80.0-dev.1486c1899

package/README.md

@@ -259,6 +259,7 @@ Full documentation is in the [`docs/`](./docs/) directory:
 
 - **[Architecture](./docs/dev/architecture.md)** — system design and dispatch pipeline
 - **[CI/CD Pipeline](./docs/dev/ci-cd-pipeline.md)** — three-stage promotion pipeline (Dev → Test → Prod)
+- **[E2E Testing](./tests/e2e/README.md)** — real-process CLI/runtime coverage and CI runner expectations
 - **[Pipeline Simplification (ADR-003)](./docs/dev/ADR-003-pipeline-simplification.md)** — merged research into planning, mechanical completion
 - **[VS Code Extension](./vscode-extension/README.md)** — chat participant, sidebar dashboard, RPC integration
 
@@ -361,7 +362,7 @@ The database is authoritative for milestones, slices, tasks, requirements, decis
 
 2. **Context pre-loading** — The dispatch prompt includes inlined task plans, slice plans, prior task summaries, dependency summaries, roadmap excerpts, and decisions register. The LLM starts with everything it needs instead of spending tool calls reading files.
 
-3. **Context Mode** — Context Mode is enabled by default and gives every auto-mode unit guidance for preserving context. Agents are steered toward `gsd_exec` for noisy scans, builds, tests, and diagnostics; full stdout/stderr is saved under `.gsd/exec/` while only a short digest enters the conversation. `gsd_exec_search` lets agents reuse prior runs instead of repeating expensive checks, and `gsd_resume` reads `.gsd/last-snapshot.md` after compaction or resume. Opt out with `context_mode.enabled: false`; tune sandbox timeout/output caps with `context_mode.exec_timeout_ms`, `context_mode.exec_stdout_cap_bytes`, and `context_mode.exec_digest_chars`.
+3. **Context Mode** — Context Mode is enabled by default and gives eligible auto-mode units guidance for preserving context. Agents are steered toward `gsd_exec` for noisy scans, builds, tests, and diagnostics; capped stdout/stderr and metadata are saved under `.gsd/exec/` while only a short digest enters the conversation. `gsd_exec_search` lets agents reuse prior runs instead of repeating expensive checks, and `gsd_resume` reads a prior compaction snapshot from `.gsd/last-snapshot.md` when one exists. Opt out with `context_mode.enabled: false` to disable Context Mode guidance, snapshot injection, `gsd_exec`, `gsd_exec_search`, and `gsd_resume`; tune sandbox timeout/output caps and environment forwarding with `context_mode.exec_timeout_ms`, `context_mode.exec_stdout_cap_bytes`, `context_mode.exec_digest_chars`, and `context_mode.exec_env_allowlist`.
 
 4. **Git isolation** — When `git.isolation` is set to `worktree` or `branch`, each milestone runs on its own `milestone/<MID>` branch (in a worktree or in-place). All slice work commits sequentially — no branch switching, no merge conflicts. When the milestone completes, it's squash-merged to main as one clean commit. The default is `none` (work on the current branch), configurable via preferences. If `worktree` is configured in a repo with no committed `HEAD`, GSD temporarily behaves as `none` until the first commit exists because git worktrees need a committed start point.
 
@@ -659,10 +660,11 @@ auto_report: true
 | `unique_milestone_ids`            | Uses unique milestone names to avoid clashes when working in teams of people                          |
 | `git.isolation`                   | `none` (default), `worktree`, or `branch` — enable worktree or branch isolation for milestone work. `worktree` requires a committed `HEAD`; zero-commit repos temporarily run as `none`    |
 | `git.manage_gitignore`            | Set `false` to prevent GSD from modifying `.gitignore`                                                |
-| `context_mode.enabled`            | Context Mode is default-on; set `false` to disable `gsd_exec`, exec history guidance, and resume snapshots |
+| `context_mode.enabled`            | Context Mode is default-on; set `false` to disable prompt guidance, snapshot injection, `gsd_exec`, `gsd_exec_search`, and `gsd_resume` |
 | `context_mode.exec_timeout_ms`    | Timeout for sandboxed `gsd_exec` runs (default: 30000)                                                |
 | `context_mode.exec_stdout_cap_bytes` | Persisted stdout cap for `gsd_exec` output (default: 1048576)                                      |
 | `context_mode.exec_digest_chars`  | Trailing stdout characters returned to the agent context (default: 300)                              |
+| `context_mode.exec_env_allowlist` | Environment variables forwarded to sandboxed `gsd_exec` runs in addition to `PATH` and `HOME`        |
 | `verification_commands`           | Array of shell commands to run after task execution (e.g., `["npm run lint", "npm run test"]`)        |
 | `verification_auto_fix`           | Auto-retry on verification failures (default: true)                                                   |
 | `verification_max_retries`        | Max retries for verification failures (default: 2)                                                    |

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

@@ -1 +1 @@
-64e3cdf0430b5181
+1788ab029536c80a

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

@@ -23,12 +23,12 @@ import { existsSync, cpSync } from "node:fs";
 import { logWarning, logError, _resetLogs, drainLogs, drainAndSummarize, formatForNotification, hasAnyIssues, } from "../workflow-logger.js";
 import { gsdRoot } from "../paths.js";
 import { atomicWriteSync } from "../atomic-write.js";
-import { verifyExpectedArtifact, diagnoseExpectedArtifact, buildLoopRemediationSteps } from "../auto-recovery.js";
+import { verifyExpectedArtifact, diagnoseExpectedArtifact, buildLoopRemediationSteps, refreshRecoveryDbForArtifact } from "../auto-recovery.js";
 import { writeUnitRuntimeRecord } from "../unit-runtime.js";
 import { withTimeout, FINALIZE_PRE_TIMEOUT_MS, FINALIZE_POST_TIMEOUT_MS } from "./finalize-timeout.js";
 import { getEligibleSlices } from "../slice-parallel-eligibility.js";
 import { startSliceParallel } from "../slice-parallel-orchestrator.js";
-import { isDbAvailable, getMilestoneSlices, refreshOpenDatabaseFromDisk } from "../gsd-db.js";
+import { isDbAvailable, getMilestoneSlices } from "../gsd-db.js";
 import { ensurePlanV2Graph, isEmptyPlanV2GraphResult, isMissingFinalizedContextResult } from "../uok/plan-v2.js";
 import { resolveUokFlags } from "../uok/flags.js";
 import { UokGateRunner } from "../uok/gate-runner.js";
@@ -42,13 +42,6 @@ import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit,
 function isSamePathLocal(a, b) {
     return normalizeWorktreePathForCompare(a) === normalizeWorktreePathForCompare(b);
 }
-function refreshPlanSliceRecoveryDbIfNeeded(unitType) {
-    if (unitType !== "plan-slice")
-        return true;
-    if (!isDbAvailable())
-        return true;
-    return refreshOpenDatabaseFromDisk();
-}
 // ─── Session timeout auto-resume state ────────────────────────────────────────
 let consecutiveSessionTimeouts = 0;
 const MAX_SESSION_TIMEOUT_AUTO_RESUMES = 3;
@@ -795,11 +788,18 @@ export async function runDispatch(ic, preData, loopState) {
                         level: 1,
                         action: "artifact-found",
                     });
-                    ctx.ui.notify(`Stuck recovery: artifact for ${unitType} ${unitId} found on disk. Invalidating caches.`, "info");
-                    if (!refreshPlanSliceRecoveryDbIfNeeded(unitType)) {
-                        ctx.ui.notify(`Stuck recovery found ${unitType} ${unitId} artifacts, but the DB refresh failed. Keeping stuck state for retry.`, "warning");
+                    const recoveryDb = refreshRecoveryDbForArtifact(unitType, unitId);
+                    if (!recoveryDb.ok) {
+                        ctx.ui.notify(recoveryDb.fatal
+                            ? `${recoveryDb.message} Pausing auto-mode for manual recovery.`
+                            : `${recoveryDb.message} Keeping stuck state for retry.`, "warning");
+                        if (recoveryDb.fatal) {
+                            await deps.pauseAuto(ctx, pi);
+                            return { action: "break", reason: recoveryDb.reason };
+                        }
                         return { action: "continue" };
                     }
+                    ctx.ui.notify(`Stuck recovery: artifact for ${unitType} ${unitId} found on disk. Invalidating caches.`, "info");
                     deps.invalidateAllCaches();
                     loopState.recentUnits.length = 0;
                     loopState.stuckRecoveryAttempts = 0;
@@ -818,13 +818,20 @@ export async function runDispatch(ic, preData, loopState) {
                         level: 2,
                         action: "artifact-found",
                     });
-                    ctx.ui.notify(`Stuck recovery: artifact for ${unitType} ${unitId} found on disk after cache invalidation. Continuing.`, "info");
-                    if (refreshPlanSliceRecoveryDbIfNeeded(unitType)) {
+                    const recoveryDb = refreshRecoveryDbForArtifact(unitType, unitId);
+                    if (recoveryDb.ok) {
+                        ctx.ui.notify(`Stuck recovery: artifact for ${unitType} ${unitId} found on disk after cache invalidation. Continuing.`, "info");
                         loopState.recentUnits.length = 0;
                         loopState.stuckRecoveryAttempts = 0;
                         return { action: "continue" };
                     }
-                    ctx.ui.notify(`Stuck recovery found ${unitType} ${unitId} artifacts, but the DB refresh failed. Stopping for manual recovery.`, "warning");
+                    ctx.ui.notify(recoveryDb.fatal
+                        ? `${recoveryDb.message} Pausing auto-mode for manual recovery.`
+                        : `${recoveryDb.message} Stopping for manual recovery.`, "warning");
+                    if (recoveryDb.fatal) {
+                        await deps.pauseAuto(ctx, pi);
+                        return { action: "break", reason: recoveryDb.reason };
+                    }
                 }
                 debugLog("autoLoop", {
                     phase: "stuck-detected",

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

@@ -17,6 +17,7 @@ import { bumpTurnGeneration } from "./turn-epoch.js";
 // scoped pendingResolve + pendingAgentEndQueue pattern.
 let _currentResolve = null;
 let _sessionSwitchInFlight = false;
+let _pendingSwitchCancellation = null;
 // ─── Setters (needed for cross-module mutation) ─────────────────────────────
 export function _setCurrentResolve(fn) {
     _currentResolve = fn;
@@ -27,6 +28,11 @@ export function _setSessionSwitchInFlight(v) {
 export function _clearCurrentResolve() {
     _currentResolve = null;
 }
+export function _consumePendingSwitchCancellation() {
+    const pending = _pendingSwitchCancellation;
+    _pendingSwitchCancellation = null;
+    return pending;
+}
 // ─── resolveAgentEnd ─────────────────────────────────────────────────────────
 /**
  * Called from the agent_end event handler in index.ts to resolve the
@@ -90,8 +96,18 @@ export function resolveAgentEndCancelled(errorContext) {
         debugLog("resolveAgentEndCancelled", { status: "resolving-cancelled" });
         const r = _currentResolve;
         _currentResolve = null;
+        _pendingSwitchCancellation = null;
         r({ status: "cancelled", ...(errorContext ? { errorContext } : {}) });
+        return true;
+    }
+    if (_sessionSwitchInFlight) {
+        bumpTurnGeneration(`cancelled-during-switch:${errorContext?.category ?? "unknown"}`);
+        _pendingSwitchCancellation = errorContext ? { errorContext } : {};
+        debugLog("resolveAgentEndCancelled", { status: "queued-during-switch" });
+        return false;
     }
+    debugLog("resolveAgentEndCancelled", { status: "no-pending-resolve" });
+    return false;
 }
 // ─── resetPendingResolve (test helper) ───────────────────────────────────────
 /**
@@ -101,6 +117,7 @@ export function resolveAgentEndCancelled(errorContext) {
 export function _resetPendingResolve() {
     _currentResolve = null;
     _sessionSwitchInFlight = false;
+    _pendingSwitchCancellation = null;
 }
 export function _hasPendingResolveForTest() {
     return _currentResolve !== null;

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

@@ -1,6 +1,6 @@
 // GSD-2 + src/resources/extensions/gsd/auto/run-unit.ts - Runs one GSD auto-mode unit from session creation through agent completion.
 import { NEW_SESSION_TIMEOUT_MS } from "./session.js";
-import { _clearCurrentResolve, _setCurrentResolve, _setSessionSwitchInFlight } from "./resolve.js";
+import { _clearCurrentResolve, _consumePendingSwitchCancellation, _setCurrentResolve, _setSessionSwitchInFlight, } from "./resolve.js";
 import { getCurrentTurnGeneration, runWithTurnGeneration, } from "./turn-epoch.js";
 import { debugLog } from "../debug-logger.js";
 import { logWarning } from "../workflow-logger.js";
@@ -71,6 +71,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     catch (sessionErr) {
         if (sessionTimeoutHandle)
             clearTimeout(sessionTimeoutHandle);
+        _consumePendingSwitchCancellation();
         const msg = sessionErr instanceof Error ? sessionErr.message : String(sessionErr);
         debugLog("runUnit", {
             phase: "session-error",
@@ -83,15 +84,18 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     if (sessionTimeoutHandle)
         clearTimeout(sessionTimeoutHandle);
     if (sessionResult.cancelled) {
+        _consumePendingSwitchCancellation();
         debugLog("runUnit-session-timeout", { unitType, unitId });
         return { status: "cancelled", errorContext: { message: "Session creation timed out", category: "timeout", isTransient: true } };
     }
     if (!s.active) {
+        _consumePendingSwitchCancellation();
         return { status: "cancelled" };
     }
     if (s.currentUnitModel && typeof pi.setModel === "function") {
         const restored = await pi.setModel(s.currentUnitModel, { persist: false });
         if (!restored) {
+            _consumePendingSwitchCancellation();
             const message = `Failed to restore configured model ${s.currentUnitModel.provider}/${s.currentUnitModel.id} after session creation`;
             ctx.ui.notify(`${message}. Cancelling unit before dispatch.`, "warning");
             return {
@@ -111,6 +115,14 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     const unitPromise = new Promise((resolve) => {
         _setCurrentResolve(resolve);
     });
+    const pendingSwitchCancellation = _consumePendingSwitchCancellation();
+    if (pendingSwitchCancellation) {
+        _clearCurrentResolve();
+        return {
+            status: "cancelled",
+            ...(pendingSwitchCancellation.errorContext ? { errorContext: pendingSwitchCancellation.errorContext } : {}),
+        };
+    }
     // ── Provider request-readiness pre-check (#4555) ──
     // Verify the provider can accept requests before dispatching. If the token
     // has expired since bootstrap, return cancelled immediately so the unit is

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

@@ -21,6 +21,7 @@ import { assertGateCoverage, getGatesForTurn, } from "./gate-registry.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
 import { readPhaseAnchor, formatAnchorForPrompt } from "./phase-anchor.js";
 import { composeContextModeInstructions, composeInlinedContext } from "./unit-context-composer.js";
+import { readCompactionSnapshot } from "./compaction-snapshot.js";
 import { logWarning } from "./workflow-logger.js";
 import { inlineGraphSubgraph } from "./graph-context.js";
 import { buildExtractionStepsBlock } from "./commands-extract-learnings.js";
@@ -178,8 +179,19 @@ function renderContextModeForPrompt(unitType, base, renderMode = "standalone") {
         renderMode,
     });
 }
-function prependContextModeToBlock(unitType, base, block, renderMode = "standalone") {
+function renderContextModeBlockForPrompt(unitType, base, renderMode = "standalone") {
     const contextMode = renderContextModeForPrompt(unitType, base, renderMode);
+    if (!contextMode)
+        return "";
+    if (renderMode === "nested")
+        return contextMode;
+    const snapshot = readCompactionSnapshot(base);
+    if (!snapshot?.trim())
+        return contextMode;
+    return `${contextMode}\n\n## Context Snapshot\nSource: \`.gsd/last-snapshot.md\`\n\n${snapshot.trimEnd()}`;
+}
+function prependContextModeToBlock(unitType, base, block, renderMode = "standalone") {
+    const contextMode = renderContextModeBlockForPrompt(unitType, base, renderMode);
     if (!contextMode)
         return block;
     if (!block.trim())

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

@@ -30,7 +30,49 @@ import { getProjectResearchStatus } from "./project-research-policy.js";
 // Re-export so existing consumers of auto-recovery.ts keep working.
 export { resolveExpectedArtifactPath, diagnoseExpectedArtifact };
 export { classifyMilestoneSummaryContent, } from "./milestone-summary-classifier.js";
-// ─── Artifact Resolution & Verification ───────────────────────────────────────
+export function refreshRecoveryDbForArtifact(unitType, unitId) {
+    if (unitType !== "plan-slice" && unitType !== "execute-task")
+        return { ok: true };
+    if (!isDbAvailable())
+        return { ok: true };
+    if (!refreshOpenDatabaseFromDisk()) {
+        return {
+            ok: false,
+            fatal: unitType === "execute-task",
+            reason: `${unitType}-db-refresh-failed`,
+            message: `Stuck recovery found ${unitType} ${unitId} artifacts, but the DB refresh failed.`,
+        };
+    }
+    if (unitType !== "execute-task")
+        return { ok: true };
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+    if (!mid || !sid || !tid) {
+        return {
+            ok: false,
+            fatal: true,
+            reason: "execute-task-invalid-unit-id",
+            message: `Stuck recovery found execute-task ${unitId} artifacts, but the unit id could not be parsed for DB verification.`,
+        };
+    }
+    const task = getTask(mid, sid, tid);
+    if (!task) {
+        return {
+            ok: false,
+            fatal: true,
+            reason: "execute-task-artifact-db-missing",
+            message: `Stuck recovery found execute-task ${unitId} artifacts, but no matching DB task row exists after refresh.`,
+        };
+    }
+    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.`,
+        };
+    }
+    return { ok: true };
+}
 function hasCapturedWorkflowPrefs(base) {
     const prefsPath = resolveExpectedArtifactPath("workflow-preferences", "WORKFLOW-PREFS", base);
     if (!prefsPath || !existsSync(prefsPath))

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

@@ -24,7 +24,7 @@ let _currentSigtermHandler = null;
  *
  * Returns the new handler so the caller can store and deregister it later.
  */
-export function registerSigtermHandler(currentBasePath, previousHandler) {
+export function registerSigtermHandler(currentBasePath, previousHandler, onSignalCleanup) {
     // Remove the explicitly-passed previous handler
     if (previousHandler) {
         for (const sig of CLEANUP_SIGNALS)
@@ -37,6 +37,13 @@ export function registerSigtermHandler(currentBasePath, previousHandler) {
             process.off(sig, _currentSigtermHandler);
     }
     const handler = () => {
+        try {
+            onSignalCleanup?.();
+        }
+        catch {
+            void 0;
+            // Signal cleanup is best-effort; lock cleanup and process exit still run.
+        }
         clearLock(currentBasePath);
         releaseSessionLock(currentBasePath);
         process.exit(0);

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

@@ -35,13 +35,13 @@ export async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rct
         writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnitStartedAt, {
             recovery: status,
         });
-        const durableComplete = status.summaryExists && status.taskChecked && status.nextActionAdvanced;
+        const durableComplete = status.dbComplete || (status.summaryExists && status.taskChecked && status.nextActionAdvanced);
         if (durableComplete) {
             writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnitStartedAt, {
                 phase: "finalized",
                 recovery: status,
             });
-            ctx.ui.notify(`${reason === "idle" ? "Idle" : "Timeout"} recovery: ${unitType} ${unitId} already completed on disk. Continuing auto-mode. (attempt ${attemptNumber})`, "info");
+            ctx.ui.notify(`${reason === "idle" ? "Idle" : "Timeout"} recovery: ${unitType} ${unitId} already completed. Continuing auto-mode. (attempt ${attemptNumber})`, "info");
             unitRecoveryCount.delete(recoveryKey);
             bumpAndResolveSynthetic(`timeout-recovery:${reason}:${unitType}/${unitId}`);
             return "recovered";

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

@@ -20,7 +20,7 @@ import { gsdRoot, resolveMilestoneFile, resolveMilestonePath, resolveDir, milest
 import { invalidateAllCaches } from "./cache.js";
 import { clearActivityLogState } from "./activity-log.js";
 import { synthesizeCrashRecovery, getDeepDiagnostic, readActiveMilestoneId, } from "./session-forensics.js";
-import { writeLock, clearLock, readCrashLock, isLockProcessAlive, formatCrashInfo, emitCrashRecoveredUnitEnd, } from "./crash-recovery.js";
+import { writeLock, clearLock, 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 { sendDesktopNotification } from "./notifications.js";
@@ -61,6 +61,8 @@ import { isClosedStatus } from "./status-guards.js";
 import { updateProgressWidget as _updateProgressWidget, updateSliceProgressCache, clearSliceProgressCache, } from "./auto-dashboard.js";
 import { registerSigtermHandler as _registerSigtermHandler, deregisterSigtermHandler as _deregisterSigtermHandler, } from "./auto-supervisor.js";
 import { isDbAvailable, getMilestone } from "./gsd-db.js";
+import { markLatestActiveForWorkerCanceled } from "./db/unit-dispatches.js";
+import { writeUnitRuntimeRecord } from "./unit-runtime.js";
 import { countPendingCaptures } from "./captures.js";
 import { CMUX_CHANNELS } from "../shared/cmux-events.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
@@ -112,11 +114,12 @@ const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
  * the DB is unavailable (e.g. fresh project before init) we skip registration
  * silently rather than blocking session start.
  */
-function registerAutoWorkerForSession(session) {
+function registerAutoWorkerForSession(session, projectRootOverride) {
     if (session.workerId)
         return; // already registered (e.g. resume re-runs)
     try {
-        const projectRootRealpath = normalizeRealPath(session.scope?.workspace.projectRoot
+        const projectRootRealpath = normalizeRealPath(projectRootOverride
+            ?? session.scope?.workspace.projectRoot
             ?? (session.originalBasePath || session.basePath));
         session.workerId = registerAutoWorker({ projectRootRealpath });
     }
@@ -272,9 +275,50 @@ export function shouldUseWorktreeIsolation(basePath) {
  */
 // Re-export budget utilities for external consumers
 export { getBudgetAlertLevel, getNewBudgetAlertLevel, getBudgetEnforcementAction, } from "./auto-budget.js";
+function closeOutSignalInterruptedUnit(currentBasePath) {
+    const currentUnit = s.currentUnit;
+    if (!currentUnit)
+        return;
+    const reason = "Auto-mode process received a termination signal";
+    const errorContext = {
+        message: reason,
+        category: "aborted",
+        isTransient: false,
+    };
+    const basePath = s.basePath || currentBasePath;
+    try {
+        emitOpenUnitEndForUnit(basePath, currentUnit.type, currentUnit.id, "cancelled", errorContext);
+    }
+    catch (err) {
+        logWarning("engine", `signal unit-end cleanup failed: ${getErrorMessage(err)}`, { file: "auto.ts" });
+    }
+    try {
+        writeUnitRuntimeRecord(basePath, currentUnit.type, currentUnit.id, currentUnit.startedAt, {
+            phase: "crashed",
+            lastProgressAt: Date.now(),
+            lastProgressKind: "signal",
+        });
+    }
+    catch (err) {
+        logWarning("engine", `signal runtime cleanup failed: ${getErrorMessage(err)}`, { file: "auto.ts" });
+    }
+    try {
+        if (s.workerId)
+            markLatestActiveForWorkerCanceled(s.workerId, "signal-exit");
+    }
+    catch (err) {
+        logWarning("engine", `signal dispatch cleanup failed: ${getErrorMessage(err)}`, { file: "auto.ts" });
+    }
+    try {
+        resolveAgentEndCancelled(errorContext);
+    }
+    catch (err) {
+        logWarning("engine", `signal resolve cleanup failed: ${getErrorMessage(err)}`, { file: "auto.ts" });
+    }
+}
 /** Wrapper: register SIGTERM handler and store reference. */
 function registerSigtermHandler(currentBasePath) {
-    s.sigtermHandler = _registerSigtermHandler(currentBasePath, s.sigtermHandler);
+    s.sigtermHandler = _registerSigtermHandler(currentBasePath, s.sigtermHandler, () => closeOutSignalInterruptedUnit(currentBasePath));
 }
 /** Wrapper: deregister SIGTERM handler and clear reference. */
 function deregisterSigtermHandler() {
@@ -1631,6 +1675,10 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         lockBase,
         buildResolver,
     };
+    // Register the worker before bootstrap enters a milestone worktree.
+    // This ensures enterMilestone can claim a lease and seed dispatch claims
+    // for crash-recovery fidelity (#5405).
+    registerAutoWorkerForSession(s, base);
     const ready = await bootstrapAutoSession(s, ctx, pi, base, verboseMode, requestedStepMode, bootstrapDeps, freshStartAssessment);
     if (!ready)
         return;

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

@@ -118,9 +118,28 @@ export async function handleAgentEnd(pi, event, ctx) {
         return;
     if (!isAutoActive())
         return;
-    if (isSessionSwitchInFlight())
-        return;
     const lastMsg = event.messages[event.messages.length - 1];
+    if (isSessionSwitchInFlight()) {
+        if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "error") {
+            const rawErrorMsg = ("errorMessage" in lastMsg && lastMsg.errorMessage) ? String(lastMsg.errorMessage) : "";
+            if (isUserInitiatedAbortMessage(rawErrorMsg)) {
+                resolveAgentEndCancelled({
+                    message: rawErrorMsg,
+                    category: "aborted",
+                    isTransient: false,
+                });
+            }
+        }
+        else if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "aborted") {
+            const content = "content" in lastMsg ? lastMsg.content : undefined;
+            const hasEmptyContent = Array.isArray(content) && content.length === 0;
+            const hasErrorMessage = "errorMessage" in lastMsg && !!lastMsg.errorMessage;
+            if (!hasEmptyContent || hasErrorMessage) {
+                resolveAgentEndCancelled(_buildAbortedPauseContext(lastMsg));
+            }
+        }
+        return;
+    }
     if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "aborted") {
         // Empty content with aborted stopReason is a non-fatal agent stop (the LLM
         // chose to end without producing output). Only pause on genuine fatal aborts

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

@@ -3,21 +3,34 @@
 // Exposes the Context Mode runtime tools in-process. Default-on; opt out with
 // `context_mode.enabled: false` in preferences.
 import { Type } from "@sinclair/typebox";
+async function loadContextModePreferences(baseDir) {
+    const [{ loadEffectiveGSDPreferences }, { logWarning }] = await Promise.all([
+        import("../preferences.js"),
+        import("../workflow-logger.js"),
+    ]);
+    try {
+        return loadEffectiveGSDPreferences(baseDir)?.preferences ?? null;
+    }
+    catch (err) {
+        logWarning("tool", `Context Mode tool could not load preferences: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
 export function registerExecTools(pi) {
     pi.registerTool({
         name: "gsd_exec",
         label: "Exec (Sandboxed)",
-        description: "Run a short script (bash/node/python) in a subprocess. Full stdout/stderr persist to " +
+        description: "Run a short script (bash/node/python) in a subprocess. Capped stdout/stderr and metadata persist to " +
             ".gsd/exec/<id>.{stdout,stderr,meta.json}; only a short digest returns in context. Use " +
             "this instead of reading many files or emitting large tool outputs — e.g. have the script " +
             "count/grep/summarize and log the finding. Enabled by default; opt out via " +
             "preferences.context_mode.enabled=false.",
-        promptSnippet: "Run a bash/node/python script in a sandbox; full output is saved to disk and only a digest returns",
+        promptSnippet: "Run a bash/node/python script in a sandbox; capped output is saved to disk and only a digest returns",
         promptGuidelines: [
             "Prefer gsd_exec for analyses that would otherwise read >3 files or produce large tool output.",
             "Write scripts that log the finding (counts, matches, summaries) rather than raw dumps.",
             "The digest is the last ~300 chars of stdout — size your log output accordingly.",
-            "Need the full output? Read the stdout_path returned in details (file on local disk).",
+            "Need persisted output? Read the stdout_path returned in details (file on local disk).",
         ],
         parameters: Type.Object({
             runtime: Type.Union([Type.Literal("bash"), Type.Literal("node"), Type.Literal("python")], { description: "Interpreter: bash (-c), node (-e), or python3 (-c)." }),
@@ -30,21 +43,11 @@ export function registerExecTools(pi) {
             })),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            const [{ executeGsdExec }, { loadEffectiveGSDPreferences }, { logWarning }] = await Promise.all([
-                import("../tools/exec-tool.js"),
-                import("../preferences.js"),
-                import("../workflow-logger.js"),
-            ]);
-            let prefs = null;
-            try {
-                prefs = loadEffectiveGSDPreferences();
-            }
-            catch (err) {
-                logWarning("tool", `gsd_exec could not load preferences: ${err instanceof Error ? err.message : String(err)}`);
-            }
+            const { executeGsdExec } = await import("../tools/exec-tool.js");
+            const baseDir = process.cwd();
             return executeGsdExec(params, {
-                baseDir: process.cwd(),
-                preferences: prefs?.preferences ?? null,
+                baseDir,
+                preferences: await loadContextModePreferences(baseDir),
             });
         },
     });
@@ -56,7 +59,7 @@ export function registerExecTools(pi) {
         promptSnippet: "Search prior gsd_exec runs by substring, runtime, or failing-only filter",
         promptGuidelines: [
             "Use this before re-running an expensive analysis — the prior run's stdout file may still answer.",
-            "The preview shows the trailing ~300 chars of stdout; read stdout_path for the full transcript.",
+            "The preview shows the trailing ~300 chars of stdout; read stdout_path for persisted output.",
         ],
         parameters: Type.Object({
             query: Type.Optional(Type.String({ description: "Substring matched against id and purpose (case-insensitive)." })),
@@ -68,8 +71,10 @@ export function registerExecTools(pi) {
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
             const { executeExecSearch } = await import("../tools/exec-search-tool.js");
+            const baseDir = process.cwd();
             return executeExecSearch(params, {
-                baseDir: process.cwd(),
+                baseDir,
+                preferences: await loadContextModePreferences(baseDir),
             });
         },
     });
@@ -87,8 +92,10 @@ export function registerExecTools(pi) {
         parameters: Type.Object({}),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
             const { executeResume } = await import("../tools/resume-tool.js");
+            const baseDir = process.cwd();
             return executeResume(params, {
-                baseDir: process.cwd(),
+                baseDir,
+                preferences: await loadContextModePreferences(baseDir),
             });
         },
     });

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -52,6 +52,25 @@ async function applyDisabledModelProviderPolicy(ctx) {
         // Non-fatal: keep default provider visibility if preferences cannot be loaded.
     }
 }
+/**
+ * Bridge `context_management.compaction_threshold_percent` from GSD preferences
+ * into the agent's runtime compaction settings (#5475). The preference is
+ * validated to (0.5, 0.95) at load time, but defense-in-depth normalization
+ * here protects against a stale or hand-edited prefs file. Calling with
+ * `undefined` clears any prior override so a removed preference does not leak.
+ */
+async function applyCompactionThresholdOverride(ctx) {
+    try {
+        const { loadEffectiveGSDPreferences } = await import("../preferences.js");
+        const prefs = loadEffectiveGSDPreferences();
+        const raw = prefs?.preferences.context_management?.compaction_threshold_percent;
+        const value = typeof raw === "number" && Number.isFinite(raw) && raw > 0 && raw < 1 ? raw : undefined;
+        ctx.setCompactionThresholdOverride(value);
+    }
+    catch {
+        // Non-fatal: leave any existing override in place.
+    }
+}
 export function resolveNotificationStoreBasePath(cwd = process.cwd()) {
     return resolveWorktreeProjectRoot(cwd);
 }
@@ -101,6 +120,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         await resetAskUserQuestionsTurnCache();
         await syncServiceTierStatus(ctx);
         await applyDisabledModelProviderPolicy(ctx);
+        await applyCompactionThresholdOverride(ctx);
         // Skip MCP auto-prep when running inside an auto-worktree (see session_switch below).
         const { isInAutoWorktree } = await import("../auto-worktree.js");
         if (!isInAutoWorktree(process.cwd())) {
@@ -149,6 +169,7 @@ export function registerHooks(pi, ecosystemHandlers) {
         clearDiscussionFlowState(process.cwd());
         await syncServiceTierStatus(ctx);
         await applyDisabledModelProviderPolicy(ctx);
+        await applyCompactionThresholdOverride(ctx);
         // Skip MCP auto-prep when running inside an auto-worktree. The worktree
         // already has .mcp.json from createAutoWorktree, and re-running the writer
         // post-chdir rewrites the file mid-run (non-idempotent due to cwd-relative

package/dist/resources/extensions/gsd/db/unit-dispatches.js

@@ -253,6 +253,45 @@ export function markCanceled(dispatchId, reason) {
      SET status = 'canceled', ended_at = :ended_at, exit_reason = :reason
      WHERE id = :id AND status IN ('pending','claimed','running')`).run({ ":id": dispatchId, ":ended_at": now, ":reason": reason });
 }
+/**
+ * Best-effort signal/crash cleanup: cancel the latest active dispatch owned by
+ * a worker when the process is exiting before the normal loop can settle it.
+ */
+export function markLatestActiveForWorkerCanceled(workerId, reason) {
+    if (!isDbAvailable())
+        return false;
+    const now = new Date().toISOString();
+    const db = _getAdapter();
+    const result = transaction(() => {
+        return db.prepare(`UPDATE unit_dispatches
+       SET status = 'canceled', ended_at = :ended_at, exit_reason = :reason
+       WHERE id = (
+         SELECT id FROM unit_dispatches
+         WHERE worker_id = :worker_id
+           AND status IN ('pending','claimed','running')
+         ORDER BY id DESC
+         LIMIT 1
+       )`).run({
+            ":ended_at": now,
+            ":reason": reason,
+            ":worker_id": workerId,
+        });
+    });
+    const changes = typeof result.changes === "number"
+        ? result.changes
+        : 0;
+    if (changes <= 0)
+        return false;
+    insertAuditEvent({
+        eventId: randomUUID(),
+        traceId: workerId,
+        category: "orchestration",
+        type: "dispatch-canceled",
+        ts: now,
+        payload: { workerId, reason },
+    });
+    return true;
+}
 /**
  * Fetch the most recent N dispatches for a unit. Used by recordDispatchClaim
  * callers to compute attempt_n and by detect-stuck.ts (B3) to consult