@mjasnikovs/pi-task 0.18.22 → 0.18.23

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

@@ -1,6 +1,7 @@
 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;
@@ -140,14 +141,7 @@ 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
@@ -155,4 +149,3 @@ export declare function taskThatIntroduced(cwd: string, rel: string): string | n
  * First real failure wins.
  */
 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,27 +587,10 @@ 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
@@ -624,7 +608,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);

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.23",
     "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",