@autorag/librarian 2.9.0 → 2.10.1

package/dist/agent/agent.d.ts

@@ -1,5 +1,5 @@
 import type { Agent, AgentTool } from "@earendil-works/pi-agent-core";
-import type { Api, Model } from "@earendil-works/pi-ai";
+import type { Api, ImageContent, Model } from "@earendil-works/pi-ai";
 import type { DatasourceIndexResult, DatasourceSkill } from "../datasource/types.js";
 import { type DupeyCliOptions } from "../dupey/index.js";
 import { type Embedder } from "../embedding-runtime/gateway-embedder.js";
@@ -17,10 +17,9 @@ import { type DefaultParserRegistryOptions } from "../parser/index.js";
 import { RetrievalEngine } from "../retrieval/engine.js";
 import { RetrievalMethodRegistry } from "../retrieval/registry.js";
 import type { DatasourceCatalogEntry } from "../retrieval/selection.js";
-import type { CuratedResult, RetrievalDiagnostic, RetrievalOptions, RetrievalResult } from "../retrieval/types.js";
+import type { RetrievalDiagnostic, RetrievalOptions, RetrievalResult } from "../retrieval/types.js";
 import { type DatasourceAgentSkill } from "./datasource-skill.js";
 import { type ScanDuplicateDocumentsDetails } from "./dupey-tool.js";
-import { type AutoRAGFastAnswerDetails } from "./fast-answer-tool.js";
 import { type JevToolOptions } from "./jev-extension.js";
 import { type JikjiFindProviderResult } from "./jikji-find-tool.js";
 import { type AutoRAGPiInteractiveRuntime, type AutoRAGPiSession } from "./pi-session.js";
