@mjasnikovs/pi-task 0.17.0 → 0.17.2

package/dist/task/gate-deps.js

@@ -0,0 +1,221 @@
+/**
+ * gate-deps — builds the concrete {@link GateDeps} (verify / enforce / recommend /
+ * commit / revert) that the post-implementation gate sequence drives.
+ *
+ * Lifted out of /task-auto's `defaultDeps` so both /task-auto and the single /task
+ * command construct the gate children identically. `runTask` (the AUTOFIX re-run) is
+ * INJECTED rather than imported, so this module never imports the orchestrators —
+ * keeping the dependency graph acyclic (the orchestrators import this).
+ *
+ * The gate children — verify, the post-FAIL recommend, and enforce — are read-only
+ * (or read,edit for enforce) passes of the same local model that must run to
+ * completion: unguarded (no wall-clock timeout, exact-match loop guard only,
+ * path-revisit disabled because re-running the same check IS the job), each with a
+ * status widget and a per-gate debug log under .pi-tasks/.
+ */
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+import { tasksDir, readTaskFile } from './task-io.js';
+import { gitCommitAll, gitDropLastCommit } from './auto-commit.js';
+import { runGuidelineEnforcement, classifyEnforceChildFailure } from './enforce-guidelines.js';
+import { runWorkVerification, extractSpecForVerification } from './verify-work.js';
+import { researchResolution } from './verify-resolution.js';
+import { runWorker } from '../workers/pi-worker-core.js';
+import { formatLoopHint } from './child-runner.js';
+import { getConfig } from '../config/config.js';
+import { startAutoLoader } from './widget.js';
+import { resolveContextUsage } from './context-usage.js';
+/**
+ * Build the gate deps for one command run. `runTask` is the orchestrator's
+ * implementation re-runner, injected by the caller. The returned object also drives
+ * a shared status widget: `getLastLine`/`getContextUsage` expose the children's
+ * latest stream line and context usage so the caller can mirror them in its own
+ * loader if it wants (the gate closures already render their own loaders).
+ */
+export function buildGateDeps(params) {
+    const { signal, parentContextWindow, runTask } = params;
+    // Captured by each gate child's loader so the widget mirrors the child's latest
+    // output line and context usage, exactly like the single-task phase widget.
+    let lastLine;
+    let contextUsage;
+    // Shared runner for the per-task GATE children (verify + post-FAIL recommend).
+    // Both are read-only passes of the same local model that must run to completion:
+    // unguarded (no wall-clock timeout, exact-match loop guard only, path-revisit
+    // disabled because re-running the same check is the job), with a status widget
+    // and a per-gate debug log. Returns the closure runWorkVerification /
+    // researchResolution expect as `runChild`.
+    const makeGateChild = (gateCtx, cwd2, taskTitle, kind, logFile) => async (tools, prompt, sig) => {
+        lastLine = undefined;
+        contextUsage = undefined;
+        const startedAt = Date.now();
+        const logPath = path.join(tasksDir(cwd2), logFile);
+        const log = (msg) => {
+            void fsp.appendFile(logPath, `${new Date().toISOString()} ${msg}\n`).catch(() => { });
+        };
+        log(`=== ${kind} start: ${taskTitle} ===`);
+        const stopLoader = startAutoLoader(gateCtx, () => ({
+            title: taskTitle,
+            kind,
+            step: kind,
+            stepNum: 1,
+            stepTotal: 1,
+            startedAt,
+            lastLine,
+            contextUsage
+        }));
+        try {
+            const r = await runWorker({
+                prompt,
+                cwd: cwd2,
+                signal: sig,
+                tools,
+                timeoutMs: 0,
+                loop: { pathThreshold: Number.POSITIVE_INFINITY },
+                onLine: line => {
+                    lastLine = line;
+                    log(line);
+                },
+                onContextUsage: snapshot => {
+                    contextUsage = resolveContextUsage(snapshot, contextUsage, parentContextWindow);
+                }
+            });
+            if (r.loopHit) {
+                log(`=== ${kind} LOOP WARNING — ${formatLoopHint(r.loopHit)} ===`);
+                gateCtx.ui.notify(`${taskTitle}: ${kind} worker looped past the nudges — continuing (not blocked).`, 'warning');
+            }
+            const failure = classifyEnforceChildFailure(r);
+            log(failure ? `=== ${kind} end: FAIL — ${failure} ===` : `=== ${kind} end: ok ===`);
+            if (failure)
+                throw new Error(failure);
+            return r.text;
+        }
+        finally {
+            stopLoader();
+        }
+    };
+    return {
+        runTask,
+        commit: (cwd2, message) => getConfig().autoCommit ?
+            gitCommitAll(cwd2, message, signal)
+            : Promise.resolve({ committed: false, reason: 'auto-commit disabled' }),
+        revert: cwd2 => gitDropLastCommit(cwd2, signal),
+        enforce: (enforceCtx, cwd2, taskTitle, mode) => {
+            if (!getConfig().enforceGuidelines) {
+                return Promise.resolve({ ok: true, reason: 'disabled' });
+            }
+            return runGuidelineEnforcement({
+                cwd: cwd2,
+                signal,
+                mode,
+                // Run the worker child UNGUARDED: no loop detector, no wall-clock
+                // timeout. This pass reworks files in place until every violation is
+                // fixed and legitimately reads/edits the same file many times — the
+                // research-worker guards mislabel that as a runaway and kill good work
+                // (proven on mx5 TASK_0002). classifyEnforceChildFailure still blocks
+                // on a real failure (non-zero exit, leaked tool call) or a user cancel.
+                runChild: async (tools, prompt, sig) => {
+                    lastLine = undefined;
+                    contextUsage = undefined;
+                    const startedAt = Date.now();
+                    // Per-pass debug log; the enforce child is otherwise unobservable.
+                    const enforceLogPath = path.join(tasksDir(cwd2), 'enforce-debug.log');
+                    const logEnforce = (msg) => {
+                        void fsp
+                            .appendFile(enforceLogPath, `${new Date().toISOString()} ${msg}\n`)
+                            .catch(() => { });
+                    };
+                    logEnforce(`=== enforce start: ${taskTitle} ===`);
+                    const stopLoader = startAutoLoader(enforceCtx, () => ({
+                        title: taskTitle,
+                        kind: 'enforce',
+                        step: 'guidelines',
+                        stepNum: 1,
+                        stepTotal: 1,
+                        startedAt,
+                        lastLine,
+                        contextUsage
+                    }));
+                    try {
+                        const r = await runWorker({
+                            prompt,
+                            cwd: cwd2,
+                            signal: sig,
+                            tools,
+                            timeoutMs: 0, // no wall-clock timeout — run to completion
+                            // Exact-match loop guard only: pathThreshold Infinity
+                            // disables the path-revisit heuristic, so revisiting one
+                            // file (which IS this pass's job) never trips — only a
+                            // literally-identical call repeated past threshold does.
+                            loop: { pathThreshold: Number.POSITIVE_INFINITY },
+                            onLine: line => {
+                                lastLine = line;
+                                logEnforce(line);
+                            },
+                            onContextUsage: snapshot => {
+                                contextUsage = resolveContextUsage(snapshot, contextUsage, parentContextWindow);
+                            }
+                        });
+                        // A loop that survived the restart-with-hint nudges is a
+                        // warning, not a failure: log it and tell the user, but let the
+                        // verdict gate be the only thing that can block.
+                        if (r.loopHit) {
+                            logEnforce(`=== enforce LOOP WARNING — ${formatLoopHint(r.loopHit)} ===`);
+                            enforceCtx.ui.notify(`${taskTitle}: enforce worker looped past the nudges — continuing (not blocked).`, 'warning');
+                        }
+                        const failure = classifyEnforceChildFailure(r);
+                        logEnforce(failure ?
+                            `=== enforce end: FAIL — ${failure} ===`
+                            : '=== enforce end: verdict captured ===');
+                        if (failure)
+                            throw new Error(failure);
+                        return r.text;
+                    }
+                    finally {
+                        stopLoader();
+                    }
+                }
+            });
+        },
+        verify: async (verifyCtx, cwd2, taskTitle, taskId) => {
+            if (!getConfig().verifyWork) {
+                return { ok: true, reason: 'disabled' };
+            }
+            // The spec to verify against is the composed spec committed in the task
+            // file. A task that never reached compose has no spec section —
+            // runWorkVerification treats a null spec as a no-op pass.
+            let spec;
+            try {
+                const { body } = await readTaskFile(cwd2, taskId);
+                spec = extractSpecForVerification(body);
+            }
+            catch {
+                spec = null;
+            }
+            return runWorkVerification({
+                cwd: cwd2,
+                signal,
+                spec,
+                runChild: makeGateChild(verifyCtx, cwd2, taskTitle, 'verify', 'verify-debug.log')
+            });
+        },
+        recommend: async (recCtx, cwd2, taskTitle, taskId, failReason) => {
+            // Read the same composed spec the verify gate judged against, so the
+            // recommendation reasons over the real contract (degrade to the bare title).
+            let spec;
+            try {
+                const { body } = await readTaskFile(cwd2, taskId);
+                spec = extractSpecForVerification(body) ?? taskTitle;
+            }
+            catch {
+                spec = taskTitle;
+            }
+            return researchResolution({
+                cwd: cwd2,
+                signal,
+                spec,
+                failReason,
+                runChild: makeGateChild(recCtx, cwd2, taskTitle, 'recommend', 'verify-debug.log')
+            });
+        }
+    };
+}

