@mjasnikovs/pi-task 0.18.28 → 0.18.30

package/dist/config/config.d.ts

@@ -61,6 +61,21 @@ export interface PiTaskConfig {
      * a true hang doesn't cost half an hour of dead time.
      */
     requestTimeoutMs: number;
+    /**
+     * UNATTENDED AUTO-PICK (see task/yolo.ts): wherever pi-task would stop and ask,
+     * take the option it already marks RECOMMENDED, stamp the artifact `(YOLO)` so
+     * an audit can tell a machine decided, and never notify. Lets a local model run
+     * a throwaway/test project end to end with nobody watching.
+     *
+     * Decided PER SITE, before the prompt is built — so the lone prompt notification
+     * (SessionUI.ask) is suppressed structurally, and the existing unattended budgets
+     * (MAX_AUTO_AUTOFIX, MAX_FINAL_GATE_AUTOFIX) still bound the loops they were
+     * written to bound. An auto-pick may cost time, never work: a question with no
+     * recommendation, or one the anti-synthesis guard demoted, is SKIPPED, not
+     * invented.
+     * DEFAULT OFF — this is never the behaviour of a normal, watched run.
+     */
+    yoloMode: boolean;
 }
 /**
  * The command-watchdog timeout choices offered by /task-config, newest-first in

package/dist/config/config.js

@@ -38,7 +38,9 @@ const DEFAULTS = {
     researchCache: true,
     searchProvider: 'exa',
     extensionWhitelist: [],
-    requestTimeoutMs: DEFAULT_REQUEST_TIMEOUT_MS
+    requestTimeoutMs: DEFAULT_REQUEST_TIMEOUT_MS,
+    // OFF: auto-answering is for unattended throwaway runs only.
+    yoloMode: false
 };
 /**
  * A hand-edited config can hold anything; keep only string entries so a stray
@@ -67,6 +69,11 @@ if (!G.loaded) {
             delete parsed.searchProvider;
         parsed.extensionWhitelist = sanitizeExtensionWhitelist(parsed.extensionWhitelist);
         parsed.requestTimeoutMs = sanitizeRequestTimeoutMs(parsed.requestTimeoutMs);
+        // A hand-edited `"yoloMode": "false"` is a truthy string — it must not
+        // silently switch a watched run into unattended auto-pick. Only a real
+        // boolean counts; anything else falls back to the OFF default.
+        if (typeof parsed.yoloMode !== 'boolean')
+            delete parsed.yoloMode;
         G.config = { ...DEFAULTS, ...parsed };
     }
     catch {

package/dist/config/register.js

@@ -107,6 +107,16 @@ const ITEMS = [
             + 'unbounded',
         // Display human labels; the stored config value stays the ms number.
         values: COMMAND_TIMEOUT_OPTIONS.map(o => o.label)
+    },
+    {
+        id: 'yoloMode',
+        label: 'yolo mode',
+        description: 'UNATTENDED: auto-answer every question with the option pi already recommends, '
+            + 'and show no prompts at all — clarify/grill answers, the verify-FAIL picker '
+            + '(auto-ACCEPT, recorded as a yolo debt), and the final-gate picker (autofix '
+            + 'while the budget lasts, then leave the run FAILED). Every auto-pick is stamped '
+            + '(YOLO) in the task file and debt ledger. For THROWAWAY/TEST projects you are '
+            + 'not watching — a real run should decide these itself'
     }
 ];
 /** Human label for the stored command-timeout ms (falls back to the raw ms). */

package/dist/shared/command-watchdog.d.ts

@@ -43,6 +43,14 @@ export interface WatchdogDeps {
     /** Invoked when a command overruns: each adapter aborts/kills here. */
     onFire: (toolCallId: string, toolName: string, timeoutMs: number) => void;
 }
+/**
+ * Stable substring of {@link reminderMessage}, used by the steer loop
+ * (orchestrator steerUntilDone) to recognise the watchdog's follow-up turn in
+ * the session entries — the artifact that distinguishes a watchdog abort from a
+ * human ESC. Interpolated into the message so the detector and the text cannot
+ * drift apart.
+ */
+export declare const WATCHDOG_CANCEL_MARKER = "was automatically cancelled \u2014 it looked stuck.";
 /**
  * MAIN-SESSION reminder, delivered as a follow-up turn after ctx.abort() has
  * cancelled the offending tool call. The session is still alive and remembers

package/dist/shared/command-watchdog.js

@@ -44,6 +44,14 @@ function correction() {
         + `timeout — set the bash tool's \`timeout\` parameter (in seconds) so it cannot hang `
         + `again — or break it into smaller steps. Do NOT simply retry the same unbounded command.`);
 }
+/**
+ * Stable substring of {@link reminderMessage}, used by the steer loop
+ * (orchestrator steerUntilDone) to recognise the watchdog's follow-up turn in
+ * the session entries — the artifact that distinguishes a watchdog abort from a
+ * human ESC. Interpolated into the message so the detector and the text cannot
+ * drift apart.
+ */
+export const WATCHDOG_CANCEL_MARKER = 'was automatically cancelled — it looked stuck.';
 /**
  * MAIN-SESSION reminder, delivered as a follow-up turn after ctx.abort() has
  * cancelled the offending tool call. The session is still alive and remembers
@@ -51,7 +59,7 @@ function correction() {
  */
 export function reminderMessage(toolName, timeoutMs) {
     return (`[SYSTEM] Your \`${toolName}\` call ran longer than ${minutes(timeoutMs)} `
-        + `and was automatically cancelled — it looked stuck. `
+        + `and ${WATCHDOG_CANCEL_MARKER} `
         + correction());
 }
 /**

package/dist/task/accept-debt.d.ts

@@ -11,6 +11,11 @@
  *     created files need a tsconfig registration every spec forbids). Cross-task
  *     contradiction: no unattended re-run can converge, so the gate loop records the
  *     defect and routes to the human picker instead of burning AUTOFIX rounds.
+ *   - 'yolo-accepted'   — YOLO MODE (unattended auto-pick, see yolo.ts) took the
+ *     verify-FAIL picker's terminal option with nobody watching. It is NOT the
+ *     'accepted' class and must never collapse into it: 'accepted' asserts a HUMAN
+ *     weighed this failing artifact and blessed it, which is exactly the assurance
+ *     an auto-pick cannot give. Same re-check treatment, honest provenance.
  *   - 'cross-task-deletion' — the task's work DELETED a sibling task's committed
  *     deliverable (mx5 run 12 PROMPT 2: a fix child deleted TASK_0020's playwright ct
  *     files to green a lint) and the user ACCEPTed the verify-FAIL anyway, so the
@@ -18,7 +23,7 @@
  *     resolved iff the named file is back in the tree (a later task restored it),
  *     otherwise surfaced.
  */
