@mjasnikovs/pi-task 0.18.23 → 0.18.24

package/dist/task/auto-orchestrator.d.ts

@@ -33,6 +33,7 @@ export interface AutoDeps extends GateDeps {
     finalGate?: (cwd: string, planText?: string) => Promise<{
         ok: boolean;
         reason: string;
+        failures?: string[];
         debtNote?: string;
         openDebts?: AcceptDebt[];
     }>;

package/dist/task/auto-orchestrator.js

@@ -913,13 +913,30 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                     // Hand the parent plan (the task list) to the gate so it can tell a
                     // served app from a CLI: the boot check requires a listener only for
                     // the former (mx5 run 10 — a CSS watcher satisfied "still alive").
+                    // Trail EVERY aggregated failure entry (mx5 run 13): the gate now
+                    // runs all sections and ranks the list; a single sliced reason
+                    // line would re-hide everything past the first entry.
+                    const trailGateFail = async (f) => {
+                        const list = f.failures ?? [f.reason];
+                        if (list.length <= 1) {
+                            await recGate(`final-gate: FAIL — ${f.reason.slice(0, 300)}`);
+                            return;
+                        }
+                        await recGate(`final-gate: FAIL — ${list.length} failures (ranked, most load-bearing first)`);
+                        for (const [i, entry] of list.entries()) {
+                            await recGate(`final-gate FAIL ${i + 1}/${list.length}: ${entry.slice(0, 300)}`);
+                        }
+                    };
                     let fin = await deps.finalGate(cwd, body);
                     // Record the outcome symmetrically (mx5 run 10 item 7): only FAIL was
                     // ever trailed, so a PASSing gate was indistinguishable from a gate
                     // that never ran. The PASS reason names the commands that were run.
-                    await recGate(fin.ok ?
-                        `final-gate: PASS — ${fin.reason.slice(0, 300)}`
-                        : `final-gate: FAIL — ${fin.reason.slice(0, 300)}`);
+                    if (fin.ok) {
+                        await recGate(`final-gate: PASS — ${fin.reason.slice(0, 300)}`);
+                    }
+                    else {
+                        await trailGateFail(fin);
+                    }
                     // ACCEPT-debt re-check surfacing (mx5 run 4 B3 / run 8 TASK_0012):
                     // tasks the user accepted despite a verify-FAIL that the gate could
                     // not prove resolved against the current tree. Surface them at the
@@ -989,13 +1006,21 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                             active.ui.notify(`${id}: final-gate autofix did not converge — ${fix.reason.slice(0, 140)}`, 'warning');
                             // Work from the FRESH gate failure when the fix pass got
                             // as far as re-running the gate; otherwise keep the last.
-                            // The debt note is carried so the next picker still shows
-                            // the open claims (the seed never includes it).
+                            // The full ranked list rides along (and is re-trailed
+                            // when fresh) so the next picker and the next fix seed
+                            // 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).
                             fin = {
                                 ok: false,
                                 reason: fix.gateReason ?? fin.reason,
+                                failures: fix.gateReason !== undefined ? fix.gateFailures : fin.failures,
                                 debtNote: fin.debtNote
                             };
+                            if (fix.gateReason !== undefined
+                                && (fix.gateFailures?.length ?? 0) > 1) {
+                                await trailGateFail(fin);
+                            }
                             continue;
                         }
                         // Leave failed — the dismissal default, unchanged from the

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

@@ -42,7 +42,10 @@ export declare function extractFailingCommand(reason: string): string | null;
 /**
  * Build the fix child's prompt. Generic by construction: the only project facts
  * in it are the gate's own failure text — the command comes from the project's
- * discovered manifest, never from a hardcoded ecosystem.
+ * discovered manifest, never from a hardcoded ecosystem. The seed may carry
+ * SEVERAL failures (the gate aggregates every section since mx5 run 13, ranked
+ * most load-bearing first); convergence means the WHOLE list is empty, so the
+ * child is told to fix all of them.
  */
 export declare function buildFinalFixPrompt(failReason: string): string;
 /**
@@ -63,6 +66,9 @@ export interface FinalFixResult {
     /** On a did-not-converge outcome: the FRESH gate failure, so the caller's next
      *  picker (and next fix attempt) works from the current state, not the stale one. */
     gateReason?: string;
