gsd-pi 2.78.0 → 2.78.1-dev.2ff77b0ce

package/dist/resources/extensions/github-sync/sync.js

@@ -140,8 +140,8 @@ async function syncMilestonePlan(basePath, mapping, config, mid) {
     });
 }
 async function syncSlicePlan(basePath, mapping, config, mid, sid) {
-    // Skip if already synced
-    if (getSliceRecord(mapping, mid, sid))
+    const existingSlice = getSliceRecord(mapping, mid, sid);
+    if (existingSlice)
         return;
     // Ensure milestone is synced first
     if (!getMilestoneRecord(mapping, mid)) {
@@ -157,7 +157,6 @@ async function syncSlicePlan(basePath, mapping, config, mid, sid) {
         return;
     const plan = parsePlan(content);
     const sliceBranch = `milestone/${mid}/${sid}`;
-    const milestoneBranch = `milestone/${mid}`;
     // Create task sub-issues first (so we can link them in the PR body)
     const taskIssueNumbers = [];
     if (plan.tasks) {
@@ -199,69 +198,80 @@ async function syncSlicePlan(basePath, mapping, config, mid, sid) {
             }
         }
     }
-    if (config.slice_prs === false) {
-        // Slice PRs disabled — just record without PR
-        setSliceRecord(mapping, mid, sid, {
-            issueNumber: 0,
-            prNumber: 0,
-            branch: sliceBranch,
-            lastSyncedAt: new Date().toISOString(),
-            state: "open",
-        });
-        return;
-    }
-    // Create slice branch from milestone branch
+    setSliceRecord(mapping, mid, sid, {
+        issueNumber: 0,
+        prNumber: 0,
+        branch: sliceBranch,
+        lastSyncedAt: new Date().toISOString(),
+        state: "open",
+    });
+    debugLog("github-sync", {
+        phase: "slice-synced",
+        mid,
+        sid,
+        pr: 0,
+        taskIssues: taskIssueNumbers.filter(t => t.issueNumber).length,
+    });
+}
+async function ensureSlicePullRequest(basePath, mapping, mid, sid) {
+    const sliceRecord = getSliceRecord(mapping, mid, sid);
+    if (!sliceRecord)
+        return null;
+    if (sliceRecord.prNumber)
+        return sliceRecord.prNumber;
+    const planPath = resolveSliceFile(basePath, mid, sid, "PLAN");
+    if (!planPath)
+        return null;
+    const content = await loadFile(planPath);
+    if (!content)
+        return null;
+    const plan = parsePlan(content);
+    const sliceBranch = sliceRecord.branch || `milestone/${mid}/${sid}`;
+    const milestoneBranch = `milestone/${mid}`;
     const branchResult = ghCreateBranch(basePath, sliceBranch, milestoneBranch);
     if (!branchResult.ok) {
         debugLog("github-sync", { phase: "create-slice-branch", error: branchResult.error });
-        // Branch might already exist — continue anyway
     }
-    // Push the slice branch
     const pushResult = ghPushBranch(basePath, sliceBranch);
     if (!pushResult.ok) {
         debugLog("github-sync", { phase: "push-slice-branch", error: pushResult.error });
+        return null;
     }
-    // Create draft PR
-    const prBody = formatSlicePRBody({
-        id: sid,
-        title: plan.title || sid,
-        goal: plan.goal,
-        mustHaves: plan.mustHaves,
-        demoCriterion: plan.demo,
-        tasks: taskIssueNumbers,
-    });
+    const tasks = (plan.tasks ?? []).map((task) => ({
+        id: task.id,
+        title: task.title,
+        issueNumber: getTaskRecord(mapping, mid, sid, task.id)?.issueNumber,
+    }));
     const prResult = ghCreatePR(basePath, {
         repo: mapping.repo,
         base: milestoneBranch,
         head: sliceBranch,
         title: `${sid}: ${plan.title || sid}`,
-        body: prBody,
+        body: formatSlicePRBody({
+            id: sid,
+            title: plan.title || sid,
+            goal: plan.goal,
+            mustHaves: plan.mustHaves,
+            demoCriterion: plan.demo,
+            tasks,
+        }),
         draft: true,
     });
-    const prNumber = prResult.ok ? prResult.data : 0;
     if (!prResult.ok) {
         debugLog("github-sync", { phase: "create-slice-pr", error: prResult.error });
+        return null;
     }
-    setSliceRecord(mapping, mid, sid, {
-        issueNumber: 0, // Slice doesn't get its own issue — tracked via PR
-        prNumber,
-        branch: sliceBranch,
-        lastSyncedAt: new Date().toISOString(),
-        state: "open",
-    });
-    debugLog("github-sync", {
-        phase: "slice-synced",
-        mid,
-        sid,
-        pr: prNumber,
-        taskIssues: taskIssueNumbers.filter(t => t.issueNumber).length,
-    });
+    sliceRecord.prNumber = prResult.data;
+    sliceRecord.lastSyncedAt = new Date().toISOString();
+    setSliceRecord(mapping, mid, sid, sliceRecord);
+    return sliceRecord.prNumber;
 }
 async function syncTaskComplete(basePath, mapping, config, mid, sid, tid) {
     const taskRecord = getTaskRecord(mapping, mid, sid, tid);
     if (!taskRecord || taskRecord.state === "closed")
         return;
     // Load task summary
+    let commentOk = true;
     const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
     if (summaryPath) {
         const content = await loadFile(summaryPath);
@@ -272,20 +282,37 @@ async function syncTaskComplete(basePath, mapping, config, mid, sid, tid) {
                 body: summary.whatHappened,
                 frontmatter: summary.frontmatter,
             });
-            ghAddComment(basePath, mapping.repo, taskRecord.issueNumber, comment);
+            const commentResult = ghAddComment(basePath, mapping.repo, taskRecord.issueNumber, comment);
+            commentOk = commentResult.ok;
+            if (!commentResult.ok) {
+                debugLog("github-sync", { phase: "task-comment-failed", mid, sid, tid, error: commentResult.error });
+            }
         }
     }
