@mjasnikovs/pi-task 0.29.1 → 0.29.3

package/dist/task/final-gate.js

@@ -59,6 +59,7 @@ import { resolveRunner, runnerEnv, isCommandNotFound } from './runner-resolve.js
 import { taskThatIntroduced } from './task-provenance.js';
 import { findDanglingArtifacts, danglingGateFailureText } from './artifact-closure.js';
 import { findMissingServeEntry, serveEntryGateFailureText } from './serve-entry.js';
+import { makefileRecipe } from './command-shrink.js';
 function packageScripts(cwd) {
     try {
         const j = JSON.parse(readFileSync(path.join(cwd, 'package.json'), 'utf8'));
@@ -924,6 +925,56 @@ export function discoverGateCommandLabels(cwd) {
     ].map(([bin, args]) => `${bin} ${args.join(' ')}`);
     return [...new Set(labels)];
 }
+/**
+ * The RESOLVED BODY of every discoverable gate command, keyed by the same label
+ * `discoverGateCommandLabels` produces.
+ *
+ * The label is what the gate CALLS; the body is what actually runs. mx5 run 19's
+ * autofix changed `scripts.test` from `AGENT=1 bun test` to `AGENT=1 bun test
+ * ./test` — the label `bun run test` was identical before and after, so the
+ * label guard saw nothing while the suite stopped covering the repository. The
+ * shrink guard compares these bodies (see command-shrink.ts).
+ *
+ * A command with no indirection (`cargo test --quiet`, `pytest -q`) resolves to
+ * itself: it cannot be narrowed without changing the label, which the label
+ * guard already owns.
+ */
+export function discoverGateCommandBodies(cwd) {
+    const boot = discoverBootCommand(cwd);
+    const cmds = [
+        ...discoverHealthCommands(cwd).cmds,
+        ...discoverLockfileChecks(cwd),
+        ...discoverIntegrationCommands(cwd).cmds,
+        ...(boot ? [boot] : [])
+    ];
+    const scripts = existsSync(path.join(cwd, 'package.json')) ? packageScripts(cwd) : {};
+    let makefile = null;
+    if (existsSync(path.join(cwd, 'Makefile'))) {
+        try {
+            makefile = readFileSync(path.join(cwd, 'Makefile'), 'utf8');
+        }
+        catch {
+            makefile = null;
+        }
+    }
+    const out = {};
+    for (const [bin, args] of cmds) {
+        const label = `${bin} ${args.join(' ')}`;
+        if (out[label] !== undefined)
+            continue;
+        out[label] = resolveCommandBody(bin, args, scripts, makefile) ?? label;
+    }
+    return out;
+}
+/** `bun run test` → `scripts.test`; `make test` → the target's recipe lines. */
+function resolveCommandBody(bin, args, scripts, makefile) {
+    if (args[0] === 'run' && args[1] !== undefined)
+        return scripts[args[1]] ?? null;
+    if (bin === 'make' && args[0] !== undefined && makefile !== null) {
+        return makefileRecipe(makefile, args[0]);
+    }
+    return null;
+}
 /** Last ~`limit` chars of the command's combined output, one line, for the reason. */
 function outputTail(stdout, stderr, limit = 400) {
     const combined = `${stdout}\n${stderr}`.trim();

package/dist/task/gate-deps.js

@@ -25,7 +25,7 @@ import { readContracts } from './contracts.js';
 import { recordAcceptDebt, recordEnforceKeptDebt, recordEnforceRevertDebt, recordFrozenBlockedDebt, recordCrossTaskDeletionDebt, recordYoloAcceptDebt, recordRootCauseDebt } from './accept-debt.js';
 import { recordRepairCandidate } from './root-cause-repair.js';
 import { runRepoHealthCheck } from './repo-health-check.js';
-import { runFinalIntegrationGate, discoverGateCommandLabels } from './final-gate.js';
+import { runFinalIntegrationGate, discoverGateCommandLabels, discoverGateCommandBodies } from './final-gate.js';
 import { runFinalGateAutofix } from './final-gate-fix.js';
 import { researchResolution } from './verify-resolution.js';
 import { extractProhibitions, findProhibitionViolations } from './prohibition-probe.js';
@@ -815,6 +815,7 @@ export function buildGateDeps(params) {
             // shrink guard's discovery is the gate's own (see final-gate.ts).
             gate: c => runFinalIntegrationGate(c),
             discoverLabels: discoverGateCommandLabels,
+            discoverBodies: discoverGateCommandBodies,
             discard: discardTreeEdits,
             // WRITE-GUARD STACK (mx5 run 11: this child ran with free bash and
             // none of the run-8 guards — it rm'd a sibling task's verified

package/dist/task/owned-freeze-conflict.js

@@ -32,7 +32,17 @@
  *     outside of X", "any files other than X", "only X may be modified",
  *     "no files outside X").
  *
- * ── STATUS: NOT WIRED. The critique seam FAILED its A/B, 2026-08-04. ─────────
+ * ── STATUS, 2026-08-05: WIRED — but as a DETACH, not as a rewrite. ──────────
+ *
+ * `owned-freeze-reassign.ts` consumes this detector at the last spec-producing
+ * step (`phases.ts`, right after `appendOwnedConstraints`) and resolves a finding
+ * by BOOKKEEPING: the requirement leaves the task that cannot satisfy it and is
+ * claimed later by the task whose refined prompt says it writes the frozen file.
+ * The quote is never edited, so the deletion failure below cannot recur. A/B-1
+ * (scripts/owned-freeze-reassign-ab.ts) PASSes on the corpus with five
+ * invariants. The rewrite lever recorded below stays REFUTED and unwired.
+ *
+ * ── The critique-REWRITE seam FAILED its A/B, 2026-08-04. ────────────────────
  *
  * The detector is precise — 1 finding over 58 real composed specs, and it is the
  * true positive (scripts/owned-freeze-conflict-fp-suite.ts, PASS; STEP 0 in

package/dist/task/owned-freeze-reassign.d.ts

@@ -0,0 +1,142 @@
+/**
+ * owned-freeze-reassign — the DETERMINISTIC resolution for the owned/freeze
+ * unsatisfiable pair (nexttask 2): an AUTHORITATIVE owned requirement whose only
+ * implementing file the same spec FREEZES. No model, no prose edit. The
+ * requirement text is never altered — only which task's ledger entry carries it,
+ * so "resolution by deletion" is structurally impossible.
+ *
+ * WHY NOT A REWRITE. Measured on mx5 run 18 (scripts/live-owned-freeze-conflict
+ * -ab.ts, 20 trials/arm): forcing the pair through the critique seam drives
+ * pair-present 8/20 → 0/20, but 11 of the 20 resolutions DELETE the
+ * AUTHORITATIVE clause instead of moving it, and the delivered VERIFY still
+ * greps `package.json` in both arms (6/20). Removal of the pair is not
+ * satisfaction of the requirement.
+ *
+ * ── THE MECHANISM: DETACH, then CLAIM ───────────────────────────────────────
+ *
+ * Two steps, each run where the information it needs actually exists:
+ *
+ *   DETACH  at the conflicting task's own critique (right after the braces
+ *           stamp the bullet, which is the first moment the pair exists): the
+ *           entry is marked `pending: [frozen paths]` in the ledger and its
+ *           stamped bullet is dropped from this spec. It is now owned by
+ *           nobody; `ownedForTitle` skips it; the quote is still there, byte for
+ *           byte.
+ *   CLAIM   at every LATER task's compose, before the belt block is built: if
+ *           that task's REFINED PROMPT shows a write intent on one of the
+ *           pending paths, the entry becomes that task's own — belt into its
+ *           compose, braces onto its spec.
+ *
+ * ── WHY NOT "PICK THE TARGET AT DETACH TIME", WHICH IS WHAT nexttask2.md ASKS ─
+ *
+ * nexttask2.md's branch 1 is "if exactly one OTHER task in the plan names path
+ * `P` — its title or its spec's file list contains `P` — move the requirement
+ * there". Measured over all 60 recorded composed specs on disk
+ * (scripts/owned-freeze-reassign-baserate.ts), on the one conflict the corpus
+ * contains (mx5 run 19 TASK_0015, path `src/server/index.ts`):
+ *
+ *     title-only    3 candidates   TASK_0014 TASK_0016 TASK_0017
+ *     FILES-only    7 candidates   TASK_0016 … TASK_0025
+ *     either        8 candidates   → "exactly one" NEVER holds
+ *
+ * and, decisively, that measurement is against RECORDED SPECS, which production
+ * does not have: at the conflicting task's compose the later tasks are still
+ * bare plan titles. None of run 19's 26 plan titles contains the string
+ * `src/server/index.ts` — TASK_0017's reads "Client API layer — typed
+ * hono/client hc<AppType> in api.ts, small fetch/mutation hooks, SPA fallback
+ * route on server". A path-lexical target rule at detach time is therefore
+ * BLIND IN PRODUCTION (0 candidates), the same way the run-18 critique probe was.
+ *
+ * The claimant knows what the planner did not. By its own compose, TASK_0017 has
+ * a refined prompt that says "add an SPA fallback route to the existing server
+ * `src/server/index.ts`". Over run 19's 26 refined prompts, `writeIntent` on that
+ * path fires on exactly two: TASK_0014 (which created the file, already run) and
+ * TASK_0017. Nothing else in the plan claims it — six other specs mention the
+ * path, all of them to fence themselves off it.
+ *
+ * ── WHY NOT nexttask2.md's BRANCH 2 (CARRY EVERYTHING CROSS-CUTTING) ────────
+ *
+ * The cross-cutting channel is for prohibitions and product-wide rules
+ * (`isCrossCuttingRequirement`; `accountCoverage` only routes those there). The
+ * corpus conflict is a task-specific deliverable clause — carrying it would push
+ * "the server serves static `dist/`" into the 11 tasks that had not yet run,
+ * none of which owns the server file. That is spec inflation dressed as a fix.
+ * An entry nobody claims stays `pending` and is surfaced at the end of the run
+ * (`unclaimedPendingRequirements`), which is a debt the run can see rather than
+ * an obligation that quietly evaporated.
+ */
+import { type OwnedFreezeOptions } from './owned-freeze-conflict.js';
+import { type OwnedRequirement } from './requirements.js';
+export type ReassignAction = {
+    kind: 'detach';
+    quote: string;
+    from: string;
+    paths: string[];
+} | {
+    kind: 'claim';
+    quote: string;
+    by: string;
+    paths: string[];
+} | {
+    kind: 'unresolved';
+    quote: string;
+    from: string;
+    paths: string[];
+    reason: string;
+};
+export interface DetachResult {
+    /** The ledger after the pass — same quotes, one of them now unowned. */
+    ledger: OwnedRequirement[];
+    /** The spec with the detached requirement's stamped bullet removed.
+     *  Byte-identical to the input when nothing detached. */
+    spec: string;
+    actions: ReassignAction[];
+}
+/**
+ * Does this text CLAIM a write on `p` — a create/modify verb reaching a mention
+ * of the path, not fenced by a negation?
+ *
+ * The negation half is not decoration. Every sibling task's refined prompt names
+ * the files it must not touch ("Do not create or modify any other files outside
+ * this slice (e.g., no changes to `src/server/index.ts`, …)" — mx5 run 19
+ * TASK_0008). Without the fence check that spec claims the server file; with it,
+ * run 19's 26 refined prompts yield exactly the two tasks that do write it.
+ */
+export declare function writeIntent(text: string, p: string): boolean;
+/**
+ * DETACH every owned requirement this spec makes unsatisfiable: mark it
+ * `pending` on the frozen paths and drop its stamped bullet. Pure bookkeeping —
+ * no quote leaves the ledger, no prose is touched.
+ */
+export declare function detachUnsatisfiableRequirements(args: {
+    spec: string;
+    /** The executing task's plan title — the ledger's join key. */
+    title: string;
+    ledger: OwnedRequirement[];
+    isSource?: OwnedFreezeOptions['isSource'];
+}): DetachResult;
+export interface ClaimResult {
+    ledger: OwnedRequirement[];
+    actions: ReassignAction[];
+}
+/**
+ * CLAIM the detached requirements this task will actually implement: those whose
+ * pending paths its refined prompt writes. Run at the START of compose, so the
+ * claimed obligation rides the same belt block every owned requirement does.
+ *
+ * First claimant wins (`inv-single-owner`): the entry stops being pending the
+ * moment it is claimed, so a later task cannot take it as well.
+ */
+export declare function claimPendingRequirements(args: {
+    /** The claiming task's refined prompt — the text that says what it will write. */
+    intent: string;
+    /** The claiming task's plan title (the ledger's join key). */
+    title: string;
+    ledger: OwnedRequirement[];
+}): ClaimResult;
+/** Entries still detached — obligations no task claimed. Surfaced at the end of
+ *  a run so an unsatisfiable requirement becomes a visible debt instead of a
+ *  silent drop. */
+export declare function unclaimedPendingRequirements(ledger: OwnedRequirement[]): OwnedRequirement[];
+/** One line per action, for the run's debug log. */
+export declare function formatReassignActions(actions: ReassignAction[]): string;

package/dist/task/owned-freeze-reassign.js

@@ -0,0 +1,211 @@
+/**
+ * owned-freeze-reassign — the DETERMINISTIC resolution for the owned/freeze
+ * unsatisfiable pair (nexttask 2): an AUTHORITATIVE owned requirement whose only
+ * implementing file the same spec FREEZES. No model, no prose edit. The
+ * requirement text is never altered — only which task's ledger entry carries it,
+ * so "resolution by deletion" is structurally impossible.
+ *
+ * WHY NOT A REWRITE. Measured on mx5 run 18 (scripts/live-owned-freeze-conflict
+ * -ab.ts, 20 trials/arm): forcing the pair through the critique seam drives
+ * pair-present 8/20 → 0/20, but 11 of the 20 resolutions DELETE the
+ * AUTHORITATIVE clause instead of moving it, and the delivered VERIFY still
+ * greps `package.json` in both arms (6/20). Removal of the pair is not
+ * satisfaction of the requirement.
+ *
+ * ── THE MECHANISM: DETACH, then CLAIM ───────────────────────────────────────
+ *
+ * Two steps, each run where the information it needs actually exists:
+ *
+ *   DETACH  at the conflicting task's own critique (right after the braces
+ *           stamp the bullet, which is the first moment the pair exists): the
+ *           entry is marked `pending: [frozen paths]` in the ledger and its
+ *           stamped bullet is dropped from this spec. It is now owned by
+ *           nobody; `ownedForTitle` skips it; the quote is still there, byte for
+ *           byte.
+ *   CLAIM   at every LATER task's compose, before the belt block is built: if
+ *           that task's REFINED PROMPT shows a write intent on one of the
+ *           pending paths, the entry becomes that task's own — belt into its
+ *           compose, braces onto its spec.
+ *
+ * ── WHY NOT "PICK THE TARGET AT DETACH TIME", WHICH IS WHAT nexttask2.md ASKS ─
+ *
+ * nexttask2.md's branch 1 is "if exactly one OTHER task in the plan names path
+ * `P` — its title or its spec's file list contains `P` — move the requirement
+ * there". Measured over all 60 recorded composed specs on disk
+ * (scripts/owned-freeze-reassign-baserate.ts), on the one conflict the corpus
+ * contains (mx5 run 19 TASK_0015, path `src/server/index.ts`):
+ *
+ *     title-only    3 candidates   TASK_0014 TASK_0016 TASK_0017
+ *     FILES-only    7 candidates   TASK_0016 … TASK_0025
+ *     either        8 candidates   → "exactly one" NEVER holds
+ *
+ * and, decisively, that measurement is against RECORDED SPECS, which production
+ * does not have: at the conflicting task's compose the later tasks are still
+ * bare plan titles. None of run 19's 26 plan titles contains the string
+ * `src/server/index.ts` — TASK_0017's reads "Client API layer — typed
+ * hono/client hc<AppType> in api.ts, small fetch/mutation hooks, SPA fallback
+ * route on server". A path-lexical target rule at detach time is therefore
+ * BLIND IN PRODUCTION (0 candidates), the same way the run-18 critique probe was.
+ *
+ * The claimant knows what the planner did not. By its own compose, TASK_0017 has
+ * a refined prompt that says "add an SPA fallback route to the existing server
+ * `src/server/index.ts`". Over run 19's 26 refined prompts, `writeIntent` on that
+ * path fires on exactly two: TASK_0014 (which created the file, already run) and
+ * TASK_0017. Nothing else in the plan claims it — six other specs mention the
+ * path, all of them to fence themselves off it.
+ *
+ * ── WHY NOT nexttask2.md's BRANCH 2 (CARRY EVERYTHING CROSS-CUTTING) ────────
+ *
+ * The cross-cutting channel is for prohibitions and product-wide rules
+ * (`isCrossCuttingRequirement`; `accountCoverage` only routes those there). The
+ * corpus conflict is a task-specific deliverable clause — carrying it would push
+ * "the server serves static `dist/`" into the 11 tasks that had not yet run,
+ * none of which owns the server file. That is spec inflation dressed as a fix.
+ * An entry nobody claims stays `pending` and is surfaced at the end of the run
+ * (`unclaimedPendingRequirements`), which is a debt the run can see rather than
+ * an obligation that quietly evaporated.
+ */
+import { findOwnedFreezeConflicts } from './owned-freeze-conflict.js';
+import { ownedForTitle } from './requirements.js';
+import { PROHIBITION_RE } from './prohibition-probe.js';
+/**
+ * Does this text CLAIM a write on `p` — a create/modify verb reaching a mention
+ * of the path, not fenced by a negation?
+ *
+ * The negation half is not decoration. Every sibling task's refined prompt names
+ * the files it must not touch ("Do not create or modify any other files outside
+ * this slice (e.g., no changes to `src/server/index.ts`, …)" — mx5 run 19
+ * TASK_0008). Without the fence check that spec claims the server file; with it,
+ * run 19's 26 refined prompts yield exactly the two tasks that do write it.
+ */
+export function writeIntent(text, p) {
+    const re = new RegExp(String.raw `\b(?:creat|add|implement|modif|updat|extend|wir|writ|mount|chang)\w*\b`
+        + String.raw `[^.\n]{0,140}?`
+        + p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi');
+    for (const m of text.matchAll(re)) {
+        // The negation usually sits BEFORE the verb, so the window reaches back
+        // past it — matching only the verb→path span misses TASK_0008 entirely.
+        const from = Math.max(0, (m.index ?? 0) - 90);
+        const window = text.slice(from, (m.index ?? 0) + m[0].length);
+        if (NEGATED_RE.test(window) || PROHIBITION_RE.test(window))
+            continue;
+        return true;
+    }
+    return false;
+}
+/** Negations that turn a write verb into a fence. Deliberately broader than
+ *  `PROHIBITION_RE`, which requires "do not"+verb adjacency and so never sees
+ *  "no changes to `X`" or "any files other than `Y`". */
+const NEGATED_RE = /\b(?:do(?:es)?\s+not|don'?t|must\s+not|may\s+not|never|no|not|other\s+than|outside(?:\s+of)?|except|besides|avoid|without|nor|unchanged|untouched)\b/i;
+/** The machine stamp `appendOwnedConstraints` writes. Only stamped lines are
+ *  ever removed — a quote compose folded in itself is model prose, and this pass
+ *  does not edit prose. */
+const STAMP_RE = /owned\s+requirement\s+from\s+the\s+source\s+design/i;
+function stampedLineFor(spec, quote) {
+    for (const raw of spec.split('\n')) {
+        if (STAMP_RE.test(raw) && raw.includes(quote))
+            return raw;
+    }
+    return null;
+}
+function dropLine(spec, line) {
+    const lines = spec.split('\n');
+    const i = lines.indexOf(line);
+    if (i < 0)
+        return spec;
+    lines.splice(i, 1);
+    return lines.join('\n');
+}
+/**
+ * DETACH every owned requirement this spec makes unsatisfiable: mark it
+ * `pending` on the frozen paths and drop its stamped bullet. Pure bookkeeping —
+ * no quote leaves the ledger, no prose is touched.
+ */
+export function detachUnsatisfiableRequirements(args) {
+    const mine = ownedForTitle(args.ledger, args.title);
+    const conflicts = findOwnedFreezeConflicts(args.spec, {
+        owned: mine,
+        isSource: args.isSource
+    });
+    const out = {
+        ledger: args.ledger.map(o => ({ ...o })),
+        spec: args.spec,
+        actions: []
+    };
+    for (const c of conflicts) {
+        const entry = out.ledger.find(o => !(o.pending && o.pending.length > 0)
+            && c.requirement.includes(o.quote)
+            && normalise(o.title) === normalise(args.title));
+        if (!entry) {
+            // The conflicting line is not one of THIS task's ledger quotes (a
+            // stamp from an earlier plan round, or a quote the ledger no longer
+            // holds). Nothing to detach; the spec is left exactly as it is.
+            out.actions.push({
+                kind: 'unresolved',
+                quote: c.requirement,
+                from: args.title,
+                paths: c.paths,
+                reason: 'no ledger entry owns this line'
+            });
+            continue;
+        }
+        const line = stampedLineFor(out.spec, entry.quote);
+        if (line === null) {
+            out.actions.push({
+                kind: 'unresolved',
+                quote: entry.quote,
+                from: args.title,
+                paths: c.paths,
+                reason: 'the quote is model prose, not a machine-stamped bullet'
+            });
+            continue;
+        }
+        entry.pending = [...c.paths];
+        out.spec = dropLine(out.spec, line);
+        out.actions.push({ kind: 'detach', quote: entry.quote, from: args.title, paths: c.paths });
+    }
+    return out;
+}
+/**
+ * CLAIM the detached requirements this task will actually implement: those whose
+ * pending paths its refined prompt writes. Run at the START of compose, so the
+ * claimed obligation rides the same belt block every owned requirement does.
+ *
+ * First claimant wins (`inv-single-owner`): the entry stops being pending the
+ * moment it is claimed, so a later task cannot take it as well.
+ */
+export function claimPendingRequirements(args) {
+    const out = { ledger: args.ledger.map(o => ({ ...o })), actions: [] };
+    if (args.title.trim().length === 0)
+        return out;
+    for (const entry of out.ledger) {
+        const paths = entry.pending ?? [];
+        if (paths.length === 0)
+            continue;
+        const claimed = paths.filter(p => writeIntent(args.intent, p));
+        if (claimed.length === 0)
+            continue;
+        delete entry.pending;
+        entry.title = args.title;
+        out.actions.push({ kind: 'claim', quote: entry.quote, by: args.title, paths: claimed });
+    }
+    return out;
+}
+/** Entries still detached — obligations no task claimed. Surfaced at the end of
+ *  a run so an unsatisfiable requirement becomes a visible debt instead of a
+ *  silent drop. */
+export function unclaimedPendingRequirements(ledger) {
+    return ledger.filter(o => (o.pending ?? []).length > 0);
+}
+const normalise = (s) => s.trim().toLowerCase().replace(/\s+/g, ' ');
+/** One line per action, for the run's debug log. */
+export function formatReassignActions(actions) {
+    return actions
+        .map(a => a.kind === 'detach' ?
+        `owned-freeze DETACH: "${a.quote.slice(0, 80)}" — frozen ${a.paths.join(', ')} in this task;`
+            + ' released to the task that writes it'
+        : a.kind === 'claim' ?
+            `owned-freeze CLAIM: "${a.quote.slice(0, 80)}" — this task writes ${a.paths.join(', ')}`
+            : `owned-freeze UNRESOLVED: "${a.quote.slice(0, 80)}" — ${a.reason}`)
+        .join('\n');
+}

package/dist/task/phases.d.ts

@@ -71,6 +71,33 @@ export declare function phaseContractsBlock(deps: PhaseDeps): Promise<string>;
  * /task is byte-identical to before.
  */
 export declare function phaseCarriedBlocks(deps: PhaseDeps): Promise<string>;
+/**
+ * DETACH (nexttask 2) — an owned requirement this task cannot satisfy, because a
+ * category freeze in the very spec that carries it covers the only file that
+ * could, stops being this task's obligation and is released to whichever later
+ * task writes that file.
+ *
+ * Runs at the LAST spec-producing step, where the pair first exists: the stamped
+ * bullet is written one statement earlier by `appendOwnedConstraints`, and a
+ * critique-time probe measured 0/40 because the stamp did not exist yet. It
+ * never edits prose and never asks a model — the run-18 rewrite lever resolved
+ * 11 of 20 pairs by DELETING the authoritative clause. The quote stays in the
+ * ledger throughout; only its owner changes.
+ */
+export declare function resolveOwnedFreezeForThisTask(deps: PhaseDeps, spec: string): Promise<string>;
+/**
+ * CLAIM (nexttask 2) — the other half. A requirement detached by an earlier task
+ * becomes THIS task's own when its refined prompt says it writes the frozen
+ * file. Run before compose builds its carried blocks, so the claimed obligation
+ * rides the same belt every owned requirement does and the braces stamp it onto
+ * this spec.
+ *
+ * The claimant is the only party that knows: at detach time the later tasks are
+ * bare plan titles, and none of mx5 run 19's 26 titles contains the path. Over
+ * the same run's 26 REFINED prompts, `writeIntent` picks out exactly the two
+ * tasks that write the server file.
+ */
+export declare function claimOwnedFreezeForThisTask(deps: PhaseDeps, refined: string): Promise<void>;
 export declare const phaseRefine: (deps: PhaseDeps, raw: string, planContext?: string) => Promise<string>;
 export declare function phaseVerifyTooling(deps: PhaseDeps, research: string): Promise<string>;
 export interface PhaseResearchDeps extends ExternalContextDeps {

package/dist/task/phases.js

@@ -24,6 +24,7 @@ import { formatServiceBlock, formatFreshnessSkippedBlock } from './service-block
 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 { spawnSync } from 'node:child_process';
 import { renderInlineMarkdown, stripInlineMarkdown } from './inline-markdown.js';
 import { isDuplicateQuestion, MAX_DUP_STRIKES, DUP_REPROMPT_HINT } from './question-dedup.js';
 import { parseGrillQuestions, parseAutoAnswer, autoAnswerHasTag, parseVerifyToolingOutput, deriveTitle } from './parsers.js';
@@ -38,7 +39,9 @@ import { findSynthesizedApis, synthesizedApiReaskHint } from './api-synthesis.js
 import { findGrepOnlyVerify, grepOnlyVerifyDefectText, GREP_THEATER_RETRY_HINT } from './verify-quality.js';
 import { existsSync } from 'node:fs';
 import { readContracts, buildContractsBlock, buildContractsVerifyBlock } from './contracts.js';
-import { readRequirements, buildRequirementsBlock, buildOwnedRequirementsBlock, readOwnedRequirements, ownedForTitle, appendOwnedConstraints } from './requirements.js';
+import { readRequirements, buildRequirementsBlock, buildOwnedRequirementsBlock, readOwnedRequirements, writeOwnedRequirements, ownedForTitle, appendOwnedConstraints } from './requirements.js';
+import { detachUnsatisfiableRequirements, claimPendingRequirements, unclaimedPendingRequirements, formatReassignActions } from './owned-freeze-reassign.js';
+import { trackedSourceOracle } from './owned-freeze-conflict.js';
 import { runPhaseChild, runPhaseWithLoopGuard, runWithEmphasisRetry, prependHint, USER_CANCELLED } from './child-runner.js';
 import { SessionUI } from '../remote/bridge.js';
 import { isYoloMode, yoloPickAutoAnswer, YOLO_STAMP } from './yolo.js';
@@ -180,6 +183,81 @@ async function ownedForThisTask(deps) {
         return [];
     }
 }
+/** This task's plan title — the owned ledger's join key. */
+async function planTitle(deps) {
+    try {
+        return ((await readSection(deps.cwd, deps.taskId, 'raw prompt')) ?? '').trim();
+    }
+    catch {
+        return '';
+    }
+}
+/** The `isSource` oracle production uses: git tracks the path in this tree. */
+function repoSourceOracle(cwd) {
+    return trackedSourceOracle(p => {
+        const r = spawnSync('git', ['ls-files', '--', p], { cwd, encoding: 'utf8', timeout: 4000 });
+        return { stdout: r.stdout ?? '', exitCode: r.status ?? 1 };
+    });
+}
+/**
+ * DETACH (nexttask 2) — an owned requirement this task cannot satisfy, because a
+ * category freeze in the very spec that carries it covers the only file that
+ * could, stops being this task's obligation and is released to whichever later
+ * task writes that file.
+ *
+ * Runs at the LAST spec-producing step, where the pair first exists: the stamped
+ * bullet is written one statement earlier by `appendOwnedConstraints`, and a
+ * critique-time probe measured 0/40 because the stamp did not exist yet. It
+ * never edits prose and never asks a model — the run-18 rewrite lever resolved
+ * 11 of 20 pairs by DELETING the authoritative clause. The quote stays in the
+ * ledger throughout; only its owner changes.
+ */
+export async function resolveOwnedFreezeForThisTask(deps, spec) {
+    const ledger = await readOwnedRequirements(deps.cwd).catch(() => []);
+    if (ledger.length === 0)
+        return spec;
+    const title = await planTitle(deps);
+    if (title.length === 0)
+        return spec;
+    const res = detachUnsatisfiableRequirements({
+        spec,
+        title,
+        ledger,
+        isSource: repoSourceOracle(deps.cwd)
+    });
+    if (res.actions.length === 0)
+        return spec;
+    deps.logDebug?.(formatReassignActions(res.actions));
+    if (!res.actions.some(a => a.kind === 'detach'))
+        return spec;
+    await writeOwnedRequirements(deps.cwd, res.ledger);
+    return res.spec;
+}
+/**
+ * CLAIM (nexttask 2) — the other half. A requirement detached by an earlier task
+ * becomes THIS task's own when its refined prompt says it writes the frozen
+ * file. Run before compose builds its carried blocks, so the claimed obligation
+ * rides the same belt every owned requirement does and the braces stamp it onto
+ * this spec.
+ *
+ * The claimant is the only party that knows: at detach time the later tasks are
+ * bare plan titles, and none of mx5 run 19's 26 titles contains the path. Over
+ * the same run's 26 REFINED prompts, `writeIntent` picks out exactly the two
+ * tasks that write the server file.
+ */
+export async function claimOwnedFreezeForThisTask(deps, refined) {
+    const ledger = await readOwnedRequirements(deps.cwd).catch(() => []);
+    if (unclaimedPendingRequirements(ledger).length === 0)
+        return;
+    const title = await planTitle(deps);
+    if (title.length === 0)
+        return;
+    const res = claimPendingRequirements({ intent: refined, title, ledger });
+    if (res.actions.length === 0)
+        return;
+    deps.logDebug?.(formatReassignActions(res.actions));
+    await writeOwnedRequirements(deps.cwd, res.ledger);
+}
 export const phaseRefine = async (deps, raw, planContext) => {
     const existingFiles = await refineExistingFilesBlock(deps).catch(() => '');
     const contracts = await phaseCarriedBlocks(deps);
@@ -1247,6 +1325,10 @@ export async function phaseGrill(deps, ctx, widgetState, refined, research) {
     return out.join('\n');
 }
 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
+    // this task's own when this task is the one that writes that file.
+    await claimOwnedFreezeForThisTask(deps, refined).catch(() => { });
     const contracts = await phaseCarriedBlocks(deps);
     return runWithEmphasisRetry(deps, 'compose', 'read', problem => COMPOSE_PROMPT(refined, research, qa, problem, contracts), text => {
         // Trim any "here's the spec:" preamble before validating, so a
@@ -1565,7 +1647,10 @@ export const PHASES = [
             if (out !== spec) {
                 d.logDebug?.('owned-requirements braces: appended omitted design obligation(s) to CONSTRAINTS');
             }
-            return out;
+            // An owned obligation whose only file this spec also FREEZES is
+            // unsatisfiable here; move it to the pending task that writes that
+            // file rather than shipping a requirement no one can meet.
+            return await resolveOwnedFreezeForThisTask(d, out);
         }
     }
 ];

package/dist/task/requirements.d.ts

@@ -132,6 +132,16 @@ export interface OwnedRequirement {
      *  against the executing task's title at phase time (ids don't exist yet at
      *  plan time, and spliced repair tasks shift them). */
     title: string;
+    /**
+     * DETACHED (nexttask 2, owned-freeze-reassign.ts): the files this obligation
+     * names that its assigned task FROZE, making it unsatisfiable there. While
+     * set, the entry is owned by nobody — `ownedForTitle` skips it — and `title`
+     * records only where it came from. The next task whose refined prompt shows
+     * a write intent on one of these paths claims it (clearing this field), and
+     * an entry nobody claims is surfaced at the end of the run rather than
+     * silently dropped. Absent on every ordinary entry.
+     */
+    pending?: string[];
 }
 export declare function ownedRequirementsFile(cwd: string): string;
 /** Persist the task-mapped requirements (host-side, plan time). Overwrites —
@@ -142,7 +152,9 @@ export declare function readOwnedRequirements(cwd: string): Promise<OwnedRequire
 export declare function parseOwnedRequirements(text: string): OwnedRequirement[];
 /** The owned entries whose plan title matches THIS task's title (normalised
  *  equality — titles travel verbatim from the plan list into task creation;
- *  spliced repair tasks simply match nothing). */
+ *  spliced repair tasks simply match nothing). A DETACHED entry (`pending`) is
+ *  owned by nobody until a task claims it, so it is never returned here — its
+ *  `title` is provenance, not ownership. */
 export declare function ownedForTitle(owned: OwnedRequirement[], title: string): OwnedRequirement[];
 /** The injection block for a task's OWN mapped obligations. Mirrors
  *  buildRequirementsBlock (the directive pattern that measurably works) but is