@mjasnikovs/pi-task 0.32.0 → 0.34.0

package/dist/task/phases.d.ts

@@ -158,6 +158,27 @@ 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>;
+/**
+ * A refutation is a DELETION. Where the run's own research explicitly says a
+ * dependency refine invented is not needed, drop that token from CONSTRAINTS —
+ * compose cannot forbid the design's own API "because the refined task
+ * explicitly requires `argon2`" if the refined task no longer requires it.
+ *
+ * Applied to the REFINED TASK ITSELF, not to compose's copy of it, and that is
+ * load-bearing: critique receives the refined task as GROUND TRUTH and is told
+ * its CONSTRAINTS "MUST be preserved in spirit — do not silently drop or weaken
+ * them", so a deletion visible only to compose is restored one phase later. Both
+ * spec-producing phases have to see the same text.
+ *
+ * Purely subtractive and never touches an owned line (task/refuted-constraint.ts).
+ * Idempotent, so a resumed run re-deriving `refined` from the task file lands in
+ * the same place. The task file's `## refined prompt` is deliberately left as
+ * refine wrote it; the drop is recorded on the `## gates` trail with both source
+ * lines quoted, so the decision stays auditable after the fact.
+ *
+ * STEP 0 `scripts/refuted-constraint-baserate.ts`; A/B-1 `…-ab.ts` (PASS).
+ */
+export declare function dropRefutedConstraints(deps: PhaseDeps, 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, research?: string, 
 /**

package/dist/task/phases.js

@@ -23,7 +23,8 @@ import { resolve } from 'node:path';
 import { formatServiceBlock, formatFreshnessSkippedBlock } from './service-blocks.js';
 import { gatherExternalContext } from './external-context.js';
 import { REFINE_PROMPT, RESEARCH_FILES_PROMPT, RESEARCH_APIS_PROMPT, RESEARCH_CONTEXT_PROMPT, RESEARCH_TOOLING_PROMPT, GRILL_GEN_PROMPT, GRILL_AUTO_ANSWER_PROMPT, GRILL_AUTO_FORMAT_HINT, COMPOSE_PROMPT, CRITIQUE_PROMPT, CRITIQUE_TRIAGE_PROMPT, VERIFY_TOOLING_PROMPT, MAX_GRILL_QUESTIONS, appendNoThink } from './prompts.js';
-import { readSection, removeTaskSection, setTaskSection, updateTaskFrontMatter } from './task-io.js';
+import { appendGateRecord, readSection, removeTaskSection, setTaskSection, updateTaskFrontMatter } from './task-io.js';
+import { applyRefutations } from './refuted-constraint.js';
 import { spawnSync } from 'node:child_process';
 import { renderInlineMarkdown, stripInlineMarkdown } from './inline-markdown.js';
 import { isDuplicateQuestion, MAX_DUP_STRIKES, DUP_REPROMPT_HINT } from './question-dedup.js';
@@ -639,13 +640,21 @@ export async function phaseResearch(deps, refined, researchDeps = {}) {
     // the pattern nexxtasks exists to prevent. To re-run the experiment, restore the block
     // this comment replaces — see the git history of this file and the PROMPT 4 entry in
     // nexxtasks.txt RESULTS.
-    // nexttask 5B fan-out bounds. Both read their env ONCE per research phase, so
-    // every worker in a run sees the same policy and a harness cannot half-apply
-    // an arm; both are null in the shipped configuration.
+    // nexttask 5B fan-out bounds. All four read their env ONCE per research
+    // phase, so every worker in a run sees the same policy and a harness cannot
+    // half-apply an arm. CAP, SCALE and carry-forward are null/false in the
+    // shipped configuration; the progress deadline shipped ON (nexttask 9).
     const fanoutBudget = projectDocsBudget();
     const fanoutTimeout = fanoutTimeoutPolicy();
     const carryForward = workerCarryForward();
     const progressCeilingMs = workerProgressCeilingMs();
+    // Which deadline policy was in force is a fact about how every number below
+    // was produced. Run 18's 120 discarded minutes were only recoverable because
+    // 5A started writing down what the workers actually did; a run whose logs do
+    // not say which policy it ran under cannot be compared with one that does.
+    deps.logDebug?.(progressCeilingMs === null ?
+        'phase:research: worker deadline = fixed elapsed cap (progress deadline DISABLED)'
+        : `phase:research: worker deadline = no-progress, ceiling ${progressCeilingMs}ms`);
     let doneCount = 0;
     const updateProgress = () => {
         doneCount++;
@@ -842,9 +851,11 @@ export async function phaseResearch(deps, refined, researchDeps = {}) {
             // 5B SCALE arm — null unless both env vars are set. Only the
             // docs-capable worker can fan out, so only it can be scaled.
             ...(spec.fanoutBounded && fanoutTimeout ? { fanoutTimeout } : {}),
-            // 5B RESCUE arm — off unless its env vars are set. Applies to
-            // EVERY research worker, not just the docs-capable one: any
-            // worker that gets killed loses its work the same way.
+            // 5B RESCUE. Applies to EVERY research worker, not just the
+            // docs-capable one: any worker that gets killed loses its work
+            // the same way. carry-forward stays OFF unless asked for
+            // (measured harmful on its own); the progress deadline SHIPPED
+            // ON in nexttask 9 and is null only when explicitly disabled.
             ...(carryForward ? { carryForward: true } : {}),
             ...(progressCeilingMs !== null ?
                 { progressTimeoutCeilingMs: progressCeilingMs }
@@ -1324,6 +1335,36 @@ export async function phaseGrill(deps, ctx, widgetState, refined, research) {
         return '(no questions produced)';
     return out.join('\n');
 }
+/**
+ * A refutation is a DELETION. Where the run's own research explicitly says a
+ * dependency refine invented is not needed, drop that token from CONSTRAINTS —
+ * compose cannot forbid the design's own API "because the refined task
+ * explicitly requires `argon2`" if the refined task no longer requires it.
+ *
+ * Applied to the REFINED TASK ITSELF, not to compose's copy of it, and that is
+ * load-bearing: critique receives the refined task as GROUND TRUTH and is told
+ * its CONSTRAINTS "MUST be preserved in spirit — do not silently drop or weaken
+ * them", so a deletion visible only to compose is restored one phase later. Both
+ * spec-producing phases have to see the same text.
+ *
+ * Purely subtractive and never touches an owned line (task/refuted-constraint.ts).
+ * Idempotent, so a resumed run re-deriving `refined` from the task file lands in
+ * the same place. The task file's `## refined prompt` is deliberately left as
+ * refine wrote it; the drop is recorded on the `## gates` trail with both source
+ * lines quoted, so the decision stays auditable after the fact.
+ *
+ * STEP 0 `scripts/refuted-constraint-baserate.ts`; A/B-1 `…-ab.ts` (PASS).
+ */
+export async function dropRefutedConstraints(deps, refined, research) {
+    const refuted = applyRefutations(refined, research);
+    if (refuted.trail.length === 0)
+        return refined;
+    for (const line of refuted.trail) {
+        deps.logDebug?.(`compose: ${line}`);
+        await appendGateRecord(deps.cwd, deps.taskId, line).catch(() => { });
+    }
+    return refuted.refined;
+}
 export async function phaseCompose(deps, refined, research, qa) {
     // CLAIM before the belt is built: an obligation an earlier task had to
     // detach (its own spec froze the only file that could satisfy it) becomes
@@ -1627,7 +1668,10 @@ export const PHASES = [
         name: 'compose',
         section: 'spec',
         field: 'spec',
-        run: (d, p) => phaseCompose(d, p.refined, p.research, p.qa)
+        run: async (d, p) => {
+            p.refined = await dropRefutedConstraints(d, p.refined, p.research);
+            return await phaseCompose(d, p.refined, p.research, p.qa);
+        }
     },
     {
         name: 'critique',

package/dist/task/refuted-constraint.d.ts

@@ -0,0 +1,82 @@
+/**
+ * A refutation is a DELETION, not an addition.
+ *
+ * THE LEAD (mx5 run 19, `~/hub/mx5 @ dfbdd6f`, TASK_0001). Refine invented a
+ * dependency the design explicitly rules out; the run's own research said so, in
+ * writing, in the same file; the composed spec then turned the invention into a
+ * capitalised prohibition against the design's own API:
+ *
+ *   :21   refine CONSTRAINTS   "Add only new entries the task requires (e.g.,
+ *                              `hono`, `bun-sql`-equivalent, …, `argon2`, …)"
+ *   :92   research CONTEXT     "Password hashing uses `Bun.password` (built-in
+ *                              argon2id) — no external `argon2` or
+ *                              `@node-rs/argon2` dependency needed despite the
+ *                              task's mention of it."
+ *   :132  spec CONSTRAINTS     "Do NOT use built-in `Bun.password` for hashing —
+ *                              the refined task explicitly requires `argon2`."
+ *
+ * `argon2@^0.41.0` shipped as a runtime dependency of a repo that never imports
+ * it, locked in by a VERIFY assertion, next to a spec telling the next
+ * implementer not to use `Bun.sql` — the API the whole data layer is built on.
+ *
+ * This is `memory/phantom-correction-additive-not-subtractive.md` at spec scale:
+ * the correction was APPENDED to research CONTEXT while the wrong text stayed in
+ * refine's CONSTRAINTS, and CONSTRAINTS is what the implementer is told is
+ * authoritative.
+ *
+ * THE LEVER. Deterministic detection, then a scoped removal, BEFORE compose sees
+ * the refined task. Never a model rewrite: every model-rewrite lever at this seam
+ * has resolved contradictions by deleting the AUTHORITATIVE side
+ * (`memory/owned-freeze-critique-lever-refuted.md`, 11/20). This pass can only
+ * delete a refine-invented token, and can never touch an owned line.
+ *
+ * The match is lexical, never semantic: a research CONTEXT bullet refutes a
+ * refine constraint when it carries one of a closed set of negation-of-need
+ * shapes AROUND a backticked token, and that same token appears backticked in a
+ * refine CONSTRAINTS line. Both sides are already separate strings in the task
+ * file.
+ *
+ * STEP 0 (`scripts/refuted-constraint-baserate.ts`) measured the closed set over
+ * every recorded task file in the corpus before any of it was wired.
+ */
+export type Refutation = {
+    /** The token as it appears inside the backticks, e.g. `argon2`. */
+    token: string;
+    /** Index into the refined prompt's lines. */
+    line: number;
+    /** The refine CONSTRAINTS line, verbatim, before the drop. */
+    constraint: string;
+    /** The research CONTEXT bullet that refutes it, verbatim. */
+    research: string;
+    /** Which member of the closed negation set fired. */
+    pattern: string;
+};
+/** Section body between a bare ALL-CAPS header and the next one (or EOF). */
+export declare function extractCapsSection(text: string, heading: string): string | null;
+/**
+ * Find every (refine constraint line, research refutation bullet, shared token)
+ * triple. `refined` is the refined prompt, `research` the research output; both
+ * are the exact strings compose is handed.
+ */
+export declare function detectRefutations(refined: string, research: string): Refutation[];
+/**
+ * Delete one token from a constraint line: the backticked span, any word-suffix
+ * glued to it (`` `bun-sql` ``-equivalent), and ONE adjacent list separator —
+ * the preceding one where there is one, so the list keeps its shape.
+ *
+ * Returns null when nothing but boilerplate would be left, which the caller
+ * turns into a whole-line drop. Never rephrases, never adds a character.
+ */
+export declare function dropToken(line: string, token: string): string | null;
+export type RefutationResult = {
+    /** The refined prompt with every refuted token deleted. */
+    refined: string;
+    /** One trail line per drop, both source lines quoted. */
+    trail: string[];
+    refutations: Refutation[];
+};
+/**
+ * Apply every detected refutation to the refined prompt. Purely subtractive: the
+ * result is always a character subsequence of the input (`inv-no-line-invention`).
+ */
+export declare function applyRefutations(refined: string, research: string): RefutationResult;

package/dist/task/refuted-constraint.js

@@ -0,0 +1,281 @@
+/**
+ * A refutation is a DELETION, not an addition.
+ *
+ * THE LEAD (mx5 run 19, `~/hub/mx5 @ dfbdd6f`, TASK_0001). Refine invented a
+ * dependency the design explicitly rules out; the run's own research said so, in
+ * writing, in the same file; the composed spec then turned the invention into a
+ * capitalised prohibition against the design's own API:
+ *
+ *   :21   refine CONSTRAINTS   "Add only new entries the task requires (e.g.,
+ *                              `hono`, `bun-sql`-equivalent, …, `argon2`, …)"
+ *   :92   research CONTEXT     "Password hashing uses `Bun.password` (built-in
+ *                              argon2id) — no external `argon2` or
+ *                              `@node-rs/argon2` dependency needed despite the
+ *                              task's mention of it."
+ *   :132  spec CONSTRAINTS     "Do NOT use built-in `Bun.password` for hashing —
+ *                              the refined task explicitly requires `argon2`."
+ *
+ * `argon2@^0.41.0` shipped as a runtime dependency of a repo that never imports
+ * it, locked in by a VERIFY assertion, next to a spec telling the next
+ * implementer not to use `Bun.sql` — the API the whole data layer is built on.
+ *
+ * This is `memory/phantom-correction-additive-not-subtractive.md` at spec scale:
+ * the correction was APPENDED to research CONTEXT while the wrong text stayed in
+ * refine's CONSTRAINTS, and CONSTRAINTS is what the implementer is told is
+ * authoritative.
+ *
+ * THE LEVER. Deterministic detection, then a scoped removal, BEFORE compose sees
+ * the refined task. Never a model rewrite: every model-rewrite lever at this seam
+ * has resolved contradictions by deleting the AUTHORITATIVE side
+ * (`memory/owned-freeze-critique-lever-refuted.md`, 11/20). This pass can only
+ * delete a refine-invented token, and can never touch an owned line.
+ *
+ * The match is lexical, never semantic: a research CONTEXT bullet refutes a
+ * refine constraint when it carries one of a closed set of negation-of-need
+ * shapes AROUND a backticked token, and that same token appears backticked in a
+ * refine CONSTRAINTS line. Both sides are already separate strings in the task
+ * file.
+ *
+ * STEP 0 (`scripts/refuted-constraint-baserate.ts`) measured the closed set over
+ * every recorded task file in the corpus before any of it was wired.
+ */
+/** Bare ALL-CAPS section header, the boundary convention used across the
+ *  refined prompt and every research section. */
+const HEADER = /^[A-Z][A-Z -]*$/;
+/** A backticked run with no whitespace inside — the only thing this pass will
+ *  ever treat as a token. */
+const TOKEN = '`[^`\\s]+`';
+/** One token, or a list of them joined by `,` / `or` / `and`. */
+const TOKEN_LIST = `${TOKEN}(?:(?:\\s*,\\s*|\\s+or\\s+|\\s+and\\s+)${TOKEN})*`;
+/**
+ * The closed negation set. Each pattern anchors the token list INSIDE the
+ * negation, so a bullet that names one package negatively and another positively
+ * ("no `@node-rs/argon2` dependency — we use `argon2`") can only ever refute the
+ * one inside the phrase.
+ *
+ * Kept deliberately small. `inv-precision` is a FAIL of the whole task on one
+ * false drop, so a shape earns its place here only by surviving a hand-read of
+ * every corpus hit it produces.
+ */
+const NEGATIONS = [
+    {
+        // "no external `argon2` or `@node-rs/argon2` dependency needed" — THE LEAD
+        name: 'no-external-dep-needed',
+        re: new RegExp(`\\bno\\s+external\\s+(${TOKEN_LIST})\\s+(?:\\w+\\s+){0,2}dependenc(?:y|ies)\\b[^.;]{0,40}?\\b(?:needed|required)\\b`, 'i')
+    },
+    {
+        // "no `bun-sql` npm package exists"
+        name: 'no-package-exists',
+        re: new RegExp(`\\bno\\s+(${TOKEN_LIST})\\s+(?:npm\\s+)?(?:package|module)\\s+exists\\b`, 'i')
+    },
+    {
+        // "no `argon2` dependency is needed".
+        //
+        // The trailing need-negation is NOT optional, and STEP 0 is why. The
+        // first cut of this pattern was the bare "no `X` dependency", and it
+        // fired 300 times in 306 corpus hits — every one of them on a
+        // MANIFEST-STATE bullet that says the exact opposite of a refutation:
+        //
+        //   "`package.json` currently lists no `hono` or `@hono/zod-validator`
+        //    dependencies; they MUST BE ADDED at versions 4.12.27 and 0.8.0"
+        //   "`package.json` has … and no `sharp` dependency — MUST ADD `sharp`
+        //    as devDependency"
+        //
+        // Dropping on that signal mutilated real constraints ("use  with the
+        // shared `loginSchema`"). "The repo does not have X yet" is a fact about
+        // the tree; "X is not needed" is a claim about the task. Only the second
+        // one refutes anything.
+        name: 'no-dep-needed',
+        re: new RegExp(`\\bno\\s+(${TOKEN_LIST})\\s+dependenc(?:y|ies)\\s+(?:is\\s+|are\\s+)?(?:needed|required|necessary)\\b`, 'i')
+    },
+    // The two shapes below name no dependency noun of their own, so they carry a
+    // DEP_WORD guard. STEP 0's near-miss census is the reason: "does not require"
+    // appears in 412 corpus CONTEXT bullets, and the shape is overwhelmingly
+    // prose about behaviour, not dependencies — "the `GET /api/listings`
+    // endpoint does NOT require authentication for the `mine` filter". Token
+    // adjacency alone would eventually reach a backticked API expression there.
+    {
+        // "`argon2` is not needed" / "`argon2` and `sharp` are not required"
+        name: 'not-needed',
+        re: new RegExp(`(${TOKEN_LIST})\\s+(?:is|are)\\s+not\\s+(?:needed|required)\\b`, 'i'),
+        needsDepWord: true
+    },
+    {
+        // "does not require `argon2`"
+        name: 'does-not-require',
+        re: new RegExp(`\\b(?:does|do)\\s+not\\s+require\\s+(${TOKEN_LIST})`, 'i'),
+        needsDepWord: true
+    }
+];
+/** The claim has to be ABOUT a dependency for a dependency to be dropped. */
+const DEP_WORD = /\bdependenc(?:y|ies)\b|\bnpm\b|\bpackages?\b|\bdevDependenc(?:y|ies)\b/i;
+/** The owned-requirement stamp (requirements.ts:813). A line carrying it is a
+ *  design-sourced obligation and is NEVER refutable by research — this is the
+ *  guard that keeps this pass out of nexttask 2's failure mode. */
+const OWNED_MARKER = 'owned requirement from the source design';
+/** Section body between a bare ALL-CAPS header and the next one (or EOF). */
+export function extractCapsSection(text, heading) {
+    const lines = text.split('\n');
+    const start = lines.findIndex(l => l.trim() === heading);
+    if (start === -1)
+        return null;
+    const rest = lines.slice(start + 1);
+    const end = rest.findIndex(l => HEADER.test(l.trim()) && l.trim().length > 1);
+    return (end === -1 ? rest : rest.slice(0, end)).join('\n');
+}
+function tokensIn(span) {
+    return [...span.matchAll(/`([^`\s]+)`/g)].map(m => m[1]);
+}
+/**
+ * Does this look like a package/module name at all? Refutations are about
+ * DEPENDENCIES; a backticked prose fragment, a path, or an API expression is not
+ * one, and dropping it from a constraint would be a semantic edit.
+ */
+function isPackageToken(tok) {
+    if (tok.length > 64)
+        return false;
+    if (!/^@?[a-z0-9][a-z0-9._/-]*$/i.test(tok))
+        return false;
+    // `Bun.password`, `p.dependencies` — dotted API expressions, not packages.
+    if (/^[A-Z]/.test(tok))
+        return false;
+    return true;
+}
+/** Every research CONTEXT bullet, one entry per bullet (continuations joined). */
+function bullets(section) {
+    const out = [];
+    for (const raw of section.split('\n')) {
+        const line = raw.trimEnd();
+        if (!line.trim())
+            continue;
+        if (/^\s*[-*]\s+/.test(line))
+            out.push(line.trim());
+        else if (out.length > 0)
+            out[out.length - 1] += ` ${line.trim()}`;
+    }
+    return out.length > 0 ? out : section.split('\n').filter(l => l.trim());
+}
+/**
+ * Find every (refine constraint line, research refutation bullet, shared token)
+ * triple. `refined` is the refined prompt, `research` the research output; both
+ * are the exact strings compose is handed.
+ */
+export function detectRefutations(refined, research) {
+    const constraintsBody = extractCapsSection(refined, 'CONSTRAINTS');
+    const contextBody = extractCapsSection(research, 'CONTEXT');
+    if (constraintsBody === null || contextBody === null)
+        return [];
+    // Refuted token → the bullet that refuted it, and the pattern that fired.
+    const refuted = new Map();
+    for (const bullet of bullets(contextBody)) {
+        for (const { name, re, needsDepWord } of NEGATIONS) {
+            const m = re.exec(bullet);
+            if (!m)
+                continue;
+            if (needsDepWord && !DEP_WORD.test(bullet))
+                continue;
+            for (const tok of tokensIn(m[1])) {
+                if (!isPackageToken(tok))
+                    continue;
+                if (!refuted.has(tok))
+                    refuted.set(tok, { research: bullet, pattern: name });
+            }
+        }
+    }
+    if (refuted.size === 0)
+        return [];
+    const lines = refined.split('\n');
+    const constraintStart = lines.findIndex(l => l.trim() === 'CONSTRAINTS');
+    const out = [];
+    for (let i = constraintStart + 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (HEADER.test(line.trim()) && line.trim().length > 1)
+            break;
+        if (line.includes(OWNED_MARKER))
+            continue;
+        for (const [tok, src] of refuted) {
+            if (!new RegExp(`\`${escapeRe(tok)}\``).test(line))
+                continue;
+            out.push({
+                token: tok,
+                line: i,
+                constraint: line,
+                research: src.research,
+                pattern: src.pattern
+            });
+        }
+    }
+    return out;
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Delete one token from a constraint line: the backticked span, any word-suffix
+ * glued to it (`` `bun-sql` ``-equivalent), and ONE adjacent list separator —
+ * the preceding one where there is one, so the list keeps its shape.
+ *
+ * Returns null when nothing but boilerplate would be left, which the caller
+ * turns into a whole-line drop. Never rephrases, never adds a character.
+ */
+export function dropToken(line, token) {
+    const tokRe = new RegExp(`\`${escapeRe(token)}\`[A-Za-z0-9-]*`, 'g');
+    let next = line;
+    for (;;) {
+        const m = tokRe.exec(next);
+        if (!m)
+            break;
+        const start = m.index;
+        const end = start + m[0].length;
+        // Prefer eating the separator BEFORE the token; fall back to the one
+        // after it (first element of a list).
+        const before = next.slice(0, start);
+        const sepBefore = /(?:,\s*|\s+or\s+|\s+and\s+)$/.exec(before);
+        if (sepBefore) {
+            next = next.slice(0, start - sepBefore[0].length) + next.slice(end);
+        }
+        else {
+            const sepAfter = /^(?:\s*,\s*|\s+or\s+|\s+and\s+)/.exec(next.slice(end));
+            next = before + next.slice(end + (sepAfter ? sepAfter[0].length : 0));
+        }
+        tokRe.lastIndex = 0;
+    }
+    if (next === line)
+        return line;
+    // An emptied list ("(e.g., )") or an emptied bullet is a whole-line drop.
+    const carcass = next
+        .replace(/^\s*[-*]\s*/, '')
+        .replace(/\(\s*e\.g\.,?\s*\)/gi, '')
+        .replace(/[\s,.;:()]/g, '');
+    if (carcass.length === 0)
+        return null;
+    return next;
+}
+/**
+ * Apply every detected refutation to the refined prompt. Purely subtractive: the
+ * result is always a character subsequence of the input (`inv-no-line-invention`).
+ */
+export function applyRefutations(refined, research) {
+    const refutations = detectRefutations(refined, research);
+    if (refutations.length === 0)
+        return { refined, trail: [], refutations };
+    const lines = refined.split('\n');
+    const dropped = new Set();
+    const trail = [];
+    for (const r of refutations) {
+        const current = lines[r.line];
+        const next = dropToken(current, r.token);
+        if (next === null) {
+            dropped.add(r.line);
+            trail.push(`constraint refuted by research — dropped the whole CONSTRAINTS line for '${r.token}'`
+                + ` | constraint: "${r.constraint.trim()}" | research: "${r.research.trim()}"`);
+        }
+        else {
+            lines[r.line] = next;
+            trail.push(`constraint refuted by research — dropped '${r.token}' from CONSTRAINTS`
+                + ` | constraint: "${r.constraint.trim()}" | research: "${r.research.trim()}"`);
+        }
+    }
+    const kept = lines.filter((_l, i) => !dropped.has(i));
+    return { refined: kept.join('\n'), trail, refutations };
+}

