@mjasnikovs/pi-task 0.18.20 → 0.18.22

package/README.md

@@ -1,6 +1,6 @@
 <div align="center">
 
-![pi-task pipeline: a /task request runs through refine, research, grill, compose and critique, then the final spec is delivered to your main pi session in the same chat. Every phase boundary is persisted to .pi-tasks/TASK_NNNN.md, so the task is crash-safe and resumable.](https://raw.githubusercontent.com/mjasnikovs/pi-task/main/assets/pipeline.svg)
+![Local models drift. pi-task doesn't trust one prompt. Your ask runs through five fixed phases — refine, research, grill, compose, critique — and what comes out is a spec.](https://raw.githubusercontent.com/mjasnikovs/pi-task/main/assets/hero.svg)
 
 # pi-task
 
@@ -38,6 +38,22 @@ pi install npm:@mjasnikovs/pi-task
 
 > Requires [`pi`](https://www.npmjs.com/package/@earendil-works/pi-coding-agent) (the Earendil coding agent) ≥ 0.80.
 
+## Quickstart
+
+One change — `/task` runs it through the full pipeline and hands the finished spec back in the same chat:
+
+```
+/task add rate limiting to the /api/upload endpoint
+```
+
+A whole plan — `/task-auto` splits it into an ordered task list and runs each one through `/task`:
+
+```
+/task-auto Implement @MY_DETAILED_AND_LARGE_PLAN.md
+```
+
+`@`-mentioning a file inlines its **contents**, so point it at the design doc you already wrote — no copy-paste.
+
 ## Slash commands
 
 | Command | What it does |
@@ -54,6 +70,12 @@ pi install npm:@mjasnikovs/pi-task
 
 ## The pipeline
 
+<div align="center">
+
+![pi-task pipeline: a /task request runs through refine, research, grill, compose and critique, then the final spec is delivered to your main pi session in the same chat. Every phase boundary is persisted to .pi-tasks/TASK_NNNN.md, so the task is crash-safe and resumable.](https://raw.githubusercontent.com/mjasnikovs/pi-task/main/assets/pipeline.svg)
+
+</div>
+
 | Phase | Output section | What happens |
 | --- | --- | --- |
 | **refine** | `refined prompt` | Sharpens your raw ask into an unambiguous, self-contained statement. |

package/assets/hero.svg

@@ -0,0 +1,92 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 960 600" width="960" height="600" font-family="-apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif" role="img" aria-label="pi-task. Local models drift. pi-task doesn't trust one prompt. Your ask runs through five fixed phases — refine, research, grill, compose, critique — and what comes out is a spec.">
+  <defs>
+    <clipPath id="frame"><rect x="6" y="6" width="948" height="588" rx="18"/></clipPath>
+    <style>
+      .code { font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace; }
+      .ic   { fill:none; stroke-width:2.25; stroke-linecap:round; stroke-linejoin:round; }
+      .icf  { stroke:none; }
+      .ph   { font-size:18px; fill:#c9d1d9; }
+      .arw  { fill:none; stroke:#6e7681; stroke-width:2.07; stroke-linecap:round; stroke-linejoin:round; }
+    </style>
+  </defs>
+
+  <rect x="6" y="6" width="948" height="588" rx="18" fill="#0d1117" stroke="#30363d" stroke-width="1.5"/>
+
+  <!-- ── watermark ── -->
+  <defs>
+    <linearGradient id="mtFade" gradientUnits="userSpaceOnUse" x1="6" y1="0" x2="688" y2="0">
+      <stop offset="0" stop-color="#fff" stop-opacity="1"/>
+      <stop offset="0.55" stop-color="#fff" stop-opacity="0.9"/>
+      <stop offset="1" stop-color="#fff" stop-opacity="0"/>
+    </linearGradient>
+    <mask id="mtMask"><rect x="0" y="0" width="960" height="600" fill="url(#mtFade)"/></mask>
+  </defs>
+  <g clip-path="url(#frame)" mask="url(#mtMask)" fill="none" stroke="#a371f7" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M6.0 594.0L75.6 530.2L139.4 550.5L203.2 486.7L275.7 518.6L342.4 449.0L412.0 501.2L484.5 460.6L559.9 521.5L629.5 486.7L687.5 594.0" stroke-width="1.5" opacity="0.12"/>
+    <path d="M264.1 330.1L6.0 594.0M264.1 330.1L130.7 594.0M264.1 330.1L255.4 594.0M264.1 330.1L380.1 594.0M264.1 330.1L504.8 594.0M264.1 330.1L629.5 594.0" stroke-width="1" opacity="0.08"/>
+    <path d="M56.8 538.9L56.8 594.0M95.9 556.3L95.9 594.0M148.1 475.1L148.1 594.0M191.6 495.4L191.6 594.0M226.4 405.5L226.4 594.0M264.1 330.1L264.1 594.0M290.2 382.3L290.2 594.0M316.3 364.9L316.3 594.0M351.1 443.2L351.1 594.0M385.9 422.9L385.9 594.0M423.6 489.6L423.6 594.0M458.4 469.3L458.4 594.0M499.0 530.2L499.0 594.0M539.6 515.7L539.6 594.0M586.0 567.9L586.0 594.0" stroke-width="1" opacity="0.07"/>
+    <path d="M6.0 594.0L56.8 538.9L95.9 556.3L148.1 475.1L191.6 495.4L226.4 405.5L264.1 330.1L290.2 382.3L316.3 364.9L351.1 443.2L385.9 422.9L423.6 489.6L458.4 469.3L499.0 530.2L539.6 515.7L586.0 567.9L629.5 594.0" stroke-width="2" opacity="0.30"/>
+    <circle cx="6.0" cy="594.0" r="2.6" fill="#a371f7" stroke="none" opacity="0.34"/>
+    <circle cx="148.1" cy="475.1" r="2.6" fill="#a371f7" stroke="none" opacity="0.34"/>
+    <circle cx="264.1" cy="330.1" r="2.6" fill="#a371f7" stroke="none" opacity="0.34"/>
+    <circle cx="351.1" cy="443.2" r="2.6" fill="#a371f7" stroke="none" opacity="0.34"/>
+    <circle cx="458.4" cy="469.3" r="2.6" fill="#a371f7" stroke="none" opacity="0.34"/>
+    <circle cx="586.0" cy="567.9" r="2.6" fill="#a371f7" stroke="none" opacity="0.34"/>
+  </g>
+
+  <!-- ── logo lockup · π in a broken circle, drawn as paths (no font dependency) ── -->
+  <g transform="translate(371,59) scale(1.2500)" fill="none" stroke="#a371f7" stroke-width="2.40" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M30.18 4.98A20 20 0 1 0 41.66 14.61"/>
+    <path d="M13.5 17H34.5M19.5 17V32M28.5 17V32"/>
+  </g>
+  <text x="449" y="99" font-size="44" font-weight="700" fill="#e6edf3">pi-task</text>
+
+  <!-- ── headline ── -->
+  <text x="480" y="224" text-anchor="middle" font-size="82" font-weight="700" fill="#6e7681">Local models drift.</text>
+  <text x="480" y="319" text-anchor="middle" font-size="82" font-weight="700" fill="#e6edf3">pi-task doesn&#39;t trust</text>
+  <text x="480" y="414" text-anchor="middle" font-size="82" font-weight="700" fill="#e6edf3">one prompt.</text>
+
+  <!-- ── phase strip ── -->
+  <rect x="65" y="473" width="831" height="61" rx="30.5" fill="#161b22" fill-opacity="0.92" stroke="#30363d" stroke-width="1.5"/>
+  <g transform="translate(108,492.5) scale(0.9167)" stroke="#58a6ff">
+    <circle class="ic" cx="12" cy="12" r="10"/>
+    <path class="ic" d="M22 12h-4M6 12H2M12 6V2M12 22v-4"/>
+    <circle class="icf" cx="12" cy="12" r="2.4" fill="#58a6ff"/>
+  </g>
+  <text x="139" y="509.8" class="ph">refine</text>
+  <path class="arw" d="M195 503.5h17.2M206.6 496.8l6.7 6.7-6.7 6.7"/>
+  <g transform="translate(229,492.5) scale(0.9167)" stroke="#39c5cf">
+    <path class="ic" d="M9.56 9.83 15.44 6.67M10.1 12h4.79M9.56 14.17 15.44 17.33"/>
+    <circle class="icf" cx="5.5" cy="12" r="2.4" fill="#39c5cf"/>
+    <circle class="icf" cx="19.5" cy="4.5" r="2.1" fill="#39c5cf"/>
+    <circle class="icf" cx="19.5" cy="12" r="2.1" fill="#39c5cf"/>
+    <circle class="icf" cx="19.5" cy="19.5" r="2.1" fill="#39c5cf"/>
+  </g>
+  <text x="260" y="509.8" class="ph">research</text>
+  <path class="arw" d="M341 503.5h17.2M352.6 496.8l6.7 6.7-6.7 6.7"/>
+  <g transform="translate(375,492.5) scale(0.9167)" stroke="#d29922">
+    <path class="ic" d="M7.6 8.4a4.5 4.5 0 1 1 5.9 4.3c-.9.35-1.5 1.2-1.5 2.2v.6"/>
+    <circle class="icf" cx="12" cy="19.8" r="1.5" fill="#d29922"/>
+  </g>
+  <text x="406" y="509.8" class="ph">grill</text>
+  <path class="arw" d="M446 503.5h17.2M457.6 496.8l6.7 6.7-6.7 6.7"/>
+  <g transform="translate(480,492.5) scale(0.9167)" stroke="#3fb950">
+    <path class="ic" d="M12 2.5 22 7.5 12 12.5 2 7.5 12 2.5z"/>
+    <path class="ic" d="M2 16.5 12 21.5 22 16.5"/>
+  </g>
+  <text x="511" y="509.8" class="ph">compose</text>
+  <path class="arw" d="M597 503.5h17.2M608.5 496.8l6.7 6.7-6.7 6.7"/>
+  <g transform="translate(631,492.5) scale(0.9167)" stroke="#a371f7">
+    <path class="ic" d="M20.5 15a9 9 0 1 1-2.1-9.4L23 10"/>
+    <path class="ic" d="M23 4v6h-6"/>
+  </g>
+  <text x="662" y="509.8" class="ph">critique</text>
+  <path class="arw" d="M732 503.5h17.2M743.5 496.8l6.7 6.7-6.7 6.7"/>
+  <g transform="translate(766,492.5) scale(0.9167)" stroke="#3fb950">
+    <path class="ic" d="M14 2.5H6.5a2 2 0 0 0-2 2v15a2 2 0 0 0 2 2h11a2 2 0 0 0 2-2V8z"/>
+    <path class="ic" d="M14 2.5V8h5.5"/>
+    <path class="ic" d="M8.5 13.5h7M8.5 17.5h7"/>
+  </g>
+  <text x="797" y="509.8" class="ph" font-weight="600" fill="#3fb950">a spec</text>
+
+</svg>

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
@@ -492,17 +496,33 @@ export function buildGateDeps(params) {
                 contracts: () => readContracts(cwd2)
             });
         },
-        lintFix: (fixCtx, cwd2, taskTitle, failReason) => runBoundedLintFix({
-            cwd: cwd2,
-            signal,
-            failReason,
-            runChild: makeGateChild(fixCtx, cwd2, taskTitle, 'lint-fix', 'verify-debug.log'),
-            repoHealth: () => Promise.resolve(runRepoHealthCheck(cwd2)),
-            git: async (args) => {
-                const r = await git(cwd2, args, signal);
-                return { exitCode: r.exitCode, stdout: r.stdout };
+        lintFix: async (fixCtx, cwd2, taskTitle, taskId, failReason) => {
+            // Same frozen extraction the enforce guard and the verify rule-4b
+            // probe consume (mx5 run 12: the lint-fix child edited spec-frozen
+            // tsconfig.json because ESLint's own error text instructed it, then
+            // verify failed the TASK for that edit — the child must know the
+            // spec's do-not-touch list AND be mechanically denied it).
+            let frozenPaths = [];
+            try {
+                const { body } = await readTaskFile(cwd2, taskId);
+                frozenPaths = frozenPathsFromSpec(extractSpecForVerification(body));
             }
-        }),
+            catch {
+                // spec unreadable → no frozen paths; the guard degrades to a no-op
+            }
+            return runBoundedLintFix({
+                cwd: cwd2,
+                signal,
+                failReason,
+                runChild: makeGateChild(fixCtx, cwd2, taskTitle, 'lint-fix', 'verify-debug.log'),
+                repoHealth: () => Promise.resolve(runRepoHealthCheck(cwd2)),
+                git: async (args) => {
+                    const r = await git(cwd2, args, signal);
+                    return { exitCode: r.exitCode, stdout: r.stdout };
+                },
+                frozenPaths
+            });
+        },
         // Deterministic static check + tree helpers for the enforce pre-commit gate.
         repoHealth: cwd2 => Promise.resolve(runRepoHealthCheck(cwd2)),
         dirty: async (cwd2) => {

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

@@ -1,33 +1,3 @@
-/**
- * lint-fix — the bounded, graduated resolution for a repo-health verify FAIL.
- *
- * The failure this closes (mx5 run 3, TASK_0017): AUTOFIX's only hammer is a FULL
- * implementation re-run. For a repo-health FAIL of 10 trivial lint findings the live
- * run burned two 36–56-minute impl turns, each REGENERATING a fresh 900-line rewrite
- * that failed lint differently — the loop cannot converge because the tool is bigger
- * than the defect. Validated live on the real TASK_0017 tree: a bounded fix child
- * (read,edit,bash) reached lint-clean in 64s and 106s, 2/2.
- *
- * The same validation caught the design's failure mode: BOTH runs cheated, running
- * `git checkout -- src/test/request.ts` — REVERTING the task's uncommitted work to
- * make the findings vanish. So this pass ships with a deterministic REVERT-GUARD,
- * outcome-based (command filtering can't catch every path to the same effect):
- *
- *   - Before the child runs: snapshot the full working state (`git add -A` +
- *     `git write-tree`, then unstage) and record which files differ from HEAD.
- *   - After: any pre-existing work file now byte-identical to HEAD means the child
- *     discarded work instead of fixing it → restore the snapshot, report not-applied.
- *   - Converge check: the injected repoHealth must pass; otherwise not-applied.
- *
- * A file whose ENTIRE pre-fix diff was the lint finding (fixing it legitimately
- * restores HEAD) trips the guard conservatively — the fix is discarded and the
- * ordinary AUTOFIX picker takes over. Safe direction: the guard may only cost time,
- * never work.
- *
- * Not-applied is never terminal: the caller falls through to the existing
- * recommend → AUTOFIX/ACCEPT/dismiss picker, so this pass can only make the loop
- * faster, never change what it can decide.
- */
 export interface LintFixResult {
     /** true → findings fixed, repo health passes, work preserved. */
     ok: boolean;
@@ -41,16 +11,26 @@ 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<{
         exitCode: number;
         stdout: string;
     }>;
+    /**
+     * Paths the task's spec forbids modifying (frozenPathsFromSpec over the same
+     * composed spec verify judges). Injected into the child's prompt AND enforced
+     * deterministically post-child: a frozen path the child changed is reverted
+     * and the fix reported not-applied. Absent/empty → no-op, prior behavior.
+     */
+    frozenPaths?: string[];
 }
 /** 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";
@@ -60,14 +40,15 @@ export declare const LINT_FIX_TOOLS = "read,edit,bash";
  * an explicit ban on discarding work (both validation runs reached green via
  * `git checkout` of the work file until the guard existed).
  */
-export declare function buildLintFixPrompt(failReason: string): string;
+export declare function buildLintFixPrompt(failReason: string, frozenPaths?: string[]): string;
 /**
  * Pure guard core: which pre-existing work files did the fix pass revert to HEAD?
  * `preDirty` = files differing from HEAD before the fix; `stillDirty` = after.
  */
 export declare function revertGuardViolations(preDirty: string[], stillDirty: Set<string>): string[];
 /**
- * Run the bounded fix: snapshot → child → revert-guard → converge check. Never
- * throws for an outcome; only a child-level user cancel propagates from runChild.
+ * Run the bounded fix: snapshot → child → revert-guard → frozen-path guard →
+ * converge check. Never throws for an outcome; only a child-level user cancel
+ * propagates from runChild.
  */
 export declare function runBoundedLintFix(deps: LintFixDeps): Promise<LintFixResult>;

package/dist/task/lint-fix.js

@@ -27,7 +27,24 @@
  * Not-applied is never terminal: the caller falls through to the existing
  * recommend → AUTOFIX/ACCEPT/dismiss picker, so this pass can only make the loop
  * faster, never change what it can decide.
+ *
+ * FROZEN-PATH GUARD (mx5 run 12, TASK_0021/0022): the checker's own error text
+ * can INSTRUCT an edit to a spec-frozen file (typed ESLint: "playwright/index.ts
+ * was not found by the project … Consider either including it in the
+ * tsconfig.json") and this child complies — while the task's spec froze
+ * `tsconfig.json` and verify's rule-4b prohibition probe then fails the TASK for
+ * the gate child's edit. Two gates, contradictory rules, same file; the loop
+ * never converges (live: TASK_0021 burned all three unattended AUTOFIX rounds).
+ * Prompt framing alone is A/B-proven ~0–1/5 on the weak model (see
+ * frozen-path-guard.ts), so the deny is mechanical: the spec's frozen paths are
+ * threaded in via `frozenPaths`, injected into the prompt as a do-not-touch list
+ * (belt), and any frozen path the child still changed is deterministically
+ * reverted post-child and the fix reported not-applied (suspenders). Only paths
+ * 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.
  */
+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';
 /**
@@ -36,7 +53,20 @@ export const LINT_FIX_TOOLS = 'read,edit,bash';
  * an explicit ban on discarding work (both validation runs reached green via
  * `git checkout` of the work file until the guard existed).
  */
-export function buildLintFixPrompt(failReason) {
+export function buildLintFixPrompt(failReason, frozenPaths = []) {
+    const frozenBlock = frozenPaths.length === 0 ?
+        []
+        : [
+            '3b. HARD CONSTRAINT — SPEC-FROZEN PATHS. The task spec forbids modifying:',
+            ...frozenPaths.map(p => `   - ${p}`),
+            '   You must NOT edit, create, or delete anything at or under these paths,',
+            "   EVEN IF the checker's own error message suggests exactly that fix",
+            '   (e.g. "consider including it in the tsconfig.json"). Any change you make',
+            '   to a frozen path is detected and reverted, and the whole fix is rejected.',
+            '   If the check cannot pass without touching a frozen path, STOP and report',
+            '   LINT-FIX: BLOCKED with the reason.',
+            ''
+        ];
     return [
         'You are a bounded static-analysis fix pass. A verification gate just failed',
         `with: ${failReason}`,
@@ -59,6 +89,7 @@ export function buildLintFixPrompt(failReason) {
         '   Reverting the work would make the findings vanish — that is destroying the',
         '   task, not fixing it, and it is detected and rejected.',
         '',
+        ...frozenBlock,
         '4. Re-run the check after editing and confirm it exits 0.',
         '',
         'End with exactly one line:',
@@ -91,8 +122,21 @@ async function dirtyFiles(deps) {
         .filter(l => l.length > 0);
 }
 /**
- * Run the bounded fix: snapshot → child → revert-guard → converge check. Never
- * throws for an outcome; only a child-level user cancel propagates from runChild.
+ * Which spec-frozen paths currently show a change in `git status`? Null when git
+ * itself failed — inconclusive, not evidence (same discipline as dirtyFiles).
+ */
+async function frozenDirtySet(deps, frozen) {
+    if (frozen.length === 0)
+        return new Set();
+    const r = await deps.git(['status', '--porcelain', '--', ...frozen]);
+    if (r.exitCode !== 0)
+        return null;
+    return new Set(parseChangedFrozenFiles(r.stdout));
+}
+/**
+ * Run the bounded fix: snapshot → child → revert-guard → frozen-path guard →
+ * converge check. Never throws for an outcome; only a child-level user cancel
+ * propagates from runChild.
  */
 export async function runBoundedLintFix(deps) {
     // Snapshot the full working state as a tree object (includes untracked files),
@@ -122,8 +166,14 @@ export async function runBoundedLintFix(deps) {
             snapshot = wt.stdout.trim();
         await deps.git(['reset']);
     }
+    // FROZEN-PATH baseline: frozen paths already dirty BEFORE the child ran carry
+    // (possibly the task's own) work — the guard must never revert those, only
+    // changes the CHILD introduces on top of a clean frozen path. A git failure
+    // here disables the guard for this run (inconclusive ≠ license to revert).
+    const frozen = deps.frozenPaths ?? [];
+    const preFrozenDirty = await frozenDirtySet(deps, frozen);
     try {
-        await deps.runChild(LINT_FIX_TOOLS, buildLintFixPrompt(deps.failReason), deps.signal);
+        await deps.runChild(LINT_FIX_TOOLS, buildLintFixPrompt(deps.failReason, frozen), deps.signal);
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -174,8 +224,52 @@ export async function runBoundedLintFix(deps) {
                 + `${violations.length > 3 ? ', …' : ''}) — fix ${snapshot ? 'rolled back' : 'REJECTED but no snapshot to restore'}`
         };
     }
+    // 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
+    // text instructed the tsconfig.json edit and the child complied, 5/5 in the
+    // live A/B). Revert JUST those paths (they were clean, so HEAD == pre-state:
+    // no work can be lost) and report not-applied so the caller falls through to
+    // the ordinary recommend → AUTOFIX/ACCEPT picker. Inconclusive git (either
+    // side) → guard steps aside; the verify probe still catches what survives.
+    if (preFrozenDirty !== null) {
+        const postFrozenDirty = await frozenDirtySet(deps, frozen);
+        if (postFrozenDirty !== null) {
+            const frozenViolations = [...postFrozenDirty].filter(f => !preFrozenDirty.has(f));
+            if (frozenViolations.length > 0) {
+                const reverted = await revertFrozenPaths(frozenViolations, deps.git);
+                return {
+                    ok: false,
+                    reason: `frozen-path: fix child modified spec-frozen path(s) `
+                        + `(${frozenViolations.slice(0, 3).join(', ')}`
+                        + `${frozenViolations.length > 3 ? ', …' : ''}) — `
+                        + `${reverted.length > 0 ? 'reverted' : 'REJECTED (revert found nothing to undo)'}; `
+                        + `the static findings need a fix that respects the spec's constraints`
+                };
+            }
+        }
+    }
     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

@@ -87,7 +87,7 @@ export interface GateDeps {
      * at most once per gate sequence; not-applied falls through to the picker.
      * Absent → the loop goes straight to recommend/picker as before.
      */
-    lintFix?: (ctx: ExtensionCommandContext, cwd: string, taskTitle: string, failReason: string) => Promise<{
+    lintFix?: (ctx: ExtensionCommandContext, cwd: string, taskTitle: string, taskId: string, failReason: string) => Promise<{
         ok: boolean;
         reason?: string;
     }>;
@@ -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
@@ -98,7 +107,7 @@ export async function runGatesForTask(ctxIn, deps, p) {
             if (!lintFixAttempted && deps.lintFix && failReason.startsWith('repo health:')) {
                 lintFixAttempted = true;
                 active.ui.notify(`${p.tag}: static findings on "${p.title}" — attempting bounded lint fix…`, 'info');
-                const fix = await deps.lintFix(active, p.cwd, p.title, failReason);
+                const fix = await deps.lintFix(active, p.cwd, p.title, p.taskId, failReason);
                 await rec(`lint-fix: ${fix.ok ?
                     `applied${fix.reason ? ` (${fix.reason})` : ''} — re-verifying`
                     : `not applied (${fix.reason ?? 'failed'})`}`);
@@ -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.20",
+    "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",
@@ -85,6 +85,6 @@
         "extensions": [
             "dist/index.js"
         ],
-        "image": "https://raw.githubusercontent.com/mjasnikovs/pi-task/main/assets/pipeline.png"
+        "image": "https://raw.githubusercontent.com/mjasnikovs/pi-task/main/assets/hero.png"
     }
 }