gsd-pi 2.38.0-dev.96dc7fb → 2.38.0-dev.bc2e21e

package/dist/app-paths.js

@@ -1,6 +1,6 @@
 import { homedir } from 'os';
 import { join } from 'path';
-export const appRoot = join(homedir(), '.gsd');
+export const appRoot = process.env.GSD_HOME || join(homedir(), '.gsd');
 export const agentDir = join(appRoot, 'agent');
 export const sessionsDir = join(appRoot, 'sessions');
 export const authFilePath = join(agentDir, 'auth.json');

package/dist/extension-registry.js

@@ -6,7 +6,7 @@
  * The only way an extension stops loading is an explicit `gsd extensions disable <id>`.
  */
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
+import { appRoot } from "./app-paths.js";
 import { dirname, join } from "node:path";
 // ─── Validation ─────────────────────────────────────────────────────────────
 function isRegistry(data) {
@@ -26,7 +26,7 @@ function isManifest(data) {
 }
 // ─── Registry Path ──────────────────────────────────────────────────────────
 export function getRegistryPath() {
-    return join(homedir(), ".gsd", "extensions", "registry.json");
+    return join(appRoot, "extensions", "registry.json");
 }
 // ─── Registry I/O ───────────────────────────────────────────────────────────
 function defaultRegistry() {

package/dist/remote-questions-config.js

@@ -9,12 +9,12 @@
  */
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { homedir } from "node:os";
+import { appRoot } from "./app-paths.js";
 // Inlined from preferences.ts to avoid crossing the compiled/uncompiled
 // boundary — this file is compiled by tsc, but preferences.ts is loaded
 // via jiti at runtime. Importing it as .js fails because no .js exists
 // in dist/. See #592, #1110.
-const GLOBAL_PREFERENCES_PATH = join(homedir(), ".gsd", "preferences.md");
+const GLOBAL_PREFERENCES_PATH = join(appRoot, "preferences.md");
 export function saveRemoteQuestionsConfig(channel, channelId) {
     const prefsPath = GLOBAL_PREFERENCES_PATH;
     const block = [

package/dist/resources/extensions/env-utils.js

@@ -0,0 +1,29 @@
+// GSD Extension — Environment variable utilities
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+//
+// Pure utility for checking existing env keys in .env files and process.env.
+// Extracted from get-secrets-from-user.ts to avoid pulling in @gsd/pi-tui
+// when only env-checking is needed (e.g. from files.ts during report generation).
+import { readFile } from "node:fs/promises";
+/**
+ * Check which keys already exist in a .env file or process.env.
+ * Returns the subset of `keys` that are already set.
+ */
+export async function checkExistingEnvKeys(keys, envFilePath) {
+    let fileContent = "";
+    try {
+        fileContent = await readFile(envFilePath, "utf8");
+    }
+    catch {
+        // ENOENT or other read error — proceed with empty content
+    }
+    const existing = [];
+    for (const key of keys) {
+        const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const regex = new RegExp(`^${escaped}\\s*=`, "m");
+        if (regex.test(fileContent) || key in process.env) {
+            existing.push(key);
+        }
+    }
+    return existing;
+}

package/dist/resources/extensions/get-secrets-from-user.js

@@ -46,30 +46,11 @@ async function writeEnvKey(filePath, key, value) {
     await writeFile(filePath, content, "utf8");
 }
 // ─── Exported utilities ───────────────────────────────────────────────────────
-/**
- * Check which keys already exist in the .env file or process.env.
- * Returns the subset of `keys` that are already set.
- * Handles ENOENT gracefully (still checks process.env).
- * Empty-string values count as existing.
- */
-export async function checkExistingEnvKeys(keys, envFilePath) {
-    let fileContent = "";
-    try {
-        fileContent = await readFile(envFilePath, "utf8");
-    }
-    catch {
-        // ENOENT or other read error — proceed with empty content
-    }
-    const existing = [];
-    for (const key of keys) {
-        const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        const regex = new RegExp(`^${escaped}\\s*=`, "m");
-        if (regex.test(fileContent) || key in process.env) {
-            existing.push(key);
-        }
-    }
-    return existing;
-}
+// Re-export from env-utils.ts so existing consumers still work.
+// The implementation lives in env-utils.ts to avoid pulling @gsd/pi-tui
+// into modules that only need env-checking (e.g. files.ts during reports).
+import { checkExistingEnvKeys } from "./env-utils.js";
+export { checkExistingEnvKeys };
 /**
  * Detect the write destination based on project files in basePath.
  * Priority: vercel.json → convex/ dir → fallback "dotenv".

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

@@ -60,6 +60,8 @@ export class AutoSession {
     lastStateRebuildAt = 0;
     // ── Sidecar queue ─────────────────────────────────────────────────────
     sidecarQueue = [];
+    // ── Dispatch circuit breakers ──────────────────────────────────────
+    rewriteAttemptCount = 0;
     // ── Metrics ──────────────────────────────────────────────────────────────
     autoStartTime = 0;
     lastPromptCharCount;
@@ -160,6 +162,7 @@ export class AutoSession {
         this.lastBaselineCharCount = undefined;
         this.pendingQuickTasks = [];
         this.sidecarQueue = [];
+        this.rewriteAttemptCount = 0;
         // Signal handler
         this.sigtermHandler = null;
         // Loop promise state

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

@@ -22,25 +22,24 @@ function missingSliceStop(mid, phase) {
 }
 // ─── Rewrite Circuit Breaker ──────────────────────────────────────────────
 const MAX_REWRITE_ATTEMPTS = 3;
-let rewriteAttemptCount = 0;
-export function resetRewriteCircuitBreaker() {
-    rewriteAttemptCount = 0;
-}
 // ─── Rules ────────────────────────────────────────────────────────────────
 const DISPATCH_RULES = [
     {
         name: "rewrite-docs (override gate)",
-        match: async ({ mid, midTitle, state, basePath }) => {
+        match: async ({ mid, midTitle, state, basePath, session }) => {
             const pendingOverrides = await loadActiveOverrides(basePath);
             if (pendingOverrides.length === 0)
                 return null;
-            if (rewriteAttemptCount >= MAX_REWRITE_ATTEMPTS) {
+            const count = session?.rewriteAttemptCount ?? 0;
+            if (count >= MAX_REWRITE_ATTEMPTS) {
                 const { resolveAllOverrides } = await import("./files.js");
                 await resolveAllOverrides(basePath);
-                rewriteAttemptCount = 0;
+                if (session)
+                    session.rewriteAttemptCount = 0;
                 return null;
             }
-            rewriteAttemptCount++;
+            if (session)
+                session.rewriteAttemptCount++;
             const unitId = state.activeSlice ? `${mid}/${state.activeSlice.id}` : mid;
             return {
                 action: "dispatch",

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

@@ -18,6 +18,13 @@ import { debugLog } from "./debug-logger.js";
  * generous headroom including retries and sidecar work.
  */
 const MAX_LOOP_ITERATIONS = 500;
+/** Data-driven budget threshold notifications (75/80/90%). The 100% case is
+ *  handled inline because it requires break/pause/stop control flow. */
+const BUDGET_THRESHOLDS = [
+    { pct: 90, label: "Budget 90%", notifyLevel: "warning", cmuxLevel: "warning" },
+    { pct: 80, label: "Approaching budget ceiling — 80%", notifyLevel: "warning", cmuxLevel: "warning" },
+    { pct: 75, label: "Budget 75%", notifyLevel: "info", cmuxLevel: "progress" },
+];
 // ─── Session-scoped promise state ───────────────────────────────────────────
 //
 // pendingResolve and pendingAgentEndQueue live on AutoSession (not module-level)
@@ -57,9 +64,10 @@ export function resolveAgentEnd(event) {
         debugLog("resolveAgentEnd", {
             status: "queued",
             queueLength: s.pendingAgentEndQueue.length + 1,
+            unitId: s.currentUnit?.id,
             warning: "agent_end arrived between loop iterations — queued for next runUnit",
         });
-        s.pendingAgentEndQueue.push(event);
+        s.pendingAgentEndQueue.push({ ...event, unitId: s.currentUnit?.id });
     }
 }
 export function isSessionSwitchInFlight() {
@@ -111,14 +119,35 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt, _prefs) {
         ];
     }
     if (s.pendingAgentEndQueue.length > 0) {
-        const queued = s.pendingAgentEndQueue.shift();
+        // Find an event matching this unit; discard stale events from other units
+        const matchIdx = s.pendingAgentEndQueue.findIndex((e) => !e.unitId || e.unitId === unitId);
+        if (matchIdx >= 0) {
+            // Discard any stale events before the match
+            if (matchIdx > 0) {
+                debugLog("runUnit", {
+                    phase: "discarded-stale-events",
+                    count: matchIdx,
+                    unitType,
+                    unitId,
+                });
+            }
+            const queued = s.pendingAgentEndQueue.splice(0, matchIdx + 1).pop();
+            debugLog("runUnit", {
+                phase: "drained-queued-event",
+                unitType,
+                unitId,
+                queueRemaining: s.pendingAgentEndQueue.length,
+            });
+            return { status: "completed", event: queued };
+        }
+        // No matching event — discard all stale events and proceed to new session
         debugLog("runUnit", {
-            phase: "drained-queued-event",
+            phase: "discarded-all-stale-events",
+            count: s.pendingAgentEndQueue.length,
             unitType,
             unitId,
-            queueRemaining: s.pendingAgentEndQueue.length,
         });
-        return { status: "completed", event: queued };
+        s.pendingAgentEndQueue = [];
     }
     // ── Session creation with timeout ──
     debugLog("runUnit", { phase: "session-create", unitType, unitId });
@@ -493,29 +522,20 @@ export async function autoLoop(ctx, pi, s, deps) {
                     deps.sendDesktopNotification("GSD", msg, "warning", "budget");
                     deps.logCmuxEvent(prefs, msg, "warning");
                 }
-                else if (newBudgetAlertLevel === 90) {
-                    s.lastBudgetAlertLevel =
-                        newBudgetAlertLevel;
-                    ctx.ui.notify(`Budget 90%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`, "warning");
-                    deps.sendDesktopNotification("GSD", `Budget 90%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`, "warning", "budget");
-                    deps.logCmuxEvent(prefs, `Budget 90%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`, "warning");
-                }
-                else if (newBudgetAlertLevel === 80) {
-                    s.lastBudgetAlertLevel =
-                        newBudgetAlertLevel;
-                    ctx.ui.notify(`Approaching budget ceiling — 80%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`, "warning");
-                    deps.sendDesktopNotification("GSD", `Approaching budget ceiling — 80%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`, "warning", "budget");
-                    deps.logCmuxEvent(prefs, `Budget 80%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`, "warning");
-                }
-                else if (newBudgetAlertLevel === 75) {
-                    s.lastBudgetAlertLevel =
-                        newBudgetAlertLevel;
-                    ctx.ui.notify(`Budget 75%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`, "info");
-                    deps.sendDesktopNotification("GSD", `Budget 75%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`, "info", "budget");
-                    deps.logCmuxEvent(prefs, `Budget 75%: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`, "progress");
-                }
-                else if (budgetAlertLevel === 0) {
-                    s.lastBudgetAlertLevel = 0;
+                else {
+                    // Data-driven 75/80/90% threshold notifications
+                    const threshold = BUDGET_THRESHOLDS.find((t) => newBudgetAlertLevel === t.pct);
+                    if (threshold) {
+                        s.lastBudgetAlertLevel =
+                            newBudgetAlertLevel;
+                        const msg = `${threshold.label}: ${deps.formatCost(totalCost)} / ${deps.formatCost(budgetCeiling)}`;
+                        ctx.ui.notify(msg, threshold.notifyLevel);
+                        deps.sendDesktopNotification("GSD", msg, threshold.notifyLevel, "budget");
+                        deps.logCmuxEvent(prefs, msg, threshold.cmuxLevel);
+                    }
+                    else if (budgetAlertLevel === 0) {
+                        s.lastBudgetAlertLevel = 0;
+                    }
                 }
             }
             else {
@@ -563,6 +583,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                 midTitle: midTitle,
                 state,
                 prefs,
+                session: s,
             });
             if (dispatchResult.action === "stop") {
                 if (s.currentUnit) {
@@ -922,8 +943,11 @@ export async function autoLoop(ctx, pi, s, deps) {
                     sidecarBroke = true;
                     break;
                 }
-                // Run pre-verification for the sidecar unit
-                const sidecarPreResult = await deps.postUnitPreVerification(postUnitCtx);
+                // Run pre-verification for the sidecar unit (lightweight path)
+                const sidecarPreOpts = item.kind === "hook"
+                    ? { skipSettleDelay: true, skipDoctor: true, skipStateRebuild: true, skipWorktreeSync: true }
+                    : { skipSettleDelay: true, skipStateRebuild: true };
+                const sidecarPreResult = await deps.postUnitPreVerification(postUnitCtx, sidecarPreOpts);
                 if (sidecarPreResult === "dispatched") {
                     // Pre-verification caused stop/pause
                     debugLog("autoLoop", {

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

@@ -22,7 +22,6 @@ import { writeUnitRuntimeRecord, clearUnitRuntimeRecord } from "./unit-runtime.j
 import { runGSDDoctor, rebuildState, summarizeDoctorIssues } from "./doctor.js";
 import { recordHealthSnapshot, checkHealEscalation } from "./doctor-proactive.js";
 import { syncStateToProjectRoot } from "./auto-worktree-sync.js";
-import { resetRewriteCircuitBreaker } from "./auto-dispatch.js";
 import { isDbAvailable } from "./gsd-db.js";
 import { consumeSignal } from "./session-status-io.js";
 import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookState, } from "./post-unit-hooks.js";
@@ -36,7 +35,7 @@ const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
  *
  * Returns "dispatched" if a signal caused stop/pause, "continue" to proceed.
  */
-export async function postUnitPreVerification(pctx) {
+export async function postUnitPreVerification(pctx, opts) {
     const { s, ctx, pi, buildSnapshotOpts, stopAuto, pauseAuto } = pctx;
     // ── Parallel worker signal check ──
     const milestoneLock = process.env.GSD_MILESTONE_LOCK;
@@ -55,8 +54,10 @@ export async function postUnitPreVerification(pctx) {
     }
     // Invalidate all caches
     invalidateAllCaches();
-    // Small delay to let files settle
-    await new Promise(r => setTimeout(r, 500));
+    // Small delay to let files settle (skipped for sidecars where latency matters more)
+    if (!opts?.skipSettleDelay) {
+        await new Promise(r => setTimeout(r, 100));
+    }
     // Auto-commit
     if (s.currentUnit) {
         try {
@@ -79,8 +80,8 @@ export async function postUnitPreVerification(pctx) {
                                 };
                             }
                         }
-                        catch {
-                            // Non-fatal
+                        catch (e) {
+                            debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
                         }
                     }
                 }
@@ -90,57 +91,60 @@ export async function postUnitPreVerification(pctx) {
                 ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
             }
         }
-        catch {
-            // Non-fatal
+        catch (e) {
+            debugLog("postUnit", { phase: "auto-commit", error: String(e) });
         }
-        // Doctor: fix mechanical bookkeeping
-        try {
-            const scopeParts = s.currentUnit.id.split("/").slice(0, 2);
-            const doctorScope = scopeParts.join("/");
-            const sliceTerminalUnits = new Set(["complete-slice", "run-uat"]);
-            const effectiveFixLevel = sliceTerminalUnits.has(s.currentUnit.type) ? "all" : "task";
-            const report = await runGSDDoctor(s.basePath, { fix: true, scope: doctorScope, fixLevel: effectiveFixLevel });
-            if (report.fixesApplied.length > 0) {
-                ctx.ui.notify(`Post-hook: applied ${report.fixesApplied.length} fix(es).`, "info");
-            }
-            // Proactive health tracking
-            const summary = summarizeDoctorIssues(report.issues);
-            recordHealthSnapshot(summary.errors, summary.warnings, report.fixesApplied.length);
-            // Check if we should escalate to LLM-assisted heal
-            if (summary.errors > 0) {
-                const unresolvedErrors = report.issues
-                    .filter(i => i.severity === "error" && !i.fixable)
-                    .map(i => ({ code: i.code, message: i.message, unitId: i.unitId }));
-                const escalation = checkHealEscalation(summary.errors, unresolvedErrors);
-                if (escalation.shouldEscalate) {
-                    ctx.ui.notify(`Doctor heal escalation: ${escalation.reason}. Dispatching LLM-assisted heal.`, "warning");
-                    try {
-                        const { formatDoctorIssuesForPrompt, formatDoctorReport } = await import("./doctor.js");
-                        const { dispatchDoctorHeal } = await import("./commands-handlers.js");
-                        const actionable = report.issues.filter(i => i.severity === "error");
-                        const reportText = formatDoctorReport(report, { scope: doctorScope, includeWarnings: true });
-                        const structuredIssues = formatDoctorIssuesForPrompt(actionable);
-                        dispatchDoctorHeal(pi, doctorScope, reportText, structuredIssues);
-                    }
-                    catch {
-                        // Non-fatal
+        // Doctor: fix mechanical bookkeeping (skipped for lightweight sidecars)
+        if (!opts?.skipDoctor)
+            try {
+                const scopeParts = s.currentUnit.id.split("/").slice(0, 2);
+                const doctorScope = scopeParts.join("/");
+                const sliceTerminalUnits = new Set(["complete-slice", "run-uat"]);
+                const effectiveFixLevel = sliceTerminalUnits.has(s.currentUnit.type) ? "all" : "task";
+                const report = await runGSDDoctor(s.basePath, { fix: true, scope: doctorScope, fixLevel: effectiveFixLevel });
+                if (report.fixesApplied.length > 0) {
+                    ctx.ui.notify(`Post-hook: applied ${report.fixesApplied.length} fix(es).`, "info");
+                }
+                // Proactive health tracking
+                const summary = summarizeDoctorIssues(report.issues);
+                recordHealthSnapshot(summary.errors, summary.warnings, report.fixesApplied.length);
+                // Check if we should escalate to LLM-assisted heal
+                if (summary.errors > 0) {
+                    const unresolvedErrors = report.issues
+                        .filter(i => i.severity === "error" && !i.fixable)
+                        .map(i => ({ code: i.code, message: i.message, unitId: i.unitId }));
+                    const escalation = checkHealEscalation(summary.errors, unresolvedErrors);
+                    if (escalation.shouldEscalate) {
+                        ctx.ui.notify(`Doctor heal escalation: ${escalation.reason}. Dispatching LLM-assisted heal.`, "warning");
+                        try {
+                            const { formatDoctorIssuesForPrompt, formatDoctorReport } = await import("./doctor.js");
+                            const { dispatchDoctorHeal } = await import("./commands-handlers.js");
+                            const actionable = report.issues.filter(i => i.severity === "error");
+                            const reportText = formatDoctorReport(report, { scope: doctorScope, includeWarnings: true });
+                            const structuredIssues = formatDoctorIssuesForPrompt(actionable);
+                            dispatchDoctorHeal(pi, doctorScope, reportText, structuredIssues);
+                        }
+                        catch (e) {
+                            debugLog("postUnit", { phase: "doctor-heal-dispatch", error: String(e) });
+                        }
                     }
                 }
             }
-        }
-        catch {
-            // Non-fatal
-        }
-        // Throttled STATE.md rebuild
-        const now = Date.now();
-        if (now - s.lastStateRebuildAt >= STATE_REBUILD_MIN_INTERVAL_MS) {
-            try {
-                await rebuildState(s.basePath);
-                s.lastStateRebuildAt = now;
-                autoCommitCurrentBranch(s.basePath, "state-rebuild", s.currentUnit.id);
+            catch (e) {
+                debugLog("postUnit", { phase: "doctor", error: String(e) });
             }
-            catch {
-                // Non-fatal
+        // Throttled STATE.md rebuild (skipped for lightweight sidecars)
+        if (!opts?.skipStateRebuild) {
+            const now = Date.now();
+            if (now - s.lastStateRebuildAt >= STATE_REBUILD_MIN_INTERVAL_MS) {
+                try {
+                    await rebuildState(s.basePath);
+                    s.lastStateRebuildAt = now;
+                    autoCommitCurrentBranch(s.basePath, "state-rebuild", s.currentUnit.id);
+                }
+                catch (e) {
+                    debugLog("postUnit", { phase: "state-rebuild", error: String(e) });
+                }
             }
         }
         // Prune dead bg-shell processes
@@ -148,27 +152,27 @@ export async function postUnitPreVerification(pctx) {
             const { pruneDeadProcesses } = await import("../bg-shell/process-manager.js");
             pruneDeadProcesses();
         }
-        catch {
-            // Non-fatal
+        catch (e) {
+            debugLog("postUnit", { phase: "prune-bg-shell", error: String(e) });
         }
-        // Sync worktree state back to project root
-        if (s.originalBasePath && s.originalBasePath !== s.basePath) {
+        // Sync worktree state back to project root (skipped for lightweight sidecars)
+        if (!opts?.skipWorktreeSync && s.originalBasePath && s.originalBasePath !== s.basePath) {
             try {
                 syncStateToProjectRoot(s.basePath, s.originalBasePath, s.currentMilestoneId);
             }
-            catch {
-                // Non-fatal
+            catch (e) {
+                debugLog("postUnit", { phase: "worktree-sync", error: String(e) });
             }
         }
         // Rewrite-docs completion
         if (s.currentUnit.type === "rewrite-docs") {
             try {
                 await resolveAllOverrides(s.basePath);
-                resetRewriteCircuitBreaker();
+                s.rewriteAttemptCount = 0;
                 ctx.ui.notify("Override(s) resolved — rewrite-docs completed.", "info");
             }
-            catch {
-                // Non-fatal
+            catch (e) {
+                debugLog("postUnit", { phase: "rewrite-docs-resolve", error: String(e) });
             }
         }
         // Reactive state cleanup on slice completion
@@ -181,8 +185,8 @@ export async function postUnitPreVerification(pctx) {
                     clearReactiveState(s.basePath, mid, sid);
                 }
             }
-            catch {
-                // Non-fatal
+            catch (e) {
+                debugLog("postUnit", { phase: "reactive-state-cleanup", error: String(e) });
             }
         }
         // Post-triage: execute actionable resolutions
@@ -224,8 +228,8 @@ export async function postUnitPreVerification(pctx) {
                     invalidateAllCaches();
                 }
             }
-            catch {
-                // Non-fatal
+            catch (e) {
+                debugLog("postUnit", { phase: "artifact-verify", error: String(e) });
             }
         }
         else {
@@ -238,8 +242,8 @@ export async function postUnitPreVerification(pctx) {
                 });
                 clearUnitRuntimeRecord(s.basePath, s.currentUnit.type, s.currentUnit.id);
             }
-            catch {
-                // Non-fatal
+            catch (e) {
+                debugLog("postUnit", { phase: "hook-finalize", error: String(e) });
             }
         }
     }
@@ -352,8 +356,8 @@ export async function postUnitPostVerification(pctx) {
                 }
             }
         }
-        catch {
-            // Triage check failure is non-fatal
+        catch (e) {
+            debugLog("postUnit", { phase: "triage-check", error: String(e) });
         }
     }
     // ── Quick-task dispatch ──
@@ -387,8 +391,8 @@ export async function postUnitPostVerification(pctx) {
             ctx.ui.notify(`Executing quick-task: ${capture.id} — "${capture.text}"`, "info");
             return "continue";
         }
-        catch {
-            // Non-fatal — proceed to normal dispatch
+        catch (e) {
+            debugLog("postUnit", { phase: "quick-task-dispatch", error: String(e) });
         }
     }
     // Step mode → show wizard instead of dispatch

package/dist/resources/extensions/gsd/auto-worktree-sync.js

@@ -13,6 +13,7 @@ import { existsSync, readFileSync, unlinkSync, readdirSync, } from "node:fs";
 import { join, sep as pathSep } from "node:path";
 import { homedir } from "node:os";
 import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 // ─── Project Root → Worktree Sync ─────────────────────────────────────────
 /**
  * Sync milestone artifacts from project root INTO worktree before deriveState.
@@ -75,7 +76,7 @@ export function syncStateToProjectRoot(worktreePath, projectRoot, milestoneId) {
  * doesn't falsely trigger staleness (#804).
  */
 export function readResourceVersion() {
-    const agentDir = process.env.GSD_CODING_AGENT_DIR || join(homedir(), ".gsd", "agent");
+    const agentDir = process.env.GSD_CODING_AGENT_DIR || join(gsdHome, "agent");
     const manifestPath = join(agentDir, "managed-resources.json");
     try {
         const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));

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

@@ -374,39 +374,23 @@ export async function stopAuto(ctx, pi, reason) {
             unlinkSync(pausedPath);
     }
     catch { /* non-fatal */ }
-    s.active = false;
-    s.paused = false;
-    s.stepMode = false;
-    s.unitDispatchCount.clear();
-    s.unitRecoveryCount.clear();
+    // Restore original model before reset() clears the IDs
+    if (pi && ctx && s.originalModelId && s.originalModelProvider) {
+        const original = ctx.modelRegistry.find(s.originalModelProvider, s.originalModelId);
+        if (original)
+            await pi.setModel(original);
+    }
+    // External cleanup (not covered by session reset)
     clearInFlightTools();
-    s.lastBudgetAlertLevel = 0;
-    s.lastStateRebuildAt = 0;
-    s.unitLifetimeDispatches.clear();
-    s.currentUnit = null;
-    s.autoModeStartModel = null;
-    s.currentMilestoneId = null;
-    s.originalBasePath = "";
-    s.completedUnits = [];
-    s.pendingQuickTasks = [];
     clearSliceProgressCache();
     clearActivityLogState();
     resetProactiveHealing();
-    s.pendingCrashRecovery = null;
-    s.pendingVerificationRetry = null;
-    s.verificationRetryCount.clear();
-    s.pausedSessionFile = null;
+    // UI cleanup
     ctx?.ui.setStatus("gsd-auto", undefined);
     ctx?.ui.setWidget("gsd-progress", undefined);
     ctx?.ui.setFooter(undefined);
-    if (pi && ctx && s.originalModelId && s.originalModelProvider) {
-        const original = ctx.modelRegistry.find(s.originalModelProvider, s.originalModelId);
-        if (original)
-            await pi.setModel(original);
-        s.originalModelId = null;
-        s.originalModelProvider = null;
-    }
-    s.cmdCtx = null;
+    // Reset all session state in one call
+    s.reset();
 }
 /**
  * Pause auto-mode without destroying state. Context is preserved.

package/dist/resources/extensions/gsd/commands-extensions.js

@@ -8,12 +8,13 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 // ─── Registry I/O ───────────────────────────────────────────────────────────
 function getRegistryPath() {
-    return join(homedir(), ".gsd", "extensions", "registry.json");
+    return join(gsdHome, "extensions", "registry.json");
 }
 function getAgentExtensionsDir() {
-    return join(homedir(), ".gsd", "agent", "extensions");
+    return join(gsdHome, "agent", "extensions");
 }
 function loadRegistry() {
     const filePath = getRegistryPath();

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

@@ -7,6 +7,7 @@ import { existsSync, readFileSync, readdirSync, unlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 import { enableDebug } from "./debug-logger.js";
 import { deriveState } from "./state.js";
 import { GSDDashboardOverlay } from "./dashboard-overlay.js";
@@ -437,7 +438,7 @@ export function registerGSDCommand(pi) {
                 if (parts.length === 3 && ["enable", "disable", "info"].includes(parts[1])) {
                     const idPrefix = parts[2] ?? "";
                     try {
-                        const extDir = join(homedir(), ".gsd", "agent", "extensions");
+                        const extDir = join(gsdHome, "agent", "extensions");
                         const ids = [];
                         for (const entry of readdirSync(extDir, { withFileTypes: true })) {
                             if (!entry.isDirectory())