@mjasnikovs/pi-task 0.18.22 → 0.18.24

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

@@ -11,8 +11,14 @@
  *     created files need a tsconfig registration every spec forbids). Cross-task
  *     contradiction: no unattended re-run can converge, so the gate loop records the
  *     defect and routes to the human picker instead of burning AUTOFIX rounds.
+ *   - 'cross-task-deletion' — the task's work DELETED a sibling task's committed
+ *     deliverable (mx5 run 12 PROMPT 2: a fix child deleted TASK_0020's playwright ct
+ *     files to green a lint) and the user ACCEPTed the verify-FAIL anyway, so the
+ *     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.
  */
-export type DebtOrigin = 'accepted' | 'enforce-revert' | 'frozen-blocked';
+export type DebtOrigin = 'accepted' | 'enforce-revert' | 'frozen-blocked' | 'cross-task-deletion';
 /** One recorded defect: the task, why its VERIFY failed, and how it was recorded. */
 export interface AcceptDebt {
     taskId: string;
@@ -60,6 +66,24 @@ export declare function recordEnforceRevertDebt(cwd: string, taskId: string, rea
  * it auto-closes iff the final gate's own static check passes.
  */
 export declare function recordFrozenBlockedDebt(cwd: string, taskId: string, reason: string): Promise<void>;
+/**
+ * Record a CROSS-TASK DELETION debt (mx5 run 12 PROMPT 2): the task's work deleted a
+ * file a DIFFERENT task's commit introduced, verify FAILed, and the user ACCEPTed —
+ * so the deletion survives into the next commit. The reason is a fixed machine-
+ * parseable shape (`deleted \`<path>\` …`) so the final gate's re-check can extract
+ * the path and prove the debt resolved iff the file is back in the tree.
+ */
+export declare function recordCrossTaskDeletionDebt(cwd: string, taskId: string, deletion: {
+    path: string;
+    owner: string;
+}): Promise<void>;
+/**
+ * The deleted path a cross-task-deletion debt names (the fixed shape
+ * recordCrossTaskDeletionDebt writes). Null on any other reason text — an
+ * unextractable path means the re-check cannot prove anything, so the debt
+ * stays open (surface, never re-hide).
+ */
+export declare function extractDeletedDebtPath(reason: string): string | null;
 /** Overwrite the ledger with exactly these records (used to prune resolved debts). */
 export declare function writeAcceptDebts(cwd: string, debts: AcceptDebt[]): Promise<void>;
 /**
@@ -73,12 +97,15 @@ export declare function writeAcceptDebts(cwd: string, debts: AcceptDebt[]): Prom
 export declare function isStaticClassDebt(reason: string): boolean;
 /**
  * Re-check the ledger against the current run state. A static-class debt is RESOLVED
- * iff the final gate's own static check now passes (`staticOk`); every other debt
- * stays OPEN (unprovable ⇒ surface, never re-hide). FP-safe: the only auto-close is
- * the one a deterministic check can stand behind.
+ * iff the final gate's own static check now passes (`staticOk`); a cross-task-deletion
+ * debt is RESOLVED iff the file it names is back in the tree (`fileExists` — a later
+ * task or a human restored it, so the deletion no longer holds); every other debt
+ * stays OPEN (unprovable ⇒ surface, never re-hide). FP-safe: the only auto-closes are
+ * ones a deterministic check can stand behind.
  */
 export declare function recheckAcceptDebts(debts: AcceptDebt[], opts: {
     staticOk: boolean;
+    fileExists?: (rel: string) => boolean;
 }): {
     open: AcceptDebt[];
     resolved: AcceptDebt[];

package/dist/task/accept-debt.js

@@ -74,7 +74,9 @@ export function parseAcceptDebts(raw) {
         out.push({
             taskId: parts[0].trim(),
             reason: parts[1].trim(),
-            ...(origin === 'enforce-revert' || origin === 'frozen-blocked' ?
+            ...((origin === 'enforce-revert'
+                || origin === 'frozen-blocked'
+                || origin === 'cross-task-deletion') ?
                 { origin: origin }
                 : {})
         });
@@ -157,6 +159,30 @@ export async function recordFrozenBlockedDebt(cwd, taskId, reason) {
         origin: 'frozen-blocked'
     });
 }
+/**
+ * Record a CROSS-TASK DELETION debt (mx5 run 12 PROMPT 2): the task's work deleted a
+ * file a DIFFERENT task's commit introduced, verify FAILed, and the user ACCEPTed —
+ * so the deletion survives into the next commit. The reason is a fixed machine-
+ * parseable shape (`deleted \`<path>\` …`) so the final gate's re-check can extract
+ * the path and prove the debt resolved iff the file is back in the tree.
+ */
+export async function recordCrossTaskDeletionDebt(cwd, taskId, deletion) {
+    await appendDebt(cwd, {
+        taskId: taskId.trim(),
+        reason: normaliseReason(`deleted \`${deletion.path}\` — ${deletion.owner}'s committed deliverable, removed by this task's work`),
+        origin: 'cross-task-deletion'
+    });
+}
+/**
+ * The deleted path a cross-task-deletion debt names (the fixed shape
+ * recordCrossTaskDeletionDebt writes). Null on any other reason text — an
+ * unextractable path means the re-check cannot prove anything, so the debt
+ * stays open (surface, never re-hide).
+ */
+export function extractDeletedDebtPath(reason) {
+    const m = /^deleted `([^`]+)`/.exec(reason.trim());
+    return m ? m[1] : null;
+}
 /** Overwrite the ledger with exactly these records (used to prune resolved debts). */
 export async function writeAcceptDebts(cwd, debts) {
     try {
@@ -184,14 +210,31 @@ export function isStaticClassDebt(reason) {
 }
 /**
  * Re-check the ledger against the current run state. A static-class debt is RESOLVED
- * iff the final gate's own static check now passes (`staticOk`); every other debt
- * stays OPEN (unprovable ⇒ surface, never re-hide). FP-safe: the only auto-close is
- * the one a deterministic check can stand behind.
+ * iff the final gate's own static check now passes (`staticOk`); a cross-task-deletion
+ * debt is RESOLVED iff the file it names is back in the tree (`fileExists` — a later
+ * task or a human restored it, so the deletion no longer holds); every other debt
+ * stays OPEN (unprovable ⇒ surface, never re-hide). FP-safe: the only auto-closes are
+ * ones a deterministic check can stand behind.
  */
 export function recheckAcceptDebts(debts, opts) {
     const open = [];
     const resolved = [];
     for (const d of debts) {
+        if (d.origin === 'cross-task-deletion') {
+            const p = extractDeletedDebtPath(d.reason);
+            let restored;
+            try {
+                restored = p !== null && opts.fileExists?.(p) === true;
+            }
+            catch {
+                restored = false; // an existence-check fault is inconclusive, not proof
+            }
+            if (restored)
+                resolved.push(d);
+            else
+                open.push(d);
+            continue;
+        }
         if (opts.staticOk && isStaticClassDebt(d.reason))
             resolved.push(d);
         else
@@ -278,5 +321,8 @@ export function describeDebt(d) {
     if (d.origin === 'frozen-blocked') {
         return 'repo health blocked by a spec-frozen path (cross-task contradiction — no task may perform the fixing edit)';
     }
+    if (d.origin === 'cross-task-deletion') {
+        return "a sibling task's committed deliverable was DELETED by this task's work and the deletion was accepted (still missing from the tree)";
+    }
     return 'accepted despite verify-FAIL';
 }

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

@@ -1,18 +1,30 @@
 import { type HealthCommand } from './repo-health-check.js';
 import { type AcceptDebt } from './accept-debt.js';
 import { type RenderOutcome } from './render-check.js';
+import { taskThatIntroduced } from './task-provenance.js';
 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
@@ -140,19 +152,21 @@ export declare function discoverGateCommandLabels(cwd: string): string[];
  * this box; the same wording in a `test` run is a real failure the suite must own).
  */
 export declare const INFRA_GAP_OUTPUT_RE: RegExp;
-/**
- * The task whose commit INTRODUCED `rel` (oldest `--diff-filter=A` commit whose
- * subject carries the pi-task `(TASK_nnnn)` suffix — both the task snapshot and the
- * ENFORCE commit shapes match). Null when the file predates the run, was never
- * committed, git is unavailable, or the adding commit is not a task commit — every
- * unknown degrades to "no conflict claim".
- */
-export declare function taskThatIntroduced(cwd: string, rel: string): string | null;
+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>;
-export {};

package/dist/task/final-gate.js

@@ -46,6 +46,7 @@ import { readAcceptDebts, recheckAcceptDebts, writeAcceptDebts, buildAcceptDebtN
 import { readDeclaredScripts, missingDeclaredScripts, runnableDeclaredScripts } from './launch-contract.js';
 import { readEnvNotes, parseEnvNotes, isExcuseNote } from './env-notes.js';
 import { runRenderCheck } from './render-check.js';
+import { taskThatIntroduced } from './task-provenance.js';
 function packageScripts(cwd) {
     try {
         const j = JSON.parse(readFileSync(path.join(cwd, 'package.json'), 'utf8'));
@@ -586,32 +587,25 @@ async function recoverOrphanPort(cwd, boot, first, bootGraceMs, deps, expectServ
     await new Promise(r => setTimeout(r, 1_500));
     return runBootCheck(cwd, boot, bootGraceMs, { expectServer, deps });
 }
-/**
- * The task whose commit INTRODUCED `rel` (oldest `--diff-filter=A` commit whose
- * subject carries the pi-task `(TASK_nnnn)` suffix — both the task snapshot and the
- * ENFORCE commit shapes match). Null when the file predates the run, was never
- * committed, git is unavailable, or the adding commit is not a task commit — every
- * unknown degrades to "no conflict claim".
- */
-export function taskThatIntroduced(cwd, rel) {
-    const r = spawnSync('git', ['log', '--diff-filter=A', '--format=%s', '--', rel], {
-        cwd,
-        encoding: 'utf8'
-    });
-    if (r.error || r.status !== 0 || !r.stdout)
-        return null;
-    const subjects = r.stdout.trim().split('\n').filter(Boolean);
-    // Newest-first output; the LAST line is the original introduction (a
-    // delete-and-re-add later in history must not reattribute the file).
-    const first = subjects[subjects.length - 1] ?? '';
-    const m = /\((TASK_\d+)\)\s*$/.exec(first);
-    return m ? m[1] : null;
-}
+// File → introducing-task provenance moved to task-provenance.ts (mx5 run-12
+// PROMPT 2 extracted it for the cross-task deletion guards); re-exported so
+// existing importers keep working.
+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);
@@ -624,7 +618,11 @@ export async function runFinalIntegrationGate(cwd, timeoutMs = 900_000, bootGrac
     // construction (see accept-debt.ts). Best-effort: a ledger read/write failure
     // must never break the gate.
     const { open: openRaw, resolved } = recheckAcceptDebts(await readAcceptDebts(cwd), {
-        staticOk: stat.ok
+        staticOk: stat.ok,
+        // Cross-task-deletion debts auto-close iff the deleted file is back in the
+        // tree — a deterministic existence check, corroborating the per-file
+        // provenance the record already carries.
+        fileExists: rel => existsSync(path.join(cwd, rel))
     });
     if (resolved.length > 0)
         await writeAcceptDebts(cwd, openRaw);
@@ -642,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
@@ -652,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 = [];
@@ -675,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);
         }
@@ -697,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);
@@ -706,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);
         }
@@ -726,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);
@@ -746,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.
@@ -768,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/dist/task/gate-deps.d.ts

@@ -40,6 +40,14 @@ export declare function collectAddedLines(cwd: string, signal?: AbortSignal): Pr
  * Failures degrade to an empty summary — the guard then has nothing to reject.
  */
 export declare function collectTreeChanges(cwd: string, signal?: AbortSignal): Promise<TreeChangeSummary>;
+/**
+ * The task's changes for the cross-task deletion probe: the working tree's status
+ * when the work is uncommitted (pre-commit verify), else the LAST COMMIT's
+ * name-status diff (the post-enforce re-verify runs on a clean tree, where that
+ * commit IS the task's work). Failures degrade to an empty summary — the probe is
+ * a sharpener, never a blocker. Same fallback discipline as collectChangedFiles.
+ */
+export declare function collectTaskTreeChanges(cwd: string, signal?: AbortSignal): Promise<TreeChangeSummary>;
 /**
  * Build the gate deps for one command run. `runTask` is the orchestrator's
  * implementation re-runner, injected by the caller. The returned object also drives

package/dist/task/gate-deps.js

@@ -21,7 +21,7 @@ import { runGuidelineEnforcement, classifyEnforceChildFailure } from './enforce-
 import { runWorkVerification, extractSpecForVerification } from './verify-work.js';
 import { readEnvNotes, appendEnvNotes } from './env-notes.js';
 import { readContracts } from './contracts.js';
-import { recordAcceptDebt, recordEnforceRevertDebt, recordFrozenBlockedDebt } from './accept-debt.js';
+import { recordAcceptDebt, recordEnforceRevertDebt, recordFrozenBlockedDebt, recordCrossTaskDeletionDebt } from './accept-debt.js';
 import { runRepoHealthCheck } from './repo-health-check.js';
 import { runFinalIntegrationGate, discoverGateCommandLabels } from './final-gate.js';
 import { runFinalGateAutofix } from './final-gate-fix.js';
@@ -30,7 +30,8 @@ import { extractProhibitions, findProhibitionViolations } from './prohibition-pr
 import { frozenPathsFromSpec, revertFrozenPaths } from './frozen-path-guard.js';
 import { findProbeGaming, parseAddedLines } from './probe-gaming.js';
 import { findSubstitutionSuspects, isTestFile } from './substitution-probe.js';
-import { parseTreeChanges, formatTreeChanges } from './write-guard.js';
+import { parseTreeChanges, parseNameStatusChanges, formatTreeChanges } from './write-guard.js';
+import { taskThatIntroduced, findCrossTaskDeletions } from './task-provenance.js';
 import { findTestRebuiltAssemblies, testAssemblyVerifyFindings } from './test-assembly.js';
 import { runBoundedLintFix } from './lint-fix.js';
 import { captureGitState, reconcileGitState } from './git-state-guard.js';
@@ -131,6 +132,20 @@ export async function collectTreeChanges(cwd, signal) {
     const r = await git(cwd, ['status', '--porcelain', '--', '.', EXCLUDE_TASKS_DIR], signal);
     return r.exitCode === 0 ? parseTreeChanges(r.stdout) : { modified: [], deleted: [], added: [] };
 }
+/**
+ * The task's changes for the cross-task deletion probe: the working tree's status
+ * when the work is uncommitted (pre-commit verify), else the LAST COMMIT's
+ * name-status diff (the post-enforce re-verify runs on a clean tree, where that
+ * commit IS the task's work). Failures degrade to an empty summary — the probe is
+ * a sharpener, never a blocker. Same fallback discipline as collectChangedFiles.
+ */
+export async function collectTaskTreeChanges(cwd, signal) {
+    const now = await collectTreeChanges(cwd, signal);
+    if (now.modified.length + now.deleted.length + now.added.length > 0)
+        return now;
+    const last = await git(cwd, ['diff', '--name-status', 'HEAD~1..HEAD', '--', '.', EXCLUDE_TASKS_DIR], signal);
+    return last.exitCode === 0 ? parseNameStatusChanges(last.stdout) : now;
+}
 /** Source extensions whose relative imports the test-assembly probe reasons over. */
 const SOURCE_EXT_RE = /\.(?:[cm]?[jt]sx?)$/;
 /** Bounds so the probe stays cheap on large repos (it reads file text). */
@@ -318,6 +333,10 @@ export function buildGateDeps(params) {
         // FAIL whose only fix is an edit to a path this task's spec froze — recorded
         // when the gate loop routes it to the picker, re-checked by the final gate.
         recordFrozenBlockedDebt: (cwd2, taskId, reason) => recordFrozenBlockedDebt(cwd2, taskId, reason),
+        // Durable cross-task-deletion ledger (PROMPT 2): a sibling's committed
+        // deliverable this task's diff deletes, ACCEPTed into a commit anyway —
+        // the final gate re-checks it (resolved iff the file is back in the tree).
+        recordCrossTaskDeletionDebt: (cwd2, taskId, deletion) => recordCrossTaskDeletionDebt(cwd2, taskId, deletion),
         // Frozen-path write-deny (see frozen-path-guard.ts): the concrete paths this
         // task's spec forbids modifying, so the gate sequence can UNDO any edit the
         // enforce EDIT pass makes to them before those edits are committed. Reads the
@@ -457,6 +476,12 @@ export function buildGateDeps(params) {
                 // ("return 401 so the verification test passes") become rule-4c
                 // findings so the child verifies the real requirement, not the check.
                 probeGamingProbe: () => collectAddedLines(cwd2, signal).then(findProbeGaming),
+                // Deterministic cross-task deletion probe (mx5 run 12 PROMPT 2):
+                // tracked files this task's diff DELETES whose introducing commit
+                // belongs to a DIFFERENT task — a sibling's committed deliverable
+                // destroyed (typically to green a check). Injected under rule 4d and
+                // carried on a FAIL so an ACCEPT records durable debts.
+                crossTaskDeletionProbe: () => collectTaskTreeChanges(cwd2, signal).then(changes => findCrossTaskDeletions(changes, taskId, rel => taskThatIntroduced(cwd2, rel))),
                 // Deterministic prohibition probe: paths the spec forbids modifying
                 // that the task's diff modified anyway become prompt-level findings
                 // under the no-waiver rule — the child otherwise rarely runs `git
@@ -520,7 +545,14 @@ export function buildGateDeps(params) {
                     const r = await git(cwd2, args, signal);
                     return { exitCode: r.exitCode, stdout: r.stdout };
                 },
-                frozenPaths
+                frozenPaths,
+                // Cross-task deletion guard (mx5 run 12 PROMPT 2): the revert-guard
+                // is blind to a clean tracked sibling deliverable, so deleting one
+                // greens the lint and the pass returns ok. Provenance is the
+                // discriminator — the guard restores a sibling's deleted file and
+                // reports not-applied naming the owner.
+                currentTaskId: taskId,
+                introducedBy: rel => Promise.resolve(taskThatIntroduced(cwd2, rel))
             });
         },
         // Deterministic static check + tree helpers for the enforce pre-commit gate.

