@mjasnikovs/pi-task 0.38.14 → 0.38.16

package/dist/workers/http-request.d.ts

@@ -0,0 +1,74 @@
+/**
+ * http-request — the one bounded HTTP request in this codebase.
+ *
+ * Five modules used to hand-roll the same ~12 lines: an internal
+ * `AbortController`, a `setTimeout` that aborts it, a `userAborted` flag set
+ * from the caller's signal, and a `finally` that clears the timer and removes
+ * the listener. Five copies of a rule is five chances to drift, and it HAD
+ * drifted — `npm-version.ts` never grew the `userAborted` flag, so a user cancel
+ * came back as `null`, indistinguishable from a registry that is down.
+ *
+ * What is shared is the BOUNDING, not the interpretation. Each caller still owns
+ * its own status-code policy (DDG treats 429/403 as rate-limiting, Brave splits
+ * auth from rate-limit, npm treats every non-OK as "no answer") and its own error
+ * type, because those genuinely differ. What they cannot differ on is whether the
+ * request was cancelled by the user, killed by the clock, or refused by the
+ * network — so that verdict is made once, here.
+ *
+ * The handler runs INSIDE the timeout. `fetch` resolves as soon as the headers
+ * arrive, so a seam that returned the `Response` and cleared its own timer would
+ * leave the body read unbounded — a hung stream would hang forever. Passing a
+ * handler keeps the clock over the whole operation, which is what every copy of
+ * the ritual already did.
+ */
+/** Injectable fetch — the narrow signature keeps test fakes free of Bun's extras. */
+export type FetchLike = (url: string, init?: RequestInit) => Promise<Response>;
+/**
+ * Why the request never produced a response. Deliberately only two kinds: a
+ * status code is not a failure of the REQUEST, and what a given status means is
+ * the caller's policy.
+ */
+export declare class HttpRequestError extends Error {
+    readonly kind: 'aborted' | 'network';
+    /** The underlying cause, already rendered — callers put it in their own message. */
+    readonly detail: string;
+    readonly cause?: unknown | undefined;
+    constructor(kind: 'aborted' | 'network', 
+    /** The underlying cause, already rendered — callers put it in their own message. */
+    detail: string, cause?: unknown | undefined);
+}
+export interface HttpRequestOpts {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    redirect?: 'follow' | 'error' | 'manual';
+    /** Wall clock over the request AND the handler. Required — no silent default. */
+    timeoutMs: number;
+    /** The caller's cancel. Its firing is what makes `userAborted()` true. */
+    signal?: AbortSignal;
+    fetchImpl?: FetchLike;
+}
+/** What a handler can ask about, and do to, the request it is reading. */
+export interface HttpRequestControl {
+    /** The request's own signal, so a handler can pass it further down. */
+    readonly signal: AbortSignal;
+    /**
+     * Abort the in-flight request from inside the handler — a size cap hit, an
+     * early stop. Distinct from both a user cancel and the timeout, so a handler
+     * that calls this can tell its own abort apart from the other two.
+     */
+    abort(): void;
+    /** The CALLER cancelled. Not the timeout, not `abort()`. */
+    userAborted(): boolean;
+    /** The wall clock fired. */
+    timedOut(): boolean;
+}
+/**
+ * Run one bounded HTTP request and hand the response to `handle`.
+ *
+ * Throws {@link HttpRequestError} when the request itself failed. Anything
+ * `handle` throws propagates untouched — that is the caller's own policy talking.
+ */
+export declare function httpRequest<T>(url: string, opts: HttpRequestOpts, handle: (response: Response, ctl: HttpRequestControl) => Promise<T>): Promise<T>;
+/** A readable one-liner for an unknown thrown value. Four byte-identical copies. */
+export declare function describeError(err: unknown): string;

package/dist/workers/http-request.js

