@mjasnikovs/pi-task 0.18.15 → 0.18.17

package/dist/task/requirements.js

@@ -0,0 +1,334 @@
+/**
+ * requirements — requirement-level coverage accounting for /task-auto planning
+ * (mx5 run 11, goal A).
+ *
+ * The failure this closes: the design's §10 Testing section REQUIRES test-first
+ * cadence, Playwright CT with screenshot baselines, a `test:ct` script, a
+ * separate test DB, and a `test/` dir — and got ZERO tasks and ZERO per-task
+ * injection. The coverage gate asked one holistic question ("do these tasks
+ * cover the whole feature?"), and a task list that mirrors the spec's own
+ * milestone list is structurally parity-complete, so the judge said COMPLETE in
+ * round 1. Milestone-parity coverage is structurally blind to sections that
+ * aren't milestones.
+ *
+ * Mechanism (spec-shape-agnostic, contracts.ts pattern):
+ *   1. EXTRACT requirement units as VERBATIM quotes from whatever structure the
+ *      spec has (headings, tables, bullets, prose) — each host-GROUNDED by the
+ *      normalised-substring guard, so a fabricated requirement can never enter.
+ *   2. MAP each grounded requirement against the task list (a per-requirement
+ *      verdict: TASK n / CROSS-CUTTING / NONE). Completeness is then computed
+ *      HOST-SIDE from the map — a blanket "COMPLETE" is structurally impossible
+ *      because the model must commit to a falsifiable claim per requirement.
+ *   3. CARRY what tasks don't own: cross-cutting requirements (methodology,
+ *      quality bars) are appended to `.pi-tasks/requirements.md` and injected
+ *      VERBATIM into every task's refine/compose (the REFINE_PRESERVE_DIRECTIVE
+ *      pattern: content travels, not a pointer); requirements still unmapped
+ *      after the retry rounds are recorded user-visibly, never silently dropped.
+ *
+ * Goal C rides the same channel: when the spec mandates a verification
+ * methodology ("a test lands in the same change as each new route"), that quote
+ * is exactly what gets injected, and compose's VERIFY rules fold it into every
+ * applicable task's runnable verification.
+ */
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+import { tasksDir } from './task-io.js';
+import { normalise } from './contracts.js';
+const REQUIREMENTS_FILE = 'requirements.md';
+/** Cap kept entries so the injected block stays bounded on a large design. */
+const MAX_REQUIREMENTS = 40;
+/** One line each; longer is prose, not a requirement statement. */
+const MAX_REQUIREMENT_LENGTH = 300;
+/** Too short to state an obligation (and to ground unambiguously). */
+const MIN_QUOTE_LENGTH = 6;
+export function requirementsFile(cwd) {
+    return path.join(tasksDir(cwd), REQUIREMENTS_FILE);
+}
+/** Parse `REQUIREMENT: "<quote>" [anchor: …]` lines (mirrors parseContractLines). */
+export function parseRequirementLines(text) {
+    const entries = [];
+    for (const m of text.matchAll(/^[ \t]*REQUIREMENT:[ \t]*(.+)$/gim)) {
+        const body = m[1].trim();
+        const q = /"([^"]+)"/.exec(body);
+        if (!q)
+            continue;
+        const quote = q[1].trim();
+        if (quote.length < MIN_QUOTE_LENGTH || quote.length > MAX_REQUIREMENT_LENGTH)
+            continue;
+        const a = /\[anchor:\s*([^\]]+)\]/i.exec(body);
+        entries.push({ quote, anchor: a ? a[1].trim() : '' });
+    }
+    return entries;
+}
+/** THE ANTI-SYNTHESIS GUARD: keep only entries whose quote is a normalised
+ *  substring of the source doc (same rule as keepGroundedContracts). Does NOT
+ *  cap — capping is capRequirements' job, which protects obligation-marked
+ *  passages from doc-order truncation. */
+export function keepGroundedRequirements(entries, sourceDoc) {
+    const haystack = normalise(sourceDoc);
+    const seen = new Set();
+    const kept = [];
+    for (const e of entries) {
+        const key = normalise(e.quote);
+        if (key.length === 0 || seen.has(key))
+            continue;
+        if (!haystack.includes(key))
+            continue;
+        seen.add(key);
+        kept.push(e);
+    }
+    return kept;
+}
+/**
+ * Bound the list WITHOUT doc-order truncation: measured live, an eager model
+ * extracts 40+ items top-down (every §1 decision row), so a plain first-N cap
+ * systematically drops the TAIL sections — exactly where mx5 keeps its testing
+ * obligations. Rule (deterministic priority, not a knob): entries quoting an
+ * obligation-marked passage survive first; the remainder fills in given order.
+ */
+export function capRequirements(entries, passages) {
+    if (entries.length <= MAX_REQUIREMENTS)
+        return entries;
+    const norms = passages.map(normalise);
+    const covers = (e) => {
+        const q = normalise(e.quote);
+        return norms.some(p => p.includes(q));
+    };
+    const marked = entries.filter(covers);
+    const rest = entries.filter(e => !covers(e));
+    return [...marked, ...rest].slice(0, MAX_REQUIREMENTS);
+}
+/**
+ * DETERMINISTIC RECALL FLOOR (same medicine as the launch-contract checklist):
+ * paragraphs carrying an obligation marker (word-bounded "required"/"must").
+ * Extraction recall over a 20KB doc is the weak model's, and it is variance-
+ * prone — measured live, 1 of 5 runs kept 16 quotes with ZERO §10 items. The
+ * host enumerates the marked passages; the prompt lists their head lines as a
+ * checklist, and uncoveredPassages() below turns "a marked passage produced no
+ * quote" into hard evidence for one forced re-extraction.
+ */
+export function enumerateObligationPassages(doc) {
+    const out = [];
+    // Normalise CRLF/CR → LF: a Windows-authored spec would otherwise collapse
+    // into one giant paragraph (the split marker never matches `\r\n\r\n`) and
+    // the per-obligation recall floor would enumerate nothing.
+    for (const para of doc.replace(/\r\n?/g, '\n').split(/\n[ \t]*\n/)) {
+        const p = para.trim();
+        if (p.length < MIN_QUOTE_LENGTH)
+            continue;
+        if (!/\b(required|must)\b/i.test(p))
+            continue;
+        out.push(p);
+        if (out.length >= 20)
+            break;
+    }
+    return out;
+}
+/** The head line of a passage, for compact checklist rendering. */
+function passageHead(p) {
+    const first = p.split('\n')[0].trim();
+    return first.length > 140 ? first.slice(0, 140) + '…' : first;
+}
+/** Marked passages none of the kept quotes came from — the hard evidence that
+ *  extraction recall failed there (a kept quote "covers" a passage when the
+ *  passage contains it, normalised). */
+export function uncoveredPassages(passages, kept) {
+    const keptNorm = kept.map(e => normalise(e.quote));
+    return passages.filter(p => {
+        const pn = normalise(p);
+        return !keptNorm.some(q => pn.includes(q));
+    });
+}
+/** Reprompt hint for the forced re-extraction over uncovered passages. */
+export function extractionRetryHint(uncovered) {
+    return ('[SYSTEM NOTE: Your previous answer produced NO requirement from these passages, '
+        + 'although each carries an explicit obligation marker. Re-extract the FULL '
+        + 'requirement list, making sure every obligation in each passage below is quoted '
+        + 'verbatim:\n'
+        + uncovered.map(p => `  - ${passageHead(p)}`).join('\n')
+        + ']');
+}
+/** The plan-time extraction prompt. Runs with --no-tools; every quote is
+ *  re-grounded host-side, so guessing wastes effort. Spec-shape-agnostic.
+ *  `passages` is enumerateObligationPassages' checklist ([] ⇒ prompt unchanged). */
+export const REQUIREMENT_EXTRACT_PROMPT = (feature, passages = []) => [
+    'You are recording the REQUIREMENTS of the feature/design below as VERBATIM quotes.',
+    'A requirement is anything the text OBLIGATES the finished work to have, do, or obey:',
+    'functional behavior, constraints, quality bars, security/accessibility rules, and any',
+    'MANDATED METHODOLOGY (testing cadence, verification practice, required scripts, files,',
+    'directory structures, databases). Extract from WHATEVER structure the text has —',
+    'numbered sections, tables, bullet lists, or flowing prose with no headings at all.',
+    "Pay particular attention to obligations that are NOT part of the text's main",
+    'feature/milestone structure (a "required" testing or security section, an obligation',
+    'buried mid-prose) — those are the ones downstream planning loses.',
+    '',
+    'FEATURE/DESIGN (the ONLY source — quote from it, never from your own knowledge):',
+    feature.trim(),
+    '',
+    ...(passages.length > 0 ?
+        [
+            'OBLIGATION-MARKED PASSAGES — found mechanically (they contain "required"/"must").',
+            'This checklist exists ONLY so you do not MISS one: every obligation in each of',
+            'these passages must appear among your REQUIREMENT lines. It is a floor, not a',
+            'ceiling — obligations outside these passages must be extracted too.',
+            ...passages.map(p => `  - ${p.split('\n')[0].trim().slice(0, 140)}`),
+            ''
+        ]
+        : []),
+    'For each requirement, emit exactly:',
+    '  REQUIREMENT: "<verbatim quote copied EXACTLY from the text>" [anchor: <section/heading, or prose>]',
+    'one per line. RULES: (1) the quote MUST be a literal substring of the text — do NOT',
+    'paraphrase, merge, normalise, or complete it; ungrounded quotes are DISCARDED',
+    'host-side. (2) Prefer the single sentence or line that states the obligation most',
+    'directly. (3) One obligation per line. (4) Do NOT quote examples, rationale, or',
+    'reference links. (5) Never invent a requirement the text does not state.',
+    '',
+    'Output the REQUIREMENT: lines and nothing else. If the text states no requirements,',
+    'output nothing.'
+].join('\n');
+/** Per-requirement coverage verdicts against a task list. Runs with --no-tools. */
+export const COVERAGE_MAP_PROMPT = (requirements, titles) => [
+    'Below are the REQUIRED CONTENTS of a feature (verbatim quotes mechanically grounded',
+    'in its design) and the planned TASK LIST. For EACH requirement, judge which task will',
+    'deliver it. Judge coverage, not wording — a task covers a requirement when its stated',
+    'scope would naturally include it.',
+    '',
+    'REQUIREMENTS:',
+    ...requirements.map((r, i) => `${i + 1}. "${r.quote}"${r.anchor ? ` [${r.anchor}]` : ''}`),
+    '',
+    'TASK LIST:',
+    ...titles.map((t, i) => `${i + 1}. ${t}`),
+    '',
+    'For EVERY requirement, in order, output exactly one line:',
+    '  MAP: <requirement#> -> TASK <task#>     (one task clearly owns it)',
+    '  MAP: <requirement#> -> CROSS-CUTTING    (a rule/methodology MANY tasks must each fold into their own work)',
+    '  MAP: <requirement#> -> NONE             (no task plausibly covers it)',
+    'Every requirement number must appear exactly once. Output the MAP: lines and nothing else.'
+].join('\n');
+/**
+ * Parse the mapping output. Index-aligned with `requirements` (0-based); a
+ * requirement the model skipped, or mapped to an out-of-range task, is `none` —
+ * distrust by default: an unaccounted requirement is exactly what this gate
+ * exists to surface, so parsing leniency must never manufacture coverage.
+ */
+export function parseCoverageMap(text, reqCount, taskCount) {
+    const out = Array.from({ length: reqCount }, () => ({ kind: 'none' }));
+    for (const m of text.matchAll(/^[ \t]*MAP:[ \t]*(\d+)[ \t]*(?:->|→)[ \t]*(TASK[ \t]*(\d+)|CROSS[- ]?CUTTING|NONE)/gim)) {
+        const reqIdx = parseInt(m[1], 10) - 1;
+        if (reqIdx < 0 || reqIdx >= reqCount)
+            continue;
+        const verdict = m[2].toUpperCase();
+        if (verdict.startsWith('TASK')) {
+            const t = parseInt(m[3], 10);
+            out[reqIdx] = t >= 1 && t <= taskCount ? { kind: 'task', task: t } : { kind: 'none' };
+        }
+        else if (verdict.startsWith('CROSS')) {
+            out[reqIdx] = { kind: 'cross' };
+        }
+        else {
+            out[reqIdx] = { kind: 'none' };
+        }
+    }
+    return out;
+}
+/** Deterministic accounting over the parsed map — the host, not the model,
+ *  decides completeness. */
+export function accountCoverage(requirements, mappings) {
+    const acc = { mapped: [], crossCutting: [], unmapped: [] };
+    for (let i = 0; i < requirements.length; i++) {
+        const m = mappings[i] ?? { kind: 'none' };
+        if (m.kind === 'task')
+            acc.mapped.push({ req: requirements[i], task: m.task });
+        else if (m.kind === 'cross')
+            acc.crossCutting.push(requirements[i]);
+        else
+            acc.unmapped.push(requirements[i]);
+    }
+    return acc;
+}
+// ─── The carried-requirements artifact + injection block ────────────────────
+/** The stored carried-requirements text ('' when none recorded). */
+export async function readRequirements(cwd) {
+    try {
+        return (await fsp.readFile(requirementsFile(cwd), 'utf8')).trim();
+    }
+    catch {
+        return '';
+    }
+}
+function formatEntry(e, marker) {
+    const anchor = e.anchor ? ` [anchor: ${e.anchor}]` : '';
+    return `"${e.quote}"${anchor}${marker ? ` [${marker}]` : ''}`;
+}
+/**
+ * Append carried requirements (cross-cutting, plus any left unmapped after the
+ * retry rounds — better carried into every task than silently lost), deduped
+ * against what is stored. Host-side only; children never write it. Best-effort.
+ */
+export async function appendCarriedRequirements(cwd, crossCutting, unresolved = []) {
+    if (crossCutting.length === 0 && unresolved.length === 0)
+        return;
+    try {
+        const existing = (await readRequirements(cwd)).split('\n').filter(l => l.trim().length > 0);
+        const seen = new Set(existing.map(l => {
+            const q = /"([^"]+)"/.exec(l);
+            return normalise(q ? q[1] : l);
+        }));
+        const merged = [...existing];
+        for (const [entries, marker] of [
+            [crossCutting, undefined],
+            [unresolved, 'no task owns this — surfaced at plan time']
+        ]) {
+            for (const e of entries) {
+                const key = normalise(e.quote);
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                merged.push(formatEntry(e, marker));
+            }
+        }
+        await fsp.mkdir(tasksDir(cwd), { recursive: true });
+        await fsp.writeFile(requirementsFile(cwd), merged.slice(-MAX_REQUIREMENTS).join('\n') + '\n', 'utf8');
+    }
+    catch {
+        // best-effort artifact
+    }
+}
+/**
+ * The read-only block refine/compose receive when carried requirements exist.
+ * Verbatim content travels with every task (the directive pattern that works),
+ * and the VERIFY mandate is explicit — goal C rides here.
+ */
+export function buildRequirementsBlock(requirements) {
+    if (requirements.trim().length === 0)
+        return '';
+    return [
+        'CROSS-CUTTING REQUIREMENTS — obligations the SOURCE design states that apply across',
+        'tasks (verbatim quotes; AUTHORITATIVE). No single task owns them, so EVERY task must',
+        'fold them into its own slice wherever they touch it:',
+        ...requirements
+            .trim()
+            .split('\n')
+            .map(l => `- ${l}`),
+        'For each entry that touches artifacts THIS task creates or changes (its routes,',
+        'components, pages, commands, files): deliver it IN THIS TASK as part of the same',
+        'change — e.g. a mandated test/check for a new artifact lands with that artifact —',
+        'and make ACCEPTANCE/VERIFY exercise it with runnable commands. These are never',
+        '"a later task\'s job" unless the plan names a task that owns them. Entries that do',
+        "not touch this task's slice are ignored, not restated.",
+        ''
+    ].join('\n');
+}
+/** The decompose-prompt ledger block (goal E's belt): the grounded requirement
+ *  list rides into decompose so structure-mirroring can't discharge it. */
+export function buildRequirementsLedger(requirements) {
+    if (requirements.length === 0)
+        return '';
+    return [
+        'REQUIRED CONTENT LEDGER (verbatim from the spec, mechanically grounded — the task',
+        'list must collectively carry EVERY entry, whatever structure you follow; mirroring',
+        "the spec's own milestone/section list does NOT by itself discharge these):",
+        ...requirements.map((r, i) => `${i + 1}. "${r.quote}"${r.anchor ? ` [${r.anchor}]` : ''}`),
+        ''
+    ].join('\n');
+}

