gsd-pi 2.33.1-dev.ee47f1b → 2.34.0-dev.bbb5216

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

@@ -17,65 +17,35 @@
  *   agent_end — auto-mode advancement
  *   session_before_compact — save continue.md OR block during auto
  */
-import { createBashTool, createEditTool, createReadTool, createWriteTool, importExtensionModule, isToolCallEventType, } from "@gsd/pi-coding-agent";
+import { createBashTool, createWriteTool, createReadTool, createEditTool, isToolCallEventType } from "@gsd/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
 import { debugTime } from "./debug-logger.js";
-import { registerLazyGSDCommand } from "./commands-bootstrap.js";
+import { registerGSDCommand } from "./commands.js";
 import { loadToolApiKeys } from "./commands-config.js";
 import { registerExitCommand } from "./exit-command.js";
-import { registerLazyWorktreeCommands } from "./worktree-command-bootstrap.js";
+import { registerWorktreeCommand, getWorktreeOriginalCwd, getActiveWorktreeName } from "./worktree-command.js";
+import { getActiveAutoWorktreeContext } from "./auto-worktree.js";
 import { saveFile, formatContinue, loadFile, parseContinue, parseSummary, loadActiveOverrides, formatOverridesSection } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
+import { deriveState } from "./state.js";
+import { isAutoActive, isAutoPaused, pauseAuto, getAutoDashboardData, getAutoModeStartModel, markToolStart, markToolEnd } from "./auto.js";
+import { isSessionSwitchInFlight, resolveAgentEnd } from "./auto-loop.js";
 import { saveActivityLog } from "./activity-log.js";
+import { checkAutoStartAfterDiscuss, getDiscussionMilestoneId, findMilestoneIds, nextMilestoneId } from "./guided-flow.js";
+import { GSDDashboardOverlay } from "./dashboard-overlay.js";
+import { loadEffectiveGSDPreferences, renderPreferencesForSystemPrompt, resolveAllSkillReferences, resolveModelWithFallbacksForUnit, getNextFallbackModel, isTransientNetworkError, } from "./preferences.js";
 import { hasSkillSnapshot, detectNewSkills, formatSkillsXml } from "./skill-discovery.js";
-import { resolveSlicePath, resolveSliceFile, resolveTaskFile, resolveTaskFiles, resolveTasksDir, relSliceFile, relSlicePath, relTaskFile, buildSliceFileName, buildMilestoneFileName, gsdRoot, resolveMilestonePath, resolveGsdRootFile, } from "./paths.js";
+import { resolveSlicePath, resolveSliceFile, resolveTaskFile, resolveTaskFiles, resolveTasksDir, relSliceFile, relSlicePath, relTaskFile, buildSliceFileName, buildMilestoneFileName, resolveMilestonePath, resolveGsdRootFile, } from "./paths.js";
 import { Key } from "@gsd/pi-tui";
 import { join } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { shortcutDesc } from "../shared/mod.js";
 import { Text } from "@gsd/pi-tui";
+import { pauseAutoForProviderError, classifyProviderError } from "./provider-error-pause.js";
 import { toPosixPath } from "../shared/mod.js";
+import { isParallelActive, shutdownParallel } from "./parallel-orchestrator.js";
 import { DEFAULT_BASH_TIMEOUT_SECS } from "./constants.js";