@@ -0,0 +1,103 @@
+/**
+ * http-request — the one bounded HTTP request in this codebase.
+ *
+ * Five modules used to hand-roll the same ~12 lines: an internal
+ * `AbortController`, a `setTimeout` that aborts it, a `userAborted` flag set
+ * from the caller's signal, and a `finally` that clears the timer and removes
+ * the listener. Five copies of a rule is five chances to drift, and it HAD
+ * drifted — `npm-version.ts` never grew the `userAborted` flag, so a user cancel
+ * came back as `null`, indistinguishable from a registry that is down.
+ *
+ * What is shared is the BOUNDING, not the interpretation. Each caller still owns
+ * its own status-code policy (DDG treats 429/403 as rate-limiting, Brave splits
+ * auth from rate-limit, npm treats every non-OK as "no answer") and its own error
+ * type, because those genuinely differ. What they cannot differ on is whether the
+ * request was cancelled by the user, killed by the clock, or refused by the
+ * network — so that verdict is made once, here.
+ *
+ * The handler runs INSIDE the timeout. `fetch` resolves as soon as the headers
+ * arrive, so a seam that returned the `Response` and cleared its own timer would
+ * leave the body read unbounded — a hung stream would hang forever. Passing a
+ * handler keeps the clock over the whole operation, which is what every copy of
+ * the ritual already did.
+ */
+/**
+ * Why the request never produced a response. Deliberately only two kinds: a
+ * status code is not a failure of the REQUEST, and what a given status means is
+ * the caller's policy.
+ */
+export class HttpRequestError extends Error {
+    kind;
+    detail;
+    cause;
+    constructor(kind, 
+    /** The underlying cause, already rendered — callers put it in their own message. */
+    detail, cause) {
+        super(detail);
+        this.kind = kind;
+        this.detail = detail;
+        this.cause = cause;
+        this.name = 'HttpRequestError';
+    }
+}
+/**
+ * Run one bounded HTTP request and hand the response to `handle`.
+ *
+ * Throws {@link HttpRequestError} when the request itself failed. Anything
+ * `handle` throws propagates untouched — that is the caller's own policy talking.
+ */
+export async function httpRequest(url, opts, handle) {
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const controller = new AbortController();
+    let userAborted = false;
+    let timedOut = false;
+    const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+    }, opts.timeoutMs);
+    const onUserAbort = () => {
+        userAborted = true;
+        controller.abort();
+    };
+    if (opts.signal) {
+        if (opts.signal.aborted)
+            onUserAbort();
+        else
+            opts.signal.addEventListener('abort', onUserAbort, { once: true });
+    }
+    const ctl = {
+        signal: controller.signal,
+        abort: () => controller.abort(),
+        userAborted: () => userAborted,
+        timedOut: () => timedOut
+    };
+    try {
+        let response;
+        try {
+            response = await fetchImpl(url, {
+                ...(opts.method === undefined ? {} : { method: opts.method }),
+                ...(opts.headers === undefined ? {} : { headers: opts.headers }),
+                ...(opts.body === undefined ? {} : { body: opts.body }),
+                ...(opts.redirect === undefined ? {} : { redirect: opts.redirect }),
+                signal: controller.signal
+            });
+        }
+        catch (err) {
+            if (userAborted)
+                throw new HttpRequestError('aborted', 'Request aborted.', err);
+            throw new HttpRequestError('network', describeError(err), err);
+        }
+        return await handle(response, ctl);
+    }
+    finally {
+        clearTimeout(timer);
+        if (opts.signal)
+            opts.signal.removeEventListener('abort', onUserAbort);
+    }
+}
+/** A readable one-liner for an unknown thrown value. Four byte-identical copies. */
+export function describeError(err) {
+    if (err instanceof Error)
+        return err.message;
+    return String(err);
+}

package/dist/workers/npm-version.js

@@ -10,6 +10,7 @@
  * enough to anchor the worker in current reality: the dist-tag 'latest', a
  * short list of recent versions, and the publish date of latest.
  */