package/dist/task/verify-reconcile.d.ts

@@ -0,0 +1,36 @@
+export interface AbsenceAssertion {
+    /** The verify line carrying the assertion (trimmed). */
+    line: string;
+    /** The path or grep pattern asserted absent (quotes stripped). */
+    target: string;
+    kind: 'path' | 'pattern';
+}
+/**
+ * All absence assertions in the spec's VERIFY block. Scans the fenced commands:
+ * `if` blocks whose body reaches `exit <nonzero>` contribute their condition's
+ * POSITIVE probes; other lines contribute their NEGATED probes.
+ */
+export declare function findAbsenceAssertions(spec: string): AbsenceAssertion[];
+export interface AbsenceConflict {
+    assertion: AbsenceAssertion;
+    against: 'disk' | 'sibling' | 'contract';
+    /** What it collided with (the sibling title / contract line / the path). */
+    detail: string;
+}
+export interface AbsenceConflictContext {
+    /** Does this (repo-relative) path exist in the worktree right now? */
+    fileExists: (path: string) => boolean;
+    /** SIBLING task titles only — never this task's own title. */
+    siblingTitles: string[];
+    /** The cross-slice contract registry text ('' when absent). */
+    contracts: string;
+}
+/** Absence assertions that collide with the plan: the deterministic D lever. */
+export declare function findAbsenceConflicts(spec: string, ctx: AbsenceConflictContext): AbsenceConflict[];
+/** The forced critique-rewrite defect text (skip-escape pattern: MANDATORY,
+ *  self-contained, names the reconciliation). */
+export declare function absenceProbeText(conflicts: AbsenceConflict[]): string;
+/** Parse SIBLING titles out of the scope-fence text (buildScopeFence's listing),
+ *  excluding the "(THIS STEP)" line — a task may legitimately assert about its
+ *  own deliverables. '' / undefined (bare /task, no plan) yields none. */
+export declare function siblingTitlesFromPlanContext(planContext: string | undefined): string[];

