@mjasnikovs/pi-task 0.18.36 → 0.18.38

package/dist/task/accept-debt.js

@@ -77,7 +77,8 @@ export function parseAcceptDebts(raw) {
             ...((origin === 'enforce-revert'
                 || origin === 'frozen-blocked'
                 || origin === 'cross-task-deletion'
-                || origin === 'yolo-accepted') ?
+                || origin === 'yolo-accepted'
+                || origin === 'final-gate') ?
                 { origin: origin }
                 : {})
         });
@@ -187,6 +188,21 @@ export async function recordYoloAcceptDebt(cwd, taskId, reason) {
         origin: 'yolo-accepted'
     });
 }
+/**
+ * Record a FINAL-GATE UNOBSERVED debt (mx5 run 14): the final gate demoted one of its
+ * OWN checks after two tree-changing fix attempts returned an identical ranked-first
+ * failure — unfalsifiable in this environment, so the gate stopped paying for it and
+ * converged on the remaining checks. Durable so the NEXT run's gate re-checks it: it
+ * is model-/environment-judged, so the re-check surfaces it (never auto-closes it).
+ * The taskId is the run's parent id — the demotion is a run-level decision.
+ */
+export async function recordFinalGateUnobservedDebt(cwd, taskId, reason) {
+    await appendDebt(cwd, {
+        taskId: taskId.trim(),
+        reason: normaliseReason(reason),
+        origin: 'final-gate'
+    });
+}
 /**
  * The deleted path a cross-task-deletion debt names (the fixed shape
  * recordCrossTaskDeletionDebt writes). Null on any other reason text — an
@@ -341,5 +357,8 @@ export function describeDebt(d) {
     if (d.origin === 'yolo-accepted') {
         return 'auto-ACCEPTED by YOLO mode despite verify-FAIL (unattended — no human weighed this)';
     }
+    if (d.origin === 'final-gate') {
+        return 'final-gate check DEMOTED to UNOBSERVED (identical failure across two tree-changing fix attempts — unfalsifiable in that environment, never proven passing)';
+    }
     return 'accepted despite verify-FAIL';
 }

package/dist/task/auto-orchestrator.js

@@ -30,7 +30,8 @@ import { buildGateDeps, collectTreeChanges } from './gate-deps.js';
 import { runGatesForTask } from './task-gates.js';
 import { gitUnmergedPaths, gitStashRef } from './auto-commit.js';
 import { runFinalIntegrationGate } from './final-gate.js';
-import { describeDebt } from './accept-debt.js';
+import { describeDebt, recordFinalGateUnobservedDebt } from './accept-debt.js';
+import { applyDemotions, isNonProgress, normalizeFailureDetail, rankedFirstFailure, unobservedDebtReason } from './final-gate-progress.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, STRANDED_FIX_COMMIT, strandedFixNote } from './final-gate-fix.js';
 import { getConfig } from '../config/config.js';
 import { isYoloMode, yoloPickAnswer, yoloFinalGateChoice, YOLO_STAMP } from './yolo.js';
@@ -1027,7 +1028,7 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                     let fixAttempts = 0;
                     // Sub-fixes a non-converging autofix attempt left uncommitted.
                     // Refreshed after every attempt; drives the picker note and the
-                    // accept-time commit (mx5 run 13 PROMPT 4 item 3).
+                    // terminal commit (mx5 run 13 PROMPT 4 item 3, run 14 item 2b).
                     let stranded = [];
                     const refreshStranded = async () => {
                         if (!deps.pendingChanges)
@@ -1040,6 +1041,42 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                             stranded = [];
                         }
                     };
+                    // NON-PROGRESS / UNFALSIFIABLE-CHECK state (mx5 run 14 item 2a).
+                    // `prevFailSig` is the previous attempt's normalized ranked-first
+                    // failure; `demoted` holds the signatures already carried as debt,
+                    // so a re-run that still reports them does not re-fail the gate.
+                    let prevFailSig = null;
+                    const demoted = new Set();
+                    // Set when a write-guard rejected an attempt whose edits could NOT
+                    // be discarded: REJECTED edits are then sitting in the tree and
+                    // must never be committed by the terminal paths below.
+                    let rejectedEditsInTree = false;
+                    // Commit whatever guard-clean repairs the fix passes left, on ANY
+                    // terminal non-converged outcome. Run 14 ended on LEAVE with 13
+                    // real repairs dirty in the tree after an unattended run — the
+                    // next checkout would have destroyed them silently.
+                    const commitStranded = async (outcome) => {
+                        if (stranded.length === 0)
+                            return;
+                        if (rejectedEditsInTree) {
+                            await recGate(`final-gate: NOT committing ${stranded.length} working-tree change(s) — a `
+                                + `write-guard rejected an attempt and its edits could not be discarded, `
+                                + `so the tree holds REJECTED edits: ${stranded.slice(0, 8).join(', ')}`);
+                            return;
+                        }
+                        try {
+                            const sha = await deps.commit(cwd, STRANDED_FIX_COMMIT(id, outcome));
+                            await recGate(`final-gate: committed ${stranded.length} stranded fix-pass change(s)`
+                                + `${sha ? ` as ${sha}` : ''} — ${stranded.slice(0, 8).join(', ')}`);
+                        }
+                        catch (err) {
+                            // Never break the terminal path over this — but say so, so
+                            // the changes are not silently lost.
+                            await recGate(`final-gate: could NOT commit ${stranded.length} stranded fix-pass `
+                                + `change(s) (${err instanceof Error ? err.message : String(err)}) — `
+                                + `they remain UNCOMMITTED in the working tree: ${stranded.slice(0, 8).join(', ')}`);
+                        }
+                    };
                     while (!fin.ok) {
                         const canAutofix = deps.finalGateFix !== undefined && fixAttempts < MAX_FINAL_GATE_AUTOFIX;
                         // The picker question shows the debts (the HUMAN weighs them);
@@ -1099,20 +1136,7 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                             // it fixed. Commit it as its own, named commit — the
                             // ACCEPT is a decision about the FAILING gate, never an
                             // instruction to throw away work (mx5 run 13 item 3).
-                            if (stranded.length > 0) {
-                                try {
-                                    const sha = await deps.commit(cwd, STRANDED_FIX_COMMIT(id));
-                                    await recGate(`final-gate: committed ${stranded.length} stranded fix-pass change(s)`
-                                        + `${sha ? ` as ${sha}` : ''} — ${stranded.slice(0, 8).join(', ')}`);
-                                }
-                                catch (err) {
-                                    // Never break the completion path over this — but
-                                    // say so, so the changes are not silently lost.
-                                    await recGate(`final-gate: could NOT commit ${stranded.length} stranded fix-pass `
-                                        + `change(s) (${err instanceof Error ? err.message : String(err)}) — `
-                                        + `they remain UNCOMMITTED in the working tree: ${stranded.slice(0, 8).join(', ')}`);
-                                }
-                            }
+                            await commitStranded('accepted');
                             active.ui.notify(`${id}: final integration gate FAIL accepted by user — completing.`
                                 + (stranded.length > 0 ?
                                     ` ${stranded.length} uncommitted fix-pass change(s) committed separately.`
@@ -1135,15 +1159,69 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                                 break;
                             }
                             await recGate(`final-gate: autofix attempt ${fixAttempts} failed — ${fix.reason.slice(0, 200)}`);
+                            // A guard that rejected an attempt WITHOUT discarding leaves
+                            // rejected edits behind: the terminal paths must not commit
+                            // the tree after that (the cheat guard stays intact).
+                            if (fix.guardTripped === true && fix.editsDiscarded !== true) {
+                                rejectedEditsInTree = true;
+                            }
                             // The attempt's edits survive a non-convergence (only a
                             // guard trip discards). Find out what they are NOW, so
-                            // the next picker shows them and an ACCEPT can commit them.
+                            // the next picker shows them and a terminal outcome commits them.
                             await refreshStranded();
                             if (stranded.length > 0) {
                                 await recGate(`final-gate: autofix attempt ${fixAttempts} left ${stranded.length} `
                                     + `uncommitted change(s) — ${stranded.slice(0, 8).join(', ')}`);
                             }
                             active.ui.notify(`${id}: final-gate autofix did not converge — ${fix.reason.slice(0, 140)}`, 'warning');
+                            // NON-PROGRESS CLASSIFIER (mx5 run 14 item 2a). An attempt
+                            // that changed the tree, re-ran the gate, and got back the
+                            // SAME ranked-first failure as the previous such attempt is
+                            // evidence about the CHECK, not the fix: run 14 burned all
+                            // three attempts on a boot probe that could not observe a
+                            // listener in that sandbox at all. Demote that one check to
+                            // UNOBSERVED-with-debt and let the REMAINING checks decide.
+                            const detail = rankedFirstFailure({
+                                reason: fix.gateReason,
+                                failures: fix.gateFailures
+                            });
+                            const edited = fix.gateReason !== undefined && stranded.length > 0;
+                            if (detail !== null
+                                && isNonProgress({
+                                    previousSignature: prevFailSig,
+                                    currentDetail: detail,
+                                    edited
+                                })) {
+                                demoted.add(normalizeFailureDetail(detail));
+                                prevFailSig = null;
+                                const debtReason = unobservedDebtReason(detail);
+                                await recordFinalGateUnobservedDebt(cwd, id, debtReason);
+                                await recGate(`final-gate: check DEMOTED to UNOBSERVED after ${fixAttempts} tree-changing `
+                                    + `attempts returned an identical failure — carried as debt (origin final-gate) `
+                                    + `and re-checked by the next run's gate: ${detail.slice(0, 240)}`);
+                                active.ui.notify(`${id}: final-gate check is unfalsifiable in this environment — carried as debt; `
+                                    + 'the remaining checks decide convergence.', 'warning');
+                            }
+                            else {
+                                prevFailSig =
+                                    detail !== null ? normalizeFailureDetail(detail) : null;
+                            }
+                            // Convergence on the REMAINING checks: a demoted signature no
+                            // longer counts against the gate. Nothing left ⇒ the run
+                            // converges carrying the demotion as debt, and the fix passes'
+                            // repairs are committed rather than stranded.
+                            if (demoted.size > 0 && fix.gateReason !== undefined) {
+                                const remaining = applyDemotions(fix.gateFailures ?? [fix.gateReason], demoted);
+                                if (remaining.length === 0) {
+                                    await deps.commit(cwd, `FINAL GATE AUTOFIX (${id})`);
+                                    const converged = `converged on all remaining checks; ${demoted.size} check(s) `
+                                        + 'carried as UNOBSERVED debt (unfalsifiable in this environment)';
+                                    await recGate(`final-gate: ${converged}`);
+                                    active.ui.notify(`${id}: final integration gate converged — ${converged}.`, 'warning');
+                                    fin = { ok: true, reason: converged };
+                                    break;
+                                }
+                            }
                             // Work from the FRESH gate failure when the fix pass got
                             // as far as re-running the gate; otherwise keep the last.
                             // The full ranked list rides along (and is re-trailed
@@ -1151,10 +1229,22 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                             // still carry every entry, not just the first. The debt
                             // note is carried so the next picker still shows the
                             // open claims (the seed never includes it).
+                            // Demoted checks are stripped from what rides forward, so the
+                            // next picker and the next fix seed target only what is still
+                            // falsifiable — never re-aiming the child at the check the
+                            // classifier just proved it cannot move.
+                            const freshFailures = fix.gateReason !== undefined ? fix.gateFailures : fin.failures;
+                            const carried = freshFailures !== undefined ?
+                                applyDemotions(freshFailures, demoted)
+                                : undefined;
                             fin = {
                                 ok: false,
-                                reason: fix.gateReason ?? fin.reason,
-                                failures: fix.gateReason !== undefined ? fix.gateFailures : fin.failures,
+                                reason: (demoted.size > 0
+                                    && carried !== undefined
+                                    && carried.length > 0) ?
+                                    carried[0]
+                                    : (fix.gateReason ?? fin.reason),
+                                failures: carried,
                                 debtNote: fin.debtNote
                             };
                             if (fix.gateReason !== undefined
@@ -1168,18 +1258,16 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                         await recGate(yoloFinal !== null ?
                             `final-gate: left failed — autofix budget spent, nobody to ask ${YOLO_STAMP}`
                             : 'final-gate: left failed (user)');
-                        // Leaving the run failed hands the working tree back to the
-                        // user, so uncommitted fix-pass edits are theirs to keep or
-                        // drop — but they must be VISIBLE, not discovered later by a
-                        // stray `git status` (mx5 run 13 item 3).
-                        if (stranded.length > 0) {
-                            await recGate(`final-gate: ${stranded.length} uncommitted fix-pass change(s) left in the `
-                                + `working tree — ${stranded.slice(0, 8).join(', ')}`);
-                        }
+                        // Leaving the run failed is TERMINAL for an unattended run, so
+                        // the fix passes' guard-clean repairs are committed here too —
+                        // run 14 left 13 of them dirty for a `git checkout` to destroy
+                        // (mx5 run 13 item 3, run 14 item 2b). The user still owns the
+                        // outcome; they own it with the work in HEAD, named in the trail.
+                        await commitStranded('left-failed');
                         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).`
                             + (stranded.length > 0 ?
-                                ` NOTE: ${stranded.length} uncommitted fix-pass change(s) are in your working tree (${stranded.slice(0, 4).join(', ')}).`
+                                ` NOTE: ${stranded.length} fix-pass change(s) were committed separately (${stranded.slice(0, 4).join(', ')}).`
                                 : ''), 'error');
                         return;
                     }

package/dist/task/child-runner.js

@@ -12,6 +12,8 @@ import { childBaseArgs } from '../shared/child-extensions.js';
 import { LoopDetector } from './loop-detector.js';
 import { detectLeakedToolCall, leakedToolCallHint, MAX_LEAK_RETRIES } from '../shared/leaked-tool-call.js';
 import { readSection, setTaskSection } from './task-io.js';
+import { streamStallCause } from '../shared/stream-watchdog.js';
+import { getConfig } from '../config/config.js';
 // ─── Loop detection constants ────────────────────────────────────────────────
 // Defined here (not in phases.ts) to avoid a circular dependency:
 //   phases.ts → child-runner.ts → phases.ts
@@ -77,6 +79,11 @@ export async function runChild(cwd, tools, prompt, signal, onLine, onContextUsag
     let loopHit;
     const result = await runChildUnified(spawnFn ?? spawn, invocation, cwd, signal, {
         mode: 'json-events',
+        // A hung model stream reports nothing at all, so without this the
+        // phase child waits forever (mx5 run 14: ~2.9h of dead air). The kill
+        // is reported below as a connection-class cause, which routes it into
+        // the retry/backoff path this file already has for a LOUD disconnect.
+        streamInactivityMs: getConfig().streamInactivityMs,
         onLine,
         onContextUsage,
         onToolCall: call => {
@@ -95,12 +102,21 @@ export async function runChild(cwd, tools, prompt, signal, onLine, onContextUsag
     // fails with the unhelpful "X child produced no output" — the raw
     // stdout/stderr that might contain the real error is discarded.
     const text = result.text || result.stdout.trim();
+    // The stream watchdog's kill leaves no provider error to report (that is the
+    // whole failure mode), so name it here rather than letting it surface as the
+    // meaningless "produced no output". Never overwrite a real reported cause.
+    const modelError = result.modelError
+        ?? (result.streamStalled ? streamStallCause(result.streamStalled.idleMs) : undefined);
     return {
         text,
-        exitCode: result.exitCode,
+        // WE killed this child, so its exit status describes our own SIGTERM, not
+        // the child's verdict. Report 0 and let `modelError` carry the cause —
+        // otherwise the wrappers' `exitCode !== 0` guard throws a bare "child
+        // failed" before the connection-error retry ever gets to look.
+        exitCode: result.streamStalled ? 0 : result.exitCode,
         stderr: result.stderr.trim(),
         loopHit,
-        modelError: result.modelError,
+        modelError,
         // A tool call the model wrote as text (wrong dialect) never executed and
         // sailed past the structured-event guards above; flag it so the wrappers
         // can re-prompt instead of accepting the unexecuted call. Only meaningful

package/dist/task/final-gate-fix.d.ts

@@ -75,9 +75,18 @@ export declare function parseFinalFixMarker(text: string): {
  *
  * The rule: a partial fix is either committed (its own commit, named in the trail) or
  * explicitly surfaced — never silently stranded.
+ *
+ * mx5 run 14 proved the committing half only ever ran on the ACCEPT path. The run
+ * ended on LEAVE (YOLO, budget spent) and 13 real repairs — the dev script, the
+ * teardown bug, test serialization, the migrate script: the changes that make that
+ * app work today — were left dirty in the tree, one `git checkout` from gone, after
+ * an UNATTENDED run nobody was watching. So EVERY terminal non-converged outcome
+ * commits them now, not just ACCEPT. Only guard-CLEAN edits qualify: an attempt a
+ * write-guard rejected without discarding leaves REJECTED edits in the tree, and
+ * those are never committed (the guard is not weakened to make committing easier).
  */