package/dist/task/lint-fix.d.ts

@@ -31,6 +31,17 @@ export interface LintFixDeps {
      * and the fix reported not-applied. Absent/empty → no-op, prior behavior.
      */
     frozenPaths?: string[];
+    /**
+     * The CURRENT task's id, for the cross-task deletion guard's provenance
+     * discriminator. Absent → the guard is disarmed (prior behavior).
+     */
+    currentTaskId?: string;
+    /**
+     * file → introducing task id (git provenance, see task-provenance.ts); null on
+     * any unknown — inconclusive is never evidence. Absent → the cross-task
+     * deletion guard is disarmed (prior behavior).
+     */
+    introducedBy?: (rel: string) => Promise<string | null>;
 }
 /** The fix child edits and runs the checker; bash exists to RUN the check, not git. */
 export declare const LINT_FIX_TOOLS = "read,edit,bash";

package/dist/task/lint-fix.js

@@ -43,8 +43,23 @@
  * that were CLEAN before the child ran are reverted — a frozen path already
  * dirty with (possibly task) work is left alone, in the guard's safe direction:
  * cost time, never work.
+ *
+ * CROSS-TASK DELETION GUARD (mx5 run 12 PROMPT 2, verify-debug.log 17:53:44): the
+ * revert-guard above is outcome-based but blind to a CLEAN tracked file — a
+ * sibling task's committed deliverable is neither pre-dirty nor pre-untracked, so
+ * DELETING it slips both checks, and if the lint converges the pass returns ok
+ * (confirmed live: the child deleted TASK_0020's playwright ct files to green a
+ * typed-lint it was frozen out of fixing properly). The discriminator is
+ * PROVENANCE, not deletion per se: a tracked file the CHILD deleted whose
+ * introducing task (per `introducedBy`, git history) differs from the CURRENT
+ * task is restored from HEAD and the fix reported not-applied naming the owner.
+ * Same-task deletions, unknown provenance, relocations, and any git error all
+ * step aside — the guard may only cost time, never work. Armed only when both
+ * `currentTaskId` and `introducedBy` are wired.
  */
 import { parseChangedFrozenFiles, pathNamedIn, revertFrozenPaths } from './frozen-path-guard.js';
