gsd-pi 2.33.0-dev.bafba33 → 2.33.1-dev.235d83a

package/dist/resources/extensions/gsd/auto-timeout-recovery.js

@@ -0,0 +1,183 @@
+/**
+ * Timeout recovery logic for auto-mode units.
+ * Handles idle and hard timeout recovery with escalation, steering messages,
+ * and blocker placeholder generation.
+ */
+import { readUnitRuntimeRecord, writeUnitRuntimeRecord, formatExecuteTaskRecoveryStatus, inspectExecuteTaskDurability, } from "./unit-runtime.js";
+import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, skipExecuteTask, writeBlockerPlaceholder, } from "./auto-recovery.js";
+import { existsSync } from "node:fs";
+import { parseUnitId } from "./unit-id.js";
+export async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rctx) {
+    const { basePath, verbose, currentUnitStartedAt, unitRecoveryCount, dispatchNextUnit } = rctx;
+    const runtime = readUnitRuntimeRecord(basePath, unitType, unitId);
+    const recoveryAttempts = runtime?.recoveryAttempts ?? 0;
+    const maxRecoveryAttempts = reason === "idle" ? 2 : 1;
+    const recoveryKey = `${unitType}/${unitId}`;
+    const attemptNumber = (unitRecoveryCount.get(recoveryKey) ?? 0) + 1;
+    unitRecoveryCount.set(recoveryKey, attemptNumber);
+    if (attemptNumber > 1) {
+        // Exponential backoff: 2^(n-1) seconds, capped at 30s
+        const backoffMs = Math.min(1000 * Math.pow(2, attemptNumber - 2), 30000);
+        ctx.ui.notify(`Recovery attempt ${attemptNumber} for ${unitType} ${unitId}. Waiting ${backoffMs / 1000}s before retry.`, "info");
+        await new Promise(r => setTimeout(r, backoffMs));
+    }
+    if (unitType === "execute-task") {
+        const status = await inspectExecuteTaskDurability(basePath, unitId);
+        if (!status)
+            return "paused";
+        writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnitStartedAt, {
+            recovery: status,
+        });
+        const durableComplete = status.summaryExists && status.taskChecked && status.nextActionAdvanced;
+        if (durableComplete) {
+            writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnitStartedAt, {
+                phase: "finalized",
+                recovery: status,
+            });
+            ctx.ui.notify(`${reason === "idle" ? "Idle" : "Timeout"} recovery: ${unitType} ${unitId} already completed on disk. Continuing auto-mode. (attempt ${attemptNumber})`, "info");
+            unitRecoveryCount.delete(recoveryKey);
+            await dispatchNextUnit(ctx, pi);
+            return "recovered";
+        }
+        if (recoveryAttempts < maxRecoveryAttempts) {
+            const isEscalation = recoveryAttempts > 0;
+            writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnitStartedAt, {
+                phase: "recovered",
+                recovery: status,
+                recoveryAttempts: recoveryAttempts + 1,
+                lastRecoveryReason: reason,
+                lastProgressAt: Date.now(),
+                progressCount: (runtime?.progressCount ?? 0) + 1,
+                lastProgressKind: reason === "idle" ? "idle-recovery-retry" : "hard-recovery-retry",
+            });
+            const steeringLines = isEscalation
+                ? [
+                    `**FINAL ${reason === "idle" ? "IDLE" : "HARD TIMEOUT"} RECOVERY — last chance before this task is skipped.**`,
+                    `You are still executing ${unitType} ${unitId}.`,
+                    `Recovery attempt ${recoveryAttempts + 1} of ${maxRecoveryAttempts}.`,
+                    `Current durability status: ${formatExecuteTaskRecoveryStatus(status)}.`,
+                    "You MUST finish the durable output NOW, even if incomplete.",
+                    "Write the task summary with whatever you have accomplished so far.",
+                    "Mark the task [x] in the plan. Commit your work.",
+                    "A partial summary is infinitely better than no summary.",
+                ]
+                : [
+                    `**${reason === "idle" ? "IDLE" : "HARD TIMEOUT"} RECOVERY — do not stop.**`,
+                    `You are still executing ${unitType} ${unitId}.`,
+                    `Recovery attempt ${recoveryAttempts + 1} of ${maxRecoveryAttempts}.`,
+                    `Current durability status: ${formatExecuteTaskRecoveryStatus(status)}.`,
+                    "Do not keep exploring.",
+                    "Immediately finish the required durable output for this unit.",
+                    "If full completion is impossible, write the partial artifact/state needed for recovery and make the blocker explicit.",
+                ];
+            pi.sendMessage({
+                customType: "gsd-auto-timeout-recovery",
+                display: verbose,
+                content: steeringLines.join("\n"),
+            }, { triggerTurn: true, deliverAs: "steer" });
+            ctx.ui.notify(`${reason === "idle" ? "Idle" : "Timeout"} recovery: steering ${unitType} ${unitId} to finish durable output (attempt ${attemptNumber}, session ${recoveryAttempts + 1}/${maxRecoveryAttempts}).`, "warning");
+            return "recovered";
+        }
+        // Retries exhausted — write missing durable artifacts and advance.
+        const diagnostic = formatExecuteTaskRecoveryStatus(status);
+        const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+        const skipped = mid && sid && tid
+            ? skipExecuteTask(basePath, mid, sid, tid, status, reason, maxRecoveryAttempts)
+            : false;
+        if (skipped) {
+            writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnitStartedAt, {
+                phase: "skipped",
+                recovery: status,
+                recoveryAttempts: recoveryAttempts + 1,
+                lastRecoveryReason: reason,
+            });
+            ctx.ui.notify(`${unitType} ${unitId} skipped after ${maxRecoveryAttempts} recovery attempts (${diagnostic}). Blocker artifacts written. Advancing pipeline. (attempt ${attemptNumber})`, "warning");
+            unitRecoveryCount.delete(recoveryKey);
+            await dispatchNextUnit(ctx, pi);
+            return "recovered";
+        }
+        // Fallback: couldn't write skip artifacts — pause as before.
+        writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnitStartedAt, {
+            phase: "paused",
+            recovery: status,
+            recoveryAttempts: recoveryAttempts + 1,
+            lastRecoveryReason: reason,
+        });
+        ctx.ui.notify(`${reason === "idle" ? "Idle" : "Timeout"} recovery check for ${unitType} ${unitId}: ${diagnostic}`, "warning");
+        return "paused";
+    }
+    const expected = diagnoseExpectedArtifact(unitType, unitId, basePath) ?? "required durable artifact";
+    // Check if the artifact already exists on disk — agent may have written it
+    // without signaling completion.
+    const artifactPath = resolveExpectedArtifactPath(unitType, unitId, basePath);
+    if (artifactPath && existsSync(artifactPath)) {
+        writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnitStartedAt, {
+            phase: "finalized",
+            recoveryAttempts: recoveryAttempts + 1,
+            lastRecoveryReason: reason,
+        });
+        ctx.ui.notify(`${reason === "idle" ? "Idle" : "Timeout"} recovery: ${unitType} ${unitId} artifact already exists on disk. Advancing. (attempt ${attemptNumber})`, "info");
+        unitRecoveryCount.delete(recoveryKey);
+        await dispatchNextUnit(ctx, pi);
+        return "recovered";
+    }
+    if (recoveryAttempts < maxRecoveryAttempts) {
+        const isEscalation = recoveryAttempts > 0;
+        writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnitStartedAt, {
+            phase: "recovered",
+            recoveryAttempts: recoveryAttempts + 1,
+            lastRecoveryReason: reason,
+            lastProgressAt: Date.now(),
+            progressCount: (runtime?.progressCount ?? 0) + 1,
+            lastProgressKind: reason === "idle" ? "idle-recovery-retry" : "hard-recovery-retry",
+        });
+        const steeringLines = isEscalation
+            ? [
+                `**FINAL ${reason === "idle" ? "IDLE" : "HARD TIMEOUT"} RECOVERY — last chance before skip.**`,
+                `You are still executing ${unitType} ${unitId}.`,
+                `Recovery attempt ${recoveryAttempts + 1} of ${maxRecoveryAttempts} — next failure skips this unit.`,
+                `Expected durable output: ${expected}.`,
+                "You MUST write the artifact file NOW, even if incomplete.",
+                "Write whatever you have — partial research, preliminary findings, best-effort analysis.",
+                "A partial artifact is infinitely better than no artifact.",
+                "If you are truly blocked, write the file with a BLOCKER section explaining why.",
+            ]
+            : [
+                `**${reason === "idle" ? "IDLE" : "HARD TIMEOUT"} RECOVERY — stay in auto-mode.**`,
+                `You are still executing ${unitType} ${unitId}.`,
+                `Recovery attempt ${recoveryAttempts + 1} of ${maxRecoveryAttempts}.`,
+                `Expected durable output: ${expected}.`,
+                "Stop broad exploration.",
+                "Write the required artifact now.",
+                "If blocked, write the partial artifact and explicitly record the blocker instead of going silent.",
+            ];
+        pi.sendMessage({
+            customType: "gsd-auto-timeout-recovery",
+            display: verbose,
+            content: steeringLines.join("\n"),
+        }, { triggerTurn: true, deliverAs: "steer" });
+        ctx.ui.notify(`${reason === "idle" ? "Idle" : "Timeout"} recovery: steering ${unitType} ${unitId} to produce ${expected} (attempt ${attemptNumber}, session ${recoveryAttempts + 1}/${maxRecoveryAttempts}).`, "warning");
+        return "recovered";
+    }
+    // Retries exhausted — write a blocker placeholder and advance the pipeline
+    // instead of silently stalling.
+    const placeholder = writeBlockerPlaceholder(unitType, unitId, basePath, `${reason} recovery exhausted ${maxRecoveryAttempts} attempts without producing the artifact.`);
+    if (placeholder) {
+        writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnitStartedAt, {
+            phase: "skipped",
+            recoveryAttempts: recoveryAttempts + 1,
+            lastRecoveryReason: reason,
+        });
+        ctx.ui.notify(`${unitType} ${unitId} skipped after ${maxRecoveryAttempts} recovery attempts. Blocker placeholder written to ${placeholder}. Advancing pipeline. (attempt ${attemptNumber})`, "warning");
+        unitRecoveryCount.delete(recoveryKey);
+        await dispatchNextUnit(ctx, pi);
+        return "recovered";
+    }
+    // Fallback: couldn't resolve artifact path — pause as before.
+    writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnitStartedAt, {
+        phase: "paused",
+        recoveryAttempts: recoveryAttempts + 1,
+        lastRecoveryReason: reason,
+    });
+    return "paused";
+}

