@mjasnikovs/pi-task 0.18.21 → 0.18.23

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 } 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). */
@@ -314,6 +329,14 @@ export function buildGateDeps(params) {
         // discardEdits): the final integration gate re-checks each debt at run end.
         recordAcceptDebt: (cwd2, taskId, reason) => recordAcceptDebt(cwd2, taskId, reason),
         recordEnforceRevertDebt: (cwd2, taskId, reason) => recordEnforceRevertDebt(cwd2, taskId, reason),
+        // Durable cross-task-contradiction ledger (PROMPT 1 layer B): a repo-health
+        // 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
@@ -453,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
@@ -516,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

@@ -11,10 +11,13 @@ export interface LintFixDeps {
     failReason: string;
     /** Run the fix child; same closure shape the other gate children use. */
     runChild: (tools: string, prompt: string, signal?: AbortSignal) => Promise<string>;
-    /** The deterministic whole-repo static check to converge against. */
+    /** The deterministic whole-repo static check to converge against. `output`
+     *  (the failing command's captured text, when the impl provides it) lets the
+     *  non-convergence path trace the findings to a spec-frozen path. */
     repoHealth: () => Promise<{
         ok: boolean;
         reason: string;
+        output?: string;
     }>;
     /** Run git in cwd; injected so the guard logic is unit-testable. */
     git: (args: string[]) => Promise<{
@@ -28,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, revertFrozenPaths } from './frozen-path-guard.js';
+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
@@ -251,6 +313,25 @@ export async function runBoundedLintFix(deps) {
     }
     const health = await deps.repoHealth();
     if (!health.ok) {
+        // FROZEN-PATH TRACE on non-convergence (PROMPT 1 layer B): when the child
+        // was honest — it did NOT touch the frozen path, so the guard above never
+        // tripped — but the check is still red and its own output NAMES a frozen
+        // path (typed ESLint: "playwright/index.ts was not found by the project …
+        // consider including it in the tsconfig.json"), the findings can only be
+        // fixed by an edit this task's spec forbids. Report it under the same
+        // `frozen-path:` prefix as the guard trip, so the gate loop can route
+        // straight to the human picker instead of burning unattended AUTOFIX
+        // rounds an impl re-run under the same freeze cannot converge out of.
+        const implicated = frozen.filter(p => pathNamedIn(`${health.reason}\n${health.output ?? ''}`, p));
+        if (implicated.length > 0) {
+            return {
+                ok: false,
+                reason: `frozen-path: static findings implicate spec-frozen path(s) `
+                    + `(${implicated.slice(0, 3).join(', ')}`
+                    + `${implicated.length > 3 ? ', …' : ''}) — did not converge `
+                    + `(${health.reason}); a fix under this task's constraints cannot converge`
+            };
+        }
         return { ok: false, reason: `did not converge: ${health.reason}` };
     }
     return { ok: true, reason: guardNote };

package/dist/task/phases.d.ts

@@ -117,7 +117,7 @@ export interface PhaseAutoAnswerDeps {
 export declare function phaseAutoAnswer(deps: PhaseDeps, refined: string, research: string, question: string, autoDeps?: PhaseAutoAnswerDeps): Promise<AutoAnswer>;
 export declare function phaseGrill(deps: PhaseDeps, ctx: ExtensionCommandContext, widgetState: WidgetState, refined: string, research: string): Promise<string>;
 export declare function phaseCompose(deps: PhaseDeps, refined: string, research: string, qa: string): Promise<string>;
-export declare function phaseCritique(deps: PhaseDeps, spec: string, refined: string, qa: string, planContext?: string): Promise<string>;
+export declare function phaseCritique(deps: PhaseDeps, spec: string, refined: string, qa: string, planContext?: string, research?: string): Promise<string>;
 export declare function critiqueWithFallback(d: PhaseDeps, p: PhaseContext): Promise<string>;
 export declare const PHASES: PhaseConfig[];
 export declare function postCommitPhase(phase: PhaseConfig, deps: PhaseDeps, pc: PhaseContext, out: string): Promise<void>;

package/dist/task/phases.js

@@ -29,6 +29,7 @@ import { parseVerifyBlock, validateSpecShape, stripSpecPreamble, isCritiqueClean
 import { findSkipEscapes, skipEscapeDefectText } from './skip-escape.js';
 import { findSynthesizedWiring, wiringProbeText, readReferencedDocs } from './wiring-claims.js';
 import { findAbsenceConflicts, absenceProbeText, siblingTitlesFromPlanContext } from './verify-reconcile.js';
+import { findFrozenPathConflicts, frozenConflictProbeText } from './frozen-conflict.js';
 import { existsSync } from 'node:fs';
 import { readContracts, buildContractsBlock, buildContractsVerifyBlock } from './contracts.js';
 import { readRequirements, buildRequirementsBlock } from './requirements.js';
@@ -791,7 +792,7 @@ export async function phaseCompose(deps, refined, research, qa) {
         return { ok: true, value: stripped };
     }, problem => new Error(`compose_invalid: ${problem}`));
 }
-export async function phaseCritique(deps, spec, refined, qa, planContext) {
+export async function phaseCritique(deps, spec, refined, qa, planContext, research) {
     // Fast triage before the expensive full rewrite. The rewrite regenerates
     // the entire spec from scratch and is the costliest tail of the pipeline
     // (observed up to ~240s). Most compose drafts are already good, so we first
@@ -850,6 +851,21 @@ export async function phaseCritique(deps, spec, refined, qa, planContext) {
         deps.logDebug?.('plan-contradiction flagged in VERIFY: '
             + absenceConflicts.map(c => `${c.assertion.target} (${c.against})`).join(' | '));
     }
+    // DETERMINISTIC unsatisfiable-pair probe (mx5 run 12 root cause): a blanket
+    // frozen path ("Do NOT modify `tsconfig.json` … handled in steps 1–2") whose
+    // registration edit the spec's OWN body — or the task's RESEARCH the spec was
+    // composed from (live drafts sometimes drop the nuance while shipping the
+    // freeze and the creation) — says the deliverable requires ("must also be
+    // included …"). Shipped as-is, the created files turn the repo-wide static
+    // check permanently red and no task is allowed to fix it — every later task
+    // burns its AUTOFIX rounds on it. Forced into the rewrite like the other
+    // probes: the rewrite must grant scoped ownership or drop the creation.
+    const frozenConflicts = findFrozenPathConflicts(spec, research);
+    const frozenProbe = frozenConflicts.length > 0 ? frozenConflictProbeText(frozenConflicts) : null;
+    if (frozenProbe) {
+        deps.logDebug?.('unsatisfiable freeze/requires-edit pair flagged in spec: '
+            + frozenConflicts.map(c => c.path).join(' | '));
+    }
     let triageDefects = null;
     if (parseVerifyBlock(spec) !== null) {
         const tTriage = Date.now();
@@ -866,12 +882,15 @@ export async function phaseCritique(deps, spec, refined, qa, planContext) {
         }
         deps.recordSubStep?.('triage', Date.now() - tTriage);
         if (verdict !== null) {
-            // A deterministic skip-escape, synthesized-wiring, or plan-contradiction
-            // finding overrides a CLEAN triage: the draft must be rewritten to resolve
-            // it even if the model judged the rest clean (the model does not
-            // self-discover any of them reliably).
+            // A deterministic skip-escape, synthesized-wiring, plan-contradiction,
+            // or unsatisfiable-pair finding overrides a CLEAN triage: the draft must
+            // be rewritten to resolve it even if the model judged the rest clean
+            // (the model does not self-discover any of them reliably).
             if (isCritiqueClean(verdict)) {
-                if (skipDefects === null && wiringProbe === null && absenceProbe === null) {
+                if (skipDefects === null
+                    && wiringProbe === null
+                    && absenceProbe === null
+                    && frozenProbe === null) {
                     return spec;
                 }
             }
@@ -881,8 +900,11 @@ export async function phaseCritique(deps, spec, refined, qa, planContext) {
         }
     }
     // Merge the deterministic skip-escape + synthesized-wiring + plan-contradiction
-    // defects with any triage defects for the rewrite (all are forced FOCUS items).
-    const rewriteDefects = [skipDefects, wiringProbe, absenceProbe, triageDefects].filter(Boolean).join('\n\n') || null;
+    // + unsatisfiable-pair defects with any triage defects for the rewrite (all are
+    // forced FOCUS items).
+    const rewriteDefects = [skipDefects, wiringProbe, absenceProbe, frozenProbe, triageDefects]
+        .filter(Boolean)
+        .join('\n\n') || null;
     const tRewrite = Date.now();
     try {
         return await runWithEmphasisRetry(deps, 'critique', 'read', problem => CRITIQUE_PROMPT(spec, refined, qa, problem !== null, rewriteDefects, contractsBlock), text => {
@@ -902,7 +924,7 @@ export async function phaseCritique(deps, spec, refined, qa, planContext) {
 // ─── Critique with fallback ──────────────────────────────────────────────────
 export async function critiqueWithFallback(d, p) {
     try {
-        return await phaseCritique(d, p.spec, p.refined, p.qa, p.planContext);
+        return await phaseCritique(d, p.spec, p.refined, p.qa, p.planContext, p.research);
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);

package/dist/task/prohibition-probe.d.ts

@@ -36,6 +36,13 @@ export interface Prohibition {
      *  against the EXACT wording — including any exception clause it states. */
     constraint: string;
 }
+/**
+ * Does this line express a modification ban? Matches the active forms ("do not
+ * modify", "must not touch", "never edit", "don't change") and the passive form
+ * ("must not be modified"). Deliberately verb-scoped to modification — a "do not
+ * add a dependency" style rule names no path and is the prompt rule's job.
+ */
+export declare const PROHIBITION_RE: RegExp;
 /**
  * Extract the concrete paths the spec explicitly forbids modifying: every
  * backtick-quoted path-like token on a line that expresses a modification ban.

package/dist/task/prohibition-probe.js

@@ -4,7 +4,7 @@
  * ("must not be modified"). Deliberately verb-scoped to modification — a "do not
  * add a dependency" style rule names no path and is the prompt rule's job.
  */
-const PROHIBITION_RE = /\b(?:do\s+not|don'?t|must\s+not|never)\s+(?:be\s+)?(?:modify|modified|touch|touched|edit|edited|change|changed|alter|altered|rewrite|rewritten|overwrite|overwritten|delete|deleted|remove|removed)\b/i;
+export const PROHIBITION_RE = /\b(?:do\s+not|don'?t|must\s+not|never)\s+(?:be\s+)?(?:modify|modified|touch|touched|edit|edited|change|changed|alter|altered|rewrite|rewritten|overwrite|overwritten|delete|deleted|remove|removed)\b/i;
 /**
  * A backtick token counts as a path only when it is whitespace-free, uses path
  * characters, and either contains a directory separator, has a file extension,

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

@@ -135,6 +135,25 @@ export interface GateDeps {
      * gate re-checks and surfaces it like an accept-debt. Best-effort; absent in tests.
      */
     recordEnforceRevertDebt?: (cwd: string, taskId: string, reason: string) => Promise<void>;
+    /**
+     * Record a durable FROZEN-BLOCKED debt (mx5 run 12 / PROMPT 1 layer B): a
+     * repo-health FAIL whose only fix is an edit to a path THIS task's spec froze —
+     * a cross-task contradiction. Recorded when the loop routes such a FAIL to the
+     * picker (whatever the human then picks, the defect is real and no task may fix
+     * 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

@@ -89,6 +89,15 @@ export async function runGatesForTask(ctxIn, deps, p) {
         // auto attempts still FAIL, the picker returns so a person can break the loop.
         let lintFixAttempted = false;
         let autoFixCount = 0;
+        // Set when the bounded lint-fix reports the `frozen-path:` rejection: the
+        // repo-health FAIL can only be fixed by editing a path THIS task's spec
+        // froze (mx5 run 12's unsatisfiable registration pair). An impl re-run is
+        // under the same freeze — rule 4b fails the task if it complies with the
+        // linter — so unattended AUTOFIX rounds CANNOT converge and are skipped;
+        // the picker is forced with the cross-task contradiction named, and the
+        // defect is recorded as a durable debt for the final gate.
+        let frozenContradiction = null;
+        let frozenDebtRecorded = false;
         while (!verified.ok) {
             const failReason = verified.reason ?? 'did not verify';
             // GRADUATED resolution: a repo-health FAIL (pure static findings) gets ONE
@@ -107,6 +116,9 @@ export async function runGatesForTask(ctxIn, deps, p) {
                     await rec(verdictLine(verified));
                     continue;
                 }
+                if ((fix.reason ?? '').startsWith('frozen-path:')) {
+                    frozenContradiction = fix.reason ?? null;
+                }
             }
             // UNOBSERVED (rule 5c): a spec-required behavioral check could not run because
             // its observation tooling is absent. An unattended AUTOFIX re-run cannot install
@@ -114,14 +126,48 @@ export async function runGatesForTask(ctxIn, deps, p) {
             // decision (provision the tool, or accept the unproven behavior) is the human's.
             // Skip the (moot) recommendation research and force the picker.
             const isUnobserved = verified.unobserved === true;
+            // FROZEN-BLOCKED (cross-task contradiction): skip the recommendation
+            // research too — it would only re-derive what the deterministic lint-fix
+            // rejection already proved. The picker shows the contradiction; ACCEPT
+            // records the (already-recorded) defect as the human's call. Applies
+            // only while the FAIL is still the repo-health one the contradiction
+            // explains — a later, different FAIL gets the ordinary resolution path.
+            const isFrozenBlocked = frozenContradiction !== null && failReason.startsWith('repo health:');
             const recOutcome = isUnobserved ? { recommend: 'autofix', rationale: failReason }
-                : deps.recommend ?
-                    await deps.recommend(active, p.cwd, p.title, p.taskId, failReason)
-                    : { recommend: 'autofix', rationale: failReason };
+                : isFrozenBlocked ?
+                    {
+                        recommend: 'accept',
+                        rationale: `${frozenContradiction} — the failing static check can only be fixed by `
+                            + `editing a path this task's spec freezes (a cross-task contradiction: `
+                            + `the spec forbids the very edit the repo needs; the "owning" earlier `
+                            + `step already completed). An implementation re-run under the same `
+                            + `freeze cannot converge. ACCEPT records it as durable debt the final `
+                            + `gate re-checks; fixing it needs a plan-level change, not a re-run.`
+                    }
+                    : deps.recommend ?
+                        await deps.recommend(active, p.cwd, p.title, p.taskId, failReason)
+                        : { recommend: 'autofix', rationale: failReason };
             await rec(isUnobserved ?
                 'resolution: verify UNOBSERVED — spec-required check could not run (tooling absent); '
                     + 'forcing the human picker, an unattended re-run cannot provision it'
-                : `resolution: recommended ${recOutcome.recommend.toUpperCase()}`);
+                : isFrozenBlocked ?
+                    'resolution: repo-health FAIL is blocked by spec-frozen path(s) — cross-task '
+                        + 'contradiction; unattended AUTOFIX skipped (an impl re-run under the same '
+                        + 'freeze cannot converge), forcing the human picker'
+                    : `resolution: recommended ${recOutcome.recommend.toUpperCase()}`);
+            if (isFrozenBlocked && !frozenDebtRecorded) {
+                frozenDebtRecorded = true;
+                // Durable regardless of what the human picks next: the contradiction
+                // is real, cross-task, and outside this task's power to fix — the
+                // final gate must surface it at run end (static-class: it auto-closes
+                // iff the run-end static check passes).
+                try {
+                    await deps.recordFrozenBlockedDebt?.(p.cwd, p.taskId, `${failReason} — ${frozenContradiction}`);
+                }
+                catch {
+                    // recording must never break the gate sequence
+                }
+            }
             // AUTO-RESOLVE the AUTOFIX path: when the research says the work is
             // genuinely wrong, re-run the fix WITHOUT prompting the user. The picker is
             // reserved for the ACCEPT recommendation (the human decides whether to bless
@@ -129,6 +175,7 @@ export async function runGatesForTask(ctxIn, deps, p) {
             // MAX_AUTO_AUTOFIX consecutive unattended attempts that still FAIL, hand
             // control back so a person can break a non-converging loop.
             const autoFixNow = !isUnobserved
+                && !isFrozenBlocked
                 && recOutcome.recommend === 'autofix'
                 && autoFixCount < MAX_AUTO_AUTOFIX;
             let choice;
@@ -151,11 +198,27 @@ export async function runGatesForTask(ctxIn, deps, p) {
                 // defect ships and nothing else revisits it (mx5 run 4 B3 / run 8
                 // TASK_0012). Record it to the run ledger; the final integration gate
                 // re-checks it at run end and surfaces it if still open. Best-effort.
-                try {
-                    await deps.recordAcceptDebt?.(p.cwd, p.taskId, failReason);
+                // The frozen-blocked routing above already recorded this defect (with
+                // the contradiction named) — don't double-enter it in the ledger.
+                if (!frozenDebtRecorded) {
+                    try {
+                        await deps.recordAcceptDebt?.(p.cwd, p.taskId, failReason);
+                    }
+                    catch {
+                        // recording must never break the gate sequence
+                    }
                 }
-                catch {
-                    // 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`);
+}