-export type DebtOrigin = 'accepted' | 'enforce-revert' | 'frozen-blocked' | 'cross-task-deletion';
+export type DebtOrigin = 'accepted' | 'enforce-revert' | 'frozen-blocked' | 'cross-task-deletion' | 'yolo-accepted';
 /** One recorded defect: the task, why its VERIFY failed, and how it was recorded. */
 export interface AcceptDebt {
     taskId: string;
@@ -77,6 +82,13 @@ export declare function recordCrossTaskDeletionDebt(cwd: string, taskId: string,
     path: string;
     owner: string;
 }): Promise<void>;
+/**
+ * Record a YOLO-ACCEPTED debt: unattended auto-pick took the verify-FAIL picker's
+ * ACCEPT branch because there was nobody to ask (yolo.ts). Its own origin — and
+ * therefore its own line in the final gate's surfaced report — so a later audit
+ * reading only the artifacts can never read it as "a human decided this".
+ */
+export declare function recordYoloAcceptDebt(cwd: string, taskId: string, reason: string): Promise<void>;
 /**
  * The deleted path a cross-task-deletion debt names (the fixed shape
  * recordCrossTaskDeletionDebt writes). Null on any other reason text — an

package/dist/task/accept-debt.js

@@ -76,7 +76,8 @@ export function parseAcceptDebts(raw) {
             reason: parts[1].trim(),
             ...((origin === 'enforce-revert'
                 || origin === 'frozen-blocked'
-                || origin === 'cross-task-deletion') ?
+                || origin === 'cross-task-deletion'
+                || origin === 'yolo-accepted') ?
                 { origin: origin }
                 : {})
         });
@@ -173,6 +174,19 @@ export async function recordCrossTaskDeletionDebt(cwd, taskId, deletion) {
         origin: 'cross-task-deletion'
     });
 }
+/**
+ * Record a YOLO-ACCEPTED debt: unattended auto-pick took the verify-FAIL picker's
+ * ACCEPT branch because there was nobody to ask (yolo.ts). Its own origin — and
+ * therefore its own line in the final gate's surfaced report — so a later audit
+ * reading only the artifacts can never read it as "a human decided this".
+ */
+export async function recordYoloAcceptDebt(cwd, taskId, reason) {
+    await appendDebt(cwd, {
+        taskId: taskId.trim(),
+        reason: normaliseReason(reason),
+        origin: 'yolo-accepted'
+    });
+}
 /**
  * The deleted path a cross-task-deletion debt names (the fixed shape
  * recordCrossTaskDeletionDebt writes). Null on any other reason text — an
@@ -324,5 +338,8 @@ export function describeDebt(d) {
     if (d.origin === 'cross-task-deletion') {
         return "a sibling task's committed deliverable was DELETED by this task's work and the deletion was accepted (still missing from the tree)";
     }
+    if (d.origin === 'yolo-accepted') {
+        return 'auto-ACCEPTED by YOLO mode despite verify-FAIL (unattended — no human weighed this)';
+    }
     return 'accepted despite verify-FAIL';
 }

package/dist/task/auto-orchestrator.js

@@ -31,6 +31,7 @@ import { runFinalIntegrationGate } from './final-gate.js';
 import { describeDebt } from './accept-debt.js';
 import { classifyFinalGateAnswer, MAX_FINAL_GATE_AUTOFIX, FINAL_LEAVE_LABEL, FINAL_LEAVE_VALUE, FINAL_ACCEPT_LABEL, FINAL_ACCEPT_VALUE, FINAL_AUTOFIX_LABEL, FINAL_AUTOFIX_VALUE } from './final-gate-fix.js';
 import { getConfig } from '../config/config.js';
+import { isYoloMode, yoloPickAnswer, yoloFinalGateChoice, YOLO_STAMP } from './yolo.js';
 import { configureResearchRun } from '../workers/research-cache.js';
 import { CONTRACT_EXTRACT_PROMPT, parseContractLines, keepGroundedContracts, appendContracts } from './contracts.js';
 import { reconcileTitleSources } from './decompose-fidelity.js';
@@ -409,6 +410,20 @@ export async function planAuto(ctx, cwd, feature, deps) {
         // the recommended one tinted green; an open question shows the bare text
         // prompt. No verbose "Recommended:" / "press Enter to accept" scaffolding.
         const twoOption = plainSuggested !== undefined && plainAlt !== undefined;
+        // YOLO: take the recommended option (index 0 / the green card) without ever
+        // building the prompt. Clarify has no anti-synthesis channel — it runs before
+        // any research — so the only step-aside here is a question that carries no
+        // recommendation to take; that one is skipped rather than guessed.
+        const yolo = yoloPickAnswer(isYoloMode(), {
+            ...(plainSuggested !== undefined && { suggested: plainSuggested }),
+            ...(plainAlt !== undefined && { alt: plainAlt })
+        });
+        if (yolo !== null) {
+            const auto = yolo.kind === 'answer' ? yolo.answer : `(skipped — ${yolo.note})`;
+            answers.push(`Q${answers.length + 1}: ${plainQ}\n`
+                + `A${answers.length + 1}: ${auto} ${YOLO_STAMP}`);
+            continue;
+        }
         const options = twoOption ?
             [
                 {
@@ -1005,21 +1020,41 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                             + (fixAttempts > 0 ?
                                 `\n\nAutofix attempts so far: ${fixAttempts}/${MAX_FINAL_GATE_AUTOFIX}.`
                                 : '');
-                        const answer = await new SessionUI(active).ask({
-                            localTitle: 'Final integration gate failed — how should pi proceed?',
-                            displayQuestion: question,
-                            question,
-                            recommended: FINAL_LEAVE_LABEL,
-                            recommended2: canAutofix ? FINAL_AUTOFIX_LABEL : FINAL_ACCEPT_LABEL,
-                            allowSkip: false,
-                            options: [
-                                { label: FINAL_LEAVE_LABEL, value: FINAL_LEAVE_VALUE },
-                                ...(canAutofix ?
-                                    [{ label: FINAL_AUTOFIX_LABEL, value: FINAL_AUTOFIX_VALUE }]
-                                    : []),
-                                { label: FINAL_ACCEPT_LABEL, value: FINAL_ACCEPT_VALUE }
-                            ]
-                        });
+                        // YOLO: keep autofixing WHILE the card is still offered — the
+                        // loop withdraws it after MAX_FINAL_GATE_AUTOFIX, so the cap
+                        // that bounds a non-converging fix pass still bounds this —
+                        // then LEAVE the run failed. Never 'accept': an unattended run
+                        // that could not green the whole-repo gate has not produced a
+                        // working project, and mx5 run 13 shows what an accepted FAIL
+                        // looks like afterwards (a shipped app that 404s at `/`).
+                        const yoloFinal = yoloFinalGateChoice(isYoloMode(), canAutofix);
+                        if (yoloFinal !== null) {
+                            await recGate(`final-gate: auto-chose ${yoloFinal.action.toUpperCase()} ${YOLO_STAMP}`);
+                        }
+                        const answer = yoloFinal !== null ?
+                            yoloFinal.action === 'autofix' ?
+                                FINAL_AUTOFIX_VALUE
+                                : FINAL_LEAVE_VALUE
+                            : await new SessionUI(active).ask({
+                                localTitle: 'Final integration gate failed — how should pi proceed?',
+                                displayQuestion: question,
+                                question,
+                                recommended: FINAL_LEAVE_LABEL,
+                                recommended2: canAutofix ? FINAL_AUTOFIX_LABEL : FINAL_ACCEPT_LABEL,
+                                allowSkip: false,
+                                options: [
+                                    { label: FINAL_LEAVE_LABEL, value: FINAL_LEAVE_VALUE },
+                                    ...(canAutofix ?
+                                        [
+                                            {
+                                                label: FINAL_AUTOFIX_LABEL,
+                                                value: FINAL_AUTOFIX_VALUE
+                                            }
+                                        ]
+                                        : []),
+                                    { label: FINAL_ACCEPT_LABEL, value: FINAL_ACCEPT_VALUE }
+                                ]
+                            });
                         const choice = classifyFinalGateAnswer(answer);
                         if (choice.action === 'accept') {
                             await recGate('final-gate: FAIL accepted by user');
@@ -1064,7 +1099,9 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                         }
                         // Leave failed — the dismissal default, unchanged from the
                         // two-option picker (an unavailable autofix demotes here too).
-                        await recGate('final-gate: left failed (user)');
+                        await recGate(yoloFinal !== null ?
+                            `final-gate: left failed — autofix budget spent, nobody to ask ${YOLO_STAMP}`
+                            : 'final-gate: left failed (user)');
                         await updateTaskFrontMatter(cwd, id, { state: 'failed' });
                         announceDone(active, `${id} finished all tasks but FAILED the final integration gate — ${fin.reason.slice(0, 200)} — fix and /task-auto-resume (the gate re-runs).`, 'error');
                         return;

package/dist/task/command-watchdog.d.ts

@@ -24,7 +24,11 @@ import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
  * them; their equivalent guard lives in runWorker (workers/pi-worker-core.ts)
  * and shares the same machine from shared/command-watchdog.ts.
  */
