@mjasnikovs/pi-task 0.18.42 → 0.18.43

package/dist/shared/child-process.js

@@ -276,11 +276,13 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
                 {
                     ...opts,
                     onToolCall: call => {
-                        streamWatch.suspend();
+                        // Keyed: a child's tool batch runs in parallel too, so the
+                        // first result must not un-pause a still-running sibling.
+                        streamWatch.suspend(call.toolCallId);
                         return opts.onToolCall ? opts.onToolCall(call) : null;
                     },
                     onToolResult: r => {
-                        streamWatch.resume();
+                        streamWatch.resume(r.toolCallId);
                         opts.onToolResult?.(r);
                     }
                 }

package/dist/shared/stream-watchdog.d.ts

@@ -64,20 +64,39 @@ export declare class StreamWatchdog {
     private timer;
     private lastEvent;
     private armedMs;
-    /** True while a TOOL is executing: the model stream is legitimately idle then,
-     *  and that window belongs to the command watchdog, not to this one. Without
-     *  this, a 10-minute build would look identical to a hung stream. */
-    private suspended;
+    /**
+     * The tool calls currently executing. While ANY is running the model stream is
+     * legitimately idle, and that window belongs to the command watchdog, not to
+     * this one — without it a 10-minute build looks identical to a hung stream.
+     *
+     * A SET, not a boolean: pi runs a tool batch in parallel (agent-loop.js
+     * `executeToolCallsParallel` emits every tool_execution_start up front, then one
+     * end per call as each settles, and answers an immediate call inline while an
+     * earlier one is still running). A boolean would be cleared by the FIRST end and
+     * leave the still-running sibling — the long build — exposed to a false fire.
+     * Same per-toolCallId idiom the command watchdog uses.
+     */
+    private readonly active;
+    /** Nesting depth for callers that cannot supply an id, counted so an unkeyed
+     *  pair nests the same way a keyed one does. */
+    private keyless;
     private fired;
+    private get suspended();
     constructor(deps: StreamWatchdogDeps);
     /** Begin watching a model request. No-op when the watchdog is off or already armed. */
     start(): void;
     /** Any stream event of any kind: resets the idle clock. */
     note(): void;
-    /** A tool started executing — pause the idle clock until it ends. */
-    suspend(): void;
-    /** A tool finished — the stream is expected to resume; restart the clock. */
-    resume(): void;
+    /** A tool started executing — pause the idle clock until it (and every sibling
+     *  still running) ends. `key` is the tool call id where the caller has one. */
+    suspend(key?: string): void;
+    /**
+     * A tool finished. The clock only restarts once the LAST one does — a fast tool
+     * settling first says nothing about a sibling that is still running. Unmatched
+     * ends (a watchdog armed mid-batch never saw the start) are ignored rather than
+     * clearing the whole set.
+     */
+    resume(key?: string): void;
     /** Stop watching (turn/agent/session end, or child exit). Safe to call twice. */
     stop(): void;
     /** @internal Exposed for the poll callback and tests. */

package/dist/shared/stream-watchdog.js

@@ -59,11 +59,26 @@ export class StreamWatchdog {
     timer;
     lastEvent = 0;
     armedMs = 0;
-    /** True while a TOOL is executing: the model stream is legitimately idle then,
-     *  and that window belongs to the command watchdog, not to this one. Without
-     *  this, a 10-minute build would look identical to a hung stream. */
-    suspended = false;
+    /**
+     * The tool calls currently executing. While ANY is running the model stream is
+     * legitimately idle, and that window belongs to the command watchdog, not to
+     * this one — without it a 10-minute build looks identical to a hung stream.
+     *
+     * A SET, not a boolean: pi runs a tool batch in parallel (agent-loop.js
+     * `executeToolCallsParallel` emits every tool_execution_start up front, then one
+     * end per call as each settles, and answers an immediate call inline while an
+     * earlier one is still running). A boolean would be cleared by the FIRST end and
+     * leave the still-running sibling — the long build — exposed to a false fire.
+     * Same per-toolCallId idiom the command watchdog uses.
+     */
+    active = new Set();
+    /** Nesting depth for callers that cannot supply an id, counted so an unkeyed
+     *  pair nests the same way a keyed one does. */
+    keyless = 0;
     fired = false;
+    get suspended() {
+        return this.active.size > 0 || this.keyless > 0;
+    }
     constructor(deps) {
         this.deps = deps;
     }
@@ -80,7 +95,8 @@ export class StreamWatchdog {
             return;
         this.armedMs = ms;
         this.fired = false;
-        this.suspended = false;
+        this.active.clear();
+        this.keyless = 0;
         this.lastEvent = this.deps.now();
         this.timer = this.deps.schedule(() => this.check(), pollIntervalMs(ms));
     }
@@ -88,21 +104,35 @@ export class StreamWatchdog {
     note() {
         this.lastEvent = this.deps.now();
     }
-    /** A tool started executing — pause the idle clock until it ends. */
-    suspend() {
-        this.suspended = true;
+    /** A tool started executing — pause the idle clock until it (and every sibling
+     *  still running) ends. `key` is the tool call id where the caller has one. */
+    suspend(key) {
+        if (key === undefined)
+            this.keyless++;
+        else
+            this.active.add(key);
     }
-    /** A tool finished — the stream is expected to resume; restart the clock. */
-    resume() {
-        this.suspended = false;
-        this.note();
+    /**
+     * A tool finished. The clock only restarts once the LAST one does — a fast tool
+     * settling first says nothing about a sibling that is still running. Unmatched
+     * ends (a watchdog armed mid-batch never saw the start) are ignored rather than
+     * clearing the whole set.
+     */
+    resume(key) {
+        if (key === undefined)
+            this.keyless = Math.max(0, this.keyless - 1);
+        else
+            this.active.delete(key);
+        if (!this.suspended)
+            this.note();
     }
     /** Stop watching (turn/agent/session end, or child exit). Safe to call twice. */
     stop() {
         if (this.timer !== undefined)
             this.deps.cancel(this.timer);
         this.timer = undefined;
-        this.suspended = false;
+        this.active.clear();
+        this.keyless = 0;
     }
     /** @internal Exposed for the poll callback and tests. */
     check() {

package/dist/task/auto-io.d.ts

@@ -1,3 +1,4 @@
+import type { TaskState } from './task-types.js';
 import type { AutoResumeCandidate } from './resume-gap.js';
 export interface TaskEntry {
     index: number;
@@ -63,7 +64,14 @@ export declare function insertTaskAfter(cwd: string, id: string, afterIndex: num
  * Find the most-recently-updated resumable TASK_AUTO_* file, with the state and
  * last-write time the resume banner reports (see resume-gap.ts). Null when there
  * is nothing resumable.
+ *
+ * `states` narrows which states count as resumable, and the UNATTENDED path passes
+ * UNATTENDED_STATES so the search answers the question that path actually asks —
+ * "is there an IN-FLIGHT run to pick up?". Selecting the newest human-resumable run
+ * and only then refusing it on state let one failed run shadow an in-flight one
+ * behind it: the boot hook refused every restart and the in-flight run stayed in
+ * exactly the dead air this feature exists to end.
  */
-export declare function findResumableAutoDetailed(cwd: string): Promise<AutoResumeCandidate | null>;
+export declare function findResumableAutoDetailed(cwd: string, states?: readonly TaskState[]): Promise<AutoResumeCandidate | null>;
 /** Id-only form of {@link findResumableAutoDetailed}. */
 export declare function findResumableAuto(cwd: string): Promise<string | null>;

package/dist/task/auto-io.js

@@ -198,8 +198,15 @@ export async function insertTaskAfter(cwd, id, afterIndex, title) {
  * Find the most-recently-updated resumable TASK_AUTO_* file, with the state and
  * last-write time the resume banner reports (see resume-gap.ts). Null when there
  * is nothing resumable.
+ *
+ * `states` narrows which states count as resumable, and the UNATTENDED path passes
+ * UNATTENDED_STATES so the search answers the question that path actually asks —
+ * "is there an IN-FLIGHT run to pick up?". Selecting the newest human-resumable run
+ * and only then refusing it on state let one failed run shadow an in-flight one
+ * behind it: the boot hook refused every restart and the in-flight run stayed in
+ * exactly the dead air this feature exists to end.
  */
-export async function findResumableAutoDetailed(cwd) {
+export async function findResumableAutoDetailed(cwd, states = RESUMABLE_STATES) {
     await ensureTasksDir(cwd);
     const entries = await fsp.readdir(tasksDir(cwd));
     const candidates = [];
@@ -212,7 +219,7 @@ export async function findResumableAutoDetailed(cwd) {
             const fm = parseFrontMatter(raw);
             if (!fm)
                 continue;
-            if (!RESUMABLE_STATES.includes(fm.state))
+            if (!states.includes(fm.state))
                 continue;
             const st = await fsp.stat(path.join(tasksDir(cwd), f));
             candidates.push({ id: m[1], state: fm.state, lastWriteMs: st.mtimeMs });

package/dist/task/auto-orchestrator.js

@@ -15,7 +15,7 @@ import { AUTO_CLARIFY_PROMPT, AUTO_DECOMPOSE_PROMPT, DECOMPOSE_COVERAGE_PROMPT }
 import { GRILL_AUTO_ANSWER_PROMPT, GRILL_AUTO_FORMAT_HINT } from './prompts.js';
 import { isDuplicateQuestion, MAX_DUP_STRIKES, DUP_REPROMPT_HINT } from './question-dedup.js';
 import { allocateAutoId, buildAutoBody, parseDecomposeList, parseCoverageVerdict, parseTaskList, checkOffTask, stampTaskInProgress, insertTaskAfter, findResumableAutoDetailed } from './auto-io.js';
-import { decideResume } from './resume-gap.js';
+import { decideResume, UNATTENDED_STATES } from './resume-gap.js';
 import { drainRepairQueue, mergeRepairCandidates, planHasRepairFor, parseRepairTitleFile, buildRepairTitle, buildRepairScopeFence, extractFailingCommand } from './root-cause-repair.js';
 import { writeTaskFile, readTaskFile, updateTaskFrontMatter, taskFilePath, tasksDir } from './task-io.js';
 import { readTextFile } from '../shared/fs-text.js';
@@ -1600,7 +1600,15 @@ async function handleTaskAutoResume(args, ctx) {
     // `--unattended` is the boot-hook path: no human decided to continue this
     // run, so it resumes in-flight states only and refuses the rest by name.
     const unattended = /(^|\s)--unattended(\s|$)/.test(args);
-    const candidate = await findResumableAutoDetailed(cwd);
+    // Unattended asks a narrower question — "is there an IN-FLIGHT run?" — so it
+    // searches those states directly. Picking the newest human-resumable run and
+    // refusing it on state let a failed run shadow an in-flight one behind it.
+    // With nothing in flight, fall back to the newest resumable run so the refusal
+    // still names it instead of claiming there is nothing here.
+    const eligible = unattended ?
+        await findResumableAutoDetailed(cwd, UNATTENDED_STATES)
+        : await findResumableAutoDetailed(cwd);
+    const candidate = eligible ?? (unattended ? await findResumableAutoDetailed(cwd) : null);
     const decision = decideResume(candidate, Date.now(), unattended);
     ctx.ui.notify(decision.banner, decision.level);
     // An unattended refusal happens with nobody watching the terminal — the

package/dist/task/final-gate-progress.js

@@ -51,12 +51,28 @@ const VOLATILE = [
     [/\bpids?\s*[:=]?\s*\d+/g, '<pid>'],
     [/(?:127\.0\.0\.1|localhost|0\.0\.0\.0|\[::1\]):\d+/g, '<addr>'],
     [/\bport\s*[:=]?\s*\d{2,5}\b/g, '<port>'],
-    [/:\d{2,5}\b/g, ':<port>'],
     // Long hex / uuid-ish ids (sha, container id, request id).
     [/\b0x[0-9a-f]+\b/g, '<hex>'],
     [/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/g, '<uuid>'],
     [/\b[0-9a-f]{7,40}\b/g, '<hex>']
 ];
+/**
+ * A bare `:NNNN` port, which the localhost/`port N` rules above do not reach (a
+ * failure that just says "no listener on :3000").
+ *
+ * NOT applied when the colon follows a SOURCE LOCATION — `src/db.ts:41`,
+ * `Cart.tsx:88:12`. A failure detail embeds the failing command's output tail
+ * verbatim (final-gate.ts `r.tail`), and tsc/eslint/bun-test tails are mostly
+ * file:line. Collapsing those made two DIFFERENT defects in one file — the second
+ * uncovered by fixing the first — compare equal, which reads as non-progress and
+ * demotes a genuinely fixable check to UNOBSERVED debt. A moved error is progress.
+ */
+const BARE_PORT = /(\S*?):(\d{2,5})\b/g;
+/** A path (has a separator) or a filename with an extension ⇒ a source location. */
+const SOURCE_LOCATION = /[/\\]|\.[a-z][a-z0-9]{0,4}$/;
+function collapseBarePorts(s) {
+    return s.replace(BARE_PORT, (whole, prefix) => SOURCE_LOCATION.test(prefix) ? whole : `${prefix}:<port>`);
+}
 /**
  * Comparison key for a gate failure entry: lowercased, volatile substrings erased,
  * whitespace collapsed. Two entries with the same key are "the same failure" for
@@ -66,6 +82,7 @@ export function normalizeFailureDetail(detail) {
     let s = detail.toLowerCase();
     for (const [re, repl] of VOLATILE)
         s = s.replace(re, repl);
+    s = collapseBarePorts(s);
     return s.replace(/\s+/g, ' ').trim();
 }
 /** The ranked-first failure of a gate outcome (the list is ranked most load-bearing

package/dist/task/stream-watchdog.js

@@ -68,16 +68,22 @@ export function registerStreamWatchdog(pi) {
     pi.on('message_start', (_e, ctx) => arm(ctx));
     pi.on('message_update', (_e, ctx) => arm(ctx));
     pi.on('message_end', (_e, ctx) => arm(ctx));
-    pi.on('tool_execution_start', (_e, ctx) => {
+    // Keyed by toolCallId: a tool BATCH runs in parallel, so the clock must stay
+    // paused until the last call settles, not the first (see StreamWatchdog.resume).
+    const callId = (e) => {
+        const id = e?.toolCallId;
+        return typeof id === 'string' && id.length > 0 ? id : undefined;
+    };
+    pi.on('tool_execution_start', (e, ctx) => {
         liveCtx = ctx;
-        watchdog.suspend();
+        watchdog.suspend(callId(e));
     });
     pi.on('tool_execution_update', (_e, ctx) => {
         liveCtx = ctx;
     });
-    pi.on('tool_execution_end', (_e, ctx) => {
+    pi.on('tool_execution_end', (e, ctx) => {
         liveCtx = ctx;
-        watchdog.resume();
+        watchdog.resume(callId(e));
     });
     // Nothing is streaming between agent loops; stop so no timer can fire into an
     // idle session (which would abort nothing and post a reminder to no one).

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.18.42",
+    "version": "0.18.43",
     "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",