@mjasnikovs/pi-task 0.17.26 → 0.18.0

package/dist/task/gate-deps.js

@@ -19,7 +19,10 @@ import { tasksDir, readTaskFile, appendGateRecord } from './task-io.js';
 import { gitCommitAll, gitDropLastCommit, git } from './auto-commit.js';
 import { runGuidelineEnforcement, classifyEnforceChildFailure } from './enforce-guidelines.js';
 import { runWorkVerification, extractSpecForVerification } from './verify-work.js';
+import { readEnvNotes, appendEnvNotes } from './env-notes.js';
 import { runRepoHealthCheck } from './repo-health-check.js';
+import { runFinalIntegrationGate, discoverGateCommandLabels } from './final-gate.js';
+import { runFinalGateAutofix } from './final-gate-fix.js';
 import { researchResolution } from './verify-resolution.js';
 import { findSubstitutionSuspects } from './substitution-probe.js';
 import { runBoundedLintFix } from './lint-fix.js';
@@ -88,6 +91,13 @@ export function buildGateDeps(params) {
     // child run (see git-state-guard.ts). runWorkVerification reads this through its
     // mutationCheck dep to discard a verdict computed on a mutated tree.
     let lastGuardReconcile = null;
+    // Restore tracked files to HEAD and drop files a pass created; the .pi-tasks
+    // trail/log writes made during the pass survive both. Shared by the enforce
+    // pre-commit gate (discardEdits) and the final-gate autofix shrink guard.
+    const discardTreeEdits = async (cwd2) => {
+        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
@@ -285,7 +295,15 @@ export function buildGateDeps(params) {
                 // guard already restored the state — see git-state-guard.ts).
                 mutationCheck: () => lastGuardReconcile?.mutated ?
                     { mutated: true, detail: lastGuardReconcile.actions.join('; ') }
-                    : { mutated: false, detail: '' }
+                    : { 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. Facts only — verdict rules unaffected.
+                envNotes: {
+                    read: () => readEnvNotes(cwd2),
+                    append: notes => appendEnvNotes(cwd2, notes)
+                }
             });
         },
         lintFix: (fixCtx, cwd2, taskTitle, failReason) => runBoundedLintFix({
@@ -305,12 +323,18 @@ export function buildGateDeps(params) {
             const r = await git(cwd2, ['status', '--porcelain', '--', '.', EXCLUDE_TASKS_DIR], signal);
             return r.exitCode === 0 && r.stdout.trim().length > 0;
         },
-        discardEdits: async (cwd2) => {
-            // Restore tracked files to HEAD and drop files the pass created; the
-            // .pi-tasks trail/log writes made during the pass survive both.
-            await git(cwd2, ['checkout', '--', '.', EXCLUDE_TASKS_DIR], signal);
-            await git(cwd2, ['clean', '-fd', '-e', '.pi-tasks'], signal);
-        },
+        discardEdits: discardTreeEdits,
+        finalGateFix: (fixCtx, cwd2, failReason) => runFinalGateAutofix({
+            cwd: cwd2,
+            signal,
+            failReason,
+            runChild: makeGateChild(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),
+            discoverLabels: discoverGateCommandLabels,
+            discard: discardTreeEdits
+        }),
         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).

package/dist/task/orchestrator.d.ts

@@ -92,8 +92,9 @@ export interface RunSingleTaskOptions {
      * Ask the user for a steering message after they interrupt (ESC) the
      * implementation turn. Return text to continue the same task as another turn,
      * or undefined/empty to pause the run. Only consulted with
-     * waitForImplementation. Defaults to a ctx.ui.input prompt; injectable so the
-     * steer loop is testable without a real dialog.
+     * waitForImplementation. Defaults to a bridged SessionUI.ask (local TUI input
+     * raced against a remote browser card); injectable so the steer loop is
+     * testable without a real dialog.
      */
     promptSteer?: (ctx: ExtensionCommandContext) => Promise<string | undefined>;
     /**

package/dist/task/orchestrator.js

@@ -25,7 +25,7 @@ import { readTextFile } from '../shared/fs-text.js';
 import { allocateTaskId, ensureTasksDir, readSection, readTaskFile, setTaskSection, taskFilePath, tasksDir, updateTaskFrontMatter, writeTaskFile } from './task-io.js';
 import { startWidget } from './widget.js';
 import { armImplWidget, disarmImplWidget, setupImplWidget } from './impl-widget.js';
-import { publishViewer, publishNotify, publishLifecycleNotice, registerBridgeCommand, getBridge } from '../remote/bridge.js';
+import { publishViewer, publishNotify, publishLifecycleNotice, registerBridgeCommand, getBridge, SessionUI } from '../remote/bridge.js';
 import { pushNotify } from '../remote/push.js';
 import { getConfig } from '../config/config.js';
 import { buildGateDeps } from './gate-deps.js';
@@ -342,6 +342,11 @@ export class TaskRunner {
 /** Dialog copy for the post-interrupt steering prompt. */
 const STEER_TITLE = 'Paused — steer the model';
 const STEER_PLACEHOLDER = 'Type guidance to continue this task, or leave empty to pause';
+/** Remote-card copy for the same prompt. The browser has no placeholder ghost
+ *  text, so the pause affordance must be spelled out in the question itself
+ *  (Skip = empty answer = pause, same as an empty local submit). */
+const STEER_QUESTION = 'Paused — the implementation was interrupted.\n'
+    + 'Type guidance to continue this task, or Skip to pause the run.';
 /**
  * True when the most recent assistant turn ended because the user interrupted it
  * (pressed ESC). pi records a user abort as stopReason "aborted" on the assistant
@@ -472,7 +477,19 @@ export async function resumeAcrossCompactions(ctx) {
  * should pause; false when the implementation completed (steered or not).
  */
 async function steerUntilDone(ctx, promptSteer) {
-    const ask = promptSteer ?? (c => c.ui.input(STEER_TITLE, STEER_PLACEHOLDER));
+    // Fan the prompt out through the bridge (local TUI input + remote browser
+    // card, first answer wins) instead of a raw ctx.ui.input: an interrupt can
+    // come from the remote Stop button just as well as a terminal ESC, and a
+    // terminal-only dialog leaves the remote viewer staring at a silently
+    // paused run. Remote Skip returns '' → same pause path as an empty local
+    // submit.
+    const ask = promptSteer
+        ?? (c => new SessionUI(c).ask({
+            localTitle: STEER_TITLE,
+            localPlaceholder: STEER_PLACEHOLDER,
+            question: STEER_QUESTION,
+            allowSkip: true
+        }));
     while (wasInterrupted(ctx)) {
         const steer = await ask(ctx);
         if (steer === undefined || steer.trim().length === 0)

package/dist/task/phases.js

@@ -318,10 +318,10 @@ export async function phaseResearch(deps, refined, researchDeps = {}) {
         }
     };
     // Per-worker timing split into wait (spawn → first byte) and work (first
-    // byte → exit). The workers run sequentially below, so each split is a clean
+    // byte → exit). With the default serial execution each split is a clean
     // per-worker measurement — waitMs the worker's own cold-start, workMs its
-    // generation+tool-call cost — not a Promise.all-relative wall-clock that
-    // conflates the two.
+    // generation+tool-call cost. Under the opt-in parallel mode the numbers are
+    // wall-clock-relative (queueing shows up in waitMs).
     const recordWorker = (label, p) => p.then(r => {
         deps.recordSubStep?.(`${label} wait`, r.waitMs);
         deps.recordSubStep?.(`${label} work`, r.workMs);
@@ -337,7 +337,9 @@ export async function phaseResearch(deps, refined, researchDeps = {}) {
     //     each other ~4x (context worker measured 27s solo vs 128s under load),
     //     so summed-but-fast (~100s) beats max-of-slowed (~130s).
     // Every worker runs /no_think (below), so sequential is the faster regime.
-    // Do NOT switch this back to Promise.all without re-running that A/B.
+    // Do NOT switch the DEFAULT back to concurrent without re-running that A/B;
+    // the opt-in `parallelResearchWorkers` config flag exists for backends that
+    // genuinely serve parallel streams.
     //
     // `/no_think` is the big win: these are agentic exploration loops, and on a
     // reasoning model the child would otherwise emit a full <think> trace at
@@ -358,9 +360,13 @@ export async function phaseResearch(deps, refined, researchDeps = {}) {
             label: 'worker:apis',
             // Read-heavy: gets the orientation core (see note above). Search/fetch
             // ride along only when a Brave key exists — see SEARCH_EXTENSION_PATH.
-            prompt: appendNoThink(orientation.block
+            // FILES' finished map rides along when available (serial default), so
+            // the worker doesn't re-derive where-things-live via docs-"."
+            // queries the FILES worker just answered (run-7 F7: up to 10
+            // duplicate `.`-decodes per task through the serial bottleneck).
+            prompt: prior => appendNoThink(orientation.block
                 + promptHeader
-                + RESEARCH_APIS_PROMPT(refined)
+                + RESEARCH_APIS_PROMPT(refined, prior.find(s => s.name === 'FILES')?.text || undefined)
                 + (searchConfigured() ? RESEARCH_SEARCH_HINT : '')),
             tools: 'read,grep,find,ls,pi-worker-docs'
                 + (searchConfigured() ? ',pi-worker-search,pi-worker-fetch' : ''),
@@ -390,25 +396,36 @@ export async function phaseResearch(deps, refined, researchDeps = {}) {
             extensions: [SINGLE_READ_EXTENSION_PATH]
         }
     ];
-    // Run workers one at a time, persisting each worker's validated output the
-    // moment it succeeds. On a resume, a worker whose cached output is already on
-    // disk is skipped — so when one worker fails and the phase is re-run, the
-    // others don't burn minutes regenerating work that was already good. Each
-    // worker is validated inline (not in a second pass) so a failure throws
-    // before later workers run, and only trustworthy text is ever cached.
-    const sections = [];
-    for (const spec of workerSpecs) {
+    // Persisting a worker's section is a read-modify-write of the shared task
+    // file, so writes are chained through one lock — a no-op in serial mode,
+    // load-bearing in parallel mode where two workers can settle together.
+    let persistChain = Promise.resolve();
+    const persistSection = (heading, text) => {
+        const next = persistChain.then(() => setTaskSection(deps.cwd, deps.taskId, heading, text));
+        persistChain = next.catch(() => { });
+        return next;
+    };
+    // One worker, cache-skip to persist: on a resume, a worker whose cached
+    // output is already on disk is skipped — so when one worker fails and the
+    // phase is re-run, the others don't burn minutes regenerating work that was
+    // already good. Each worker is validated inline (not in a second pass), so
+    // only trustworthy text is ever cached.
+    //
+    // A fatal failure (crash/empty/leak) still throws — the already-cached
+    // workers survive for the resume. A runaway (loop/timeout) degrades to its
+    // partial output instead, so one weak worker can't abort a whole auto-run;
+    // the degraded section is cached too, so a resume doesn't re-loop it.
+    const runSpec = async (spec, prior) => {
         const cacheHeading = researchWorkerCacheHeading(spec.section);
         const cached = (await readSection(deps.cwd, deps.taskId, cacheHeading)) ?? '';
         if (cached.trim().length > 0) {
             deps.logDebug?.(`${spec.label}: cached — skipping re-run`);
             updateProgress();
-            sections.push({ name: spec.section, text: cached.trim() });
-            continue;
+            return { name: spec.section, text: cached.trim() };
         }
         deps.logDebug?.(`${spec.label}: start`);
         const r = await recordWorker(spec.label, runWorker({
-            prompt: spec.prompt,
+            prompt: typeof spec.prompt === 'function' ? spec.prompt(prior) : spec.prompt,
             cwd: deps.cwd,
             signal: deps.signal,
             spawn: deps.spawn,
@@ -423,10 +440,6 @@ export async function phaseResearch(deps, refined, researchDeps = {}) {
             + (r.stderr ? ` stderr=${r.stderr.slice(0, 300)}` : '')
             + (r.leakedToolCall ? ` leaked=${r.leakedToolCall.trim().slice(0, 80)}` : ''));
         updateProgress();
-        // A fatal failure (crash/empty/leak) still throws — the already-cached
-        // workers survive for the resume. A runaway (loop/timeout) degrades to its
-        // partial output instead, so one weak worker can't abort a whole auto-run;
-        // the degraded section is cached too, so a resume doesn't re-loop it.
         const failure = classifyResearchWorker(spec.section, r);
         if (failure?.kind === 'fatal')
             throw failure.error;
@@ -436,8 +449,34 @@ export async function phaseResearch(deps, refined, researchDeps = {}) {
         if (failure?.kind === 'runaway') {
             deps.logDebug?.(`${spec.label}: degraded — ${failure.reason}`);
         }
-        await setTaskSection(deps.cwd, deps.taskId, cacheHeading, sectionText);
-        sections.push({ name: spec.section, text: sectionText });
+        await persistSection(cacheHeading, sectionText);
+        return { name: spec.section, text: sectionText };
+    };
+    const sections = [];
+    if (!getConfig().parallelResearchWorkers) {
+        // Default: ONE AT A TIME (see the A/B note above the specs) — a fatal
+        // failure throws before later workers run, and each worker can see the
+        // finished sections before it (APIS builds on the FILES map).
+        for (const spec of workerSpecs) {
+            sections.push(await runSpec(spec, sections));
+        }
+    }
+    else {
+        // Opt-in for parallel-capable backends. allSettled (not all): every
+        // worker runs to its own outcome first, so one fatal failure cannot
+        // orphan the others' output — their sections persist for the resume
+        // before the failure is thrown. Assembly order stays the spec order
+        // regardless of completion order. No prior sections exist here, so
+        // prompt builders get none (APIS runs map-less, as before this option).
+        const settled = await Promise.allSettled(workerSpecs.map(spec => runSpec(spec, [])));
+        for (const s of settled) {
+            if (s.status === 'rejected')
+                throw s.reason;
+        }
+        for (const s of settled) {
+            if (s.status === 'fulfilled')
+                sections.push(s.value);
+        }
     }
     // All workers succeeded — the assembled output below becomes the canonical
     // 'research' section (written by the orchestrator). The per-worker caches

package/dist/task/prompts.d.ts

@@ -50,7 +50,7 @@ export declare const COMPRESS_LABEL_PROMPT: (title: string, maxChars: number) =>
 declare const REFINE_PROMPT: (raw: string, planContext?: string, existingFiles?: string) => string;
 declare const RESEARCH_READ_ONLY_CONSTRAINT = "IMPORTANT: You are ONLY allowed to READ. Do NOT create, modify, or delete any files. Use the read, grep, find, and ls tools to inspect the repo.";
 declare const RESEARCH_FILES_PROMPT: (refined: string) => string;
-declare const RESEARCH_APIS_PROMPT: (refined: string) => string;
+declare const RESEARCH_APIS_PROMPT: (refined: string, filesMap?: string) => string;
 declare const RESEARCH_CONTEXT_PROMPT: (refined: string) => string;
 declare const RESEARCH_TOOLING_PROMPT: (refined: string) => string;
 declare const GRILL_GEN_PROMPT: (refined: string, research: string, priorQA: string) => string;

package/dist/task/prompts.js

@@ -122,7 +122,7 @@ No section header. No other sections. No preamble.
 
 Task:
 ${refined}`;
-const RESEARCH_APIS_PROMPT = (refined) => `You are doing targeted research for an AI coding agent. Use the read, grep, find, and ls tools — and \`pi-worker-docs\` for installed npm packages — to identify the commands, functions, types, and interfaces the agent will use for the following task.
+const RESEARCH_APIS_PROMPT = (refined, filesMap) => `You are doing targeted research for an AI coding agent. Use the read, grep, find, and ls tools — and \`pi-worker-docs\` for installed npm packages — to identify the commands, functions, types, and interfaces the agent will use for the following task.
 
 NPM PACKAGES — use pi-worker-docs, NOT file reads: for any third-party npm package (e.g. "zod", "hono", "drizzle-orm"), call \`pi-worker-docs(module, query)\` to get its type signatures and API surface. Do NOT open node_modules source files directly — those reads are expensive and produce far more noise than the tool. The tool returns a compact, focused excerpt in a fraction of the token cost.
 
@@ -133,7 +133,14 @@ RUNTIME BUILTINS — verify, do NOT echo: a task (or the spec doc it references)
 APIS owns symbols and commands BY NAME ONLY. Do NOT include any file path or path fragment — no \`package.json\`, no \`./src/foo.ts\`, no \`package.json#scripts.lint\`. If the symbol is a script defined in package.json, write the invocation (\`npm run lint\`), not its location. If the symbol is a config file, it does not belong in APIS at all — it belongs in FILES.
 
 RELEVANCE — read carefully: list ONLY the symbols the agent will call, implement, modify, or directly depend on for THIS task. Do NOT enumerate the project's entire public surface or dump every exported function in a touched file. A symbol unrelated to the task does not belong here just because it sits in the same module. Keep the smallest sufficient set: include every symbol the task actually exercises and nothing more. There is no fixed limit — list as many as the task truly needs and no padding beyond that.
+${filesMap ?
+    `
+PROJECT FILE MAP — already surveyed for this task by a prior worker (authoritative):
+${filesMap}
 
+USE THE MAP: where things live is ALREADY ANSWERED above. Do NOT re-derive it — never call \`pi-worker-docs(".", …)\` (or grep/find) for a question the map already answers: which file holds X, whether a path exists, what a file is for. Reserve \`.\`-queries for symbol-level facts the map cannot carry — signatures, parameter and return types, what a module exports. Go straight to the mapped files' symbols.
+`
+    : ''}
 ${RESEARCH_INPUTS_NOT_DELIVERABLE}
 
 ${RESEARCH_READ_ONLY_CONSTRAINT}

package/dist/task/verify-work.d.ts

@@ -42,7 +42,7 @@ export declare function extractSpecForVerification(taskBody: string): string | n
  * pure git shape (test files the task itself changed), so the mandate is
  * language- and framework-agnostic.
  */
-export declare function buildVerifyPrompt(spec: string, probeFindings?: string[]): string;
+export declare function buildVerifyPrompt(spec: string, probeFindings?: string[], envNotes?: string): string;
 /**
  * Parse the child's verdict. Scans for the LAST `WORK-VERIFIED: PASS|FAIL` marker
  * (the model discusses before concluding, and bash output may echo the word
@@ -94,6 +94,17 @@ export interface VerificationDeps {
         mutated: boolean;
         detail: string;
     };
+    /**
+     * Per-run environment-facts cache (see env-notes.ts): `read` supplies the
+     * facts earlier gate children discovered (inlined into the prompt with the
+     * no-waiver caveat); `append` stores the `ENV-NOTE:` lines this child
+     * emitted, host-side. ABSENT → no block, no capture (tests unchanged).
+     * Facts only cut re-discovery time; verdict rules are unaffected.
+     */
+    envNotes?: {
+        read: () => Promise<string>;
+        append: (notes: string[]) => Promise<void>;
+    };
 }
 /**
  * Run the verification pass for one task. A missing spec is a pass. Otherwise run

package/dist/task/verify-work.js

@@ -68,6 +68,7 @@
  * verify, this is a pass (ok: true).
  */
 import { USER_CANCELLED } from './child-runner.js';
+import { buildEnvNotesBlock, ENV_NOTE_EMIT_INSTRUCTION, extractEnvNotes } from './env-notes.js';
 /**
  * The verification child gets exactly two tools: `read` and `bash`.
  *
@@ -123,7 +124,7 @@ export function extractSpecForVerification(taskBody) {
  * pure git shape (test files the task itself changed), so the mandate is
  * language- and framework-agnostic.
  */
-export function buildVerifyPrompt(spec, probeFindings) {
+export function buildVerifyPrompt(spec, probeFindings, envNotes) {
     const probeBlock = probeFindings && probeFindings.length > 0 ?
         [
             'SELF-VERIFICATION NOTICE (deterministic, computed by the orchestrator from the diff):',
@@ -137,6 +138,7 @@ export function buildVerifyPrompt(spec, probeFindings) {
             ''
         ]
         : [];
+    const envBlock = envNotes && envNotes.trim().length > 0 ? [buildEnvNotesBlock(envNotes)] : [];
     return [
         'You are a strict verification pass running right after an AI coding agent',
         'finished a task and committed it. The agent is known to mark work "done"',
@@ -150,6 +152,7 @@ export function buildVerifyPrompt(spec, probeFindings) {
         'THE TASK SPEC (its ACCEPTANCE criteria and VERIFY block are the contract):',
         spec.trim(),
         '',
+        ...envBlock,
         ...probeBlock,
         'How to verify — verify the REAL, shipped deliverable exactly as an unaided fresh',
         'checkout (or CI run) would experience it:',
@@ -249,6 +252,8 @@ export function buildVerifyPrompt(spec, probeFindings) {
         'a required behavior missing — the verdict is FAIL, even if typecheck and lint are green',
         'and even if the gap seems minor. Never downgrade an unmet criterion to a warning note.',
         '',
+        ENV_NOTE_EMIT_INSTRUCTION,
+        '',
         'When you are done, output EXACTLY ONE of these as the final line:',
         "  WORK-VERIFIED: PASS              (the project's own command, run unaided, met the spec)",
         '  WORK-VERIFIED: FAIL <text>      (the shipped command failed or did not meet the spec; say what failed)',
@@ -305,6 +310,17 @@ export async function runWorkVerification(deps) {
             findings = [];
         }
     }
+    // Environment facts from earlier gate children (best-effort; a cache failure
+    // must never block verification).
+    let envNotes = '';
+    if (deps.envNotes) {
+        try {
+            envNotes = await deps.envNotes.read();
+        }
+        catch {
+            envNotes = '';
+        }
+    }
     // A child that emits NO verdict never judged the work (budget/context death mid-
     // investigation — seen live: an 11-minute verify wandered, died verdict-less, and
     // the resulting FAIL burned a full implementation re-run on an unjudged artifact).
@@ -312,7 +328,7 @@ export async function runWorkVerification(deps) {
     for (let attempt = 1;; attempt++) {
         let text;
         try {
-            text = await deps.runChild(VERIFY_TOOLS, buildVerifyPrompt(deps.spec, findings), deps.signal);
+            text = await deps.runChild(VERIFY_TOOLS, buildVerifyPrompt(deps.spec, findings, envNotes), deps.signal);
         }
         catch (err) {
             if (err instanceof Error && err.message === USER_CANCELLED)
@@ -320,6 +336,16 @@ export async function runWorkVerification(deps) {
             const msg = err instanceof Error ? err.message : String(err);
             return { ok: false, reason: `verification pass could not run: ${msg}` };
         }
+        // Capture the environment facts the child shared — regardless of verdict
+        // (a FAIL run's discoveries are just as reusable).
+        if (deps.envNotes) {
+            try {
+                await deps.envNotes.append(extractEnvNotes(text));
+            }
+            catch {
+                // best-effort cache
+            }
+        }
         // A child that mutated the repo (git-state guard fired) judged a tree it had
         // itself changed — its verdict is meaningless in both directions, so discard
         // it BEFORE parsing. The guard already restored the state, so one retry runs

package/dist/task/widget.d.ts

@@ -57,8 +57,9 @@ export interface AutoLoaderState {
      *  pass and 'verify' is the per-task work-verification pass, neither of which
      *  has step numbering. 'recommend' is the read-only research that picks the
      *  recommended action after a verify FAIL. 'lint-fix' is the bounded fix pass
-     *  for a repo-health verify FAIL. */
-    kind?: 'planning' | 'enforce' | 'verify' | 'recommend' | 'lint-fix';
+     *  for a repo-health verify FAIL; 'final-fix' the bounded fix pass for a
+     *  final-integration-gate FAIL. */
+    kind?: 'planning' | 'enforce' | 'verify' | 'recommend' | 'lint-fix' | 'final-fix';
 }
 export declare function buildAutoLoaderLines(s: AutoLoaderState, theme?: WidgetTheme): string[];
 /** Structured mirror of buildAutoLoaderLines. Only the numbered planning stage

package/dist/task/widget.js

@@ -148,7 +148,8 @@ export function buildAutoLoaderLines(s, theme) {
         : s.kind === 'verify' ? `verifying work · ${elapsed}`
             : s.kind === 'recommend' ? `assessing the failure · ${elapsed}`
                 : s.kind === 'lint-fix' ? `fixing static findings · ${elapsed}`
-                    : `planning ${s.stepNum}/${s.stepTotal} ${s.step} · ${elapsed}`;
+                    : s.kind === 'final-fix' ? `fixing the final gate · ${elapsed}`
+                        : `planning ${s.stepNum}/${s.stepTotal} ${s.step} · ${elapsed}`;
     if (s.contextUsage) {
         const ctxDetail = formatContextDetail(s.contextUsage, theme);
         if (ctxDetail)
@@ -167,7 +168,8 @@ export function buildAutoLoaderData(s) {
         : s.kind === 'verify' ? 'verifying work'
             : s.kind === 'recommend' ? 'assessing the failure'
                 : s.kind === 'lint-fix' ? 'fixing static findings'
-                    : s.step;
+                    : s.kind === 'final-fix' ? 'fixing the final gate'
+                        : s.step;
     const d = {
         title: `/task-auto · ${s.title}`,
         phase,

package/dist/workers/pi-worker-core.d.ts

@@ -36,6 +36,16 @@ export interface RunWorkerInput {
         threshold?: number;
         pathThreshold?: number;
     } | false;
+    /**
+     * Dead-backend stall guard override. Default ON: no output for
+     * STALL_AFTER_MS → probe the model endpoints pi is configured with →
+     * unreachable → kill + `stalled: true`. Pass `false` to disable, or
+     * override the window/probe (tests, harnesses).
+     */
+    stall?: {
+        afterMs?: number;
+        probe?: () => Promise<boolean>;
+    } | false;
 }
 export interface RunWorkerResult {
     text: string;
@@ -73,5 +83,11 @@ export interface RunWorkerResult {
      * the caller must treat it as a failure.
      */
     timedOut?: boolean;
+    /**
+     * Set when the stall guard killed the worker: no output progress AND the
+     * model endpoint unreachable. Check BEFORE `aborted` — the kill sets
+     * aborted too, and mislabeling this as a user cancel hides a dead backend.
+     */
+    stalled?: boolean;
 }
 export declare function runWorker(input: RunWorkerInput): Promise<RunWorkerResult>;

package/dist/workers/pi-worker-core.js

@@ -3,6 +3,7 @@ import { CHILD_BASE_ARGS, runChildDefault } from '../shared/child-process.js';
 import { LoopDetector } from '../task/loop-detector.js';
 import { LOOP_WINDOW, LOOP_THRESHOLD, MAX_LOOP_RESTARTS, formatLoopHint } from '../task/child-runner.js';
 import { detectLeakedToolCall, leakedToolCallHint, MAX_LEAK_RETRIES } from '../shared/leaked-tool-call.js';
+import { discoverModelEndpoints, probeModelEndpoints } from '../shared/model-endpoint.js';
 // `--mode json` makes pi emit structured events as they happen instead of
 // buffering the assistant text and flushing on exit. That matters for the
 // wait/work timing split: in text mode the first stdout chunk only arrives at
@@ -21,6 +22,15 @@ const DEFAULT_TOOLS = 'read,grep,find,ls';
  * so it never trips a legitimately slow run.
  */
 const RESEARCH_WORKER_TIMEOUT_MS = 240_000;
+/**
+ * Output-stall window before the dead-backend probe fires (mx5 run 7: model
+ * server died mid-gate-child, the child hung MUTE for 64 minutes). This is NOT
+ * a wall-clock cap — output progress resets it, and even a fully stalled child
+ * is only killed when the model endpoint is actually unreachable. Sized so a
+ * long local prompt-processing pass (minutes of legitimate silence, server
+ * alive) just gets probed and waits on.
+ */
+const STALL_AFTER_MS = 180_000;
 /** Restart hint after a wall-clock timeout — distinct from the loop hint. */
 const WORKER_TIMEOUT_HINT = '[SYSTEM NOTE: Your previous attempt ran out of time before answering — you '
     + 'were exploring too long. Be decisive: do the minimum reads/greps needed, '
@@ -95,6 +105,15 @@ export async function runWorker(input) {
         try {
             result = await runChildDefault(invocation, input.cwd, timeout.signal, {
                 mode: 'json-events',
+                ...(input.stall === false ?
+                    {}
+                    : {
+                        stall: {
+                            afterMs: input.stall?.afterMs ?? STALL_AFTER_MS,
+                            probe: input.stall?.probe
+                                ?? (() => probeModelEndpoints(discoverModelEndpoints()))
+                        }
+                    }),
                 onFirstByte: () => (tFirstByte = Date.now()),
                 onToolCall: call => {
                     if (!loopDetector)
@@ -150,7 +169,8 @@ export async function runWorker(input) {
             workMs,
             ...(leaked ? { leakedToolCall: leaked } : {}),
             ...(loopHit ? { loopHit } : {}),
-            ...(timedOut ? { timedOut: true } : {})
+            ...(timedOut ? { timedOut: true } : {}),
+            ...(result.stalled ? { stalled: true } : {})
         };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.17.26",
+    "version": "0.18.0",
     "description": "Deterministic task planning and spec-orchestration for local models — crash-safe /task pipelines with verify/enforce gates, a real-time remote web view, and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",