@mjasnikovs/pi-task 0.38.15 → 0.38.17

package/dist/task/task-gates.js

@@ -1,3 +1,4 @@
+import { verifyFailClass } from './verify-work.js';
 import { resolutionOptions, classifyResolutionAnswer } from './verify-resolution.js';
 import { SessionUI } from '../remote/bridge.js';
 import { isYoloMode, yoloVerifyResolution, YOLO_STAMP } from './yolo.js';
@@ -121,7 +122,8 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
             // bounded fix attempt before the picker — smallest tool first. Applied →
             // re-verify and re-enter the loop on the fresh verdict; not applied (guard
             // trip, no convergence) → fall through to the ordinary picker unchanged.
-            if (!lintFixAttempted && deps.lintFix && failReason.startsWith('repo health:')) {
+            const failClass = verifyFailClass(verified);
+            if (!lintFixAttempted && deps.lintFix && failClass === 'repo-health') {
                 lintFixAttempted = true;
                 active.ui.notify(`${p.tag}: static findings on "${p.title}" — attempting bounded lint fix…`, 'info');
                 const fix = await deps.lintFix(active, p.cwd, p.title, p.taskId, failReason);
@@ -149,7 +151,7 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
             // records the (already-recorded) defect as the human's call. Applies
             // only while the FAIL is still the repo-health one the contradiction
             // explains — a later, different FAIL gets the ordinary resolution path.
-            const isFrozenBlocked = frozenContradiction !== null && failReason.startsWith('repo health:');
+            const isFrozenBlocked = frozenContradiction !== null && failClass === 'repo-health';
             const recOutcome = isUnobserved ? { recommend: 'autofix', rationale: failReason }
                 : isFrozenBlocked ?
                     {
@@ -319,12 +321,31 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
                 fixInstruction
             });
             active = fixRes.ctx ?? active;
-            if (fixRes.sessionCancelled)
+            // The re-run's ending, mapped to this loop's own terminal kinds. A
+            // CANCEL lands on `interrupted` — the user stopped it, so the task is
+            // left resumable rather than reported as a fault.
+            if (fixRes.end.kind === 'no-session') {
                 return { stop: { kind: 'session-cancelled', ctx: active } };
-            if (fixRes.interrupted)
+            }
+            // A CANCEL and an ESC-interrupt are NOT the same ending. Folding them
+            // together sent a cancelled re-run down the `interrupted` row, which
+            // demotes the task file — writing `failed` over the `cancelled` the
+            // cancel itself wrote.
+            if (fixRes.end.kind === 'cancelled') {
+                return { stop: { kind: 'cancelled', ctx: active } };
+            }
+            if (fixRes.end.kind === 'interrupted') {
                 return { stop: { kind: 'interrupted', ctx: active } };
-            if (!fixRes.ok)
-                return { stop: { kind: 'failed', ctx: active, reason: fixRes.reason } };
+            }
+            if (fixRes.end.kind === 'failed') {
+                return {
+                    stop: {
+                        kind: 'failed',
+                        ctx: active,
+                        ...(fixRes.end.reason === undefined ? {} : { reason: fixRes.end.reason })
+                    }
+                };
+            }
             // Resume reuses the same inner task id, so p.taskId is stable.
             verified = await deps.verify(active, p.cwd, p.title, p.taskId);
             await rec(verdictLine(verified));

package/dist/task/terminal-outcome.d.ts

@@ -25,7 +25,7 @@
  * overrides, which is not a simplification.
  */
 /** The gate outcomes a command has to act on. Mirrors runGatesForTask's union. */
-export type TerminalOutcomeKind = 'done' | 'paused' | 'session-cancelled' | 'interrupted' | 'failed';
+export type TerminalOutcomeKind = 'done' | 'paused' | 'session-cancelled' | 'cancelled' | 'interrupted' | 'failed';
 /** What the message needs to name. */
 export interface TerminalMessageContext {
     /** The task or run id shown to the user (`TASK_0007`, `AUTO_0002`, `Task`). */

package/dist/task/terminal-outcome.js

@@ -59,6 +59,18 @@ export const TERMINAL_OUTCOMES = {
         message: c => `${c.tag} paused — could not start a session for autofix. `
             + `Run ${c.resumeCmd} to retry.`
     },
+    cancelled: {
+        // The USER stopped the re-run. The task file already says `cancelled`, and
+        // `markResumable` writes `failed` — that both lies in the ledger and turns
+        // a deliberate stop into a red error. RUN_END_POLICY states this for the
+        // first implementation run; this row states the same thing for a re-run.
+        markResumable: false,
+        failParent: false,
+        level: 'warning',
+        // `cancelled` is already in RESUMABLE_STATES, so the file needs no demotion
+        // AND the resume works — naming it costs nothing and is true.
+        message: c => `${c.tag} cancelled${c.at} — resume with ${c.resumeCmd}.`
+    },
     interrupted: {
         markResumable: true,
         // NOT a failure: the user stopped it. The parent run stays in_progress so

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

@@ -34,7 +34,53 @@ export interface VerifyOutcome {
      *  can record each as a durable debt if the user ACCEPTs anyway — the deletion
      *  then ships in the next commit and the final gate must re-check it. */
     crossTaskDeletions?: CrossTaskDeletion[];
+    /**
+     * WHICH KIND of FAIL this is, as data. Only meaningful when ok === false.
+     *
+     * `unobserved` was already carried as a typed field and read as one. Its
+     * siblings were not: the repo-health class travelled only as the `repo health:`
+     * PREFIX of `reason`, and three independent production sites recovered it by
+     * re-typing that literal with two different matchers — the graduated lint-fix
+     * gate, the frozen-blocked contradiction test, and the ONE auto-closing debt
+     * class. A reword of the mint disabled all three, with no compile error and a
+     * green suite. This is the `observedFailures` finding one altitude down: the
+     * outcome CLASS never travelled with the failure TEXT, so every classifier
+     * downstream had to guess.
+     */
+    failClass?: VerifyFailClass;
 }
+/**
+ * The kinds of verify FAIL. A new member is a compile error until it declares a
+ * display prefix below.
+ *
+ * `static-checks` is the RUN-level twin of `repo-health`: `final-gate.ts` mints
+ * `static checks: …` for the same concept at the other altitude, which is why
+ * `isStaticClassDebt` was structurally blind to every run-level static failure
+ * that reached the ledger.
+ */
+export type VerifyFailClass = 'repo-health' | 'static-checks' | 'unobserved' | 'model-verdict' | 'harness-fault';
+/**
+ * The prefix each class MINTS, stated once.
+ *
+ * These strings are byte-frozen: the debt ledger stores `reason` verbatim, so a
+ * reword would orphan every debt already on disk. The registry exists so minting
+ * and matching cannot drift apart, not to make the wording editable.
+ */
+export declare const VERIFY_FAIL_PREFIX: Record<VerifyFailClass, string>;
+/**
+ * The class of a FAIL — from the typed field when it is there, else from the
+ * prefix the registry above owns.
+ *
+ * The prefix test survives in exactly ONE place instead of three. It has to
+ * survive somewhere: `GateDeps.verify` is a seam, a debt read back off disk is a
+ * bare string with no outcome attached, and the run-level gate mints its own
+ * `static checks:` line through a different path entirely.
+ */
+export declare function verifyFailClass(o: Pick<VerifyOutcome, 'failClass' | 'reason'>): VerifyFailClass | undefined;
+/** The class a recorded reason STRING belongs to, by its minted prefix. */
+export declare function failClassOfReason(reason: string): VerifyFailClass | undefined;
+/** Does this class name a deterministic whole-repo static check, at either altitude? */
+export declare function isStaticClass(cls: VerifyFailClass | undefined): boolean;
 /**
  * Slice the delivered spec (GOAL / CONSTRAINTS / ACCEPTANCE / VERIFY) out of a
  * task file body. The composed spec lives under a `## spec` header and runs until

package/dist/task/verify-work.js

@@ -87,6 +87,47 @@ import { crossTaskDeletionVerifyFindings } from './task-provenance.js';
  *    enforce pass had to drop `write` to stop.
  */
 const VERIFY_TOOLS = 'read,bash';
+/**
+ * The prefix each class MINTS, stated once.
+ *
+ * These strings are byte-frozen: the debt ledger stores `reason` verbatim, so a
+ * reword would orphan every debt already on disk. The registry exists so minting
+ * and matching cannot drift apart, not to make the wording editable.
+ */
+export const VERIFY_FAIL_PREFIX = {
+    'repo-health': 'repo health:',
+    'static-checks': 'static checks:',
+    unobserved: 'work unobserved:',
+    'model-verdict': 'work did not verify:',
+    'harness-fault': 'verification pass could not run:'
+};
+/**
+ * The class of a FAIL — from the typed field when it is there, else from the
+ * prefix the registry above owns.
+ *
+ * The prefix test survives in exactly ONE place instead of three. It has to
+ * survive somewhere: `GateDeps.verify` is a seam, a debt read back off disk is a
+ * bare string with no outcome attached, and the run-level gate mints its own
+ * `static checks:` line through a different path entirely.
+ */
+export function verifyFailClass(o) {
+    if (o.failClass)
+        return o.failClass;
+    return failClassOfReason(o.reason ?? '');
+}
+/** The class a recorded reason STRING belongs to, by its minted prefix. */
+export function failClassOfReason(reason) {
+    const head = reason.trimStart().toLowerCase();
+    for (const [cls, prefix] of Object.entries(VERIFY_FAIL_PREFIX)) {
+        if (head.startsWith(prefix.toLowerCase()))
+            return cls;
+    }
+    return undefined;
+}
+/** Does this class name a deterministic whole-repo static check, at either altitude? */
+export function isStaticClass(cls) {
+    return cls === 'repo-health' || cls === 'static-checks';
+}
 /**
  * Slice the delivered spec (GOAL / CONSTRAINTS / ACCEPTANCE / VERIFY) out of a
  * task file body. The composed spec lives under a `## spec` header and runs until
@@ -762,8 +803,9 @@ export async function runWorkVerification(deps) {
     if (deps.repoHealth) {
         stage('repo health');
         const h = await deps.repoHealth();
-        if (!h.ok)
-            return { ok: false, reason: `repo health: ${h.reason}` };
+        if (!h.ok) {
+            return { ok: false, failClass: 'repo-health', reason: `repo health: ${h.reason}` };
+        }
     }
     if (!deps.spec || deps.spec.trim().length === 0) {
         return { ok: true, reason: 'no spec to verify' };
@@ -818,7 +860,11 @@ export async function runWorkVerification(deps) {
             if (err instanceof Error && err.message === USER_CANCELLED)
                 throw err;
             const msg = err instanceof Error ? err.message : String(err);
-            return { ok: false, reason: `verification pass could not run: ${msg}` };
+            return {
+                ok: false,
+                failClass: 'harness-fault',
+                reason: `${VERIFY_FAIL_PREFIX['harness-fault']} ${msg}`
+            };
         }
         // Capture the environment facts the child shared — regardless of verdict
         // (a FAIL run's discoveries are just as reusable).
@@ -860,12 +906,14 @@ export async function runWorkVerification(deps) {
             return {
                 ok: false,
                 unobserved: true,
+                failClass: 'unobserved',
                 reason: `work unobserved: ${verdict.detail}`,
                 ...deletions
             };
         }
         return {
             ok: false,
+            failClass: 'model-verdict',
             reason: `work did not verify: ${verdict.detail}${verdict.detail === 'no verdict emitted' ? ' (after verify retry)' : ''}`,
             ...deletions
         };

package/dist/workers/brave-search.d.ts

@@ -1,3 +1,4 @@
+import { type FetchLike } from './http-request.js';
 import type { SearchResult } from './search-types.js';
 export type BraveResult = SearchResult;
 export interface BraveSearchOpts {
@@ -5,6 +6,12 @@ export interface BraveSearchOpts {
     count?: number;
     timeoutMs?: number;
     signal?: AbortSignal;
+    /**
+     * Injectable fetch. Brave was the ONE provider without this: exa and ddg both
+     * took a `fetchImpl`, so brave's status ladder — the widest of the three — was
+     * the only one no test could drive at the request level.
+     */
+    fetchImpl?: FetchLike;
 }
 export declare class BraveSearchError extends Error {
     readonly kind: 'auth' | 'rate-limit' | 'http' | 'network' | 'aborted';

package/dist/workers/brave-search.js

@@ -1,3 +1,4 @@
+import { httpRequest, HttpRequestError } from './http-request.js';
 const BRAVE_ENDPOINT = 'https://api.search.brave.com/res/v1/web/search';
 const DEFAULT_COUNT = 10;
 const MAX_COUNT = 20;
@@ -14,64 +15,44 @@ export class BraveSearchError extends Error {
 }
 export async function braveSearch(query, opts) {
     const count = Math.max(1, Math.min(MAX_COUNT, opts.count ?? DEFAULT_COUNT));
-    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const url = `${BRAVE_ENDPOINT}?q=${encodeURIComponent(query)}&count=${count}`;
-    const internalController = new AbortController();
-    let userAborted = false;
-    const timeoutHandle = setTimeout(() => internalController.abort(), timeoutMs);
-    const onUserAbort = () => {
-        userAborted = true;
-        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/json',
-                    'x-subscription-token': opts.apiKey
-                },
-                signal: internalController.signal
-            });
-        }
-        catch (err) {
-            if (userAborted) {
-                throw new BraveSearchError('Search aborted.', 'aborted');
+        return await httpRequest(url, {
+            timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+            ...(opts.signal === undefined ? {} : { signal: opts.signal }),
+            ...(opts.fetchImpl === undefined ? {} : { fetchImpl: opts.fetchImpl }),
+            method: 'GET',
+            headers: {
+                accept: 'application/json',
+                'x-subscription-token': opts.apiKey
             }
-            throw new BraveSearchError(`Brave Search request failed: ${describeError(err)}`, 'network');
-        }
-        if (response.status === 401 || response.status === 403) {
-            throw new BraveSearchError(`Brave Search rejected the key (HTTP ${response.status}). Check BRAVE_SEARCH_API_KEY.`, 'auth', response.status);
-        }
-        if (response.status === 429) {
-            throw new BraveSearchError('Brave Search rate limit hit (HTTP 429). Try again in a moment.', 'rate-limit', 429);
-        }
-        if (!response.ok) {
-            throw new BraveSearchError(`Brave Search HTTP ${response.status} ${response.statusText}`, 'http', response.status);
-        }
-        const body = (await response.json());
-        const rawResults = body.web?.results ?? [];
-        return rawResults
-            .filter((r) => typeof r.title === 'string'
-            && typeof r.url === 'string'
-            && typeof r.description === 'string')
-            .map(r => ({ title: r.title, url: r.url, description: r.description }));
+        }, async (response) => {
+            // Brave's own status policy: a rejected key and a rate limit are
+            // different problems for the user, and neither is a plain HTTP fault.
+            if (response.status === 401 || response.status === 403) {
+                throw new BraveSearchError(`Brave Search rejected the key (HTTP ${response.status}). Check BRAVE_SEARCH_API_KEY.`, 'auth', response.status);
+            }
+            if (response.status === 429) {
+                throw new BraveSearchError('Brave Search rate limit hit (HTTP 429). Try again in a moment.', 'rate-limit', 429);
+            }
+            if (!response.ok) {
+                throw new BraveSearchError(`Brave Search HTTP ${response.status} ${response.statusText}`, 'http', response.status);
+            }
+            const body = (await response.json());
+            const rawResults = body.web?.results ?? [];
+            return rawResults
+                .filter((r) => typeof r.title === 'string'
+                && typeof r.url === 'string'
+                && typeof r.description === 'string')
+                .map(r => ({ title: r.title, url: r.url, description: r.description }));
+        });
     }
-    finally {
-        clearTimeout(timeoutHandle);
-        if (opts.signal)
-            opts.signal.removeEventListener('abort', onUserAbort);
+    catch (err) {
+        if (err instanceof HttpRequestError) {
+            throw err.kind === 'aborted' ?
+                new BraveSearchError('Search aborted.', 'aborted')
+                : new BraveSearchError(`Brave Search request failed: ${err.detail}`, 'network');
+        }
+        throw err;
     }
 }
-function describeError(err) {
-    if (err instanceof Error)
-        return err.message;
-    return String(err);
-}

package/dist/workers/ddg-search.d.ts

@@ -7,7 +7,7 @@
  * get the destination URL. Ad rows redirect through duckduckgo.com itself and
  * are dropped.
  */
-import type { FetchLike } from './exa-search.js';
+import { type FetchLike } from './http-request.js';
 import type { SearchResult } from './search-types.js';
 export interface DdgSearchOpts {
     count?: number;

package/dist/workers/ddg-search.js

@@ -8,6 +8,7 @@
  * are dropped.
  */
 import { parseHTML } from 'linkedom';
+import { httpRequest, HttpRequestError } from './http-request.js';
 const DDG_ENDPOINT = 'https://html.duckduckgo.com/html/';
 const DEFAULT_COUNT = 10;
 const MAX_COUNT = 20;
@@ -26,51 +27,35 @@ export class DdgSearchError extends Error {
 }
 export async function ddgSearch(query, opts = {}) {
     const count = Math.max(1, Math.min(MAX_COUNT, opts.count ?? DEFAULT_COUNT));
-    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    const fetchImpl = opts.fetchImpl ?? fetch;
     const url = `${DDG_ENDPOINT}?q=${encodeURIComponent(query)}`;
-    const internalController = new AbortController();
-    let userAborted = false;
-    const timeoutHandle = setTimeout(() => internalController.abort(), timeoutMs);
-    const onUserAbort = () => {
-        userAborted = true;
-        internalController.abort();
-    };
-    if (opts.signal) {
-        if (opts.signal.aborted)
-            onUserAbort();
-        else
-            opts.signal.addEventListener('abort', onUserAbort, { once: true });
-    }
     try {
-        let response;
-        try {
-            response = await fetchImpl(url, {
-                method: 'GET',
-                headers: {
-                    'user-agent': USER_AGENT,
-                    accept: 'text/html'
-                },
-                signal: internalController.signal
-            });
-        }
-        catch (err) {
-            if (userAborted)
-                throw new DdgSearchError('Search aborted.', 'aborted');
-            throw new DdgSearchError(`DuckDuckGo request failed: ${describeError(err)}`, 'network');
-        }
-        if (response.status === 429 || response.status === 403) {
-            throw new DdgSearchError(`DuckDuckGo is rate-limiting this client (HTTP ${response.status}). Try again in a moment.`, 'rate-limit', response.status);
-        }
-        if (!response.ok) {
-            throw new DdgSearchError(`DuckDuckGo HTTP ${response.status} ${response.statusText}`, 'http', response.status);
-        }
-        return parseDdgHtml(await response.text()).slice(0, count);
+        return await httpRequest(url, {
+            timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+            ...(opts.signal === undefined ? {} : { signal: opts.signal }),
+            ...(opts.fetchImpl === undefined ? {} : { fetchImpl: opts.fetchImpl }),
+            method: 'GET',
+            headers: {
+                'user-agent': USER_AGENT,
+                accept: 'text/html'
+            }
+        }, async (response) => {
+            // DDG's own status policy: 429/403 is throttling, not a plain HTTP fault.
+            if (response.status === 429 || response.status === 403) {
+                throw new DdgSearchError(`DuckDuckGo is rate-limiting this client (HTTP ${response.status}). Try again in a moment.`, 'rate-limit', response.status);
+            }
+            if (!response.ok) {
+                throw new DdgSearchError(`DuckDuckGo HTTP ${response.status} ${response.statusText}`, 'http', response.status);
+            }
+            return parseDdgHtml(await response.text()).slice(0, count);
+        });
     }
-    finally {
-        clearTimeout(timeoutHandle);
-        if (opts.signal)
-            opts.signal.removeEventListener('abort', onUserAbort);
+    catch (err) {
+        if (err instanceof HttpRequestError) {
+            throw err.kind === 'aborted' ?
+                new DdgSearchError('Search aborted.', 'aborted')
+                : new DdgSearchError(`DuckDuckGo request failed: ${err.detail}`, 'network');
+        }
+        throw err;
     }
 }
 export function parseDdgHtml(html) {
@@ -123,8 +108,3 @@ function unwrapDdgRedirect(href) {
 function collapse(text) {
     return text.replace(/\s+/g, ' ').trim();
 }
-function describeError(err) {
-    if (err instanceof Error)
-        return err.message;
-    return String(err);
-}

package/dist/workers/docs-core.d.ts

@@ -167,11 +167,81 @@ export declare function findDeclaredRange(parentPkg: string, cwd: string): strin
 export declare function buildVersionBanner(pin: AutoInstallPin | undefined, resolved: string, version: string, cwd: string): string;
 export declare function getDocsModulesDir(): string;
 export declare function ensureDocsModulesDir(dir: string): void;
-export declare function runAutoInstall(spawn: SpawnFn, packageName: string, signal: AbortSignal | undefined, versionRange?: string): Promise<{
+/**
+ * Options rather than a positional tail: `signal` and `versionRange` sat adjacent,
+ * and reaching the range meant writing `undefined` into the signal slot — which is
+ * exactly how the primary acquisition path lost its abort signal while the hop path
+ * kept it.
+ */
+export interface AutoInstallOptions {
+    signal?: AbortSignal | undefined;
+    versionRange?: string | undefined;
+}
+export declare function runAutoInstall(spawn: SpawnFn, packageName: string, opts?: AutoInstallOptions): Promise<{
     success: boolean;
     installDir: string;
     stderr: string;
 }>;
+/** What acquiring one package produced, or the stage at which it failed. */
+export type AcquireOutcome = {
+    ok: true;
+    pkg: ResolvedPackage;
+    autoInstalled: boolean;
+    pin?: AutoInstallPin;
+} | {
+    ok: false;
+    stage: 'resolve';
+    err: unknown;
+} | {
+    ok: false;
+    stage: 'install';
+    stderr: string;
+    pin: AutoInstallPin;
+    asked: string;
+} | {
+    ok: false;
+    stage: 'reresolve';
+    err: unknown;
+    pin: AutoInstallPin;
+};
+export interface AcquireInput {
+    /** The specifier to resolve. May be a subpath (`pkg/sub`) — the INSTALL always
+     *  targets its parent package. */
+    name: string;
+    cwd: string;
+    spawn: SpawnFn;
+    resolvePackage: typeof defaultResolvePackage;
+    signal: AbortSignal | undefined;
+}
+/**
+ * Get a package onto disk and resolved: resolve from `cwd`, and on
+ * `not_installed` install it — at the range the PROJECT declares when it declares
+ * one — then resolve again from the install dir.
+ *
+ * One statement of the ladder, for both callers. It was written twice: inline in
+ * `docsRaw` for the requested package, and in `tryResolveOrInstall` for each hop
+ * of the type-redirect chain — and the copies had drifted on all three things
+ * that matter.
+ *
+ *  - The abort signal. The hop copy passed it; the primary copy passed a bare
+ *    `undefined` placeholder to reach the fourth positional, while
+ *    `DocsRawInput.signal` was honoured on either side of that call. So a user
+ *    cancel during the MAIN `npm install` of a model-chosen package was not
+ *    delivered. `runAutoInstall` takes an options object now, so a hole like that
+ *    cannot be typed.
+ *  - The version pin. `findDeclaredRange` had exactly one call site — the primary
+ *    copy. The hop copy installed `latest` unconditionally, on the hop most likely
+ *    to be the declared one: `declarationChain` exists precisely because "a
+ *    project that uses Bun declares `@types/bun`, not `bun`".
+ *  - The provenance. `autoInstalled`/`autoInstallPin` were locals of `docsRaw`, so
+ *    a package acquired only through a hop reported neither and got no version
+ *    banner.
+ *
+ * CONTEXT.md records the redirect WALK as unified (`resolveTypeSource`) and its
+ * `resolveHop` seam as "the one thing its two call sites disagree about". They
+ * should disagree only about WHETHER to install, never about HOW.
+ */
+export declare function acquirePackage(input: AcquireInput): Promise<AcquireOutcome>;
 export declare function docsRaw(input: DocsRawInput): Promise<DocsRawResult>;
 export declare function docsFocused(input: DocsFocusedInput): Promise<DocsFocusedResult>;
 export declare function buildPrompt(pkg: ResolvedPackage, query: string, content: string): string;