+import { parseTreeChanges } from './write-guard.js';
+import { findCrossTaskDeletions } from './task-provenance.js';
 /** The fix child edits and runs the checker; bash exists to RUN the check, not git. */
 export const LINT_FIX_TOOLS = 'read,edit,bash';
 /**
@@ -121,6 +136,17 @@ async function dirtyFiles(deps) {
         .map(l => l.trim())
         .filter(l => l.length > 0);
 }
+/**
+ * The whole tree's current changes (`git status --porcelain` shape), or null when
+ * git itself failed — inconclusive, not evidence (same discipline as dirtyFiles).
+ * Feeds the cross-task deletion guard's pre/post comparison.
+ */
+async function treeChanges(deps) {
+    const r = await deps.git(['status', '--porcelain', '--', '.', EXCLUDE_TASKS_DIR]);
+    if (r.exitCode !== 0)
+        return null;
+    return parseTreeChanges(r.stdout);
+}
 /**
  * Which spec-frozen paths currently show a change in `git status`? Null when git
  * itself failed — inconclusive, not evidence (same discipline as dirtyFiles).
@@ -172,6 +198,12 @@ export async function runBoundedLintFix(deps) {
     // here disables the guard for this run (inconclusive ≠ license to revert).
     const frozen = deps.frozenPaths ?? [];
     const preFrozenDirty = await frozenDirtySet(deps, frozen);
+    // CROSS-TASK DELETION baseline: deletions already in the tree pre-child are
+    // the task's own (uncommitted) work, not the child's — only deletions the
+    // CHILD introduces on top are candidates. A git failure here disarms the
+    // guard for this run (inconclusive ≠ evidence).
+    const deletionGuardArmed = Boolean(deps.currentTaskId && deps.introducedBy);
+    const preChanges = deletionGuardArmed ? await treeChanges(deps) : null;
     try {
         await deps.runChild(LINT_FIX_TOOLS, buildLintFixPrompt(deps.failReason, frozen), deps.signal);
     }
@@ -224,6 +256,36 @@ export async function runBoundedLintFix(deps) {
                 + `${violations.length > 3 ? ', …' : ''}) — fix ${snapshot ? 'rolled back' : 'REJECTED but no snapshot to restore'}`
         };
     }
+    // CROSS-TASK DELETION GUARD: a tracked file the CHILD deleted whose
+    // introducing task differs from the current task is a sibling's committed
+    // deliverable destroyed to go green (mx5 run 12: the child deleted TASK_0020's
+    // playwright ct files and the pass returned ok — the revert-guard above only
+    // watches pre-dirty and pre-untracked files, and a clean tracked sibling file
+    // is neither). Restore JUST those paths from HEAD (they were clean pre-child,
+    // so nothing of the task's work can be lost) and report not-applied naming the
+    // owner. Inconclusive on any side — git error, unknown provenance, same-task
+    // deletion, relocation — steps aside.
+    if (deletionGuardArmed && preChanges !== null) {
+        const postChanges = await treeChanges(deps);
+        if (postChanges !== null) {
+            const preDeleted = new Set(preChanges.deleted);
+            const crossDeletions = await findCrossTaskDeletions({
+                modified: postChanges.modified,
+                added: postChanges.added,
+                deleted: postChanges.deleted.filter(p => !preDeleted.has(p))
+            }, deps.currentTaskId, deps.introducedBy);
+            if (crossDeletions.length > 0) {
+                await deps.git(['checkout', '-f', 'HEAD', '--', ...crossDeletions.map(d => d.path)]);
+                const named = crossDeletions.map(d => `${d.path} — ${d.owner}'s deliverable`);
+                return {
+                    ok: false,
+                    reason: `cross-task-deletion: fix child DELETED sibling task deliverable(s) `
+                        + `(${named.slice(0, 3).join('; ')}${crossDeletions.length > 3 ? '; …' : ''}) `
+                        + `— restored from HEAD; deleting another task's committed work is not a fix`
+                };
+            }
+        }
+    }
     // FROZEN-PATH GUARD: a frozen path that was clean pre-child and is changed
     // now is the child's edit — the exact write verify's rule-4b prohibition
     // probe is guaranteed to fail the TASK for (mx5 run 12: ESLint's own error

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

@@ -143,6 +143,17 @@ export interface GateDeps {
      * it), so the final gate re-checks it at run end. Best-effort; absent in tests.
      */
     recordFrozenBlockedDebt?: (cwd: string, taskId: string, reason: string) => Promise<void>;
