@opengsd/gsd-pi 1.1.1-dev.3ea310e → 1.1.1-dev.595401e

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

@@ -277,7 +277,6 @@ export class AutoOrchestrator implements AutoOrchestrationModule {
       this.status.activeUnit = { unitType: decision.unitType, unitId: decision.unitId };
       this.status.phase = "running";
       this.lastAdvanceKey = nextKey;
-      this.lastFinalizedUnitKey = null;
       this.bumpTransition();
 
       await this.deps.runtime.journalTransition({

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

@@ -88,7 +88,7 @@ import { resolveManifest } from "../unit-context-manifest.js";
 import { createWorktreeSafetyModule, type WorktreeSafetyResult } from "../worktree-safety.js";
 import { isSuspiciousGhostCompletion } from "../auto-unit-closeout.js";
 import { decideVerificationRetry, verificationRetryKey } from "./verification-retry-policy.js";
-import { buildPhaseHandoffOutcome, setAutoOutcomeWidget } from "../auto-dashboard.js";
+import { buildPhaseHandoffOutcome, setAutoActiveStatus, setAutoOutcomeWidget } from "../auto-dashboard.js";
 import { getConsecutiveDispatchBlocker } from "../dispatch-guard.js";
 import {
   captureRootDirtySnapshot,
@@ -100,7 +100,7 @@ import { classifyError, isTransient } from "../error-classifier.js";
 export const STUCK_WINDOW_SIZE = 6;
 const STUCK_RECOVERY_ATTEMPTS_KEY = "stuck_recovery_attempts";
 const ZERO_TOOL_PROVIDER_ERROR_PREFIX_RE =
-  /^(?:api error(?::|$|\s*\()|provider error(?::|$|\s*\()|request failed\b|(?:http\s*)?(?:429|500|502|503)\b|\b(?:econnreset|etimedout|econnrefused|epipe)\b|socket hang up\b|fetch failed\b|(?:network|connection|server) error(?::|$)|connection (?:reset|refused)(?::|$|\s+by\b)|dns\b.*(?:fail|error|timeout)|unexpected eof\b|stream idle timeout\b|partial response received\b|stream_exhausted\b|terminated(?::|$)|(?:connection|stream|request)\b.{0,40}\bterminated\b|other side closed\b|rate.?limit(?:ed| exceeded| reached| error)|too many requests\b|you(?:'ve| have) hit your limit\b|usage limit\b|out of extra usage\b|service.?unavailable\b|internal(?: server)? error(?::|$)|internal(?:[_-]server)?[_-]error\b|server[_-]error\b|(?:provider|server|api|model|codex|claude|openai|anthropic|gemini)\b.{0,80}\boverloaded\b|overloaded\b.{0,80}\b(?:provider|server|api|model)\b|context (?:window|length) exceed|context window exceed)/i;
+  /^(?:api error(?::|$|\s*\()|provider error(?::|$|\s*\()|request failed\b|(?:http\s*)?(?:429|500|502|503)\b|\b(?:econnreset|etimedout|econnrefused|epipe)\b|socket hang up\b|fetch failed\b|(?:network|connection|server) error(?::|$)|connection (?:reset|refused)(?::|$|\s+by\b)|dns\b.*(?:fail|error|timeout)|unexpected eof\b|stream idle timeout\b|partial response received\b|stream_exhausted\b|terminated(?::|$)|(?:connection|stream|request)\b.{0,40}\bterminated\b|other side closed\b|rate.?limit(?:ed| exceeded| reached| error)|too many requests\b|you(?:'ve| have) (?:hit|reached) your (?:\w+ )?limit\b|.*\b(?:usage|session|weekly|daily|monthly|quota) limit\b|limit\b.{0,40}\bresets?\b|out of extra usage\b|service.?unavailable\b|internal(?: server)? error(?::|$)|internal(?:[_-]server)?[_-]error\b|server[_-]error\b|(?:provider|server|api|model|codex|claude|openai|anthropic|gemini)\b.{0,80}\boverloaded\b|overloaded\b.{0,80}\b(?:provider|server|api|model)\b|context (?:window|length) exceed|context window exceed)/i;
 const ZERO_TOOL_PROVIDER_ERROR_SIGNAL_RE =
   /(?:\b(?:http|status(?: code)?|code|error:)\s*(?:429|500|502|503)\b|\b(?:api|provider) error\s*[:(]?\s*(?:429|500|502|503)\b|\b(?:typeerror|error):\s*(?:fetch failed\b|socket hang up\b|terminated(?::|$)|connection (?:reset|refused)(?::|$|\s+by\b)|(?:network|connection|server) error(?::|$)|stream idle timeout\b|partial response received\b|unexpected eof\b)|\b(?:server_error|api_error|stream_exhausted(?:_without_result)?)\b|\b(?:econnreset|etimedout|econnrefused|epipe)\b|context (?:window|length) exceed|context window exceed)/i;
 
@@ -114,6 +114,8 @@ function classifyZeroToolProviderMessage(message: string): ReturnType<typeof cla
   return classifyError(firstLine);
 }
 
+export const _classifyZeroToolProviderMessageForTest = classifyZeroToolProviderMessage;
+
 export function resolveDispatchRecoveryAttempts(
   unitRecoveryCount: Map<string, number>,
   unitType: string,
@@ -2092,7 +2094,7 @@ export async function runUnitPhase(
   const nextDispatchCount = (s.unitDispatchCount.get(dispatchKey) ?? 0) + 1;
 
   // Status bar (widget + preconditions deferred until after model selection — see #2899)
-  ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
+  setAutoActiveStatus(ctx, s.stepMode ? "next" : "auto");
   if (mid)
     deps.updateSliceProgressCache(s.basePath, mid, state.activeSlice?.id);
 

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

@@ -13,10 +13,11 @@ import type {
   ExtensionCommandContext,
   ReadonlyFooterDataProvider,
   Theme,
+  ThemeColor,
 } from "@gsd/pi-coding-agent";
 import type { GSDState } from "./types.js";
 import { getActiveHook } from "./post-unit-hooks.js";
-import { getLedger } from "./metrics.js";
+import { getLedger, getProjectTotals } from "./metrics.js";
 import { getErrorMessage } from "./error-utils.js";
 import { nativeIsRepo } from "./native-git-bridge.js";
 import {
@@ -304,6 +305,40 @@ export function shouldRenderRoadmapProgress(
   return !!progress && progress.total > 0;
 }
 
+function widgetGridLabel(theme: Theme, text: string, color: ThemeColor = "borderAccent"): string {
+  return theme.fg(color, theme.bold(text.toUpperCase()));
+}
+
+function widgetGridColumn(content: string, width: number): string {
+  return padRightVisible(truncateToWidth(content, width, "…"), width);
+}
+
+function widgetGridColumns(theme: Theme, width: number, parts: string[]): string {
+  if (parts.length === 0) return "";
+  const gap = theme.fg("dim", " │ ");
+  const gapWidth = visibleWidth(gap) * (parts.length - 1);
+  const available = Math.max(parts.length * 8, width - gapWidth);
+  const base = Math.floor(available / parts.length);
+  let remaining = available - base * parts.length;
+  const columns = parts.map((part) => {
+    const columnWidth = base + (remaining > 0 ? 1 : 0);
+    remaining--;
+    return widgetGridColumn(part, columnWidth);
+  });
+  return truncateToWidth(columns.join(gap), width, "…");
+}
+
+function formatSmallWidgetSpend(): string {
+  const ledger = getLedger();
+  if (!ledger || ledger.units.length === 0) return "--";
+
+  const totals = getProjectTotals(ledger.units);
+  const parts: string[] = [];
+  if (totals.tokens.total > 0) parts.push(formatWidgetTokens(totals.tokens.total));
+  if (totals.cost > 0) parts.push(`$${totals.cost.toFixed(2)}`);
+  return parts.length > 0 ? parts.join(" · ") : "--";
+}
+
 // ─── ETA Estimation ──────────────────────────────────────────────────────────
 
 /**
@@ -516,8 +551,9 @@ export const hideFooter = (_tui: unknown, theme: Theme, footerData: ReadonlyFoot
 
 /** Widget display modes: full → small → min → off → full */
 export type WidgetMode = "full" | "small" | "min" | "off";
+export const DEFAULT_WIDGET_MODE: WidgetMode = "small";
 const WIDGET_MODES: WidgetMode[] = ["full", "small", "min", "off"];
-let widgetMode: WidgetMode = "full";
+let widgetMode: WidgetMode = DEFAULT_WIDGET_MODE;
 let widgetModeInitialized = false;
 let widgetModePreferencePath: string | null = null;
 
@@ -628,7 +664,7 @@ export function getWidgetMode(projectPath?: string, globalPath?: string): Widget
 
 /** Test-only reset for widget mode caching. */
 export function _resetWidgetModeForTests(): void {
-  widgetMode = "full";
+  widgetMode = DEFAULT_WIDGET_MODE;
   widgetModeInitialized = false;
   widgetModePreferencePath = null;
 }
@@ -648,6 +684,16 @@ export interface WidgetStateAccessors {
   getCurrentDispatchedModelId(): string | null;
 }
 
+function clearAutoOutcomeWidget(ctx: ExtensionContext): void {
+  if (!ctx.hasUI) return;
+  ctx.ui.setWidget("gsd-outcome", undefined);
+}
+
+export function setAutoActiveStatus(ctx: ExtensionContext, status: "auto" | "next"): void {
+  ctx.ui.setStatus("gsd-auto", status);
+  clearAutoOutcomeWidget(ctx);
+}
+
 export function updateProgressWidget(
   ctx: ExtensionContext,
   unitType: string,
@@ -673,7 +719,7 @@ export function updateProgressWidget(
     ctx.ui.setStatus("gsd-step", undefined);
   }
   if (!accessors.isSessionSwitching()) {
-    ctx.ui.setWidget("gsd-outcome", undefined);
+    clearAutoOutcomeWidget(ctx);
   }
 
   const verb = unitVerb(unitType);
@@ -732,6 +778,7 @@ export function updateProgressWidget(
         logWarning("dashboard", `DB status update failed: ${err instanceof Error ? err.message : String(err)}`);
       }
     }, 15_000);
+    progressRefreshTimer.unref?.();
 
     return {
       render(width: number): string[] {
@@ -824,29 +871,62 @@ export function updateProgressWidget(
           return lines;
         }
 
-        // ── Mode: small — header + active work progress ───────────────
+        // ── Mode: small — dense horizontal grid ───────────────────────
         if (widgetMode === "small") {
-          lines.push("");
-
-          // Action line
-          const target = task ? `${task.id}: ${task.title}` : unitId;
-          const actionLeft = `${pad}${theme.fg("accent", "▸")} ${theme.fg("accent", verb)}  ${theme.fg("text", target)}`;
-          lines.push(rightAlign(actionLeft, theme.fg("dim", phaseLabel), width));
+          lines.length = 0;
+          lines.push(...ui.bar());
 
-          // Progress bar
           const roadmapSlices = mid ? getRoadmapSlicesSync() : null;
+          const unitLabel = unitId || [mid?.id, slice?.id, task?.id].filter(Boolean).join("/");
+          const statusParts = [
+            spinner,
+            theme.fg("success", modeTag),
+            theme.fg(stateColor, activeState),
+          ];
+          if (runtimeSignal?.summary) {
+            statusParts.push(theme.fg(healthColor, healthSummary));
+          } else if (healthLevel !== "green") {
+            statusParts.push(`${theme.fg(healthColor, healthIcon)} ${theme.fg(healthColor, healthSummary)}`);
+          }
+
+          const timeValue = [elapsed, etaShort].filter(Boolean).join(" · ") || "--";
+          const rowOne = widgetGridColumns(theme, width, [
+            `${widgetGridLabel(theme, "status", "border")} ${statusParts.join(" ")}`,
+            `${widgetGridLabel(theme, "unit")} ${theme.fg("text", unitLabel || "--")}`,
+            `${widgetGridLabel(theme, "spend", "border")} ${theme.fg("dim", formatSmallWidgetSpend())}`,
+            `${widgetGridLabel(theme, "time")} ${theme.fg("dim", timeValue)}`,
+          ]);
+
+          const target = task
+            ? `${task.id}: ${task.title}`
+            : slice
+              ? `${slice.id}: ${slice.title}`
+              : unitId;
+
+          let taskValue = task?.id ?? "--";
+          let sliceValue = slice?.id ?? "--";
           if (shouldRenderRoadmapProgress(roadmapSlices)) {
             const { done, total, activeSliceTasks } = roadmapSlices;
-            const barWidth = Math.max(6, Math.min(18, Math.floor(width * 0.25)));
+            const barWidth = Math.max(4, Math.min(14, Math.floor(width * 0.12)));
             const bar = renderProgressBar(theme, done, total, barWidth);
-            let meta = `${theme.fg("text", `${done}`)}${theme.fg("dim", `/${total} slices`)}`;
+            sliceValue = `${bar} ${theme.fg("text", `${done}/${total}`)}`;
             if (activeSliceTasks && activeSliceTasks.total > 0) {
-              const tn = Math.min(activeSliceTasks.done + 1, activeSliceTasks.total);
-              meta += `${theme.fg("dim", " · task ")}${theme.fg("accent", `${tn}`)}${theme.fg("dim", `/${activeSliceTasks.total}`)}`;
+              const taskNum = isHook
+                ? Math.max(activeSliceTasks.done, 1)
+                : Math.min(activeSliceTasks.done + 1, activeSliceTasks.total);
+              taskValue = `${theme.fg("accent", `${taskNum}`)}${theme.fg("dim", `/${activeSliceTasks.total}`)}`;
             }
-            lines.push(`${pad}${bar} ${meta}`);
           }
 
+          const rowTwo = widgetGridColumns(theme, width, [
+            `${widgetGridLabel(theme, "phase", "border")} ${theme.fg("dim", unitType)}`,
+            `${widgetGridLabel(theme, "work")} ${theme.fg("text", target || "--")}`,
+            `${widgetGridLabel(theme, "task", "border")} ${taskValue}`,
+            `${widgetGridLabel(theme, "slice")} ${sliceValue}`,
+          ]);
+
+          lines.push(rowOne);
+          lines.push(rowTwo);
           lines.push(...ui.bar());
           cachedLines = lines;
           cachedWidth = width;
@@ -1003,7 +1083,7 @@ export function setCompletionProgressWidget(
 ): void {
   if (!ctx.hasUI) return;
   const widgetKey = "gsd-progress";
-  ctx.ui.setWidget("gsd-outcome", undefined);
+  clearAutoOutcomeWidget(ctx);
 
   if (typeof ctx.ui?.setHeader === "function") {
     ctx.ui.setHeader(() => ({

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

@@ -622,6 +622,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
           structuredQuestionsAvailable,
           { headless: !!process.env.GSD_HEADLESS },
         ),
+        pauseAfterDispatch: !process.env.GSD_HEADLESS,
       };
     },
   },
@@ -772,6 +773,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
           structuredQuestionsAvailable,
           { headless: !!process.env.GSD_HEADLESS },
         ),
+        pauseAfterDispatch: !process.env.GSD_HEADLESS,
       };
     },
   },
@@ -805,6 +807,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
         unitType: "discuss-project",
         unitId: "PROJECT",
         prompt: await buildDiscussProjectPrompt(basePath, structuredQuestionsAvailable),
+        pauseAfterDispatch: !process.env.GSD_HEADLESS,
       };
     },
   },
@@ -826,6 +829,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
         unitType: "discuss-requirements",
         unitId: "REQUIREMENTS",
         prompt: await buildDiscussRequirementsPrompt(basePath, structuredQuestionsAvailable),
+        pauseAfterDispatch: !process.env.GSD_HEADLESS,
       };
     },
   },
@@ -940,6 +944,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
           structuredQuestionsAvailable,
           { headless: !!process.env.GSD_HEADLESS },
         ),
+        pauseAfterDispatch: !process.env.GSD_HEADLESS,
       };
     },
   },

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

@@ -55,8 +55,10 @@ import { parseRoadmap as parseLegacyRoadmap } from "./parsers-legacy.js";
 import { consumeSignal } from "./session-status-io.js";
 import {
   checkPostUnitHooks,
+  consumeHookFailure,
   isRetryPending,
   consumeRetryTrigger,
+  consumeGateBlock,
   persistHookState,
   resolveHookArtifactPath,
 } from "./post-unit-hooks.js";
@@ -394,6 +396,50 @@ function stripKnownIdPrefix(value: string | undefined | null, id: string): strin
   return raw;
 }
 
+function parseReactiveBatchTaskIds(unitId: string): string[] {
+  const { task: batchPart } = parseUnitId(unitId);
+  if (!batchPart?.startsWith("reactive+")) return [];
+
+  const rawIds = batchPart
+    .slice("reactive+".length)
+    .split(",")
+    .map((taskId) => taskId.trim().toUpperCase())
+    .filter(Boolean);
+
+  const unique = new Set<string>();
+  for (const taskId of rawIds) {
+    unique.add(taskId);
+  }
+  return [...unique];
+}
+
+function dedupePaths(values: string[]): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const value of values) {
+    if (!seen.has(value)) {
+      seen.add(value);
+      result.push(value);
+    }
+  }
+  return result;
+}
+
+function getPlannedKeyFiles(tasks: Array<
+  { expected_output?: string[]; files?: string[]; key_files?: string[] }
+>): string[] {
+  return dedupePaths(
+    tasks.flatMap((taskRow) => [
+      ...(taskRow.expected_output ?? []),
+      ...(taskRow.files ?? []),
+      ...(taskRow.key_files ?? []),
+    ]),
+  );
+}
+
+export const _parseReactiveBatchTaskIdsForTest = parseReactiveBatchTaskIds;
+export const _getPlannedKeyFilesForTest = getPlannedKeyFiles;
+
 function resolveVerificationFailureMarkerPath(
   unitType: string,
   unitId: string,
@@ -481,6 +527,40 @@ async function buildTaskCommitContextForUnit(
   };
 }
 
+async function buildReactiveTaskCommitContext(
+  _basePath: string,
+  unitId: string,
+): Promise<TaskCommitContext | undefined> {
+  const { milestone: mid, slice: sid } = parseUnitId(unitId);
+  if (!mid || !sid || !isDbAvailable()) return undefined;
+
+  const batchTaskIds = parseReactiveBatchTaskIds(unitId);
+  if (batchTaskIds.length === 0) return undefined;
+
+  const milestone = getMilestone(mid);
+  const slice = getSlice(mid, sid);
+  const taskRows = batchTaskIds
+    .map((tid) => getTask(mid, sid, tid))
+    .filter((taskRow): taskRow is NonNullable<ReturnType<typeof getTask>> => taskRow !== null);
+
+  const keyFiles = getPlannedKeyFiles(taskRows);
+  if (taskRows.length === 0 || keyFiles.length === 0) return undefined;
+
+  const taskLabel = taskRows.map((row) => row.id).join(",");
+
+  return {
+    taskId: `${sid}/${taskLabel}`,
+    taskDisplayId: "reactive-batch",
+    taskTitle: `Reactive batch: ${taskLabel}`,
+    milestoneId: mid,
+    milestoneTitle: stripKnownIdPrefix(milestone?.title, mid),
+    sliceId: sid,
+    sliceTitle: stripKnownIdPrefix(slice?.title, sid),
+    oneLiner: `Reactive execute for ${taskLabel}`,
+    keyFiles,
+  };
+}
+
 async function runPostUnitGitHubSyncIfNeeded(
   basePath: string,
   unit: NonNullable<AutoSession["currentUnit"]>,
@@ -943,6 +1023,8 @@ export async function autoCommitUnit(
 
     if (unitType === "execute-task") {
       taskContext = await buildTaskCommitContextForUnit(basePath, unitId);
+    } else if (unitType === "reactive-execute") {
+      taskContext = await buildReactiveTaskCommitContext(basePath, unitId);
     }
 
     _resetHasChangesCache();
@@ -1005,6 +1087,21 @@ async function runCloseoutGitAction(
       if (mid && sid && tid && isDbAvailable()) {
         targetRepositories = getTask(mid, sid, tid)?.target_repositories;
       }
+    } else if (turnAction === "commit" && unit.type === "reactive-execute") {
+      taskContext = await buildReactiveTaskCommitContext(s.basePath, unit.id);
+      const { milestone: mid, slice: sid } = parseUnitId(unit.id);
+      if (mid && sid && isDbAvailable()) {
+        const repositories = new Set<string>();
+        for (const tid of parseReactiveBatchTaskIds(unit.id)) {
+          const taskRow = getTask(mid, sid, tid);
+          for (const repoId of taskRow?.target_repositories ?? []) {
+            repositories.add(repoId);
+          }
+        }
+        if (repositories.size > 0) {
+          targetRepositories = [...repositories];
+        }
+      }
     }
 
     // Invalidate the nativeHasChanges cache before auto-commit (#1853).
@@ -1436,12 +1533,24 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
         const { milestone: sMid, slice: sSid, task: sTid } = parseUnitId(s.currentUnit.id);
 
         // File change validation (execute-task only, after unit execution)
-        if (safetyConfig.file_change_validation && s.currentUnit.type === "execute-task" && sMid && sSid && sTid && isDbAvailable()) {
+        if (safetyConfig.file_change_validation && s.currentUnit.type === "execute-task" && sMid && sSid && sTid) {
           try {
-            const taskRow = getTask(sMid, sSid, sTid);
-            if (taskRow) {
-              const expectedOutput = taskRow.expected_output ?? [];
-              const plannedFiles = taskRow.files ?? [];
+            const sliceTaskRows = isDbAvailable()
+              ? getSliceTasks(sMid, sSid).filter((t) => isClosedStatus(t.status) || t.id === sTid)
+              : [];
+
+            if (sliceTaskRows.length > 0) {
+              const expectedOutput = getPlannedKeyFiles(
+                sliceTaskRows.map((taskRow) => ({
+                  expected_output: taskRow.expected_output,
+                  files: taskRow.files,
+                })),
+              );
+              const plannedFiles = getPlannedKeyFiles(
+                sliceTaskRows.map((taskRow) => ({
+                  files: taskRow.files,
+                })),
+              );
               const audit = validateFileChanges(s.basePath, expectedOutput, plannedFiles, safetyConfig.file_change_allowlist);
               if (audit && audit.violations.length > 0) {
                 const warnings = audit.violations.filter(v => v.severity === "warning");
@@ -1455,6 +1564,30 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
                   );
                 }
               }
+            } else {
+              const taskRow = getTask(sMid, sSid, sTid);
+              if (taskRow) {
+                const expectedOutput = taskRow.expected_output ?? [];
+                const plannedFiles = taskRow.files ?? [];
+                const audit = validateFileChanges(
+                  s.basePath,
+                  expectedOutput,
+                  plannedFiles,
+                  safetyConfig.file_change_allowlist,
+                );
+                if (audit && audit.violations.length > 0) {
+                  const warnings = audit.violations.filter(v => v.severity === "warning");
+                  for (const v of warnings) {
+                    logWarning("safety", `file-change: ${v.file} — ${v.reason}`);
+                  }
+                  if (warnings.length > 0) {
+                    ctx.ui.notify(
+                      `Safety: ${warnings.length} unexpected file change(s) outside task plan`,
+                      "warning",
+                    );
+                  }
+                }
+              }
             }
           } catch (e) {
             debugLog("postUnit", { phase: "safety-file-change", error: String(e) });
@@ -2096,11 +2229,11 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
   // ── Post-unit hooks ──
   if (s.currentUnit && !s.stepMode) {
     const hookUnit = checkPostUnitHooks(s.currentUnit.type, s.currentUnit.id, s.basePath);
+    persistHookState(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));
       }
-      persistHookState(s.basePath);
 
       return enqueueSidecar(
         s, ctx,
@@ -2109,12 +2242,23 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
       );
     }
 
+    const hookFailure = consumeHookFailure();
+    if (hookFailure) {
+      ctx.ui.notify(
+        `Post-unit hook ${hookFailure.hookName} failed for ${hookFailure.unitId}: ${hookFailure.reason}. Pausing auto-mode.`,
+        "warning",
+      );
+      await pauseAuto(ctx, pi);
+      return "stopped";
+    }
+
     // Check if a hook requested a retry of the trigger unit
     if (isRetryPending()) {
       const trigger = consumeRetryTrigger();
       if (trigger) {
+        persistHookState(s.basePath);
         ctx.ui.notify(
-          `Hook requested retry of ${trigger.unitType} ${trigger.unitId} — resetting task state.`,
+          `Hook requested retry of ${trigger.unitType} ${trigger.unitId} — resetting trigger unit state.`,
           "info",
         );
 
@@ -2168,6 +2312,19 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
         // Fall through to normal dispatch — deriveState will re-derive the unit
       }
     }
+
+    const gateBlock = consumeGateBlock();
+    if (gateBlock) {
+      persistHookState(s.basePath);
+      const verdict = gateBlock.verdict ? ` verdict=${gateBlock.verdict};` : "";
+      const artifact = gateBlock.artifact ? ` artifact=${gateBlock.artifact};` : "";
+      const message =
+        `Post-unit gate "${gateBlock.hookName}" blocked ${gateBlock.triggerUnitType} ${gateBlock.triggerUnitId}:` +
+        `${verdict}${artifact} ${gateBlock.reason}. Run /gsd status to inspect, then /gsd auto after recovery.`;
+      ctx.ui.notify(message, "warning");
+      await pauseAuto(ctx, pi);
+      return "stopped";
+    }
   }
 
   // ── Fast-path stop detection (#3487) ──