-export { CommandWatchdog, commandTimeoutHint, realTimerDeps, reminderMessage, type TimerHandle, type WatchdogDeps } from '../shared/command-watchdog.js';
+export { CommandWatchdog, commandTimeoutHint, realTimerDeps, reminderMessage, WATCHDOG_CANCEL_MARKER, type TimerHandle, type WatchdogDeps } from '../shared/command-watchdog.js';
+/** @internal Set by onFire when it aborts a turn. Exported for the adapter and tests. */
+export declare function noteWatchdogAbort(): void;
+/** True exactly once per watchdog abort; clears the flag. */
+export declare function consumeWatchdogAbort(): boolean;
 /**
  * Wire the watchdog into the main session. Only ever active in the host session
  * (children run `--no-extensions`), which is exactly where the observed hangs

package/dist/task/command-watchdog.js

@@ -27,7 +27,31 @@ import { CommandWatchdog, realTimerDeps, reminderMessage } from '../shared/comma
  */
 // Re-exported so existing importers (and the machine's own tests) keep their
 // entry point while the implementation lives in shared/.
-export { CommandWatchdog, commandTimeoutHint, realTimerDeps, reminderMessage } from '../shared/command-watchdog.js';
+export { CommandWatchdog, commandTimeoutHint, realTimerDeps, reminderMessage, WATCHDOG_CANCEL_MARKER } from '../shared/command-watchdog.js';
+/**
+ * One-shot marker: the most recent turn abort was issued BY THE WATCHDOG, not by
+ * a human ESC. Both end the assistant turn with stopReason 'aborted' — the only
+ * signal steerUntilDone's wasInterrupted() can read — so without this flag the
+ * steer loop can win the race against the watchdog's queued follow-up turn and
+ * show a steering prompt to an empty room (wedging an unattended run).
+ *
+ * Set synchronously in onFire BEFORE ctx.abort(), so it is observable by the
+ * time any waitForIdle resolves; consumed (cleared) by the first reader. A stale
+ * flag (the aborted turn wasn't one the steer loop was watching) only costs the
+ * consumer a bounded wait before it falls back to prompting — it can never
+ * permanently suppress a human's steer prompt.
+ */
+let watchdogAbortPending = false;
+/** @internal Set by onFire when it aborts a turn. Exported for the adapter and tests. */
+export function noteWatchdogAbort() {
+    watchdogAbortPending = true;
+}
+/** True exactly once per watchdog abort; clears the flag. */
+export function consumeWatchdogAbort() {
+    const was = watchdogAbortPending;
+    watchdogAbortPending = false;
+    return was;
+}
 /**
  * Wire the watchdog into the main session. Only ever active in the host session
  * (children run `--no-extensions`), which is exactly where the observed hangs
@@ -46,8 +70,12 @@ export function registerCommandWatchdog(pi) {
             ctxByCall.delete(toolCallId);
             // Cancel the stuck command (kills the tool's whole process tree via
             // the turn's AbortSignal), then start a fresh turn telling the model
-            // to bound its next attempt.
-            ctx?.abort();
+            // to bound its next attempt. The flag must precede the abort so the
+            // steer loop can never observe the 'aborted' turn before the flag.
+            if (ctx) {
+                noteWatchdogAbort();
+                ctx.abort();
+            }
             pi.sendUserMessage(reminderMessage(toolName, timeoutMs), { deliverAs: 'followUp' });
         }
     });

package/dist/task/gate-deps.js

@@ -21,7 +21,7 @@ import { runGuidelineEnforcement, classifyEnforceChildFailure } from './enforce-
 import { runWorkVerification, extractSpecForVerification } from './verify-work.js';
 import { readEnvNotes, appendEnvNotes } from './env-notes.js';
 import { readContracts } from './contracts.js';
-import { recordAcceptDebt, recordEnforceRevertDebt, recordFrozenBlockedDebt, recordCrossTaskDeletionDebt } from './accept-debt.js';
+import { recordAcceptDebt, recordEnforceRevertDebt, recordFrozenBlockedDebt, recordCrossTaskDeletionDebt, recordYoloAcceptDebt } from './accept-debt.js';
 import { runRepoHealthCheck } from './repo-health-check.js';
 import { runFinalIntegrationGate, discoverGateCommandLabels } from './final-gate.js';
 import { runFinalGateAutofix } from './final-gate-fix.js';
@@ -337,6 +337,7 @@ export function buildGateDeps(params) {
         // Durable ACCEPT-despite-verify-FAIL ledger under .pi-tasks/ (survives
         // discardEdits): the final integration gate re-checks each debt at run end.
         recordAcceptDebt: (cwd2, taskId, reason) => recordAcceptDebt(cwd2, taskId, reason),
+        recordYoloAcceptDebt: (cwd2, taskId, reason) => recordYoloAcceptDebt(cwd2, taskId, reason),
         recordEnforceRevertDebt: (cwd2, taskId, reason) => recordEnforceRevertDebt(cwd2, taskId, reason),
         // Durable cross-task-contradiction ledger (PROMPT 1 layer B): a repo-health
         // FAIL whose only fix is an edit to a path this task's spec froze — recorded

package/dist/task/orchestrator.d.ts

@@ -212,6 +212,41 @@ export declare const MAX_COMPACTION_RESUMES = 20;
  * of resumes performed (0 when the turn did not end on a compaction).
  */
 export declare function resumeAcrossCompactions(ctx: SteerCtx): Promise<number>;
