@mjasnikovs/pi-task 0.18.21 → 0.18.23

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

@@ -6,8 +6,19 @@
  *     server entry point … the Hono server cannot be started"), so the terminal defect
  *     was FOUND and then erased by the very mechanism that found it. Persisted here so
  *     the final gate re-checks and surfaces it instead of letting it die with the revert.
+ *   - 'frozen-blocked' — a repo-health verify-FAIL whose only fix is an edit to a path
+ *     THIS task's spec froze (mx5 run 12: `bun run lint` permanently red because the
+ *     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';
+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;
@@ -46,6 +57,33 @@ export declare function recordAcceptDebt(cwd: string, taskId: string, reason: st
  * rather than letting it die with the revert.
  */
 export declare function recordEnforceRevertDebt(cwd: string, taskId: string, reason: string): Promise<void>;
+/**
+ * Record a FROZEN-BLOCKED debt (mx5 run 12 / PROMPT 1 layer B): a repo-health FAIL
+ * whose static findings can only be fixed by editing a path this task's spec froze —
+ * a cross-task contradiction no unattended re-run may resolve. Recorded when the gate
+ * loop routes to the picker (regardless of what the human then picks), so the final
+ * gate re-checks it at run end. Static-class by reason prefix (`repo health: …`), so
+ * 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>;
 /**
@@ -59,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,11 @@ export function parseAcceptDebts(raw) {
         out.push({
             taskId: parts[0].trim(),
             reason: parts[1].trim(),
-            ...(origin === 'enforce-revert' ? { origin: 'enforce-revert' } : {})
+            ...((origin === 'enforce-revert'
+                || origin === 'frozen-blocked'
+                || origin === 'cross-task-deletion') ?
+                { origin: origin }
+                : {})
         });
     }
     return out;
@@ -92,8 +96,8 @@ function normaliseReason(reason) {
 }
 function serialize(d) {
     // Legacy 2-field shape for 'accepted' (backward compatible); a 3rd origin field
-    // only for the enforce-revert class, so old readers/files round-trip unchanged.
-    return d.origin === 'enforce-revert' ?
+    // only for the non-accepted classes, so old readers/files round-trip unchanged.
+    return d.origin && d.origin !== 'accepted' ?
         `${d.taskId}${FIELD_SEP}${d.reason}${FIELD_SEP}${d.origin}`
         : `${d.taskId}${FIELD_SEP}${d.reason}`;
 }
@@ -140,6 +144,45 @@ export async function recordEnforceRevertDebt(cwd, taskId, reason) {
         origin: 'enforce-revert'
     });
 }
+/**
+ * Record a FROZEN-BLOCKED debt (mx5 run 12 / PROMPT 1 layer B): a repo-health FAIL
+ * whose static findings can only be fixed by editing a path this task's spec froze —
+ * a cross-task contradiction no unattended re-run may resolve. Recorded when the gate
+ * loop routes to the picker (regardless of what the human then picks), so the final
+ * gate re-checks it at run end. Static-class by reason prefix (`repo health: …`), so
+ * it auto-closes iff the final gate's own static check passes.
+ */
+export async function recordFrozenBlockedDebt(cwd, taskId, reason) {
+    await appendDebt(cwd, {
+        taskId: taskId.trim(),
+        reason: normaliseReason(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 {
@@ -167,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
@@ -255,7 +315,14 @@ export function buildAcceptDebtNote(open) {
 }
 /** One-line provenance label for a debt, for the surfaced report. */
 export function describeDebt(d) {
-    return d.origin === 'enforce-revert' ?
-        'enforce re-verify FAILED then the edits were reverted (defect indicts the ORIGINAL work, still shipped)'
-        : 'accepted despite verify-FAIL';
+    if (d.origin === 'enforce-revert') {
+        return 'enforce re-verify FAILED then the edits were reverted (defect indicts the ORIGINAL work, still shipped)';
+    }
+    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/frozen-conflict.d.ts

@@ -0,0 +1,36 @@
+/** One unsatisfiable freeze/requires-edit pair found in a composed spec. */
+export interface FrozenPathConflict {
+    /** The frozen path (normalized: no leading ./, no trailing /). */
+    path: string;
+    /** The freeze line, verbatim (the `Do NOT modify` constraint). */
+    constraint: string;
+    /** The sentence stating the deliverable requires changing that path
+     *  (or surrendering to the consequences of not being allowed to). */
+    statement: string;
+    /** Where the statement was found: the spec's own body, or the task's
+     *  research (the compose INPUT — live drafts sometimes drop the research
+     *  nuance from the spec text while the contradiction remains real). */
+    source: 'spec' | 'research';
+}
+/**
+ * Find every unsatisfiable pair in the composed spec: a BLANKET frozen path
+ * whose registration/edit is declared necessary by the spec's own body (or
+ * explicitly surrendered to), or - when `research` is given - by the task's
+ * research the spec was composed FROM. The frozen paths always come from the
+ * SPEC alone; research contributes only the statement side (live compose
+ * sometimes drops the research's "must also be included" nuance from the spec
+ * text while shipping the freeze and the file creation - the contradiction is
+ * then visible only across the compose boundary). Deterministic, pure text -
+ * the same extraction the live A/B grounds its measurements in, so the model
+ * cannot self-report its way past it. Empty on a null spec or one that froze
+ * nothing.
+ */
+export declare function findFrozenPathConflicts(spec: string | null | undefined, research?: string | null): FrozenPathConflict[];
+/**
+ * The forced critique-rewrite defect text (skip-escape pattern: MANDATORY,
+ * self-contained, names the exact resolution options). The two permitted
+ * resolutions come straight from the incident analysis: scoped ownership or
+ * dropping the creation — prose acknowledging the gap is called out as a
+ * non-resolution because that is precisely what the live model shipped.
+ */
+export declare function frozenConflictProbeText(conflicts: FrozenPathConflict[]): string;

package/dist/task/frozen-conflict.js

@@ -0,0 +1,206 @@
+/**
+ * frozen-conflict — deterministic detection of an UNSATISFIABLE spec pair at
+ * compose time (mx5 run 12 root cause, PROMPT 1 layer A).
+ *
+ * The failure this closes: compose authored TASK_0020 with a blanket freeze
+ * ("Do not modify `tsconfig.json`, `eslint.config.js`, or `.prettierrc.cjs`;
+ * those are handled in steps 1–2") while the deliverable — new
+ * `playwright-ct.config.ts` + `playwright/index.ts` — needs exactly that
+ * registration edit, and the spec "resolved" the contradiction with prose
+ * surrender ("Accept that `playwright-ct.config.ts` will not be covered by
+ * `tsc --noEmit` since `tsconfig.json` is not modified in this step"). Typed
+ * ESLint does not "accept" anything: the moment the created files land,
+ * `bun run lint` hard-errors REPO-WIDE and permanently — and the "owning"
+ * steps 1–2 completed long ago, so NO task may ever perform the edit (every
+ * spec carries the same freeze). Every subsequent task then burned its
+ * unattended AUTOFIX rounds on a repo-health FAIL none of them was allowed to
+ * fix, and the eventual "escape" was a child DELETING the deliverables.
+ *
+ * The contradiction is visible IN THE COMPOSED TEXT ITSELF, so it must die at
+ * spec time. Like the skip-escape / synthesized-wiring / plan-contradiction
+ * probes (prompt-only rules are A/B-proven ~0–1/5 on the weak model), the
+ * detector is deterministic and its finding is FORCED into the critique
+ * rewrite: the rewrite must either grant scoped ownership ("MAY edit `X` ONLY
+ * to register the files this task creates") or drop the file creation.
+ *
+ * High-precision by construction (FP-swept over the 26 real mx5 run-12 specs):
+ *   - the freeze side must be BLANKET — a `Do NOT modify` line with no
+ *     exception clause; a scoped freeze ("MAY edit … ONLY to register",
+ *     "Only edit `X` …", "… except to add …") is already the resolution shape
+ *     and must never re-fire;
+ *   - the statement side is judged per SENTENCE, not per line (real GOALs are
+ *     one giant line — line scoping false-fired on `must include` in a
+ *     response-shape sentence three paths away from the frozen one);
+ *   - a sentence that is itself prohibition-shaped ("Preserve … do not
+ *     remove or modify …") is the freeze side restated, never a statement;
+ *   - the sentence must NAME the frozen path (pathNamedIn) AND match one of
+ *     the measured phrasing families: passive registration ("must also be
+ *     included"), unless-added ("won't be type-checked unless added"),
+ *     directional active ("requires adding … to" / "must add … to"), or the
+ *     prose SURRENDER itself ("will not be covered … since `X` is not
+ *     modified" — the exact line the live TASK_0020 spec shipped).
+ * Mere co-mention never fires.
+ */
+import { extractProhibitions, PROHIBITION_RE } from './prohibition-probe.js';
+import { pathNamedIn } from './frozen-path-guard.js';
+/**
+ * A freeze that carves out its own exception is SCOPED, not blanket — it is
+ * exactly the resolution shape the probe demands ("MAY edit `X` ONLY to
+ * register…", "Only edit `X` (add the search route)…", "Do not modify `X`
+ * except to add…"), so it never counts as the freeze side of a conflict, or
+ * the recomposed spec would re-fire forever.
+ */
+const EXCEPTION_RE = /\b(?:except|unless|beyond|other\s+than|apart\s+from|only\s+(?:to|for|if|when|where|edit|modify|change|touch|update)|may\s+(?:edit|modify|change|update|add))\b/i;
+/** Passive registration: "must (also) be included/added/registered/…". */
+const PASSIVE_REG_RE = /\b(?:must|needs?\s+to|has\s+to|should)\s+(?:also\s+)?be\s+(?:includ|add|regist|list|referenc|declar|updat)\w*/i;
+/** "unless (it is) added/included/registered/updated". */
+const UNLESS_ADDED_RE = /\bunless\s+(?:it\s+is\s+|it'?s\s+|they\s+are\s+|first\s+)?(?:add|includ|regist|updat)\w*/i;
+/** "won't be type-checked/compiled/linted/covered … unless …". */
+const NOT_CHECKED_UNLESS_RE = /\b(?:won'?t|will\s+not|cannot|can'?t|does\s+not|doesn'?t|is\s+not|isn'?t)\s+(?:be\s+)?[\w\s-]{0,40}?(?:type-?check|compil|lint|cover|resolv|recogni[sz]|includ|pick)\w*[^;]{0,80}?\bunless\b/i;
+/** Directional active: "requires adding … to …" / "must add … to/into/in …".
+ *  The preposition requirement is what keeps a response-shape "must include
+ *  `field`" sentence from counting as a registration edit. */
+const REQUIRES_DIRECTIONAL_RE = /\brequires?\s+(?:add|includ|regist|updat|edit|modify|chang)\w*[^;]{0,80}?\b(?:to|into|in)\b/i;
+const MUST_ADD_DIRECTIONAL_RE = /\bmust\s+(?:also\s+)?(?:add|includ|regist|updat)\w*[^;]{0,80}?\b(?:to|into|in)\b/i;
+/** The prose-surrender pair: an artifact "will not be covered/type-checked/…"
+ *  BECAUSE the (frozen) path "is not modified". Both halves must be present —
+ *  this is the exact contradiction shape the live TASK_0020 spec shipped. */
+const NOT_COVERED_RE = /\b(?:will\s+not|won'?t|cannot|can'?t|is\s+not|isn'?t)\s+(?:be\s+)?(?:covered|type-?checked|checked|compiled|linted|validated|included)\b/i;
+const BECAUSE_NOT_MODIFIED_RE = /\b(?:since|because|as)\b[^;]{0,80}?\b(?:is\s+|are\s+|was\s+|were\s+)?not\s+(?:be(?:ing)?\s+)?(?:modif|edit|chang|updat|touch)\w*/i;
+function isRequiresEditStatement(sentence) {
+    return (PASSIVE_REG_RE.test(sentence)
+        || UNLESS_ADDED_RE.test(sentence)
+        || NOT_CHECKED_UNLESS_RE.test(sentence)
+        || REQUIRES_DIRECTIONAL_RE.test(sentence)
+        || MUST_ADD_DIRECTIONAL_RE.test(sentence)
+        || (NOT_COVERED_RE.test(sentence) && BECAUSE_NOT_MODIFIED_RE.test(sentence)));
+}
+/**
+ * Split a spec line into sentences: a `.` or `;` followed by whitespace and a
+ * capital/backtick/bracket opener ends a sentence. The opener requirement
+ * keeps `e.g. foo` and mid-path dots intact; backtick paths carry no `. ` so
+ * they never split. Judging per sentence is what makes one-giant-line GOALs
+ * scannable without cross-sentence false fires.
+ */
+function splitSentences(line) {
+    return line.split(/[.;]\s+(?=[A-Z`([-])/);
+}
+/** Backtick-quoted path-shaped tokens in a sentence (the same shape rule the
+ *  prohibition extractor applies), minus surrounding quotes. */
+function pathTokensIn(sentence) {
+    const out = [];
+    for (const m of sentence.matchAll(/`([^`]+)`/g)) {
+        const token = m[1].trim().replace(/^["']|["']$/g, '');
+        if (!/^[\w.@~/-]+$/.test(token))
+            continue;
+        if (token.includes('/') || /\.[A-Za-z0-9]+$/.test(token) || token.startsWith('.')) {
+            out.push(token);
+        }
+    }
+    return out;
+}
+/** Scan one text's sentences for requires-edit statements naming a blanket
+ *  frozen path, appending each new pair to `out`.
+ *
+ *  `anchorSpec` (research scans only): a research statement counts ONLY when,
+ *  besides the frozen path, it names at least one other path that still
+ *  appears in the SPEC. That anchor is what makes resolution (b) terminal:
+ *  when the rewrite DROPS the file creation, the created file vanishes from
+ *  the spec, the research statement about it loses its anchor, and the
+ *  detector goes quiet instead of re-firing forever on stale research. */
+function scanForStatements(text, blanket, source, out, seen, anchorSpec) {
+    for (const raw of text.split('\n')) {
+        for (const fragment of splitSentences(raw)) {
+            const sentence = fragment.trim();
+            if (sentence.length === 0)
+                continue;
+            // A prohibition-shaped sentence IS the freeze side (the constraint
+            // itself, or a "Preserve/do not remove or modify" restatement) -
+            // never the requires-edit side.
+            if (PROHIBITION_RE.test(sentence))
+                continue;
+            if (!isRequiresEditStatement(sentence))
+                continue;
+            for (const p of blanket) {
+                if (!pathNamedIn(sentence, p.path))
+                    continue;
+                if (anchorSpec !== undefined) {
+                    const anchors = pathTokensIn(sentence).filter(t => t !== p.path && !pathNamedIn(p.path, t));
+                    if (!anchors.some(a => pathNamedIn(anchorSpec, a)))
+                        continue;
+                }
+                const key = `${p.path} ${sentence}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                out.push({ path: p.path, constraint: p.constraint, statement: sentence, source });
+            }
+        }
+    }
+}
+/**
+ * Find every unsatisfiable pair in the composed spec: a BLANKET frozen path
+ * whose registration/edit is declared necessary by the spec's own body (or
+ * explicitly surrendered to), or - when `research` is given - by the task's
+ * research the spec was composed FROM. The frozen paths always come from the
+ * SPEC alone; research contributes only the statement side (live compose
+ * sometimes drops the research's "must also be included" nuance from the spec
+ * text while shipping the freeze and the file creation - the contradiction is
+ * then visible only across the compose boundary). Deterministic, pure text -
+ * the same extraction the live A/B grounds its measurements in, so the model
+ * cannot self-report its way past it. Empty on a null spec or one that froze
+ * nothing.
+ */
+export function findFrozenPathConflicts(spec, research) {
+    if (!spec)
+        return [];
+    const blanket = extractProhibitions(spec)
+        .filter(p => !EXCEPTION_RE.test(p.constraint))
+        .map(p => ({
+        path: p.path.replace(/^\.\//, '').replace(/\/+$/, ''),
+        constraint: p.constraint
+    }))
+        .filter(p => p.path.length > 0);
+    if (blanket.length === 0)
+        return [];
+    const out = [];
+    const seen = new Set();
+    scanForStatements(spec, blanket, 'spec', out, seen);
+    if (research)
+        scanForStatements(research, blanket, 'research', out, seen, spec);
+    return out;
+}
+/**
+ * The forced critique-rewrite defect text (skip-escape pattern: MANDATORY,
+ * self-contained, names the exact resolution options). The two permitted
+ * resolutions come straight from the incident analysis: scoped ownership or
+ * dropping the creation — prose acknowledging the gap is called out as a
+ * non-resolution because that is precisely what the live model shipped.
+ */
+export function frozenConflictProbeText(conflicts) {
+    const items = conflicts.map(c => `- the spec FREEZES \`${c.path}\` ("${c.constraint.slice(0, 160)}") yet `
+        + (c.source === 'research' ?
+            `the task's own RESEARCH (the input this spec was composed from) states the `
+                + `deliverable REQUIRES changing it ("${c.statement.slice(0, 160)}") — the spec `
+                + `omitting this fact does not remove the requirement`
+            : `its own body states the deliverable REQUIRES changing it `
+                + `("${c.statement.slice(0, 160)}")`));
+    return [
+        'UNSATISFIABLE-CONSTRAINT FINDING (deterministic; MUST be resolved, it overrides a CLEAN triage):',
+        ...items,
+        'This pair is self-contradictory: the files this task creates need a registration edit',
+        'that the spec itself forbids, and the step that "owns" the frozen file has already',
+        'completed — no task will ever be allowed to perform the edit. The moment the created',
+        'files land, the repo-wide static check fails PERMANENTLY and every later task burns',
+        'its autofix rounds on a defect none of them may touch. Prose acknowledging the gap',
+        '("accept that it will not be covered…") is NOT a resolution.',
+        'REWRITE the spec to resolve it in exactly ONE of these two ways:',
+        '  (a) SCOPED OWNERSHIP — replace the blanket freeze on the conflicting path with:',
+        '      "You MAY edit `<path>` ONLY to register the files this task creates (e.g. add',
+        '      them to its include list); any other change to `<path>` is forbidden." Keep the',
+        '      blanket freeze for the other frozen paths.',
+        '  (b) DROP the creation of the files that would require the frozen edit (and remove',
+        '      the acceptance/verify steps that depend on them), stating why.',
+        'Never ship both the blanket freeze and the requires-edit statement.'
+    ].join('\n');
+}

package/dist/task/frozen-path-guard.d.ts

@@ -11,6 +11,15 @@ export type FrozenGit = (args: string[]) => Promise<{
  * no-op by construction.
  */
 export declare function frozenPathsFromSpec(spec: string | null | undefined): string[];
+/**
+ * Does this prose/tool-output text NAME the given path? Word-bounded on both
+ * sides so `tsconfig.json` matches `` `tsconfig.json` ``, `(tsconfig.json:18)`
+ * and a bare mention, but never `foo.tsconfig.json`, `config/tsconfig.json`
+ * (a different file) or `tsconfig.json5`/`tsconfig.json.bak`. Shared by the
+ * compose-time unsatisfiable-pair detector (frozen-conflict.ts) and lint-fix's
+ * non-convergence trace, so "the text names a frozen path" means one thing.
+ */
+export declare function pathNamedIn(text: string, path: string): boolean;
 /**
  * Parse `git status --porcelain` output (already scoped to the frozen pathspec)
  * into the list of changed files, for the gate-trail record and to decide whether

package/dist/task/frozen-path-guard.js

@@ -48,6 +48,21 @@ export function frozenPathsFromSpec(spec) {
     }
     return [...seen];
 }
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * Does this prose/tool-output text NAME the given path? Word-bounded on both
+ * sides so `tsconfig.json` matches `` `tsconfig.json` ``, `(tsconfig.json:18)`
+ * and a bare mention, but never `foo.tsconfig.json`, `config/tsconfig.json`
+ * (a different file) or `tsconfig.json5`/`tsconfig.json.bak`. Shared by the
+ * compose-time unsatisfiable-pair detector (frozen-conflict.ts) and lint-fix's
+ * non-convergence trace, so "the text names a frozen path" means one thing.
+ */
+export function pathNamedIn(text, path) {
+    const p = path.replace(/^\.\//, '').replace(/\/+$/, '');
+    if (p.length === 0)
+        return false;
+    return new RegExp(`(?:^|[^\\w./-])${escapeRe(p)}(?!\\.?[\\w-])`, 'im').test(text);
+}
 /**
  * Parse `git status --porcelain` output (already scoped to the frozen pathspec)
  * into the list of changed files, for the gate-trail record and to decide whether

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