package/dist/task/research-fanout-budget.d.ts

@@ -1,13 +1,18 @@
 /**
  * nexttask 5B — the two candidate bounds on worker:apis's project-source fan-out.
  *
- * ⚠ NOT WIRED. Both levers here are OFF unless their env var is set, so the
- * shipped path is bit-for-bit what it was. They exist so
- * `scripts/live-research-fanout-budget-ab.ts` can run them against the shipped
- * baseline in the SAME build — the alternative (dist surgery) measures a patched
- * copy of the code and not the code. Nothing may read these outside that harness
- * until it reports PASS; a lever wired on argument rather than measurement is the
- * failure mode nexttasks exists to prevent.
+ * ⚠ ONE of the levers in this file is wired: the RESCUE progress deadline
+ * (`workerProgressCeilingMs`) SHIPPED ON in nexttask 9, on a PASS measured over 42
+ * trials per arm against an instrument whose own false-break rate is on record at
+ * 1.5%. CAP, SCALE and RESCUE-CARRY remain OFF unless their env var is set — CAP
+ * and SCALE were rejected on argument (see below), carry-forward was measured
+ * HARMFUL on its own.
+ *
+ * The OFF levers exist so `scripts/live-research-fanout-budget-ab.ts` can run them
+ * against the shipped baseline in the SAME build — the alternative (dist surgery)
+ * measures a patched copy of the code and not the code. Nothing may read them
+ * outside that harness until it reports PASS; a lever wired on argument rather
+ * than measurement is the failure mode nexttasks exists to prevent.
  *
  * THE FAULT THEY TARGET (mx5 run 18, measured — scripts/research-restart-baserate.ts):
  * `worker:apis` fans out `pi-worker-docs(module: ".")` project-source lookups, each
@@ -102,9 +107,40 @@ export declare function fanoutTimeoutPolicy(env?: Env): {
  */
 export declare function workerCarryForward(env?: Env): boolean;
 /**
- * The absolute backstop for the progress-based deadline, or null when off.
- * Required rather than defaulted: a progress deadline with no ceiling is an
- * unbounded worker, which is the one thing the fixed cap exists to prevent.
+ * The absolute backstop for the progress-based deadline.
+ *
+ * WHY THIS NUMBER. It is not a budget and it does not decide how long a worker
+ * may take — the no-progress deadline does that, and it resets on every tool call.
+ * This is the last-resort bound on a worker that never stops moving (an infinite
+ * tool-call loop the loop detector somehow misses), so its only requirement is to
+ * sit clear of the real workload. Measured on 42 progress-arm trials
+ * (`~/tmp/research-fanout-ab-v3`): median 275s, p90 523s, **max 730s**. 20 minutes
+ * is 1.6x the observed worst case, and 1.7x the 720s the SHIPPED path already
+ * spends on a worker that burns all three attempts and returns nothing.
+ *
+ * A ceiling that never fires in production is the correct behaviour for a
+ * backstop, not evidence it is untested: it fires under test
+ * (`pi-worker-core.test.ts` — 'the absolute ceiling still bounds a worker that
+ * never stops moving'), and a worker that goes QUIET is killed long before it, at
+ * `timeoutMs` without progress and by the stall probe.
+ */
+export declare const DEFAULT_WORKER_PROGRESS_CEILING_MS = 1200000;
+/**
+ * The progress-based deadline's ceiling, or null when the lever is OFF.
+ *
+ * SHIPPED ON as of nexttask 9 — the env var is now the OFF switch, not the on
+ * switch. Measured baseline vs progress over 42 trials/arm on a calibrated
+ * instrument (A/A false-break 1.5%): worker-timeout restarts 22/24 → 0/24,
+ * degrades 8/24 → 0/24, entries up on all four high-fan-out fixtures (TASK_0021
+ * 11.0 → 25.5), quality invariants HOLD, every treatment-arm ungrounded flag
+ * hand-verified as an instrument artifact rather than a fabrication.
+ *
+ *     unset            ON at DEFAULT_WORKER_PROGRESS_CEILING_MS
+ *     "0" | "off"      OFF — the fixed elapsed-time cap, exactly as before
+ *     positive int     ON at that ceiling, in ms
+ *
+ * A garbage value keeps the SHIPPED behaviour rather than silently disabling the
+ * lever: turning it off is a decision and has to be spelled.
  */
 export declare function workerProgressCeilingMs(env?: Env): number | null;
 /**

package/dist/task/research-fanout-budget.js

@@ -1,13 +1,18 @@
 /**
  * nexttask 5B — the two candidate bounds on worker:apis's project-source fan-out.
  *
- * ⚠ NOT WIRED. Both levers here are OFF unless their env var is set, so the
- * shipped path is bit-for-bit what it was. They exist so
- * `scripts/live-research-fanout-budget-ab.ts` can run them against the shipped
- * baseline in the SAME build — the alternative (dist surgery) measures a patched
- * copy of the code and not the code. Nothing may read these outside that harness
- * until it reports PASS; a lever wired on argument rather than measurement is the
- * failure mode nexttasks exists to prevent.
+ * ⚠ ONE of the levers in this file is wired: the RESCUE progress deadline
+ * (`workerProgressCeilingMs`) SHIPPED ON in nexttask 9, on a PASS measured over 42
+ * trials per arm against an instrument whose own false-break rate is on record at
+ * 1.5%. CAP, SCALE and RESCUE-CARRY remain OFF unless their env var is set — CAP
+ * and SCALE were rejected on argument (see below), carry-forward was measured
+ * HARMFUL on its own.
+ *
+ * The OFF levers exist so `scripts/live-research-fanout-budget-ab.ts` can run them
+ * against the shipped baseline in the SAME build — the alternative (dist surgery)
+ * measures a patched copy of the code and not the code. Nothing may read them
+ * outside that harness until it reports PASS; a lever wired on argument rather
+ * than measurement is the failure mode nexttasks exists to prevent.
  *
  * THE FAULT THEY TARGET (mx5 run 18, measured — scripts/research-restart-baserate.ts):
  * `worker:apis` fans out `pi-worker-docs(module: ".")` project-source lookups, each
@@ -113,12 +118,48 @@ export function workerCarryForward(env = defaultEnv) {
     return env(WORKER_CARRY_FORWARD_ENV) === '1';
 }
 /**
- * The absolute backstop for the progress-based deadline, or null when off.
- * Required rather than defaulted: a progress deadline with no ceiling is an
- * unbounded worker, which is the one thing the fixed cap exists to prevent.
+ * The absolute backstop for the progress-based deadline.
+ *
+ * WHY THIS NUMBER. It is not a budget and it does not decide how long a worker
+ * may take — the no-progress deadline does that, and it resets on every tool call.
+ * This is the last-resort bound on a worker that never stops moving (an infinite
+ * tool-call loop the loop detector somehow misses), so its only requirement is to
+ * sit clear of the real workload. Measured on 42 progress-arm trials
+ * (`~/tmp/research-fanout-ab-v3`): median 275s, p90 523s, **max 730s**. 20 minutes
+ * is 1.6x the observed worst case, and 1.7x the 720s the SHIPPED path already
+ * spends on a worker that burns all three attempts and returns nothing.
+ *
+ * A ceiling that never fires in production is the correct behaviour for a
+ * backstop, not evidence it is untested: it fires under test
+ * (`pi-worker-core.test.ts` — 'the absolute ceiling still bounds a worker that
+ * never stops moving'), and a worker that goes QUIET is killed long before it, at
+ * `timeoutMs` without progress and by the stall probe.
+ */
+export const DEFAULT_WORKER_PROGRESS_CEILING_MS = 1_200_000;
+/**
+ * The progress-based deadline's ceiling, or null when the lever is OFF.
+ *
+ * SHIPPED ON as of nexttask 9 — the env var is now the OFF switch, not the on
+ * switch. Measured baseline vs progress over 42 trials/arm on a calibrated
+ * instrument (A/A false-break 1.5%): worker-timeout restarts 22/24 → 0/24,
+ * degrades 8/24 → 0/24, entries up on all four high-fan-out fixtures (TASK_0021
+ * 11.0 → 25.5), quality invariants HOLD, every treatment-arm ungrounded flag
+ * hand-verified as an instrument artifact rather than a fabrication.
+ *
+ *     unset            ON at DEFAULT_WORKER_PROGRESS_CEILING_MS
+ *     "0" | "off"      OFF — the fixed elapsed-time cap, exactly as before
+ *     positive int     ON at that ceiling, in ms
+ *
+ * A garbage value keeps the SHIPPED behaviour rather than silently disabling the
+ * lever: turning it off is a decision and has to be spelled.
  */
 export function workerProgressCeilingMs(env = defaultEnv) {
-    return positiveInt(env(WORKER_PROGRESS_CEILING_ENV));
+    const raw = env(WORKER_PROGRESS_CEILING_ENV);
+    if (raw === undefined || raw.trim() === '')
+        return DEFAULT_WORKER_PROGRESS_CEILING_MS;
+    if (raw.trim() === '0' || raw.trim().toLowerCase() === 'off')
+        return null;
+    return positiveInt(raw) ?? DEFAULT_WORKER_PROGRESS_CEILING_MS;
 }
 /**
  * The upfront half of the CAP arm, appended to the APIS worker's prompt.

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

@@ -285,6 +285,29 @@ export type GateResult = {
  * regardless of this count (blessing an artifact as-is is a human's call).
  */
 export declare const MAX_AUTO_AUTOFIX = 3;