+    /**
+     * Record a durable CROSS-TASK DELETION debt (mx5 run 12 PROMPT 2): the task's
+     * work deleted a file a DIFFERENT task's commit introduced, verify FAILed with
+     * the deterministic finding attached, and the user ACCEPTed anyway — the
+     * deletion ships in the next commit, so the final gate must re-check it
+     * (resolved iff the file is back in the tree). Best-effort; absent in tests.
+     */
+    recordCrossTaskDeletionDebt?: (cwd: string, taskId: string, deletion: {
+        path: string;
+        owner: string;
+    }) => Promise<void>;
     /**
      * The concrete paths this task's spec forbids modifying (its `Do NOT modify`
      * CONSTRAINTS — see frozen-path-guard.ts / prohibition-probe.ts). Used to

package/dist/task/task-gates.js

@@ -208,6 +208,18 @@ export async function runGatesForTask(ctxIn, deps, p) {
                         // recording must never break the gate sequence
                     }
                 }
+                // Cross-task deletions the verify probe detected ship in the next
+                // commit with this ACCEPT — record each as its own durable debt so
+                // the final gate re-checks them (mx5 run 12 PROMPT 2). Best-effort.
+                for (const del of verified.crossTaskDeletions ?? []) {
+                    try {
+                        await deps.recordCrossTaskDeletionDebt?.(p.cwd, p.taskId, del);
+                        await rec(`accept-debt: cross-task deletion recorded — ${del.path} (${del.owner}'s deliverable)`);
+                    }
+                    catch {
+                        // recording must never break the gate sequence
+                    }
+                }
                 active.ui.notify(`${p.tag}: accepted "${p.title}" despite verify FAIL (${failReason.slice(0, 120)}) — proceeding.`, 'warning');
                 break;
             }

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

@@ -0,0 +1,45 @@
+import { type TreeChangeSummary } from './write-guard.js';
+/** Run a git subcommand; only stdout + exit code are read (injectable for tests). */
+export type ProvenanceGit = (args: string[]) => Promise<{
+    stdout: string;
+    exitCode: number;
+}>;
+/**
+ * The task id carried by the OLDEST commit subject in `git log --diff-filter=A
+ * --format=%s` output (newest-first, so the LAST line is the original
+ * introduction — a delete-and-re-add later in history must not reattribute the
+ * file). Both the task snapshot and the ENFORCE commit shapes match the
+ * `(TASK_nnnn)` suffix. Null when the output is empty or the adding commit is
+ * not a task commit.
+ */
+export declare function parseIntroducingTask(logSubjects: string): string | null;
+/**
+ * The task whose commit INTRODUCED `rel`. Null when the file predates the run,
+ * was never committed, git is unavailable, or the adding commit is not a task
+ * commit — every unknown degrades to "no provenance claim".
+ */
+export declare function taskThatIntroduced(cwd: string, rel: string): string | null;
+/** Same lookup through an injected async git (the lint-fix deps shape). */
+export declare function taskThatIntroducedVia(git: ProvenanceGit, rel: string): Promise<string | null>;
+/** One detected cross-task deletion: the file and the task whose commit introduced it. */
+export interface CrossTaskDeletion {
+    path: string;
+    owner: string;
+}
+/**
+ * Deterministic cross-task deletion detection: a tracked file DELETED in the
+ * given change summary whose introducing task differs from the CURRENT task is a
+ * finding. Everything else steps aside by construction — same-task deletions and
+ * unknown provenance are never findings (a task refactoring its own work must not
+ * be blocked), an unknown CURRENT task id disables the check ("differs" cannot be
+ * established), and a relocation (the same file name reappears among the added
+ * files — write-guard's allowance) is not a deletion. `introducedBy` may be sync
+ * or async and may throw; a throw reads as unknown provenance.
+ */
+export declare function findCrossTaskDeletions(changes: TreeChangeSummary, currentTaskId: string, introducedBy: (rel: string) => string | null | Promise<string | null>): Promise<CrossTaskDeletion[]>;
+/**
+ * Finding lines for the verify prompt (the substitution-probe injection pattern:
+ * the rule alone is A/B-proven ignored, the rule plus a concrete finding naming
+ * the file is what lands).
+ */
+export declare function crossTaskDeletionVerifyFindings(found: CrossTaskDeletion[]): string[];