-import { getErrorMessage } from "./error-utils.js";
-function memoizeImport(loader) {
-    let promise = null;
-    return () => {
-        if (!promise) {
-            promise = loader();
-        }
-        return promise;
-    };
-}
-const loadAutoModule = memoizeImport(() => importExtensionModule(import.meta.url, "./auto.js"));
-const loadStateModule = memoizeImport(() => importExtensionModule(import.meta.url, "./state.js"));
-const loadGuidedFlowModule = memoizeImport(() => importExtensionModule(import.meta.url, "./guided-flow.js"));
-const loadPreferencesModule = memoizeImport(() => importExtensionModule(import.meta.url, "./preferences.js"));
-const loadDashboardOverlayModule = memoizeImport(() => importExtensionModule(import.meta.url, "./dashboard-overlay.js"));
-const loadWorktreeCommandModule = memoizeImport(() => importExtensionModule(import.meta.url, "./worktree-command.js"));
-const loadAutoWorktreeModule = memoizeImport(() => importExtensionModule(import.meta.url, "./auto-worktree.js"));
-const loadProviderErrorPauseModule = memoizeImport(() => importExtensionModule(import.meta.url, "./provider-error-pause.js"));
-const loadParallelOrchestratorModule = memoizeImport(() => importExtensionModule(import.meta.url, "./parallel-orchestrator.js"));
-/**
- * Ensure the GSD database is available, auto-initializing if needed.
- * Returns true if the DB is ready, false if initialization failed.
- */
-async function ensureDbAvailable() {
-    try {
-        const db = await importExtensionModule(import.meta.url, "./gsd-db.js");
-        if (db.isDbAvailable())
-            return true;
-        // Auto-initialize: open (and create if needed) the DB at the standard path
-        const gsdDir = gsdRoot(process.cwd());
-        if (!existsSync(gsdDir))
-            return false; // No GSD project — can't create DB
-        const dbPath = join(gsdDir, "gsd.db");
-        return db.openDatabase(dbPath);
-    }
-    catch {
-        return false;
-    }
-}
 // ── Agent Instructions ────────────────────────────────────────────────────
 // Lightweight "always follow" files injected into every GSD agent session.
 // Global: ~/.gsd/agent-instructions.md   Project: .gsd/agent-instructions.md
@@ -105,9 +75,7 @@ function loadAgentInstructions() {
     return parts.join("\n\n");
 }
 // ── Depth verification state ──────────────────────────────────────────────
-// Tracks which milestones have passed depth verification.
-// Single-milestone flows set '*' (wildcard). Multi-milestone flows set per-ID.
-const depthVerifiedMilestones = new Set();
+let depthVerificationDone = false;
 // ── Queue phase tracking ──────────────────────────────────────────────────
 // When true, the LLM is in a queue flow writing CONTEXT.md files.
 // The write-gate applies during queue flows just like discussion flows.
@@ -116,25 +84,10 @@ let activeQueuePhase = false;
 // Tracks per-model retry attempts for transient network errors.
 // Cleared when a model switch occurs or retries are exhausted.
 const networkRetryCounters = new Map();