-    // Close the task issue
-    ghCloseIssue(basePath, mapping.repo, taskRecord.issueNumber);
-    taskRecord.state = "closed";
+    if (!commentOk)
+        return;
+    // Do not close the GitHub issue here. The task commit may still be local-only;
+    // closing before the commit/PR reaches GitHub breaks the remote audit trail.
+    // Commit trailers / PR merge should close linked issues once code is delivered.
+    taskRecord.state = "open";
     taskRecord.lastSyncedAt = new Date().toISOString();
     setTaskRecord(mapping, mid, sid, tid, taskRecord);
-    debugLog("github-sync", { phase: "task-closed", mid, sid, tid, issue: taskRecord.issueNumber });
+    debugLog("github-sync", { phase: "task-complete-commented", mid, sid, tid, issue: taskRecord.issueNumber });
 }
 async function syncSliceComplete(basePath, mapping, config, mid, sid) {
-    const sliceRecord = getSliceRecord(mapping, mid, sid);
+    let sliceRecord = getSliceRecord(mapping, mid, sid);
+    if (!sliceRecord) {
+        await syncSlicePlan(basePath, mapping, config, mid, sid);
+        sliceRecord = getSliceRecord(mapping, mid, sid);
+    }
     if (!sliceRecord || sliceRecord.state === "closed")
         return;
+    if (!sliceRecord.prNumber && config.slice_prs !== false) {
+        await ensureSlicePullRequest(basePath, mapping, mid, sid);
+        sliceRecord = getSliceRecord(mapping, mid, sid);
+        if (!sliceRecord || !sliceRecord.prNumber)
+            return;
+    }
     // Post slice summary as PR comment
     const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
     if (summaryPath && sliceRecord.prNumber) {
@@ -374,28 +401,29 @@ export async function bootstrapSync(basePath) {
     return counts;
 }
 // ─── Config Loading ─────────────────────────────────────────────────────────
-let _cachedConfig;
-function loadGitHubSyncConfig(_basePath) {
-    if (_cachedConfig !== undefined)
-        return _cachedConfig;
+const _cachedConfigByBasePath = new Map();
+function loadGitHubSyncConfig(basePath) {
+    if (_cachedConfigByBasePath.has(basePath))
+        return _cachedConfigByBasePath.get(basePath);
     try {
-        const prefs = loadEffectiveGSDPreferences();
+        const prefs = loadEffectiveGSDPreferences(basePath);
         const github = prefs?.preferences?.github;
         if (!github || typeof github !== "object") {
-            _cachedConfig = null;
+            _cachedConfigByBasePath.set(basePath, null);
             return null;
         }
-        _cachedConfig = github;
-        return _cachedConfig;
+        const config = github;
+        _cachedConfigByBasePath.set(basePath, config);
+        return config;
     }
     catch {
-        _cachedConfig = null;
+        _cachedConfigByBasePath.set(basePath, null);
         return null;
     }
 }
 /** Reset config cache (for testing). */
 export function _resetConfigCache() {
-    _cachedConfig = undefined;
+    _cachedConfigByBasePath.clear();
 }
 function resolveRepo(basePath) {
     const result = ghDetectRepo(basePath);

package/dist/resources/extensions/google-search/index.js

@@ -1,7 +1,3 @@
-export default function (pi) {
-    pi.on("session_start", async (_event, ctx) => {
-        ctx.ui.notify("google_search is being extracted to @gsd-extensions/google-search " +
-            "(not yet published to npm). This stub will be replaced once the " +
-            "package is available. No action needed for now.", "warning");
-    });
+export default function (_pi) {
+    // Deprecation notice intentionally suppressed until @gsd-extensions/google-search ships.
 }

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

@@ -163,6 +163,17 @@ function resolveDispatchNodeKind(unitType, sidecarItem) {
     }
     return "unit";
 }
+async function enforceMinRequestInterval(s, prefs) {
+    const minInterval = prefs?.min_request_interval_ms ?? 0;
+    if (minInterval > 0 && s.lastRequestTimestamp > 0) {
+        const elapsed = Date.now() - s.lastRequestTimestamp;
+        if (elapsed < minInterval) {
+            const waitMs = minInterval - elapsed;
+            debugLog("autoLoop", { phase: "rate-limit-wait", waitMs });
+            await new Promise(r => setTimeout(r, waitMs));
+        }
+    }
+}
 async function runUnitPhaseViaContract(dispatchContract, ic, iterData, loopState, sidecarItem) {
     if (dispatchContract === "legacy-direct") {
         return runUnitPhase(ic, iterData, loopState, sidecarItem);
@@ -392,7 +403,13 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     break;
                 }
                 // ── Unit execution (shared with dev path) ──
+                await enforceMinRequestInterval(s, prefs);
                 const unitPhaseResult = await runUnitPhaseViaContract(dispatchContract, ic, iterData, loopState);
+                if (unitPhaseResult.action === "next") {
+                    const requestTimestamp = unitPhaseResult.data.requestDispatchedAt ?? unitPhaseResult.data.unitStartedAt;
+                    if (typeof requestTimestamp === "number")
+                        s.lastRequestTimestamp = requestTimestamp;
+                }
                 deps.uokObserver?.onPhaseResult("unit", unitPhaseResult.action, {
                     unitType: iterData.unitType,
                     unitId: iterData.unitId,
@@ -555,7 +572,13 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     sidecarKind: sidecarItem.kind,
                 });
             }
+            await enforceMinRequestInterval(s, prefs);
             const unitPhaseResult = await runUnitPhaseViaContract(dispatchContract, ic, iterData, loopState, sidecarItem);
+            if (unitPhaseResult.action === "next") {
+                const requestTimestamp = unitPhaseResult.data.requestDispatchedAt ?? unitPhaseResult.data.unitStartedAt;
+                if (typeof requestTimestamp === "number")
+                    s.lastRequestTimestamp = requestTimestamp;
+            }
             deps.uokObserver?.onPhaseResult("unit", unitPhaseResult.action, {
                 unitType: iterData.unitType,
                 unitId: iterData.unitId,

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

@@ -7,10 +7,12 @@
  * Imports from: auto/types, auto/detect-stuck, auto/run-unit, auto/loop-deps
  */
 import { importExtensionModule } from "@gsd/pi-coding-agent";
+import { USER_DRIVEN_DEEP_UNITS, isAwaitingUserInput, } from "../auto-post-unit.js";
 import { MAX_RECOVERY_CHARS, BUDGET_THRESHOLDS, MAX_FINALIZE_TIMEOUTS, } from "./types.js";
 import { detectStuck } from "./detect-stuck.js";
 import { runUnit } from "./run-unit.js";
 import { debugLog } from "../debug-logger.js";
+import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { PROJECT_FILES, hasProjectFileInAncestor } from "../detection.js";
 import { MergeConflictError } from "../git-service.js";
 import { setCurrentPhase, clearCurrentPhase } from "../../shared/gsd-phase-state.js";
@@ -27,7 +29,7 @@ import { withTimeout, FINALIZE_PRE_TIMEOUT_MS, FINALIZE_POST_TIMEOUT_MS } from "
 import { getEligibleSlices } from "../slice-parallel-eligibility.js";
 import { startSliceParallel } from "../slice-parallel-orchestrator.js";
 import { isDbAvailable, getMilestoneSlices } from "../gsd-db.js";
-import { ensurePlanV2Graph, isMissingFinalizedContextResult } from "../uok/plan-v2.js";
+import { ensurePlanV2Graph, isEmptyPlanV2GraphResult, isMissingFinalizedContextResult } from "../uok/plan-v2.js";
 import { resolveUokFlags } from "../uok/flags.js";
 import { UokGateRunner } from "../uok/gate-runner.js";
 import { resetEvidence, loadEvidenceFromDisk } from "../safety/evidence-collector.js";
@@ -48,11 +50,7 @@ export function resetSessionTimeoutState() {
  * Exported for testing as _resolveReportBasePath.
  */
 export function _resolveReportBasePath(s) {
-    // Strip /.gsd/worktrees/ suffix when basePath is itself a worktree path and
-    // originalBasePath is falsy — prevents reports landing in the worktree (#3729).
-    const resolved = s.originalBasePath || s.basePath;
-    const markerIdx = resolved.indexOf("/.gsd/worktrees/");
-    return markerIdx !== -1 ? resolved.slice(0, markerIdx) : resolved;
+    return resolveWorktreeProjectRoot(s.basePath, s.originalBasePath);
 }
 /**
  * Resolve the authoritative project base for dispatch guards.
@@ -60,12 +58,7 @@ export function _resolveReportBasePath(s) {
  * unit is running inside an auto worktree.
  */
 export function _resolveDispatchGuardBasePath(s) {
-    // Strip /.gsd/worktrees/ suffix when basePath is itself a worktree path and
-    // originalBasePath is falsy — prevents guard checks running against the
-    // worktree instead of the project root (#3729).
-    const resolved = s.originalBasePath || s.basePath;
-    const markerIdx = resolved.indexOf("/.gsd/worktrees/");
-    return markerIdx !== -1 ? resolved.slice(0, markerIdx) : resolved;
+    return resolveWorktreeProjectRoot(s.basePath, s.originalBasePath);
 }
 const PLAN_V2_GATE_PHASES = new Set([
     "executing",
@@ -293,8 +286,48 @@ export async function runPreDispatch(ic, loopState) {
     }
     // Derive state
     let state = await deps.deriveState(s.basePath);
-    if (prefs?.uok?.plan_v2?.enabled && shouldRunPlanV2Gate(state.phase)) {
-        const compiled = ensurePlanV2Graph(s.basePath, state);
+    const { getDeepStageGate } = await import("../auto-dispatch.js");
+    const deepStageGate = getDeepStageGate(prefs, s.basePath);
+    const canRunDeepSetupGate = state.phase === "pre-planning" ||
+        state.phase === "needs-discussion" ||
+        state.phase === "planning";
+    if (canRunDeepSetupGate &&
+        (deepStageGate.status === "pending" || deepStageGate.status === "blocked")) {
+        debugLog("autoLoop", {
+            phase: "deep-project-stage-gate",
+            stage: deepStageGate.stage,
+            status: deepStageGate.status,
+            reason: deepStageGate.reason,
+        });
+        return {
+            action: "next",
+            data: {
+                state: {
+                    ...state,
+                    phase: "pre-planning",
+                    activeMilestone: null,
+                    activeSlice: null,
+                    activeTask: null,
+                    nextAction: deepStageGate.reason,
+                },
+                mid: "PROJECT",
+                midTitle: "Project setup",
+            },
+        };
+    }
+    if (uokFlags.planV2 && shouldRunPlanV2Gate(state.phase)) {
+        let compiled = ensurePlanV2Graph(s.basePath, state);
+        if (isEmptyPlanV2GraphResult(compiled)) {
+            deps.invalidateAllCaches();
+            state = await deps.deriveState(s.basePath);
+            compiled = shouldRunPlanV2Gate(state.phase)
+                ? ensurePlanV2Graph(s.basePath, state)
+                : {
+                    ok: true,
+                    reason: "empty plan-v2 graph recovered by state rederive",
+                    nodeCount: 0,
+                };
+        }
         if (!compiled.ok) {
             const reason = compiled.reason ?? "Plan v2 compilation failed";
             if (isMissingFinalizedContextResult(compiled)) {
@@ -443,7 +476,7 @@ export async function runPreDispatch(ic, loopState) {
         mid = state.activeMilestone?.id;
         midTitle = state.activeMilestone?.title;
         if (mid) {
-            if (deps.getIsolationMode() !== "none") {
+            if (deps.getIsolationMode(s.basePath) !== "none") {
                 deps.captureIntegrationBranch(s.basePath, mid);
             }
             deps.resolver.enterMilestone(mid, ctx.ui);
@@ -638,10 +671,16 @@ export async function runDispatch(ic, preData, loopState) {
         ? ctx.modelRegistry.getProviderAuthMode(provider)
         : undefined;
     const activeTools = typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [];
-    const structuredQuestionsAvailable = supportsStructuredQuestions(activeTools, {
-        authMode,
-        baseUrl: ctx.model?.baseUrl,
-    }) ? "true" : "false";
+    // Deep planning intentionally keeps human checkpoints in plain chat. In
+    // Claude Code/local MCP transports, structured question requests can be
+    // cancelled outside the normal chat flow, which made approval gates easy to
+    // skip or bury under tool output.
+    const structuredQuestionsAvailable = prefs?.planning_depth === "deep"
+        ? "false"
+        : supportsStructuredQuestions(activeTools, {
+            authMode,
+            baseUrl: ctx.model?.baseUrl,
+        }) ? "true" : "false";
     debugLog("autoLoop", { phase: "dispatch-resolve", iteration: ic.iteration });
     const dispatchResult = await deps.resolveDispatch({
         basePath: s.basePath,
@@ -652,6 +691,7 @@ export async function runDispatch(ic, preData, loopState) {
         session: s,
         structuredQuestionsAvailable,
         sessionContextWindow: ctx.model?.contextWindow,
+        sessionProvider: ctx.model?.provider,
         modelRegistry: ctx.modelRegistry,
     });
     if (dispatchResult.action === "stop") {
@@ -1041,6 +1081,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     s.currentUnit = { type: unitType, id: unitId, startedAt: Date.now() };
     s.lastGitActionFailure = null;
     s.lastGitActionStatus = null;
+    s.lastUnitAgentEndMessages = null;
     setCurrentPhase(unitType);
     s.lastToolInvocationError = null; // #2883: clear stale error from previous unit
     const unitStartSeq = ic.nextSeq();
@@ -1218,6 +1259,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         unitId,
     });
     const unitResult = await runUnit(ctx, pi, s, unitType, unitId, finalPrompt);
+    s.lastUnitAgentEndMessages = unitResult.event?.messages ?? null;
     debugLog("autoLoop", {
         phase: "runUnit-end",
         iteration: ic.iteration,
@@ -1356,16 +1398,25 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         if (currentLedger?.units) {
             const lastUnit = [...currentLedger.units].reverse().find((u) => u.type === unitType && u.id === unitId && u.startedAt === s.currentUnit?.startedAt);
             if (lastUnit && lastUnit.toolCalls === 0) {
-                debugLog("runUnitPhase", {
-                    phase: "zero-tool-calls",
-                    unitType,
-                    unitId,
-                    warning: "Unit completed with 0 tool calls — likely context exhaustion, marking as failed",
-                });
-                ctx.ui.notify(`${unitType} ${unitId} completed with 0 tool calls — context exhaustion, will retry`, "warning");
-                // Fall through to next iteration where dispatch will re-derive
-                // and re-dispatch this unit.
-                return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt } };
+                if (USER_DRIVEN_DEEP_UNITS.has(unitType) && isAwaitingUserInput(s.lastUnitAgentEndMessages ?? undefined)) {
+                    debugLog("runUnitPhase", {
+                        phase: "zero-tool-calls-awaiting-user-input",
+                        unitType,
+                        unitId,
+                    });
+                }
+                else {
+                    debugLog("runUnitPhase", {
+                        phase: "zero-tool-calls",
+                        unitType,
+                        unitId,
+                        warning: "Unit completed with 0 tool calls — likely context exhaustion, marking as failed",
+                    });
+                    ctx.ui.notify(`${unitType} ${unitId} completed with 0 tool calls — context exhaustion, will retry`, "warning");
+                    // Fall through to next iteration where dispatch will re-derive
+                    // and re-dispatch this unit.
+                    return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt, requestDispatchedAt: unitResult.requestDispatchedAt } };
+                }
             }
         }
     }
@@ -1418,7 +1469,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         }
         s.checkpointSha = null;
     }
-    return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt } };
+    return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt, requestDispatchedAt: unitResult.requestDispatchedAt } };
 }
 // ─── runFinalize ──────────────────────────────────────────────────────────────
 /**
@@ -1453,9 +1504,9 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
     // Sidecar items use lightweight pre-verification opts
     const preVerificationOpts = sidecarItem
         ? sidecarItem.kind === "hook"
-            ? { skipSettleDelay: true, skipWorktreeSync: true }
-            : { skipSettleDelay: true }
-        : undefined;
+            ? { skipSettleDelay: true, skipWorktreeSync: true, agentEndMessages: s.lastUnitAgentEndMessages ?? undefined }
+            : { skipSettleDelay: true, agentEndMessages: s.lastUnitAgentEndMessages ?? undefined }
+        : { agentEndMessages: s.lastUnitAgentEndMessages ?? undefined };
     const preUnitSnapshot = s.currentUnit
         ? { type: s.currentUnit.type, id: s.currentUnit.id, startedAt: s.currentUnit.startedAt }
         : null;

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

@@ -22,6 +22,29 @@ let sessionSwitchGeneration = 0;
  */
 export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     debugLog("runUnit", { phase: "start", unitType, unitId });
+    // Ensure cwd matches basePath BEFORE newSession() captures it. The new
+    // session reads process.cwd() during construction to anchor its tool
+    // runtime and system prompt; if cwd has drifted (async_bash, background
+    // jobs, prior unit cleanup), the session would otherwise be rooted to
+    // the wrong directory. Must be synchronous — no awaits between chdir
+    // and newSession (#1389, #4762 follow-up).
+    try {
+        if (process.cwd() !== s.basePath) {
+            process.chdir(s.basePath);
+        }
+    }
+    catch (e) {
+        const msg = `Failed to chdir to basePath before newSession (basePath: ${s.basePath}): ${String(e)}`;
+        logWarning("engine", msg, { basePath: s.basePath, error: String(e) });
+        return {
+            status: "cancelled",
+            errorContext: {
+                message: msg,
+                category: "session-failed",
+                isTransient: true,
+            },
+        };
+    }
     // ── Session creation with timeout ──
     debugLog("runUnit", { phase: "session-create", unitType, unitId });
     let sessionResult;
@@ -91,17 +114,6 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     const unitPromise = new Promise((resolve) => {
         _setCurrentResolve(resolve);
     });
-    // Ensure cwd matches basePath before dispatch (#1389).
-    // async_bash and background jobs can drift cwd away from the worktree.
-    // Realigning here prevents commits from landing on the wrong branch.
-    try {
-        if (process.cwd() !== s.basePath) {
-            process.chdir(s.basePath);
-        }
-    }
-    catch (e) {
-        logWarning("engine", "Failed to chdir to basePath before dispatch", { basePath: s.basePath, error: String(e) });
-    }
     // ── Provider request-readiness pre-check (#4555) ──
     // Verify the provider can accept requests before dispatching. If the token
     // has expired since bootstrap, return cancelled immediately so the unit is
@@ -138,6 +150,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     const capturedTurnGen = getCurrentTurnGeneration();
     // ── Send the prompt ──
     debugLog("runUnit", { phase: "send-message", unitType, unitId });
+    const requestDispatchedAt = Date.now();
     pi.sendMessage({ customType: "gsd-auto", content: prompt, display: s.verbose }, { triggerTurn: true });
     // ── Await agent_end with absolute timeout (H4 fix) ──
     // If supervision fails to resolve unitPromise within 30s, treat as cancelled.
@@ -160,6 +173,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
         unitId,
         status: result.status,
     });
+    const finalResult = { ...result, requestDispatchedAt };
     // Discard trailing follow-up messages (e.g. async_job_result notifications)
     // from the completed unit. Without this, queued follow-ups trigger wasteful
     // LLM turns before the next session can start (#1642).
@@ -174,5 +188,5 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     catch (e) {
         logWarning("engine", "clearQueue failed after unit completion", { error: String(e) });
     }
-    return result;
+    return finalResult;
 }

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

@@ -15,6 +15,7 @@
  * auto-session-encapsulation.test.ts enforce that auto.ts has no module-level
  * `let` or `var` declarations.
  */
+import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 // ─── Constants ───────────────────────────────────────────────────────────────
 export const STUB_RECOVERY_THRESHOLD = 2;
 export const NEW_SESSION_TIMEOUT_MS = 120_000;
@@ -92,6 +93,8 @@ export class AutoSession {
     /** Set when a GSD tool execution ends with isError due to malformed/truncated
      *  JSON arguments. Checked by postUnitPreVerification to break retry loops. */
     lastToolInvocationError = null;
+    /** Agent-end messages from the just-finished unit, consumed during finalize. */
+    lastUnitAgentEndMessages = null;
     /** Set when turn-level git action fails during closeout. */
     lastGitActionFailure = null;
     /** Last turn-level git action status captured during finalize. */
@@ -118,6 +121,8 @@ export class AutoSession {
     lastPromptCharCount;
     lastBaselineCharCount;
     pendingQuickTasks = [];
+    /** Timestamp of the last LLM request dispatch (ms since epoch). Used for proactive rate limiting. */
+    lastRequestTimestamp = 0;
     // ── Safety harness ───────────────────────────────────────────────────────
     /** SHA of the pre-unit git checkpoint ref. Cleared on success or rollback. */
     checkpointSha = null;
@@ -153,12 +158,7 @@ export class AutoSession {
         this.unitLifetimeDispatches.clear();
     }
     get lockBasePath() {
-        // Prefer originalBasePath (project root); fall back to basePath.
-        // Strip /.gsd/worktrees/ suffix if basePath is itself a worktree path
-        // to avoid reading/writing the lock inside the worktree (#3729).
-        const resolved = this.originalBasePath || this.basePath;
-        const markerIdx = resolved.indexOf("/.gsd/worktrees/");
-        return markerIdx !== -1 ? resolved.slice(0, markerIdx) : resolved;
+        return resolveWorktreeProjectRoot(this.basePath, this.originalBasePath);
     }
     reset() {
         this.clearTimers();
@@ -215,11 +215,13 @@ export class AutoSession {
         this.lastPromptCharCount = undefined;
         this.lastBaselineCharCount = undefined;
         this.pendingQuickTasks = [];
+        this.lastRequestTimestamp = 0;
         this.sidecarQueue = [];
         this.rewriteAttemptCount = 0;
         this.consecutiveCompleteBootstraps = 0;
         this.lastPreExecFailure = null;
         this.lastToolInvocationError = null;
+        this.lastUnitAgentEndMessages = null;
         this.lastGitActionFailure = null;
         this.lastGitActionStatus = null;
         this.isolationDegraded = false;