+/**
+ * Timing knobs for the watchdog-abort guard in {@link steerUntilDone}, injectable
+ * so tests exercise the grace expiry without a 10-second wait. `graceMs` bounds
+ * how long the loop waits for the watchdog's follow-up to be DELIVERED (not to
+ * finish — its turn may legitimately run for minutes afterwards); delivery is
+ * normally near-instant, so the grace only expires on a stale flag.
+ */
+export interface SteerWatchdogDeps {
+    consume: () => boolean;
+    graceMs: number;
+    pollMs: number;
+}
+/**
+ * After the implementation turn settles, honour a user ESC by letting them steer.
+ *
+ * `waitForIdle` resolves both on natural completion AND on an ESC (which aborts
+ * the turn → idle). When the last turn was aborted, the host's main input loop is
+ * blocked inside our command handler, so a message typed in the editor would only
+ * queue, never run (interactive-mode routes idle input through onInputCallback,
+ * which is unset while we hold the loop). We therefore solicit the steering text
+ * ourselves and feed it back as another turn via sendUserMessage — which runs to
+ * completion when the session is idle. Repeat until a turn finishes uninterrupted.
+ *
+ * A WATCHDOG abort also ends the turn with stopReason 'aborted' — indistinguishable
+ * from a human ESC by the session entries alone at that instant. The watchdog
+ * queues its own recovery follow-up, so prompting there would show a steering
+ * dialog to an empty room and wedge an unattended run on the race. The one-shot
+ * flag (set synchronously before the abort) routes that case to
+ * {@link awaitWatchdogFollowUp} instead; a stale flag degrades to a bounded wait
+ * followed by the ordinary prompt, never to a suppressed one.
+ *
+ * Returns true when the user declined to steer (empty/cancelled) and the run
+ * should pause; false when the implementation completed (steered or not).
+ */
+export declare function steerUntilDone(ctx: SteerCtx, promptSteer?: (ctx: ExtensionCommandContext) => Promise<string | undefined>, watchdog?: Partial<SteerWatchdogDeps>): Promise<boolean>;
 /**
  * Run one prompt through the full single-task pipeline in a fresh session and
  * deliver its spec. With waitForImplementation, block until the agent finishes

package/dist/task/orchestrator.js

@@ -28,6 +28,7 @@ import { armImplWidget, disarmImplWidget, setupImplWidget } from './impl-widget.
 import { publishViewer, publishNotify, publishLifecycleNotice, registerBridgeCommand, getBridge, SessionUI } from '../remote/bridge.js';
 import { pushNotify } from '../remote/push.js';
 import { getConfig } from '../config/config.js';
+import { consumeWatchdogAbort, WATCHDOG_CANCEL_MARKER } from './command-watchdog.js';
 import { buildGateDeps } from './gate-deps.js';
 import { runGatesForTask } from './task-gates.js';
 import { parseVerifyBlock } from './spec-validation.js';
@@ -462,6 +463,67 @@ export async function resumeAcrossCompactions(ctx) {
     }
     return resumes;
 }
+/**
+ * True when the watchdog's reminder follow-up has been DELIVERED into the session
+ * after the aborted assistant turn but its own turn has not finished yet — the
+ * artifact that confirms a pending watchdog recovery. Scoped after the LAST
+ * assistant entry so an earlier fire's reminder (already answered by its own
+ * turn) never matches.
+ */
+function watchdogReminderDelivered(ctx) {
+    const entries = ctx.sessionManager.getEntries();
+    let lastAssistant = -1;
+    for (let i = 0; i < entries.length; i++) {
+        const e = entries[i];
+        if ('message' in e && 'role' in e.message && e.message.role === 'assistant') {
+            lastAssistant = i;
+        }
+    }
+    for (let i = lastAssistant + 1; i < entries.length; i++) {
+        const e = entries[i];
+        if (!('message' in e) || !('role' in e.message) || e.message.role !== 'user')
+            continue;
+        const content = e.message.content;
+        const text = typeof content === 'string' ? content
+            : Array.isArray(content) ?
+                content
+                    .map(b => b !== null && typeof b === 'object' && 'text' in b ?
+                    String(b.text)
+                    : '')
+                    .join(' ')
+                : '';
+        if (text.includes(WATCHDOG_CANCEL_MARKER))
+            return true;
+    }
+    return false;
+}
+const STEER_WATCHDOG_DEFAULTS = {
+    consume: consumeWatchdogAbort,
+    graceMs: 10_000,
+    pollMs: 100
+};
+/**
+ * Wait for a watchdog abort's queued follow-up turn instead of prompting. The
+ * abort and the reminder follow-up are two separate steps in the watchdog's
+ * onFire, so the steer loop can observe the aborted turn before the reminder is
+ * delivered — poll (bounded) until it lands or the follow-up turn has already
+ * completed. True = recovery observed, re-check the loop; false = grace expired
+ * with no reminder (stale flag) — fall back to the human prompt.
+ */
+async function awaitWatchdogFollowUp(ctx, wd) {
+    const deadline = Date.now() + wd.graceMs;
+    for (;;) {
+        if (!wasInterrupted(ctx))
+            return true; // follow-up turn already completed
+        if (watchdogReminderDelivered(ctx)) {
+            await ctx.waitForIdle(); // let the follow-up turn run to completion
+            return true;
+        }
+        if (Date.now() >= deadline)
+            return false;
+        await new Promise(r => setTimeout(r, wd.pollMs));
+    }
+}
 /**
  * After the implementation turn settles, honour a user ESC by letting them steer.
  *
@@ -473,10 +535,19 @@ export async function resumeAcrossCompactions(ctx) {
  * ourselves and feed it back as another turn via sendUserMessage — which runs to
  * completion when the session is idle. Repeat until a turn finishes uninterrupted.
  *
+ * A WATCHDOG abort also ends the turn with stopReason 'aborted' — indistinguishable
+ * from a human ESC by the session entries alone at that instant. The watchdog
+ * queues its own recovery follow-up, so prompting there would show a steering
+ * dialog to an empty room and wedge an unattended run on the race. The one-shot
+ * flag (set synchronously before the abort) routes that case to
+ * {@link awaitWatchdogFollowUp} instead; a stale flag degrades to a bounded wait
+ * followed by the ordinary prompt, never to a suppressed one.
+ *
  * Returns true when the user declined to steer (empty/cancelled) and the run
  * should pause; false when the implementation completed (steered or not).
  */