+/** Which of the four disjoint branches sent a FAIL to the terminal YOLO ACCEPT. */
+export interface YoloAcceptContext {
+    /** Rule 5c: the spec-required check could not run (tooling absent). */
+    isUnobserved: boolean;
+    /** Cross-task contradiction: the repo-health fix needs a spec-frozen path. */
+    isFrozenBlocked: boolean;
+    /** What the resolution research recommended, when it was consulted at all. */
+    recommend: ResolutionOutcome['recommend'];
+    /** Unattended AUTOFIX attempts already spent on this task. */
+    autoFixCount: number;
+}
+/**
+ * The reason an auto-ACCEPT is being written — NAMED, not assumed.
+ *
+ * The line this replaces asserted "autofix budget spent" on every branch. It was
+ * measured false in 2709 of 2709 recorded accepts (scripts/yolo-accept-baserate.ts):
+ * the budget has never once reached MAX_AUTO_AUTOFIX anywhere in the corpus — 30%
+ * of accepts are UNOBSERVED (the research is never even consulted) and 70% are an
+ * ACCEPT recommendation with the budget fully untouched. A durable trail that
+ * misstates why a defect shipped is worse than no trail: mx5 run 19's TASK_0009
+ * reads as an exhausted fixer when nothing was ever attempted.
+ */
+export declare function yoloAcceptReason(c: YoloAcceptContext): string;
 /**
  * Show the boxed two-choice picker after a verify FAIL and return what the user
  * decided. The model-recommended card is placed first so the renderer tints it

package/dist/task/task-gates.js

@@ -13,6 +13,29 @@ import { attributeEnforceFailure } from './enforce-attribution.js';
  * regardless of this count (blessing an artifact as-is is a human's call).
  */
 export const MAX_AUTO_AUTOFIX = 3;