package/dist/task/task-provenance.js

@@ -0,0 +1,98 @@
+/**
+ * task-provenance — file → introducing-task lookup, and the cross-task deletion
+ * detection built on it (mx5 run-12 PROMPT 2).
+ *
+ * The failure class: write-enabled gate/fix children can DELETE a sibling task's
+ * committed deliverable to turn a red check green. Live (mx5 2026-07-16,
+ * verify-debug.log 17:53:44): `bun run lint` was permanently red because
+ * committed playwright ct files were not registered in a spec-frozen tsconfig —
+ * so a lint-fix child deleted TASK_0020's verified deliverables and the pass
+ * returned ok. Every existing guard missed the class:
+ *
+ *   - the lint-fix revert-guard checks only pre-DIRTY files reverted and
+ *     pre-UNTRACKED files gone — a CLEAN tracked sibling file is in neither set;
+ *   - the frozen-path guard covers only paths THIS task's spec froze;
+ *   - the run-11 deletion guard covers only the final-fix child;
+ *   - the impl turn legitimately deletes files (its own refactors), so a blanket
+ *     ban is wrong — the discriminator must be PROVENANCE: who introduced the file.
+ *
+ * The provenance primitive (extracted from final-gate.ts, where it fed the
+ * conflicting-claim annotation) resolves a file to the task whose commit ADDED it
+ * (`git log --diff-filter=A` → oldest task-subject commit). Every unknown — a file
+ * predating the run, a non-task commit, any git error — degrades to null:
+ * inconclusive is never evidence, so the guards built on this may only cost time,
+ * never work.
+ */
+import { spawnSync } from 'node:child_process';
+import { findForbiddenDeletions } from './write-guard.js';
+/**
+ * The task id carried by the OLDEST commit subject in `git log --diff-filter=A
+ * --format=%s` output (newest-first, so the LAST line is the original
+ * introduction — a delete-and-re-add later in history must not reattribute the
+ * file). Both the task snapshot and the ENFORCE commit shapes match the
+ * `(TASK_nnnn)` suffix. Null when the output is empty or the adding commit is
+ * not a task commit.
+ */
+export function parseIntroducingTask(logSubjects) {
+    const subjects = logSubjects.trim().split('\n').filter(Boolean);
+    const first = subjects[subjects.length - 1] ?? '';
+    const m = /\((TASK_\d+)\)\s*$/.exec(first);
+    return m ? m[1] : null;
+}
+/**
+ * The task whose commit INTRODUCED `rel`. Null when the file predates the run,
+ * was never committed, git is unavailable, or the adding commit is not a task
+ * commit — every unknown degrades to "no provenance claim".
+ */
+export function taskThatIntroduced(cwd, rel) {
+    const r = spawnSync('git', ['log', '--diff-filter=A', '--format=%s', '--', rel], {
+        cwd,
+        encoding: 'utf8'
+    });
+    if (r.error || r.status !== 0 || !r.stdout)
+        return null;
+    return parseIntroducingTask(r.stdout);
+}
+/** Same lookup through an injected async git (the lint-fix deps shape). */
+export async function taskThatIntroducedVia(git, rel) {
+    const r = await git(['log', '--diff-filter=A', '--format=%s', '--', rel]);
+    if (r.exitCode !== 0 || !r.stdout)
+        return null;
+    return parseIntroducingTask(r.stdout);
+}
+/**
+ * Deterministic cross-task deletion detection: a tracked file DELETED in the
+ * given change summary whose introducing task differs from the CURRENT task is a
+ * finding. Everything else steps aside by construction — same-task deletions and
+ * unknown provenance are never findings (a task refactoring its own work must not
+ * be blocked), an unknown CURRENT task id disables the check ("differs" cannot be
+ * established), and a relocation (the same file name reappears among the added
+ * files — write-guard's allowance) is not a deletion. `introducedBy` may be sync
+ * or async and may throw; a throw reads as unknown provenance.
+ */
+export async function findCrossTaskDeletions(changes, currentTaskId, introducedBy) {
+    const current = currentTaskId.trim();
+    if (current.length === 0)
+        return [];
+    const out = [];
+    for (const p of findForbiddenDeletions(changes)) {
+        let owner;
+        try {
+            owner = await introducedBy(p);
+        }
+        catch {
+            owner = null;
+        }
+        if (owner && owner !== current)
+            out.push({ path: p, owner });
+    }
+    return out;
+}
+/**
+ * Finding lines for the verify prompt (the substitution-probe injection pattern:
+ * the rule alone is A/B-proven ignored, the rule plus a concrete finding naming
+ * the file is what lands).
+ */
+export function crossTaskDeletionVerifyFindings(found) {
+    return found.map(f => `\`${f.path}\` — introduced and committed by ${f.owner}, DELETED by this task's work`);
+}