package/dist/task/verify-reconcile.js

@@ -0,0 +1,203 @@
+/**
+ * verify-reconcile — deterministic reconciliation of a spec's VERIFY assertions
+ * against the PLAN (mx5 run 11, goal D).
+ *
+ * The failure this closes: TASK_0009's composed spec carried
+ *   `if [ -f src/client/pages/admin.tsx ] || grep -rn 'Admin' src/client/pages/ …; then … exit 1`
+ * — a NEGATIVE EXISTENCE assertion on a SIBLING task's pinned deliverable
+ * (TASK_0008 shipped the admin page; the design pins the admin routes). The
+ * scope fence ("do NOT build other steps' work") leaked into the verify script
+ * as "other steps' work must be ABSENT". Verify then correctly FAILed at run
+ * end, the user accepted it as debt, and the final-gate autofix treated the
+ * debt as an instruction and `rm`'d the sibling's deliverable.
+ *
+ * A sibling's deliverable is a CLAIM about the tree this task runs in — never a
+ * valid absence target. The defect must die at SPEC time (a forced critique
+ * rewrite, the skip-escape pattern), not surface as a run-end verify-FAIL.
+ *
+ * Detection is deterministic and shape-aware for how these specs actually write
+ * absence checks (measured on the real run-11 artifacts):
+ *   - `if <cond>; then … exit 1; fi` where <cond> contains a POSITIVE existence
+ *     probe (`[ -f P ]`, `test -e P`, `grep PAT …`): P/PAT must be absent or the
+ *     verify fails.
+ *   - a standalone / `|| exit`-guarded NEGATED probe (`[ ! -f P ]`,
+ *     `test ! -f P`, `! grep PAT …`): same meaning outside an if-header.
+ * `grep -v` occurrences are filters, not probes, and are skipped.
+ *
+ * A detected absence target is a CONFLICT when the plan pins it elsewhere:
+ *   - 'disk'     — the path already exists in the worktree at spec time (a
+ *                  sibling shipped it; asserting its absence is a guaranteed
+ *                  future FAIL);
+ *   - 'sibling'  — a SIBLING task's title names it;
+ *   - 'contract' — the cross-slice contract registry quotes it.
+ * Matching: pattern targets by case-insensitive substring (all-words matching
+ * false-fires on `bun:sql` vs a "Bun SQL connection" title); path targets by
+ * full-path substring or a word-bounded basename. No similarity thresholds.
+ *
+ * The finding is a PROBE, not a gate: it forces the critique rewrite and names
+ * the reconciliation (delete-tasks legitimately assert absence — the rewrite
+ * keeps the check when the GOAL explicitly deletes the artifact).
+ */
+import { parseVerifyBlock } from './spec-validation.js';
+/** A quoted or bare shell word. */
+const SHELL_WORD = `"[^"]+"|'[^']+'|[^\\s\\]&|;)]+`;
+/** Positive existence probes: `-f P` / `-e P` / `-d P` not preceded by `!`. */
+const EXIST_RE = new RegExp(`(!?)\\s*(?:\\[\\[?\\s*)?(!?)\\s*(?:test\\s+)?(!?)\\s*-[efd]\\s+(${SHELL_WORD})`, 'g');
+/** grep probes: optional leading `!`, flags, then the first pattern argument. */
+const GREP_RE = new RegExp(`(!\\s+)?\\bgrep\\s+((?:-{1,2}[\\w=,.-]+\\s+)*)(${SHELL_WORD})`, 'g');
+function stripQuotes(w) {
+    const m = /^"(.*)"$|^'(.*)'$/.exec(w);
+    return m ? (m[1] ?? m[2] ?? '') : w;
+}
+/** Extract absence assertions from one shell fragment.
+ *  `positiveMeansAbsent` is true inside an `if …; then … exit 1` condition. */
+function assertionsInFragment(fragment, positiveMeansAbsent) {
+    const out = [];
+    const line = fragment.trim();
+    for (const m of line.matchAll(EXIST_RE)) {
+        const negated = Boolean(m[1] || m[2] || m[3]);
+        const wantsAbsent = positiveMeansAbsent ? !negated : negated;
+        if (!wantsAbsent)
+            continue;
+        const target = stripQuotes(m[4]).trim();
+        if (target.length === 0 || target.startsWith('-') || target.startsWith('$'))
+            continue;
+        out.push({ line, target, kind: 'path' });
+    }
+    for (const m of line.matchAll(GREP_RE)) {
+        const flags = m[2] ?? '';
+        if (/(?:^|\s)-\w*v|--invert-match/.test(flags))
+            continue; // a filter, not a probe
+        const negated = Boolean(m[1]);
+        const wantsAbsent = positiveMeansAbsent ? !negated : negated;
+        if (!wantsAbsent)
+            continue;
+        const target = stripQuotes(m[3]).trim();
+        if (target.length === 0 || target.startsWith('-') || target.startsWith('$'))
+            continue;
+        out.push({ line, target, kind: 'pattern' });
+    }
+    return out;
+}
+/**
+ * All absence assertions in the spec's VERIFY block. Scans the fenced commands:
+ * `if` blocks whose body reaches `exit <nonzero>` contribute their condition's
+ * POSITIVE probes; other lines contribute their NEGATED probes.
+ */
+export function findAbsenceAssertions(spec) {
+    const cmds = parseVerifyBlock(spec);
+    if (cmds === null)
+        return [];
+    const lines = cmds.map(c => c.raw);
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        const ifm = /^if\s+(.+?)(?:;\s*then\b.*)?$/.exec(lines[i]);
+        if (ifm) {
+            // Collect the block body up to the matching fi (flat scan — generated
+            // VERIFY blocks don't nest ifs; a nested one just extends the body).
+            let depth = 1;
+            let body = '';
+            let j = i + 1;
+            for (; j < lines.length && depth > 0; j++) {
+                if (/^if\b/.test(lines[j]))
+                    depth++;
+                if (/^fi\b/.test(lines[j]))
+                    depth--;
+                if (depth > 0)
+                    body += lines[j] + '\n';
+            }
+            if (/\bexit\s+[1-9]/.test(body)) {
+                out.push(...assertionsInFragment(ifm[1], true));
+            }
+            i = j - 1;
+            continue;
+        }
+        out.push(...assertionsInFragment(lines[i], false));
+    }
+    return out;
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** basename without extension: src/client/pages/admin.tsx → admin */
+function basenameSansExt(p) {
+    const base = p.split('/').pop() ?? p;
+    const dot = base.lastIndexOf('.');
+    return dot > 0 ? base.slice(0, dot) : base;
+}
+/** Does `haystack` name this target? Patterns match by ci-substring; paths by
+ *  full-path substring or word-bounded basename. */
+function namesTarget(haystack, a) {
+    const h = haystack.toLowerCase();
+    if (a.kind === 'pattern')
+        return h.includes(a.target.toLowerCase());
+    if (h.includes(a.target.toLowerCase()))
+        return true;
+    const base = basenameSansExt(a.target);
+    if (base.length === 0)
+        return false;
+    return new RegExp(`\\b${escapeRe(base)}\\b`, 'i').test(haystack);
+}
+/** Absence assertions that collide with the plan: the deterministic D lever. */
+export function findAbsenceConflicts(spec, ctx) {
+    const out = [];
+    for (const a of findAbsenceAssertions(spec)) {
+        if (a.kind === 'path' && ctx.fileExists(a.target)) {
+            out.push({ assertion: a, against: 'disk', detail: a.target });
+        }
+        for (const title of ctx.siblingTitles) {
+            if (namesTarget(title, a)) {
+                out.push({ assertion: a, against: 'sibling', detail: title });
+                break;
+            }
+        }
+        if (ctx.contracts.trim().length > 0) {
+            const line = ctx.contracts.split('\n').find(l => namesTarget(l, a));
+            if (line !== undefined) {
+                out.push({ assertion: a, against: 'contract', detail: line.trim() });
+            }
+        }
+    }
+    return out;
+}
+/** The forced critique-rewrite defect text (skip-escape pattern: MANDATORY,
+ *  self-contained, names the reconciliation). */
+export function absenceProbeText(conflicts) {
+    const what = {
+        disk: 'ALREADY EXISTS in the worktree (a prior task shipped it)',
+        sibling: "is a SIBLING task's deliverable",
+        contract: 'is pinned by a cross-slice contract'
+    };
+    const items = conflicts.map(c => `- VERIFY asserts \`${c.assertion.target}\` must be ABSENT (\`${c.assertion.line.slice(0, 120)}\`), `
+        + `but it ${what[c.against]}: ${c.detail.slice(0, 160)}`);
+    return [
+        'PLAN-CONTRADICTION FINDING (deterministic; MUST be resolved, it overrides a CLEAN triage):',
+        ...items,
+        "A sibling step's deliverable is a FACT about the tree this task runs in, never a",
+        "violation. The plan's scope fence forbids THIS task from BUILDING sibling work; it",
+        'does not make sibling work absent. A check like this is guaranteed to FAIL at run',
+        "end and misleads automated fixers into DELETING the sibling's shipped work.",
+        "REWRITE each flagged check to assert THIS task's own deliverables (what it adds or",
+        "changes). Keep an absence check ONLY if this task's GOAL explicitly deletes that",
+        "exact artifact — then say so in the check's comment."
+    ].join('\n');
+}
+/** Parse SIBLING titles out of the scope-fence text (buildScopeFence's listing),
+ *  excluding the "(THIS STEP)" line — a task may legitimately assert about its
+ *  own deliverables. '' / undefined (bare /task, no plan) yields none. */
+export function siblingTitlesFromPlanContext(planContext) {
+    if (!planContext)
+        return [];
+    const out = [];
+    for (const line of planContext.split('\n')) {
+        const m = /^\[\d+\](.*)$/.exec(line.trim());
+        if (!m)
+            continue;
+        if (m[1].startsWith(' (THIS STEP)'))
+            continue;
+        const title = m[1].trim();
+        if (title.length > 0)
+            out.push(title);
+    }
+    return out;
+}