package/dist/resources/extensions/gsd/auto-timers.js

@@ -0,0 +1,181 @@
+/**
+ * Unit supervision timers — soft timeout warning, idle watchdog,
+ * hard timeout, and context-pressure monitor.
+ *
+ * Extracted from dispatchNextUnit() in auto.ts. All timers are set up
+ * via startUnitSupervision() and torn down by the caller via clearUnitTimeout().
+ */
+import { readUnitRuntimeRecord, writeUnitRuntimeRecord } from "./unit-runtime.js";
+import { resolveAutoSupervisorConfig } from "./preferences.js";
+import { computeBudgets, resolveExecutorContextWindow } from "./context-budget.js";
+import { getInFlightToolCount, getOldestInFlightToolStart, } from "./auto-tool-tracking.js";
+import { detectWorkingTreeActivity } from "./auto-supervisor.js";
+import { closeoutUnit } from "./auto-unit-closeout.js";
+import { saveActivityLog } from "./activity-log.js";
+import { recoverTimedOutUnit } from "./auto-timeout-recovery.js";
+import { getErrorMessage } from "./error-utils.js";
+/**
+ * Set up all four supervision timers for the current unit:
+ * 1. Soft timeout warning (wrapup)
+ * 2. Idle watchdog (progress polling, stuck tool detection)
+ * 3. Hard timeout (pause + recovery)
+ * 4. Context-pressure monitor (continue-here)
+ */
+export function startUnitSupervision(sctx) {
+    const { s, ctx, pi, unitType, unitId, prefs, buildSnapshotOpts, buildRecoveryContext, pauseAuto } = sctx;
+    const supervisor = resolveAutoSupervisorConfig();
+    const softTimeoutMs = (supervisor.soft_timeout_minutes ?? 0) * 60 * 1000;
+    const idleTimeoutMs = (supervisor.idle_timeout_minutes ?? 0) * 60 * 1000;
+    const hardTimeoutMs = (supervisor.hard_timeout_minutes ?? 0) * 60 * 1000;
+    // ── 1. Soft timeout warning ──
+    s.wrapupWarningHandle = setTimeout(() => {
+        s.wrapupWarningHandle = null;
+        if (!s.active || !s.currentUnit)
+            return;
+        writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
+            phase: "wrapup-warning-sent",
+            wrapupWarningSent: true,
+        });
+        pi.sendMessage({
+            customType: "gsd-auto-wrapup",
+            display: s.verbose,
+            content: [
+                "**TIME BUDGET WARNING — keep going only if progress is real.**",
+                "This unit crossed the soft time budget.",
+                "If you are making progress, continue. If not, switch to wrap-up mode now:",
+                "1. rerun the minimal required verification",
+                "2. write or update the required durable artifacts",
+                "3. mark task or slice state on disk correctly",
+                "4. leave precise resume notes if anything remains unfinished",
+            ].join("\n"),
+        }, { triggerTurn: true });
+    }, softTimeoutMs);
+    // ── 2. Idle watchdog ──
+    s.idleWatchdogHandle = setInterval(async () => {
+        try {
+            if (!s.active || !s.currentUnit)
+                return;
+            const runtime = readUnitRuntimeRecord(s.basePath, unitType, unitId);
+            if (!runtime)
+                return;
+            if (Date.now() - runtime.lastProgressAt < idleTimeoutMs)
+                return;
+            // Agent has tool calls currently executing — not idle, just waiting.
+            // But only suppress recovery if the tool started recently.
+            if (getInFlightToolCount() > 0) {
+                const oldestStart = getOldestInFlightToolStart();
+                const toolAgeMs = Date.now() - oldestStart;
+                if (toolAgeMs < idleTimeoutMs) {
+                    writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
+                        lastProgressAt: Date.now(),
+                        lastProgressKind: "tool-in-flight",
+                    });
+                    return;
+                }
+                ctx.ui.notify(`Stalled tool detected: a tool has been in-flight for ${Math.round(toolAgeMs / 60000)}min. Treating as hung — attempting idle recovery.`, "warning");
+            }
+            // Check if the agent is producing work on disk.
+            if (detectWorkingTreeActivity(s.basePath)) {
+                writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
+                    lastProgressAt: Date.now(),
+                    lastProgressKind: "filesystem-activity",
+                });
+                return;
+            }
+            if (s.currentUnit) {
+                await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, buildSnapshotOpts());
+            }
+            else {
+                saveActivityLog(ctx, s.basePath, unitType, unitId);
+            }
+            const recovery = await recoverTimedOutUnit(ctx, pi, unitType, unitId, "idle", buildRecoveryContext());
+            if (recovery === "recovered")
+                return;
+            writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
+                phase: "paused",
+            });
+            ctx.ui.notify(`Unit ${unitType} ${unitId} made no meaningful progress for ${supervisor.idle_timeout_minutes}min. Pausing auto-mode.`, "warning");
+            await pauseAuto(ctx, pi);
+        }
+        catch (err) {
+            const message = getErrorMessage(err);
+            console.error(`[idle-watchdog] Unhandled error: ${message}`);
+            try {
+                ctx.ui.notify(`Idle watchdog error: ${message}`, "warning");
+            }
+            catch { /* best effort */ }
+        }
+    }, 15000);
+    // ── 3. Hard timeout ──
+    s.unitTimeoutHandle = setTimeout(async () => {
+        try {
+            s.unitTimeoutHandle = null;
+            if (!s.active)
+                return;
+            if (s.currentUnit) {
+                writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
+                    phase: "timeout",
+                    timeoutAt: Date.now(),
+                });
+                await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, buildSnapshotOpts());
+            }
+            else {
+                saveActivityLog(ctx, s.basePath, unitType, unitId);
+            }
+            const recovery = await recoverTimedOutUnit(ctx, pi, unitType, unitId, "hard", buildRecoveryContext());
+            if (recovery === "recovered")
+                return;
+            ctx.ui.notify(`Unit ${unitType} ${unitId} exceeded ${supervisor.hard_timeout_minutes}min hard timeout. Pausing auto-mode.`, "warning");
+            await pauseAuto(ctx, pi);
+        }
+        catch (err) {
+            const message = getErrorMessage(err);
+            console.error(`[hard-timeout] Unhandled error: ${message}`);
+            try {
+                ctx.ui.notify(`Hard timeout error: ${message}`, "warning");
+            }
+            catch { /* best effort */ }
+        }
+    }, hardTimeoutMs);
+    // ── 4. Context-pressure continue-here monitor ──
+    if (s.continueHereHandle) {
+        clearInterval(s.continueHereHandle);
+        s.continueHereHandle = null;
+    }
+    const executorContextWindow = resolveExecutorContextWindow(ctx.modelRegistry, prefs, ctx.model?.contextWindow);
+    const continueHereThreshold = computeBudgets(executorContextWindow).continueThresholdPercent;
+    s.continueHereHandle = setInterval(() => {
+        if (!s.active || !s.currentUnit || !s.cmdCtx)
+            return;
+        const runtime = readUnitRuntimeRecord(s.basePath, unitType, unitId);
+        if (runtime?.continueHereFired)
+            return;
+        const contextUsage = s.cmdCtx.getContextUsage();
+        if (!contextUsage || contextUsage.percent == null || contextUsage.percent < continueHereThreshold)
+            return;
+        writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
+            continueHereFired: true,
+        });
+        if (s.verbose) {
+            ctx.ui.notify(`Context at ${contextUsage.percent}% (threshold: ${continueHereThreshold}%) — sending wrap-up signal.`, "info");
+        }
+        pi.sendMessage({
+            customType: "gsd-auto-wrapup",
+            display: s.verbose,
+            content: [
+                "**CONTEXT BUDGET WARNING — wrap up this unit now.**",
+                `Context window is at ${contextUsage.percent}% (threshold: ${continueHereThreshold}%).`,
+                "The next unit needs a fresh context to work effectively. Wrap up now:",
+                "1. Finish any in-progress file writes",
+                "2. Write or update the required durable artifacts (summary, checkboxes)",
+                "3. Mark task state on disk correctly",
+                "4. Leave precise resume notes if anything remains unfinished",
+                "Do NOT start new sub-tasks or investigations.",
+            ].join("\n"),
+        }, { triggerTurn: true });
+        if (s.continueHereHandle) {
+            clearInterval(s.continueHereHandle);
+            s.continueHereHandle = null;
+        }
+    }, 15_000);
+}