package/dist/task/verify-work.d.ts

@@ -1,3 +1,4 @@
+import { type CrossTaskDeletion } from './task-provenance.js';
 /**
  * The verification child gets exactly two tools: `read` and `bash`.
  *
@@ -27,6 +28,12 @@ export interface VerifyOutcome {
      *  AUTOFIX re-run, which cannot provision a missing tool. Only meaningful when
      *  ok === false. */
     unobserved?: boolean;
+    /** The deterministic cross-task deletion findings (see task-provenance.ts) that
+     *  were live when this verdict was produced: sibling tasks' committed
+     *  deliverables this task's diff deletes. Carried on a FAIL so the gate loop
+     *  can record each as a durable debt if the user ACCEPTs anyway — the deletion
+     *  then ships in the next commit and the final gate must re-check it. */
+    crossTaskDeletions?: CrossTaskDeletion[];
 }
 /**
  * Slice the delivered spec (GOAL / CONSTRAINTS / ACCEPTANCE / VERIFY) out of a
@@ -61,7 +68,7 @@ export declare function extractSpecForVerification(taskBody: string): string | n
  * Guard: honest-clean fixture (prohibition in spec, probe silent) 5/5 PASS — no
  * paranoia. Reverted-violation ≡ clean at the diff level (no entry → no finding).
  */