package/dist/task/write-guard.d.ts

@@ -0,0 +1,52 @@
+/**
+ * write-guard — deterministic tree-change accounting for WRITE-CAPABLE gate
+ * children (mx5 run 11).
+ *
+ * The failure class: the final-gate autofix child (read,edit,bash) was added after
+ * the run-8 guard generation and inherited NONE of the guards the other
+ * write-capable passes carry — no diff capture, no frozen-path deny, no probe
+ * scans, free `rm`. Run 11 it deleted `src/client/pages/admin.tsx` (TASK_0008's
+ * verified deliverable) to satisfy a recorded debt claim, and the deletion was
+ * invisible: nothing even logged what the pass changed.
+ *
+ * This module is the pure half of the guard stack: parse `git status --porcelain`
+ * into a change summary (the diff-capture log line every write-capable child now
+ * gets at the gate-deps seam), and classify tracked-file DELETIONS. A fix pass
+ * exists to repair the assembled repository, not to shrink it: every tracked file
+ * is a committed task's deliverable, so deleting one is rejected outright — with
+ * one allowance, a RELOCATION (the same file name reappears as an added file
+ * elsewhere, e.g. moving a test the runner was never meant to pick up out of its
+ * glob — the legitimate fix shape from run 7). Pure text/path analysis; no git
+ * execution, no stack assumptions.
+ */
+/** What a write-capable pass changed, from `git status --porcelain`. */
+export interface TreeChangeSummary {
+    /** Tracked files modified in place (includes rename targets). */
+    modified: string[];
+    /** Tracked files deleted from the worktree/index (includes rename sources). */
+    deleted: string[];
+    /** New files: untracked (`??`) or staged adds (includes rename targets). */
+    added: string[];
+}
+/**
+ * Parse `git status --porcelain` output into the change summary. A rename entry
+ * contributes its source to `deleted` and its target to `added` (unstaged child
+ * edits show the same reality as separate ` D old` + `?? new` lines, so both
+ * shapes classify identically). Deterministic and pure so it is unit-tested
+ * without a repo.
+ */
+export declare function parseTreeChanges(porcelain: string): TreeChangeSummary;
+/**
+ * The deletions a fix pass may NOT make: every deleted tracked file whose name does
+ * not reappear among the added files (a relocation keeps the file, under the same
+ * name, somewhere in the tree). Anything returned here rejects the whole fix
+ * attempt — run 11's `rm src/client/pages/admin.tsx` had no corresponding add and
+ * destroyed a sibling task's verified deliverable.
+ */
+export declare function findForbiddenDeletions(changes: TreeChangeSummary): string[];
+/**
+ * One-line summary for the gate debug log — the diff capture every write-capable
+ * child gets so "what did this pass change" is answerable from artifacts (the
+ * run-11 `rm` left no trace outside the bash stream).
+ */
+export declare function formatTreeChanges(changes: TreeChangeSummary): string;