package/dist/resources/extensions/gsd/auto-tool-tracking.js

@@ -0,0 +1,50 @@
+/**
+ * In-flight tool call tracking for auto-mode idle detection.
+ * Tracks which tool calls are currently executing so the idle watchdog
+ * can distinguish "waiting for tool completion" from "truly idle".
+ */
+const inFlightTools = new Map();
+/**
+ * Mark a tool execution as in-flight.
+ * Records start time so the idle watchdog can detect tools hung longer than the idle timeout.
+ */
+export function markToolStart(toolCallId, isActive) {
+    if (!isActive)
+        return;
+    inFlightTools.set(toolCallId, Date.now());
+}
+/**
+ * Mark a tool execution as completed.
+ */
+export function markToolEnd(toolCallId) {
+    inFlightTools.delete(toolCallId);
+}
+/**
+ * Returns the age (ms) of the oldest currently in-flight tool, or 0 if none.
+ */
+export function getOldestInFlightToolAgeMs() {
+    if (inFlightTools.size === 0)
+        return 0;
+    const oldestStart = Math.min(...inFlightTools.values());
+    return Date.now() - oldestStart;
+}
+/**
+ * Returns the number of currently in-flight tools.
+ */
+export function getInFlightToolCount() {
+    return inFlightTools.size;
+}
+/**
+ * Returns the start timestamp of the oldest in-flight tool, or undefined if none.
+ */
+export function getOldestInFlightToolStart() {
+    if (inFlightTools.size === 0)
+        return undefined;
+    return Math.min(...inFlightTools.values());
+}
+/**
+ * Clear all in-flight tool tracking state.
+ */
+export function clearInFlightTools() {
+    inFlightTools.clear();
+}

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

