gsd-pi 2.37.1-dev.d3ace49 → 2.38.0-dev.63ad7e5

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

@@ -5,9 +5,9 @@
  * pattern with a while loop. The agent_end event resolves a promise instead
  * of recursing.
  *
- * MAINTENANCE RULE: The only module-level mutable state here is `_activeSession`,
- * used by the agent_end bridge. Promise state itself lives on AutoSession so
- * concurrent auto sessions cannot corrupt each other.
+ * MAINTENANCE RULE: Module-level mutable state is limited to `_currentResolve`
+ * (per-unit one-shot resolver) and `_sessionSwitchInFlight` (guard for
+ * session rotation). No queue — stale agent_end events are dropped.
  */
 import { NEW_SESSION_TIMEOUT_MS } from "./auto/session.js";
 import { debugLog } from "./debug-logger.js";
@@ -18,71 +18,66 @@ import { debugLog } from "./debug-logger.js";
  * generous headroom including retries and sidecar work.
  */
 const MAX_LOOP_ITERATIONS = 500;
-// ─── Session-scoped promise state ───────────────────────────────────────────
+/** 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" },
+];
+// ─── Per-unit one-shot promise state ────────────────────────────────────────
 //
-// pendingResolve and pendingAgentEndQueue live on AutoSession (not module-level)
-// so concurrent sessions cannot corrupt each other's promises.
-/**
- * The singleton session reference used by resolveAgentEnd. Set by autoLoop
- * on entry so that the agent_end handler in index.ts can resolve the correct
- * session's promise without needing a direct reference to `s`.
- */
-let _activeSession = null;
+// A single module-level resolve function scoped to the current unit execution.
+// No queue — if an agent_end arrives with no pending resolver, it is dropped
+// (logged as warning). This is simpler and safer than the previous session-
+// scoped pendingResolve + pendingAgentEndQueue pattern.
+let _currentResolve = null;
+let _sessionSwitchInFlight = false;
 // ─── resolveAgentEnd ─────────────────────────────────────────────────────────
 /**
  * Called from the agent_end event handler in index.ts to resolve the
  * in-flight unit promise. One-shot: the resolver is nulled before calling
  * to prevent double-resolution from model fallback retries.
  *
- * If no pendingResolve exists (event arrived between loop iterations),
- * the event is queued on the session so the next runUnit can drain it.
+ * If no resolver exists (event arrived between loop iterations or during
+ * session switch), the event is dropped with a debug warning.
  */
 export function resolveAgentEnd(event) {
-    const s = _activeSession;
-    if (!s) {
-        debugLog("resolveAgentEnd", {
-            status: "no-active-session",
-            warning: "agent_end with no active loop session",
-        });
+    if (_sessionSwitchInFlight) {
+        debugLog("resolveAgentEnd", { status: "ignored-during-switch" });
         return;
     }
-    if (s.pendingResolve) {
+    if (_currentResolve) {
         debugLog("resolveAgentEnd", { status: "resolving", hasEvent: true });
-        const r = s.pendingResolve;
-        s.pendingResolve = null;
+        const r = _currentResolve;
+        _currentResolve = null;
         r({ status: "completed", event });
     }
     else {
-        // Queue the event so the next runUnit picks it up immediately
         debugLog("resolveAgentEnd", {
-            status: "queued",
-            queueLength: s.pendingAgentEndQueue.length + 1,
-            warning: "agent_end arrived between loop iterations — queued for next runUnit",
+            status: "no-pending-resolve",
+            warning: "agent_end with no pending unit",
         });
-        s.pendingAgentEndQueue.push(event);
     }
 }
 export function isSessionSwitchInFlight() {
-    return _activeSession?.sessionSwitchInFlight ?? false;
+    return _sessionSwitchInFlight;
 }
 // ─── resetPendingResolve (test helper) ───────────────────────────────────────
 /**
- * Reset session promise state. Only exported for test cleanup — production code
- * should never call this.
+ * Reset module-level promise state. Only exported for test cleanup —
+ * production code should never call this.
  */
 export function _resetPendingResolve() {
-    if (_activeSession) {
-        _activeSession.pendingResolve = null;
-        _activeSession.pendingAgentEndQueue = [];
-    }
-    _activeSession = null;
+    _currentResolve = null;
+    _sessionSwitchInFlight = false;
 }
 /**
- * Set the active session for resolveAgentEnd. Only exported for test setup —
- * production code sets this via autoLoop entry.
+ * No-op for backward compatibility with tests that previously set the
+ * active session. The module no longer holds a session reference.
  */
-export function _setActiveSession(session) {
-    _activeSession = session;
+export function _setActiveSession(_session) {
+    // No-op — kept for test backward compatibility
 }
 // ─── runUnit ─────────────────────────────────────────────────────────────────
 /**
@@ -95,39 +90,14 @@ export function _setActiveSession(session) {
  */
 export async function runUnit(ctx, pi, s, unitType, unitId, prompt, _prefs) {
     debugLog("runUnit", { phase: "start", unitType, unitId });
-    // ── Drain queued events from error-recovery retries ──
-    // If an agent_end arrived between iterations (e.g. from a model fallback
-    // sendMessage retry), consume it immediately instead of creating a new promise.
-    // Cap queue to 3 entries to prevent unbounded growth from stale events.
-    if (s.pendingAgentEndQueue.length > 3) {
-        debugLog("runUnit", {
-            phase: "queue-overflow",
-            dropped: s.pendingAgentEndQueue.length - 1,
-            unitType,
-            unitId,
-        });
-        s.pendingAgentEndQueue = [
-            s.pendingAgentEndQueue[s.pendingAgentEndQueue.length - 1],
-        ];
-    }
-    if (s.pendingAgentEndQueue.length > 0) {
-        const queued = s.pendingAgentEndQueue.shift();
-        debugLog("runUnit", {
-            phase: "drained-queued-event",
-            unitType,
-            unitId,
-            queueRemaining: s.pendingAgentEndQueue.length,
-        });
-        return { status: "completed", event: queued };
-    }
     // ── Session creation with timeout ──
     debugLog("runUnit", { phase: "session-create", unitType, unitId });
     let sessionResult;
     let sessionTimeoutHandle;
-    s.sessionSwitchInFlight = true;
+    _sessionSwitchInFlight = true;
     try {
         const sessionPromise = s.cmdCtx.newSession().finally(() => {
-            s.sessionSwitchInFlight = false;
+            _sessionSwitchInFlight = false;
         });
         const timeoutPromise = new Promise((resolve) => {
             sessionTimeoutHandle = setTimeout(() => resolve({ cancelled: true }), NEW_SESSION_TIMEOUT_MS);
@@ -155,11 +125,12 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt, _prefs) {
     if (!s.active) {
         return { status: "cancelled" };
     }
-    // ── Create the agent_end promise (session-scoped) ──
+    // ── Create the agent_end promise (per-unit one-shot) ──
     // This happens after newSession completes so session-switch agent_end events
     // from the previous session cannot resolve the new unit.
+    _sessionSwitchInFlight = false;
     const unitPromise = new Promise((resolve) => {
-        s.pendingResolve = resolve;
+        _currentResolve = resolve;
     });
     // Ensure cwd matches basePath before dispatch (#1389).
     // async_bash and background jobs can drift cwd away from the worktree.
@@ -195,7 +166,6 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt, _prefs) {
  */
 export async function autoLoop(ctx, pi, s, deps) {
     debugLog("autoLoop", { phase: "enter" });
-    _activeSession = s;
     let iteration = 0;
     let lastDerivedUnit = "";
     let sameUnitCount = 0;
@@ -373,7 +343,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 +352,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 +463,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 +524,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                 midTitle: midTitle,
                 state,
                 prefs,
+                session: s,
             });
             if (dispatchResult.action === "stop") {
                 if (s.currentUnit) {
@@ -916,8 +884,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", {
@@ -990,6 +961,6 @@ export async function autoLoop(ctx, pi, s, deps) {
             }
         }
     }
-    _activeSession = null;
+    _currentResolve = null;
     debugLog("autoLoop", { phase: "exit", totalIterations: iteration });
 }

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-prompts.js

@@ -12,10 +12,7 @@ import { resolveSkillDiscoveryMode, resolveInlineLevel, loadEffectiveGSDPreferen
 import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { computeBudgets, resolveExecutorContextWindow } from "./context-budget.js";
-import { compressToTarget } from "./prompt-compressor.js";
-import { distillSummaries } from "./summary-distiller.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
-import { chunkByRelevance, formatChunks } from "./semantic-chunker.js";
 // ─── Executor Constraints ─────────────────────────────────────────────────────
 /**
  * Format executor context constraints for injection into the plan-slice prompt.
@@ -126,14 +123,10 @@ export async function inlineFileSmart(absPath, relPath, label, query, threshold
     if (content.length <= threshold || !query) {
         return `### ${label}\nSource: \`${relPath}\`\n\n${content.trim()}`;
     }
-    // Use semantic chunking for large files
-    const result = chunkByRelevance(content, query, { maxChunks: 5, minScore: 0.05 });
-    // If chunking didn't save much (< 20%), just include full content
-    if (result.savingsPercent < 20) {
-        return `### ${label}\nSource: \`${relPath}\`\n\n${content.trim()}`;
-    }
-    const formatted = formatChunks(result, relPath);
-    return `### ${label} (${result.omittedChunks} sections omitted for relevance)\nSource: \`${relPath}\`\n\n${formatted}`;
+    // For large files, truncate at section boundary
+    const { truncateAtSectionBoundary } = await import("./context-budget.js");
+    const truncated = truncateAtSectionBoundary(content, threshold).content;
+    return `### ${label}\nSource: \`${relPath}\`\n\n${truncated}`;
 }
 /**
  * Load and inline dependency slice summaries (full content, not just paths).
@@ -165,20 +158,6 @@ export async function inlineDependencySummaries(mid, sid, base, budgetChars) {
     }
     const result = sections.join("\n\n");
     if (budgetChars !== undefined && result.length > budgetChars) {
-        // For 3+ summaries, try distillation first (preserves more information)
-        if (sections.length >= 3) {
-            const rawSummaries = sections.map(s => {
-                // Extract content after the header line
-                const lines = s.split("\n");
-                const contentStart = lines.findIndex(l => l.startsWith("Source:"));
-                return contentStart >= 0 ? lines.slice(contentStart + 1).join("\n").trim() : s;
-            });
-            const distilled = distillSummaries(rawSummaries, budgetChars);
-            if (distilled.content.length <= budgetChars) {
-                return distilled.content;
-            }
-        }
-        // Fall back to section-boundary truncation
         const { truncateAtSectionBoundary } = await import("./context-budget.js");
         return truncateAtSectionBoundary(result, budgetChars).content;
     }
@@ -777,15 +756,12 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     const contextWindow = resolveExecutorContextWindow(undefined, prefs?.preferences);
     const budgets = computeBudgets(contextWindow);
     const verificationBudget = `~${Math.round(budgets.verificationBudgetChars / 1000)}K chars`;
-    // Compress carry-forward section when it exceeds 40% of inline context budget.
-    // Only compress when compression_strategy is "compress" (budget/balanced profiles).
+    // Truncate carry-forward section when it exceeds 40% of inline context budget.
     const carryForwardBudget = Math.floor(budgets.inlineContextBudgetChars * 0.4);
     let finalCarryForward = carryForwardSection;
     if (carryForwardSection.length > carryForwardBudget) {
-        const { resolveCompressionStrategy } = await import("./preferences.js");
-        if (resolveCompressionStrategy() === "compress") {
-            finalCarryForward = compressToTarget(carryForwardSection, carryForwardBudget).content;
-        }
+        const { truncateAtSectionBoundary } = await import("./context-budget.js");
+        finalCarryForward = truncateAtSectionBoundary(carryForwardSection, carryForwardBudget).content;
     }
     return loadPrompt("execute-task", {
         overridesSection,

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

@@ -11,7 +11,7 @@
 import { deriveState } from "./state.js";
 import { loadFile, getManifestStatus } from "./files.js";
 import { loadEffectiveGSDPreferences, resolveSkillDiscoveryMode, getIsolationMode, } from "./preferences.js";
-import { ensureGsdSymlink } from "./repo-identity.js";
+import { ensureGsdSymlink, validateProjectId } from "./repo-identity.js";
 import { migrateToExternalState, recoverFailedMigration } from "./migrate-external.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
 import { gsdRoot, resolveMilestoneFile } from "./paths.js";
@@ -63,6 +63,12 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         return false;
     }
     try {
+        // Validate GSD_PROJECT_ID early so the user gets immediate feedback
+        const customProjectId = process.env.GSD_PROJECT_ID;
+        if (customProjectId && !validateProjectId(customProjectId)) {
+            ctx.ui.notify(`GSD_PROJECT_ID must contain only alphanumeric characters, hyphens, and underscores. Got: "${customProjectId}"`, "error");
+            return releaseLockAndReturn();
+        }
         // Ensure git repo exists
         if (!nativeIsRepo(base)) {
             const mainBranch = loadEffectiveGSDPreferences()?.preferences?.git?.main_branch || "main";
@@ -303,11 +309,16 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // ── Auto-worktree setup ──
         s.originalBasePath = base;
         const isUnderGsdWorktrees = (p) => {
+            // Direct layout: /.gsd/worktrees/
             const marker = `${pathSep}.gsd${pathSep}worktrees${pathSep}`;
             if (p.includes(marker))
                 return true;
             const worktreesSuffix = `${pathSep}.gsd${pathSep}worktrees`;
-            return p.endsWith(worktreesSuffix);
+            if (p.endsWith(worktreesSuffix))
+                return true;
+            // Symlink-resolved layout: /.gsd/projects/<hash>/worktrees/
+            const symlinkRe = new RegExp(`\\${pathSep}\\.gsd\\${pathSep}projects\\${pathSep}[a-f0-9]+\\${pathSep}worktrees(?:\\${pathSep}|$)`);
+            return symlinkRe.test(p);
         };
         if (s.currentMilestoneId &&
             shouldUseWorktreeIsolation() &&