+/**
+ * The reason an auto-ACCEPT is being written — NAMED, not assumed.
+ *
+ * The line this replaces asserted "autofix budget spent" on every branch. It was
+ * measured false in 2709 of 2709 recorded accepts (scripts/yolo-accept-baserate.ts):
+ * the budget has never once reached MAX_AUTO_AUTOFIX anywhere in the corpus — 30%
+ * of accepts are UNOBSERVED (the research is never even consulted) and 70% are an
+ * ACCEPT recommendation with the budget fully untouched. A durable trail that
+ * misstates why a defect shipped is worse than no trail: mx5 run 19's TASK_0009
+ * reads as an exhausted fixer when nothing was ever attempted.
+ */
+export function yoloAcceptReason(c) {
+    if (c.isUnobserved)
+        return 'verify UNOBSERVED — tooling absent, an unattended re-run cannot provision it';
+    if (c.isFrozenBlocked)
+        return 'repo-health blocked by a spec-frozen path — an impl re-run under the same freeze cannot converge';
+    if (c.recommend === 'autofix') {
+        return `autofix budget spent (${c.autoFixCount}/${MAX_AUTO_AUTOFIX})`;
+    }
+    return c.autoFixCount === 0 ?
+        `judge recommended ACCEPT (autofix budget 0/${MAX_AUTO_AUTOFIX} unused)`
+        : `judge recommended ACCEPT (autofix budget ${c.autoFixCount}/${MAX_AUTO_AUTOFIX} already spent)`;
+}
 /**
  * Bound a captured health-check output before it is embedded in a gate-trail line.
  * appendGateRecord flattens newlines to spaces, so the trail stays one line per
@@ -134,6 +157,8 @@ export async function runGatesForTask(ctxIn, deps, p) {
         // defect is recorded as a durable debt for the final gate.
         let frozenContradiction = null;
         let frozenDebtRecorded = false;
+        // YOLO only: has the one-attempt rescue below already been spent on this task?
+        let yoloRescueUsed = false;
         while (!verified.ok) {
             const failReason = verified.reason ?? 'did not verify';
             // GRADUATED resolution: a repo-health FAIL (pure static findings) gets ONE
@@ -213,23 +238,54 @@ export async function runGatesForTask(ctxIn, deps, p) {
             const autoFixNow = !isUnobserved
                 && !isFrozenBlocked
                 && recOutcome.recommend === 'autofix'
-                && autoFixCount < MAX_AUTO_AUTOFIX;
-            // YOLO: the picker is unreachable with nobody watching, and by the time
-            // we are here the unattended AUTOFIX budget is ALREADY spent (autoFixNow
-            // is false) — so the only option left that terminates is ACCEPT, recorded
-            // as its own 'yolo-accepted' debt. Deliberately NOT a re-entry into
-            // autofix: MAX_AUTO_AUTOFIX exists to break a non-converging loop, and an
+                && autoFixCount < MAX_AUTO_AUTOFIX
+                // A rescue attempt that still FAILed is terminal under YOLO: the
+                // recommendation that got us here was ACCEPT, so a later flip to
+                // AUTOFIX must not bootstrap the full budget from it.
+                && !yoloRescueUsed;
+            // YOLO, THE RESCUE BRANCH: the recommendation is ACCEPT, nobody can be
+            // asked, and the unattended budget is UNTOUCHED. Accepting here ships a
+            // defect having attempted nothing — mx5 run 19 did exactly that twice,
+            // and the final-gate autofix later fixed one of the two in a single pass
+            // (`0 pass 130 fail` → `121 pass 0 fail`). So spend ONE attempt first.
+            // Bounded by construction: one, not MAX_AUTO_AUTOFIX, so an ACCEPT
+            // recommendation can never restart a full loop; if it still FAILs the
+            // next turn falls through to the same auto-ACCEPT and the same debt.
+            const yoloRescueNow = isYoloMode()
+                && !yoloRescueUsed
+                && !isUnobserved
+                && !isFrozenBlocked
+                && recOutcome.recommend === 'accept'
+                && autoFixCount === 0;
+            // YOLO: the picker is unreachable with nobody watching, and every
+            // unattended attempt this task may make has been made — so the only
+            // option left that terminates is ACCEPT, recorded as its own
+            // 'yolo-accepted' debt. Deliberately NOT a re-entry into autofix:
+            // MAX_AUTO_AUTOFIX exists to break a non-converging loop, and an
             // auto-pick here would restart the budget from the site that proves it ran out.
-            const yoloChoice = autoFixNow ? null : yoloVerifyResolution(isYoloMode());
+            const yoloChoice = autoFixNow || yoloRescueNow ? null : yoloVerifyResolution(isYoloMode());
             let choice;
             if (yoloChoice !== null) {
                 choice = yoloChoice;
-                await rec(`resolution: auto-ACCEPTED despite verify FAIL — autofix budget spent, nobody to ask ${YOLO_STAMP}`);
+                // NAME the branch. This line is the durable record of why a defect
+                // shipped; asserting a spent budget on all four branches made run
+                // 19's zero-attempt accepts read as an exhausted fixer.
+                await rec(`resolution: auto-ACCEPTED despite verify FAIL — ${yoloAcceptReason({
+                    isUnobserved,
+                    isFrozenBlocked,
+                    recommend: recOutcome.recommend,
+                    autoFixCount
+                })}, nobody to ask ${YOLO_STAMP}`);
             }
-            else if (autoFixNow) {
+            else if (autoFixNow || yoloRescueNow) {
                 autoFixCount += 1;
-                await rec(`resolution: auto-AUTOFIX (recommended, unattended ${autoFixCount}/${MAX_AUTO_AUTOFIX})`);
-                active.ui.notify(`${p.tag}: verify FAIL on "${p.title}" — auto-fixing (recommended, ${autoFixCount}/${MAX_AUTO_AUTOFIX})…`, 'info');
+                if (yoloRescueNow)
+                    yoloRescueUsed = true;
+                await rec(yoloRescueNow ?
+                    `resolution: auto-AUTOFIX (${YOLO_STAMP} rescue — judge recommended ACCEPT with the unattended `
+                        + `budget unspent; one attempt, ${autoFixCount}/${MAX_AUTO_AUTOFIX})`
+                    : `resolution: auto-AUTOFIX (recommended, unattended ${autoFixCount}/${MAX_AUTO_AUTOFIX})`);
+                active.ui.notify(`${p.tag}: verify FAIL on "${p.title}" — auto-fixing (${yoloRescueNow ? `${YOLO_STAMP} one attempt before accepting` : 'recommended'}, ${autoFixCount}/${MAX_AUTO_AUTOFIX})…`, 'info');
                 choice = { action: 'autofix' };
             }
             else {
@@ -292,7 +348,13 @@ export async function runGatesForTask(ctxIn, deps, p) {
             // hand that diagnosis to the re-run so it fixes the located cause
             // instead of re-deriving it from the bare FAIL line. Skipped when there
             // is no researched rationale beyond the failure text itself.
-            await rec('resolution: user chose AUTOFIX — re-running the implementation turn');
+            // Only the picker branch may claim a person chose this: the two
+            // unattended branches already recorded themselves one line above, and a
+            // trail that says "user chose" when nobody was asked is the same lie the
+            // accept line used to tell.
+            if (!autoFixNow && !yoloRescueNow) {
+                await rec('resolution: user chose AUTOFIX — re-running the implementation turn');
+            }
             active.ui.notify(`${p.tag}: autofixing "${p.title}"…`, 'info');
             const diagnosis = (recOutcome.recommend === 'autofix'
                 && recOutcome.rationale.length > 0

package/package.json

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