-async function steerUntilDone(ctx, promptSteer) {
+export async function steerUntilDone(ctx, promptSteer, watchdog) {
+    const wd = { ...STEER_WATCHDOG_DEFAULTS, ...watchdog };
     // Fan the prompt out through the bridge (local TUI input + remote browser
     // card, first answer wins) instead of a raw ctx.ui.input: an interrupt can
     // come from the remote Stop button just as well as a terminal ESC, and a
@@ -491,6 +562,8 @@ async function steerUntilDone(ctx, promptSteer) {
             allowSkip: true
         }));
     while (wasInterrupted(ctx)) {
+        if (wd.consume() && (await awaitWatchdogFollowUp(ctx, wd)))
+            continue;
         const steer = await ask(ctx);
         if (steer === undefined || steer.trim().length === 0)
             return true; // pause

package/dist/task/parsers.d.ts

@@ -3,6 +3,23 @@
  *
  * Pure functions that parse raw model output into structured data.
  */
+/**
+ * WHY an auto-answer came back `unknown` — the producers are otherwise
+ * indistinguishable at the call site, and they are NOT equivalent: only
+ * 'api-synthesis' marks a recommendation a machine must never take (see
+ * task/yolo.ts). Mechanical tag, never a text pattern-match:
+ *   - 'model-unknown' — the child itself emitted UNKNOWN (or the parser salvaged a
+ *     bare recommendation): a genuine open fork carrying a best-effort suggestion.
+ *   - 'api-synthesis' — the answer was ANSWERED, then DEMOTED because it names an
+ *     API identifier absent from the research and the question, in a namespace the
+ *     research covers (mx5 run 13: an invented `Bun.mkdirSync` reached requirements
+ *     AND the VERIFY block). The suggestion rides along for a HUMAN to judge.
+ *   - 'integration' — an integration/build-wiring unknown no fetched doc grounded;
+ *     a wrong guess is a structural landmine, so the model's answer is offered as
+ *     a recommendation instead of being taken silently.
+ *   - 'threw' — the child failed; there is no recommendation at all.
+ */
+export type AutoAnswerUnknownReason = 'model-unknown' | 'api-synthesis' | 'integration' | 'threw';
 export type AutoAnswer = {
     kind: 'answered';
     text: string;
@@ -12,6 +29,7 @@ export type AutoAnswer = {
     suggested?: string;
     alt?: string;
     raw: string;
+    reason?: AutoAnswerUnknownReason;
 };
 /** One /task-auto clarify question with its model-recommended default answer. */
 export interface ClarifyQuestion {

package/dist/task/parsers.js

@@ -148,7 +148,8 @@ export function parseAutoAnswer(raw) {
             kind: 'unknown',
             ...(suggested !== undefined && { suggested }),
             ...(alt !== undefined && { alt }),
-            raw
+            raw,
+            reason: 'model-unknown'
         };
     }
     // Last-resort salvage: the model emitted no tag at all. Take the first line
@@ -159,8 +160,8 @@ export function parseAutoAnswer(raw) {
     // answer than to pre-fill a meaningless preamble.
     const salvaged = lines.find(l => !l.endsWith(':'));
     if (salvaged)
-        return { kind: 'unknown', suggested: salvaged, raw };
-    return { kind: 'unknown', raw };
+        return { kind: 'unknown', suggested: salvaged, raw, reason: 'model-unknown' };
+    return { kind: 'unknown', raw, reason: 'model-unknown' };
 }
 // ─── Verify tooling output parser ────────────────────────────────────────────
 export function parseVerifyToolingOutput(output) {

package/dist/task/phases.js

@@ -37,6 +37,7 @@ import { readContracts, buildContractsBlock, buildContractsVerifyBlock } from '.
 import { readRequirements, buildRequirementsBlock } from './requirements.js';
 import { runPhaseChild, runPhaseWithLoopGuard, runWithEmphasisRetry, prependHint, USER_CANCELLED } from './child-runner.js';
 import { SessionUI } from '../remote/bridge.js';
+import { isYoloMode, yoloPickAutoAnswer, YOLO_STAMP } from './yolo.js';
 // ─── Re-export constants from their home modules ────────────────────────────
 export { MAX_GRILL_QUESTIONS };
 // ─── Tooling helpers ─────────────────────────────────────────────────────────
@@ -665,7 +666,15 @@ export async function phaseAutoAnswer(deps, refined, research, question, autoDep
                     const still = reasked ?? parsed;
                     const suggested = still.kind === 'answered' ? still.text : parsed.text;
                     deps.logDebug?.('grill-auto: answer still carries an unverified API — surfacing to user');
-                    parsed = { kind: 'unknown', suggested, raw: still.raw };
+                    parsed = {
+                        kind: 'unknown',
+                        suggested,
+                        raw: still.raw,
+                        // Tagged so a call site can tell this producer from the other
+                        // two: the suggestion is PROVEN to name an unverified API, so
+                        // it may only be judged by a human (yolo.ts must not take it).
+                        reason: 'api-synthesis'
+                    };
                 }
                 else {
                     parsed = reasked;
@@ -683,13 +692,13 @@ export async function phaseAutoAnswer(deps, refined, research, question, autoDep
         if (parsed.kind === 'answered' && !docResolved && isIntegrationUnknown(question)) {
             deps.logDebug?.(`grill-auto: integration unknown unresolved by fetch — surfacing to user `
                 + `instead of auto-answering: ${question.replace(/\s+/g, ' ').slice(0, 120)}`);
-            return { kind: 'unknown', suggested: parsed.text, raw: parsed.raw };
+            return { kind: 'unknown', suggested: parsed.text, raw: parsed.raw, reason: 'integration' };
         }
         return parsed;
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        return { kind: 'unknown', raw: `(threw: ${msg})` };
+        return { kind: 'unknown', raw: `(threw: ${msg})`, reason: 'threw' };
     }
 }
 export async function phaseGrill(deps, ctx, widgetState, refined, research) {
@@ -755,6 +764,21 @@ export async function phaseGrill(deps, ctx, widgetState, refined, research) {
             // locally — each answer in its own bounding box, the recommended one
             // tinted green; an open question shows the bare text prompt.
             const twoOption = plainSuggested !== undefined && plainAlt !== undefined;
+            // YOLO: take the recommended option and never build the prompt (which
+            // is also what suppresses its notification — see yolo.ts). An answer the
+            // anti-synthesis guard demoted, or a question with no recommendation at
+            // all, is SKIPPED instead: costing the spec one unanswered fork is the
+            // guard direction, promoting a hallucination is not.
+            const yolo = yoloPickAutoAnswer(isYoloMode(), auto);
+            if (yolo !== null) {
+                answer =
+                    yolo.kind === 'answer' ?
+                        stripInlineMarkdown(yolo.answer)
+                        : `(skipped — ${yolo.note})`;
+                out.push(`A${n + 1}: ${answer} ${YOLO_STAMP}`);
+                qa.push(`Q${n + 1}: ${plainQ}\nA${n + 1}: ${answer} ${YOLO_STAMP}`);
+                continue;
+            }
             const options = twoOption ?
                 [
                     {

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

@@ -127,6 +127,14 @@ export interface GateDeps {
      * and surfaces it if still open. Best-effort; absent in tests → no ledger written.
      */
     recordAcceptDebt?: (cwd: string, taskId: string, reason: string) => Promise<void>;
+    /**
+     * Record a durable YOLO-ACCEPTED debt: the same ACCEPT branch, but reached by an
+     * unattended auto-pick (yolo mode) rather than a human. Separate dep — and
+     * separate ledger origin — because collapsing the two would let an auto-pick
+     * read as "a human blessed this" in the final gate's run-end report. Best-effort;
+     * absent in tests → no ledger written.
+     */
+    recordYoloAcceptDebt?: (cwd: string, taskId: string, reason: string) => Promise<void>;
     /**
      * Record a durable ENFORCE-REVERT debt (mx5 run 10 item 3): the enforce re-verify
      * FAILED and the enforce edits were reverted, but the FAIL indicts the ORIGINAL

package/dist/task/task-gates.js

@@ -1,5 +1,6 @@
 import { resolutionOptions, classifyResolutionAnswer } from './verify-resolution.js';
 import { SessionUI } from '../remote/bridge.js';
+import { isYoloMode, yoloVerifyResolution, YOLO_STAMP } from './yolo.js';
 /**
  * How many times a verify FAIL may be auto-fixed UNATTENDED (the research
  * recommended AUTOFIX, so pi re-runs the impl turn without prompting) before the
@@ -178,8 +179,19 @@ export async function runGatesForTask(ctxIn, deps, p) {
                 && !isFrozenBlocked
                 && recOutcome.recommend === 'autofix'
                 && autoFixCount < MAX_AUTO_AUTOFIX;
+            // YOLO: the picker is unreachable with nobody watching, and by the time
+            // we are here the unattended AUTOFIX budget is ALREADY spent (autoFixNow
+            // is false) — so the only option left that terminates is ACCEPT, recorded
+            // as its own 'yolo-accepted' debt. Deliberately NOT a re-entry into
+            // autofix: MAX_AUTO_AUTOFIX exists to break a non-converging loop, and an
+            // auto-pick here would restart the budget from the site that proves it ran out.
+            const yoloChoice = autoFixNow ? null : yoloVerifyResolution(isYoloMode());
             let choice;
-            if (autoFixNow) {
+            if (yoloChoice !== null) {
+                choice = yoloChoice;
+                await rec(`resolution: auto-ACCEPTED despite verify FAIL — autofix budget spent, nobody to ask ${YOLO_STAMP}`);
+            }
+            else if (autoFixNow) {
                 autoFixCount += 1;
                 await rec(`resolution: auto-AUTOFIX (recommended, unattended ${autoFixCount}/${MAX_AUTO_AUTOFIX})`);
                 active.ui.notify(`${p.tag}: verify FAIL on "${p.title}" — auto-fixing (recommended, ${autoFixCount}/${MAX_AUTO_AUTOFIX})…`, 'info');
@@ -193,7 +205,9 @@ export async function runGatesForTask(ctxIn, deps, p) {
                 return { kind: 'paused', ctx: active, reason: failReason };
             }
             if (choice.action === 'accept') {
-                await rec('resolution: user ACCEPTED the work despite verify FAIL');
+                const byYolo = yoloChoice !== null;
+                if (!byYolo)
+                    await rec('resolution: user ACCEPTED the work despite verify FAIL');
                 // Durable debt: the human blessed a FAILing artifact as-is, so the
                 // defect ships and nothing else revisits it (mx5 run 4 B3 / run 8
                 // TASK_0012). Record it to the run ledger; the final integration gate
@@ -202,7 +216,15 @@ export async function runGatesForTask(ctxIn, deps, p) {
                 // the contradiction named) — don't double-enter it in the ledger.
                 if (!frozenDebtRecorded) {
                     try {
-                        await deps.recordAcceptDebt?.(p.cwd, p.taskId, failReason);
+                        // Provenance splits here, mandatorily: an auto-pick writes the
+                        // 'yolo-accepted' origin, never the plain 'accepted' one that
+                        // asserts a human weighed the failing artifact.
+                        if (byYolo) {
+                            await deps.recordYoloAcceptDebt?.(p.cwd, p.taskId, failReason);
+                        }
+                        else {
+                            await deps.recordAcceptDebt?.(p.cwd, p.taskId, failReason);
+                        }
                     }
                     catch {
                         // recording must never break the gate sequence
@@ -220,7 +242,7 @@ export async function runGatesForTask(ctxIn, deps, p) {
                         // recording must never break the gate sequence
                     }
                 }
-                active.ui.notify(`${p.tag}: accepted "${p.title}" despite verify FAIL (${failReason.slice(0, 120)}) — proceeding.`, 'warning');
+                active.ui.notify(`${p.tag}: accepted "${p.title}" despite verify FAIL (${failReason.slice(0, 120)}) — proceeding.${byYolo ? ` ${YOLO_STAMP}` : ''}`, 'warning');
                 break;
             }
             // AUTOFIX: re-run the implementation turn with the failure (and any typed

package/dist/task/yolo.d.ts

@@ -0,0 +1,74 @@
+import type { AutoAnswer } from './parsers.js';
+import type { ResolutionChoice } from './verify-resolution.js';
+import type { FinalGateChoice } from './final-gate-fix.js';
+/**
+ * Visible provenance marker on EVERY artifact an auto-pick writes (gate trails,
+ * task-file Q&A, the debt ledger's reason text). A later audit reading only the
+ * artifacts must never mistake an auto-pick for a human decision — that is the
+ * same confusion the accept-debt origins were introduced to prevent.
+ */
+export declare const YOLO_STAMP = "(YOLO)";
+/** Is unattended auto-pick on for this run? The ONLY config read in this module. */
+export declare function isYoloMode(): boolean;
+/**
+ * What YOLO does at a question site:
+ *   - 'answer' — take this (the recommended option).
+ *   - 'skip'   — YOLO is on but there is nothing safe to take; leave the question
+ *                unanswered and move on, with `note` recorded as the reason.
+ *   - null     — YOLO is off: ask the human exactly as before.
+ */
+export type YoloPick = {
+    kind: 'answer';
+    answer: string;
+} | {
+    kind: 'skip';
+    note: string;
+} | null;
+/**
+ * The clarify/grill policy: take the RECOMMENDED option — which is positional,
+ * index 0 of the card list (question-box.ts tints it green), i.e. `suggested`,
+ * falling back to the B-side `alt` when a fork offers only that.
+ *
+ * `unsafe` is the step-aside channel: a caller that KNOWS the recommendation must
+ * not be auto-accepted passes why, and the question is skipped instead. Its one
+ * producer today is the anti-synthesis demotion — an answer proven to name a
+ * hallucinated API identifier. Auto-accepting that would re-promote exactly the
+ * invention the demotion was built to stop (it reached requirements AND the VERIFY
+ * block in mx5 run 13), so a machine may never take it; a human still can.
+ */
+export declare function yoloPickAnswer(enabled: boolean, opts: {
+    suggested?: string;
+    alt?: string;
+    unsafe?: string;
+}): YoloPick;
+/**
+ * The same policy expressed over an {@link AutoAnswer}, for the grill site. Only
+ * the ANTI-SYNTHESIS unknown is unsafe: the other two producers (an integration
+ * unknown research could not ground, a child that threw) carry an ordinary
+ * best-effort recommendation, which is precisely what a human would be shown as
+ * the green card. The variants are told apart by the union's `reason` tag — never
+ * by pattern-matching the answer text.
+ */
+export declare function yoloPickAutoAnswer(enabled: boolean, auto: AutoAnswer): YoloPick;
+/**
+ * The verify-FAIL picker policy: ACCEPT (and write a debt), never AUTOFIX.
+ *
+ * Not a preference — a bound. Every branch that REACHES this picker has already
+ * spent its unattended budget: the loop auto-runs AUTOFIX while the research
+ * recommends it, up to MAX_AUTO_AUTOFIX consecutive failures, and only then hands
+ * over. Answering AUTOFIX here would restart that budget from a site whose whole
+ * purpose is that the budget ran out. So YOLO takes the terminal option and
+ * records the defect ('yolo-accepted' — an origin a human never produces).
+ */
+export declare function yoloVerifyResolution(enabled: boolean): ResolutionChoice | null;
+/**
+ * The final-integration-gate policy: keep autofixing WHILE the picker still
+ * offers that card (the loop withdraws it after MAX_FINAL_GATE_AUTOFIX attempts),
+ * then leave the run FAILED.
+ *
+ * 'leave', not 'accept': an unattended run that cannot fix the whole-repo gate has
+ * not produced a working project, and the honest terminal state is a failed run a
+ * resume can re-enter — mx5 run 13 ended "FAIL accepted by user" on an app that
+ * 404'd at `/`, and that acceptance is what made the failure look like a success.
+ */
+export declare function yoloFinalGateChoice(enabled: boolean, canAutofix: boolean): FinalGateChoice | null;

package/dist/task/yolo.js

@@ -0,0 +1,112 @@
+/**
+ * yolo — unattended auto-pick of the option pi-task already marks RECOMMENDED.
+ *
+ * GOAL: let a local model take a throwaway/test project end to end with nobody
+ * watching. Wherever pi-task would stop and ask, it takes the recommended option,
+ * STAMPS the artifact so a later audit can see a machine decided, and never
+ * notifies. OFF by default; never the behaviour of a normal run.
+ *
+ * WHY PER-SITE, NOT ONE HOOK (the trap this module exists to avoid): the single
+ * interactive choke point is SessionUI.ask() (remote/bridge.ts) — auto-picking
+ * "index 0" inside it would be one tiny patch, and it would be wrong. The
+ * verify-FAIL picker is reached ONLY AFTER MAX_AUTO_AUTOFIX unattended autofix
+ * attempts have already failed, yet it STILL tints AUTOFIX as recommended: a
+ * central hook would pick AUTOFIX forever and defeat the exact cap that exists to
+ * break a non-converging loop. So every site decides for itself, BEFORE ask() is
+ * called — which also means the prompt notification (the lone pushNotify in
+ * ask()) is suppressed structurally, with zero suppression code.
+ *
+ * Guard direction (repo constraint): an auto-pick may cost time, never work.
+ * Anything this module cannot stand behind — no recommendation to take, an answer
+ * the anti-synthesis guard proved unverifiable — steps ASIDE ('skip') rather than
+ * inventing a decision.
+ *
+ * The policy functions are PURE and take `enabled` explicitly, so each site's
+ * behaviour is unit-tested with the flag both ways; only {@link isYoloMode} reads
+ * the config.
+ */
+import { getConfig } from '../config/config.js';
+/**
+ * Visible provenance marker on EVERY artifact an auto-pick writes (gate trails,
+ * task-file Q&A, the debt ledger's reason text). A later audit reading only the
+ * artifacts must never mistake an auto-pick for a human decision — that is the
+ * same confusion the accept-debt origins were introduced to prevent.
+ */
+export const YOLO_STAMP = '(YOLO)';
+/** Is unattended auto-pick on for this run? The ONLY config read in this module. */
+export function isYoloMode() {
+    return getConfig().yoloMode;
+}
+/**
+ * The clarify/grill policy: take the RECOMMENDED option — which is positional,
+ * index 0 of the card list (question-box.ts tints it green), i.e. `suggested`,
+ * falling back to the B-side `alt` when a fork offers only that.
+ *
+ * `unsafe` is the step-aside channel: a caller that KNOWS the recommendation must
+ * not be auto-accepted passes why, and the question is skipped instead. Its one
+ * producer today is the anti-synthesis demotion — an answer proven to name a
+ * hallucinated API identifier. Auto-accepting that would re-promote exactly the
+ * invention the demotion was built to stop (it reached requirements AND the VERIFY
+ * block in mx5 run 13), so a machine may never take it; a human still can.
+ */
+export function yoloPickAnswer(enabled, opts) {
+    if (!enabled)
+        return null;
+    if (opts.unsafe !== undefined && opts.unsafe.length > 0) {
+        return { kind: 'skip', note: opts.unsafe };
+    }
+    const pick = opts.suggested ?? opts.alt;
+    if (pick === undefined || pick.trim().length === 0) {
+        return { kind: 'skip', note: 'no recommended option to take' };
+    }
+    return { kind: 'answer', answer: pick };
+}
+/**
+ * The same policy expressed over an {@link AutoAnswer}, for the grill site. Only
+ * the ANTI-SYNTHESIS unknown is unsafe: the other two producers (an integration
+ * unknown research could not ground, a child that threw) carry an ordinary
+ * best-effort recommendation, which is precisely what a human would be shown as
+ * the green card. The variants are told apart by the union's `reason` tag — never
+ * by pattern-matching the answer text.
+ */
+export function yoloPickAutoAnswer(enabled, auto) {
+    if (!enabled)
+        return null;
+    if (auto.kind === 'answered')
+        return { kind: 'answer', answer: auto.text };
+    return yoloPickAnswer(enabled, {
+        ...(auto.suggested !== undefined && { suggested: auto.suggested }),
+        ...(auto.alt !== undefined && { alt: auto.alt }),
+        ...(auto.reason === 'api-synthesis' && {
+            unsafe: 'the suggested answer names an unverified API identifier — needs a human'
+        })
+    });
+}
+/**
+ * The verify-FAIL picker policy: ACCEPT (and write a debt), never AUTOFIX.
+ *
+ * Not a preference — a bound. Every branch that REACHES this picker has already
+ * spent its unattended budget: the loop auto-runs AUTOFIX while the research
+ * recommends it, up to MAX_AUTO_AUTOFIX consecutive failures, and only then hands
+ * over. Answering AUTOFIX here would restart that budget from a site whose whole
+ * purpose is that the budget ran out. So YOLO takes the terminal option and
+ * records the defect ('yolo-accepted' — an origin a human never produces).
+ */
+export function yoloVerifyResolution(enabled) {
+    return enabled ? { action: 'accept' } : null;
+}
+/**
+ * The final-integration-gate policy: keep autofixing WHILE the picker still
+ * offers that card (the loop withdraws it after MAX_FINAL_GATE_AUTOFIX attempts),
+ * then leave the run FAILED.
+ *
+ * 'leave', not 'accept': an unattended run that cannot fix the whole-repo gate has
+ * not produced a working project, and the honest terminal state is a failed run a
+ * resume can re-enter — mx5 run 13 ended "FAIL accepted by user" on an app that
+ * 404'd at `/`, and that acceptance is what made the failure look like a success.
+ */
+export function yoloFinalGateChoice(enabled, canAutofix) {
+    if (!enabled)
+        return null;
+    return canAutofix ? { action: 'autofix' } : { action: 'leave' };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.18.28",
+    "version": "0.18.30",
     "description": "Deterministic task planning and spec-orchestration for local models — crash-safe /task pipelines with verify/enforce gates, a real-time remote web view, and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",