gsd-pi 2.37.1 → 2.38.0-dev.add4f78

package/README.md

@@ -629,7 +629,7 @@ GSD isn't locked to one provider. It runs on the [Pi SDK](https://github.com/bad
 
 ### Built-in Providers
 
-Anthropic, OpenAI, Google (Gemini), OpenRouter, GitHub Copilot, Amazon Bedrock, Azure OpenAI, Google Vertex, Groq, Cerebras, Mistral, xAI, HuggingFace, Vercel AI Gateway, and more.
+Anthropic, Anthropic (Vertex AI), OpenAI, Google (Gemini), OpenRouter, GitHub Copilot, Amazon Bedrock, Azure OpenAI, Google Vertex, Groq, Cerebras, Mistral, xAI, HuggingFace, Vercel AI Gateway, and more.
 
 ### OAuth / Max Plans
 

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/cli.js

@@ -505,6 +505,15 @@ if (enabledModelPatterns && enabledModelPatterns.length > 0) {
         session.setScopedModels(scopedModels);
     }
 }
+// Welcome screen — shown on every fresh interactive session before TUI takes over
+{
+    const { printWelcomeScreen } = await import('./welcome-screen.js');
+    printWelcomeScreen({
+        version: process.env.GSD_VERSION || '0.0.0',
+        modelName: settingsManager.getDefaultModel() || undefined,
+        provider: settingsManager.getDefaultProvider() || undefined,
+    });
+}
 const interactiveMode = new InteractiveMode(session);
 markStartup('InteractiveMode');
 printStartupTimings();

package/dist/extension-discovery.d.ts

