@mjasnikovs/pi-task 0.38.2 → 0.38.3

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

@@ -0,0 +1,104 @@
+/**
+ * gate-child — running ONE gate child pi, and the table of what each kind of gate
+ * child is allowed to do.
+ *
+ * Five children run under the gates: `verify`, `recommend`, `lint-fix`,
+ * `final-fix` and `enforce`. All five share one ritual — reset the widget state,
+ * stamp the start, open a per-gate debug log, write a start marker, raise a
+ * status loader, call `runWorker` unguarded (no wall clock, exact-match loop
+ * guard only), warn on a surviving loop, classify the failure, write an end
+ * marker, throw on failure, and stop the loader in a `finally`. That was ~85
+ * lines, and it was written TWICE: once as `makeGateChild` and once as an inline
+ * closure for `enforce`, whose comments repeated the originals verbatim.
+ *
+ * The enforce copy differed in exactly four things — no git-state guard, no
+ * tool-result logging, no tree-change capture, and a different end marker — which
+ * is why they are row data here rather than a forked body. Apply the deletion
+ * test to that copy and it passes: routing enforce through this concentrates the
+ * differences into a table instead of moving them.
+ *
+ * The second reason for the module is that all of it used to live inside
+ * `buildGateDeps`'s closure, so nothing about it was reachable from a test:
+ * `buildGateDeps` is ~700 lines and is never called by the suite. The
+ * git-state-guard wiring in particular — snapshot, restore-in-`finally`,
+ * `verdictTainted` — is the mechanism that discards a verify verdict computed on
+ * a tree the child mutated (mx5 run 6, where the verify child `git stash`ed the
+ * task's uncommitted work and never popped it), and it could only be checked
+ * indirectly through a fake `mutationCheck` one layer up. Here `runWorker` and
+ * the git helpers are injected, so the ordering, the trail lines and the
+ * throwing-child path are all directly assertable.
+ */
+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';
+/** Which gate child this is. */
+export type GateChildKind = 'verify' | 'recommend' | 'lint-fix' | 'final-fix' | 'enforce';
+export interface GateChildRow {
+    /**
+     * Snapshot the tree before and restore after. These children are read-only BY
+     * CONTRACT, but the contract is prompt-level and the live model breaks it.
+     * `lint-fix` and `final-fix` are excluded because editing is their job (they
+     * carry their own revert guards), and `enforce` because it edits too.
+     */
+    guarded: boolean;
+    /**
+     * Log tool OUTPUTS, not just the calls (mx5 run 10 item 6): without the result,
+     * "verify claimed curl PASS on a server that cannot serve" is undecidable from
+     * the log. Off for `enforce`, whose log is a per-pass verdict trail.
+     */
+    logToolResults: boolean;
+    /** The loader's step label. */
+    step: string;
+    /** The end-marker written on success. */
+    okMarker: string;
+}
+/**
+ * What each kind may do. Adding a child is a row; it cannot be added without
+ * deciding all four questions, which is the point.
+ */
+export declare const GATE_CHILD_KINDS: Record<GateChildKind, GateChildRow>;
+/** Everything the runner needs that is not a property of the KIND. */
+export interface GateChildDeps {
+    ctx: ExtensionCommandContext;
+    cwd: string;
+    taskTitle: string;
+    kind: GateChildKind;
+    /** Absolute path of the debug log for this gate. */
+    logPath: string;
+    /**
+     * `false` when the CALLER already renders a loader spanning this child (the
+     * verify gate does). Two loaders on one widget key only fight each other.
+     */
+    loader?: boolean;
+    /** Per-command ceiling; pi's bash tool has no default timeout. */
+    commandTimeoutMs: number;
+    /** Hung-stream bound; the probe-based stall guard cannot supply it. */
+    streamInactivityMs: number;
+    parentContextWindow: number;
+    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;
+}
+/**
+ * Build the `runChild` closure the gate steps expect.
+ *
+ * The `finally` ordering is load-bearing: the git-state restore runs BEFORE any
+ * verdict or failure is acted on, and it runs even when the child THREW — a
+ * crashed child must not skip the restore.
+ */
+export declare function makeGateChild(deps: GateChildDeps): (tools: string, prompt: string, sig?: AbortSignal) => Promise<string>;

package/dist/task/gate-child.js