+    /** The fresh gate's individual ranked failures (see FinalGateOutcome.failures),
+     *  so the caller can trail each entry — never just the first. */
+    gateFailures?: string[];
 }
 export interface FinalFixDeps {
     cwd: string;
@@ -72,10 +78,13 @@ export interface FinalFixDeps {
     failReason: string;
     /** Run the fix child; same closure shape the other gate children use. */
     runChild: (tools: string, prompt: string, signal?: AbortSignal) => Promise<string>;
-    /** Re-run the final integration gate — the only arbiter of convergence. */
+    /** Re-run the final integration gate — the only arbiter of convergence.
+     *  Converges only when the gate's FULL aggregated failure list is empty
+     *  (ok=true); `failures` rides through so the caller sees every entry. */
     gate: (cwd: string) => Promise<{
         ok: boolean;
         reason: string;
+        failures?: string[];
     }>;
     /** Labels of every currently-discoverable gate command (static + integration),
      *  for the shrink guard. Pure discovery — nothing is executed. */

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

@@ -96,19 +96,24 @@ export function extractFailingCommand(reason) {
 /**
  * Build the fix child's prompt. Generic by construction: the only project facts
  * in it are the gate's own failure text — the command comes from the project's
- * discovered manifest, never from a hardcoded ecosystem.
+ * discovered manifest, never from a hardcoded ecosystem. The seed may carry
+ * SEVERAL failures (the gate aggregates every section since mx5 run 13, ranked
+ * most load-bearing first); convergence means the WHOLE list is empty, so the
+ * child is told to fix all of them.
  */
 export function buildFinalFixPrompt(failReason) {
     return [
         'You are a bounded fix pass for a FAILED whole-repo integration gate.',
         'Every task in this run is complete and committed; then the project’s own',
-        'integration command was run against the assembled repository and failed:',
+        'integration commands were run against the assembled repository and failed:',
         '',
         failReason.trim(),
         '',
-        'Your ONLY job is to make that command pass by fixing the DEFECT it reveals.',
+        'Your ONLY job is to fix the DEFECT(s) those failures reveal. When several',
+        'failures are listed they are ranked most load-bearing first — fix ALL of',
+        'them; the gate only converges when every one passes.',
         '',
-        '1. Re-run the exact failing command first and read its full output.',
+        '1. Re-run each exact failing command first and read its full output.',
         '2. Diagnose the root cause, then fix it with the smallest correct change.',
         '   The project’s own manifests, configs and conventions define what',
         '   correct means — follow them, do not invent new structure.',
@@ -129,9 +134,9 @@ export function buildFinalFixPrompt(failReason) {
         '     revert, stash, clean). The work in this repository is finished and',
         '     committed — reverting it is destroying the run, not fixing it.',
         '',
-        '4. Re-run the failing command after your fix and confirm it exits 0. The',
-        '   gate is re-run mechanically after you finish — your claim is not the',
-        '   verdict, the real exit code is.',
+        '4. Re-run the failing command(s) after your fix and confirm they exit 0.',
+        '   The gate is re-run mechanically after you finish — your claim is not',
+        '   the verdict, the real exit codes are.',
         '',
         'End with exactly one line:',
         '  FINAL-GATE-FIX: DONE',
@@ -240,7 +245,8 @@ export async function runFinalGateAutofix(deps) {
         return {
             ok: false,
             reason: `did not converge: ${fin.reason}`,
-            gateReason: fin.reason
+            gateReason: fin.reason,
+            gateFailures: fin.failures
         };
     }
     return { ok: true, reason: fin.reason };

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

@@ -6,14 +6,25 @@ export interface FinalGateOutcome {
     /** true → statics and every runnable integration command passed (or nothing to run). */
     ok: boolean;
     /**
-     * On a fail: the exact command, its exit code, and the tail of its output — the
-     * MECHANICAL failure only. The accept-debt note is deliberately NOT folded in
+     * On a fail: the exact command(s), exit code(s), and output tail(s) — the
+     * MECHANICAL failures only. The accept-debt note is deliberately NOT folded in
      * here (mx5 run 11): this string seeds the final-gate AUTOFIX child's prompt,
      * and a debt included there is read as an instruction — the run-11 fix child
      * `rm`'d a sibling task's verified deliverable to satisfy a recorded claim. The
      * child cannot act on text it never receives; debts travel in `debtNote`.
+     * With multiple failures this is the numbered, ranked list (see `failures`).
      */
     reason: string;
+    /**
+     * On a fail: EVERY section failure individually, ranked most load-bearing
+     * first — boot/render ("the app does not serve/render") outranks any single
+     * test failure. The gate runs every section and aggregates rather than
+     * early-returning (mx5 run 13: a bun-test glob failure shadowed the boot +
+     * render probe, so the user accepted the FAIL having only ever seen 1 failing
+     * CT test while the shipped app 404'd on every non-API GET). Callers trail
+     * each entry and show the full list wherever an ACCEPT decision is made.
+     */
+    failures?: string[];
     /**
      * Human-facing suffix listing the still-open accepted-defect claims (see
      * buildAcceptDebtNote) — for the picker question and the trail, NEVER for the
@@ -146,6 +157,16 @@ export { taskThatIntroduced };
  * Run the final gate: static analysis first, then the lockfile consistency
  * checks, then the discovered integration commands, then one boot exercise of
  * the start command — whole-repo, verbatim, unaided. Deterministic (no model).
- * First real failure wins.
+ *
+ * EVERY section runs and failures AGGREGATE (mx5 run 13): the gate used to
+ * early-return on the first failing section, and the boot + render probe — built
+ * after run 11 exactly for "app serves blank/nothing" — was ordered last, so any
+ * earlier failure shadowed the most load-bearing signal. Run 13's user accepted
+ * the FAIL having seen only 1 failing CT test while the app 404'd on every
+ * non-API GET; boot/render never executed in any attempt. Now the outcome
+ * carries the full ranked failure list (boot/render first — "the app does not
+ * serve/render" outranks any single test), the ACCEPT decision is made on all of
+ * it, and autofix converges only when the whole list is empty. Per-section
+ * env-gap/INFRA_GAP skip semantics and orphan-port recovery are unchanged.
  */
 export declare function runFinalIntegrationGate(cwd: string, timeoutMs?: number, bootGraceMs?: number, bootDeps?: BootDeps, planText?: string): Promise<FinalGateOutcome>;

package/dist/task/final-gate.js

@@ -595,7 +595,17 @@ export { taskThatIntroduced };
  * Run the final gate: static analysis first, then the lockfile consistency
  * checks, then the discovered integration commands, then one boot exercise of
  * the start command — whole-repo, verbatim, unaided. Deterministic (no model).
- * First real failure wins.
+ *
+ * EVERY section runs and failures AGGREGATE (mx5 run 13): the gate used to
+ * early-return on the first failing section, and the boot + render probe — built
+ * after run 11 exactly for "app serves blank/nothing" — was ordered last, so any
+ * earlier failure shadowed the most load-bearing signal. Run 13's user accepted
+ * the FAIL having seen only 1 failing CT test while the app 404'd on every
+ * non-API GET; boot/render never executed in any attempt. Now the outcome
+ * carries the full ranked failure list (boot/render first — "the app does not
+ * serve/render" outranks any single test), the ACCEPT decision is made on all of
+ * it, and autofix converges only when the whole list is empty. Per-section
+ * env-gap/INFRA_GAP skip semantics and orphan-port recovery are unchanged.
  */
 export async function runFinalIntegrationGate(cwd, timeoutMs = 900_000, bootGraceMs = 10_000, bootDeps = {}, planText) {
     const stat = runRepoHealthCheck(cwd);
@@ -630,8 +640,15 @@ export async function runFinalIntegrationGate(cwd, timeoutMs = 900_000, bootGrac
         ...(debtNote ? { debtNote } : {}),
         openDebts
     });
+    // Aggregated failures across ALL sections (mx5 run 13 — see the function doc).
+    // rank 0 = boot/render ("does not serve/render" is the most load-bearing
+    // signal); rank 1 = everything else, kept in execution order by stable sort.
+    const failures = [];
+    const fail = (text, rank = 1) => {
+        failures.push({ rank, text });
+    };
     if (!stat.ok)
-        return withDebts({ ok: false, reason: `static checks: ${stat.reason}` });
+        fail(`static checks: ${stat.reason}`);
     // Launch-contract diff (mx5 run 10 item 4): the design declared `migrate`/`seed`
     // scripts that fell through decompose and shipped missing, unchecked. Diff the
     // plan-time-extracted declared scripts against the manifest; a missing one is a
@@ -640,16 +657,13 @@ export async function runFinalIntegrationGate(cwd, timeoutMs = 900_000, bootGrac
     if (declared.length > 0) {
         const missing = missingDeclaredScripts(declared, Object.keys(packageScripts(cwd)));
         if (missing.length > 0) {
-            return withDebts({
-                ok: false,
-                reason: `launch contract: the design declares script(s) the shipped package.json does not expose: ${missing.join(', ')} (declared: ${declared.join(', ')})`
-            });
+            fail(`launch contract: the design declares script(s) the shipped package.json does not expose: ${missing.join(', ')} (declared: ${declared.join(', ')})`);
         }
     }
     const lockCmds = discoverLockfileChecks(cwd);
     const { cmds } = discoverIntegrationCommands(cwd);
     const boot = discoverBootCommand(cwd);
-    if (lockCmds.length === 0 && cmds.length === 0 && !boot) {
+    if (lockCmds.length === 0 && cmds.length === 0 && !boot && failures.length === 0) {
         return withDebts({ ok: true, reason: 'no integration command found (statics passed)' });
     }
     const ran = [];
@@ -663,10 +677,8 @@ export async function runFinalIntegrationGate(cwd, timeoutMs = 900_000, bootGrac
             if (r.outcome === 'skip')
                 continue;
             if (r.outcome === 'fail') {
-                return withDebts({
-                    ok: false,
-                    reason: `${prefix}\`${label}\` exited ${r.status}${r.tail ? ` — ${r.tail}` : ''}`
-                });
+                fail(`${prefix}\`${label}\` exited ${r.status}${r.tail ? ` — ${r.tail}` : ''}`);
+                continue;
             }
             ran.push(label);
         }
@@ -685,7 +697,13 @@ export async function runFinalIntegrationGate(cwd, timeoutMs = 900_000, bootGrac
     if (declared.length > 0) {
         const covered = cmds.flatMap(([bin, args]) => (bin === 'bun' || bin === 'npm') && args[0] === 'run' && args[1] ? [args[1]] : []);
         const skippedLaunch = [];
+        // A declared script the manifest doesn't expose is already a launch-contract
+        // failure above; executing it too would double-report (pre-aggregation the
+        // contract diff early-returned, so this loop could assume presence).
+        const present = new Set(Object.keys(packageScripts(cwd)).map(s => s.toLowerCase()));
         for (const name of runnableDeclaredScripts(declared, covered)) {
+            if (!present.has(name.toLowerCase()))
+                continue;
             const cmd = ['bun', ['run', name]];
             const label = `${cmd[0]} ${cmd[1].join(' ')}`;
             const r = runGateCommand(cwd, cmd, Math.min(timeoutMs, 180_000), INFRA_GAP_OUTPUT_RE);
@@ -694,10 +712,8 @@ export async function runFinalIntegrationGate(cwd, timeoutMs = 900_000, bootGrac
                 continue;
             }
             if (r.outcome === 'fail') {
-                return withDebts({
-                    ok: false,
-                    reason: `launch script: \`${label}\` exited ${r.status}${r.tail ? ` — ${r.tail}` : ''}`
-                });
+                fail(`launch script: \`${label}\` exited ${r.status}${r.tail ? ` — ${r.tail}` : ''}`);
+                continue;
             }
             ran.push(label);
         }
@@ -714,6 +730,9 @@ export async function runFinalIntegrationGate(cwd, timeoutMs = 900_000, bootGrac
             }
         }
     }
+    // Boot + render ALWAYS runs (mx5 run 13): it is independent of test results by
+    // construction, and it carries the run's most load-bearing signal — earlier
+    // failures no longer shadow it. Its failures rank FIRST in the aggregate.
     if (boot) {
         const label = `${boot[0]} ${boot[1].join(' ')}`;
         const expectServer = detectsServedApp(cwd, planText);
@@ -734,21 +753,18 @@ export async function runFinalIntegrationGate(cwd, timeoutMs = 900_000, bootGrac
             b = await recoverOrphanPort(cwd, boot, b, bootGraceMs, bootDepsWithRender, expectServer);
         }
         if (b.outcome === 'fail') {
-            return withDebts({ ok: false, reason: `boot check: \`${label}\` ${b.detail}` });
+            fail(`boot check: \`${label}\` ${b.detail}`, 0);
         }
-        if (b.outcome === 'orphan-port') {
+        else if (b.outcome === 'orphan-port') {
             // Could not clear the port. Distinct HARNESS diagnosis, never a bare app
             // FAIL: name the port and (when known) the process squatting on it.
             const holder = b.port !== null ? (bootDeps.findPortHolder ?? defaultFindPortHolder)(b.port) : null;
             const who = holder ? ` — held by an orphaned process (pid ${holder.pid}: ${holder.command})`
                 : b.port !== null ? ` — port ${b.port} is held by another process`
                     : '';
-            return withDebts({
-                ok: false,
-                reason: `boot check: \`${label}\` could not bind: orphaned process / port already in use${who} (harness condition, not an app fault)`
-            });
+            fail(`boot check: \`${label}\` could not bind: orphaned process / port already in use${who} (harness condition, not an app fault)`, 0);
         }
-        if (b.outcome === 'pass') {
+        else if (b.outcome === 'pass') {
             ran.push(label);
             // A listener that served, but whose page could not be OBSERVED to render
             // (no browser, undeterminable port) → UNOBSERVED warning, not a silent pass.
@@ -756,6 +772,22 @@ export async function runFinalIntegrationGate(cwd, timeoutMs = 900_000, bootGrac
                 warnings.push(b.renderNote);
         }
     }
+    if (failures.length > 0) {
+        // Stable sort: boot/render (rank 0) leads, everything else keeps execution
+        // order. One failure keeps the exact single-failure wording; several become
+        // a numbered list so the trail, the ACCEPT picker, and the autofix seed all
+        // carry the complete ranked picture.
+        const texts = [...failures].sort((a, b) => a.rank - b.rank).map(f => f.text);
+        return withDebts({
+            ok: false,
+            reason: texts.length === 1 ?
+                texts[0]
+                : `${texts.length} failures (ranked, most load-bearing first):\n${texts
+                    .map((t, i) => `${i + 1}. ${t}`)
+                    .join('\n')}`,
+            failures: texts
+        });
+    }
     const warningNote = warnings.length > 0 ? ` — WARNING: ${warnings.join('; WARNING: ')}` : '';
     return withDebts({
         ok: true,

package/package.json

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