@mjasnikovs/pi-task 0.18.37 → 0.18.39

package/dist/task/child-runner.js

@@ -12,6 +12,8 @@ import { childBaseArgs } from '../shared/child-extensions.js';
 import { LoopDetector } from './loop-detector.js';
 import { detectLeakedToolCall, leakedToolCallHint, MAX_LEAK_RETRIES } from '../shared/leaked-tool-call.js';
 import { readSection, setTaskSection } from './task-io.js';
+import { streamStallCause } from '../shared/stream-watchdog.js';
+import { getConfig } from '../config/config.js';
 // ─── Loop detection constants ────────────────────────────────────────────────
 // Defined here (not in phases.ts) to avoid a circular dependency:
 //   phases.ts → child-runner.ts → phases.ts
@@ -77,6 +79,11 @@ export async function runChild(cwd, tools, prompt, signal, onLine, onContextUsag
     let loopHit;
     const result = await runChildUnified(spawnFn ?? spawn, invocation, cwd, signal, {
         mode: 'json-events',
+        // A hung model stream reports nothing at all, so without this the
+        // phase child waits forever (mx5 run 14: ~2.9h of dead air). The kill
+        // is reported below as a connection-class cause, which routes it into
+        // the retry/backoff path this file already has for a LOUD disconnect.
+        streamInactivityMs: getConfig().streamInactivityMs,
         onLine,
         onContextUsage,
         onToolCall: call => {
@@ -95,12 +102,21 @@ export async function runChild(cwd, tools, prompt, signal, onLine, onContextUsag
     // fails with the unhelpful "X child produced no output" — the raw
     // stdout/stderr that might contain the real error is discarded.
     const text = result.text || result.stdout.trim();
+    // The stream watchdog's kill leaves no provider error to report (that is the
+    // whole failure mode), so name it here rather than letting it surface as the
+    // meaningless "produced no output". Never overwrite a real reported cause.
+    const modelError = result.modelError
+        ?? (result.streamStalled ? streamStallCause(result.streamStalled.idleMs) : undefined);
     return {
         text,
-        exitCode: result.exitCode,
+        // WE killed this child, so its exit status describes our own SIGTERM, not
+        // the child's verdict. Report 0 and let `modelError` carry the cause —
+        // otherwise the wrappers' `exitCode !== 0` guard throws a bare "child
+        // failed" before the connection-error retry ever gets to look.
+        exitCode: result.streamStalled ? 0 : result.exitCode,
         stderr: result.stderr.trim(),
         loopHit,
-        modelError: result.modelError,
+        modelError,
         // A tool call the model wrote as text (wrong dialect) never executed and
         // sailed past the structured-event guards above; flag it so the wrappers
         // can re-prompt instead of accepting the unexecuted call. Only meaningful

package/dist/task/gate-deps.js

@@ -391,6 +391,11 @@ export function buildGateDeps(params) {
                     // 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 },
                     onLine: line => {
                         lastLine = line;
@@ -538,6 +543,9 @@ export function buildGateDeps(params) {
                             // 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

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

@@ -0,0 +1,32 @@
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+/**
+ * MAIN-SESSION adapter for the model-stream watchdog.
+ *
+ * WHY (mx5 run 14): three implementation turns died mid-turn — the session jsonl's
+ * last record is an ordinary assistant message, then silence forever, while the
+ * model container stayed Up(healthy). No error is ever thrown for this shape, so
+ * the connection-error retry (which needs a reported ModelError) cannot fire and
+ * the command watchdog, which only covers tool executions, never arms. The run sat
+ * dead for ~2.9h across the three until a human restarted it.
+ *
+ * HOW: pi's extension events ARE the stream. Any of them — a token delta, a
+ * thinking delta, a tool-call delta, the provider's response headers — resets the
+ * idle clock; only total silence for the configured window fires. On fire the turn
+ * is aborted and a follow-up user turn tells the model to CONTINUE from the
+ * transcript (its completed tool calls and results are already recorded, so a
+ * blind re-send would re-run them).
+ *
+ * ONE ABORT CHANNEL: the fire path goes through the command watchdog's existing
+ * {@link noteWatchdogAbort} flag and its WATCHDOG_CANCEL_MARKER, so
+ * steerUntilDone's already-fixed abort/steer race (b543d15) covers this watchdog
+ * too instead of racing a second, parallel abort mechanism.
+ *
+ * SUSPENDED DURING TOOLS: while a tool executes the model stream is legitimately
+ * idle — a 12-minute build emits nothing. That window belongs to the command
+ * watchdog (requestTimeoutMs); this one pauses between tool_execution_start and
+ * tool_execution_end so the two can never double-fire on the same silence.
+ *
+ * SCOPE: main session only. Children run `--no-extensions`, so their equivalent
+ * guard lives in runChild (shared/child-process.ts) and shares the same machine.
+ */
+export declare function registerStreamWatchdog(pi: ExtensionAPI): void;

package/dist/task/stream-watchdog.js

@@ -0,0 +1,90 @@
+import { getConfig } from '../config/config.js';
+import { realStreamTimerDeps, StreamWatchdog, streamStallReminder } from '../shared/stream-watchdog.js';
+import { noteWatchdogAbort, WATCHDOG_CANCEL_MARKER } from './command-watchdog.js';
+/**
+ * MAIN-SESSION adapter for the model-stream watchdog.
+ *
+ * WHY (mx5 run 14): three implementation turns died mid-turn — the session jsonl's
+ * last record is an ordinary assistant message, then silence forever, while the
+ * model container stayed Up(healthy). No error is ever thrown for this shape, so
+ * the connection-error retry (which needs a reported ModelError) cannot fire and
+ * the command watchdog, which only covers tool executions, never arms. The run sat
+ * dead for ~2.9h across the three until a human restarted it.
+ *
+ * HOW: pi's extension events ARE the stream. Any of them — a token delta, a
+ * thinking delta, a tool-call delta, the provider's response headers — resets the
+ * idle clock; only total silence for the configured window fires. On fire the turn
+ * is aborted and a follow-up user turn tells the model to CONTINUE from the
+ * transcript (its completed tool calls and results are already recorded, so a
+ * blind re-send would re-run them).
+ *
+ * ONE ABORT CHANNEL: the fire path goes through the command watchdog's existing
+ * {@link noteWatchdogAbort} flag and its WATCHDOG_CANCEL_MARKER, so
+ * steerUntilDone's already-fixed abort/steer race (b543d15) covers this watchdog
+ * too instead of racing a second, parallel abort mechanism.
+ *
+ * SUSPENDED DURING TOOLS: while a tool executes the model stream is legitimately
+ * idle — a 12-minute build emits nothing. That window belongs to the command
+ * watchdog (requestTimeoutMs); this one pauses between tool_execution_start and
+ * tool_execution_end so the two can never double-fire on the same silence.
+ *
+ * SCOPE: main session only. Children run `--no-extensions`, so their equivalent
+ * guard lives in runChild (shared/child-process.ts) and shares the same machine.
+ */
+export function registerStreamWatchdog(pi) {
+    // The ctx whose abort() ends the in-flight turn, refreshed on every event so
+    // the fire (which happens outside any handler) aborts the CURRENT operation.
+    let liveCtx;
+    const watchdog = new StreamWatchdog({
+        getTimeoutMs: () => getConfig().streamInactivityMs,
+        ...realStreamTimerDeps,
+        onFire: idleMs => {
+            const ctx = liveCtx;
+            liveCtx = undefined;
+            // Flag BEFORE the abort, exactly as the command watchdog does: the
+            // steer loop can otherwise observe the 'aborted' turn first and show
+            // a steering prompt to an empty room, wedging an unattended run.
+            if (ctx) {
+                noteWatchdogAbort();
+                ctx.abort();
+            }
+            pi.sendUserMessage(streamStallReminder(idleMs, WATCHDOG_CANCEL_MARKER), {
+                deliverAs: 'followUp'
+            });
+        }
+    });
+    // Any event proves the stream is alive. `arm` also (re)starts the machine, so
+    // a request that begins after a previous turn ended is watched again without
+    // needing a single canonical "request started" event.
+    const arm = (ctx) => {
+        if (ctx)
+            liveCtx = ctx;
+        watchdog.start();
+        watchdog.note();
+    };
+    pi.on('before_provider_request', (_e, ctx) => arm(ctx));
+    pi.on('after_provider_response', (_e, ctx) => arm(ctx));
+    pi.on('turn_start', (_e, ctx) => arm(ctx));
+    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) => {
+        liveCtx = ctx;
+        watchdog.suspend();
+    });
+    pi.on('tool_execution_update', (_e, ctx) => {
+        liveCtx = ctx;
+    });
+    pi.on('tool_execution_end', (_e, ctx) => {
+        liveCtx = ctx;
+        watchdog.resume();
+    });
+    // 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).
+    const stop = () => {
+        watchdog.stop();
+        liveCtx = undefined;
+    };
+    pi.on('agent_end', stop);
+    pi.on('session_shutdown', stop);
+}

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

@@ -74,6 +74,16 @@ export interface RunWorkerInput {
         afterMs?: number;
         probe?: () => Promise<boolean>;
     } | false;
+    /**
+     * Stream-inactivity ceiling in ms (shared/stream-watchdog.ts). The stall guard
+     * above cannot catch a HUNG stream on a HEALTHY backend — it reads a reachable
+     * endpoint as proof of life, which is exactly what run 14's three hangs looked
+     * like. This one asks nothing of the backend: no output for this long (with
+     * tool executions excluded) ⇒ kill and restart the attempt with
+     * {@link streamStallHint}, inside the same shared restart budget.
+     * 0 / omitted = off.
+     */
+    streamInactivityMs?: number;
 }
 export interface RunWorkerResult {
     text: string;
@@ -129,6 +139,16 @@ export interface RunWorkerResult {
         toolName: string;
         timeoutMs: number;
     };
+    /**
+     * Set when the stream watchdog killed the worker's FINAL attempt: the model
+     * stream produced nothing for the configured window while no tool was running.
+     * Like loopHit/timedOut the text is partial — treat as a failure, and check it
+     * BEFORE `aborted` (the kill aborts too), or a hung backend is mislabeled a
+     * user cancel.
+     */
+    streamStalled?: {
+        idleMs: number;
+    };
 }
 /**
  * The per-command ceiling for attempt N, halving each time a hang recurs.

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

@@ -6,6 +6,7 @@ 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';
+import { streamStallHint } from '../shared/stream-watchdog.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
@@ -207,6 +208,9 @@ export async function runWorker(input) {
                                 ?? (() => probeModelEndpoints(discoverModelEndpoints()))
                         }
                     }),
+                ...(input.streamInactivityMs ?
+                    { streamInactivityMs: input.streamInactivityMs }
+                    : {}),
                 onFirstByte: () => (tFirstByte = Date.now()),
                 onToolCall: call => {
                     cmdWatch?.onStart(call);
@@ -240,6 +244,7 @@ export async function runWorker(input) {
         const text = result.text ?? '';
         const timedOut = timeout.timedOut();
         const commandKill = cmdWatch?.killed();
+        const streamStalled = result.streamStalled;
         // A loop-kill gets the same restart-with-hint treatment every other phase
         // already gets (runPhaseWithLoopGuard) — name the offending call so the
         // re-spawn avoids it. Bounded by the shared restart budget.
@@ -265,6 +270,14 @@ export async function runWorker(input) {
             hangKills++;
             continue;
         }
+        // A hung model stream is restartable on the same budget. Checked before
+        // the wall-clock timeout because it is the more specific diagnosis (and
+        // its hint does not blame the model: nothing it did caused the hang).
+        if (streamStalled && !loopHit && restarts < MAX_LOOP_RESTARTS) {
+            hint = streamStallHint(streamStalled.idleMs);
+            restarts++;
+            continue;
+        }
         // A wall-clock timeout (the backstop for varied thrash the exact-match
         // detector misses) is also restartable, sharing the same budget. Skip when
         // a loop also tripped — the loop hint above is more specific.
@@ -293,6 +306,7 @@ export async function runWorker(input) {
             ...(loopHit ? { loopHit } : {}),
             ...(timedOut ? { timedOut: true } : {}),
             ...(result.stalled ? { stalled: true } : {}),
+            ...(streamStalled ? { streamStalled } : {}),
             ...(commandKill ?
                 {
                     commandTimedOut: {

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

@@ -5,6 +5,13 @@ import { resolvePackage as defaultResolvePackage } from './docs-resolve.js';
 import { retrieveChunks as defaultRetrieveChunks } from './docs-retrieve.js';
 import { npmVersionLookup as defaultNpmVersionLookup } from './npm-version.js';
 import { type SpawnFn } from '../shared/child-process.js';
+/**
+ * The package NAME a module specifier belongs to — `hono/client` → `hono`,
+ * `@scope/name/sub` → `@scope/name`. The cache stores this (not the raw specifier) as an
+ * entry's package provenance, so a subpath lookup is matched against package.json's key
+ * and invalidated with its package rather than living forever unmatched.
+ */
+export declare function packageRootOf(module: string): string;
 export interface PiWorkerDocsInternals {
     resolvePackage?: typeof defaultResolvePackage;
     ensureIndexed?: typeof defaultEnsureIndexed;

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

@@ -21,6 +21,16 @@ const Params = Type.Object({
         description: 'What to extract from the docs. The child pi reads ranked chunks and returns ONLY content answering this.'
     })
 });
+/**
+ * The package NAME a module specifier belongs to — `hono/client` → `hono`,
+ * `@scope/name/sub` → `@scope/name`. The cache stores this (not the raw specifier) as an
+ * entry's package provenance, so a subpath lookup is matched against package.json's key
+ * and invalidated with its package rather than living forever unmatched.
+ */
+export function packageRootOf(module) {
+    const parts = module.trim().split('/');
+    return parts[0].startsWith('@') ? parts.slice(0, 2).join('/') : parts[0];
+}
 function pinDetails(pin) {
     return pin ? { versionSource: pin.source, declaredRange: pin.range } : {};
 }
@@ -249,6 +259,12 @@ export function registerPiWorkerDocs(pi, internals = {}) {
         cacheKey: params => params.module === '.' ?
             null
             : `${normalizeQuery(params.module)}::${normalizeQuery(params.query)}`,
+        // Package provenance for per-entry resume invalidation: a docs digest describes
+        // one package at one declared version, so a resume drops it only when THAT
+        // package moves — an unrelated install no longer discards it. Package names are
+        // matched against package.json verbatim (npm names are case-sensitive), unlike
+        // the cache key, which normalises for phrasing collisions.
+        cachePkg: params => (params.module === '.' ? undefined : packageRootOf(params.module)),
         // Only a completed lookup (child exited 0) is a real answer; not-installed,
         // no-chunks, resolve/cache errors, and aborts omit childExitCode:0 and fall
         // through to a live retry next time.

package/dist/workers/research-cache.d.ts

@@ -23,31 +23,32 @@ export declare function configureResearchRun(enabled: boolean): string | undefin
  */
 export declare function normalizeQuery(s: string): string;
 /**
- * A stable fingerprint of the project's declared dependency surface — the only input a
- * cached docs digest actually depends on (a digest summarises a package's INSTALLED
- * types/README at a pinned version). Built from package.json's dependency blocks with
- * keys sorted, so formatting churn or an unrelated field edit does not invalidate it,
- * while any add/remove/version-bump does.
+ * The project's declared dependency surface as a name→range map, flattened across every
+ * dependency block (a package listed in two blocks resolves to the first range seen, in
+ * block order — a real manifest does not disagree with itself, and a disagreement can
+ * only make the comparison stricter, i.e. re-fetch).
  *
- * Returns undefined when the manifest is missing or unparseable — the caller then has
- * NO positive evidence of freshness and must not reuse. Deliberately NOT the lockfile's
- * hash or mtime: a lockfile is rewritten by installs that do not change any resolved
- * version, which would defeat reuse for no correctness gain.
+ * Returns undefined when the manifest is missing or unparseable: the caller then cannot
+ * prove any package's version and must treat every package-scoped entry as unprovable.
+ * Deliberately NOT the lockfile: it is rewritten by installs that change no resolved
+ * version, which would drop digests for no correctness gain.
  */
-export declare function depsFingerprint(cwd: string): Promise<string | undefined>;
+export declare function depsMap(cwd: string): Promise<Record<string, string> | undefined>;
 /**
- * Resume hook: reuse the interrupted run's cache id when — and only when — the file
- * proves it describes the same dependency surface. Returns the id now stamped into the
- * environment (reused or fresh), or undefined when caching is off.
+ * Resume hook: keep the interrupted run's cache id and PRUNE the entries the manifest
+ * has invalidated, rather than discarding the whole cache because anything moved. Returns
+ * the id now stamped into the environment (reused or fresh), how many entries survived,
+ * and how many were dropped; undefined id when caching is off.
  *
- * Every uncertain path falls through to a fresh id, which merely re-fetches:
- * caching disabled, no/corrupt cache file, a file with no fingerprint (written before
- * this shipped), an unreadable manifest, or a fingerprint that no longer matches.
+ * Falls through to a fresh id only where there is nothing to reuse or nothing to reason
+ * with: caching disabled, no/corrupt cache file, or a file predating per-entry package
+ * provenance (`pkgv`) whose docs entries cannot be told apart from its search entries.
  */
 export declare function resumeResearchRun(cwd: string, enabled: boolean): Promise<{
     runId: string | undefined;
     reused: boolean;
     entries: number;
+    dropped: number;
 }>;
 /**
  * Look up a cached result for `key` in the current run. Returns undefined on a miss,
@@ -61,6 +62,13 @@ export declare function lookupResearch(cwd: string, runId: string, key: string):
  * Store a successful result under `key` for the current run. A file written for a
  * different run id is discarded and started fresh (first write of a new run drops the
  * prior run's contents — self-healing per-run isolation without an explicit clear).
+ *
+ * `pkg` is the npm package the answer is ABOUT, supplied by package-scoped tools (docs).
+ * Its declared version is resolved HERE, at store time, so a package installed mid-run
+ * is stamped with the version its own digest was taken against — not with whatever the
+ * manifest happened to say at the run's first write. That is what makes a later resume
+ * able to prune this one entry instead of the whole file.
+ *
  * Best-effort: any failure is swallowed, leaving the caller's live result untouched.
  */
-export declare function storeResearch(cwd: string, runId: string, key: string, text: string, details: unknown): Promise<void>;
+export declare function storeResearch(cwd: string, runId: string, key: string, text: string, details: unknown, pkg?: string): Promise<void>;