gsd-pi 2.33.1-dev.235d83a → 2.33.1-dev.29a8268

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

@@ -0,0 +1,618 @@
+/**
+ * Post-unit processing for handleAgentEnd — auto-commit, doctor run,
+ * state rebuild, worktree sync, DB dual-write, hooks, triage, and
+ * quick-task dispatch.
+ *
+ * Split into two functions called sequentially by handleAgentEnd with
+ * the verification gate between them:
+ *   1. postUnitPreVerification() — commit, doctor, state rebuild, worktree sync, artifact verification
+ *   2. postUnitPostVerification() — DB dual-write, hooks, triage, quick-tasks
+ *
+ * Extracted from handleAgentEnd() in auto.ts.
+ */
+
+import type { ExtensionContext, ExtensionCommandContext, ExtensionAPI } from "@gsd/pi-coding-agent";
+import { deriveState } from "./state.js";
+import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
+import { loadPrompt } from "./prompt-loader.js";
+import {
+  resolveSliceFile,
+  resolveTaskFile,
+  resolveMilestoneFile,
+  gsdRoot,
+} from "./paths.js";
+import { invalidateAllCaches } from "./cache.js";
+import { closeoutUnit, type CloseoutOptions } from "./auto-unit-closeout.js";
+import {
+  autoCommitCurrentBranch,
+  type TaskCommitContext,
+} from "./worktree.js";
+import {
+  verifyExpectedArtifact,
+  persistCompletedKey,
+  removePersistedKey,
+} from "./auto-recovery.js";
+import { writeUnitRuntimeRecord, clearUnitRuntimeRecord } from "./unit-runtime.js";
+import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences } from "./preferences.js";
+import { runGSDDoctor, rebuildState, summarizeDoctorIssues } from "./doctor.js";
+import { COMPLETION_TRANSITION_CODES } from "./doctor-types.js";
+import { recordHealthSnapshot, checkHealEscalation } from "./doctor-proactive.js";
+import { resetRewriteCircuitBreaker } from "./auto-dispatch.js";
+import { isDbAvailable } from "./gsd-db.js";
+import { consumeSignal } from "./session-status-io.js";
+import {
+  checkPostUnitHooks,
+  getActiveHook,
+  resetHookState,
+  isRetryPending,
+  consumeRetryTrigger,
+  persistHookState,
+} from "./post-unit-hooks.js";
+import { hasPendingCaptures, loadPendingCaptures, countPendingCaptures } from "./captures.js";
+import { writeLock } from "./crash-recovery.js";
+import { debugLog } from "./debug-logger.js";
+import type { AutoSession } from "./auto/session.js";
+import type { WidgetStateAccessors, AutoDashboardData } from "./auto-dashboard.js";
+import {
+  updateProgressWidget as _updateProgressWidget,
+  updateSliceProgressCache,
+  unitVerb,
+  hideFooter,
+} from "./auto-dashboard.js";
+import { join } from "node:path";
+import { STATE_REBUILD_MIN_INTERVAL_MS } from "./auto-constants.js";
+import { parseUnitId } from "./unit-id.js";
+
+/**
+ * Initialize a unit dispatch: stamp the current time, set `s.currentUnit`,
+ * and persist the initial runtime record. Returns `startedAt` for callers
+ * that need the timestamp.
+ */
+function dispatchUnit(
+  s: AutoSession,
+  basePath: string,
+  unitType: string,
+  unitId: string,
+): number {
+  const startedAt = Date.now();
+  s.currentUnit = { type: unitType, id: unitId, startedAt };
+  writeUnitRuntimeRecord(basePath, unitType, unitId, startedAt, {
+    phase: "dispatched",
+    wrapupWarningSent: false,
+    timeoutAt: null,
+    lastProgressAt: startedAt,
+    progressCount: 0,
+    lastProgressKind: "dispatch",
+  });
+  return startedAt;
+}
+
+export interface PostUnitContext {
+  s: AutoSession;
+  ctx: ExtensionContext;
+  pi: ExtensionAPI;
+  buildSnapshotOpts: (unitType: string, unitId: string) => CloseoutOptions & Record<string, unknown>;
+  lockBase: () => string;
+  stopAuto: (ctx?: ExtensionContext, pi?: ExtensionAPI, reason?: string) => Promise<void>;
+  pauseAuto: (ctx?: ExtensionContext, pi?: ExtensionAPI) => Promise<void>;
+  updateProgressWidget: (ctx: ExtensionContext, unitType: string, unitId: string, state: import("./types.js").GSDState) => void;
+}
+
+/**
+ * Pre-verification processing: parallel worker signal check, cache invalidation,
+ * auto-commit, doctor run, state rebuild, worktree sync, artifact verification.
+ *
+ * Returns "dispatched" if a signal caused stop/pause, "continue" to proceed.
+ */
+export async function postUnitPreVerification(pctx: PostUnitContext): Promise<"dispatched" | "continue"> {
+  const { s, ctx, pi, buildSnapshotOpts, stopAuto, pauseAuto } = pctx;
+
+  // ── Parallel worker signal check ──
+  const milestoneLock = process.env.GSD_MILESTONE_LOCK;
+  if (milestoneLock) {
+    const signal = consumeSignal(s.basePath, milestoneLock);
+    if (signal) {
+      if (signal.signal === "stop") {
+        await stopAuto(ctx, pi);
+        return "dispatched";
+      }
+      if (signal.signal === "pause") {
+        await pauseAuto(ctx, pi);
+        return "dispatched";
+      }
+    }
+  }
+
+  // Invalidate all caches
+  invalidateAllCaches();
+
+  // Small delay to let files settle
+  await new Promise(r => setTimeout(r, 500));
+
+  // Auto-commit
+  if (s.currentUnit) {
+    try {
+      let taskContext: TaskCommitContext | undefined;
+
+      if (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);
+                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,
+                };
+              }
+            } catch {
+              // Non-fatal
+            }
+          }
+        }
+      }
+
+      const commitMsg = autoCommitCurrentBranch(s.basePath, s.currentUnit.type, s.currentUnit.id, taskContext);
+      if (commitMsg) {
+        ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
+      }
+    } catch {
+      // Non-fatal
+    }
+
+    // Doctor: fix mechanical bookkeeping
+    try {
+      const { milestone, slice } = parseUnitId(s.currentUnit.id);
+      const doctorScope = slice ? `${milestone}/${slice}` : milestone;
+      const sliceTerminalUnits = new Set(["complete-slice", "run-uat"]);
+      const effectiveFixLevel = sliceTerminalUnits.has(s.currentUnit.type) ? "all" as const : "task" as const;
+      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 — exclude completion-transition codes at task level
+      // since they are expected after the last task and resolved by complete-slice
+      const issuesForHealth = effectiveFixLevel === "task"
+        ? report.issues.filter(i => !COMPLETION_TRANSITION_CODES.has(i.code))
+        : report.issues;
+      const summary = summarizeDoctorIssues(issuesForHealth);
+      recordHealthSnapshot(summary.errors, summary.warnings, report.fixesApplied.length);
+
+      // Check if we should escalate to LLM-assisted heal
+      if (summary.errors > 0) {
+        const unresolvedErrors = issuesForHealth
+          .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
+          }
+        }
+      }
+    } 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 {
+        // Non-fatal
+      }
+    }
+
+    // Prune dead bg-shell processes and kill non-persistent live ones.
+    // Without killing live processes between units, dev servers spawned during
+    // one task keep ports bound, causing conflicts in subsequent tasks (#1209).
+    try {
+      const { pruneDeadProcesses, killSessionProcesses } = await import("../bg-shell/process-manager.js");
+      pruneDeadProcesses();
+      killSessionProcesses();
+    } catch {
+      // Non-fatal
+    }
+
+    // Rewrite-docs completion
+    if (s.currentUnit.type === "rewrite-docs") {
+      try {
+        await resolveAllOverrides(s.basePath);
+        resetRewriteCircuitBreaker();
+        ctx.ui.notify("Override(s) resolved — rewrite-docs completed.", "info");
+      } catch {
+        // Non-fatal
+      }
+    }
+
+    // Post-triage: execute actionable resolutions
+    if (s.currentUnit.type === "triage-captures") {
+      try {
+        const { executeTriageResolutions } = await import("./triage-resolution.js");
+        const state = await deriveState(s.basePath);
+        const mid = state.activeMilestone?.id;
+        const sid = state.activeSlice?.id;
+
+        if (mid && sid) {
+          const triageResult = executeTriageResolutions(s.basePath, mid, sid);
+
+          if (triageResult.injected > 0) {
+            ctx.ui.notify(
+              `Triage: injected ${triageResult.injected} task${triageResult.injected === 1 ? "" : "s"} into ${sid} plan.`,
+              "info",
+            );
+          }
+          if (triageResult.replanned > 0) {
+            ctx.ui.notify(
+              `Triage: replan trigger written for ${sid} — next dispatch will enter replanning.`,
+              "info",
+            );
+          }
+          if (triageResult.quickTasks.length > 0) {
+            for (const qt of triageResult.quickTasks) {
+              s.pendingQuickTasks.push(qt);
+            }
+            ctx.ui.notify(
+              `Triage: ${triageResult.quickTasks.length} quick-task${triageResult.quickTasks.length === 1 ? "" : "s"} queued for execution.`,
+              "info",
+            );
+          }
+          for (const action of triageResult.actions) {
+            process.stderr.write(`gsd-triage: ${action}\n`);
+          }
+        }
+      } catch (err) {
+        process.stderr.write(`gsd-triage: resolution execution failed: ${(err as Error).message}\n`);
+      }
+    }
+
+    // Artifact verification and completion persistence
+    let triggerArtifactVerified = false;
+    if (!s.currentUnit.type.startsWith("hook/")) {
+      try {
+        triggerArtifactVerified = verifyExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
+        if (triggerArtifactVerified) {
+          const completionKey = `${s.currentUnit.type}/${s.currentUnit.id}`;
+          if (!s.completedKeySet.has(completionKey)) {
+            persistCompletedKey(s.basePath, completionKey);
+            s.completedKeySet.add(completionKey);
+          }
+          invalidateAllCaches();
+        }
+      } catch {
+        // Non-fatal
+      }
+    } else {
+      // Hook unit completed — finalize its runtime record
+      try {
+        writeUnitRuntimeRecord(s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, {
+          phase: "finalized",
+          progressCount: 1,
+          lastProgressKind: "hook-completed",
+        });
+        clearUnitRuntimeRecord(s.basePath, s.currentUnit.type, s.currentUnit.id);
+      } catch {
+        // Non-fatal
+      }
+    }
+  }
+
+  return "continue";
+}
+
+/**
+ * Post-verification processing: DB dual-write, post-unit hooks, triage
+ * capture dispatch, quick-task dispatch.
+ *
+ * Returns:
+ * - "dispatched" — a hook/triage/quick-task was dispatched (sendMessage sent)
+ * - "continue" — proceed to normal dispatchNextUnit
+ * - "step-wizard" — step mode, show wizard instead
+ * - "stopped" — stopAuto was called
+ */
+export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"dispatched" | "continue" | "step-wizard" | "stopped"> {
+  const { s, ctx, pi, buildSnapshotOpts, lockBase, stopAuto, pauseAuto, updateProgressWidget } = pctx;
+
+  // ── DB dual-write ──
+  if (isDbAvailable()) {
+    try {
+      const { migrateFromMarkdown } = await import("./md-importer.js");
+      migrateFromMarkdown(s.basePath);
+    } catch (err) {
+      process.stderr.write(`gsd-db: re-import failed: ${(err as Error).message}\n`);
+    }
+  }
+
+  // ── Mechanical completion (ADR-003) ──
+  // After task execution, attempt mechanical slice and milestone completion
+  // instead of dispatching LLM sessions for complete-slice / validate-milestone.
+  if (s.currentUnit?.type === "execute-task" && !s.stepMode) {
+    try {
+      const { milestone: mid, slice: sid } = parseUnitId(s.currentUnit.id);
+      if (mid && sid) {
+        const state = await deriveState(s.basePath);
+        if (state.phase === "summarizing" && state.activeSlice?.id === sid) {
+          const { mechanicalSliceCompletion } = await import("./mechanical-completion.js");
+          const ok = await mechanicalSliceCompletion(s.basePath, mid, sid);
+          if (ok) {
+            invalidateAllCaches();
+            autoCommitCurrentBranch(s.basePath, "mechanical-completion", `${mid}/${sid}`);
+            ctx.ui.notify(`Mechanical completion: ${sid} summary + roadmap updated.`, "info");
+
+            // Re-derive state — check if milestone is now ready for validation
+            invalidateAllCaches();
+            const postSliceState = await deriveState(s.basePath);
+            if (postSliceState.phase === "validating-milestone" || postSliceState.phase === "completing-milestone") {
+              const { aggregateMilestoneVerification, generateMilestoneSummary } = await import("./mechanical-completion.js");
+              const validation = await aggregateMilestoneVerification(s.basePath, mid);
+              if (validation.verdict !== "failed") {
+                await generateMilestoneSummary(s.basePath, mid);
+                invalidateAllCaches();
+                autoCommitCurrentBranch(s.basePath, "mechanical-milestone-completion", mid);
+                ctx.ui.notify(`Mechanical completion: ${mid} validation + summary written.`, "info");
+              }
+            }
+          }
+          // If !ok, summarizing phase persists → dispatch rule fires as LLM fallback
+        }
+      }
+    } catch (err) {
+      process.stderr.write(`gsd-mechanical: completion failed: ${(err as Error).message}\n`);
+      // Non-fatal — fall through to normal dispatch
+    }
+  }
+
+  // ── Post-unit hooks ──
+  if (s.currentUnit && !s.stepMode) {
+    const hookUnit = checkPostUnitHooks(s.currentUnit.type, s.currentUnit.id, s.basePath);
+    if (hookUnit) {
+      if (s.currentUnit) {
+        await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
+      }
+      dispatchUnit(s, s.basePath, hookUnit.unitType, hookUnit.unitId);
+
+      const state = await deriveState(s.basePath);
+      updateProgressWidget(ctx, hookUnit.unitType, hookUnit.unitId, state);
+      const hookState = getActiveHook();
+      ctx.ui.notify(
+        `Running post-unit hook: ${hookUnit.hookName} (cycle ${hookState?.cycle ?? 1})`,
+        "info",
+      );
+
+      // Switch model if the hook specifies one
+      if (hookUnit.model) {
+        const availableModels = ctx.modelRegistry.getAvailable();
+        const match = availableModels.find(m =>
+          m.id === hookUnit.model || `${m.provider}/${m.id}` === hookUnit.model,
+        );
+        if (match) {
+          try {
+            await pi.setModel(match);
+          } catch { /* non-fatal */ }
+        }
+      }
+
+      const result = await s.cmdCtx!.newSession();
+      if (result.cancelled) {
+        resetHookState();
+        await stopAuto(ctx, pi, "Hook session cancelled");
+        return "stopped";
+      }
+      const sessionFile = ctx.sessionManager.getSessionFile();
+      writeLock(lockBase(), hookUnit.unitType, hookUnit.unitId, s.completedUnits.length, sessionFile);
+      persistHookState(s.basePath);
+
+      // Start supervision timers for hook units
+      const supervisor = resolveAutoSupervisorConfig();
+      const hookHardTimeoutMs = (supervisor.hard_timeout_minutes ?? 30) * 60 * 1000;
+      s.unitTimeoutHandle = setTimeout(async () => {
+        s.unitTimeoutHandle = null;
+        if (!s.active) return;
+        if (s.currentUnit) {
+          writeUnitRuntimeRecord(s.basePath, hookUnit.unitType, hookUnit.unitId, s.currentUnit.startedAt, {
+            phase: "timeout",
+            timeoutAt: Date.now(),
+          });
+        }
+        ctx.ui.notify(
+          `Hook ${hookUnit.hookName} exceeded ${supervisor.hard_timeout_minutes ?? 30}min timeout. Pausing auto-mode.`,
+          "warning",
+        );
+        resetHookState();
+        await pauseAuto(ctx, pi);
+      }, hookHardTimeoutMs);
+
+      if (!s.active) return "stopped";
+      pi.sendMessage(
+        { customType: "gsd-auto", content: hookUnit.prompt, display: s.verbose },
+        { triggerTurn: true },
+      );
+      return "dispatched";
+    }
+
+    // Check if a hook requested a retry of the trigger unit
+    if (isRetryPending()) {
+      const trigger = consumeRetryTrigger();
+      if (trigger) {
+        const triggerKey = `${trigger.unitType}/${trigger.unitId}`;
+        s.completedKeySet.delete(triggerKey);
+        removePersistedKey(s.basePath, triggerKey);
+        ctx.ui.notify(
+          `Hook requested retry of ${trigger.unitType} ${trigger.unitId}.`,
+          "info",
+        );
+        // Fall through to normal dispatch
+      }
+    }
+  }
+
+  // ── Triage check ──
+  if (
+    !s.stepMode &&
+    s.currentUnit &&
+    !s.currentUnit.type.startsWith("hook/") &&
+    s.currentUnit.type !== "triage-captures" &&
+    s.currentUnit.type !== "quick-task"
+  ) {
+    try {
+      if (hasPendingCaptures(s.basePath)) {
+        const pending = loadPendingCaptures(s.basePath);
+        if (pending.length > 0) {
+          const state = await deriveState(s.basePath);
+          const mid = state.activeMilestone?.id;
+          const sid = state.activeSlice?.id;
+
+          if (mid && sid) {
+            let currentPlan = "";
+            let roadmapContext = "";
+            const planFile = resolveSliceFile(s.basePath, mid, sid, "PLAN");
+            if (planFile) currentPlan = (await loadFile(planFile)) ?? "";
+            const roadmapFile = resolveMilestoneFile(s.basePath, mid, "ROADMAP");
+            if (roadmapFile) roadmapContext = (await loadFile(roadmapFile)) ?? "";
+
+            const capturesList = pending.map(c =>
+              `- **${c.id}**: "${c.text}" (captured: ${c.timestamp})`
+            ).join("\n");
+
+            const prompt = loadPrompt("triage-captures", {
+              pendingCaptures: capturesList,
+              currentPlan: currentPlan || "(no active slice plan)",
+              roadmapContext: roadmapContext || "(no active roadmap)",
+            });
+
+            ctx.ui.notify(
+              `Triaging ${pending.length} pending capture${pending.length === 1 ? "" : "s"}...`,
+              "info",
+            );
+
+            if (s.currentUnit) {
+              await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt);
+            }
+
+            const triageUnitType = "triage-captures";
+            const triageUnitId = `${mid}/${sid}/triage`;
+            dispatchUnit(s, s.basePath, triageUnitType, triageUnitId);
+            updateProgressWidget(ctx, triageUnitType, triageUnitId, state);
+
+            const result = await s.cmdCtx!.newSession();
+            if (result.cancelled) {
+              await stopAuto(ctx, pi);
+              return "stopped";
+            }
+            const sessionFile = ctx.sessionManager.getSessionFile();
+            writeLock(lockBase(), triageUnitType, triageUnitId, s.completedUnits.length, sessionFile);
+
+            const supervisor = resolveAutoSupervisorConfig();
+            const triageTimeoutMs = (supervisor.hard_timeout_minutes ?? 30) * 60 * 1000;
+            s.unitTimeoutHandle = setTimeout(async () => {
+              s.unitTimeoutHandle = null;
+              if (!s.active) return;
+              ctx.ui.notify(
+                `Triage unit exceeded timeout. Pausing auto-mode.`,
+                "warning",
+              );
+              await pauseAuto(ctx, pi);
+            }, triageTimeoutMs);
+
+            if (!s.active) return "stopped";
+            pi.sendMessage(
+              { customType: "gsd-auto", content: prompt, display: s.verbose },
+              { triggerTurn: true },
+            );
+            return "dispatched";
+          }
+        }
+      }
+    } catch {
+      // Triage check failure is non-fatal
+    }
+  }
+
+  // ── Quick-task dispatch ──
+  if (
+    !s.stepMode &&
+    s.pendingQuickTasks.length > 0 &&
+    s.currentUnit &&
+    s.currentUnit.type !== "quick-task"
+  ) {
+    try {
+      const capture = s.pendingQuickTasks.shift()!;
+      const { buildQuickTaskPrompt } = await import("./triage-resolution.js");
+      const { markCaptureExecuted } = await import("./captures.js");
+      const prompt = buildQuickTaskPrompt(capture);
+
+      ctx.ui.notify(
+        `Executing quick-task: ${capture.id} — "${capture.text}"`,
+        "info",
+      );
+
+      if (s.currentUnit) {
+        await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt);
+      }
+
+      const qtUnitType = "quick-task";
+      const qtUnitId = `${s.currentMilestoneId}/${capture.id}`;
+      dispatchUnit(s, s.basePath, qtUnitType, qtUnitId);
+      const state = await deriveState(s.basePath);
+      updateProgressWidget(ctx, qtUnitType, qtUnitId, state);
+
+      const result = await s.cmdCtx!.newSession();
+      if (result.cancelled) {
+        await stopAuto(ctx, pi);
+        return "stopped";
+      }
+      const sessionFile = ctx.sessionManager.getSessionFile();
+      writeLock(lockBase(), qtUnitType, qtUnitId, s.completedUnits.length, sessionFile);
+
+      markCaptureExecuted(s.basePath, capture.id);
+
+      const supervisor = resolveAutoSupervisorConfig();
+      const qtTimeoutMs = (supervisor.hard_timeout_minutes ?? 30) * 60 * 1000;
+      s.unitTimeoutHandle = setTimeout(async () => {
+        s.unitTimeoutHandle = null;
+        if (!s.active) return;
+        ctx.ui.notify(
+          `Quick-task ${capture.id} exceeded timeout. Pausing auto-mode.`,
+          "warning",
+        );
+        await pauseAuto(ctx, pi);
+      }, qtTimeoutMs);
+
+      if (!s.active) return "stopped";
+      pi.sendMessage(
+        { customType: "gsd-auto", content: prompt, display: s.verbose },
+        { triggerTurn: true },
+      );
+      return "dispatched";
+    } catch {
+      // Non-fatal — proceed to normal dispatch
+    }
+  }
+
+  // Step mode → show wizard instead of dispatch
+  if (s.stepMode) {
+    return "step-wizard";
+  }
+
+  return "continue";
+}