-export declare function buildVerifyPrompt(spec: string, probeFindings?: string[], envNotes?: string, prohibitionFindings?: string[], skipEscapeFindings?: string[], contracts?: string, testAssemblyFindings?: string[], probeGamingFindings?: string[]): string;
+export declare function buildVerifyPrompt(spec: string, probeFindings?: string[], envNotes?: string, prohibitionFindings?: string[], skipEscapeFindings?: string[], contracts?: string, testAssemblyFindings?: string[], probeGamingFindings?: string[], crossTaskDeletionFindings?: string[]): string;
 /**
  * Parse the child's verdict. Scans for the LAST `WORK-VERIFIED: PASS|FAIL|UNOBSERVED`
  * marker (the model discusses before concluding, and bash output may echo the word
@@ -130,6 +137,15 @@ export interface VerificationDeps {
      * underlying requirement is genuinely met rather than trusting the green check.
      * Pure diff-text analysis; ABSENT or empty → no probe block. */
     probeGamingProbe?: () => Promise<string[]>;
+    /**
+     * DETERMINISTIC cross-task deletion probe (see task-provenance.ts, mx5 run 12
+     * PROMPT 2): tracked files the task's diff DELETES whose introducing task (git
+     * provenance) differs from the current task — a sibling's committed deliverable
+     * destroyed, typically to green a check. Injected as prompt findings under rule
+     * 4d (MANDATORY + verdict-gating, the A/B-proven shape — buried rules score
+     * 0/5), and carried structurally on a FAIL outcome so an ACCEPT records each as
+     * a durable debt. ABSENT or empty → no block. */
+    crossTaskDeletionProbe?: () => Promise<CrossTaskDeletion[]>;
     /**
      * Result of the git-state guard for the MOST RECENT runChild call (see
      * git-state-guard.ts): did the child mutate repo state (stash/checkout/file

package/dist/task/verify-work.js

@@ -71,6 +71,7 @@ import { USER_CANCELLED } from './child-runner.js';
 import { buildEnvNotesBlock, ENV_NOTE_EMIT_INSTRUCTION, extractEnvNotes } from './env-notes.js';
 import { buildContractsVerifyBlock } from './contracts.js';
 import { findSkipEscapes, skipEscapeVerifyFindings } from './skip-escape.js';
+import { crossTaskDeletionVerifyFindings } from './task-provenance.js';
 /**
  * The verification child gets exactly two tools: `read` and `bash`.
  *
@@ -139,7 +140,7 @@ export function extractSpecForVerification(taskBody) {
  * Guard: honest-clean fixture (prohibition in spec, probe silent) 5/5 PASS — no
  * paranoia. Reverted-violation ≡ clean at the diff level (no entry → no finding).
  */