@@ -255,10 +254,10 @@ export interface AutoRAGAgentOptions {
     memoryEmbedder?: Embedder | false;
     /**
      * Agent self-configuration. When set (and Jev is on), Jev gains a `config`
-     * branch for questions about AutoRAG's own settings: the turn skips
-     * `emit_fast_answer`, receives the full `autorag-setup` skill, edits
-     * `configPath` with the pi tools, and reports through
-     * `emit_autorag_results`. Always omitted for remote P2P sessions.
+     * branch for questions about AutoRAG's own settings: the turn skips the
+     * fast answer, receives the full `autorag-setup` skill, edits
+     * `configPath` with the pi tools, and reports what it changed as its final
+     * message. Always omitted for remote P2P sessions.
      */
     selfConfig?: SelfConfigOptions;
     /**
@@ -356,13 +355,20 @@ export declare class AutoRAGAgent {
     private readonly runLogger;
     private lastQuery;
     private lastSessionId;
-    private readonly sessions;
     private activeRun;
-    private resultCapture;
-    private interactiveFastAnswerCallback;
+    /**
+     * Steering state of the running search. A TUI query runs detached from pi's
+     * input loop (pi reads the next input only after its input handler returns),
+     * so input typed meanwhile steers this run (Enter) or waits behind it
+     * (Alt+Enter), the way pi steers its own turns. {@link steer} feeds the same
+     * state for `searchDocuments()` / `searchDocumentsStream()` callers.
+     */
+    private readonly interactive;
+    /** Aborted by {@link abort} and by the run's timeout: gates publishing and the run's own requests. */
+    private activeRunAbort;
     private modelNativeSearchAuth;
     private retrievalTrace;
-    /** Evidence every retrieval tool returned this run; emit tools resolve model-cited ids against it. */
+    /** Evidence every retrieval tool returned this run; the answer's inline `[eN]` citations resolve against it. */
     private readonly evidenceLedger;
     private preliminaryCallback;
     /** Per-phase thinking levels of the two-phase search. */
@@ -474,8 +480,69 @@ export declare class AutoRAGAgent {
     private currentSystemPromptConfig;
     subscribe(listener: Parameters<Agent["subscribe"]>[0]): () => void;
     createPiInteractiveRuntime(): Promise<AutoRAGPiInteractiveRuntime>;
+    /**
+     * The session's custom tools, with retrieval and web reads interruptible by a
+     * steer: stopping them loses no side effect. bash and the file tools are pi
+     * built-ins and never pass through here.
+     */
+    private steerableTools;
+    /**
+     * Lets a steer cut a retrieval tool short, like an interruptible wait in pi:
+     * the tool's signal also aborts on the steer, and the call resolves at once
+     * with a skipped result telling the model to retry if the search still
+     * matters, so the steer reaches the model before the next request.
+     */
+    private interruptibleBySteer;
+    /** Resolve the model's inline `[eN]` citations against this run's evidence and derive the structured results. */
+    private deriveAnswer;
+    /**
+     * Routes one TUI input the way pi routes typed input for its own turns. With
+     * no search running it starts one. During a search, Enter steers it (the
+     * user is correcting a search that is going wrong) and Alt+Enter queues a
+     * follow-up question that runs once this search answers.
+     */
+    private routeInteractiveInput;
+    /**
+     * Esc and Alt+Enter during a search. pi handles both itself while a turn
+     * streams (abort, queue follow-up); between phases it ignores Esc and submits
+     * Alt+Enter like Enter, so AutoRAG acts on them there.
+     */
+    private handleInteractiveKey;
+    /** Runs one TUI query detached from pi's input loop, then any follow-ups queued behind it. */
+    private startInteractiveQuery;
+    /**
+     * Drives one TUI query through the two-phase search. The model's own
+     * assistant messages (progress notes before a tool call, the fast answer,
+     * the final answer) are already recorded and rendered by the bound pi
+     * session, so nothing is re-sent here: a second copy would show every answer
+     * twice and put it in the model's context twice.
+     */
     private runInteractivePiQuery;
+    /** Resolves once the TUI search and every follow-up queued behind it finished. */
+    waitForIdle(): Promise<void>;
+    /**
+     * Steers the running `searchDocuments()` / `searchDocumentsStream()` search,
+     * the way Enter steers a TUI search: `text` is a correction of the search in
+     * progress, not a new question. It reaches the search's next model request
+     * (also between phases, where no turn streams), cuts in-flight retrieval and
+     * the baseline prefetch short so it lands promptly, and forces the
+     * verification phase, whose prompt restates it. A steer that lands after
+     * verification's last request gets one more verification turn in the same
+     * search. The final answer stays the answer to the original question.
+     *
+     * Returns false, and does nothing, when no search is running, the search was
+     * stopped, or it is past its last model request; the caller should then ask
+     * the text as a new question.
+     */
+    steer(text: string, images?: readonly ImageContent[]): boolean;
+    /**
+     * Stops the running search as a whole: the streaming model turn, the
+     * baseline prefetch, in-flight retrieval, and every later phase. The search
+     * then resolves without a verified answer.
+     */
     abort(): void;
+    /** The next model request took the queued steers into the transcript; later retrieval runs uninterrupted until the next steer. */
+    private steersReachedModel;
     /**
      * Periodically re-runs the incremental {@link refresh} so parsed mirrors and
      * indexes stay current. Re-parsing is incremental (mtime/size) via the
@@ -486,13 +553,14 @@ export declare class AutoRAGAgent {
     }): void;
     stopAutoRefresh(): void;
     private runAutoRefreshTick;
-    getResultRegistry(sessionId?: string): ReadonlyMap<number, CuratedResult>;
     searchDocuments(query: string, options?: RetrievalOptions): Promise<SearchDocumentsResponse>;
     /**
      * Stream bounded progress updates while retaining the stable
-     * {@link searchDocuments} promise API. Progress is sourced from model text
-     * deltas, so callers can render it in a TUI, CLI, or parent agent and can
-     * stop by calling {@link abort}.
+     * {@link searchDocuments} promise API. Progress is the text an assistant
+     * message wrote before calling a tool (`stopReason: "toolUse"`); a message
+     * that ends its turn is an answer, delivered as `preliminary` or
+     * `complete`, never as progress. Callers can render it in a TUI, CLI, or
+     * parent agent and can stop by calling {@link abort}.
      */
     searchDocumentsStream(query: string, options?: RetrievalOptions): AsyncGenerator<SearchDocumentsStreamEvent, void, void>;
     /**
@@ -529,7 +597,7 @@ export declare class AutoRAGAgent {
     /** Path-opaque component diagnostics for the search response. */
     private collectComponentDiagnostics;
     /**
-     * Jev check run after emit_fast_answer: does the answer need correction,
+     * Jev check run after the fast answer: does the answer need correction,
      * clarification, or further research? "No" ends the run with the fast
      * answer as the final answer. Without Jev, or when the check fails, the run
      * always continues into verification.
@@ -574,14 +642,14 @@ export declare class AutoRAGAgent {
     private rerankPrefetchPool;
     /**
      * Fast-phase prompt for two-phase searches. The baseline retrieval context
-     * is already gathered, so the model answers immediately with thinking off
-     * via emit_fast_answer, without any further tool calls.
+     * is already gathered, so the model answers immediately with thinking off,
+     * as plain text, without any further tool calls.
      */
     buildFastAnswerPrompt(query: string, options: RetrievalOptions, baseline: string): string;
     /**
      * Prompt for a question Jev routed to a direct answer: general knowledge or
      * small talk. No retrieval ran and no verification phase follows, so the
-     * answer emitted here is final.
+     * reply is the final answer.
      */
     buildDirectAnswerPrompt(query: string): string;
     /** Discovery-tool hint naming only the registered discovery tools; empty when none. */
@@ -595,10 +663,10 @@ export declare class AutoRAGAgent {
     /**
      * Verification-phase prompt for two-phase searches. The fast answer, when a
      * consumer already received it, is embedded verbatim so the model can diff
-     * against it; the model then verifies with thinking on and finalizes with
-     * emit_autorag_results exactly once, returning only the delta.
+     * against it; the model then verifies with thinking on and ends with the
+     * final answer as a plain reply, returning only the delta.
      */
-    buildRefinementPrompt(query: string, options: RetrievalOptions, fastAnswer: AutoRAGFastAnswerDetails | undefined, fastAnswerDelivered: boolean): string;
+    buildRefinementPrompt(query: string, options: RetrievalOptions, fastAnswer: string | undefined, fastAnswerDelivered: boolean, steers?: readonly string[]): string;
     buildSearchPrompt(query: string, options: RetrievalOptions, initialRetrievalContext?: string): string;
     refresh(force?: boolean, opts?: AutoRAGRefreshOptions): Promise<AutoRAGRefreshResult>;
     /**
@@ -673,6 +741,7 @@ export declare class AutoRAGAgent {
     findJikji(query: string, opts?: {
         readonly topK?: number;
         readonly first?: boolean;
+        readonly signal?: AbortSignal;
     }): Promise<JikjiFindProviderResult>;
     /**
      * Merge per-root answer packs into one. Concatenates answer_paths/candidates
@@ -717,6 +786,7 @@ export declare class AutoRAGAgent {
     searchAllDocuments(query: string, options?: {
         readonly topK?: number;
         readonly scope?: string;
+        readonly signal?: AbortSignal;
     }): Promise<{
         results: RetrievalResult[];
         diagnostics: RetrievalDiagnostic[];
@@ -734,6 +804,7 @@ export declare class AutoRAGAgent {
     searchSingleDatasourceDocuments(datasourceId: string, query: string, options?: {
         readonly topK?: number;
         readonly scope?: string;
+        readonly signal?: AbortSignal;
     }): Promise<{
         results: RetrievalResult[];
         diagnostics: RetrievalDiagnostic[];

package/dist/agent/answer-citations.d.ts

@@ -0,0 +1,22 @@
+import { type EvidenceLedger } from "./evidence-ledger.js";
+import type { AutoRAGResultsDetails } from "./results.js";
+import type { SearchDocumentDiagnostic } from "./search-documents.js";
+export interface DerivedAnswer {
+    readonly details: AutoRAGResultsDetails;
+    readonly diagnostics: readonly SearchDocumentDiagnostic[];
+}
+/**
+ * Turn the model's plain answer into the structured results the rest of the
+ * harness consumes. The model cites with the evidence ids the retrieval tools
+ * printed (`[e3]`, `[e3, e7]`) or `[file:<abs path>]` for a file it opened
+ * itself. Each id is resolved against the run's evidence ledger, so a source,
+ * method, and chunk always come from recorded evidence, never from model text.
+ *
+ * Results are one per cited source, numbered by first appearance, and every
+ * marker in the returned answer is rewritten to its result number (`[1]`).
+ * A marker that matches no evidence, and any numeric marker the model wrote on
+ * its own, is dropped and reported: it can never point at the wrong result.
+ */
+export declare function deriveResultsFromAnswer(text: string, ledger: EvidenceLedger, options: {
+    readonly allowLocalFiles: boolean;
+}): DerivedAnswer;

package/dist/agent/answer-guidelines.d.ts

@@ -1,19 +1,19 @@
 /**
  * The single file-path exception to the answer "no file paths" rule
- * (issue #1790). Every prompt and tool description that shapes `answer` uses
- * this exact wording so a caller that can render images receives a markdown
- * image embed whose path is a real result source, while the no-path rule
- * otherwise still stands.
+ * (issue #1790). Every prompt that shapes the answer uses this exact wording so
+ * a caller that can render images receives a markdown image embed whose path is
+ * a real evidence source, while the no-path rule otherwise still stands.
  */
-export declare const ANSWER_IMAGE_EMBED_RULE = "**Images**: when a retrieved result is itself an image file (png, jpg, jpeg, gif, webp, svg, bmp, avif, heic, tiff) and showing it answers the question, embed it in `answer` as a markdown image on its own line: `![short description](<absolute source path>)`, followed by its citation, e.g. `![Q3 revenue chart](</data/reports/q3 chart.png>) [2]`. Use only the real source path of a result in `results`/`mapping`. Never invent a path, use relative paths, or embed remote URLs. Apart from these image embeds, the no-file-paths rule stands.";
+export declare const ANSWER_IMAGE_EMBED_RULE = "**Images**: when a retrieved result is itself an image file (png, jpg, jpeg, gif, webp, svg, bmp, avif, heic, tiff) and showing it answers the question, embed it in the answer as a markdown image on its own line: `![short description](<absolute source path>)`, followed by its citation, e.g. `![Q3 revenue chart](</data/reports/q3 chart.png>) [e2]`. Use only the real source path of retrieved evidence. Never invent a path, use relative paths, or embed remote URLs. Apart from these image embeds, the no-file-paths rule stands.";
 /**
  * Delta (verification) answers must not re-embed an image the first answer
  * already showed.
  */
 export declare const ANSWER_IMAGE_DELTA_RULE = "An image already embedded in the first answer must not be embedded again.";
 /**
- * One numbering space for citations (issue #1788): every `[n]` in `answer`
- * must be a `results[].number` emitted in the same call. Retrieval candidate
- * numbers and first-answer unit numbers are never citation numbers.
+ * Inline evidence citations. The model writes the id the retrieval tools print
+ * next to each result; the harness resolves it to the recorded source and
+ * renumbers the markers `[1]`, `[2]`, ... in order of first appearance, so the
+ * caller only ever sees numbered citations backed by recorded evidence.
  */
-export declare const ANSWER_CITATION_RULE = "**Citation numbers**: every bracketed citation [n] in `answer` must be the `number` of a result you emit in `results` of the same call. Numbers shown in retrieval candidates or in an earlier first answer are NOT citation numbers \u2014 renumber against your own `results`, and add a result for any evidence you cite.";
+export declare const ANSWER_CITATION_RULE = "**Citations**: cite supporting evidence inline with the evidence id shown next to each retrieved result, in square brackets (e.g. [e3], or [e3][e7] for two). Copy ids exactly; never invent one. For a local file you opened yourself with `bash`, cite `[file:<absolute path>]`. Cite the evidence that backs a sentence at the end of that sentence. Do not cite numbers, paths, or anything else.";

package/dist/agent/citations.d.ts

@@ -1,7 +1,39 @@
-/** Sorted, de-duplicated citation numbers in `answer` with no matching result. */
-export declare function unresolvedCitations(answer: string, results: readonly {
+/**
+ * Bracketed citations in an answer. Two grammars share one scanner:
+ *
+ * - **Final form** `[n]`: a number that must resolve to a `results[].number`
+ *   of the same response (issue #1788).
+ * - **Model form** `[e3]`, `[e3, e7]`, `[file:/abs/path]`: the evidence ids the
+ *   retrieval tools print next to each result, or a local file the model opened
+ *   itself. The harness resolves them against the run's evidence ledger and
+ *   rewrites them into the final form.
+ *
+ * A markdown image target `(<...>)` is skipped verbatim so a bracketed token
+ * inside a real file path is never mistaken for a citation; `[n](...)` is a
+ * markdown link, not a citation.
+ *
+ * `answer` is model- or caller-supplied, so this is a single linear scan rather
+ * than a regex: alternations like `\(<[^>]*>\)` / `[ \t]*\[` backtrack
+ * quadratically on inputs such as repeated `(<` or long whitespace runs.
+ */
+export type AnswerMarker = {
+    readonly kind: "number";
+    readonly start: number;
+    readonly end: number;
     readonly number: number;
-}[]): number[];
+} | {
+    readonly kind: "evidence";
+    readonly start: number;
+    readonly end: number;
+    readonly ids: readonly string[];
+} | {
+    readonly kind: "file";
+    readonly start: number;
+    readonly end: number;
+    readonly path: string;
+};
+/** Every citation marker in `answer`, in order. `isFile` decides which `[file:...]` paths are real. */
+export declare function answerMarkers(answer: string, isFile?: (path: string) => boolean): AnswerMarker[];
 /** Remove citation markers whose number has no matching result. */
 export declare function stripUnresolvedCitations(answer: string, results: readonly {
     readonly number: number;
@@ -10,34 +42,14 @@ export declare function stripUnresolvedCitations(answer: string, results: readon
     readonly unresolved: readonly number[];
 };
 export declare function formatCitationList(numbers: readonly number[]): string;
-/**
- * Throw a corrective error when two results share a number. A repeated number
- * collapses into one registry entry and one feedback id, so the other result's
- * evidence would be lost. Emit tools call this at tool time so the model sees
- * the error and re-emits.
- */
-export declare function assertUniqueResultNumbers(label: string, results: readonly {
-    readonly number: number;
-}[]): void;
 /**
  * Throw a corrective error unless `results` and `mapping` carry the same
  * numbers, exactly one entry each. Duplicates are rejected even when both
  * sides repeat them: a repeated number collapses into a single registry entry,
  * so the other entry's evidence would be lost.
- * Emit tools call this at tool time (issue #1807) so the model sees the error
- * and re-emits; checking only after the run ended failed the whole search and
- * discarded an already-delivered answer.
  */
 export declare function assertResultsMappingOneToOne(label: string, results: readonly {
     readonly number: number;
 }[], mapping: readonly {
     readonly number: number;
 }[]): void;
-/**
- * Throw a corrective error when `answer` cites numbers absent from `results`.
- * Emit tools surface the message to the model as a tool error so it re-emits
- * with one consistent numbering.
- */
-export declare function assertCitationsResolve(label: string, answer: string, results: readonly {
-    readonly number: number;
-}[]): void;

package/dist/agent/context-token-guard.d.ts

@@ -0,0 +1,23 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { Model } from "@earendil-works/pi-ai";
+type ContextTokenGuardModel = Model<any> | (() => Model<any> | undefined) | undefined;
+/**
+ * Compose an optional context transform with the aggregate token guard. The
+ * guard runs on the final transcript immediately before each provider request,
+ * so it sees the system prompt, tool declarations, user query, memory context,
+ * and every prior tool result.
+ */
+export declare function createContextTokenGuardedTransform(model: ContextTokenGuardModel, base?: (messages: AgentMessage[]) => Promise<AgentMessage[]>, fixedOverheadTokens?: () => number): (messages: AgentMessage[]) => Promise<AgentMessage[]>;
+/**
+ * Keep complete retrieval candidates while the assembled request fits the
+ * model budget. Removing a per-chunk cut is only safe because this drops whole
+ * lower-ranked candidates (with an explicit marker) instead of hiding text.
+ */
+export declare function guardAgentContextMessages(model: Model<any> | undefined, messages: AgentMessage[], useReportedUsage?: boolean, fixedOverheadTokens?: number): AgentMessage[];
+/**
+ * Estimate the current transcript with pi-coding-agent's conservative chars/4
+ * counter. `useReportedUsage` adds the last assistant turn's provider-reported
+ * usage for the settled prefix; pass false when the messages were just edited.
+ */
+export declare function estimateContextMessageTokens(messages: readonly AgentMessage[], useReportedUsage?: boolean): number;
+export {};

package/dist/agent/evidence-ledger.d.ts

@@ -1,5 +1,5 @@
 import type { RetrievalResult } from "../retrieval/types.js";
-import type { AutoRAGEvidenceRef } from "./emit-results-tool.js";
+import type { AutoRAGEvidenceRef } from "./results.js";
 export interface LedgerEvidenceInput {
     readonly method: string;
     readonly source: string;
@@ -13,16 +13,11 @@ export interface LedgerEvidenceInput {
     readonly evidenceType?: string;
     readonly evidenceLocation?: string;
 }
-export interface ResolveEvidenceOptions {
-    /** Tool name used to prefix corrective errors. */
-    readonly label: string;
-    /** Result number the refs belong to; named in corrective errors. */
-    readonly number: number;
-    /** Excerpt recorded for a local file the model opened itself (no search returned it). */
-    readonly fallbackContent: string;
+export interface LookupEvidenceOptions {
     /** False in remote sessions: only evidence a tool returned this run may be cited. */
     readonly allowLocalFiles: boolean;
 }
+export declare function isRegularFile(path: string): boolean;
 /**
  * Per-run record of every piece of evidence a retrieval tool returned.
  *
@@ -47,13 +42,13 @@ export declare class EvidenceLedger {
     /** Record one retrieval result as returned by `tool`; backend metadata is carried over. */
     registerResult(tool: string, result: RetrievalResult): string;
     /**
-     * Resolve model-supplied refs to recorded evidence. A ref is an evidence id
+     * Resolve one cited reference to recorded evidence. A ref is an evidence id
      * (`e3` or `[e3]`), the exact source a tool returned (a URL, a datasource
      * id, a path), or the absolute path of a real local file the model opened
-     * itself. Anything else throws a corrective error naming the result.
+     * itself. Returns an empty list when nothing matches: the caller drops the
+     * citation instead of failing the run.
      */
-    resolve(refs: readonly string[], options: ResolveEvidenceOptions): AutoRAGEvidenceRef[];
+    lookup(raw: string, options: LookupEvidenceOptions): AutoRAGEvidenceRef[];
     /** Forget every recorded entry. Ids are never reissued, so a previous run's id stays unresolvable. */
     clear(): void;
-    private unresolvedMessage;
 }

package/dist/agent/index.d.ts

@@ -2,11 +2,11 @@ export type { AutoRAGAgentOptions, AutoRefreshOptions, PeerQueryOptions } from "
 export { AutoRAGAgent } from "./agent.js";
 export { buildDatasourceSkillsPrompt, createLoadDatasourceSkillTool, type DatasourceSkillProvider, datasourceSkillLocation, formatDatasourceSkillInvocation, LOAD_DATASOURCE_SKILL_TOOL_NAME, type LoadDatasourceSkillDetails, toDatasourceAgentSkill, } from "./datasource-skill.js";
 export { createScanDuplicateDocumentsTool, SCAN_DUPLICATE_DOCUMENTS_TOOL_NAME, type ScanDuplicateDocumentsDetails, type ScanDuplicateDocumentsProvider, } from "./dupey-tool.js";
-export type { AutoRAGEmittedResult, AutoRAGMappingEntry, AutoRAGResultsDetails, } from "./emit-results-tool.js";
-export { createEmitResultsTool, EMIT_AUTORAG_RESULTS_TOOL_NAME, emitResultsSchema, reportSchema, } from "./emit-results-tool.js";
 export { createJevExtension, JEV_TOOL_NAME, type JevBackendName, type JevToolOptions, } from "./jev-extension.js";
 export { createJikjiFindTool, JIKJI_FIND_TOOL_NAME, type JikjiFindDetails, type JikjiFindPerRootPolicy, type JikjiFindProvider, type JikjiFindProviderResult, type MergedJikjiPolicy, } from "./jikji-find-tool.js";
 export { createQueryPeerAgentTool, QUERY_PEER_AGENT_TOOL_NAME, type QueryPeerAgentDetails, type QueryPeerAgentResult, type QueryPeerAgentToolOptions, } from "./query-peer-tool.js";
+export type { AutoRAGEmittedResult, AutoRAGMappingEntry, AutoRAGResultsDetails, } from "./results.js";
+export { reportSchema } from "./results.js";
 export { createSearchAllDocumentsTool, SEARCH_ALL_DOCUMENTS_TOOL_NAME, type SearchAllDocumentsDetails, type SearchAllDocumentsProvider, type SearchAllDocumentsResult, } from "./search-all-tool.js";
 export type { SearchDocumentDiagnostic, SearchDocumentDiagnosticCode, SearchDocumentDiagnosticSeverity, SearchDocumentEvidence, SearchDocumentResult, SearchDocumentsResponse, SearchDocumentsStreamEvent, SearchDocumentWarning, } from "./search-documents.js";
 export { createSearchMinSyncDocumentsTool, SEARCH_MINSYNC_DOCUMENTS_TOOL_NAME, type SearchMinSyncDocumentsDetails, } from "./search-minsync-tool.js";

package/dist/agent/jev-extension.d.ts

@@ -4,9 +4,10 @@ import { type JevBackend, type Judgment, type Question, type State } from "jev-u
 export declare const JEV_TOOL_NAME = "jev";
 /**
  * Jev backends the `jev-use` engine resolves from the environment, in
- * auto-select order: TypeSafe -> OpenRouter -> Vercel AI Gateway.
+ * auto-select order: TypeSafe -> OpenRouter -> Vercel AI Gateway. `autorag` is
+ * the hosted AutoRAG (Dazzi) plan, built here rather than resolved by jev-use.
  */
-export type JevBackendName = "typesafe" | "openrouter" | "vercel";
+export type JevBackendName = "typesafe" | "openrouter" | "vercel" | "autorag";
 /**
  * OpenRouter's live Jev model id. `jev-use` 0.8.0 ships `typesafe/jev-latest`,
  * which OpenRouter rejects with HTTP 400 ("Model ... does not exist"), so the
@@ -51,8 +52,8 @@ export type JevJudge = (state: State, questions: Question[], options?: {
 /**
  * Builds the Jev judge shared by the `jev` tool and the query router. The
  * `jev-use` client is created lazily on the first call, so no credential
- * resolves at construction time, and the OpenRouter model pin applies to
- * every caller.
+ * resolves at construction time, and the per-backend model default (the
+ * OpenRouter pin, or `jev-1.13` on the hosted plan) applies to every caller.
  */
 export declare function createJevJudge(options?: JevJudgeOptions): JevJudge;
 /**

package/dist/agent/jikji-find-tool.d.ts

@@ -44,6 +44,7 @@ export interface JikjiFindProvider {
     findJikji(query: string, opts?: {
         readonly topK?: number;
         readonly first?: boolean;
+        readonly signal?: AbortSignal;
     }): Promise<JikjiFindProviderResult>;
 }
 export interface JikjiFindDetails {

package/dist/agent/pi-session.d.ts

@@ -1,5 +1,5 @@
 import type { AgentMessage, AgentTool } from "@earendil-works/pi-agent-core";
-import type { Api, Model } from "@earendil-works/pi-ai";
+import type { Api, ImageContent, Model } from "@earendil-works/pi-ai";
 import { type AgentSession, type AgentSessionRuntime, type ExtensionAPI, type ExtensionFactory, SettingsManager, type ToolDefinition, type TuiMode } from "@earendil-works/pi-coding-agent";
 export declare const PI_BUILTIN_TOOL_NAMES: readonly ["read", "bash", "edit", "write", "grep", "find", "ls"];
 /**
@@ -34,10 +34,43 @@ export interface AutoRAGPiSessionOptions {
     readonly remoteSession?: boolean;
     readonly contextTransform?: (messages: AgentMessage[]) => Promise<AgentMessage[]>;
 }
+/**
+ * How AutoRAG takes one interactive input. `steer` while a pi turn streams
+ * returns the text pi should queue as steering (pi delivers it before the
+ * turn's next model request); every other outcome is fully handled by AutoRAG.
+ */
+export type AutoRAGInputDisposition = {
+    readonly kind: "handled";
+} | {
+    readonly kind: "steer";
+    readonly text: string;
+};
+export interface AutoRAGInteractiveInput {
+    readonly text: string;
+    readonly images: readonly ImageContent[] | undefined;
+    /** pi's delivery for input typed while a turn streams; undefined when no turn streams. */
+    readonly streamingBehavior: "steer" | "followUp" | undefined;
+}
+/** A TUI key AutoRAG acts on itself while a search runs, even when no pi turn streams. */
+export type AutoRAGInteractiveKey = "interrupt" | "followUp";
 export interface AutoRAGPiInteractiveRuntimeOptions extends Omit<AutoRAGPiSessionOptions, "model"> {
     readonly model?: Model<Api>;
     readonly inactiveToolNames?: readonly string[];
-    readonly onQuery: (query: string, pi: ExtensionAPI) => void | Promise<void>;
+    /**
+     * Routes one interactive input: a new query, a steer of the running search,
+     * or a follow-up queued behind it. Must not wait for a search to finish:
+     * pi's TUI reads the next input only after this returns.
+     */
+    readonly onInput: (input: AutoRAGInteractiveInput, pi: ExtensionAPI) => AutoRAGInputDisposition;
+    /** Whether a search is running: while it is, every interactive input belongs to it. */
+    readonly isSearchRunning?: () => boolean;
+    /**
+     * Called for pi's interrupt (Esc) and follow-up (Alt+Enter) keys while a
+     * search runs. pi acts on them only while a turn streams, but a search also
+     * spends time between turns (routing, prefetch, checks). Return true to
+     * consume the key; pi then never sees it.
+     */
+    readonly onKey?: (key: AutoRAGInteractiveKey) => boolean;
     /**
      * Optional best-effort provider for a startup update notice. Resolves to the
      * notice text, or `undefined` when there is nothing to announce. Called once

package/dist/agent/request-limits.d.ts

@@ -0,0 +1,20 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { ModelInputLimits } from "@earendil-works/pi-ai";
+/** Stands in for an image dropped from a model request by {@link fitRequestLimits}. */
+export declare const IMAGE_OMITTED_NOTE = "[Image omitted from this request to stay within the model provider's request limits. Read the file again if you still need to see it.]";
+/**
+ * Fits a model request into the provider's declared `inputLimits`.
+ *
+ * pi keeps every image a tool returned in the transcript and resends all of
+ * them on each later turn, but it never enforces `maxRequestBytes` or
+ * `images.maxPerRequest`. A search that reads a handful of photos therefore
+ * grows past a provider's body limit and the request fails outright (the hosted
+ * AutoRAG API answers HTTP 413). Images are what grows the body, so the oldest
+ * ones are replaced with {@link IMAGE_OMITTED_NOTE} until the request fits; the
+ * newest images, which the model is looking at, go last. Text is never touched.
+ *
+ * The size is the serialized transcript, a close lower bound of the provider
+ * body, so `maxRequestBytes` should keep headroom below the hard limit.
+ * Returns undefined when the request already fits; never mutates `messages`.
+ */
+export declare function fitRequestLimits(messages: readonly AgentMessage[], limits: ModelInputLimits | undefined): AgentMessage[] | undefined;

package/dist/agent/{emit-results-tool.d.ts → results.d.ts}

@@ -1,33 +1,11 @@
-import type { AgentTool } from "@earendil-works/pi-agent-core";
 import { Type } from "typebox";
-import type { EvidenceLedger } from "./evidence-ledger.js";
-export declare const EMIT_AUTORAG_RESULTS_TOOL_NAME = "emit_autorag_results";
-/**
- * Model-facing schema of `emit_autorag_results`. The model cites evidence by
- * the short ids retrieval tools print next to each result (`refs`); the
- * harness resolves them to the recorded source, method, and chunk, so the
- * model never retypes a path or a chunk.
- */
-export declare const emitResultsSchema: Type.TObject<{
-    answer: Type.TString;
-    results: Type.TArray<Type.TObject<{
-        number: Type.TInteger;
-        title: Type.TString;
-        summary: Type.TString;
-        evidence: Type.TArray<Type.TObject<{
-            excerpt: Type.TString;
-            lineNumber: Type.TOptional<Type.TInteger>;
-        }>>;
-        confidence: Type.TNumber;
-        refs: Type.TArray<Type.TString>;
-    }>>;
-    warnings: Type.TOptional<Type.TArray<Type.TString>>;
-}>;
 /**
  * Report schema with the explicit number -> source mapping. This is the
  * persisted/typed shape and the input contract of `autorag report` and the MCP
  * report tool, where an external agent curated the evidence and no harness
- * ledger exists.
+ * ledger exists. The librarian itself never produces this shape from the
+ * model: it writes a plain answer and the harness derives the results from the
+ * evidence ids the answer cites.
  */
 export declare const reportSchema: Type.TObject<{
     answer: Type.TString;
@@ -75,7 +53,8 @@ export interface AutoRAGEmittedResult {
     readonly title: string;
     readonly summary: string;
     readonly evidence: readonly AutoRAGEmittedEvidence[];
-    readonly confidence: number;
+    /** Absent for results the harness derived from cited evidence: nothing measured a confidence. */
+    readonly confidence?: number;
 }
 export interface AutoRAGEvidenceRef {
     readonly method: string;
@@ -107,17 +86,3 @@ export interface AutoRAGResultsDetails {
     readonly mapping: readonly AutoRAGMappingEntry[];
     readonly warnings: readonly string[];
 }
-export interface EmitResultsToolOptions {
-    /** Evidence the run's retrieval tools returned; `refs` resolve against it. */
-    readonly ledger: EvidenceLedger;
-    /** False in remote sessions: only evidence a tool returned this run may be cited. */
-    readonly allowLocalFiles: boolean;
-}
-/**
- * Builds the terminating structured-result tool. The model calls this exactly
- * once as its final action; the typed `details` plus `terminate: true` end the
- * Pi Agent run and hand the curated results back through `capture` — no
- * assistant-text parsing involved. The number -> source mapping is built here
- * from the harness-held evidence the model cited by id, never from model text.
- */
-export declare function createEmitResultsTool(capture: (details: AutoRAGResultsDetails) => void, options: EmitResultsToolOptions): AgentTool<typeof emitResultsSchema, AutoRAGResultsDetails>;

package/dist/agent/search-all-tool.d.ts

@@ -18,6 +18,7 @@ export interface SearchAllDocumentsProvider {
     searchAllDocuments(query: string, options?: {
         readonly topK?: number;
         readonly scope?: string;
+        readonly signal?: AbortSignal;
     }): Promise<SearchAllDocumentsResult>;
 }
 export interface SearchAllDocumentsDetails {