gsd-pi 2.80.0 → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/auto-direct-dispatch.ts

@@ -31,7 +31,6 @@ import { loadEffectiveGSDPreferences } from "./preferences.js";
 import type { MinimalModelRegistry } from "./context-budget.js";
 import { pauseAuto } from "./auto.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
-import { logWarning } from "./workflow-logger.js";
 import {
   getWorkflowTransportSupportError,
   getRequiredWorkflowToolsForAutoUnit,
@@ -290,38 +289,13 @@ export async function dispatchDirectPhase(
 
   ctx.ui.notify(`Dispatching ${unitType} for ${unitId}...`, "info");
 
-  const originalCwd = process.cwd();
-
-  try {
-    // Ensure cwd matches dispatchBase BEFORE newSession() captures it. Synchronous —
-    // no awaits between chdir and newSession.
-    try {
-      if (process.cwd() !== dispatchBase) {
-        process.chdir(dispatchBase);
-      }
-    } catch (err) {
-      const msg = `Failed to chdir before direct-dispatch newSession (basePath: ${dispatchBase}): ${err instanceof Error ? err.message : String(err)}`;
-      logWarning("engine", msg, { file: "auto-direct-dispatch.ts", basePath: dispatchBase, error: err instanceof Error ? err.message : String(err) });
-      ctx.ui.notify(`${msg}. Cancelling dispatch to avoid running in the wrong directory.`, "error");
-      return;
-    }
-
-    const result = await ctx.newSession();
-    if (result.cancelled) {
-      ctx.ui.notify("Session creation cancelled.", "warning");
-      return;
-    }
-    pi.sendMessage(
-      { customType: "gsd-dispatch", content: prompt, display: false },
-      { triggerTurn: true },
-    );
-  } finally {
-    try {
-      if (process.cwd() !== originalCwd) {
-        process.chdir(originalCwd);
-      }
-    } catch (err) {
-      logWarning("engine", `Failed to restore cwd after direct dispatch: ${err instanceof Error ? err.message : String(err)}`, { file: "auto-direct-dispatch.ts", basePath: originalCwd });
-    }
+  const result = await ctx.newSession({ workspaceRoot: dispatchBase });
+  if (result.cancelled) {
+    ctx.ui.notify("Session creation cancelled.", "warning");
+    return;
   }
+  pi.sendMessage(
+    { customType: "gsd-dispatch", content: prompt, display: false },
+    { triggerTurn: true },
+  );
 }

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

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Declarative auto-mode dispatch rules and dispatch resolver.
+
 /**
  * Auto-mode Dispatch Table — declarative phase → unit mapping.
  *
@@ -211,6 +214,23 @@ export function hasPendingDeepStage(prefs: GSDPreferences | undefined, basePath:
   return gate.status === "pending" || gate.status === "blocked";
 }
 
+export function shouldRunDeepProjectSetup(
+  state: Pick<GSDState, "phase">,
+  prefs: GSDPreferences | undefined,
+  basePath: string,
+  options: { hasSurvivorBranch?: boolean } = {},
+): boolean {
+  if (options.hasSurvivorBranch === true) return false;
+  if (
+    state.phase !== "pre-planning" &&
+    state.phase !== "needs-discussion" &&
+    state.phase !== "planning"
+  ) {
+    return false;
+  }
+  return hasPendingDeepStage(prefs, basePath);
+}
+
 function missingSliceStop(mid: string, phase: string): DispatchAction {
   return {
     action: "stop",
@@ -921,6 +941,22 @@ export const DISPATCH_RULES: DispatchRule[] = [
       const unitId = `${mid}/${sid}`;
       let priorPreExecFailure: { blockingFindings: string[]; verdictExcerpt: string } | undefined;
       if (session?.lastPreExecFailure?.unitId === unitId) {
+        // Circuit breaker: stop re-dispatching after 2 failed retries. The
+        // planner has had multiple attempts with injected failure context and
+        // still cannot produce a valid plan — human review is required.
+        const MAX_PRE_EXEC_RETRIES = 2;
+        const retryCount = session.preExecRetryCount?.get(unitId) ?? 0;
+        if (retryCount >= MAX_PRE_EXEC_RETRIES) {
+          const findings = session.lastPreExecFailure.blockingFindings.join("; ");
+          session.lastPreExecFailure = null;
+          session.preExecRetryCount?.delete(unitId);
+          return {
+            action: "stop",
+            reason: `Pre-execution checks failed ${retryCount} times for ${unitId} — manual intervention required. Blocking findings: ${findings}. Fix the plan manually, then run /gsd auto to resume.`,
+            level: "error",
+            matchedRule: "planning → plan-slice",
+          };
+        }
         priorPreExecFailure = {
           blockingFindings: session.lastPreExecFailure.blockingFindings,
           verdictExcerpt: session.lastPreExecFailure.verdictExcerpt,
@@ -1385,8 +1421,19 @@ export const DISPATCH_RULES: DispatchRule[] = [
   },
   {
     name: "complete → stop",
-    match: async ({ state }) => {
+    match: async ({ state, mid, midTitle, basePath }) => {
       if (state.phase !== "complete") return null;
+      if (mid && isDbAvailable()) {
+        const milestone = getMilestone(mid);
+        if (milestone && !isClosedStatus(milestone.status)) {
+          return {
+            action: "dispatch",
+            unitType: "complete-milestone",
+            unitId: mid,
+            prompt: await buildCompleteMilestonePrompt(mid, midTitle, basePath),
+          };
+        }
+      }
       return {
         action: "stop",
         reason: "All milestones complete.",

package/src/resources/extensions/gsd/auto-post-unit.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Auto-mode post-unit git, verification, projection, and hook processing.
 /**
  * Post-unit processing for auto-loop — auto-commit, doctor run,
  * state rebuild, projection checks, DB tool closeout, hooks, triage, and
@@ -41,9 +43,10 @@ import {
   diagnoseExpectedArtifact,
 } from "./auto-recovery.js";
 import { regenerateIfMissing } from "./workflow-projections.js";
-import { syncStateToProjectRoot } from "./auto-worktree.js";
+import { WorktreeStateProjection } from "./worktree-state-projection.js";
+import { createWorkspace, scopeMilestone } from "./workspace.js";
 import { normalizeWorktreePathForCompare } from "./worktree-root.js";
-import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter, getVerificationEvidence } from "./gsd-db.js";
 import { renderPlanCheckboxes } from "./markdown-renderer.js";
 import { consumeSignal } from "./session-status-io.js";
 import {
@@ -80,6 +83,7 @@ import {
   finalizeProjectResearchTimeout,
 } from "./project-research-policy.js";
 import { validateArtifact } from "./schemas/validate.js";
+import { verificationRetryKey } from "./auto/verification-retry-policy.js";
 
 // ─── Path Comparison Helper ───────────────────────────────────────────────
 /** Compare two paths for physical identity, tolerating trailing slashes and symlinks. */
@@ -87,6 +91,9 @@ function isSamePathLocal(a: string, b: string): boolean {
   return normalizeWorktreePathForCompare(a) === normalizeWorktreePathForCompare(b);
 }
 
+/** Stateless WorktreeStateProjection — methods are pure functions of MilestoneScope. */
+const _worktreeProjection = new WorktreeStateProjection();
+
 /** Maximum verification retry attempts before escalating to blocker placeholder (#2653). */
 const MAX_VERIFICATION_RETRIES = 3;
 /** Keep failure toasts short while still showing concrete examples. */
@@ -103,6 +110,67 @@ function formatPreExecutionCheckDetail(check: PreExecutionCheckJSON): string {
 const COMPLETE_MILESTONE_DB_SETTLE_MS = 1500;
 const COMPLETE_MILESTONE_DB_SETTLE_POLL_MS = 100;
 
+function stripKnownIdPrefix(value: string | undefined | null, id: string): string | undefined {
+  const raw = String(value ?? "").trim();
+  if (!raw) return undefined;
+  const lower = raw.toLowerCase();
+  const idLower = id.toLowerCase();
+  if (lower.startsWith(`${idLower}:`)) return raw.slice(id.length + 1).trim() || undefined;
+  return raw;
+}
+
+async function buildTaskCommitContextForUnit(
+  basePath: string,
+  unitId: string,
+): Promise<TaskCommitContext | undefined> {
+  const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+  if (!mid || !sid || !tid) return undefined;
+
+  const milestone = isDbAvailable() ? getMilestone(mid) : null;
+  const slice = isDbAvailable() ? getSlice(mid, sid) : null;
+  const task = isDbAvailable() ? getTask(mid, sid, tid) : null;
+  let summary: ReturnType<typeof parseSummary> | null = null;
+
+  const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+  if (summaryPath) {
+    try {
+      const summaryContent = await loadFile(summaryPath);
+      if (summaryContent) summary = parseSummary(summaryContent);
+    } catch (e) {
+      debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
+    }
+  }
+
+  if (!summary && !task) return undefined;
+
+  let ghIssueNumber: number | undefined;
+  try {
+    const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
+    ghIssueNumber = getTaskIssueNumberForCommit(basePath, mid, sid, tid) ?? undefined;
+  } catch (err) {
+    logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+
+  return {
+    taskId: `${sid}/${tid}`,
+    taskDisplayId: tid,
+    taskTitle:
+      stripKnownIdPrefix(summary?.title, tid) ??
+      stripKnownIdPrefix(task?.title, tid) ??
+      tid,
+    milestoneId: mid,
+    milestoneTitle: stripKnownIdPrefix(milestone?.title, mid),
+    sliceId: sid,
+    sliceTitle: stripKnownIdPrefix(slice?.title, sid),
+    oneLiner: summary?.oneLiner || task?.one_liner || undefined,
+    keyFiles:
+      summary?.frontmatter.key_files?.filter(f => !f.includes("{{")) ??
+      task?.key_files ??
+      undefined,
+    issueNumber: ghIssueNumber,
+  };
+}
+
 async function waitForMilestoneDbClose(mid: string): Promise<boolean> {
   const deadline = Date.now() + COMPLETE_MILESTONE_DB_SETTLE_MS;
   while (Date.now() < deadline) {
@@ -134,6 +202,26 @@ function enqueueSidecar(
   if (notification) ctx.ui.notify(notification, "info");
   return "continue";
 }
+
+export function _shouldDispatchTriageForTest(
+  state: Pick<AutoSession, "stepMode" | "currentUnit">,
+): boolean {
+  return !state.stepMode &&
+    !!state.currentUnit &&
+    !state.currentUnit.type.startsWith("hook/") &&
+    state.currentUnit.type !== "triage-captures" &&
+    state.currentUnit.type !== "quick-task";
+}
+
+export function _shouldDispatchQuickTaskForTest(
+  state: Pick<AutoSession, "stepMode" | "currentUnit" | "pendingQuickTasks">,
+): boolean {
+  return !state.stepMode &&
+    state.pendingQuickTasks.length > 0 &&
+    !!state.currentUnit &&
+    state.currentUnit.type !== "quick-task";
+}
+
 /** Unit types that only touch `.gsd/` internal state files (no code changes).
  *  Auto-commit is skipped for these — their state files are picked up by the
  *  next actual task commit via `smartStage()`. */
@@ -276,7 +364,7 @@ export function detectRogueFileWrites(
  * in auto-verification.ts. Exceeding this limit pauses auto-mode instead of
  * looping indefinitely (#2007).
  */
-const MAX_ARTIFACT_VERIFICATION_RETRIES = 3;
+export const MAX_ARTIFACT_VERIFICATION_RETRIES = 3;
 
 export const STEP_COMPLETE_FALLBACK_MESSAGE =
   "Step complete. Run /clear, then /gsd to continue (or /gsd auto to run continuously).";
@@ -357,35 +445,7 @@ export async function autoCommitUnit(
     let taskContext: TaskCommitContext | undefined;
 
     if (unitType === "execute-task") {
-      const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
-      if (mid && sid && tid) {
-        const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
-        if (summaryPath) {
-          try {
-            const summaryContent = await loadFile(summaryPath);
-            if (summaryContent) {
-              const summary = parseSummary(summaryContent);
-              let ghIssueNumber: number | undefined;
-              try {
-                const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
-                ghIssueNumber = getTaskIssueNumberForCommit(basePath, mid, sid, tid) ?? undefined;
-              } catch (err) {
-                logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-              }
-
-              taskContext = {
-                taskId: `${sid}/${tid}`,
-                taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
-                oneLiner: summary.oneLiner || undefined,
-                keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
-                issueNumber: ghIssueNumber,
-              };
-            }
-          } catch (e) {
-            debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
-          }
-        }
-      }
+      taskContext = await buildTaskCommitContextForUnit(basePath, unitId);
     }
 
     _resetHasChangesCache();
@@ -457,37 +517,7 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
       let taskContext: TaskCommitContext | undefined;
 
       if (turnAction === "commit" && s.currentUnit.type === "execute-task") {
-        const { milestone: mid, slice: sid, task: tid } = parseUnitId(s.currentUnit.id);
-        if (mid && sid && tid) {
-          const summaryPath = resolveTaskFile(s.basePath, mid, sid, tid, "SUMMARY");
-          if (summaryPath) {
-            try {
-              const summaryContent = await loadFile(summaryPath);
-              if (summaryContent) {
-                const summary = parseSummary(summaryContent);
-                // Look up GitHub issue number for commit linking
-                let ghIssueNumber: number | undefined;
-                try {
-                  const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
-                  ghIssueNumber = getTaskIssueNumberForCommit(s.basePath, mid, sid, tid) ?? undefined;
-                } catch (err) {
-                  // GitHub sync not available — skip
-                  logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-                }
-
-                taskContext = {
-                  taskId: `${sid}/${tid}`,
-                  taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
-                  oneLiner: summary.oneLiner || undefined,
-                  keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
-                  issueNumber: ghIssueNumber,
-                };
-              }
-            } catch (e) {
-              debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
-            }
-          }
-        }
+        taskContext = await buildTaskCommitContextForUnit(s.basePath, s.currentUnit.id);
       }
 
       // Invalidate the nativeHasChanges cache before auto-commit (#1853).
@@ -626,7 +656,18 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
     // Sync worktree state back to project root (skipped for lightweight sidecars)
     if (!opts?.skipWorktreeSync && s.originalBasePath && !isSamePathLocal(s.originalBasePath, s.basePath)) {
       await runSafely("postUnit", "worktree-sync", () => {
-        syncStateToProjectRoot(s.basePath, s.originalBasePath!, s.currentMilestoneId);
+        let scope = s.scope;
+        if (!scope && s.currentMilestoneId) {
+          try {
+            scope = scopeMilestone(createWorkspace(s.basePath), s.currentMilestoneId);
+          } catch {
+            // Non-fatal: scope construction can fail on synthetic test paths;
+            // skipping the projection mirrors the prior path-string variant's
+            // early-return behaviour for missing milestone/path inputs.
+            scope = null;
+          }
+        }
+        if (scope) _worktreeProjection.projectWorktreeToRoot(scope);
       });
     }
 
@@ -852,22 +893,22 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
         }
 
         // Evidence cross-reference (execute-task only)
-        // Verification evidence is passed via the complete-task tool call and
-        // stored in the SUMMARY.md on disk — not available as structured data
-        // in the DB. The evidence collector tracks actual bash tool calls, so
-        // we can still detect units that claimed success but ran no commands.
+        // Only compare against concrete command evidence persisted by the task
+        // completion tool. A prose Verify field can be satisfied later by the
+        // host verification gate, so it is not enough to accuse the unit.
         if (safetyConfig.evidence_cross_reference && s.currentUnit.type === "execute-task") {
           try {
             const actual = getEvidence();
             const bashCalls = actual.filter(e => e.kind === "bash");
-            // If the task is marked complete but zero bash commands were run,
-            // it's suspicious — the LLM may have fabricated results.
             if (sMid && sSid && sTid && isDbAvailable()) {
               const taskRow = getTask(sMid, sSid, sTid);
-              if (taskRow?.status === "complete" && taskRow.verify && bashCalls.length === 0) {
-                logWarning("safety", "task marked complete with verification commands but no bash calls were executed");
+              const claimedCommands = getVerificationEvidence(sMid, sSid, sTid)
+                .map((row) => row.command)
+                .filter((command): command is string => typeof command === "string" && command.trim().length > 0);
+              if (taskRow?.status === "complete" && claimedCommands.length > 0 && bashCalls.length === 0) {
+                logWarning("safety", "task claimed verification command evidence but no execution tool calls were recorded");
                 ctx.ui.notify(
-                  `Safety: task ${sTid} has verification commands but no bash calls were recorded`,
+                  `Safety: task ${sTid} claimed command evidence but no execution tool calls were recorded`,
                   "warning",
                 );
               }
@@ -976,6 +1017,7 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
         );
         s.pendingVerificationRetry = null;
         s.verificationRetryCount.delete(retryKey);
+        s.verificationRetryFailureHashes.delete(retryKey);
         triggerArtifactVerified = verifyExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
         if (triggerArtifactVerified) {
           invalidateAllCaches();
@@ -1034,6 +1076,7 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
         s.lastToolInvocationError = null;
         s.pendingVerificationRetry = null;
         s.verificationRetryCount.delete(retryKey);
+        s.verificationRetryFailureHashes.delete(retryKey);
         writeBlockerPlaceholder(s.currentUnit.type, s.currentUnit.id, s.basePath, reason);
         ctx.ui.notify(
           `${s.currentUnit.type} ${s.currentUnit.id} — deterministic policy rejection, wrote blocker placeholder (no retries) (#4973)`,
@@ -1071,6 +1114,7 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
           );
           if (attempt > MAX_ARTIFACT_VERIFICATION_RETRIES) {
             s.verificationRetryCount.delete(retryKey);
+            s.verificationRetryFailureHashes.delete(retryKey);
             debugLog("postUnit", { phase: "artifact-verify-exhausted", unitType: s.currentUnit.type, unitId: s.currentUnit.id, attempt });
             ctx.ui.notify(
               `${failureDetails} Pausing auto-mode after ${MAX_ARTIFACT_VERIFICATION_RETRIES} retries.`,
@@ -1097,7 +1141,9 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
       // Verification succeeded — clear the retry counter so a future failure
       // of the same unit gets a full retry budget instead of the stale count.
       if (triggerArtifactVerified) {
-        s.verificationRetryCount.delete(`${s.currentUnit.type}:${s.currentUnit.id}`);
+        const retryKey = verificationRetryKey(s.currentUnit.type, s.currentUnit.id);
+        s.verificationRetryCount.delete(retryKey);
+        s.verificationRetryFailureHashes.delete(retryKey);
       }
     } else {
       // Hook unit completed — no additional processing needed
@@ -1320,8 +1366,12 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
 
         const strictMode = prefs?.enhanced_verification_strict === true;
 
-        // Run pre-execution checks
-        const result: PreExecutionResult = await runPreExecutionChecks(tasks, s.basePath);
+        // Run pre-execution checks against s.basePath — the actual checkout
+        // where prior-slice files were created.  In worktree isolation,
+        // s.canonicalProjectRoot is the project root and lacks files that a
+        // prior slice wrote to the worktree but hasn't merged to main yet.
+        const preExecutionBasePath = s.basePath;
+        const result: PreExecutionResult = await runPreExecutionChecks(tasks, preExecutionBasePath);
 
         // Log summary to stderr in existing verification output format
         const emoji = result.status === "pass" ? "✅" : result.status === "warn" ? "⚠️" : "❌";
@@ -1338,12 +1388,12 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
         }
 
         // Write evidence JSON to slice artifacts directory
-        const slicePath = resolveSlicePath(s.basePath, mid, sid);
+        const slicePath = resolveSlicePath(preExecutionBasePath, mid, sid);
         const evidenceFileName = `${sid}-PRE-EXEC-VERIFY.json`;
         let evidencePath = join(".gsd", "milestones", mid, "slices", sid, evidenceFileName);
         if (slicePath) {
           writePreExecutionEvidence(result, slicePath, mid, sid);
-          evidencePath = relative(s.basePath, join(slicePath, evidenceFileName)) || evidenceFileName;
+          evidencePath = relative(preExecutionBasePath, join(slicePath, evidenceFileName)) || evidenceFileName;
         }
 
         if (uokFlags.gates) {
@@ -1398,6 +1448,9 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
             ),
             verdictExcerpt: `status=${result.status}; ${blockingCount} blocking issue${blockingCount === 1 ? "" : "s"} detected`,
           };
+          // Track consecutive pre-exec failures per slice for loop detection.
+          const retryKey = currentUnit.id;
+          s.preExecRetryCount.set(retryKey, (s.preExecRetryCount.get(retryKey) ?? 0) + 1);
           preExecPauseNeeded = true;
         } else if (result.status === "warn") {
           ctx.ui.notify(
@@ -1414,10 +1467,18 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
               ),
               verdictExcerpt: `status=${result.status} (strict mode); ${warnChecks.length} warning${warnChecks.length === 1 ? "" : "s"} treated as blocking`,
             };
+            const retryKey = currentUnit.id;
+            s.preExecRetryCount.set(retryKey, (s.preExecRetryCount.get(retryKey) ?? 0) + 1);
             preExecPauseNeeded = true;
           }
         }
 
+        // Reset the retry counter when checks pass — a successful re-plan
+        // should not carry over a stale failure count into future slices.
+        if (result.status === "pass") {
+          s.preExecRetryCount.delete(currentUnit.id);
+        }
+
         debugLog("postUnitPostVerification", {
           phase: "pre-execution-checks",
           status: result.status,
@@ -1473,13 +1534,7 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
   }
 
   // ── Triage check ──
-  if (
-    !s.stepMode &&
-    s.currentUnit &&
-    !s.currentUnit.type.startsWith("hook/") &&
-    s.currentUnit.type !== "triage-captures" &&
-    s.currentUnit.type !== "quick-task"
-  ) {
+  if (_shouldDispatchTriageForTest(s)) {
     try {
       if (hasPendingCaptures(s.basePath)) {
         const pending = loadPendingCaptures(s.basePath);
@@ -1527,12 +1582,7 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
   }
 
   // ── Quick-task dispatch ──
-  if (
-    !s.stepMode &&
-    s.pendingQuickTasks.length > 0 &&
-    s.currentUnit &&
-    s.currentUnit.type !== "quick-task"
-  ) {
+  if (_shouldDispatchQuickTaskForTest(s)) {
     try {
       const capture = s.pendingQuickTasks.shift()!;
       const { buildQuickTaskPrompt } = await import("./triage-resolution.js");