-export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFindings, skipEscapeFindings, contracts, testAssemblyFindings, probeGamingFindings) {
+export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFindings, skipEscapeFindings, contracts, testAssemblyFindings, probeGamingFindings, crossTaskDeletionFindings) {
     const probeBlock = probeFindings && probeFindings.length > 0 ?
         [
             'SELF-VERIFICATION NOTICE (deterministic, computed by the orchestrator from the diff):',
@@ -166,6 +167,22 @@ export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFind
             ''
         ]
         : [];
+    const crossTaskDeletionBlock = crossTaskDeletionFindings && crossTaskDeletionFindings.length > 0 ?
+        [
+            'CROSS-TASK DELETION NOTICE (deterministic, computed by the orchestrator from',
+            "git provenance over the task's diff): this task's work DELETED committed",
+            'deliverable(s) that a DIFFERENT, already-completed task introduced:',
+            ...crossTaskDeletionFindings.map(f => `- ${f}`),
+            "A sibling task's verified, committed deliverable is not this task's to remove.",
+            'Deleting the file a checker complains about is the cheapest way to turn a red',
+            'check green — the finding vanishes with the file — and it destroys finished',
+            'work (rule 4d). A green check suite on the shrunken tree is NOT a waiver.',
+            "Unless THIS task's spec explicitly REQUIRES removing exactly that file, the",
+            'verdict is FAIL naming the deleted file and its owning task — even if every',
+            'check passes and the deletion made them pass.',
+            ''
+        ]
+        : [];
     const probeGamingBlock = probeGamingFindings && probeGamingFindings.length > 0 ?
         [
             'CHECK-GAMING NOTICE (deterministic, computed by the orchestrator from the',
@@ -235,6 +252,7 @@ export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFind
         ...contractsBlock,
         ...probeBlock,
         ...prohibitionBlock,
+        ...crossTaskDeletionBlock,
         ...probeGamingBlock,
         ...skipEscapeBlock,
         ...testAssemblyBlock,
@@ -359,6 +377,17 @@ export function buildVerifyPrompt(spec, probeFindings, envNotes, prohibitionFind
         '   check, not implementing the behavior). If the requirement is genuinely unmet while',
         '   the check passes, the verdict is FAIL naming the gamed check and the real gap.',
         '',
+        "4d. A SIBLING TASK'S COMMITTED DELIVERABLE IS NOT THIS TASK'S TO DELETE — check the",
+        "   task's own diff (git) for DELETED tracked files. A file that a DIFFERENT completed",
+        "   task introduced and committed, deleted by this task's work, is finished work",
+        '   destroyed — usually to make a red check go green (the file the checker complains',
+        '   about simply disappears; that is quieting the messenger, rule 4c, not fixing the',
+        '   defect). A passing check suite on the shrunken tree is not a waiver. Only two',
+        "   outcomes are not a FAIL: THIS task's spec explicitly requires that removal, or",
+        '   the deletion is a genuine relocation (the same file lives on elsewhere in the',
+        '   tree). Otherwise the verdict is FAIL naming the deleted file and the task that',
+        '   owns it.',
+        '',
         '5. The ONLY thing you may assume is already provided is a genuinely EXTERNAL running',
         '   service or network resource (a database server, an API host) that the project',
         '   documents as a prerequisite. Before you rely on that assumption, PROBE for the',
@@ -531,6 +560,18 @@ export async function runWorkVerification(deps) {
             probeGaming = [];
         }
     }
+    // Cross-task deletion findings feed the prompt (rule 4d) AND ride on a FAIL
+    // outcome (structured) so an ACCEPT can record them as durable debts. A probe
+    // failure must never block verification.
+    let crossDeletions = [];
+    if (deps.crossTaskDeletionProbe) {
+        try {
+            crossDeletions = await deps.crossTaskDeletionProbe();
+        }
+        catch {
+            crossDeletions = [];
+        }
+    }
     // Environment facts from earlier gate children (best-effort; a cache failure
     // must never block verification).
     let envNotes = '';
@@ -566,7 +607,7 @@ export async function runWorkVerification(deps) {
     for (let attempt = 1;; attempt++) {
         let text;
         try {
-            text = await deps.runChild(VERIFY_TOOLS, buildVerifyPrompt(deps.spec, findings, envNotes, prohibitions, skipEscapes, contracts, testAssembly, probeGaming), deps.signal);
+            text = await deps.runChild(VERIFY_TOOLS, buildVerifyPrompt(deps.spec, findings, envNotes, prohibitions, skipEscapes, contracts, testAssembly, probeGaming, crossTaskDeletionVerifyFindings(crossDeletions)), deps.signal);
         }
         catch (err) {
             if (err instanceof Error && err.message === USER_CANCELLED)
@@ -603,15 +644,25 @@ export async function runWorkVerification(deps) {
             return { ok: true };
         if (verdict.detail === 'no verdict emitted' && attempt === 1)
             continue;
+        // Structured cross-task deletion findings ride on every FAIL outcome: if the
+        // human ACCEPTs the failing artifact, the deletions ship in the next commit
+        // and the gate loop must record each as a durable debt (see task-gates.ts).
+        const deletions = crossDeletions.length > 0 ? { crossTaskDeletions: crossDeletions } : {};
         // UNOBSERVED (rule 5c): a spec-required behavioral check could not run because
         // its tooling is absent. Block like any FAIL, but flag it so the gate hands it
         // straight to the human — re-running the impl turn cannot install a missing tool.
         if (verdict.unobserved) {
-            return { ok: false, unobserved: true, reason: `work unobserved: ${verdict.detail}` };
+            return {
+                ok: false,
+                unobserved: true,
+                reason: `work unobserved: ${verdict.detail}`,
+                ...deletions
+            };
         }
         return {
             ok: false,
-            reason: `work did not verify: ${verdict.detail}${verdict.detail === 'no verdict emitted' ? ' (after verify retry)' : ''}`
+            reason: `work did not verify: ${verdict.detail}${verdict.detail === 'no verdict emitted' ? ' (after verify retry)' : ''}`,
+            ...deletions
         };
     }
 }

package/dist/task/write-guard.d.ts

@@ -36,6 +36,16 @@ export interface TreeChangeSummary {
  * without a repo.
  */
 export declare function parseTreeChanges(porcelain: string): TreeChangeSummary;
+/**
+ * Parse `git diff --name-status` output (tab-separated: `M\tpath`, `A\tpath`,
+ * `D\tpath`, `R100\told\tnew`, `C75\told\tnew`) into the same change summary. Used
+ * where the working tree is already clean and the last COMMIT's diff is the record
+ * of the task's changes (the post-enforce re-verify fallback). A rename entry
+ * contributes its source to `deleted` and its target to `added`, matching
+ * parseTreeChanges so the relocation allowance below reads both shapes identically;
+ * a copy's source still exists, so only its target counts (as added).
+ */
+export declare function parseNameStatusChanges(nameStatus: string): TreeChangeSummary;
 /**
  * The deletions a fix pass may NOT make: every deleted tracked file whose name does
  * not reappear among the added files (a relocation keeps the file, under the same

package/dist/task/write-guard.js

@@ -75,6 +75,46 @@ export function parseTreeChanges(porcelain) {
     }
     return { modified: [...modified], deleted: [...deleted], added: [...added] };
 }
+/**
+ * Parse `git diff --name-status` output (tab-separated: `M\tpath`, `A\tpath`,
+ * `D\tpath`, `R100\told\tnew`, `C75\told\tnew`) into the same change summary. Used
+ * where the working tree is already clean and the last COMMIT's diff is the record
+ * of the task's changes (the post-enforce re-verify fallback). A rename entry
+ * contributes its source to `deleted` and its target to `added`, matching
+ * parseTreeChanges so the relocation allowance below reads both shapes identically;
+ * a copy's source still exists, so only its target counts (as added).
+ */
+export function parseNameStatusChanges(nameStatus) {
+    const modified = new Set();
+    const deleted = new Set();
+    const added = new Set();
+    for (const raw of nameStatus.split('\n')) {
+        const parts = raw.split('\t').map(s => s.trim());
+        const code = parts[0] ?? '';
+        if (code.length === 0 || !parts[1])
+            continue;
+        if (code.startsWith('R')) {
+            deleted.add(parts[1]);
+            if (parts[2])
+                added.add(parts[2]);
+            continue;
+        }
+        if (code.startsWith('C')) {
+            added.add(parts[2] ?? parts[1]);
+            continue;
+        }
+        if (code.startsWith('D')) {
+            deleted.add(parts[1]);
+            continue;
+        }
+        if (code.startsWith('A')) {
+            added.add(parts[1]);
+            continue;
+        }
+        modified.add(parts[1]);
+    }
+    return { modified: [...modified], deleted: [...deleted], added: [...added] };
+}
 const basename = (p) => {
     const i = p.lastIndexOf('/');
     return i === -1 ? p : p.slice(i + 1);

package/package.json

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