@@ -0,0 +1,177 @@
+/**
+ * gate-child — running ONE gate child pi, and the table of what each kind of gate
+ * child is allowed to do.
+ *
+ * Five children run under the gates: `verify`, `recommend`, `lint-fix`,
+ * `final-fix` and `enforce`. All five share one ritual — reset the widget state,
+ * stamp the start, open a per-gate debug log, write a start marker, raise a
+ * status loader, call `runWorker` unguarded (no wall clock, exact-match loop
+ * guard only), warn on a surviving loop, classify the failure, write an end
+ * marker, throw on failure, and stop the loader in a `finally`. That was ~85
+ * lines, and it was written TWICE: once as `makeGateChild` and once as an inline
+ * closure for `enforce`, whose comments repeated the originals verbatim.
+ *
+ * The enforce copy differed in exactly four things — no git-state guard, no
+ * tool-result logging, no tree-change capture, and a different end marker — which
+ * is why they are row data here rather than a forked body. Apply the deletion
+ * test to that copy and it passes: routing enforce through this concentrates the
+ * differences into a table instead of moving them.
+ *
+ * The second reason for the module is that all of it used to live inside
+ * `buildGateDeps`'s closure, so nothing about it was reachable from a test:
+ * `buildGateDeps` is ~700 lines and is never called by the suite. The
+ * git-state-guard wiring in particular — snapshot, restore-in-`finally`,
+ * `verdictTainted` — is the mechanism that discards a verify verdict computed on
+ * a tree the child mutated (mx5 run 6, where the verify child `git stash`ed the
+ * task's uncommitted work and never popped it), and it could only be checked
+ * indirectly through a fake `mutationCheck` one layer up. Here `runWorker` and
+ * the git helpers are injected, so the ordering, the trail lines and the
+ * throwing-child path are all directly assertable.
+ */
+import { formatLoopHint } from './child-runner.js';
+import { classifyEnforceChildFailure } from './enforce-guidelines.js';
+/**
+ * What each kind may do. Adding a child is a row; it cannot be added without
+ * deciding all four questions, which is the point.
+ */
+export const GATE_CHILD_KINDS = {
+    verify: { guarded: true, logToolResults: true, step: 'verify', okMarker: 'ok' },
+    recommend: { guarded: true, logToolResults: true, step: 'recommend', okMarker: 'ok' },
+    // Editing is lint-fix's job, so the guard would revert its work.
+    'lint-fix': { guarded: false, logToolResults: true, step: 'lint-fix', okMarker: 'ok' },
+    'final-fix': { guarded: false, logToolResults: true, step: 'final-fix', okMarker: 'ok' },
+    enforce: {
+        guarded: false,
+        logToolResults: false,
+        step: 'guidelines',
+        okMarker: 'verdict captured'
+    }
+};
+/**
+ * Build the `runChild` closure the gate steps expect.
+ *
+ * The `finally` ordering is load-bearing: the git-state restore runs BEFORE any
+ * verdict or failure is acted on, and it runs even when the child THREW — a
+ * crashed child must not skip the restore.
+ */
+export function makeGateChild(deps) {
+    const row = GATE_CHILD_KINDS[deps.kind];
+    return async (tools, prompt, sig) => {
+        deps.widget.lastLine = undefined;
+        deps.widget.contextUsage = undefined;
+        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
+        // the default level. Only the child's own stdout and its tool results
+        // pass 'stream'.
+        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, () => ({
+                title: deps.taskTitle,
+                kind: deps.kind,
+                step: row.step,
+                stepNum: 1,
+                stepTotal: 1,
+                startedAt,
+                lastLine: deps.widget.lastLine,
+                contextUsage: deps.widget.contextUsage
+            }));
+        try {
+            let r;
+            try {
+                r = await deps.runWorker({
+                    prompt,
+                    cwd: deps.cwd,
+                    ...(sig ? { signal: sig } : {}),
+                    tools,
+                    // Run to completion: these passes legitimately read and edit the
+                    // same file many times, and the research-worker guards mislabel
+                    // that as a runaway and kill good work (mx5 TASK_0002).
+                    timeoutMs: 0,
+                    commandTimeoutMs: deps.commandTimeoutMs,
+                    streamInactivityMs: deps.streamInactivityMs,
+                    // Exact-match loop guard only: pathThreshold Infinity disables
+                    // the path-revisit heuristic, so revisiting one file (which IS
+                    // the job) never trips — only a literally-identical call
+                    // repeated past threshold does.
+                    loop: { pathThreshold: Number.POSITIVE_INFINITY },
+                    // A discarded attempt is otherwise invisible: the returned
+                    // exitCode/text describe the FINAL attempt, so a child that
+                    // burned two attempts reads exactly like one that ran clean.
+                    onRestart: rs => log(`=== ${deps.kind} RESTART (attempt ${rs.attempt} discarded)`
+                        + ` reason=${rs.reason} wall=${rs.wallMs}ms`
+                        + (rs.detail ? ` — ${rs.detail}` : '')
+                        + ' ==='),
+                    onLine: line => {
+                        // `lastLine` 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;
+                        log(line, 'stream');
+                    },
+                    ...(row.logToolResults ?
+                        {
+                            onToolResult: ({ name, isError, text }) => log(`↳ ${name} [${isError ? 'ERR' : 'ok'}]: `
+                                + deps.truncateToolResult(text), 'stream')
+                        }
+                        : {}),
+                    onContextUsage: snapshot => {
+                        deps.widget.contextUsage = deps.resolveContextUsage(snapshot, deps.widget.contextUsage, deps.parentContextWindow);
+                    }
+                });
+            }
+            finally {
+                // Restore whatever the child moved BEFORE any verdict or failure is
+                // acted on — a crashed child must not skip the restore either.
+                if (guardSnapshot) {
+                    const rec = await deps.reconcileGitState(deps.cwd, guardSnapshot, sig);
+                    deps.onReconcile?.(rec);
+                    if (rec.mutated) {
+                        // Distinguish the two outcomes in the trail: a tainting
+                        // mutation (graded work altered → verdict discarded) vs
+                        // benign cleanup (test-runner output the child left behind
+                        // → verdict stands).
+                        const label = rec.verdictTainted ?
+                            'child mutated graded state (verdict discarded)'
+                            : 'cleaned child test-runner artifacts (verdict kept)';
+                        log(`=== ${deps.kind} GIT-STATE GUARD — ${label}; `
+                            + `restored: ${rec.actions.join('; ')} ===`);
+                        if (rec.verdictTainted) {
+                            deps.ctx.ui.notify(`${deps.taskTitle}: ${deps.kind} child mutated repo state — `
+                                + `restored (${rec.actions.join('; ').slice(0, 140)}).`, 'warning');
+                        }
+                    }
+                }
+            }
+            // A loop that survived the restart-with-hint nudges is a WARNING, not a
+            // failure: log it and tell the user, but let the verdict gate be the
+            // only thing that can block.
+            if (r.loopHit) {
+                log(`=== ${deps.kind} LOOP WARNING — ${formatLoopHint(r.loopHit)} ===`);
+                deps.ctx.ui.notify(`${deps.taskTitle}: ${deps.kind} worker looped past the nudges — `
+                    + 'continuing (not blocked).', 'warning');
+            }
+            const failure = classifyEnforceChildFailure(r);
+            log(failure ?
+                `=== ${deps.kind} end: FAIL — ${failure} ===`
+                : `=== ${deps.kind} end: ${row.okMarker} ===`);
+            if (failure)
+                throw new Error(failure);
+            // CAPABILITY-LEVEL diff capture (mx5 run 11): any WRITE-capable child —
+            // decided by its TOOLS, not by which phase spawned it — gets its tree
+            // changes logged, so a future write-capable kind cannot run invisibly
+            // the way the final-fix child's `rm` did.
+            if (/\b(?:edit|bash|write)\b/.test(tools)) {
+                log(`=== ${deps.kind} tree changes: `
+                    + `${await deps.describeTreeChanges(deps.cwd, sig)} ===`);
+            }
+            return r.text;
+        }
+        finally {
+            stopLoader();
+        }
+    };
+}