@@ -0,0 +1,30 @@
+/**
+ * Unit closeout helper — consolidates the repeated pattern of
+ * snapshotting metrics + saving activity log + extracting memories
+ * that appears 6+ times in auto.ts.
+ */
+import { snapshotUnitMetrics } from "./metrics.js";
+import { saveActivityLog } from "./activity-log.js";
+/**
+ * Snapshot metrics, save activity log, and fire-and-forget memory extraction
+ * for a completed unit. Returns the activity log file path (if any).
+ */
+export async function closeoutUnit(ctx, basePath, unitType, unitId, startedAt, opts) {
+    const modelId = ctx.model?.id ?? "unknown";
+    snapshotUnitMetrics(ctx, unitType, unitId, startedAt, modelId, opts);
+    const activityFile = saveActivityLog(ctx, basePath, unitType, unitId);
+    if (activityFile) {
+        try {
+            const { buildMemoryLLMCall, extractMemoriesFromUnit } = await import('./memory-extractor.js');
+            const llmCallFn = buildMemoryLLMCall(ctx);
+            if (llmCallFn) {
+                extractMemoriesFromUnit(activityFile, unitType, unitId, llmCallFn).catch((err) => {
+                    if (process.env.GSD_DEBUG)
+                        console.error(`[gsd] memory extraction failed for ${unitType}/${unitId}:`, err);
+                });
+            }
+        }
+        catch { /* non-fatal */ }
+    }
+    return activityFile ?? undefined;
+}

