@mjasnikovs/pi-task 0.18.35 → 0.18.37

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

@@ -22,8 +22,15 @@
  *     deletion ships in the next commit. Recorded so the final gate re-checks it:
  *     resolved iff the named file is back in the tree (a later task restored it),
  *     otherwise surfaced.
+ *   - 'final-gate' — the final integration gate DEMOTED one of its own checks to
+ *     UNOBSERVED (mx5 run 14): two fix attempts that both changed the tree and
+ *     re-ran the gate produced a byte-identical ranked-first failure, so the check
+ *     is unfalsifiable in this environment (run 14: the boot probe needed `ss` or
+ *     `lsof` and the sandbox had neither) and no further attempt can move it. The
+ *     run is allowed to converge on the REMAINING checks, carrying this one here
+ *     so the next run's gate re-checks and re-surfaces it rather than losing it.
  */
-export type DebtOrigin = 'accepted' | 'enforce-revert' | 'frozen-blocked' | 'cross-task-deletion' | 'yolo-accepted';
+export type DebtOrigin = 'accepted' | 'enforce-revert' | 'frozen-blocked' | 'cross-task-deletion' | 'yolo-accepted' | 'final-gate';
 /** One recorded defect: the task, why its VERIFY failed, and how it was recorded. */
 export interface AcceptDebt {
     taskId: string;
@@ -89,6 +96,15 @@ export declare function recordCrossTaskDeletionDebt(cwd: string, taskId: string,
  * 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>;
+/**
+ * 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 declare function recordFinalGateUnobservedDebt(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

@@ -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/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/final-gate.d.ts

@@ -103,6 +103,20 @@ export interface BootDeps {
      * the gate wires runRenderCheck by default for served apps.
      */
     renderProbe?: (url: string) => RenderOutcome;
+    /**
+     * Can this box enumerate listeners with pids AT ALL (ss/netstat/lsof)? False
+     * means the served-app requirement is UNOBSERVABLE here and must degrade to the
+     * survival rule rather than fail — see canEnumerateListeners.
+     */
+    enumerationCapable?: () => boolean;
+    /**
+     * Reserve a free port to hand the boot child as PORT, so an HTTP answer on it is
+     * ownership evidence. null → no port could be reserved (the check then relies on
+     * pgid attribution alone). Injected for tests.
+     */
+    pickPort?: () => Promise<number | null>;
+    /** Does anything answer HTTP on 127.0.0.1:`port`? Injected for tests. */
+    httpProbe?: (port: number) => boolean;
 }
 /**
  * Does the finished run stand up a listening HTTP server? Deterministic, from the
@@ -111,6 +125,39 @@ export interface BootDeps {
  * LISTENER (served app) or may pass on mere survival / quick exit (CLI project).
  */
 export declare function detectsServedApp(cwd: string, planText?: string): boolean;
+/** `ss -tlnpH` rows → {pid, port}. Column 4 (0-based 3) is the local address; the
+ *  port is its last `:`-suffixed number ("0.0.0.0:3000", "[::]:3000"). */
+export declare function parseSsListeners(stdout: string): Array<{
+    pid: number;
+    port: number;
+}>;
+/**
+ * `netstat -tlnp` rows → {pid, port} (mx5 run 14, validated: the agent-sandbox
+ * image ships NEITHER ss NOR lsof — only ps and netstat — so the served-app boot
+ * check could never observe a listener and failed unfalsifiably). The pid rides
+ * in the trailing "PID/Program name" column ("1234/bun"); rows the kernel will
+ * not attribute to us print "-" there and are skipped.
+ */
+export declare function parseNetstatListeners(stdout: string): Array<{
+    pid: number;
+    port: number;
+}>;
+/** `lsof -iTCP -sTCP:LISTEN -n -P` rows → {pid, port}. */
+export declare function parseLsofListeners(stdout: string): Array<{
+    pid: number;
+    port: number;
+}>;
+export declare function canEnumerateListeners(): boolean;
+/** Test seam: forget the memoised capability answer. */
+export declare function resetListenerToolCapability(): void;
+/**
+ * A free TCP port on the loopback interface, or null if one cannot be reserved.
+ * The boot check hands this to the child as PORT so that a successful HTTP
+ * request to it is OWNERSHIP evidence: nobody else knows the number (mx5 runs
+ * 8/10/11 — orphaned servers from earlier checks answered curl on the
+ * conventional :3000 and passed checks the app had not earned).
+ */
+export declare function pickFreePort(): Promise<number | null>;
 /**
  * Exercise the start command ONCE. For a CLI project (`expectServer` false) the
  * command's own fate within the grace window decides:
@@ -126,9 +173,28 @@ export declare function detectsServedApp(cwd: string, planText?: string): boolea
  * served nothing (mx5 run 10 — both were blessed by the survival rule). The boot then
  * PASSes only once a LISTENing socket owned by our process group is observed; if the
  * command exits, or the grace window closes, with no listener ever seen → FAIL naming
- * that a listening server was expected. (The listener requirement needs pgid probing,
- * absent on win32, where `expectServer` collapses to the survival rule — best-effort,
- * never a false FAIL on a platform we cannot probe.)
+ * that a listening server was expected.
+ *
+ * OBSERVABILITY is a precondition of that FAIL (mx5 run 14, validated). The listener
+ * requirement needs pgid-attributed socket enumeration; win32 has none, and neither
+ * does a Linux image shipping no ss/netstat/lsof — run 14's sandbox was exactly that,
+ * so the check emitted "never opened a listening socket" against an app that
+ * demonstrably served, three autofix passes could not falsify it, and the run was
+ * recorded failed. Two defences, in order:
+ *
+ *   - the child is spawned with a freshly reserved, otherwise-unused PORT, and an
+ *     HTTP answer on THAT port proves a listener regardless of tooling. The private
+ *     port is what makes the HTTP probe trustworthy: an orphaned server from an
+ *     earlier check answers on :3000, but nobody else knows this number.
+ *   - if nothing can enumerate listeners AND the assigned port never answered, the
+ *     served-app requirement is unobservable here, so `expectServer` collapses to
+ *     the survival rule and the PASS is stamped UNOBSERVED. An app that ignores PORT
+ *     is indistinguishable from one that never listened — an observer limitation,
+ *     not an app defect, and it may not be reported as one.
+ *
+ * A child that EXITS non-zero still FAILs in every environment: "the process died"
+ * needs no socket probe, so run 14's original true positive (a `--hot` runtime
+ * pinning a crashed app) stays reportable wherever the tooling exists.
  *
  * Env-gap contract as everywhere: spawn error (ENOENT) or exit 127 → skip.
  */

package/dist/task/final-gate.js

@@ -40,6 +40,7 @@
  */
 import { spawn, spawnSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
+import * as net from 'node:net';
 import * as path from 'node:path';
 import { runRepoHealthCheck, discoverHealthCommands } from './repo-health-check.js';
 import { readAcceptDebts, recheckAcceptDebts, writeAcceptDebts, buildAcceptDebtNote, annotateDebtConflicts } from './accept-debt.js';
@@ -198,6 +199,11 @@ function extractPort(text) {
     const n = Number(m[1]);
     return n > 0 && n < 65536 ? n : null;
 }
+/** Stamped on a PASS the boot check could not actually observe, so the trail says
+ *  so out loud instead of implying the listener requirement was met. */
+const UNOBSERVED_LISTENER_NOTE = 'listener check UNOBSERVED: no socket-enumeration tool (ss/netstat/lsof) in this '
+    + 'environment and the app never answered on the port it was given — passed on the '
+    + 'survival rule (the process stayed up), NOT on observed serving';
 /** Package deps that mean "this project stands up an HTTP server" — the deterministic
  *  proxy for "the plan/spec promised a served app". Bare framework names plus the
  *  scoped families whose presence implies a listener at runtime. */
@@ -224,54 +230,163 @@ export function detectsServedApp(cwd, planText) {
     }
     return planText !== undefined && SERVE_TEXT_RE.test(planText);
 }
-/** Listening TCP sockets as {pid, port} pairs (best-effort; ss first, then lsof).
- *  Empty on any failure — the caller then cannot attribute a listener to our group
- *  and the served-app check degrades to survival (never a false FAIL). */
-function listeningSockets() {
+/** `ss -tlnpH` rows → {pid, port}. Column 4 (0-based 3) is the local address; the
+ *  port is its last `:`-suffixed number ("0.0.0.0:3000", "[::]:3000"). */
+export function parseSsListeners(stdout) {
     const out = [];
-    try {
-        const t = spawnSync('ss', ['-tlnpH'], { encoding: 'utf8', timeout: 4000 });
-        if (!t.error && t.stdout) {
-            for (const line of t.stdout.split('\n')) {
-                const pm = /pid=(\d+)/.exec(line);
-                if (!pm)
-                    continue;
-                // Column 4 (0-based 3) is the local address; the port is its last
-                // `:`-suffixed number ("0.0.0.0:3000", "[::]:3000").
-                const local = line.trim().split(/\s+/)[3] ?? '';
-                const portm = /:(\d+)$/.exec(local);
-                if (!portm)
-                    continue;
-                out.push({ pid: Number(pm[1]), port: Number(portm[1]) });
-            }
+    for (const line of stdout.split('\n')) {
+        const pm = /pid=(\d+)/.exec(line);
+        if (!pm)
+            continue;
+        const local = line.trim().split(/\s+/)[3] ?? '';
+        const portm = /:(\d+)$/.exec(local);
+        if (!portm)
+            continue;
+        out.push({ pid: Number(pm[1]), port: Number(portm[1]) });
+    }
+    return out;
+}
+/**
+ * `netstat -tlnp` rows → {pid, port} (mx5 run 14, validated: the agent-sandbox
+ * image ships NEITHER ss NOR lsof — only ps and netstat — so the served-app boot
+ * check could never observe a listener and failed unfalsifiably). The pid rides
+ * in the trailing "PID/Program name" column ("1234/bun"); rows the kernel will
+ * not attribute to us print "-" there and are skipped.
+ */
+export function parseNetstatListeners(stdout) {
+    const out = [];
+    for (const line of stdout.split('\n')) {
+        if (!/^\s*tcp/i.test(line))
+            continue;
+        const cols = line.trim().split(/\s+/);
+        const local = cols[3] ?? '';
+        const portm = /:(\d+)$/.exec(local);
+        if (!portm)
+            continue;
+        const pidm = /^(\d+)\//.exec(cols[cols.length - 1] ?? '');
+        if (!pidm)
+            continue;
+        out.push({ pid: Number(pidm[1]), port: Number(portm[1]) });
+    }
+    return out;
+}
+/** `lsof -iTCP -sTCP:LISTEN -n -P` rows → {pid, port}. */
+export function parseLsofListeners(stdout) {
+    const out = [];
+    for (const line of stdout.split('\n').slice(1)) {
+        const cols = line.trim().split(/\s+/);
+        const pid = Number(cols[1]);
+        const name = cols.find(c => /:\d+$/.test(c)) ?? '';
+        const portm = /:(\d+)$/.exec(name);
+        if (Number.isInteger(pid) && pid > 0 && portm) {
+            out.push({ pid, port: Number(portm[1]) });
         }
     }
-    catch {
-        // ss missing — try lsof
+    return out;
+}
+/** The socket-enumeration tools we can attribute listeners with, in preference
+ *  order: ss (richest), netstat (present where ss is not), lsof (BSD/macOS). */
+const LISTENER_TOOLS = [
+    { bin: 'ss', args: ['-tlnpH'], parse: parseSsListeners },
+    { bin: 'netstat', args: ['-tlnp'], parse: parseNetstatListeners },
+    { bin: 'lsof', args: ['-iTCP', '-sTCP:LISTEN', '-n', '-P'], parse: parseLsofListeners }
+];
+/** Listening TCP sockets as {pid, port} pairs (best-effort; ss, then netstat, then
+ *  lsof). Empty on any failure — the caller then cannot attribute a listener to our
+ *  group and the served-app check degrades to survival (never a false FAIL). */
+function listeningSockets() {
+    for (const { bin, args, parse } of LISTENER_TOOLS) {
+        try {
+            const t = spawnSync(bin, args, { encoding: 'utf8', timeout: 4000 });
+            if (t.error || !t.stdout)
+                continue;
+            const rows = parse(t.stdout);
+            if (rows.length > 0)
+                return rows;
+        }
+        catch {
+            // tool missing/unusable — try the next one
+        }
     }
-    if (out.length === 0) {
+    return [];
+}
+/**
+ * Can ANY socket-enumeration tool run here at all? (mx5 run 14: the sandbox had
+ * none, so `groupHasListener` returned false forever and the boot check emitted
+ * "never opened a listening socket" no matter what the app did — an unfalsifiable
+ * FAIL that failed a run whose app demonstrably served.) This is a CAPABILITY
+ * question, deliberately separate from "did we see a listener": a tool that ran
+ * and found nothing is an observation; no tool at all is blindness, and blindness
+ * must degrade to the survival rule exactly like win32 — never a false FAIL on a
+ * platform we cannot probe.
+ *
+ * "Ran" = spawned without ENOENT and either exited 0 or printed something (lsof
+ * exits 1 on an empty match set; a netstat that rejects `-p` prints nothing).
+ * Memoised: the answer is a property of the box, not of the run.
+ */
+let listenerToolCapability = null;
+export function canEnumerateListeners() {
+    if (listenerToolCapability !== null)
+        return listenerToolCapability;
+    listenerToolCapability = LISTENER_TOOLS.some(({ bin, args }) => {
         try {
-            const t = spawnSync('lsof', ['-iTCP', '-sTCP:LISTEN', '-n', '-P'], {
-                encoding: 'utf8',
-                timeout: 4000
+            const r = spawnSync(bin, args, { encoding: 'utf8', timeout: 4000 });
+            if (r.error)
+                return false;
+            return r.status === 0 || (r.stdout ?? '').trim().length > 0;
+        }
+        catch {
+            return false;
+        }
+    });
+    return listenerToolCapability;
+}
+/** Test seam: forget the memoised capability answer. */
+export function resetListenerToolCapability() {
+    listenerToolCapability = null;
+}
+/**
+ * A free TCP port on the loopback interface, or null if one cannot be reserved.
+ * The boot check hands this to the child as PORT so that a successful HTTP
+ * request to it is OWNERSHIP evidence: nobody else knows the number (mx5 runs
+ * 8/10/11 — orphaned servers from earlier checks answered curl on the
+ * conventional :3000 and passed checks the app had not earned).
+ */
+export function pickFreePort() {
+    return new Promise(resolve => {
+        try {
+            const srv = net.createServer();
+            srv.once('error', () => resolve(null));
+            srv.listen(0, '127.0.0.1', () => {
+                const a = srv.address();
+                const port = typeof a === 'object' && a !== null ? a.port : null;
+                srv.close(() => resolve(port));
             });
-            if (!t.error && t.stdout) {
-                for (const line of t.stdout.split('\n').slice(1)) {
-                    const cols = line.trim().split(/\s+/);
-                    const pid = Number(cols[1]);
-                    const name = cols.find(c => /:\d+$/.test(c)) ?? '';
-                    const portm = /:(\d+)$/.exec(name);
-                    if (Number.isInteger(pid) && pid > 0 && portm) {
-                        out.push({ pid, port: Number(portm[1]) });
-                    }
-                }
-            }
         }
         catch {
-            // neither tool available
+            resolve(null);
         }
+    });
+}
+/**
+ * Does anything answer HTTP on 127.0.0.1:`port`? Any response at all (404, 500 —
+ * a status is a listener) counts; only a connection error or timeout is a no.
+ * Runs in a throwaway child of our own runtime so it needs no curl on PATH and
+ * stays synchronous inside the boot poll.
+ */
+function defaultHttpProbe(port) {
+    const script = `fetch('http://127.0.0.1:${port}/').then(()=>process.exit(0),()=>process.exit(1));`
+        + `setTimeout(()=>process.exit(1),2000)`;
+    try {
+        const r = spawnSync(process.execPath, ['-e', script], {
+            encoding: 'utf8',
+            timeout: 5000
+        });
+        return !r.error && r.status === 0;
+    }
+    catch {
+        return false;
     }
-    return out;
 }
 /** Process-group id of `pid`, or null if it cannot be read. */
 function pgidOf(pid) {
@@ -367,21 +482,48 @@ function holderIsOurs(command, boot) {
  * served nothing (mx5 run 10 — both were blessed by the survival rule). The boot then
  * PASSes only once a LISTENing socket owned by our process group is observed; if the
  * command exits, or the grace window closes, with no listener ever seen → FAIL naming
- * that a listening server was expected. (The listener requirement needs pgid probing,
- * absent on win32, where `expectServer` collapses to the survival rule — best-effort,
- * never a false FAIL on a platform we cannot probe.)
+ * that a listening server was expected.
+ *
+ * OBSERVABILITY is a precondition of that FAIL (mx5 run 14, validated). The listener
+ * requirement needs pgid-attributed socket enumeration; win32 has none, and neither
+ * does a Linux image shipping no ss/netstat/lsof — run 14's sandbox was exactly that,
+ * so the check emitted "never opened a listening socket" against an app that
+ * demonstrably served, three autofix passes could not falsify it, and the run was
+ * recorded failed. Two defences, in order:
+ *
+ *   - the child is spawned with a freshly reserved, otherwise-unused PORT, and an
+ *     HTTP answer on THAT port proves a listener regardless of tooling. The private
+ *     port is what makes the HTTP probe trustworthy: an orphaned server from an
+ *     earlier check answers on :3000, but nobody else knows this number.
+ *   - if nothing can enumerate listeners AND the assigned port never answered, the
+ *     served-app requirement is unobservable here, so `expectServer` collapses to
+ *     the survival rule and the PASS is stamped UNOBSERVED. An app that ignores PORT
+ *     is indistinguishable from one that never listened — an observer limitation,
+ *     not an app defect, and it may not be reported as one.
+ *
+ * A child that EXITS non-zero still FAILs in every environment: "the process died"
+ * needs no socket probe, so run 14's original true positive (a `--hot` runtime
+ * pinning a crashed app) stays reportable wherever the tooling exists.
  *
  * Env-gap contract as everywhere: spawn error (ENOENT) or exit 127 → skip.
  */
-export function runBootCheck(cwd, [bin, args], graceMs = 10_000, opts = {}) {
+export async function runBootCheck(cwd, [bin, args], graceMs = 10_000, opts = {}) {
     const expectServer = (opts.expectServer ?? false) && process.platform !== 'win32';
     const groupHasListener = opts.deps?.groupHasListener ?? defaultGroupHasListener;
+    const httpProbe = opts.deps?.httpProbe ?? defaultHttpProbe;
+    const canEnumerate = expectServer ? (opts.deps?.enumerationCapable ?? canEnumerateListeners)() : true;
+    // Only served apps get an assigned port: a CLI project has nothing to bind, and
+    // an unexpected PORT in its env is noise.
+    const assignedPort = expectServer ? await (opts.deps?.pickPort ?? pickFreePort)() : null;
     return new Promise(resolve => {
         const child = spawn(bin, args, {
             cwd,
             detached: true,
             stdio: ['ignore', 'pipe', 'pipe'],
-            env: { ...process.env }
+            env: {
+                ...process.env,
+                ...(assignedPort !== null ? { PORT: String(assignedPort) } : {})
+            }
         });
         // Best-effort cleanup only: killGroup below can silently fail to reap the
         // process (platform/sandbox-specific — observed on a GH Actions Linux
@@ -443,13 +585,21 @@ export function runBootCheck(cwd, [bin, args], graceMs = 10_000, opts = {}) {
             setInterval(() => {
                 if (settled || !child.pid)
                     return;
-                if (!groupHasListener(child.pid))
+                // pgid attribution first (precise, cheap). If it saw nothing — or
+                // cannot see anything here — fall back to the private assigned
+                // port: an HTTP answer on a number only this child was told is
+                // proof of OUR listener, not of some orphan on :3000.
+                const byGroup = canEnumerate && groupHasListener(child.pid);
+                const byPort = !byGroup && assignedPort !== null && httpProbe(assignedPort);
+                if (!byGroup && !byPort)
                     return;
                 listenerSeen = true;
                 const probe = opts.deps?.renderProbe;
                 if (!probe)
                     return passAndKill();
-                const port = (opts.deps?.groupListeningPort ?? defaultGroupListeningPort)(child.pid);
+                const port = byGroup ?
+                    (opts.deps?.groupListeningPort ?? defaultGroupListeningPort)(child.pid)
+                    : assignedPort;
                 if (port === null) {
                     return passAndKill('render check UNOBSERVED: a listener was seen but its port could not be determined');
                 }
@@ -462,6 +612,12 @@ export function runBootCheck(cwd, [bin, args], graceMs = 10_000, opts = {}) {
             : null;
         const timer = setTimeout(() => {
             if (expectServer && !listenerSeen) {
+                // Blind here (no enumeration tool, and the assigned port never
+                // answered) ⇒ we cannot tell "never listened" from "ignores PORT".
+                // Survival rule, stamped UNOBSERVED — an observer limitation is not
+                // an app defect (mx5 run 14).
+                if (!canEnumerate)
+                    return passAndKill(UNOBSERVED_LISTENER_NOTE);
                 settle({
                     outcome: 'fail',
                     detail: `still running after ${graceMs}ms but never opened a listening socket — the spec/dependencies promise an HTTP server`
@@ -476,6 +632,9 @@ export function runBootCheck(cwd, [bin, args], graceMs = 10_000, opts = {}) {
         child.on('exit', (status, signal) => {
             if (status === 0) {
                 if (expectServer && !listenerSeen) {
+                    if (!canEnumerate) {
+                        return settle({ outcome: 'pass', renderNote: UNOBSERVED_LISTENER_NOTE });
+                    }
                     return settle({
                         outcome: 'fail',
                         detail: 'exited 0 without ever opening a listening socket — the spec/dependencies '

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.18.35",
+    "version": "0.18.37",
     "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",