@mjasnikovs/pi-task 0.18.21 → 0.18.22

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

@@ -6,8 +6,13 @@
  *     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.
  */
-export type DebtOrigin = 'accepted' | 'enforce-revert';
+export type DebtOrigin = 'accepted' | 'enforce-revert' | 'frozen-blocked';
 /** One recorded defect: the task, why its VERIFY failed, and how it was recorded. */
 export interface AcceptDebt {
     taskId: string;
@@ -46,6 +51,15 @@ 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>;
 /** Overwrite the ledger with exactly these records (used to prune resolved debts). */
 export declare function writeAcceptDebts(cwd: string, debts: AcceptDebt[]): Promise<void>;
 /**

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: 'enforce-revert' } : {})
+            ...(origin === 'enforce-revert' || origin === 'frozen-blocked' ?
+                { origin: origin }
+                : {})
         });
     }
     return out;
@@ -92,8 +94,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 +142,21 @@ 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'
+    });
+}
 /** Overwrite the ledger with exactly these records (used to prune resolved debts). */
 export async function writeAcceptDebts(cwd, debts) {
     try {
@@ -255,7 +272,11 @@ 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)';
+    }
+    return 'accepted despite verify-FAIL';
 }

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.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 } 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';
@@ -314,6 +314,10 @@ 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),
         // 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

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<{

package/dist/task/lint-fix.js

@@ -44,7 +44,7 @@
  * dirty with (possibly task) work is left alone, in the guard's safe direction:
  * cost time, never work.
  */
-import { parseChangedFrozenFiles, revertFrozenPaths } from './frozen-path-guard.js';
+import { parseChangedFrozenFiles, pathNamedIn, revertFrozenPaths } from './frozen-path-guard.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';
 /**
@@ -251,6 +251,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,14 @@ 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>;
     /**
      * 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,15 @@ 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);
-                }
-                catch {
-                    // recording must never break the gate sequence
+                // 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
+                    }
                 }
                 active.ui.notify(`${p.tag}: accepted "${p.title}" despite verify FAIL (${failReason.slice(0, 120)}) — proceeding.`, 'warning');
                 break;

package/package.json

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