-// ── Transient error escalation ───────────────────────────────────────────
-// Tracks consecutive transient auto-resume attempts. Each attempt doubles
-// the delay. After MAX_TRANSIENT_AUTO_RESUMES consecutive failures, auto-mode
-// pauses indefinitely to avoid infinite rapid-fire retries (#1166).
-const MAX_TRANSIENT_AUTO_RESUMES = 5;
+const MAX_TRANSIENT_AUTO_RESUMES = 3;
 let consecutiveTransientErrors = 0;
 export function isDepthVerified() {
-    return depthVerifiedMilestones.has("*") || depthVerifiedMilestones.size > 0;
-}
-/** Check whether a specific milestone has passed depth verification. */
-export function isDepthVerifiedFor(milestoneId) {
-    // Wildcard means "all milestones verified" (single-milestone flow)
-    if (depthVerifiedMilestones.has("*"))
-        return true;
-    return depthVerifiedMilestones.has(milestoneId);
-}
-/** Mark a specific milestone as depth-verified. */
-export function markDepthVerified(milestoneId) {
-    depthVerifiedMilestones.add(milestoneId);
+    return depthVerificationDone;
 }
 /** Check whether a queue phase is active. */
 export function isQueuePhaseActive() {
@@ -156,25 +109,11 @@ export function shouldBlockContextWrite(toolName, inputPath, milestoneId, depthV
         return { block: false };
     if (!MILESTONE_CONTEXT_RE.test(inputPath))
         return { block: false };
-    // For discussion flows: check global depth verification (backward compat)
-    if (inDiscussion && depthVerified)
+    if (depthVerified)
         return { block: false };
-    // For queue flows: extract milestone ID from the path and check per-milestone verification
-    if (inQueue) {
-        const pathMatch = inputPath.match(/\/(M\d+(?:-[a-z0-9]{6})?)-CONTEXT\.md$/);
-        const targetMid = pathMatch?.[1];
-        if (targetMid && depthVerifiedMilestones.has(targetMid))
-            return { block: false };
-        // Wildcard passes all
-        if (depthVerifiedMilestones.has("*"))
-            return { block: false };
-    }
     return {
         block: true,
-        reason: `Blocked: Cannot write milestone CONTEXT.md without depth verification. ` +
-            `Use ask_user_questions with a question id containing "depth_verification" first. ` +
-            `For multi-milestone flows, include the milestone ID in the question id (e.g., "depth_verification_M001"). ` +
-            `This ensures each milestone's context has been critically examined before being written.`,
+        reason: `Blocked: Cannot write to milestone CONTEXT.md during discussion phase without depth verification. Call ask_user_questions with question id "depth_verification" first to confirm discussion depth before writing context.`,
     };
 }
 // ── ASCII logo ────────────────────────────────────────────────────────────
@@ -187,8 +126,8 @@ const GSD_LOGO_LINES = [
     "   ╚═════╝ ╚══════╝╚═════╝ ",
 ];
 export default function (pi) {
-    registerLazyGSDCommand(pi);
-    registerLazyWorktreeCommands(pi);
+    registerGSDCommand(pi);
+    registerWorktreeCommand(pi);
     registerExitCommand(pi);
     // ── EPIPE guard — prevent crash when stdout/stderr pipe closes unexpectedly ──
     // Node.js throws a fatal `Error: write EPIPE` when the parent process closes
@@ -197,22 +136,11 @@ export default function (pi) {
     // chance to persist state and pause instead of crashing (see issue #739).
     if (!process.listeners("uncaughtException").some(l => l.name === "_gsdEpipeGuard")) {
         const _gsdEpipeGuard = (err) => {
-            const code = err.code;
-            if (code === "EPIPE") {
+            if (err.code === "EPIPE") {
                 // Pipe closed — nothing we can write; just exit cleanly
                 process.exit(0);
             }
-            // ECOMPROMISED: proper-lockfile's update timer detected mtime drift (system
-            // sleep, heavy event loop stall, or filesystem precision mismatch on Node.js
-            // v25+). The onCompromised callback already set _lockCompromised = true, but
-            // due to a subtle interaction between the synchronous fs adapter and the
-            // setTimeout boundary, the error can still propagate here as an uncaught
-            // exception. Exit cleanly so the process.once("exit") handler removes the
-            // lock directory — allowing the next session to acquire cleanly (#1322).
-            if (code === "ECOMPROMISED") {
-                process.exit(1);
-            }
-            // Re-throw anything that isn't EPIPE or ECOMPROMISED so real crashes still surface
+            // Re-throw anything that isn't EPIPE so real crashes still surface
             throw err;
         };
         process.on("uncaughtException", _gsdEpipeGuard);
@@ -301,8 +229,14 @@ export default function (pi) {
             when_context: Type.Optional(Type.String({ description: "When/context for the decision (e.g. milestone ID)" })),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            // Ensure DB is available (auto-initialize if needed)
-            if (!await ensureDbAvailable()) {
+            // Check DB availability
+            let dbAvailable = false;
+            try {
+                const db = await import("./gsd-db.js");
+                dbAvailable = db.isDbAvailable();
+            }
+            catch { /* dynamic import failed */ }
+            if (!dbAvailable) {
                 return {
                     content: [{ type: "text", text: "Error: GSD database is not available. Cannot save decision." }],
                     isError: true,
@@ -310,7 +244,7 @@ export default function (pi) {
                 };
             }
             try {
-                const { saveDecisionToDb } = await importExtensionModule(import.meta.url, "./db-writer.js");
+                const { saveDecisionToDb } = await import("./db-writer.js");
                 const { id } = await saveDecisionToDb({
                     scope: params.scope,
                     decision: params.decision,
@@ -325,7 +259,7 @@ export default function (pi) {
                 };
             }
             catch (err) {
-                const msg = getErrorMessage(err);
+                const msg = err instanceof Error ? err.message : String(err);
                 process.stderr.write(`gsd-db: gsd_save_decision tool failed: ${msg}\n`);
                 return {
                     content: [{ type: "text", text: `Error saving decision: ${msg}` }],
@@ -357,8 +291,13 @@ export default function (pi) {
             supporting_slices: Type.Optional(Type.String({ description: "Supporting slices" })),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            // Ensure DB is available (auto-initialize if needed)
-            if (!await ensureDbAvailable()) {
+            let dbAvailable = false;
+            try {
+                const db = await import("./gsd-db.js");
+                dbAvailable = db.isDbAvailable();
+            }
+            catch { /* dynamic import failed */ }
+            if (!dbAvailable) {
                 return {
                     content: [{ type: "text", text: "Error: GSD database is not available. Cannot update requirement." }],
                     isError: true,
@@ -367,7 +306,7 @@ export default function (pi) {
             }
             try {
                 // Verify requirement exists
-                const db = await importExtensionModule(import.meta.url, "./gsd-db.js");
+                const db = await import("./gsd-db.js");
                 const existing = db.getRequirementById(params.id);
                 if (!existing) {
                     return {
@@ -376,7 +315,7 @@ export default function (pi) {
                         details: { operation: "update_requirement", id: params.id, error: "not_found" },
                     };
                 }
-                const { updateRequirementInDb } = await importExtensionModule(import.meta.url, "./db-writer.js");
+                const { updateRequirementInDb } = await import("./db-writer.js");
                 const updates = {};
                 if (params.status !== undefined)
                     updates.status = params.status;
@@ -397,7 +336,7 @@ export default function (pi) {
                 };
             }
             catch (err) {
-                const msg = getErrorMessage(err);
+                const msg = err instanceof Error ? err.message : String(err);
                 process.stderr.write(`gsd-db: gsd_update_requirement tool failed: ${msg}\n`);
                 return {
                     content: [{ type: "text", text: `Error updating requirement: ${msg}` }],
@@ -427,8 +366,13 @@ export default function (pi) {
             content: Type.String({ description: "The full markdown content of the artifact" }),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            // Ensure DB is available (auto-initialize if needed)
-            if (!await ensureDbAvailable()) {
+            let dbAvailable = false;
+            try {
+                const db = await import("./gsd-db.js");
+                dbAvailable = db.isDbAvailable();
+            }
+            catch { /* dynamic import failed */ }
+            if (!dbAvailable) {
                 return {
                     content: [{ type: "text", text: "Error: GSD database is not available. Cannot save artifact." }],
                     isError: true,
@@ -456,7 +400,7 @@ export default function (pi) {
                 else {
                     relativePath = `milestones/${params.milestone_id}/${params.milestone_id}-${params.artifact_type}.md`;
                 }
-                const { saveArtifactToDb } = await importExtensionModule(import.meta.url, "./db-writer.js");
+                const { saveArtifactToDb } = await import("./db-writer.js");
                 await saveArtifactToDb({
                     path: relativePath,
                     artifact_type: params.artifact_type,
@@ -471,7 +415,7 @@ export default function (pi) {
                 };
             }
             catch (err) {
-                const msg = getErrorMessage(err);
+                const msg = err instanceof Error ? err.message : String(err);
                 process.stderr.write(`gsd-db: gsd_save_summary tool failed: ${msg}\n`);
                 return {
                     content: [{ type: "text", text: `Error saving artifact: ${msg}` }],
@@ -505,10 +449,6 @@ export default function (pi) {
         parameters: Type.Object({}),
         async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
             try {
-                const [{ findMilestoneIds, nextMilestoneId }, { loadEffectiveGSDPreferences }] = await Promise.all([
-                    loadGuidedFlowModule(),
-                    loadPreferencesModule(),
-                ]);
                 const basePath = process.cwd();
                 const existingIds = findMilestoneIds(basePath);
                 const uniqueEnabled = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
@@ -522,7 +462,7 @@ export default function (pi) {
                 };
             }
             catch (err) {
-                const msg = getErrorMessage(err);
+                const msg = err instanceof Error ? err.message : String(err);
                 return {
                     content: [{ type: "text", text: `Error generating milestone ID: ${msg}` }],
                     isError: true,
@@ -533,9 +473,8 @@ export default function (pi) {
     });
     // ── session_start: render branded GSD header + load tool keys + remote status ──
     pi.on("session_start", async (_event, ctx) => {
-        // Clear depth verification and queue phase state from any prior session
-        depthVerifiedMilestones.clear();
-        activeQueuePhase = false;
+        // Clear per-session state that must not leak across sessions (e.g. RPC mode)
+        depthVerificationDone = false;
         // Theme access throws in RPC mode (no TUI) — header is decorative, skip it
         try {
             const theme = ctx.ui.theme;
@@ -550,17 +489,11 @@ export default function (pi) {
         }
         // Load tool API keys from auth.json into environment
         loadToolApiKeys();
-        // Always-on health widget — ambient system health signal below the editor
-        try {
-            const { initHealthWidget } = await importExtensionModule(import.meta.url, "./health-widget.js");
-            initHealthWidget(ctx);
-        }
-        catch { /* non-fatal — widget is best-effort */ }
         // Notify remote questions status if configured
         try {
             const [{ getRemoteConfigStatus }, { getLatestPromptSummary }] = await Promise.all([
-                importExtensionModule(import.meta.url, "../remote-questions/config.js"),
-                importExtensionModule(import.meta.url, "../remote-questions/status.js"),
+                import("../remote-questions/config.js"),
+                import("../remote-questions/status.js"),
             ]);
             const status = getRemoteConfigStatus();
             const latest = getLatestPromptSummary();
@@ -578,12 +511,11 @@ export default function (pi) {
         description: shortcutDesc("Open GSD dashboard", "/gsd status"),
         handler: async (ctx) => {
             // Only show if .gsd/ exists
-            if (!existsSync(gsdRoot(process.cwd()))) {
+            if (!existsSync(join(process.cwd(), ".gsd"))) {
                 ctx.ui.notify("No .gsd/ directory found. Run /gsd to start.", "info");
                 return;
             }
-            const { GSDDashboardOverlay } = await loadDashboardOverlayModule();
-            const result = await ctx.ui.custom((tui, theme, _kb, done) => {
+            await ctx.ui.custom((tui, theme, _kb, done) => {
                 return new GSDDashboardOverlay(tui, theme, () => done());
             }, {
                 overlay: true,
@@ -594,20 +526,14 @@ export default function (pi) {
                     anchor: "center",
                 },
             });
-            // Fallback for RPC mode where ctx.ui.custom() returns undefined.
-            if (result === undefined) {
-                const { fireStatusViaCommand } = await importExtensionModule(import.meta.url, "./commands.js");
-                await fireStatusViaCommand(ctx);
-            }
         },
     });
     // ── before_agent_start: inject GSD contract into true system prompt ─────
     pi.on("before_agent_start", async (event, ctx) => {
-        if (!existsSync(gsdRoot(process.cwd())))
+        if (!existsSync(join(process.cwd(), ".gsd")))
             return;
         const stopContextTimer = debugTime("context-inject");
         const systemContent = loadPrompt("system");
-        const { loadEffectiveGSDPreferences, resolveAllSkillReferences, renderPreferencesForSystemPrompt } = await loadPreferencesModule();
         const loadedPreferences = loadEffectiveGSDPreferences();
         let preferenceBlock = "";
         if (loadedPreferences) {
@@ -636,7 +562,7 @@ export default function (pi) {
         // Inject auto-learned project memories
         let memoryBlock = "";
         try {
-            const { getActiveMemoriesRanked, formatMemoriesForPrompt } = await importExtensionModule(import.meta.url, "./memory-store.js");
+            const { getActiveMemoriesRanked, formatMemoriesForPrompt } = await import("./memory-store.js");
             const memories = getActiveMemoriesRanked(30);
             if (memories.length > 0) {
                 const formatted = formatMemoriesForPrompt(memories, 2000);
@@ -663,10 +589,6 @@ export default function (pi) {
         const injection = await buildGuidedExecuteContextInjection(event.prompt, process.cwd());
         // Worktree context — override the static CWD in the system prompt
         let worktreeBlock = "";
-        const [{ getActiveWorktreeName, getWorktreeOriginalCwd }, { getActiveAutoWorktreeContext }] = await Promise.all([
-            loadWorktreeCommandModule(),
-            loadAutoWorktreeModule(),
-        ]);
         const worktreeName = getActiveWorktreeName();
         const worktreeMainCwd = getWorktreeOriginalCwd();
         const autoWorktree = getActiveAutoWorktreeContext();
@@ -728,27 +650,21 @@ export default function (pi) {
     });
     // ── agent_end: auto-mode advancement or auto-start after discuss ───────────
     pi.on("agent_end", async (event, ctx) => {
-        const [{ isAutoActive, pauseAuto, getAutoDashboardData, getAutoModeStartModel, handleAgentEnd, }, { checkAutoStartAfterDiscuss }, { isTransientNetworkError, resolveModelWithFallbacksForUnit, getNextFallbackModel, }, { classifyProviderError, pauseAutoForProviderError },] = await Promise.all([
-            loadAutoModule(),
-            loadGuidedFlowModule(),
-            loadPreferencesModule(),
-            loadProviderErrorPauseModule(),
-        ]);
-        // Clean up quick-task branch if one just completed (#1269)
-        try {
-            const { cleanupQuickBranch } = await importExtensionModule(import.meta.url, "./quick.js");
-            cleanupQuickBranch();
-        }
-        catch { /* non-fatal */ }
         // If discuss phase just finished, start auto-mode
         if (checkAutoStartAfterDiscuss()) {
-            depthVerifiedMilestones.clear();
+            depthVerificationDone = false;
             activeQueuePhase = false;
             return;
         }
         // If auto-mode is already running, advance to next unit
         if (!isAutoActive())
             return;
+        // Fresh-session auto-mode intentionally aborts the previous session during
+        // cmdCtx.newSession(). Ignore that agent_end so we neither pause nor
+        // resolve the new unit with an event from the old session.
+        if (isSessionSwitchInFlight()) {
+            return;
+        }
         // If the agent was aborted (user pressed Escape) or hit a provider
         // error (fetch failure, rate limit, etc.), pause auto-mode instead of
         // advancing. This preserves the conversation so the user can inspect
@@ -853,43 +769,39 @@ export default function (pi) {
             const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number")
                 ? lastMsg.retryAfterMs
                 : undefined;
-            let retryAfterMs = explicitRetryAfterMs ?? classification.suggestedDelayMs;
-            // ── Escalating backoff for repeated transient errors ──────────────
-            // Each consecutive transient auto-resume doubles the delay. After
-            // MAX_TRANSIENT_AUTO_RESUMES consecutive failures, treat as permanent
-            // to avoid infinite rapid-fire retries (#1166).
-            let effectiveTransient = classification.isTransient;
             if (classification.isTransient) {
-                consecutiveTransientErrors++;
-                if (consecutiveTransientErrors > MAX_TRANSIENT_AUTO_RESUMES) {
-                    effectiveTransient = false;
-                    ctx.ui.notify(`${consecutiveTransientErrors} consecutive transient errors. Pausing indefinitely — resume manually with /gsd auto.`, "error");
-                    consecutiveTransientErrors = 0;
-                }
-                else {
-                    // Escalate: base delay × 2^(consecutive-1) → 30s, 60s, 120s, 240s, 480s
-                    retryAfterMs = retryAfterMs * 2 ** (consecutiveTransientErrors - 1);
-                }
+                consecutiveTransientErrors += 1;
+            }
+            else {
+                consecutiveTransientErrors = 0;
+            }
+            const baseRetryAfterMs = explicitRetryAfterMs ?? classification.suggestedDelayMs;
+            const retryAfterMs = classification.isTransient ? baseRetryAfterMs * 2 ** Math.max(0, consecutiveTransientErrors - 1) : baseRetryAfterMs;
+            const allowAutoResume = classification.isTransient
+                && consecutiveTransientErrors <= MAX_TRANSIENT_AUTO_RESUMES;
+            if (classification.isTransient && !allowAutoResume) {
+                ctx.ui.notify(`Transient provider errors persisted after ${MAX_TRANSIENT_AUTO_RESUMES} auto-resume attempts. Pausing for manual review.`, "warning");
             }
             await pauseAutoForProviderError(ctx.ui, errorDetail, () => pauseAuto(ctx, pi), {
                 isRateLimit: classification.isRateLimit,
-                isTransient: effectiveTransient,
+                isTransient: allowAutoResume,
                 retryAfterMs,
-                resume: () => {
-                    pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution \u2014 provider error recovery delay elapsed.", display: false }, { triggerTurn: true });
-                },
+                resume: allowAutoResume
+                    ? () => {
+                        pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution \u2014 provider error recovery delay elapsed.", display: false }, { triggerTurn: true });
+                    }
+                    : undefined,
             });
             return;
         }
         try {
+            consecutiveTransientErrors = 0;
             networkRetryCounters.clear(); // Clear network retry state on successful unit completion
-            consecutiveTransientErrors = 0; // Reset escalating backoff on success
-            await handleAgentEnd(ctx, pi);
+            resolveAgentEnd(event);
         }
         catch (err) {
-            // Safety net: if handleAgentEnd throws despite its internal try-catch,
-            // ensure auto-mode stops gracefully instead of silently stalling (#381).
-            const message = getErrorMessage(err);
+            // Safety net: if resolveAgentEnd throws, ensure auto-mode stops gracefully (#381).
+            const message = err instanceof Error ? err.message : String(err);
             ctx.ui.notify(`Auto-mode error in agent_end handler: ${message}. Stopping auto-mode.`, "error");
             try {
                 await pauseAuto(ctx, pi);
@@ -901,10 +813,6 @@ export default function (pi) {
     });
     // ── session_before_compact ────────────────────────────────────────────────
     pi.on("session_before_compact", async (_event, _ctx) => {
-        const [{ isAutoActive, isAutoPaused }, { deriveState }] = await Promise.all([
-            loadAutoModule(),
-            loadStateModule(),
-        ]);
         // Block compaction during auto-mode — each unit is a fresh session
         // Also block during paused state — context is valuable for the user
         if (isAutoActive() || isAutoPaused()) {
@@ -948,29 +856,12 @@ export default function (pi) {
     });
     // ── session_shutdown: save activity log on Ctrl+C / SIGTERM ─────────────
     pi.on("session_shutdown", async (_event, ctx) => {
-        const [{ isParallelActive, shutdownParallel }, { isAutoActive, isAutoPaused, getAutoDashboardData }] = await Promise.all([
-            loadParallelOrchestratorModule(),
-            loadAutoModule(),
-        ]);
         if (isParallelActive()) {
             try {
                 await shutdownParallel(process.cwd());
             }
             catch { /* best-effort */ }
         }
-        // Auto-commit dirty work in CLI-spawned worktrees so nothing is lost.
-        // The CLI sets GSD_CLI_WORKTREE when launched with -w.
-        const cliWorktree = process.env.GSD_CLI_WORKTREE;
-        if (cliWorktree) {
-            try {
-                const { autoCommitCurrentBranch } = await importExtensionModule(import.meta.url, "./worktree.js");
-                const msg = autoCommitCurrentBranch(process.cwd(), "session-end", cliWorktree);
-                if (msg) {
-                    ctx.ui.notify(`Auto-committed worktree ${cliWorktree} before exit.`, "info");
-                }
-            }
-            catch { /* best-effort */ }
-        }
         if (!isAutoActive() && !isAutoPaused())
             return;
         // Save the current session — the lock file stays on disk
@@ -980,56 +871,32 @@ export default function (pi) {
             saveActivityLog(ctx, dash.basePath, dash.currentUnit.type, dash.currentUnit.id);
         }
     });
-    // ── tool_call: block CONTEXT.md writes without depth verification ──
-    // Active during both discussion flows (pendingAutoStart set) and
-    // queue flows (activeQueuePhase set). For multi-milestone queue flows,
-    // each milestone must pass its own depth verification before its
-    // CONTEXT.md can be written.
+    // ── tool_call: block CONTEXT.md writes during discussion without depth verification ──
     pi.on("tool_call", async (event) => {
         if (!isToolCallEventType("write", event))
             return;
-        const { getDiscussionMilestoneId } = await loadGuidedFlowModule();
         const result = shouldBlockContextWrite(event.toolName, event.input.path, getDiscussionMilestoneId(), isDepthVerified(), activeQueuePhase);
         if (result.block)
             return result;
     });
     // ── tool_result: persist discussion exchanges & detect depth gate ──────
-    // Handles both discussion flows and queue flows. For queue flows,
-    // depth verification question IDs may include milestone IDs
-    // (e.g., "depth_verification_M001") for per-milestone gating.
     pi.on("tool_result", async (event) => {
         if (event.toolName !== "ask_user_questions")
             return;
-        const { getDiscussionMilestoneId } = await loadGuidedFlowModule();
         const milestoneId = getDiscussionMilestoneId();
-        // Queue flows don't set pendingAutoStart, so milestoneId may be null.
-        // Depth gate detection still applies — it sets per-milestone flags.
-        const inQueue = activeQueuePhase;
+        if (!milestoneId)
+            return;
         const details = event.details;
         if (details?.cancelled || !details?.response)
             return;
         // ── Depth gate detection ──────────────────────────────────────────
-        // Supports two patterns:
-        //   1. "depth_verification" — wildcard, marks all milestones verified
-        //   2. "depth_verification_M001" — per-milestone verification
         const questions = event.input?.questions ?? [];
         for (const q of questions) {
             if (typeof q.id === "string" && q.id.includes("depth_verification")) {
-                // Extract milestone ID from question ID if present
-                const midMatch = q.id.match(/depth_verification[_-](M\d+(?:-[a-z0-9]{6})?)/i);
-                if (midMatch) {
-                    depthVerifiedMilestones.add(midMatch[1]);
-                }
-                else {
-                    // Wildcard — all milestones verified (backward compat for single-milestone)
-                    depthVerifiedMilestones.add("*");
-                }
+                depthVerificationDone = true;
                 break;
             }
         }
-        // Discussion persistence only applies when in a discussion flow with a known milestone
-        if (!milestoneId)
-            return;
         // ── Persist exchange to DISCUSSION.md ──────────────────────────────
         const basePath = process.cwd();
         const milestoneDir = resolveMilestonePath(basePath, milestoneId);
@@ -1069,13 +936,11 @@ export default function (pi) {
     });
     // ── tool_execution_start/end: track in-flight tools for idle detection ──
     pi.on("tool_execution_start", async (event) => {
-        const { isAutoActive, markToolStart } = await loadAutoModule();
         if (!isAutoActive())
             return;
         markToolStart(event.toolCallId);
     });
     pi.on("tool_execution_end", async (event) => {
-        const { markToolEnd } = await loadAutoModule();
         markToolEnd(event.toolCallId);
     });
 }
@@ -1088,7 +953,6 @@ async function buildGuidedExecuteContextInjection(prompt, basePath) {
     const resumeMatch = prompt.match(/Resume interrupted work\.[\s\S]*?slice\s+(S\d+)\s+of milestone\s+(M\d+(?:-[a-z0-9]{6})?)/i);
     if (resumeMatch) {
         const [, sliceId, milestoneId] = resumeMatch;
-        const { deriveState } = await loadStateModule();
         const state = await deriveState(basePath);
         if (state.activeMilestone?.id === milestoneId &&
             state.activeSlice?.id === sliceId &&