gsd-pi 2.78.0 → 2.78.1-dev.42ef05fbe

package/src/resources/extensions/claude-code-cli/tests/stream-adapter.test.ts

@@ -787,7 +787,7 @@ describe("stream-adapter — session persistence (#2859)", () => {
 		assert.equal("thinking" in options, false, "non-adaptive models must not receive a thinking field");
 	});
 
-	test("buildSdkOptions includes workflow MCP server config when env is set", () => {
+	test("buildSdkOptions prefers workflow MCP question tools over native AskUserQuestion", () => {
 		const restore = setWorkflowMcpEnv({
 			GSD_WORKFLOW_MCP_COMMAND: "node",
 			GSD_WORKFLOW_MCP_NAME: "gsd-workflow",
@@ -807,7 +807,7 @@ describe("stream-adapter — session persistence (#2859)", () => {
 			assert.equal(srv.env.GSD_CLI_PATH, "/tmp/gsd");
 			assert.equal(srv.env.GSD_PERSIST_WRITE_GATE_STATE, "1");
 			assert.equal(srv.env.GSD_WORKFLOW_PROJECT_ROOT, "/tmp/project");
-			assert.deepEqual(options.disallowedTools, []);
+			assert.deepEqual(options.disallowedTools, ["AskUserQuestion"]);
 			assert.deepEqual(options.allowedTools, [
 				"Read",
 				"Write",
@@ -818,7 +818,6 @@ describe("stream-adapter — session persistence (#2859)", () => {
 				"Agent",
 				"WebFetch",
 				"WebSearch",
-				"AskUserQuestion",
 				"mcp__gsd-workflow__*",
 			]);
 		} finally {
@@ -826,7 +825,7 @@ describe("stream-adapter — session persistence (#2859)", () => {
 		}
 	});
 
-	test("buildSdkOptions auto-approves every tool for custom workflow MCP server names", () => {
+	test("buildSdkOptions prefers custom workflow MCP question tools over native AskUserQuestion", () => {
 		const restore = setWorkflowMcpEnv({
 			GSD_WORKFLOW_MCP_COMMAND: "node",
 			GSD_WORKFLOW_MCP_NAME: "custom-workflow",
@@ -839,7 +838,7 @@ describe("stream-adapter — session persistence (#2859)", () => {
 			const options = buildSdkOptions("claude-sonnet-4-20250514", "test");
 			const mcpServers = options.mcpServers as Record<string, any>;
 			assert.ok(mcpServers?.["custom-workflow"], "expected custom workflow server config");
-			assert.deepEqual(options.disallowedTools, []);
+			assert.deepEqual(options.disallowedTools, ["AskUserQuestion"]);
 			assert.deepEqual(options.allowedTools, [
 				"Read",
 				"Write",
@@ -850,7 +849,6 @@ describe("stream-adapter — session persistence (#2859)", () => {
 				"Agent",
 				"WebFetch",
 				"WebSearch",
-				"AskUserQuestion",
 				"mcp__custom-workflow__*",
 			]);
 		} finally {
@@ -882,7 +880,7 @@ describe("stream-adapter — session persistence (#2859)", () => {
 			const mcpServers = (options as any).mcpServers;
 			if (mcpServers) {
 				assert.ok(mcpServers["gsd-workflow"], "if present, must be gsd-workflow");
-				assert.deepEqual((options as any).disallowedTools, []);
+				assert.deepEqual((options as any).disallowedTools, ["AskUserQuestion"]);
 			} else {
 				assert.deepEqual((options as any).disallowedTools, []);
 			}
@@ -923,7 +921,7 @@ describe("stream-adapter — session persistence (#2859)", () => {
 			assert.equal(srv.env.GSD_CLI_PATH, "/tmp/gsd");
 			assert.equal(srv.env.GSD_PERSIST_WRITE_GATE_STATE, "1");
 			assert.equal(srv.env.GSD_WORKFLOW_PROJECT_ROOT, resolvedRepoDir);
-			assert.deepEqual(options.disallowedTools, []);
+			assert.deepEqual(options.disallowedTools, ["AskUserQuestion"]);
 		} finally {
 			process.chdir(originalCwd);
 			rmSync(repoDir, { recursive: true, force: true });
@@ -1609,17 +1607,40 @@ describe("stream-adapter — canUseTool handler", () => {
 		assert.equal(notified.length, 0);
 	});
 
-	test("Always Allow for non-Bash without suggestions omits updatedPermissions", async () => {
+	test("Always Allow for non-Bash without suggestions builds tool-name-only fallback rule", async () => {
 		const notified: string[] = [];
 		const ui = { select: async (_p: string, opts: string[]) => opts.find((o) => o.startsWith("Always Allow"))!, notify: (msg: string) => notified.push(msg) };
 
 		const handler = createClaudeCodeCanUseToolHandler(ui as any);
-		const result = await handler!("Write", { file_path: "/tmp/test.txt" }, makeOptions());
+		const result = await handler!("AskUserQuestion", { questions: [{ question: "?", header: "h", multiSelect: false, options: [] }] }, makeOptions());
 
 		assert.equal(result.behavior, "allow");
-		assert.equal((result as any).updatedPermissions, undefined);
-		// No suggestions → no notification
-		assert.equal(notified.length, 0);
+		assert.deepEqual((result as any).updatedPermissions, [{
+			type: "addRules",
+			rules: [{ toolName: "AskUserQuestion" }],
+			behavior: "allow",
+			destination: "localSettings",
+		}]);
+		assert.equal(notified.length, 1);
+		assert.match(notified[0], /AskUserQuestion/);
+	});
+
+	test("Always Allow for non-Bash with empty suggestions array builds tool-name-only fallback rule", async () => {
+		const notified: string[] = [];
+		const ui = { select: async (_p: string, opts: string[]) => opts.find((o) => o.startsWith("Always Allow"))!, notify: (msg: string) => notified.push(msg) };
+
+		const handler = createClaudeCodeCanUseToolHandler(ui as any);
+		const result = await handler!("AskUserQuestion", { questions: [{ question: "?", header: "h", multiSelect: false, options: [] }] }, makeOptions({ suggestions: [] }));
+
+		assert.equal(result.behavior, "allow");
+		assert.deepEqual((result as any).updatedPermissions, [{
+			type: "addRules",
+			rules: [{ toolName: "AskUserQuestion" }],
+			behavior: "allow",
+			destination: "localSettings",
+		}]);
+		assert.equal(notified.length, 1);
+		assert.match(notified[0], /AskUserQuestion/);
 	});
 
 	test("prompt includes command text for Bash tools", async () => {

package/src/resources/extensions/google-search/index.ts

@@ -1,13 +1,6 @@
 // GSD-2 — Deprecation stub for google-search (moved to @gsd-extensions/google-search)
 import type { ExtensionAPI } from "@gsd/pi-coding-agent";
 
-export default function (pi: ExtensionAPI) {
-  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: ExtensionAPI) {
+  // Deprecation notice intentionally suppressed until @gsd-extensions/google-search ships.
 }

package/src/resources/extensions/gsd/auto/loop-deps.ts

@@ -113,7 +113,7 @@ export interface LoopDeps {
     basePath: string,
     mid: string,
   ) => void;
-  getIsolationMode: () => string;
+  getIsolationMode: (basePath?: string) => string;
   getCurrentBranch: (basePath: string) => string;
   autoWorktreeBranch: (milestoneId: string) => string;
   resolveMilestoneFile: (

package/src/resources/extensions/gsd/auto/loop.ts

@@ -195,19 +195,31 @@ function resolveDispatchNodeKind(
   return "unit";
 }
 
+async function enforceMinRequestInterval(s: AutoSession, prefs: IterationContext["prefs"]): Promise<void> {
+  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<void>(r => setTimeout(r, waitMs));
+    }
+  }
+}
+
 async function runUnitPhaseViaContract(
   dispatchContract: DispatchContract,
   ic: IterationContext,
   iterData: IterationData,
   loopState: LoopState,
   sidecarItem?: SidecarItem,
-): Promise<PhaseResult<{ unitStartedAt: number }>> {
+): Promise<PhaseResult<{ unitStartedAt?: number; requestDispatchedAt?: number }>> {
   if (dispatchContract === "legacy-direct") {
     return runUnitPhase(ic, iterData, loopState, sidecarItem);
   }
 
   const scheduler = new ExecutionGraphScheduler();
-  let outcome: PhaseResult<{ unitStartedAt: number }> | null = null;
+  let outcome: PhaseResult<{ unitStartedAt?: number; requestDispatchedAt?: number }> | null = null;
   const executeNode = async (): Promise<void> => {
     outcome = await runUnitPhase(ic, iterData, loopState, sidecarItem);
   };
@@ -468,12 +480,17 @@ export async function autoLoop(
         }
 
         // ── 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,
@@ -653,6 +670,7 @@ export async function autoLoop(
         });
       }
 
+      await enforceMinRequestInterval(s, prefs);
       const unitPhaseResult = await runUnitPhaseViaContract(
         dispatchContract,
         ic,
@@ -660,6 +678,10 @@ export async function autoLoop(
         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/src/resources/extensions/gsd/auto/phases.ts

@@ -11,7 +11,12 @@ import { importExtensionModule, type ExtensionAPI, type ExtensionContext } from
 
 import type { AutoSession, SidecarItem } from "./session.js";
 import type { LoopDeps } from "./loop-deps.js";
-import type { PostUnitContext, PreVerificationOpts } from "../auto-post-unit.js";
+import {
+  USER_DRIVEN_DEEP_UNITS,
+  isAwaitingUserInput,
+  type PostUnitContext,
+  type PreVerificationOpts,
+} from "../auto-post-unit.js";
 import type { Phase } from "../types.js";
 import {
   MAX_RECOVERY_CHARS,
@@ -26,6 +31,7 @@ import {
 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";
@@ -51,7 +57,7 @@ import { getEligibleSlices } from "../slice-parallel-eligibility.js";
 import { startSliceParallel } from "../slice-parallel-orchestrator.js";
 import { isDbAvailable, getMilestoneSlices } from "../gsd-db.js";
 import type { MinimalModelRegistry } from "../context-budget.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";
@@ -81,11 +87,7 @@ export function resetSessionTimeoutState(): void {
  * Exported for testing as _resolveReportBasePath.
  */
 export function _resolveReportBasePath(s: Pick<AutoSession, "originalBasePath" | "basePath">): string {
-  // 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);
 }
 
 /**
@@ -96,12 +98,7 @@ export function _resolveReportBasePath(s: Pick<AutoSession, "originalBasePath" |
 export function _resolveDispatchGuardBasePath(
   s: Pick<AutoSession, "originalBasePath" | "basePath">,
 ): string {
-  // 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: ReadonlySet<Phase> = new Set([
@@ -417,8 +414,47 @@ export async function runPreDispatch(
 
   // 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);
+  if (
+    (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)) {
@@ -615,7 +651,7 @@ export async function runPreDispatch(
     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);
@@ -911,10 +947,16 @@ export async function runDispatch(
     ? 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({
@@ -926,6 +968,7 @@ export async function runDispatch(
     session: s,
     structuredQuestionsAvailable,
     sessionContextWindow: ctx.model?.contextWindow,
+    sessionProvider: ctx.model?.provider,
     modelRegistry: ctx.modelRegistry as MinimalModelRegistry | undefined,
   });
 
@@ -1342,7 +1385,7 @@ export async function runUnitPhase(
   iterData: IterationData,
   loopState: LoopState,
   sidecarItem?: SidecarItem,
-): Promise<PhaseResult<{ unitStartedAt: number }>> {
+): Promise<PhaseResult<{ unitStartedAt?: number; requestDispatchedAt?: number }>> {
   const { ctx, pi, s, deps, prefs } = ic;
   const { unitType, unitId, prompt, state, mid } = iterData;
 
@@ -1413,6 +1456,7 @@ export async function runUnitPhase(
   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();
@@ -1647,6 +1691,7 @@ export async function runUnitPhase(
     unitId,
     finalPrompt,
   );
+  s.lastUnitAgentEndMessages = unitResult.event?.messages ?? null;
   debugLog("autoLoop", {
     phase: "runUnit-end",
     iteration: ic.iteration,
@@ -1848,19 +1893,27 @@ export async function runUnitPhase(
         (u: { type: string; id: string; startedAt: number; toolCalls: number }) => 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 } };
+        }
       }
     }
   }
@@ -1924,7 +1977,7 @@ export async function runUnitPhase(
     s.checkpointSha = null;
   }
 
-  return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt } };
+  return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt, requestDispatchedAt: unitResult.requestDispatchedAt } };
 }
 
 // ─── runFinalize ──────────────────────────────────────────────────────────────
@@ -1968,11 +2021,11 @@ export async function runFinalize(
   // mutations are harmless — postUnitPreVerification guards all side effects
   // behind `if (s.currentUnit)`. The next iteration sets a fresh currentUnit.
   // Sidecar items use lightweight pre-verification opts
-  const preVerificationOpts: PreVerificationOpts | undefined = sidecarItem
+  const preVerificationOpts: 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/src/resources/extensions/gsd/auto/run-unit.ts

@@ -40,6 +40,29 @@ export async function runUnit(
 ): Promise<UnitResult> {
   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 });
 
@@ -120,17 +143,6 @@ export async function runUnit(
     _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
@@ -171,6 +183,7 @@ export async function runUnit(
   // ── 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 },
@@ -201,6 +214,7 @@ export async function runUnit(
     unitId,
     status: result.status,
   });
+  const finalResult: UnitResult = { ...result, requestDispatchedAt };
 
   // Discard trailing follow-up messages (e.g. async_job_result notifications)
   // from the completed unit. Without this, queued follow-ups trigger wasteful
@@ -216,5 +230,5 @@ export async function runUnit(
     logWarning("engine", "clearQueue failed after unit completion", { error: String(e) });
   }
 
-  return result;
+  return finalResult;
 }

package/src/resources/extensions/gsd/auto/session.ts

@@ -21,6 +21,7 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent
 import type { GitServiceImpl } from "../git-service.js";
 import type { CaptureEntry } from "../captures.js";
 import type { BudgetAlertLevel } from "../auto-budget.js";
+import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 
 // ─── Exported Types ──────────────────────────────────────────────────────────
 
@@ -162,6 +163,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: string | null = null;
+  /** Agent-end messages from the just-finished unit, consumed during finalize. */
+  lastUnitAgentEndMessages: unknown[] | null = null;
   /** Set when turn-level git action fails during closeout. */
   lastGitActionFailure: string | null = null;
   /** Last turn-level git action status captured during finalize. */
@@ -193,6 +196,8 @@ export class AutoSession {
   lastPromptCharCount: number | undefined;
   lastBaselineCharCount: number | undefined;
   pendingQuickTasks: CaptureEntry[] = [];
+  /** 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. */
@@ -224,12 +229,7 @@ export class AutoSession {
   }
 
   get lockBasePath(): string {
-    // 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(): void {
@@ -294,11 +294,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;

package/src/resources/extensions/gsd/auto/types.ts

@@ -66,6 +66,7 @@ export interface UnitResult {
   status: "completed" | "cancelled" | "error";
   event?: AgentEndEvent;
   errorContext?: ErrorContext;
+  requestDispatchedAt?: number;
 }
 
 // ─── Phase pipeline types ────────────────────────────────────────────────────

package/src/resources/extensions/gsd/auto-artifact-paths.ts

@@ -5,6 +5,7 @@
 // function was removed entirely — callers now query WorkflowEngine directly.
 
 import {
+  gsdRoot,
   resolveMilestonePath,
   resolveSlicePath,
   relMilestoneFile,
@@ -26,6 +27,16 @@ export function resolveExpectedArtifactPath(
 ): string | null {
   const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
   switch (unitType) {
+    case "workflow-preferences":
+      return join(gsdRoot(base), "PREFERENCES.md");
+    case "discuss-project":
+      return join(gsdRoot(base), "PROJECT.md");
+    case "discuss-requirements":
+      return join(gsdRoot(base), "REQUIREMENTS.md");
+    case "research-decision":
+      return join(gsdRoot(base), "runtime", "research-decision.json");
+    case "research-project":
+      return join(gsdRoot(base), "research", "PROJECT-RESEARCH-BLOCKER.md");
     case "discuss-milestone": {
       const dir = resolveMilestonePath(base, mid);
       return dir ? join(dir, buildMilestoneFileName(mid, "CONTEXT")) : null;
@@ -115,6 +126,16 @@ export function diagnoseExpectedArtifact(
 ): string | null {
   const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
   switch (unitType) {
+    case "workflow-preferences":
+      return ".gsd/PREFERENCES.md with workflow_prefs_captured: true";
+    case "discuss-project":
+      return ".gsd/PROJECT.md (valid project context)";
+    case "discuss-requirements":
+      return ".gsd/REQUIREMENTS.md (valid requirements registry)";
+    case "research-decision":
+      return ".gsd/runtime/research-decision.json with decision research|skip";
+    case "research-project":
+      return ".gsd/research/{STACK,FEATURES,ARCHITECTURE,PITFALLS}.md with at least one real research file; blocker-only outputs stop";
     case "discuss-milestone":
       return `${relMilestoneFile(base, mid, "CONTEXT")} (milestone context from discussion)`;
     case "discuss-slice":

package/src/resources/extensions/gsd/auto-dashboard.ts

@@ -45,6 +45,7 @@ import {
 } from "../shared/rtk-session-stats.js";
 import { logWarning } from "./workflow-logger.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
+import { homedir } from "node:os";
 
 // ─── UAT Slice Extraction ─────────────────────────────────────────────────────
 
@@ -341,6 +342,16 @@ function refreshLastCommit(basePath: string): void {
       cachedLastCommit = null;
       return;
     }
+    try {
+      execFileSync("git", ["rev-parse", "--verify", "HEAD"], {
+        cwd: basePath,
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 3000,
+      });
+    } catch {
+      cachedLastCommit = null;
+      return;
+    }
     const raw = execFileSync("git", ["log", "-1", "--format=%cr|%s"], {
       cwd: basePath,
       encoding: "utf-8",
@@ -582,8 +593,8 @@ export function updateProgressWidget(
   let widgetPwd: string;
   {
     let fullPwd = process.cwd();
-    const widgetHome = process.env.HOME || process.env.USERPROFILE;
-    if (widgetHome && fullPwd.startsWith(widgetHome)) {
+    const widgetHome = homedir();
+    if (widgetHome && (fullPwd === widgetHome || fullPwd.startsWith(widgetHome + "/") || fullPwd.startsWith(widgetHome + "\\"))) {
       fullPwd = `~${fullPwd.slice(widgetHome.length)}`;
     }
     const parts = fullPwd.split("/");