+import { httpRequest, HttpRequestError } from './http-request.js';
 const REGISTRY_BASE = 'https://registry.npmjs.org';
 const DEFAULT_TIMEOUT_MS = 3000;
 const RECENT_VERSIONS_LIMIT = 10;
@@ -24,50 +25,44 @@ export async function npmVersionLookup(pkg, opts = {}) {
         return null;
     const base = opts.registry ?? REGISTRY_BASE;
     const url = `${base}/${encodePackageName(pkg)}`;
-    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    const internalController = new AbortController();
-    const timeoutHandle = setTimeout(() => internalController.abort(), timeoutMs);
-    const onUserAbort = () => internalController.abort();
-    if (opts.signal) {
-        if (opts.signal.aborted)
-            onUserAbort();
-        else
-            opts.signal.addEventListener('abort', onUserAbort, { once: true });
-    }
     try {
-        let response;
-        try {
-            response = await fetch(url, {
-                method: 'GET',
-                headers: { accept: 'application/vnd.npm.install-v1+json, application/json' },
-                signal: internalController.signal
-            });
-        }
-        catch {
-            return null;
-        }
-        if (!response.ok)
-            return null;
-        let body;
-        try {
-            body = (await response.json());
-        }
-        catch {
-            return null;
-        }
-        const latest = body['dist-tags']?.latest;
-        if (typeof latest !== 'string' || latest.length === 0)
-            return null;
-        const allVersions = Object.keys(body.versions ?? {});
-        const recent = allVersions.slice(-RECENT_VERSIONS_LIMIT).reverse();
-        const publishedAtRaw = body.time?.[latest];
-        const publishedAt = typeof publishedAtRaw === 'string' ? publishedAtRaw : undefined;
-        return { pkg, latest, recent, publishedAt };
+        return await httpRequest(url, {
+            timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+            ...(opts.signal === undefined ? {} : { signal: opts.signal }),
+            method: 'GET',
+            headers: { accept: 'application/vnd.npm.install-v1+json, application/json' }
+        }, async (response) => {
+            // npm's own status policy: a version banner is a nicety, so every
+            // non-OK answer is simply "no version to report".
+            if (!response.ok)
+                return null;
+            let body;
+            try {
+                body = (await response.json());
+            }
+            catch {
+                return null;
+            }
+            const latest = body['dist-tags']?.latest;
+            if (typeof latest !== 'string' || latest.length === 0)
+                return null;
+            const allVersions = Object.keys(body.versions ?? {});
+            const recent = allVersions.slice(-RECENT_VERSIONS_LIMIT).reverse();
+            const publishedAtRaw = body.time?.[latest];
+            const publishedAt = typeof publishedAtRaw === 'string' ? publishedAtRaw : undefined;
+            return { pkg, latest, recent, publishedAt };
+        });
     }
-    finally {
-        clearTimeout(timeoutHandle);
-        if (opts.signal)
-            opts.signal.removeEventListener('abort', onUserAbort);
+    catch (err) {
+        // A user cancel is re-thrown, not swallowed. This module was the copy of the
+        // request ritual that never grew a `userAborted` flag, so a cancelled lookup
+        // returned `null` — indistinguishable from a registry that is down, and the
+        // caller went on assembling a block for a run the user had already stopped.
+        if (err instanceof HttpRequestError && err.kind === 'aborted')
+            throw err;
+        if (err instanceof HttpRequestError)
+            return null;
+        throw err;
     }
 }
 /** Format an NpmVersionInfo as a short Markdown block for EXTERNAL CONTEXT. */

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

@@ -1,7 +1,18 @@
 import { type ContextSnapshot, type SpawnFn } from '../shared/child-process.js';
 import { type LoopHit } from '../task/loop-detector.js';
-/** True when a tool call retrieves content an APIS entry could be grounded in. */
-export declare function isGroundingRetrieval(toolName: string): boolean;
+/**
+ * Tool calls that can GROUND an APIS claim — i.e. return content a signature or
+ * command could be cited from. `pi-worker-docs` (the primary), `read` and `grep`
+ * (project source), and the web escalations `pi-worker-search`/`pi-worker-fetch`.
+ *
+ * `ls` and `find` are deliberately EXCLUDED: they return file/directory NAMES,
+ * and APIS owns symbols by name only, never paths (RESEARCH_APIS_PROMPT). Bare
+ * enumeration cannot verify a signature, so a worker that fabricates its section
+ * from memory does not launder itself grounded by calling `ls` once. That
+ * exclusion is the anti-gaming property of any gate built on this count: "one
+ * trivial `ls` then fabricate the rest" leaves groundingRetrievalCount at 0.
+ */
+export { isGroundingRetrieval } from './worker-channels.js';
 /**
  * Does this partial output carry ANSWER CONTENT, or is it the model clearing its
  * throat?

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

@@ -1,6 +1,7 @@
 import { getPiInvocation } from '../shared/pi-invocation.js';
 import { runChildDefault } from '../shared/child-process.js';
 import { CommandWatchdog, commandTimeoutHint, realTimerDeps } from '../shared/command-watchdog.js';
+import { isGroundingRetrieval as isGrounding, workerChannel } from './worker-channels.js';
 import { childBaseArgs } from '../shared/child-extensions.js';
 import { LoopDetector } from '../task/loop-detector.js';
 import { LOOP_WINDOW, LOOP_THRESHOLD, MAX_LOOP_RESTARTS, formatLoopHint, isConnectionError, connectionRetryBackoffMs } from '../task/child-runner.js';
@@ -27,17 +28,10 @@ const DEFAULT_TOOLS = 'read,grep,find,ls';
  * exclusion is the anti-gaming property of any gate built on this count: "one
  * trivial `ls` then fabricate the rest" leaves groundingRetrievalCount at 0.
  */
-const GROUNDING_RETRIEVAL_TOOLS = new Set([
-    'pi-worker-docs',
-    'read',
-    'grep',
-    'pi-worker-search',
-    'pi-worker-fetch'
-]);
-/** True when a tool call retrieves content an APIS entry could be grounded in. */
-export function isGroundingRetrieval(toolName) {
-    return GROUNDING_RETRIEVAL_TOOLS.has(toolName);
-}
+// The grounding set is derived from WORKER_CHANNELS (worker-channels.ts), not
+// hand-kept — this was a second copy of the four tool names. Re-exported because
+// several call sites and tests import it from here.
+export { isGroundingRetrieval } from './worker-channels.js';
 /**
  * Hard wall-clock bound on a single research worker run (one spawn). The
  * exact-match LoopDetector only catches *identical* repeated tool calls; a model
@@ -272,7 +266,7 @@ export function commandCeilingForAttempt(baseMs, priorHangs) {
 const RESTART_RULES = [
     {
         // A loop-kill gets the same restart-with-hint treatment every other phase
-        // already gets (runPhaseWithLoopGuard) — name the offending call so the
+        // already gets (runPhaseChild) — name the offending call so the
         // re-spawn avoids it. Bounded by the shared restart budget.
         reason: 'loop',
         detect: s => s.loopHit && s.restartBudgetSpent < MAX_LOOP_RESTARTS ?
@@ -329,7 +323,7 @@ const RESTART_RULES = [
     },
     {
         // A connection-class model error is restartable on the same budget, exactly
-        // as runPhaseWithLoopGuard already treats it — a research worker had no such
+        // as runPhaseChild already treats it — a research worker had no such
         // retry, so one dropped fetch failed the whole task at research while the
         // identical blip in refine/compose was absorbed.
         //
@@ -429,7 +423,7 @@ export async function runWorker(input) {
     const timeoutMs = input.timeoutMs ?? RESEARCH_WORKER_TIMEOUT_MS;
     let hint = null;
     // Loop-kill and timeout share one restart budget, mirroring
-    // runPhaseWithLoopGuard: a runaway worker gets re-spawned with a corrective
+    // runPhaseChild: a runaway worker gets re-spawned with a corrective
     // hint up to MAX_LOOP_RESTARTS times before we give up. Leaked tool calls
     // keep their own MAX_LEAK_RETRIES budget below — a different failure mode.
     let restartBudgetSpent = 0;
@@ -522,12 +516,13 @@ export async function runWorker(input) {
                     // A tool call is the worker working. Inert unless the
                     // caller opted into a progress-based deadline.
                     timeout.progress();
+                    // The generic child runner used to name ONE tool and ONE of
+                    // its parameters here. It asks the tool's own row now.
                     if (input.fanoutTimeout
-                        && call.name === 'pi-worker-docs'
-                        && call.args?.module === '.') {
+                        && workerChannel(call.name)?.isProjectSourceLookup?.(call.args ?? {}) === true) {
                         timeout.extend(input.fanoutTimeout.perLookupMs, input.fanoutTimeout.ceilingMs);
                     }
-                    if (isGroundingRetrieval(call.name))
+                    if (isGrounding(call.name))
                         groundingRetrievalCount++;
                     if (!loopDetector)
                         return null;

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

@@ -67,7 +67,7 @@ export declare function registerPiWorkerDocs(pi: ExtensionAPI, internals?: PiWor
  * exists to prevent: four regexes matching three phrasings, documented at length in
  * abstention.ts, which cost a real bug.
  */
-export declare function docsCacheable(d: Pick<DocsDetails, 'childExitCode' | 'typeOnly' | 'excerptVerified'>, text: string): boolean;
+export declare function docsCacheable(d: Pick<DocsDetails, 'typeOnly' | 'excerptVerified'>, text: string): boolean;
 /** The docs cache key: a package's answer is per (module, question). A project-source
  *  `.` lookup is never cached — the working tree mutates as tasks implement. */
 export declare function docsCacheKey(params: {

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

@@ -7,7 +7,7 @@ import { formatResultText } from '../shared/child-output.js';
 import { docsRaw, packageHeader, buildPrompt, buildVersionBanner } from './docs-core.js';
 import { formatNpmVersionSection } from './npm-version.js';
 import { runFocusedExtraction } from './focused-extractor.js';
-import { makeWorkerTool } from './shared.js';
+import { childFailureReason, makeWorkerTool, workerAnswer, workerUnavailable } from './shared.js';
 import { isTypeOnlyAnswer } from '../task/type-only-answer.js';
 import { logDocsAnswer } from './typeonly-log.js';
 import { normalizeQuery } from './research-cache.js';
@@ -61,18 +61,18 @@ function pinDetails(pin) {
  * The paths differ only in `prefix`: the npm path leads every result, failures included, with
  * its version banner and npm-version header; the project path has neither.
  *
- * `childExitCode` is recorded but NOT as 0, which is what keeps a failure out of the research
- * cache (see `cacheable` below).
+ * It says UNAVAILABLE, so the cache cannot take it. It used to say so by writing a
+ * non-zero `childExitCode` and letting `docsCacheable` re-derive the verdict — a
+ * derivation that failed on the case it mattered most for: a signal-killed child
+ * reports exit code 0, so `"Docs lookup aborted."` was cached for the whole run.
+ * `aborted` was written here and read by nothing, which is what let that hide.
  */
 function docsFailureResult(extraction, baseDetails, prefix) {
-    return {
-        text: prefix + extraction.failure,
-        details: {
-            ...baseDetails,
-            ...(extraction.aborted ? { aborted: true } : {}),
-            childExitCode: extraction.exitCode
-        }
-    };
+    return workerUnavailable(prefix + extraction.failure, {
+        ...baseDetails,
+        ...(extraction.aborted ? { aborted: true } : {}),
+        childExitCode: extraction.exitCode
+    }, childFailureReason({ exitCode: extraction.exitCode, aborted: extraction.aborted }));
 }
 export function registerPiWorkerDocs(pi, internals = {}) {
     // CAP arm of nexttask 5B — OFF unless PI_TASK_PROJECT_DOCS_BUDGET is set, and
@@ -145,10 +145,7 @@ export function registerPiWorkerDocs(pi, internals = {}) {
                 if (budget !== null && ++projectLookups > budget) {
                     // Refused BEFORE any work: the point of the cap is the child
                     // spawn and the model pass this branch would otherwise run.
-                    return {
-                        text: projectDocsBudgetExhausted(budget),
-                        details: { budgetSpent: true }
-                    };
+                    return workerUnavailable(projectDocsBudgetExhausted(budget), { budgetSpent: true }, 'budget-spent');
                 }
                 const openCache = internals.openCache ?? defaultOpenCache;
                 let cache;
@@ -160,24 +157,19 @@ export function registerPiWorkerDocs(pi, internals = {}) {
                     cacheError = err instanceof Error ? err.message : String(err);
                 }
                 if (!cache) {
-                    return {
-                        text: `Project docs unavailable: cache open failed (${cacheError}).`,
-                        details: {}
-                    };
+                    return workerUnavailable(`Project docs unavailable: cache open failed (${cacheError}).`, {}, 'cache-open-failed');
                 }
                 const retrieveChunks = internals.retrieveChunks ?? defaultRetrieveChunks;
                 const projectResult = projectDocsRaw(cache, ctx.cwd, params.query, retrieveChunks);
                 if (projectResult.kind === 'error') {
-                    return { text: `Project docs error: ${projectResult.message}`, details: {} };
+                    return workerUnavailable(`Project docs error: ${projectResult.message}`, {}, 'project-docs-error');
                 }
                 if (projectResult.kind === 'no_chunks') {
-                    return {
-                        text: `Project "${projectResult.projectName}" has no .ts/.tsx files indexed.`,
-                        details: {
-                            hitCache: projectResult.hitCache,
-                            indexedFiles: projectResult.filesIngested
-                        }
-                    };
+                    // The project IS indexed and has nothing — a real answer.
+                    return workerAnswer(`Project "${projectResult.projectName}" has no .ts/.tsx files indexed.`, {
+                        hitCache: projectResult.hitCache,
+                        indexedFiles: projectResult.filesIngested
+                    });
                 }
                 const { projectName, chunks, hitCache, filesIngested, indexingMs } = projectResult;
                 const baseDetails = {
@@ -214,14 +206,10 @@ export function registerPiWorkerDocs(pi, internals = {}) {
                     excerptCheck: extraction.excerptCheck,
                     toolText: text
                 });
-                return {
-                    text,
-                    details: {
-                        ...baseDetails,
-                        childExitCode: 0,
-                        excerptVerified: verified
-                    }
-                };
+                return workerAnswer(text, {
+                    ...baseDetails,
+                    excerptVerified: verified
+                });
             }
             // ── npm package lookup (existing path) ──────────────────────────
             const rawResult = await docsRaw({
@@ -253,31 +241,27 @@ export function registerPiWorkerDocs(pi, internals = {}) {
                     autoInstalled: rawResult.autoInstalled,
                     ...npmDetails
                 };
-                return { text: npmHeader + rawResult.message, details };
+                return workerUnavailable(npmHeader + rawResult.message, details, 'docs-error');
             }
             if (rawResult.kind === 'not_installed') {
-                return {
-                    text: npmHeader
-                        + `Package "${rawResult.pkg}" is not installed and auto-install failed.`,
-                    details: { resolveError: 'not_installed', ...npmDetails }
-                };
+                return workerUnavailable(npmHeader
+                    + `Package "${rawResult.pkg}" is not installed and auto-install failed.`, { resolveError: 'not_installed', ...npmDetails }, 'not-installed');
             }
             if (rawResult.kind === 'no_chunks') {
                 const banner = buildVersionBanner(rawResult.autoInstallPin, rawResult.pkg.name, rawResult.pkg.version, ctx.cwd);
-                return {
-                    text: banner
-                        + npmHeader
-                        + `Package ${rawResult.pkg.name}@${rawResult.pkg.version} has no .d.ts files or README. Use pi-worker to read source directly.`,
-                    details: {
-                        version: rawResult.pkg.version,
-                        hitCache: rawResult.hitCache,
-                        indexedFiles: rawResult.indexedFiles ?? 0,
-                        cacheError: rawResult.cacheError,
-                        autoInstalled: rawResult.autoInstalled,
-                        ...pinDetails(rawResult.autoInstallPin),
-                        ...npmDetails
-                    }
-                };
+                // The package resolved and genuinely ships nothing to read — an
+                // answer, and a stable one for this run.
+                return workerAnswer(banner
+                    + npmHeader
+                    + `Package ${rawResult.pkg.name}@${rawResult.pkg.version} has no .d.ts files or README. Use pi-worker to read source directly.`, {
+                    version: rawResult.pkg.version,
+                    hitCache: rawResult.hitCache,
+                    indexedFiles: rawResult.indexedFiles ?? 0,
+                    cacheError: rawResult.cacheError,
+                    autoInstalled: rawResult.autoInstalled,
+                    ...pinDetails(rawResult.autoInstallPin),
+                    ...npmDetails
+                });
             }
             // kind === 'ok'
             const { pkg, chunks, hitCache, indexingMs, cacheError, autoInstalled } = rawResult;
@@ -352,15 +336,11 @@ export function registerPiWorkerDocs(pi, internals = {}) {
                 excerptCheck: extraction.excerptCheck,
                 toolText: text
             });
-            return {
-                text,
-                details: {
-                    ...baseDetails,
-                    childExitCode: 0,
-                    excerptVerified: verified,
-                    ...(typeOnly.typeOnly ? { typeOnly: true } : {})
-                }
-            };
+            return workerAnswer(text, {
+                ...baseDetails,
+                excerptVerified: verified,
+                ...(typeOnly.typeOnly ? { typeOnly: true } : {})
+            });
         },
         renderCall(args, theme) {
             const query = args.query.replace(/\s+/g, ' ').trim();
@@ -410,10 +390,11 @@ export function registerPiWorkerDocs(pi, internals = {}) {
  * abstention.ts, which cost a real bug.
  */
 export function docsCacheable(d, text) {
-    return (d.childExitCode === 0
-        && d.typeOnly !== true
-        && d.excerptVerified !== false
-        && !isAbstention(text));
+    // Answer QUALITY only. Whether there IS an answer is `WorkerOutcome.kind`, and
+    // `makeWorkerTool` has already refused an `unavailable` before reaching here —
+    // this used to open with `childExitCode === 0`, which a signal-killed child
+    // satisfies, so an aborted lookup was memoised for the run.
+    return d.typeOnly !== true && d.excerptVerified !== false && !isAbstention(text);
 }
 /** The docs cache key: a package's answer is per (module, question). A project-source
  *  `.` lookup is never cached — the working tree mutates as tasks implement. */

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

@@ -28,7 +28,7 @@ export declare function registerPiWorkerFetch(pi: ExtensionAPI, internals?: PiWo
  * `docsCacheable`: pi-worker-fetch.test.ts carried a hand-retyped copy driving four
  * tests, which a change to the shipped rule would leave green.
  */
-export declare function fetchCacheable(d: Pick<FetchDetails, 'childExitCode'>, text: string): boolean;
+export declare function fetchCacheable(_d: Pick<FetchDetails, never>, text: string): boolean;
 /** The fetch cache key. URL verbatim (path case can matter), question normalised —
  *  same page, different question is a different answer. */
 export declare function fetchCacheKey(params: {