@mjasnikovs/pi-task 0.38.11 → 0.38.12

package/dist/task/gate-child.d.ts

@@ -31,8 +31,7 @@
 import type { ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
 import type { RunWorkerInput, RunWorkerResult } from '../workers/pi-worker-core.js';
 import type { GitStateSnapshot, ReconcileResult } from './git-state-guard.js';
-import type { ContextSnapshot } from '../shared/child-process.js';
-import type { AutoLoaderState } from './widget.js';
+import type { ChildStatus } from './child-status.js';
 /** Which gate child this is. */
 export type GateChildKind = 'verify' | 'recommend' | 'lint-fix' | 'final-fix' | 'enforce';
 export interface GateChildRow {
@@ -76,21 +75,20 @@ export interface GateChildDeps {
     commandTimeoutMs: number;
     /** Hung-stream bound; the probe-based stall guard cannot supply it. */
     streamInactivityMs: number;
-    parentContextWindow: number;
+    /**
+     * The live widget state this child feeds and its loader reads. SHARED with
+     * the caller — the verify gate's own loader reads the same status while this
+     * child runs with `loader: false` — so it is the caller's object, not a copy.
+     * It also owns the loader ritual and the context-usage resolution.
+     */
+    status: ChildStatus;
     runWorker: (input: RunWorkerInput) => Promise<RunWorkerResult>;
     makeDebugAppender: (path: string) => (line: string, level?: 'event' | 'stream') => void;
-    startAutoLoader: (ctx: ExtensionCommandContext, getState: () => AutoLoaderState | null) => () => void;
     captureGitState: (cwd: string, signal?: AbortSignal) => Promise<GitStateSnapshot>;
     reconcileGitState: (cwd: string, snapshot: GitStateSnapshot, signal?: AbortSignal) => Promise<ReconcileResult>;
     /** Tree changes for a WRITE-capable child, already formatted. */
     describeTreeChanges: (cwd: string, signal?: AbortSignal) => Promise<string>;
-    resolveContextUsage: (snapshot: ContextSnapshot, prev: ContextSnapshot | undefined, parentContextWindow: number) => ContextSnapshot;
     truncateToolResult: (text: string) => string;
-    /** Where the live widget reads `lastLine` / `contextUsage` from. */
-    widget: {
-        lastLine?: string;
-        contextUsage?: ContextSnapshot;
-    };
     /** Set to the last reconcile so the caller can discard a tainted verdict. */
     onReconcile?: (rec: ReconcileResult) => void;
 }

package/dist/task/gate-child.js

@@ -57,8 +57,11 @@ export const GATE_CHILD_KINDS = {
 export function makeGateChild(deps) {
     const row = GATE_CHILD_KINDS[deps.kind];
     return async (tools, prompt, sig) => {
-        deps.widget.lastLine = undefined;
-        deps.widget.contextUsage = undefined;
+        // Reset FIRST — before the start marker and the guard snapshot, not just
+        // inside `track` — so a previous child's trailer never shows under this
+        // one while the git snapshot is still being taken (the verify gate's own
+        // loader is already reading this status by then).
+        deps.status.reset();
         const startedAt = Date.now();
         // Every marker below (start/end, the guard's restore, the loop warning, a
         // write-capable child's tree changes) is a guard record that survives at
@@ -67,19 +70,17 @@ export function makeGateChild(deps) {
         const log = deps.makeDebugAppender(deps.logPath);
         log(`=== ${deps.kind} start: ${deps.taskTitle} ===`);
         const guardSnapshot = row.guarded ? await deps.captureGitState(deps.cwd, sig) : null;
-        const stopLoader = deps.loader === false ?
-            () => { }
-            : deps.startAutoLoader(deps.ctx, () => ({
+        const frame = deps.loader === false ?
+            null
+            : () => ({
                 title: deps.taskTitle,
                 kind: deps.kind,
                 step: row.step,
                 stepNum: 1,
                 stepTotal: 1,
-                startedAt,
-                lastLine: deps.widget.lastLine,
-                contextUsage: deps.widget.contextUsage
-            }));
-        try {
+                startedAt
+            });
+        return deps.status.track(deps.ctx, frame, async () => {
             let r;
             try {
                 r = await deps.runWorker({
@@ -106,10 +107,10 @@ export function makeGateChild(deps) {
                         + (rs.detail ? ` — ${rs.detail}` : '')
                         + ' ==='),
                     onLine: line => {
-                        // `lastLine` feeds the LIVE widget and is not logging — it
+                        // The status feeds the LIVE widget and is not logging — it
                         // stays outside the gate, or a quiet trail would also blank
                         // the progress display.
-                        deps.widget.lastLine = line;
+                        deps.status.onLine(line);
                         log(line, 'stream');
                     },
                     ...(row.logToolResults ?
@@ -118,9 +119,7 @@ export function makeGateChild(deps) {
                                 + deps.truncateToolResult(text), 'stream')
                         }
                         : {}),
-                    onContextUsage: snapshot => {
-                        deps.widget.contextUsage = deps.resolveContextUsage(snapshot, deps.widget.contextUsage, deps.parentContextWindow);
-                    }
+                    onContextUsage: snapshot => deps.status.onContextUsage(snapshot)
                 });
             }
             finally {
@@ -169,9 +168,6 @@ export function makeGateChild(deps) {
                     + `${await deps.describeTreeChanges(deps.cwd, sig)} ===`);
             }
             return r.text;
-        }
-        finally {
-            stopLoader();
-        }
+        });
     };
 }

package/dist/task/gate-deps.d.ts

@@ -1,5 +1,6 @@
 import type { ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
 import type { GateDeps } from './task-gates.js';
+import { type VerifyProbes } from './verify-work.js';
 import { type FinalFixResult } from './final-gate-fix.js';
 import { type AddedLine } from './probe-gaming.js';
 import { type ChangedFile } from './substitution-probe.js';
@@ -135,6 +136,34 @@ export declare function collectTaskTreeChanges(cwd: string, signal?: AbortSignal
  * costs one extra tracked-file listing, not a second diff.
  */
 export declare function collectTestAssemblyFindings(cwd: string, changed: ChangedFile[], signal?: AbortSignal): Promise<string[]>;
+/**
+ * The composed spec a gate judges against: the `## spec` section of the task file
+ * (see extractSpecForVerification). A task that never reached compose has no spec
+ * section, and an unreadable task file is the same case — both are null, and every
+ * caller already treats null as "nothing to hold the work to" (verify no-ops,
+ * frozen paths are empty, recommend falls back to the title). Never throws. This
+ * used to be the same four-line try/catch at four gate sites.
+ */
+export declare function readSpecForVerification(cwd: string, taskId: string): Promise<string | null>;
+/**
+ * Bind the deterministic verify probes — THE one place the collectors above meet
+ * the probe table in verify-work.ts. One entry per `BoundProbeKey`; the table row
+ * with that key reads it, and the table's loop owns the ritual (skip when absent,
+ * degrade to the row's empty value when the thunk throws), so nothing here needs a
+ * try/catch and a fault in one probe cannot reach another. Each thunk is LAZY:
+ * building the record runs no git.
+ *
+ * `spec` is the composed spec (see readSpecForVerification): the prohibition probe
+ * reads it and skips the git call when the spec forbids nothing. `log` is the
+ * verify debug appender for the one probe that repairs as well as reports.
+ */
+export declare function buildVerifyProbes(params: {
+    cwd: string;
+    signal?: AbortSignal;
+    taskId: string;
+    spec: string | null;
+    log?: (msg: string) => void;
+}): VerifyProbes;
 /**
  * Build the gate deps for one command run. `runTask` is the orchestrator's
  * implementation re-runner, injected by the caller. The returned object also drives

package/dist/task/gate-deps.js

@@ -44,7 +44,7 @@ import { runWorker } from '../workers/pi-worker-core.js';
 import { getConfig } from '../config/config.js';
 import { makeDebugAppender } from './debug-log.js';
 import { startAutoLoader } from './widget.js';
-import { resolveContextUsage } from './context-usage.js';
+import { ChildStatus } from './child-status.js';
 import { makeGateChild } from './gate-child.js';
 /** Max chars of a tool result kept in the gate debug log (mx5 run 10 item 6). */
 const TOOL_RESULT_LOG_LIMIT = 300;
@@ -457,6 +457,90 @@ export async function collectTestAssemblyFindings(cwd, changed, signal) {
     }
     return testAssemblyVerifyFindings(findTestRebuiltAssemblies(testFiles, production));
 }
+/**
+ * The composed spec a gate judges against: the `## spec` section of the task file
+ * (see extractSpecForVerification). A task that never reached compose has no spec
+ * section, and an unreadable task file is the same case — both are null, and every
+ * caller already treats null as "nothing to hold the work to" (verify no-ops,
+ * frozen paths are empty, recommend falls back to the title). Never throws. This
+ * used to be the same four-line try/catch at four gate sites.
+ */
+export async function readSpecForVerification(cwd, taskId) {
+    try {
+        const { body } = await readTaskFile(cwd, taskId);
+        return extractSpecForVerification(body);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Bind the deterministic verify probes — THE one place the collectors above meet
+ * the probe table in verify-work.ts. One entry per `BoundProbeKey`; the table row
+ * with that key reads it, and the table's loop owns the ritual (skip when absent,
+ * degrade to the row's empty value when the thunk throws), so nothing here needs a
+ * try/catch and a fault in one probe cannot reach another. Each thunk is LAZY:
+ * building the record runs no git.
+ *
+ * `spec` is the composed spec (see readSpecForVerification): the prohibition probe
+ * reads it and skips the git call when the spec forbids nothing. `log` is the
+ * verify debug appender for the one probe that repairs as well as reports.
+ */
+export function buildVerifyProbes(params) {
+    const { cwd, signal, taskId, spec, log } = params;
+    return {
+        // Deterministic self-verification probe: test files the task itself
+        // authored/changed become prompt-level findings mandating the child
+        // to drive the real artifact before trusting their green result.
+        substitution: () => collectChangedFiles(cwd, signal).then(findSubstitutionSuspects),
+        // Deterministic prohibition probe: paths the spec forbids modifying
+        // that the task's diff modified anyway become prompt-level findings
+        // under the no-waiver rule — the child otherwise rarely runs `git
+        // diff` and cannot even see the violation.
+        prohibition: () => {
+            const banned = spec ? extractProhibitions(spec) : [];
+            if (banned.length === 0)
+                return Promise.resolve([]);
+            return collectChangedFiles(cwd, signal).then(files => findProhibitionViolations(banned, files));
+        },
+        // Deterministic cross-task deletion probe (mx5 run 12 PROMPT 2):
+        // tracked files this task's diff DELETES whose introducing commit
+        // belongs to a DIFFERENT task — a sibling's committed deliverable
+        // destroyed (typically to green a check). Injected under rule 4d and
+        // carried on a FAIL so an ACCEPT records durable debts.
+        crossTaskDeletion: () => collectTaskTreeChanges(cwd, signal).then(changes => findCrossTaskDeletions(changes, taskId, rel => taskThatIntroduced(cwd, rel))),
+        // Deterministic probe-gaming probe (F6): added lines whose stated
+        // purpose is to make a check pass rather than meet the requirement
+        // ("return 401 so the verification test passes") become rule-4c
+        // findings so the child verifies the real requirement, not the check.
+        probeGaming: () => collectAddedLines(cwd, signal).then(findProbeGaming),
+        // Deterministic sandbox-path-leak probe (mx5 run 13 PROMPT 4 item
+        // 1): absolute paths committed from the authoring child's own
+        // environment (`/workspace/src/shared`) that resolve nowhere here.
+        // Repaired deterministically where the relative form provably
+        // resolves; the remainder is injected under rule 4e, whose point is
+        // that such a path breaks the BUILD — so the checks that would have
+        // caught it report nothing rather than failing.
+        foreignPath: () => collectForeignPathFindings(cwd, signal, log),
+        // Deterministic neutered-check-script probe (mx5 run 13 PROMPT 4
+        // item 4): a check script this task authored that cannot fail
+        // (`… || true`, an inverted-grep launder). Injected under rule 4f,
+        // because the child provably cannot find this by running the
+        // script — it passes, which IS the defect.
+        scriptEscape: () => collectScriptEscapeFindings(cwd, signal),
+        // Deterministic runner glob-collision probe (mx5 runs 7 AND 13,
+        // PROMPT 4 item 2): both `bun test` and `playwright test` declared
+        // with no proof their file sets are disjoint. Injected under rule
+        // 4g — the collision kills the suite during COLLECTION, which does
+        // not look like a test failure.
+        runnerGlob: () => collectRunnerGlobFindings(cwd),
+        // Deterministic test-assembly probe (F4): authored test files that
+        // rebuild production wiring — importing the leaf modules the shipped
+        // entry composes and assembling their own copy — become rule-3f
+        // findings so the child drives the REAL assembly, not the copy.
+        testAssembly: () => collectChangedFiles(cwd, signal).then(changed => collectTestAssemblyFindings(cwd, changed, signal))
+    };
+}
 /**
  * Build the gate deps for one command run. `runTask` is the orchestrator's
  * implementation re-runner, injected by the caller. The returned object also drives
@@ -471,10 +555,11 @@ export function buildGateDeps(params) {
     // loader across the deterministic stage — so the dead air can be measured in the
     // SAME binary rather than against a remembered baseline. Unset in every real run.
     const deadAirBaseline = process.env.DEADAIR_AB_ARM === 'baseline';
-    // Captured by each gate child's loader so the widget mirrors the child's latest
-    // output line and context usage, exactly like the single-task phase widget.
-    let lastLine;
-    let contextUsage;
+    // ONE live status for every gate child, so the widget mirrors the running
+    // child's latest output line and context usage exactly like the single-task
+    // phase widget — and so the verify gate's own loader (below) reads what its
+    // loader-less child feeds.
+    const status = new ChildStatus({ parentContextWindow });
     // What the git-state guard had to restore after the MOST RECENT verify/recommend
     // child run (see git-state-guard.ts). runWorkVerification reads this through its
     // mutationCheck dep to discard a verdict computed on a mutated tree.
@@ -488,50 +573,28 @@ export function buildGateDeps(params) {
     };
     // Adapter onto the shared gate-child runner (gate-child.ts). What survives
     // here is WIRING — which context, which log file, which config knobs, and
-    // where the live-widget state lives; the ritual and the per-kind policy are
-    // the table's. The enforce child below goes through the same call.
-    const gateChild = (gateCtx, cwd2, taskTitle, kind, logFile, opts = {}) => {
-        // An accessor box, not a copy: the runner writes these fields and the
-        // loader snapshot reads them on every tick, so both must see the same
-        // closure state the rest of buildGateDeps already shares.
-        const widget = {
-            get lastLine() {
-                return lastLine;
-            },
-            set lastLine(v) {
-                lastLine = v;
-            },
-            get contextUsage() {
-                return contextUsage;
-            },
-            set contextUsage(v) {
-                contextUsage = v;
-            }
-        };
-        return makeGateChild({
-            ctx: gateCtx,
-            cwd: cwd2,
-            taskTitle,
-            kind,
-            logPath: path.join(tasksDir(cwd2), logFile),
-            ...(opts.loader === undefined ? {} : { loader: opts.loader }),
-            commandTimeoutMs: getConfig().requestTimeoutMs,
-            streamInactivityMs: getConfig().streamInactivityMs,
-            parentContextWindow,
-            runWorker,
-            makeDebugAppender,
-            startAutoLoader,
-            captureGitState,
-            reconcileGitState,
-            describeTreeChanges: async (c, sig) => formatTreeChanges(await collectTreeChanges(c, sig)),
-            resolveContextUsage,
-            truncateToolResult,
-            widget,
-            onReconcile: rec => {
-                lastGuardReconcile = rec;
-            }
-        });
-    };
+    // the shared live status; the ritual and the per-kind policy are the
+    // table's. The enforce child below goes through the same call.
+    const gateChild = (gateCtx, cwd2, taskTitle, kind, logFile, opts = {}) => makeGateChild({
+        ctx: gateCtx,
+        cwd: cwd2,
+        taskTitle,
+        kind,
+        logPath: path.join(tasksDir(cwd2), logFile),
+        ...(opts.loader === undefined ? {} : { loader: opts.loader }),
+        commandTimeoutMs: getConfig().requestTimeoutMs,
+        streamInactivityMs: getConfig().streamInactivityMs,
+        status,
+        runWorker,
+        makeDebugAppender,
+        captureGitState,
+        reconcileGitState,
+        describeTreeChanges: async (c, sig) => formatTreeChanges(await collectTreeChanges(c, sig)),
+        truncateToolResult,
+        onReconcile: rec => {
+            lastGuardReconcile = rec;
+        }
+    });
     return {
         runTask,
         // Durable per-task gate trail: every verdict/decision lands in the task
@@ -604,15 +667,7 @@ export function buildGateDeps(params) {
         // enforce EDIT pass makes to them before those edits are committed. Reads the
         // same composed spec + extractProhibitions the verify probe consumes; empty on
         // a spec that froze nothing → the guard is a no-op.
-        frozenPaths: async (cwd2, taskId) => {
-            try {
-                const { body } = await readTaskFile(cwd2, taskId);
-                return frozenPathsFromSpec(extractSpecForVerification(body));
-            }
-            catch {
-                return [];
-            }
-        },
+        frozenPaths: async (cwd2, taskId) => frozenPathsFromSpec(await readSpecForVerification(cwd2, taskId)),
         // Restore those frozen paths to HEAD, discarding a gate child's edits to them;
         // returns the files actually reverted (for the trail). Best-effort git shape.
         revertFrozenPaths: (cwd2, paths) => revertFrozenPaths(paths, async (args) => {
@@ -654,14 +709,7 @@ export function buildGateDeps(params) {
             // The spec to verify against is the composed spec committed in the task
             // file. A task that never reached compose has no spec section —
             // runWorkVerification treats a null spec as a no-op pass.
-            let spec;
-            try {
-                const { body } = await readTaskFile(cwd2, taskId);
-                spec = extractSpecForVerification(body);
-            }
-            catch {
-                spec = null;
-            }
+            const spec = await readSpecForVerification(cwd2, taskId);
             // DEAD AIR (the reason this loader exists). The gate's DETERMINISTIC
             // stage — repo health plus ten probes — runs before the verify child,
             // and the child's own loader only starts once the child does. The impl
@@ -674,133 +722,84 @@ export function buildGateDeps(params) {
             // deterministic stage and the child — so the run is never silent.
             const gateStartedAt = Date.now();
             let stageLine;
-            // Clear the PREVIOUS child's trailer before the loader goes up: the
-            // deterministic stage has no child of its own, so a stale `↳` line from
-            // the last task's enforce pass would otherwise sit under the new
-            // status block as if it were live.
-            lastLine = undefined;
-            contextUsage = undefined;
-            const stopGateLoader = deadAirBaseline ?
-                () => { }
-                : startAutoLoader(verifyCtx, () => ({
-                    title: taskTitle,
-                    kind: 'verify',
-                    step: 'verify',
-                    stepNum: 1,
-                    stepTotal: 1,
-                    startedAt: gateStartedAt,
-                    lastLine: lastLine ?? stageLine,
-                    contextUsage
-                }));
-            try {
-                return await runWorkVerification({
+            // `track` clears the PREVIOUS child's trailer before the loader goes
+            // up: the deterministic stage has no child of its own, so a stale `↳`
+            // line from the last task's enforce pass would otherwise sit under the
+            // new status block as if it were live. The frame's `lastLine` wins
+            // over the status's own, which is how the stage label shows until
+            // the child has a line.
+            const gateFrame = deadAirBaseline ? null : (() => ({
+                title: taskTitle,
+                kind: 'verify',
+                step: 'verify',
+                stepNum: 1,
+                stepTotal: 1,
+                startedAt: gateStartedAt,
+                lastLine: status.snapshot().lastLine ?? stageLine
+            }));
+            return status.track(verifyCtx, gateFrame, () => runWorkVerification({
+                cwd: cwd2,
+                signal,
+                spec,
+                // The child renders no loader of its own: the gate-wide one above is
+                // already live and reads the same status the child feeds, so a
+                // second widget on the same key would only fight it.
+                runChild: gateChild(verifyCtx, cwd2, taskTitle, 'verify', 'verify-debug.log', {
+                    loader: deadAirBaseline
+                }),
+                // Names the deterministic step in the live status line.
+                onStage: label => {
+                    stageLine = label;
+                },
+                // Deterministic whole-repo static-analysis gate — runs the project's
+                // own lint/typecheck and fails on a real non-zero exit, independent of
+                // the model-authored VERIFY block (which may not lint at all). ASYNC:
+                // the sync runner froze the event loop for the whole lint (see above).
+                repoHealth: () => deadAirBaseline ?
+                    Promise.resolve(runRepoHealthCheck(cwd2))
+                    : runRepoHealthCheckAsync(cwd2, {
+                        signal,
+                        onCommand: c => {
+                            stageLine = `repo health · ${c}`;
+                        }
+                    }),
+                // The deterministic probes, bound in one place (buildVerifyProbes
+                // above); the PROBE_ADAPTERS table in verify-work.ts runs them.
+                probes: buildVerifyProbes({
                     cwd: cwd2,
                     signal,
+                    taskId,
                     spec,
-                    // The child renders no loader of its own: the gate-wide one above is
-                    // already live and reads the same `lastLine`/`contextUsage` the child
-                    // feeds, so a second widget on the same key would only fight it.
-                    runChild: gateChild(verifyCtx, cwd2, taskTitle, 'verify', 'verify-debug.log', {
-                        loader: deadAirBaseline
-                    }),
-                    // Names the deterministic step in the live status line.
-                    onStage: label => {
-                        stageLine = label;
-                    },
-                    // Deterministic whole-repo static-analysis gate — runs the project's
-                    // own lint/typecheck and fails on a real non-zero exit, independent of
-                    // the model-authored VERIFY block (which may not lint at all). ASYNC:
-                    // the sync runner froze the event loop for the whole lint (see above).
-                    repoHealth: () => deadAirBaseline ?
-                        Promise.resolve(runRepoHealthCheck(cwd2))
-                        : runRepoHealthCheckAsync(cwd2, {
-                            signal,
-                            onCommand: c => {
-                                stageLine = `repo health · ${c}`;
-                            }
-                        }),
-                    // Deterministic self-verification probe: test files the task itself
-                    // authored/changed become prompt-level findings mandating the child
-                    // to drive the real artifact before trusting their green result.
-                    probe: () => collectChangedFiles(cwd2, signal).then(findSubstitutionSuspects),
-                    // Deterministic test-assembly probe (F4): authored test files that
-                    // rebuild production wiring — importing the leaf modules the shipped
-                    // entry composes and assembling their own copy — become rule-3f
-                    // findings so the child drives the REAL assembly, not the copy.
-                    testAssemblyProbe: () => collectChangedFiles(cwd2, signal).then(changed => collectTestAssemblyFindings(cwd2, changed, signal)),
-                    // Deterministic probe-gaming probe (F6): added lines whose stated
-                    // purpose is to make a check pass rather than meet the requirement
-                    // ("return 401 so the verification test passes") become rule-4c
-                    // findings so the child verifies the real requirement, not the check.
-                    probeGamingProbe: () => collectAddedLines(cwd2, signal).then(findProbeGaming),
-                    // Deterministic cross-task deletion probe (mx5 run 12 PROMPT 2):
-                    // tracked files this task's diff DELETES whose introducing commit
-                    // belongs to a DIFFERENT task — a sibling's committed deliverable
-                    // destroyed (typically to green a check). Injected under rule 4d and
-                    // carried on a FAIL so an ACCEPT records durable debts.
-                    crossTaskDeletionProbe: () => collectTaskTreeChanges(cwd2, signal).then(changes => findCrossTaskDeletions(changes, taskId, rel => taskThatIntroduced(cwd2, rel))),
-                    // Deterministic sandbox-path-leak probe (mx5 run 13 PROMPT 4 item
-                    // 1): absolute paths committed from the authoring child's own
-                    // environment (`/workspace/src/shared`) that resolve nowhere here.
-                    // Repaired deterministically where the relative form provably
-                    // resolves; the remainder is injected under rule 4e, whose point is
-                    // that such a path breaks the BUILD — so the checks that would have
-                    // caught it report nothing rather than failing.
-                    foreignPathProbe: () => collectForeignPathFindings(cwd2, signal, makeDebugAppender(path.join(tasksDir(cwd2), 'verify-debug.log'))),
-                    // Deterministic neutered-check-script probe (mx5 run 13 PROMPT 4
-                    // item 4): a check script this task authored that cannot fail
-                    // (`… || true`, an inverted-grep launder). Injected under rule 4f,
-                    // because the child provably cannot find this by running the
-                    // script — it passes, which IS the defect.
-                    scriptEscapeProbe: () => collectScriptEscapeFindings(cwd2, signal),
-                    // Deterministic runner glob-collision probe (mx5 runs 7 AND 13,
-                    // PROMPT 4 item 2): both `bun test` and `playwright test` declared
-                    // with no proof their file sets are disjoint. Injected under rule
-                    // 4g — the collision kills the suite during COLLECTION, which does
-                    // not look like a test failure.
-                    runnerGlobProbe: () => collectRunnerGlobFindings(cwd2),
-                    // Deterministic prohibition probe: paths the spec forbids modifying
-                    // that the task's diff modified anyway become prompt-level findings
-                    // under the no-waiver rule — the child otherwise rarely runs `git
-                    // diff` and cannot even see the violation.
-                    prohibitionProbe: () => {
-                        const banned = spec ? extractProhibitions(spec) : [];
-                        if (banned.length === 0)
-                            return Promise.resolve([]);
-                        return collectChangedFiles(cwd2, signal).then(files => findProhibitionViolations(banned, files));
-                    },
-                    // Git-state guard result of the most recent child run: a verdict
-                    // computed on a tree the child itself mutated is discarded — but ONLY
-                    // when the mutation touched graded state (verdictTainted). A child
-                    // that merely left test-runner output behind (test-results/,
-                    // playwright-report/ …) judged an equivalent tree; its verdict stands
-                    // and the artifacts were still cleaned (mx5 run 9 lost 7 verdicts this
-                    // way — see git-state-guard.ts).
-                    mutationCheck: () => lastGuardReconcile?.verdictTainted ?
-                        { mutated: true, detail: lastGuardReconcile.actions.join('; ') }
-                        : { mutated: false, detail: '' },
-                    // Per-run environment-facts cache under .pi-tasks/ (survives
-                    // discardEdits): earlier children's discoveries save this child
-                    // the re-archaeology; its own ENV-NOTE lines are stored for the
-                    // next one, stamped with this task's id as their origin so a
-                    // later child sees a cited fact is second-hand and must
-                    // re-validate before excusing a failure (F7). Facts only —
-                    // verdict rules unaffected.
-                    envNotes: {
-                        read: () => readEnvNotes(cwd2),
-                        append: notes => appendEnvNotes(cwd2, notes, taskId)
-                    },
-                    // Per-run cross-slice contract registry under .pi-tasks/ (F3): the
-                    // verbatim interface facts the design pins that multiple slices
-                    // share, so the verify child checks this slice's boundary against
-                    // them. Empty on single-`/task` runs or a design with no shared
-                    // boundary → no block.
-                    contracts: () => readContracts(cwd2)
-                });
-            }
-            finally {
-                stopGateLoader();
-            }
+                    log: makeDebugAppender(path.join(tasksDir(cwd2), 'verify-debug.log'))
+                }),
+                // Git-state guard result of the most recent child run: a verdict
+                // computed on a tree the child itself mutated is discarded — but ONLY
+                // when the mutation touched graded state (verdictTainted). A child
+                // that merely left test-runner output behind (test-results/,
+                // playwright-report/ …) judged an equivalent tree; its verdict stands
+                // and the artifacts were still cleaned (mx5 run 9 lost 7 verdicts this
+                // way — see git-state-guard.ts).
+                mutationCheck: () => lastGuardReconcile?.verdictTainted ?
+                    { mutated: true, detail: lastGuardReconcile.actions.join('; ') }
+                    : { mutated: false, detail: '' },
+                // Per-run environment-facts cache under .pi-tasks/ (survives
+                // discardEdits): earlier children's discoveries save this child
+                // the re-archaeology; its own ENV-NOTE lines are stored for the
+                // next one, stamped with this task's id as their origin so a
+                // later child sees a cited fact is second-hand and must
+                // re-validate before excusing a failure (F7). Facts only —
+                // verdict rules unaffected.
+                envNotes: {
+                    read: () => readEnvNotes(cwd2),
+                    append: notes => appendEnvNotes(cwd2, notes, taskId)
+                },
+                // Per-run cross-slice contract registry under .pi-tasks/ (F3): the
+                // verbatim interface facts the design pins that multiple slices
+                // share, so the verify child checks this slice's boundary against
+                // them. Empty on single-`/task` runs or a design with no shared
+                // boundary → no block.
+                contracts: () => readContracts(cwd2)
+            }));
         },
         lintFix: async (fixCtx, cwd2, taskTitle, taskId, failReason) => {
             // Same frozen extraction the enforce guard and the verify rule-4b
@@ -808,14 +807,8 @@ export function buildGateDeps(params) {
             // tsconfig.json because ESLint's own error text instructed it, then
             // verify failed the TASK for that edit — the child must know the
             // spec's do-not-touch list AND be mechanically denied it).
-            let frozenPaths = [];
-            try {
-                const { body } = await readTaskFile(cwd2, taskId);
-                frozenPaths = frozenPathsFromSpec(extractSpecForVerification(body));
-            }
-            catch {
-                // spec unreadable → no frozen paths; the guard degrades to a no-op
-            }
+            // (spec unreadable → no frozen paths; the guard degrades to a no-op)
+            const frozenPaths = frozenPathsFromSpec(await readSpecForVerification(cwd2, taskId));
             return runBoundedLintFix({
                 cwd: cwd2,
                 signal,
@@ -906,14 +899,7 @@ export function buildGateDeps(params) {
         recommend: async (recCtx, cwd2, taskTitle, taskId, failReason) => {
             // Read the same composed spec the verify gate judged against, so the
             // recommendation reasons over the real contract (degrade to the bare title).
-            let spec;
-            try {
-                const { body } = await readTaskFile(cwd2, taskId);
-                spec = extractSpecForVerification(body) ?? taskTitle;
-            }
-            catch {
-                spec = taskTitle;
-            }
+            const spec = (await readSpecForVerification(cwd2, taskId)) ?? taskTitle;
             return researchResolution({
                 cwd: cwd2,
                 signal,