package/dist/task/gate-deps.js

@@ -18,7 +18,7 @@ import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
 import { tasksDir, readTaskFile, appendGateRecord } from './task-io.js';
 import { gitCommitAll, gitDropLastCommit, git } from './auto-commit.js';
-import { runGuidelineEnforcement, classifyEnforceChildFailure } from './enforce-guidelines.js';
+import { runGuidelineEnforcement } from './enforce-guidelines.js';
 import { runWorkVerification, extractSpecForVerification } from './verify-work.js';
 import { readEnvNotes, appendEnvNotes } from './env-notes.js';
 import { readContracts } from './contracts.js';
@@ -41,11 +41,11 @@ import { findScriptEscapesInManifest, scriptEscapeVerifyFindings } from './scrip
 import { assessRunnerGlobs, runnerGlobVerifyFindings } from './runner-globs.js';
 import { captureGitState, reconcileGitState } from './git-state-guard.js';
 import { runWorker } from '../workers/pi-worker-core.js';
-import { formatLoopHint } from './child-runner.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 { 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;
 /**
@@ -474,136 +474,51 @@ export function buildGateDeps(params) {
         await git(cwd2, ['checkout', '--', '.', EXCLUDE_TASKS_DIR], signal);
         await git(cwd2, ['clean', '-fd', '-e', '.pi-tasks'], signal);
     };
-    // Shared runner for the per-task GATE children (verify + post-FAIL recommend).
-    // Both are read-only passes of the same local model that must run to completion:
-    // unguarded (no wall-clock timeout, exact-match loop guard only, path-revisit
-    // disabled because re-running the same check is the job), with a status widget
-    // and a per-gate debug log. Returns the closure runWorkVerification /
-    // researchResolution expect as `runChild`.
-    const makeGateChild = (gateCtx, cwd2, taskTitle, kind, logFile, 
-    /** `loader: false` when the CALLER already renders a loader that spans
-     *  this child (the verify gate does — see its dead-air note). Two
-     *  loaders on one widget key only fight each other. */
-    opts = {}) => async (tools, prompt, sig) => {
-        lastLine = undefined;
-        contextUsage = undefined;
-        lastGuardReconcile = null;
-        const startedAt = Date.now();
-        // `kind` defaults to 'event': every marker below (start/end, the
-        // git-state guard's restore, the loop warning, a write-capable child's
-        // tree changes) is a guard record that survives at the default level.
-        // Only the child's own stdout and its tool results pass 'stream'.
-        const log = makeDebugAppender(path.join(tasksDir(cwd2), logFile));
-        log(`=== ${kind} start: ${taskTitle} ===`);
-        // GIT-STATE GUARD: these children are read-only BY CONTRACT, but the
-        // contract is prompt-level and the live model breaks it (mx5 run 6: the
-        // verify child `git stash`ed the task's uncommitted work and never popped
-        // — the impl was destroyed and the orphan stash detonated 2 days later).
-        // Snapshot before, deterministically restore after; lint-fix is excluded
-        // because editing is its job (it carries its own revert guard).
-        const guardSnapshot = kind === 'verify' || kind === 'recommend' ? await captureGitState(cwd2, sig) : null;
-        const stopLoader = opts.loader === false ?
-            () => { }
-            : startAutoLoader(gateCtx, () => ({
-                title: taskTitle,
-                kind,
-                step: kind,
-                stepNum: 1,
-                stepTotal: 1,
-                startedAt,
-                lastLine,
-                contextUsage
-            }));
-        try {
-            let r;
-            try {
-                r = await runWorker({
-                    prompt,
-                    cwd: cwd2,
-                    signal: sig,
-                    tools,
-                    timeoutMs: 0,
-                    // The gate child runs to completion (timeoutMs 0), but a
-                    // single command inside it must still be bounded: pi's bash
-                    // tool has no default timeout, so a `bun run dev` / hung
-                    // check the model forgot to bound wedges the gate forever.
-                    // The stall guard cannot see it — a reachable model endpoint
-                    // reads as proof of life while the command blocks. Same
-                    // ceiling the main session uses, so one /task-config knob
-                    // covers implementation and gates alike.
-                    commandTimeoutMs: getConfig().requestTimeoutMs,
-                    // Same reasoning one level up: a gate child with no
-                    // wall-clock cap also needs the HUNG-STREAM bound, which
-                    // the probe-based stall guard structurally cannot supply
-                    // (a healthy endpoint reads as proof of life).
-                    streamInactivityMs: getConfig().streamInactivityMs,
-                    loop: { pathThreshold: Number.POSITIVE_INFINITY },
-                    // A discarded attempt is otherwise invisible here too: the
-                    // returned exitCode/text describe the FINAL attempt, so a
-                    // gate child that burned two attempts and its wall clock
-                    // reads exactly like one that ran clean.
-                    onRestart: rs => log(`=== ${kind} RESTART (attempt ${rs.attempt} discarded)`
-                        + ` reason=${rs.reason} wall=${rs.wallMs}ms`
-                        + (rs.detail ? ` — ${rs.detail}` : '')
-                        + ' ==='),
-                    onLine: line => {
-                        // `lastLine` feeds the LIVE status widget and is not
-                        // logging — it stays outside the gate, or a quiet
-                        // trail would also blank the progress display.
-                        lastLine = line;
-                        log(line, 'stream');
-                    },
-                    // Log tool OUTPUTS, not just the command (mx5 run 10 item 6):
-                    // without the result "verify claimed curl PASS on a server that
-                    // cannot serve" is undecidable from the log. Truncated, tail-kept
-                    // (a bind failure / status usually lands at the end), error-flagged.
-                    onToolResult: ({ name, isError, text }) => log(`↳ ${name} [${isError ? 'ERR' : 'ok'}]: ${truncateToolResult(text)}`, 'stream'),
-                    onContextUsage: snapshot => {
-                        contextUsage = resolveContextUsage(snapshot, contextUsage, parentContextWindow);
-                    }
-                });
+    // 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;
             }
-            finally {
-                // Restore whatever the child moved BEFORE any verdict/failure is
-                // acted on — a crashed child must not skip the restore either.
-                if (guardSnapshot) {
-                    const rec = await reconcileGitState(cwd2, guardSnapshot, sig);
-                    lastGuardReconcile = rec;
-                    if (rec.mutated) {
-                        // Distinguish the two outcomes in the trail: a tainting
-                        // mutation (graded work altered → verdict will be
-                        // discarded) vs benign cleanup (test-runner output the
-                        // child left behind → verdict stands).
-                        const label = rec.verdictTainted ?
-                            'child mutated graded state (verdict discarded)'
-                            : 'cleaned child test-runner artifacts (verdict kept)';
-                        log(`=== ${kind} GIT-STATE GUARD — ${label}; restored: ${rec.actions.join('; ')} ===`);
-                        if (rec.verdictTainted) {
-                            gateCtx.ui.notify(`${taskTitle}: ${kind} child mutated repo state — restored (${rec.actions.join('; ').slice(0, 140)}).`, 'warning');
-                        }
-                    }
-                }
-            }
-            if (r.loopHit) {
-                log(`=== ${kind} LOOP WARNING — ${formatLoopHint(r.loopHit)} ===`);
-                gateCtx.ui.notify(`${taskTitle}: ${kind} worker looped past the nudges — continuing (not blocked).`, 'warning');
-            }
-            const failure = classifyEnforceChildFailure(r);
-            log(failure ? `=== ${kind} end: FAIL — ${failure} ===` : `=== ${kind} end: ok ===`);
-            if (failure)
-                throw new Error(failure);
-            // CAPABILITY-LEVEL diff capture (mx5 run 11): any WRITE-capable
-            // child — decided by its tools, not by which phase spawned it —
-            // gets its tree changes logged, so a future write-capable kind
-            // cannot run invisibly the way the final-fix child's `rm` did.
-            if (/\b(?:edit|bash|write)\b/.test(tools)) {
-                log(`=== ${kind} tree changes: ${formatTreeChanges(await collectTreeChanges(cwd2, sig))} ===`);
+        };
+        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;
             }
-            return r.text;
-        }
-        finally {
-            stopLoader();
-        }
+        });
     };
     return {
         runTask,
@@ -710,77 +625,14 @@ export function buildGateDeps(params) {
                 // research-worker guards mislabel that as a runaway and kill good work
                 // (proven on mx5 TASK_0002). classifyEnforceChildFailure still blocks
                 // on a real failure (non-zero exit, leaked tool call) or a user cancel.
-                runChild: async (tools, prompt, sig) => {
-                    lastLine = undefined;
-                    contextUsage = undefined;
-                    const startedAt = Date.now();
-                    // Per-pass debug log; the enforce child is otherwise unobservable.
-                    const logEnforce = makeDebugAppender(path.join(tasksDir(cwd2), 'enforce-debug.log'));
-                    logEnforce(`=== enforce start: ${taskTitle} ===`);
-                    const stopLoader = startAutoLoader(enforceCtx, () => ({
-                        title: taskTitle,
-                        kind: 'enforce',
-                        step: 'guidelines',
-                        stepNum: 1,
-                        stepTotal: 1,
-                        startedAt,
-                        lastLine,
-                        contextUsage
-                    }));
-                    try {
-                        const r = await runWorker({
-                            prompt,
-                            cwd: cwd2,
-                            signal: sig,
-                            tools,
-                            timeoutMs: 0, // no wall-clock timeout — run to completion
-                            // …but still bound any SINGLE command (see makeGateChild).
-                            // enforce is read,edit today, so nothing here can hang on
-                            // bash — wired anyway so a future tool grant can't quietly
-                            // re-open the hole.
-                            commandTimeoutMs: getConfig().requestTimeoutMs,
-                            // Unbounded wall clock here too — the hung-stream
-                            // bound is the only thing that ends a dead stream.
-                            streamInactivityMs: getConfig().streamInactivityMs,
-                            // Exact-match loop guard only: pathThreshold Infinity
-                            // disables the path-revisit heuristic, so revisiting one
-                            // file (which IS this pass's job) never trips — only a
-                            // literally-identical call repeated past threshold does.
-                            loop: { pathThreshold: Number.POSITIVE_INFINITY },
-                            // Same reasoning as the gate child: without this a
-                            // discarded attempt leaves no trace anywhere.
-                            onRestart: rs => logEnforce(`=== enforce RESTART (attempt ${rs.attempt} discarded)`
-                                + ` reason=${rs.reason} wall=${rs.wallMs}ms`
-                                + (rs.detail ? ` — ${rs.detail}` : '')
-                                + ' ==='),
-                            onLine: line => {
-                                // `lastLine` drives the live widget, not the trail.
-                                lastLine = line;
-                                logEnforce(line, 'stream');
-                            },
-                            onContextUsage: snapshot => {
-                                contextUsage = resolveContextUsage(snapshot, contextUsage, parentContextWindow);
-                            }
-                        });
-                        // A loop that survived the restart-with-hint nudges is a
-                        // warning, not a failure: log it and tell the user, but let the
-                        // verdict gate be the only thing that can block.
-                        if (r.loopHit) {
-                            logEnforce(`=== enforce LOOP WARNING — ${formatLoopHint(r.loopHit)} ===`);
-                            enforceCtx.ui.notify(`${taskTitle}: enforce worker looped past the nudges — continuing (not blocked).`, 'warning');
-                        }
-                        const failure = classifyEnforceChildFailure(r);
-                        logEnforce(failure ?
-                            `=== enforce end: FAIL — ${failure} ===`
-                            : '=== enforce end: verdict captured ===');
-                        if (failure)
-                            throw new Error(failure);
-                        return r.text;
-                    }
-                    finally {
-                        stopLoader();
-                    }
-                }
+                //
+                // This used to be an inline ~85-line copy of the gate-child ritual,
+                // differing only in the four things GATE_CHILD_KINDS now carries as
+                // row data: no git-state guard (editing is this pass's job), no
+                // tool-result logging, no tree-change capture, and its own end
+                // marker. Its own debug log stays — the enforce child is otherwise
+                // unobservable.
+                runChild: gateChild(enforceCtx, cwd2, taskTitle, 'enforce', 'enforce-debug.log')
             });
         },
         verify: async (verifyCtx, cwd2, taskTitle, taskId) => {
@@ -836,7 +688,7 @@ export function buildGateDeps(params) {
                     // 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: makeGateChild(verifyCtx, cwd2, taskTitle, 'verify', 'verify-debug.log', {
+                    runChild: gateChild(verifyCtx, cwd2, taskTitle, 'verify', 'verify-debug.log', {
                         loader: deadAirBaseline
                     }),
                     // Names the deterministic step in the live status line.
@@ -956,7 +808,7 @@ export function buildGateDeps(params) {
                 cwd: cwd2,
                 signal,
                 failReason,
-                runChild: makeGateChild(fixCtx, cwd2, taskTitle, 'lint-fix', 'verify-debug.log'),
+                runChild: gateChild(fixCtx, cwd2, taskTitle, 'lint-fix', 'verify-debug.log'),
                 repoHealth: () => runRepoHealthCheckAsync(cwd2, { signal }),
                 git: async (args) => {
                     const r = await git(cwd2, args, signal);
@@ -1005,7 +857,7 @@ export function buildGateDeps(params) {
             cwd: cwd2,
             signal,
             failReason,
-            runChild: makeGateChild(fixCtx, cwd2, 'final integration gate', 'final-fix', 'final-gate-debug.log'),
+            runChild: gateChild(fixCtx, cwd2, 'final integration gate', 'final-fix', 'final-gate-debug.log'),
             // The gate re-run is the only arbiter of convergence, and the
             // shrink guard's discovery is the gate's own (see final-gate.ts).
             gate: c => runFinalIntegrationGate(c),
@@ -1055,7 +907,7 @@ export function buildGateDeps(params) {
                 signal,
                 spec,
                 failReason,
-                runChild: makeGateChild(recCtx, cwd2, taskTitle, 'recommend', 'verify-debug.log')
+                runChild: gateChild(recCtx, cwd2, taskTitle, 'recommend', 'verify-debug.log')
             });
         }
     };