@mjasnikovs/pi-task 0.18.23 → 0.18.25

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

@@ -5,6 +5,7 @@
  * This module currently holds the planning half (AutoDeps + planAuto). The run
  * loop, command handlers, and defaultDeps are added by the next task.
  */
+import { existsSync } from 'node:fs';
 import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
 import { gateRunTask, markResumable } from './orchestrator.js';
@@ -35,6 +36,7 @@ import { CONTRACT_EXTRACT_PROMPT, parseContractLines, keepGroundedContracts, app
 import { reconcileTitleSources } from './decompose-fidelity.js';
 import { REQUIREMENT_EXTRACT_PROMPT, COVERAGE_MAP_PROMPT, parseRequirementLines, keepGroundedRequirements, capRequirements, enumerateObligationPassages, uncoveredPassages, extractionRetryHint, parseCoverageMap, accountCoverage, isCrossCuttingRequirement, appendCarriedRequirements, buildRequirementsLedger } from './requirements.js';
 import { decideAdoption, groundedCoverage } from './coverage-loop.js';
+import { findSpecDanglingArtifacts, titlesCoverArtifact, danglingMissingText, danglingCarryText } from './artifact-closure.js';
 import { LAUNCH_EXTRACT_PROMPT, enumerateScriptCandidates, parseScriptLines, keepGroundedScripts, appendDeclaredScripts } from './launch-contract.js';
 // Hard ceiling on clarify questions per feature. The loop is open-ended (it stops
 // when the model emits NONE), but a model that never says NONE would otherwise
@@ -493,6 +495,25 @@ export async function planAuto(ctx, cwd, feature, deps) {
     catch {
         // best-effort channel
     }
+    // Artifact-production closure, plan side (mx5 run 13, PROMPT 2): runtime
+    // files the spec REFERENCES (server snippets, prose "serve the built
+    // index.html") that neither its file tree, its parsed build outputs, nor the
+    // existing scaffold produce. Sentence-grounded coverage credited the SERVING
+    // side and reported "0 unowned" while nothing ever CREATED the file — so
+    // these ride the coverage loop's `missing` list as unowned areas until some
+    // task title claims the artifact (grounded in titles, which the coverage-map
+    // model cannot fake — the run-12 lesson). Deterministic and best-effort.
+    let specDangling = [];
+    try {
+        specDangling = findSpecDanglingArtifacts(featureForModel, rel => existsSync(path.join(cwd, rel)));
+        if (specDangling.length > 0) {
+            logPlanDebug(cwd, `artifact closure: ${specDangling.length} dangling runtime artifact(s) in the `
+                + `spec: ${specDangling.map(d => d.path).join(', ')}`);
+        }
+    }
+    catch {
+        // best-effort channel
+    }
     // decompose
     const decomposePrompt = AUTO_DECOMPOSE_PROMPT(featureForModel, clarifications, buildRequirementsLedger(reqEntries));
     // Parse + FIDELITY RECONCILIATION (mx5 run 11, goal B): ground each title's
@@ -589,6 +610,13 @@ export async function planAuto(ctx, cwd, feature, deps) {
             }
         }
         const missing = [...verdictMissing, ...(acc?.unmapped ?? []).map(e => `"${e.quote}"`)];
+        // Unclaimed dangling artifacts are unowned areas: they force a coverage
+        // round that assigns a producing task, and clear as soon as a title
+        // names the file.
+        for (const d of specDangling) {
+            if (!titlesCoverArtifact(titles, d))
+                missing.push(danglingMissingText(d));
+        }
         return {
             plan: { titles, covered, missing },
             accounting: acc,
@@ -707,12 +735,23 @@ export async function planAuto(ctx, cwd, feature, deps) {
     const carriedCrossCutting = accounting?.crossCutting ?? [];
     const carriedUnmapped = accounting?.unmapped ?? [];
     const carriedJudge = best.judgeMissing;
-    if (carriedCrossCutting.length > 0 || carriedUnmapped.length > 0 || carriedJudge.length > 0) {
-        await appendCarriedRequirements(cwd, carriedCrossCutting, carriedUnmapped, carriedJudge);
+    // Dangling artifacts still unclaimed by any title of the SHIPPING plan are a
+    // fourth channel: the producing obligation travels verbatim into every task
+    // (whichever task builds the referencing side must also produce the file),
+    // and the final gate re-checks the shipped tree regardless.
+    const carriedDangling = specDangling
+        .filter(d => !titlesCoverArtifact(planTitles, d))
+        .map(danglingCarryText);
+    if (carriedCrossCutting.length > 0
+        || carriedUnmapped.length > 0
+        || carriedJudge.length > 0
+        || carriedDangling.length > 0) {
+        await appendCarriedRequirements(cwd, carriedCrossCutting, carriedUnmapped, carriedJudge, carriedDangling);
         const parts = [
             carriedCrossCutting.length > 0 ? `${carriedCrossCutting.length} cross-cutting` : '',
             carriedUnmapped.length > 0 ? `${carriedUnmapped.length} unowned` : '',
-            carriedJudge.length > 0 ? `${carriedJudge.length} judge-flagged` : ''
+            carriedJudge.length > 0 ? `${carriedJudge.length} judge-flagged` : '',
+            carriedDangling.length > 0 ? `${carriedDangling.length} dangling-artifact` : ''
         ].filter(p => p.length > 0);
         ctx.ui.notify(`/task-auto: carrying ${parts.join(', ')} requirement(s) into every task`
             + ' — see .pi-tasks/requirements.md.', 'info');
@@ -913,13 +952,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 +1045,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

@@ -47,6 +47,7 @@ import { readDeclaredScripts, missingDeclaredScripts, runnableDeclaredScripts }
 import { readEnvNotes, parseEnvNotes, isExcuseNote } from './env-notes.js';
 import { runRenderCheck } from './render-check.js';
 import { taskThatIntroduced } from './task-provenance.js';
+import { findDanglingArtifacts, danglingGateFailureText } from './artifact-closure.js';
 function packageScripts(cwd) {
     try {
         const j = JSON.parse(readFileSync(path.join(cwd, 'package.json'), 'utf8'));
@@ -595,7 +596,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 +641,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 +658,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 +678,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 +698,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 +713,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 +731,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 +754,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 +773,37 @@ export async function runFinalIntegrationGate(cwd, timeoutMs = 900_000, bootGrac
                 warnings.push(b.renderNote);
         }
     }
+    // Artifact-production closure (mx5 run 13, PROMPT 2): a runtime file
+    // reference with NO producer anywhere ships silently — the server read
+    // `Bun.file('dist/index.html')` while the build emitted only app.css +
+    // main.js, so every non-API GET 404'd behind 32/32 green checkoffs.
+    // Deterministic scan of the shipped tree (literal refs only, positive
+    // producer evidence required — see artifact-closure.ts); each dangle is a
+    // ranked failure naming referencer + missing path. Rank 0: "the app cannot
+    // serve what it references" is the same load-bearing class as boot/render.
+    try {
+        for (const d of findDanglingArtifacts(cwd))
+            fail(danglingGateFailureText(d), 0);
+    }
+    catch {
+        // best-effort scan — a scanner fault must never break the gate
+    }
+    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/dist/task/requirements.d.ts

@@ -88,8 +88,13 @@ export declare function readRequirements(cwd: string): Promise<string>;
  *     was warned-about then dropped). These are plain strings, not quotes of the
  *     source; marked distinctly so a task can tell an inferred area from a verbatim
  *     obligation.
+ *   • `danglingArtifacts` — runtime files the spec references but nothing
+ *     produces (mx5 run 13: the served `index.html` no task, tree entry, or
+ *     build output ever created), still unclaimed by any title at coverage
+ *     exhaustion. Deterministically extracted (artifact-closure.ts), so like
+ *     judge areas they are host-authored strings, not source quotes.
  */
-export declare function appendCarriedRequirements(cwd: string, crossCutting: RequirementEntry[], unresolved?: RequirementEntry[], judgeFlagged?: string[]): Promise<void>;
+export declare function appendCarriedRequirements(cwd: string, crossCutting: RequirementEntry[], unresolved?: RequirementEntry[], judgeFlagged?: string[], danglingArtifacts?: string[]): Promise<void>;
 /**
  * The read-only block refine/compose receive when carried requirements exist.
  * Verbatim content travels with every task (the directive pattern that works),

package/dist/task/requirements.js

@@ -320,10 +320,19 @@ function formatEntry(e, marker) {
  *     was warned-about then dropped). These are plain strings, not quotes of the
  *     source; marked distinctly so a task can tell an inferred area from a verbatim
  *     obligation.
+ *   • `danglingArtifacts` — runtime files the spec references but nothing
+ *     produces (mx5 run 13: the served `index.html` no task, tree entry, or
+ *     build output ever created), still unclaimed by any title at coverage
+ *     exhaustion. Deterministically extracted (artifact-closure.ts), so like
+ *     judge areas they are host-authored strings, not source quotes.
  */
-export async function appendCarriedRequirements(cwd, crossCutting, unresolved = [], judgeFlagged = []) {
-    if (crossCutting.length === 0 && unresolved.length === 0 && judgeFlagged.length === 0)
+export async function appendCarriedRequirements(cwd, crossCutting, unresolved = [], judgeFlagged = [], danglingArtifacts = []) {
+    if (crossCutting.length === 0
+        && unresolved.length === 0
+        && judgeFlagged.length === 0
+        && danglingArtifacts.length === 0) {
         return;
+    }
     try {
         const existing = (await readRequirements(cwd)).split('\n').filter(l => l.trim().length > 0);
         const seen = new Set(existing.map(l => {
@@ -337,6 +346,10 @@ export async function appendCarriedRequirements(cwd, crossCutting, unresolved =
             [
                 judgeFlagged.map(q => ({ quote: q, anchor: '' })),
                 'judge-flagged uncovered area, no task owns this — surfaced at plan time'
+            ],
+            [
+                danglingArtifacts.map(q => ({ quote: q, anchor: '' })),
+                'dangling runtime artifact, nothing produces it — surfaced at plan time'
             ]
         ]) {
             for (const e of entries) {

package/package.json

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