package/dist/resources/extensions/gsd/auto-verification.js

@@ -0,0 +1,209 @@
+/**
+ * Post-unit verification gate for auto-mode.
+ *
+ * Runs typecheck/lint/test checks, captures runtime errors, performs
+ * dependency audits, handles auto-fix retry logic, and writes
+ * verification evidence JSON.
+ *
+ * Extracted from handleAgentEnd() in auto.ts. Returns a sentinel
+ * value instead of calling return/pauseAuto directly — the caller
+ * checks the result and handles control flow.
+ */
+import { loadFile, parsePlan } from "./files.js";
+import { resolveSliceFile, resolveSlicePath } from "./paths.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { runVerificationGate, formatFailureContext, captureRuntimeErrors, runDependencyAudit, } from "./verification-gate.js";
+import { writeVerificationJSON } from "./verification-evidence.js";
+import { removePersistedKey } from "./auto-recovery.js";
+import { join } from "node:path";
+import { getErrorMessage } from "./error-utils.js";
+import { parseUnitId } from "./unit-id.js";
+/**
+ * Run the verification gate for the current execute-task unit.
+ * Returns:
+ * - "continue" — gate passed (or no checks configured), proceed normally
+ * - "retry" — gate failed with retries remaining, dispatchNextUnit already called
+ * - "pause" — gate failed with retries exhausted, pauseAuto already called
+ */
+export async function runPostUnitVerification(vctx, dispatchNextUnit, startDispatchGapWatchdog, pauseAuto) {
+    const { s, ctx, pi } = vctx;
+    if (!s.currentUnit || s.currentUnit.type !== "execute-task") {
+        return "continue";
+    }
+    try {
+        const effectivePrefs = loadEffectiveGSDPreferences();
+        const prefs = effectivePrefs?.preferences;
+        // Read task plan verify field
+        const { milestone: mid, slice: sid, task: tid } = parseUnitId(s.currentUnit.id);
+        let taskPlanVerify;
+        if (mid && sid && tid) {
+            const planFile = resolveSliceFile(s.basePath, mid, sid, "PLAN");
+            if (planFile) {
+                const planContent = await loadFile(planFile);
+                if (planContent) {
+                    const slicePlan = parsePlan(planContent);
+                    const taskEntry = slicePlan?.tasks?.find(t => t.id === tid);
+                    taskPlanVerify = taskEntry?.verify;
+                }
+            }
+        }
+        const result = runVerificationGate({
+            basePath: s.basePath,
+            unitId: s.currentUnit.id,
+            cwd: s.basePath,
+            preferenceCommands: prefs?.verification_commands,
+            taskPlanVerify,
+        });
+        // Capture runtime errors
+        const runtimeErrors = await captureRuntimeErrors();
+        if (runtimeErrors.length > 0) {
+            result.runtimeErrors = runtimeErrors;
+            if (runtimeErrors.some(e => e.blocking)) {
+                result.passed = false;
+            }
+        }
+        // Dependency audit
+        const auditWarnings = runDependencyAudit(s.basePath);
+        if (auditWarnings.length > 0) {
+            result.auditWarnings = auditWarnings;
+            process.stderr.write(`verification-gate: ${auditWarnings.length} audit warning(s)\n`);
+            for (const w of auditWarnings) {
+                process.stderr.write(`  [${w.severity}] ${w.name}: ${w.title}\n`);
+            }
+        }
+        // Auto-fix retry preferences
+        const autoFixEnabled = prefs?.verification_auto_fix !== false;
+        const maxRetries = typeof prefs?.verification_max_retries === "number" ? prefs.verification_max_retries : 2;
+        const completionKey = `${s.currentUnit.type}/${s.currentUnit.id}`;
+        if (result.checks.length > 0) {
+            const blockingChecks = result.checks.filter(c => c.blocking);
+            const advisoryChecks = result.checks.filter(c => !c.blocking);
+            const blockingPassCount = blockingChecks.filter(c => c.exitCode === 0).length;
+            const advisoryFailCount = advisoryChecks.filter(c => c.exitCode !== 0).length;
+            if (result.passed) {
+                let msg = blockingChecks.length > 0
+                    ? `Verification gate: ${blockingPassCount}/${blockingChecks.length} blocking checks passed`
+                    : `Verification gate: passed (no blocking checks)`;
+                if (advisoryFailCount > 0) {
+                    msg += ` (${advisoryFailCount} advisory warning${advisoryFailCount > 1 ? "s" : ""})`;
+                }
+                ctx.ui.notify(msg);
+                // Log advisory warnings to stderr for visibility
+                if (advisoryFailCount > 0) {
+                    const advisoryFailures = advisoryChecks.filter(c => c.exitCode !== 0);
+                    process.stderr.write(`verification-gate: ${advisoryFailCount} advisory (non-blocking) failure(s)\n`);
+                    for (const f of advisoryFailures) {
+                        process.stderr.write(`  [advisory] ${f.command} exited ${f.exitCode}\n`);
+                    }
+                }
+            }
+            else {
+                const blockingFailures = blockingChecks.filter(c => c.exitCode !== 0);
+                const failNames = blockingFailures.map(f => f.command).join(", ");
+                ctx.ui.notify(`Verification gate: FAILED — ${failNames}`);
+                process.stderr.write(`verification-gate: ${blockingFailures.length}/${blockingChecks.length} blocking checks failed\n`);
+                for (const f of blockingFailures) {
+                    process.stderr.write(`  ${f.command} exited ${f.exitCode}\n`);
+                    if (f.stderr)
+                        process.stderr.write(`  stderr: ${f.stderr.slice(0, 500)}\n`);
+                }
+                if (advisoryFailCount > 0) {
+                    process.stderr.write(`verification-gate: ${advisoryFailCount} additional advisory (non-blocking) failure(s)\n`);
+                }
+            }
+        }
+        // Log blocking runtime errors
+        if (result.runtimeErrors?.some(e => e.blocking)) {
+            const blockingErrors = result.runtimeErrors.filter(e => e.blocking);
+            process.stderr.write(`verification-gate: ${blockingErrors.length} blocking runtime error(s) detected\n`);
+            for (const err of blockingErrors) {
+                process.stderr.write(`  [${err.source}] ${err.severity}: ${err.message.slice(0, 200)}\n`);
+            }
+        }
+        // Write verification evidence JSON
+        const attempt = s.verificationRetryCount.get(s.currentUnit.id) ?? 0;
+        if (mid && sid && tid) {
+            try {
+                const sDir = resolveSlicePath(s.basePath, mid, sid);
+                if (sDir) {
+                    const tasksDir = join(sDir, "tasks");
+                    if (result.passed) {
+                        writeVerificationJSON(result, tasksDir, tid, s.currentUnit.id);
+                    }
+                    else {
+                        const nextAttempt = attempt + 1;
+                        writeVerificationJSON(result, tasksDir, tid, s.currentUnit.id, nextAttempt, maxRetries);
+                    }
+                }
+            }
+            catch (evidenceErr) {
+                process.stderr.write(`verification-evidence: write error — ${evidenceErr.message}\n`);
+            }
+        }
+        // ── Auto-fix retry logic ──
+        if (result.passed) {
+            s.verificationRetryCount.delete(s.currentUnit.id);
+            s.pendingVerificationRetry = null;
+            return "continue";
+        }
+        // Check if all failures are infra errors (ETIMEDOUT, ENOENT, etc.).
+        // Infra errors are transient OS-level problems the agent cannot fix —
+        // retrying the entire task is wasteful and creates phantom failures.
+        const failedChecks = result.checks.filter(c => c.exitCode !== 0);
+        const allInfraErrors = failedChecks.length > 0 && failedChecks.every(c => c.infraError === true);
+        if (allInfraErrors) {
+            const infraNames = failedChecks.map(f => f.command).join(", ");
+            ctx.ui.notify(`Verification gate: infra error (${infraNames}) — skipping retry, not a code issue`, "warning");
+            process.stderr.write(`verification-gate: all ${failedChecks.length} failure(s) are infra errors — treating as transient, no retry\n`);
+            s.verificationRetryCount.delete(s.currentUnit.id);
+            s.pendingVerificationRetry = null;
+            return "continue";
+        }
+        if (result.discoverySource === "package-json") {
+            // Auto-discovered checks from package.json may fail on pre-existing errors
+            // that the current task didn't introduce. Don't trigger the retry loop —
+            // log a warning and let the task proceed (#1186).
+            process.stderr.write(`verification-gate: auto-discovered checks failed (source: package-json) — treating as advisory, not blocking\n`);
+            ctx.ui.notify(`Verification: auto-discovered checks failed (pre-existing errors likely). Continuing without retry.`, "warning");
+            s.verificationRetryCount.delete(s.currentUnit.id);
+            s.pendingVerificationRetry = null;
+            return "continue";
+        }
+        if (autoFixEnabled && attempt + 1 <= maxRetries) {
+            const nextAttempt = attempt + 1;
+            s.verificationRetryCount.set(s.currentUnit.id, nextAttempt);
+            s.pendingVerificationRetry = {
+                unitId: s.currentUnit.id,
+                failureContext: formatFailureContext(result),
+                attempt: nextAttempt,
+            };
+            ctx.ui.notify(`Verification failed — auto-fix attempt ${nextAttempt}/${maxRetries}`, "warning");
+            s.completedKeySet.delete(completionKey);
+            removePersistedKey(s.basePath, completionKey);
+            // Dispatch retry immediately
+            try {
+                await dispatchNextUnit(ctx, pi);
+            }
+            catch (retryDispatchErr) {
+                const msg = getErrorMessage(retryDispatchErr);
+                ctx.ui.notify(`Verification retry dispatch error: ${msg}`, "error");
+                startDispatchGapWatchdog(ctx, pi);
+            }
+            return "retry";
+        }
+        else {
+            // Gate failed, retries exhausted
+            const exhaustedAttempt = attempt + 1;
+            s.verificationRetryCount.delete(s.currentUnit.id);
+            s.pendingVerificationRetry = null;
+            ctx.ui.notify(`Verification gate FAILED after ${exhaustedAttempt > maxRetries ? exhaustedAttempt - 1 : exhaustedAttempt} retries — pausing for human review`, "error");
+            await pauseAuto(ctx, pi);
+            return "pause";
+        }
+    }
+    catch (err) {
+        // Gate errors are non-fatal
+        process.stderr.write(`verification-gate: error — ${err.message}\n`);
+        return "continue";
+    }
+}