@@ -1,9 +1,11 @@
 /**
  * Resolves the entry-point file(s) for a single extension directory.
  *
- * 1. If the directory contains a package.json with a `pi.extensions` array,
- *    each entry is resolved relative to the directory and returned (if it exists).
- * 2. Otherwise falls back to `index.ts` → `index.js`.
+ * 1. If the directory contains a package.json with a `pi` manifest object,
+ *    the manifest is authoritative:
+ *    - `pi.extensions` array → resolve each entry relative to the directory.
+ *    - `pi: {}` (no extensions) → return empty (library opt-out, e.g. cmux).
+ * 2. Only when no `pi` manifest exists does it fall back to `index.ts` → `index.js`.
  */
 export declare function resolveExtensionEntries(dir: string): string[];
 /**

package/dist/extension-discovery.js

@@ -6,24 +6,29 @@ function isExtensionFile(name) {
 /**
  * Resolves the entry-point file(s) for a single extension directory.
  *
- * 1. If the directory contains a package.json with a `pi.extensions` array,
- *    each entry is resolved relative to the directory and returned (if it exists).
- * 2. Otherwise falls back to `index.ts` → `index.js`.
+ * 1. If the directory contains a package.json with a `pi` manifest object,
+ *    the manifest is authoritative:
+ *    - `pi.extensions` array → resolve each entry relative to the directory.
+ *    - `pi: {}` (no extensions) → return empty (library opt-out, e.g. cmux).
+ * 2. Only when no `pi` manifest exists does it fall back to `index.ts` → `index.js`.
  */
 export function resolveExtensionEntries(dir) {
     const packageJsonPath = join(dir, 'package.json');
     if (existsSync(packageJsonPath)) {
         try {
             const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-            const declared = pkg?.pi?.extensions;
-            if (Array.isArray(declared)) {
-                const resolved = declared
+            if (pkg?.pi && typeof pkg.pi === 'object') {
+                // When a pi manifest exists, it is authoritative — don't fall through
+                // to index.ts/index.js auto-detection. This allows library directories
+                // (like cmux) to opt out by declaring "pi": {} with no extensions.
+                const declared = pkg.pi.extensions;
+                if (!Array.isArray(declared) || declared.length === 0) {
+                    return [];
+                }
+                return declared
                     .filter((entry) => typeof entry === 'string')
                     .map((entry) => resolve(dir, entry))
                     .filter((entry) => existsSync(entry));
-                if (resolved.length > 0) {
-                    return resolved;
-                }
             }
         }
         catch {

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/onboarding.js

@@ -38,6 +38,7 @@ const TOOL_KEYS = [
 /** Known LLM provider IDs that, if authed, mean the user doesn't need onboarding */
 const LLM_PROVIDER_IDS = [
     'anthropic',
+    'anthropic-vertex',
     'openai',
     'github-copilot',
     'openai-codex',

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/browser-tools/package.json

@@ -7,7 +7,9 @@
     "test": "node --test tests/*.test.mjs"
   },
   "pi": {
-    "extensions": ["./index.ts"]
+    "extensions": [
+      "./index.js"
+    ]
   },
   "peerDependencies": {
     "playwright": ">=1.40.0",

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

@@ -237,11 +237,14 @@ export class CmuxClient {
         return extractSurfaceIds(parsed);
     }
     async createSplit(direction) {
+        return this.createSplitFrom(this.config.surfaceId, direction);
+    }
+    async createSplitFrom(sourceSurfaceId, direction) {
         if (!this.config.splits)
             return null;
         const before = new Set(await this.listSurfaceIds());
         const args = ["new-split", direction];
-        const scopedArgs = this.appendSurface(this.appendWorkspace(args), this.config.surfaceId);
+        const scopedArgs = this.appendSurface(this.appendWorkspace(args), sourceSurfaceId);
         await this.runAsync(scopedArgs);
         const after = await this.listSurfaceIds();
         for (const id of after) {
@@ -250,6 +253,57 @@ export class CmuxClient {
         }
         return null;
     }
+    /**
+     * Create a grid of surfaces for parallel agent execution.
+     *
+     * Layout strategy (gsd stays in the original surface):
+     *   1 agent:  [gsd | A]
+     *   2 agents: [gsd | A]
+     *             [    | B]
+     *   3 agents: [gsd | A]
+     *             [ C  | B]
+     *   4 agents: [gsd | A]
+     *             [ C  | B]  (D splits from B downward)
+     *             [    | D]
+     *
+     * Returns surface IDs in order, or empty array on failure.
+     */
+    async createGridLayout(count) {
+        if (!this.config.splits || count <= 0)
+            return [];
+        const surfaces = [];
+        // First split: create right column from the gsd surface
+        const rightCol = await this.createSplitFrom(this.config.surfaceId, "right");
+        if (!rightCol)
+            return [];
+        surfaces.push(rightCol);
+        if (count === 1)
+            return surfaces;
+        // Second split: split right column down → bottom-right
+        const bottomRight = await this.createSplitFrom(rightCol, "down");
+        if (!bottomRight)
+            return surfaces;
+        surfaces.push(bottomRight);
+        if (count === 2)
+            return surfaces;
+        // Third split: split gsd surface down → bottom-left
+        const bottomLeft = await this.createSplitFrom(this.config.surfaceId, "down");
+        if (!bottomLeft)
+            return surfaces;
+        surfaces.push(bottomLeft);
+        if (count === 3)
+            return surfaces;
+        // Fourth+: split subsequent surfaces down from the last created
+        let lastSurface = bottomRight;
+        for (let i = 3; i < count; i++) {
+            const next = await this.createSplitFrom(lastSurface, "down");
+            if (!next)
+                break;
+            surfaces.push(next);
+            lastSurface = next;
+        }
+        return surfaces;
+    }
     async sendSurface(surfaceId, text) {
         const payload = text.endsWith("\n") ? text : `${text}\n`;
         const stdout = await this.runAsync(["send-surface", "--surface", surfaceId, payload]);

package/dist/resources/extensions/context7/package.json

@@ -5,7 +5,7 @@
   "type": "module",
   "pi": {
     "extensions": [
-      "./index.ts"
+      "./index.js"
     ]
   }
 }

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/google-search/package.json

@@ -4,6 +4,8 @@
   "version": "1.0.0",
   "type": "module",
   "pi": {
-    "extensions": ["./index.ts"]
+    "extensions": [
+      "./index.js"
+    ]
   }
 }

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

@@ -12,7 +12,7 @@ import { loadFile, loadActiveOverrides, parseRoadmap } from "./files.js";
 import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relSliceFile, buildMilestoneFileName, } from "./paths.js";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
+import { buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
 function missingSliceStop(mid, phase) {
     return {
         action: "stop",
@@ -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",
@@ -223,6 +222,72 @@ const DISPATCH_RULES = [
             };
         },
     },
+    {
+        name: "executing → reactive-execute (parallel dispatch)",
+        match: async ({ state, mid, midTitle, basePath, prefs }) => {
+            if (state.phase !== "executing" || !state.activeTask)
+                return null;
+            if (!state.activeSlice)
+                return null; // fall through
+            // Only activate when reactive_execution is explicitly enabled
+            const reactiveConfig = prefs?.reactive_execution;
+            if (!reactiveConfig?.enabled)
+                return null;
+            const sid = state.activeSlice.id;
+            const sTitle = state.activeSlice.title;
+            const maxParallel = reactiveConfig.max_parallel ?? 2;
+            // Dry-run mode: max_parallel=1 means graph is derived and logged but
+            // execution remains sequential
+            if (maxParallel <= 1)
+                return null;
+            try {
+                const { loadSliceTaskIO, deriveTaskGraph, isGraphAmbiguous, getReadyTasks, chooseNonConflictingSubset, graphMetrics, } = await import("./reactive-graph.js");
+                const taskIO = await loadSliceTaskIO(basePath, mid, sid);
+                if (taskIO.length < 2)
+                    return null; // single task, no point
+                const graph = deriveTaskGraph(taskIO);
+                // Ambiguous graph → fall through to sequential
+                if (isGraphAmbiguous(graph))
+                    return null;
+                const completed = new Set(graph.filter((n) => n.done).map((n) => n.id));
+                const readyIds = getReadyTasks(graph, completed, new Set());
+                // Only activate reactive dispatch when >1 task is ready
+                if (readyIds.length <= 1)
+                    return null;
+                const selected = chooseNonConflictingSubset(readyIds, graph, maxParallel, new Set());
+                if (selected.length <= 1)
+                    return null;
+                // Log graph metrics for observability
+                const metrics = graphMetrics(graph);
+                process.stderr.write(`gsd-reactive: ${mid}/${sid} graph — tasks:${metrics.taskCount} edges:${metrics.edgeCount} ` +
+                    `ready:${metrics.readySetSize} dispatching:${selected.length} ambiguous:${metrics.ambiguous}\n`);
+                // Persist dispatched batch so verification and recovery can check
+                // exactly which tasks were sent.
+                const { saveReactiveState } = await import("./reactive-graph.js");
+                saveReactiveState(basePath, mid, sid, {
+                    sliceId: sid,
+                    completed: [...completed],
+                    dispatched: selected,
+                    graphSnapshot: metrics,
+                    updatedAt: new Date().toISOString(),
+                });
+                // Encode selected task IDs in unitId for artifact verification.
+                // Format: M001/S01/reactive+T02,T03
+                const batchSuffix = selected.join(",");
+                return {
+                    action: "dispatch",
+                    unitType: "reactive-execute",
+                    unitId: `${mid}/${sid}/reactive+${batchSuffix}`,
+                    prompt: await buildReactiveExecutePrompt(mid, midTitle, sid, sTitle, selected, basePath),
+                };
+            }
+            catch (err) {
+                // Non-fatal — fall through to sequential execution
+                process.stderr.write(`gsd-reactive: graph derivation failed: ${err.message}\n`);
+                return null;
+            }
+        },
+    },
     {
         name: "executing → execute-task (recover missing task plan → plan-slice)",
         match: async ({ state, mid, midTitle, basePath }) => {

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 });
@@ -373,7 +402,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                     await deps.closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, deps.buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
                 }
                 const incomplete = state.registry.filter((m) => m.status !== "complete" && m.status !== "parked");
-                if (incomplete.length === 0) {
+                if (incomplete.length === 0 && state.registry.length > 0) {
                     // All milestones complete — merge milestone branch before stopping
                     if (s.currentMilestoneId) {
                         deps.resolver.mergeAndExit(s.currentMilestoneId, ctx.ui);
@@ -382,6 +411,12 @@ export async function autoLoop(ctx, pi, s, deps) {
                     deps.logCmuxEvent(deps.loadEffectiveGSDPreferences()?.preferences, "All milestones complete.", "success");
                     await deps.stopAuto(ctx, pi, "All milestones complete");
                 }
+                else if (incomplete.length === 0 && state.registry.length === 0) {
+                    // Empty registry — no milestones visible, likely a path resolution bug
+                    const diag = `basePath=${s.basePath}, phase=${state.phase}`;
+                    ctx.ui.notify(`No milestones visible in current scope. Possible path resolution issue.\n   Diagnostic: ${diag}`, "error");
+                    await deps.stopAuto(ctx, pi, `No milestones found — check basePath resolution`);
+                }
                 else if (state.phase === "blocked") {
                     const blockerMsg = `Blocked: ${state.blockers.join(", ")}`;
                     await deps.stopAuto(ctx, pi, blockerMsg);
@@ -487,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 {
@@ -557,6 +583,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                 midTitle: midTitle,
                 state,
                 prefs,
+                session: s,
             });
             if (dispatchResult.action === "stop") {
                 if (s.currentUnit) {
@@ -916,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", {