package/dist/task/orchestrator.d.ts

@@ -17,6 +17,8 @@
  */
 import type { ExtensionAPI, ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
 import { type WidgetState } from './widget.js';
+import { type RunTaskFn } from './gate-deps.js';
+import { type GateDeps } from './task-gates.js';
 import type { SpawnFn } from '../shared/child-process.js';
 /** Encapsulates the full lifecycle of a single pi-task run. */
 export declare class TaskRunner {
@@ -216,4 +218,23 @@ export declare function resumeAcrossCompactions(ctx: SteerCtx): Promise<number>;
  * front-matter state (TaskRunner.run never throws).
  */
 export declare function runSingleTask(ctx: ExtensionCommandContext, cwd: string, rawPrompt: string, opts?: RunSingleTaskOptions): Promise<RunSingleTaskResult>;
+/**
+ * The AUTOFIX re-runner injected into the gate deps: re-run a task's
+ * implementation turn, blocking until it finishes (steering across interrupts and
+ * resuming across compactions). Shared by /task and /task-auto so both gate the
+ * same way; lives here because it wraps runSingleTask (gate-deps must not import the
+ * orchestrators, to keep the dependency graph acyclic).
+ */
+export declare const gateRunTask: RunTaskFn;
+/**
+ * Run a single /task through implementation AND the shared verify + enforce gates,
+ * blocking until both finish. Used instead of the fire-and-forget handoff whenever
+ * `verify work` or `enforce guidelines` is enabled — so /task gates exactly like a
+ * /task-auto sub-task does. A terminal stop (the implementation died, or a gate
+ * paused/failed) leaves the task resumable and tells the user to /task-resume.
+ */
+export declare function runGatedTask(ctx: ExtensionCommandContext, cwd: string, raw: string, opts?: {
+    resumeId?: string;
+    deps?: GateDeps;
+}): Promise<void>;
 export declare function registerTask(pi: ExtensionAPI): void;

package/dist/task/orchestrator.js

@@ -24,8 +24,11 @@ import { normaliseTaskId, parseFrontMatter, extractSection } from './task-parser
 import { allocateTaskId, ensureTasksDir, readSection, readTaskFile, setTaskSection, taskFilePath, tasksDir, updateTaskFrontMatter, writeTaskFile } from './task-io.js';
 import { startWidget } from './widget.js';
 import { armImplWidget, disarmImplWidget, setupImplWidget } from './impl-widget.js';
-import { publishViewer, publishNotify, registerBridgeCommand, getBridge } from '../remote/bridge.js';
+import { publishViewer, publishNotify, publishLifecycleNotice, registerBridgeCommand, getBridge } from '../remote/bridge.js';
 import { pushNotify } from '../remote/push.js';
+import { getConfig } from '../config/config.js';
+import { buildGateDeps } from './gate-deps.js';
+import { runGatesForTask } from './task-gates.js';
 import { parseVerifyBlock } from './spec-validation.js';
 import { findDeliveryPhantoms, formatApiOverrideBanner } from '../workers/phantom-imports.js';
 import { titleForDisplay } from './parsers.js';
@@ -555,6 +558,121 @@ export async function runSingleTask(ctx, cwd, rawPrompt, opts = {}) {
     }
     return { taskId, ok, sessionCancelled: false, ctx: freshCtx, interrupted, reason: implError };
 }
+// ─── Gated single-task flow ────────────────────────────────────────────────────
+/**
+ * The AUTOFIX re-runner injected into the gate deps: re-run a task's
+ * implementation turn, blocking until it finishes (steering across interrupts and
+ * resuming across compactions). Shared by /task and /task-auto so both gate the
+ * same way; lives here because it wraps runSingleTask (gate-deps must not import the
+ * orchestrators, to keep the dependency graph acyclic).
+ */
+export const gateRunTask = (c, cwd, t, opts) => runSingleTask(c, cwd, t, {
+    waitForImplementation: true,
+    resumeId: opts?.resumeId,
+    onStart: opts?.onStart,
+    planContext: opts?.planContext,
+    fixInstruction: opts?.fixInstruction
+});
+/**
+ * Demote a task file to a resumable state after a gate (or its implementation)
+ * stopped short. The file is marked `completed` at spec-handoff — before the work
+ * is even verified — so a gate FAIL would otherwise leave it un-resumable
+ * (`completed` is not in RESUMABLE_STATES). Best-effort; a missing/empty id is a
+ * no-op. Mirrors how /task-auto marks the parent run `failed` so resume re-runs it.
+ */
+async function markResumable(cwd, taskId) {
+    if (!taskId)
+        return;
+    try {
+        await updateTaskFrontMatter(cwd, taskId, { state: 'failed' });
+    }
+    catch {
+        /* best-effort */
+    }
+}
+/**
+ * Run a single /task through implementation AND the shared verify + enforce gates,
+ * blocking until both finish. Used instead of the fire-and-forget handoff whenever
+ * `verify work` or `enforce guidelines` is enabled — so /task gates exactly like a
+ * /task-auto sub-task does. A terminal stop (the implementation died, or a gate
+ * paused/failed) leaves the task resumable and tells the user to /task-resume.
+ */
+export async function runGatedTask(ctx, cwd, raw, opts = {}) {
+    const abort = new AbortController();
+    const deps = opts.deps
+        ?? buildGateDeps({
+            signal: abort.signal,
+            parentContextWindow: getParentContextWindow(ctx),
+            runTask: gateRunTask
+        });
+    let active = ctx;
+    // One push + remote bubble on the terminal outcome (parity with the
+    // notifyFinish push the fire-and-forget path emits via runSingleTask).
+    const announce = (msg, level) => {
+        active.ui.notify(msg, level);
+        publishLifecycleNotice(msg, level);
+        void pushNotify('Task finished', msg, 'pi-end').catch(() => { });
+    };
+    // First implementation run (blocking).
+    const res = await deps.runTask(active, cwd, raw, { resumeId: opts.resumeId });
+    active = res.ctx ?? active;
+    const tag = res.taskId || 'Task';
+    if (res.sessionCancelled) {
+        announce(`${tag} — could not start a fresh session for /task.`, 'warning');
+        return;
+    }
+    if (res.interrupted) {
+        await markResumable(cwd, res.taskId);
+        announce(`${tag} paused — resume with /task-resume.`, 'warning');
+        return;
+    }
+    if (!res.ok) {
+        await markResumable(cwd, res.taskId);
+        const why = res.reason ? ` — ${res.reason.slice(0, 160)}` : '';
+        announce(`${tag} stopped${why} — fix and run /task-resume.`, 'error');
+        return;
+    }
+    // The composed task's own front-matter title — used in commit messages and
+    // notifies (the gate sequence has no plan title to borrow). Degrade to the id.
+    let title = tag;
+    try {
+        const { frontMatter } = await readTaskFile(cwd, res.taskId);
+        title = frontMatter.title || tag;
+    }
+    catch {
+        /* keep the id as the title */
+    }
+    const gate = await runGatesForTask(active, deps, {
+        cwd,
+        taskId: res.taskId,
+        title,
+        tag
+        // No sibling plan → no scope fence; no parent list → no check-off.
+    });
+    active = gate.ctx;
+    switch (gate.kind) {
+        case 'paused':
+            await markResumable(cwd, res.taskId);
+            announce(`${tag} paused — verification failed and you dismissed the choice; resume with /task-resume.`, 'warning');
+            return;
+        case 'session-cancelled':
+            announce(`${tag} paused — could not start a session for autofix. Run /task-resume to retry.`, 'warning');
+            return;
+        case 'interrupted':
+            await markResumable(cwd, res.taskId);
+            announce(`${tag} paused — resume with /task-resume.`, 'warning');
+            return;
+        case 'failed': {
+            await markResumable(cwd, res.taskId);
+            const why = gate.reason ? ` — ${gate.reason.slice(0, 160)}` : '';
+            announce(`${tag} stopped${why} — fix and run /task-resume.`, 'error');
+            return;
+        }
+        case 'done':
+            announce(`${tag} complete — verified.`, 'info');
+            return;
+    }
+}
 // ─── Command handlers ────────────────────────────────────────────────────────
 async function handleTask(args, ctx) {
     await ctx.waitForIdle();
@@ -565,6 +683,15 @@ async function handleTask(args, ctx) {
         ctx.ui.notify('Type your prompt after /task (use @ for file completion).', 'info');
         return;
     }
+    // When a gate is enabled, /task awaits the implementation and runs the same
+    // verify + enforce gates a /task-auto sub-task does. With both gates off
+    // (the default), /task stays fire-and-forget: hand the spec to the main
+    // conversation and return immediately, exactly as before.
+    const cfg = getConfig();
+    if (cfg.verifyWork || cfg.enforceGuidelines) {
+        await runGatedTask(ctx, cwd, raw);
+        return;
+    }
     const { sessionCancelled } = await runSingleTask(ctx, cwd, raw, { notifyFinish: true });
     if (sessionCancelled) {
         ctx.ui.notify('Could not start a fresh session for /task.', 'warning');
@@ -648,6 +775,12 @@ async function handleTaskResume(args, ctx) {
         }
         id = candidates[0].id;
     }
+    // Match /task: resume through the gates when one is enabled, else fire-and-forget.
+    const cfg = getConfig();
+    if (cfg.verifyWork || cfg.enforceGuidelines) {
+        await runGatedTask(ctx, cwd, '', { resumeId: id });
+        return;
+    }
     const { sessionCancelled } = await runSingleTask(ctx, cwd, '', { resumeId: id, notifyFinish: true });
     if (sessionCancelled) {
         ctx.ui.notify('Could not start a fresh session for /task-resume.', 'warning');

package/dist/task/task-gates.d.ts

@@ -0,0 +1,148 @@
+/**
+ * task-gates — the post-implementation GATE sequence shared by /task-auto's per-task
+ * loop and the single /task command.
+ *
+ * After a task's implementation turn settles, the same two gates run against the
+ * just-finished work:
+ *
+ *   1. VERIFY — RUN the composed spec's VERIFY block in the real workspace and
+ *      judge a PASS/FAIL. A FAIL offers the user a boxed AUTOFIX / ACCEPT / dismiss
+ *      picker (the user always decides; AUTOFIX re-runs the implementation turn and
+ *      loops back to the gate uncapped).
+ *   2. ENFORCE — hold the committed work to the project's AGENTS.md / CLAUDE.md
+ *      rules. Runs in `edit` mode (fix in place) only when the verify gate produced
+ *      a genuine clean pass to guard the edits against; otherwise `flag` mode
+ *      (read-only, report don't fix). An edit pass that regresses the verify signal
+ *      is reverted.
+ *
+ * Both gates are no-ops when their config flag is off (the injected deps return a
+ * disabled pass), so wiring this into a command is inert until the user enables
+ * `verify work` / `enforce guidelines` in /task-config.
+ *
+ * The sequence is parameterised so each caller supplies the parent-specific glue
+ * (notify prefix, the autofix scope fence, and the "mark verified" step — a parent
+ * task-list check-off for /task-auto, a no-op for /task). Terminal outcomes are
+ * returned as a discriminated GateResult; the caller turns them into its own
+ * announce + state changes (the resume command differs: /task-auto-resume vs
+ * /task-resume).
+ */
+import type { ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
+import type { RunSingleTaskResult } from './orchestrator.js';
+import type { CommitResult } from './auto-commit.js';
+import type { VerifyOutcome } from './verify-work.js';
+import type { EnforceOutcome } from './enforce-guidelines.js';
+import { type ResolutionOutcome, type ResolutionChoice } from './verify-resolution.js';
+/**
+ * The deps the gate sequence drives. A superset of these is built once per command
+ * by buildGateDeps; AutoDeps extends this with the planning-only `runChild`. Every
+ * gate dep is injected so the sequence is testable without spawning pi, and so the
+ * optional gates (verify/enforce/recommend/revert) can be absent in tests or when
+ * their config flag is off — the sequence then treats them as a pass / no-op.
+ */
+export interface GateDeps {
+    /**
+     * Re-run a task's implementation turn (AUTOFIX after a verify FAIL). Resumes
+     * the same inner task id, optionally fenced by a plan scope and led by a
+     * RE-ATTEMPT banner naming the verification failure.
+     */
+    runTask: (ctx: ExtensionCommandContext, cwd: string, title: string, opts?: {
+        resumeId?: string;
+        onStart?: (taskId: string) => void | Promise<void>;
+        planContext?: string;
+        fixInstruction?: string;
+    }) => Promise<RunSingleTaskResult>;
+    /** Snapshot the working tree into one commit after a task passes. */
+    commit: (cwd: string, message: string) => Promise<CommitResult>;
+    /**
+     * Verify the just-finished task's work by RUNNING its composed spec's VERIFY
+     * block in the real workspace, then reporting a PASS/FAIL verdict. Absent in
+     * tests or when `verify work` is off → the sequence treats it as a pass.
+     */
+    verify?: (ctx: ExtensionCommandContext, cwd: string, taskTitle: string, taskId: string) => Promise<VerifyOutcome>;
+    /**
+     * Hold the committed work to AGENTS.md / CLAUDE.md. `edit` (fix in place) only
+     * with a clean verify signal to guard against; otherwise `flag` (report only).
+     * Absent in tests or when `enforce guidelines` is off → skipped.
+     */
+    enforce?: (ctx: ExtensionCommandContext, cwd: string, taskTitle: string, mode: 'edit' | 'flag') => Promise<EnforceOutcome>;
+    /**
+     * After a verify FAIL, research whether to recommend AUTOFIX or ACCEPT — only
+     * sets which card the picker tints RECOMMENDED; the user always decides. Absent
+     * → the picker defaults the recommendation to AUTOFIX.
+     */
+    recommend?: (ctx: ExtensionCommandContext, cwd: string, taskTitle: string, taskId: string, failReason: string) => Promise<ResolutionOutcome>;
+    /**
+     * Discard the working-tree edits an `edit` enforcement pass made, restoring the
+     * verified task commit (the differential guard's revert). Absent → the guard
+     * skips the revert and warns.
+     */
+    revert?: (cwd: string) => Promise<void>;
+}
+/** Inputs the sequence needs that vary per caller. */
+export interface GateParams {
+    cwd: string;
+    /** The inner task id whose spec is verified and whose work is committed. */
+    taskId: string;
+    /** The task title — used in commit messages and user-facing notifies. */
+    title: string;
+    /** Prefix for in-progress notifies (the parent /task-auto id, or the /task id). */
+    tag: string;
+    /** Scope fence forwarded to an AUTOFIX re-run's refine (siblings for /task-auto;
+     *  undefined for a bare /task). */
+    planContext?: string;
+    /** Runs after the verify gate passes/accepts and BEFORE the work is committed —
+     *  the parent task-list check-off for /task-auto, omitted for /task. */
+    onVerified?: () => void | Promise<void>;
+}
+/**
+ * Why the gate sequence stopped. `done` means the work verified (or was accepted),
+ * was checked off + committed, and enforcement ran — the caller proceeds. The other
+ * kinds are terminal: the caller announces them (with its own resume command) and
+ * stops. `ctx` is always the live (possibly session-replaced) context the caller
+ * must adopt.
+ */
+export type GateResult = {
+    kind: 'done';
+    ctx: ExtensionCommandContext;
+}
+/** User dismissed the verify-FAIL picker — pause, leave the work unblessed. */
+ | {
+    kind: 'paused';
+    ctx: ExtensionCommandContext;
+    reason: string;
+}
+/** An AUTOFIX re-run could not start a fresh session. */
+ | {
+    kind: 'session-cancelled';
+    ctx: ExtensionCommandContext;
+}
+/** An AUTOFIX re-run was interrupted (ESC) and the user declined to steer. */
+ | {
+    kind: 'interrupted';
+    ctx: ExtensionCommandContext;
+}
+/** An AUTOFIX re-run's implementation itself failed. */
+ | {
+    kind: 'failed';
+    ctx: ExtensionCommandContext;
+    reason?: string;
+};
+/**
+ * Show the boxed two-choice picker after a verify FAIL and return what the user
+ * decided. The model-recommended card is placed first so the renderer tints it
+ * green; the user ALWAYS makes the final call (there is no auto-pick). Mirrors the
+ * clarify/grill dialog: the same SessionUI.ask races the local boxed picker against
+ * a remote answer, with the two actions also surfaced as remote buttons.
+ */
+export declare function askVerifyResolution(ctx: ExtensionCommandContext, title: string, failReason: string, rec: ResolutionOutcome): Promise<ResolutionChoice>;
+/**
+ * Run the verify + enforce gates against a task's just-finished implementation.
+ *
+ * Lifted verbatim from /task-auto's per-task loop so the two commands gate
+ * identically. Returns a GateResult; `done` means the caller should proceed (the
+ * work is verified-or-accepted, checked off, committed, and enforced), every other
+ * kind is a terminal stop the caller announces. Never throws for a gate outcome —
+ * only a user cancel inside a gate child propagates (handled by the caller's
+ * USER_CANCELLED path).
+ */
+export declare function runGatesForTask(ctxIn: ExtensionCommandContext, deps: GateDeps, p: GateParams): Promise<GateResult>;