-/** Commit subject for partial fixes committed alongside an accepted gate FAIL. */
-export declare const STRANDED_FIX_COMMIT: (runId: string) => string;
+/** Commit subject for partial fixes committed alongside a terminal gate FAIL. */
+export declare const STRANDED_FIX_COMMIT: (runId: string, outcome?: "accepted" | "left-failed") => string;
 /**
  * The picker/trail line describing what a non-converging fix pass left behind.
  * Empty string when the tree is clean — the caller then says nothing at all.
@@ -94,6 +103,13 @@ export interface FinalFixResult {
     /** The fresh gate's individual ranked failures (see FinalGateOutcome.failures),
      *  so the caller can trail each entry — never just the first. */
     gateFailures?: string[];
+    /** A write-guard rejected this attempt (deletion / shrink / probe-gaming). */
+    guardTripped?: boolean;
+    /** …and its edits were discarded. When a guard tripped and this is false, the
+     *  working tree still holds REJECTED edits, so the caller must NOT commit what
+     *  it finds there (mx5 run 14 item 2b: commit surviving fix-pass edits — but
+     *  only guard-CLEAN ones; the cheat guard is never weakened to ease committing). */
+    editsDiscarded?: boolean;
 }
 export interface FinalFixDeps {
     cwd: string;

package/dist/task/final-gate-fix.js

@@ -178,9 +178,20 @@ export function parseFinalFixMarker(text) {
  *
  * The rule: a partial fix is either committed (its own commit, named in the trail) or
  * explicitly surfaced — never silently stranded.
+ *
+ * mx5 run 14 proved the committing half only ever ran on the ACCEPT path. The run
+ * ended on LEAVE (YOLO, budget spent) and 13 real repairs — the dev script, the
+ * teardown bug, test serialization, the migrate script: the changes that make that
+ * app work today — were left dirty in the tree, one `git checkout` from gone, after
+ * an UNATTENDED run nobody was watching. So EVERY terminal non-converged outcome
+ * commits them now, not just ACCEPT. Only guard-CLEAN edits qualify: an attempt a
+ * write-guard rejected without discarding leaves REJECTED edits in the tree, and
+ * those are never committed (the guard is not weakened to make committing easier).
  */
-/** Commit subject for partial fixes committed alongside an accepted gate FAIL. */
-export const STRANDED_FIX_COMMIT = (runId) => `FINAL GATE PARTIAL FIX (${runId}) — accepted with gate still failing`;
+/** Commit subject for partial fixes committed alongside a terminal gate FAIL. */
+export const STRANDED_FIX_COMMIT = (runId, outcome = 'accepted') => `FINAL GATE PARTIAL FIX (${runId}) — ${outcome === 'accepted' ?
+    'accepted with gate still failing'
+    : 'run left failed, repairs preserved'}`;
 /**
  * The picker/trail line describing what a non-converging fix pass left behind.
  * Empty string when the tree is clean — the caller then says nothing at all.
@@ -190,9 +201,9 @@ export function strandedFixNote(paths) {
         return '';
     const shown = paths.slice(0, 8).join(', ');
     return (`\n\nUNCOMMITTED: the fix pass left ${paths.length} change(s) in the working tree `
-        + `(${shown}${paths.length > 8 ? ', …' : ''}). These are NOT in HEAD. Accepting will `
-        + `commit them as their own commit so they are not lost; leaving the run failed keeps `
-        + `them in your working tree.`);
+        + `(${shown}${paths.length > 8 ? ', …' : ''}). These are NOT in HEAD. Either terminal `
+        + `choice commits them as their own, named commit so they cannot be lost to a later `
+        + `checkout — the run's outcome is recorded in the gate trail either way.`);
 }
 /**
  * Run one bounded final-gate fix attempt: snapshot discovery → child → write-guard
@@ -214,7 +225,9 @@ export async function runFinalGateAutofix(deps) {
     }
     const rejected = (what) => ({
         ok: false,
-        reason: `${what} — edits ${deps.discard ? 'discarded' : 'REJECTED but left in the tree (no discard available)'}`
+        reason: `${what} — edits ${deps.discard ? 'discarded' : 'REJECTED but left in the tree (no discard available)'}`,
+        guardTripped: true,
+        editsDiscarded: deps.discard !== undefined
     });
     // (Diff capture — what the pass changed, durably — happens at the gate-deps
     // seam for every write-capable child; here only the guards act on it.)

package/dist/task/final-gate-progress.d.ts

@@ -0,0 +1,67 @@
+/**
+ * final-gate-progress — the non-progress classifier for the final-gate autofix loop.
+ *
+ * The failure this closes (mx5 run 14, validated from TASK_AUTO_0001.md's gates
+ * trail): the gate's boot check asserted "the app never opened a listening socket"
+ * in a sandbox where NO tool the probe knows (`ss`, `lsof`) exists — the check was
+ * UNFALSIFIABLE there. Three autofix attempts each edited real files, re-ran, and
+ * came back with a byte-identical ranked-first failure; the budget was spent on a
+ * check no edit could ever move, the two checks that WERE fixable had converged by
+ * attempt 2, and the run ended `failed` with 13 genuinely repaired files sitting
+ * uncommitted in the working tree.
+ *
+ * The rule this encodes: an attempt that CHANGED the tree and re-ran the gate, and
+ * got the same first failure back as the previous attempt, is evidence about the
+ * CHECK, not about the fix. Two identical post-fix results ⇒ the check is
+ * env-shaped/unfalsifiable in this environment ⇒ stop paying for it: demote that
+ * one check to UNOBSERVED-with-debt (durable, so the NEXT run's gate re-checks it)
+ * and let the REMAINING checks decide whether the gate converged. Run 14 replay:
+ * checks 2 and 3 were fixed by attempts 1–2, so the run converges with the boot
+ * check carried as debt instead of failing with the repairs stranded.
+ *
+ * Deliberately conservative:
+ *   - It never fires on attempt 1. The first repeat can be an ordinary
+ *     didn't-fix-it-yet; only a SECOND identical post-fix result is evidence.
+ *   - It never fires when the attempt changed nothing (a BLOCKED child, a
+ *     guard-discarded attempt): with no edit there is nothing to conclude about
+ *     falsifiability.
+ *   - It demotes exactly the one repeated check. Every other failure still has to
+ *     pass for real; the debt keeps the demoted one visible at run end and in the
+ *     next run's gate.
+ */
+/**
+ * Comparison key for a gate failure entry: lowercased, volatile substrings erased,
+ * whitespace collapsed. Two entries with the same key are "the same failure" for
+ * non-progress purposes.
+ */
+export declare function normalizeFailureDetail(detail: string): string;
+/** The ranked-first failure of a gate outcome (the list is ranked most load-bearing
+ *  first; a wiring without a list degrades to the single reason). */
+export declare function rankedFirstFailure(outcome: {
+    reason?: string;
+    failures?: string[];
+}): string | null;
+export interface NonProgressInput {
+    /** Normalized ranked-first failure of the PREVIOUS attempt's gate re-run
+     *  (null before any attempt has produced one — the classifier cannot fire). */
+    previousSignature: string | null;
+    /** This attempt's ranked-first failure, raw. */
+    currentDetail: string | null;
+    /** Did this attempt actually change the tree AND survive the guards? Only an
+     *  attempt that edited and re-tested says anything about falsifiability. */
+    edited: boolean;
+}
+/**
+ * True when this attempt is evidence that the ranked-first check is unfalsifiable
+ * here: it edited the tree, the gate re-ran, and returned the same first failure
+ * as the previous attempt.
+ */
+export declare function isNonProgress(input: NonProgressInput): boolean;
+/**
+ * Drop every failure entry matching an already-demoted signature. What survives is
+ * what still has to pass for the gate to converge; empty ⇒ converged-with-debt.
+ */
+export declare function applyDemotions(failures: string[], demoted: ReadonlySet<string>): string[];
+/** The debt reason recorded for a demoted check, and the gate-trail wording. Kept
+ *  in one place so the ledger line and the trail line cannot drift apart. */
+export declare function unobservedDebtReason(detail: string): string;

package/dist/task/final-gate-progress.js

@@ -0,0 +1,106 @@
+/**
+ * final-gate-progress — the non-progress classifier for the final-gate autofix loop.
+ *
+ * The failure this closes (mx5 run 14, validated from TASK_AUTO_0001.md's gates
+ * trail): the gate's boot check asserted "the app never opened a listening socket"
+ * in a sandbox where NO tool the probe knows (`ss`, `lsof`) exists — the check was
+ * UNFALSIFIABLE there. Three autofix attempts each edited real files, re-ran, and
+ * came back with a byte-identical ranked-first failure; the budget was spent on a
+ * check no edit could ever move, the two checks that WERE fixable had converged by
+ * attempt 2, and the run ended `failed` with 13 genuinely repaired files sitting
+ * uncommitted in the working tree.
+ *
+ * The rule this encodes: an attempt that CHANGED the tree and re-ran the gate, and
+ * got the same first failure back as the previous attempt, is evidence about the
+ * CHECK, not about the fix. Two identical post-fix results ⇒ the check is
+ * env-shaped/unfalsifiable in this environment ⇒ stop paying for it: demote that
+ * one check to UNOBSERVED-with-debt (durable, so the NEXT run's gate re-checks it)
+ * and let the REMAINING checks decide whether the gate converged. Run 14 replay:
+ * checks 2 and 3 were fixed by attempts 1–2, so the run converges with the boot
+ * check carried as debt instead of failing with the repairs stranded.
+ *
+ * Deliberately conservative:
+ *   - It never fires on attempt 1. The first repeat can be an ordinary
+ *     didn't-fix-it-yet; only a SECOND identical post-fix result is evidence.
+ *   - It never fires when the attempt changed nothing (a BLOCKED child, a
+ *     guard-discarded attempt): with no edit there is nothing to conclude about
+ *     falsifiability.
+ *   - It demotes exactly the one repeated check. Every other failure still has to
+ *     pass for real; the debt keeps the demoted one visible at run end and in the
+ *     next run's gate.
+ */
+/**
+ * Volatile substrings that differ between two runs of the SAME failing check —
+ * ports, timings, pids, temp paths, timestamps, hex ids. They must be erased
+ * before comparing, or the classifier never fires on a real repeat (a boot probe
+ * that prints the port it tried, a test runner that prints elapsed ms).
+ *
+ * Ordinary integers are NOT collapsed: "3 tests failed" → "1 test failed" is real
+ * progress and must stay visible as a difference.
+ */
+const VOLATILE = [
+    // ISO-ish timestamps, then clock times.
+    [/\d{4}-\d{2}-\d{2}[t ]\d{2}:\d{2}:\d{2}(?:\.\d+)?z?/g, '<ts>'],
+    [/\b\d{1,2}:\d{2}:\d{2}(?:\.\d+)?\b/g, '<time>'],
+    // Temp dirs (posix + macOS + windows) up to the next whitespace/quote.
+    [/(?:\/tmp|\/private\/var\/folders|\/var\/folders)\/[^\s'"`)]+/g, '<tmp>'],
+    [/[a-z]:\\+(?:users\\+[^\s'"`)\\]+\\+)?appdata\\+local\\+temp\\+[^\s'"`)]+/g, '<tmp>'],
+    // Durations with a unit.
+    [/\b\d+(?:\.\d+)?\s?(?:ms|µs|us|ns|s|m|h|sec|secs|seconds?|minutes?|hours?)\b/g, '<dur>'],
+    // pids, addresses and ports (address first — it subsumes the port form).
+    [/\bpids?\s*[:=]?\s*\d+/g, '<pid>'],
+    [/(?:127\.0\.0\.1|localhost|0\.0\.0\.0|\[::1\]):\d+/g, '<addr>'],
+    [/\bport\s*[:=]?\s*\d{2,5}\b/g, '<port>'],
+    [/:\d{2,5}\b/g, ':<port>'],
+    // Long hex / uuid-ish ids (sha, container id, request id).
+    [/\b0x[0-9a-f]+\b/g, '<hex>'],
+    [/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/g, '<uuid>'],
+    [/\b[0-9a-f]{7,40}\b/g, '<hex>']
+];
+/**
+ * Comparison key for a gate failure entry: lowercased, volatile substrings erased,
+ * whitespace collapsed. Two entries with the same key are "the same failure" for
+ * non-progress purposes.
+ */
+export function normalizeFailureDetail(detail) {
+    let s = detail.toLowerCase();
+    for (const [re, repl] of VOLATILE)
+        s = s.replace(re, repl);
+    return s.replace(/\s+/g, ' ').trim();
+}
+/** The ranked-first failure of a gate outcome (the list is ranked most load-bearing
+ *  first; a wiring without a list degrades to the single reason). */
+export function rankedFirstFailure(outcome) {
+    const first = outcome.failures?.[0] ?? outcome.reason;
+    const t = first?.trim();
+    return t && t.length > 0 ? t : null;
+}
+/**
+ * True when this attempt is evidence that the ranked-first check is unfalsifiable
+ * here: it edited the tree, the gate re-ran, and returned the same first failure
+ * as the previous attempt.
+ */
+export function isNonProgress(input) {
+    if (!input.edited)
+        return false;
+    if (input.previousSignature === null || input.currentDetail === null)
+        return false;
+    return normalizeFailureDetail(input.currentDetail) === input.previousSignature;
+}
+/**
+ * Drop every failure entry matching an already-demoted signature. What survives is
+ * what still has to pass for the gate to converge; empty ⇒ converged-with-debt.
+ */
+export function applyDemotions(failures, demoted) {
+    if (demoted.size === 0)
+        return [...failures];
+    return failures.filter(f => !demoted.has(normalizeFailureDetail(f)));
+}
+/** The debt reason recorded for a demoted check, and the gate-trail wording. Kept
+ *  in one place so the ledger line and the trail line cannot drift apart. */
+export function unobservedDebtReason(detail) {
+    return (`final gate check UNOBSERVED — ${detail.trim().slice(0, 200)} — `
+        + 'repeated identically across two fix attempts that both changed the tree and '
+        + 're-ran the gate; treated as unfalsifiable in this environment and carried as '
+        + 'debt (re-checked by the next run’s gate), not as a proven defect');
+}

package/dist/task/gate-deps.js

@@ -391,6 +391,11 @@ export function buildGateDeps(params) {
                     // ceiling the main session uses, so one /task-config knob
                     // covers implementation and gates alike.
                     commandTimeoutMs: getConfig().requestTimeoutMs,
+                    // Same reasoning one level up: a gate child with no
+                    // wall-clock cap also needs the HUNG-STREAM bound, which
+                    // the probe-based stall guard structurally cannot supply
+                    // (a healthy endpoint reads as proof of life).
+                    streamInactivityMs: getConfig().streamInactivityMs,
                     loop: { pathThreshold: Number.POSITIVE_INFINITY },
                     onLine: line => {
                         lastLine = line;
@@ -538,6 +543,9 @@ export function buildGateDeps(params) {
                             // bash — wired anyway so a future tool grant can't quietly
                             // re-open the hole.
                             commandTimeoutMs: getConfig().requestTimeoutMs,
+                            // Unbounded wall clock here too — the hung-stream
+                            // bound is the only thing that ends a dead stream.
+                            streamInactivityMs: getConfig().streamInactivityMs,
                             // 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

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

@@ -0,0 +1,32 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+/**
+ * MAIN-SESSION adapter for the model-stream watchdog.
+ *
+ * WHY (mx5 run 14): three implementation turns died mid-turn — the session jsonl's
+ * last record is an ordinary assistant message, then silence forever, while the
+ * model container stayed Up(healthy). No error is ever thrown for this shape, so
+ * the connection-error retry (which needs a reported ModelError) cannot fire and
+ * the command watchdog, which only covers tool executions, never arms. The run sat
+ * dead for ~2.9h across the three until a human restarted it.
+ *
+ * HOW: pi's extension events ARE the stream. Any of them — a token delta, a
+ * thinking delta, a tool-call delta, the provider's response headers — resets the
+ * idle clock; only total silence for the configured window fires. On fire the turn
+ * is aborted and a follow-up user turn tells the model to CONTINUE from the
+ * transcript (its completed tool calls and results are already recorded, so a
+ * blind re-send would re-run them).
+ *
+ * ONE ABORT CHANNEL: the fire path goes through the command watchdog's existing
+ * {@link noteWatchdogAbort} flag and its WATCHDOG_CANCEL_MARKER, so
+ * steerUntilDone's already-fixed abort/steer race (b543d15) covers this watchdog
+ * too instead of racing a second, parallel abort mechanism.
+ *
+ * SUSPENDED DURING TOOLS: while a tool executes the model stream is legitimately
+ * idle — a 12-minute build emits nothing. That window belongs to the command
+ * watchdog (requestTimeoutMs); this one pauses between tool_execution_start and
+ * tool_execution_end so the two can never double-fire on the same silence.
+ *
+ * SCOPE: main session only. Children run `--no-extensions`, so their equivalent
+ * guard lives in runChild (shared/child-process.ts) and shares the same machine.
+ */
+export declare function registerStreamWatchdog(pi: ExtensionAPI): void;