@mjasnikovs/pi-task 0.38.2 → 0.38.4

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;
 /**
@@ -61,6 +61,18 @@ export function truncateToolResult(text, limit = TOOL_RESULT_LOG_LIMIT) {
 }
 /** Keep the gate machinery's own artifacts out of every git pathspec below. */
 const EXCLUDE_TASKS_DIR = ':(exclude).pi-tasks';
+/**
+ * Pin the diff header prefixes on any command whose output we PARSE for paths.
+ *
+ * `parseAddedLines` reads the file out of the `+++ b/…` header, but the prefix is
+ * user-configurable: `diff.mnemonicPrefix=true` emits `i/` and `w/` instead of
+ * `a/` and `b/`, and `diff.noprefix=true` emits none. Both are common developer
+ * settings, and under either one every added line was attributed to a path like
+ * `w/src/app.ts`, which exists nowhere — so the probe-gaming and sandbox-path
+ * probes silently read a diff of files that are not in the repo. Passing the
+ * prefixes explicitly makes the output independent of the host's git config.
+ */
+const DIFF_PREFIX_ARGS = ['--src-prefix=a/', '--dst-prefix=b/'];
 const splitLines = (s) => s
     .split('\n')
     .map(l => l.trim())
@@ -110,7 +122,7 @@ export async function collectChangedFiles(cwd, signal) {
  * never a blocker. The `.pi-tasks/` bookkeeping is excluded from every git command.
  */
 export async function collectAddedLines(cwd, signal) {
-    const tracked = await git(cwd, ['diff', 'HEAD', '--', '.', EXCLUDE_TASKS_DIR], signal);
+    const tracked = await git(cwd, ['diff', ...DIFF_PREFIX_ARGS, 'HEAD', '--', '.', EXCLUDE_TASKS_DIR], signal);
     const lines = tracked.exitCode === 0 ? parseAddedLines(tracked.stdout) : [];
     const untracked = await git(cwd, ['ls-files', '--others', '--exclude-standard', '--', '.', EXCLUDE_TASKS_DIR], signal);
     for (const name of splitLines(untracked.exitCode === 0 ? untracked.stdout : '')) {
@@ -124,7 +136,7 @@ export async function collectAddedLines(cwd, signal) {
         }
     }
     if (lines.length === 0) {
-        const last = await git(cwd, ['diff', 'HEAD~1..HEAD', '--', '.', EXCLUDE_TASKS_DIR], signal);
+        const last = await git(cwd, ['diff', ...DIFF_PREFIX_ARGS, 'HEAD~1..HEAD', '--', '.', EXCLUDE_TASKS_DIR], signal);
         return last.exitCode === 0 ? parseAddedLines(last.stdout) : [];
     }
     return lines;
@@ -141,7 +153,7 @@ export async function collectAddedLines(cwd, signal) {
  * cannot repair still reaches the child under rule 4e. Failures degrade to no
  * findings — a sharpener, never a blocker.
  */
-async function collectForeignPathFindings(cwd, signal, logDebug) {
+export async function collectForeignPathFindings(cwd, signal, logDebug) {
     const lines = await collectAddedLines(cwd, signal);
     if (lines.length === 0)
         return [];
@@ -474,136 +486,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);
-                    }
-                });
-            }
-            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');
+    // 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;
             }
-            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 +637,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 +700,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 +820,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 +869,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 +919,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')
             });
         }
     };

package/dist/task/orchestrator.js

@@ -42,6 +42,7 @@ import { beginRun, endRun, takeHeldInput } from './mid-run-input.js';
 import { reportDroppedInput } from './dropped-input.js';
 import { formatTimings } from './timings.js';
 import { getParentContextWindow, resolveContextUsage } from './context-usage.js';
+import { TERMINAL_OUTCOMES, formatAt, formatWhy } from './terminal-outcome.js';
 // ─── Module-level state ──────────────────────────────────────────────────────
 let activeTask = null;
 /** Set the module-level active task (avoids `this` aliasing in TaskRunner.run). */
@@ -792,28 +793,18 @@ async function runGatedTaskInner(ctx, cwd, raw, opts = {}) {
         // No sibling plan → no scope fence; no parent list → no check-off.
     });
     active = gate.ctx;
-    switch (gate.kind) {
-        case 'paused':
-            await markResumable(cwd, res.taskId);
-            announce(`${tag} paused — verification failed and you dismissed the choice; resume with /task-resume.`, 'warning');
-            return;
-        case 'session-cancelled':
-            announce(`${tag} paused — could not start a session for autofix. Run /task-resume to retry.`, 'warning');
-            return;
-        case 'interrupted':
-            await markResumable(cwd, res.taskId);
-            announce(`${tag} paused — resume with /task-resume.`, 'warning');
-            return;
-        case 'failed': {
-            await markResumable(cwd, res.taskId);
-            const why = gate.reason ? ` — ${gate.reason.slice(0, 160)}` : '';
-            announce(`${tag} stopped${why} — fix and run /task-resume.`, 'error');
-            return;
-        }
-        case 'done':
-            announce(`${tag} complete — verified.`, 'info');
-            return;
-    }
+    // What each outcome means for persistence and for the user is stated once, in
+    // TERMINAL_OUTCOMES, and shared with /task-auto's loop. `failParent` is
+    // ignored here: /task runs one task and has no parent run file to fail.
+    const outcome = TERMINAL_OUTCOMES[gate.kind];
+    if (outcome.markResumable)
+        await markResumable(cwd, res.taskId);
+    announce(outcome.message({
+        tag,
+        at: formatAt(),
+        why: formatWhy(gate.kind === 'failed' ? gate.reason : undefined),
+        resumeCmd: '/task-resume'
+    }), outcome.level);
 }
 // ─── Command handlers ────────────────────────────────────────────────────────
 async function handleTask(args, ctx) {