@autorag/librarian 2.6.2 → 2.7.0

package/NOTICE

@@ -18,6 +18,9 @@ License: MIT
 @earendil-works/pi-tui@0.86.1
 License: MIT
 
+@openrouter/sdk@1.4.21
+License: Apache-2.0
+
 chardet@2.2.0
 License: MIT
 
@@ -66,3 +69,12 @@ licenses/gemma-section-3.2-flow-down.txt
 licenses/gemma-terms-of-use.txt
 licenses/gemma-terms-of-use.html
 licenses/embedding-assets.json
+
+Bundled Windows binaries (vendor/everything, extracted only on Windows):
+Everything 1.4.1.1032 portable (voidtools, David Carpenter)
+License: MIT (closed source); includes PCRE (BSD-3-Clause)
+licenses/everything-MIT-and-PCRE-BSD.txt
+
+ES 1.1.0.38 command-line interface (voidtools)
+License: MIT
+licenses/es-MIT.txt

package/README.md

@@ -51,7 +51,7 @@ Three principles drive every design decision in AutoRAG Agent:
 
 1. **Never migrate your data to search it.** Traditional RAG systems force you to upload, ETL, and duplicate your files into a centralized vector database. AutoRAG Agent federates your data **in place**, querying CLI-native stores (`lazykatok`, `discrawl`, `slacrawl`, `mailcrawl`, `rclone`, `qmd`) where your data already lives. Results retain opaque, source-native identities (`/kakao/...`, `/slack/...`) that preserve local access control and privacy. *(See our [Competitive Landscape Study](docs/competitive-landscape-2026-09.md) on why in-place federation is the durable differentiator).*
 
-2. **Just works — no RAG degree required.** No pipeline tuning, no vector-DB maintenance, and no remote embedding API keys. AutoRAG Agent automatically manages [MinSync](docs/minsync-setup.md) for incremental Change Data Capture (CDC) chunking and provides a local [embedding gateway](docs/embedding-runtime.md) out of the box with zero external telemetry.
+2. **Just works — no RAG degree required.** No pipeline tuning, no vector-DB maintenance, and no remote embedding keys required. AutoRAG Agent automatically manages [MinSync](docs/minsync-setup.md) for incremental Change Data Capture (CDC) chunking and provides a local [embedding gateway](docs/embedding-runtime.md) out of the box with zero external telemetry. A [remote rerank model](docs/rerank.md) (OpenRouter, `voyageai/rerank-3-lite` by default) is an opt-in extra.
 
 3. **Fast by design.** Rather than coordinating slow multi-agent hierarchies, a single configured model owns the entire retrieval, direct-read, and curation loop. Local CDC chunks (BM25, vector, and hybrid modes) deliver rapid, low-latency turnaround across multi-turn research queries.
 
@@ -67,11 +67,20 @@ AutoRAG Agent orchestrates five integrated subsystems:
    - **Semantic Vector Search:** Dense vector retrieval over CDC chunks via the built-in embedding gateway.
    - **Hybrid Search:** Combines BM25 and vector ranking via Reciprocal Rank Fusion (RRF).
    - **Jikji Find-First Discovery:** Local CLI-backed fast discovery answer packs.
+   - **Everything File-Name Search (Windows):** The bundled [voidtools Everything](https://www.voidtools.com/) indexes file and folder names under your search roots so the agent finds files by name, extension, path, size, or date instantly (`everything_search`).
+   - **FSearch File-Name Search (macOS/Linux):** [fsearch-cli](https://github.com/NomaDamas/fsearch-mac) (FSearch) keeps a live, per-workspace name index of your search roots so the agent finds files by name, extension, path, size, or date instantly (`fsearch_search`); without fsearch-cli installed it degrades to a slow filesystem walk.
    - **Datasource Skills:** Server-authorized federated retrieval across external applications.
 3. **Result Merger & Scoped Access Gate:** Cross-method deduplication, score normalization, and default-deny permission checks.
 4. **Direct Evidence Reading (`bash`):** The agent directly opens and inspects promising files with `cat`, `grep`, or `find` to verify facts against ground truth.
 5. **Curation & Active Feedback:** Structured findings are returned via `emit_autorag_results`. When callers provide feedback on which items were useful, AutoRAG records this to optimize future queries.
 
+### Pi host boundary
+
+AutoRAG uses `@earendil-works/pi-coding-agent` as the runtime host for model sessions. Pi owns provider credentials and OAuth storage, model-runtime dispatch, session JSONL persistence/resume, extension loading, lifecycle events, and the built-in `read`/`bash`/`edit`/`write`/`grep`/`find`/`ls` tools. AutoRAG registers only its domain tools and keeps orchestration outside the host: datasource authorization, MinSync/Jikji preparation, memory hints, fast-to-verification two-phase search, structured result emission, and remote-session filtering.
+
+The CLI TUI (`autorag tui`) is Pi's interactive mode hosted on the AutoRAG librarian: there is no separate AutoRAG renderer. Pi owns the terminal UI and its native in-session commands — `/login`/`/logout`, `/model`, `/resume`, `/new`, `/tree`, `/compact`, and `/settings` — so provider sign-in and model selection work on first launch even when no AutoRAG model is configured. AutoRAG registers its retrieval tools and streams progress, preliminary answers, and final results into the same Pi session, so resume and two-phase search keep working together.
+
+
 ---
 
 ## 🤖 For AI Agents & LLMs: Setup & Skills
@@ -175,7 +184,7 @@ AutoRAG Agent connects to external tools and communication platforms using dedic
 | **RSS / News** | `rss` | Native HTTP Poller | RSS 2.0 & Atom feeds (24h deduplication) | Lexical |
 | **macOS Spotlight** | `spotlight` | Native `mdfind` CLI | macOS system metadata and content index | System Native |
 
-For configuration syntax and connector details, see [docs/datasource-skills.md](docs/datasource-skills.md).
+For configuration syntax and connector details, see [docs/datasource-skills.md](docs/datasource-skills.md). Non-interactive `sync`/`index` steps get a 30-minute per-connector budget (`connector.indexTimeoutMs`) because first-run imports routinely take minutes; interactive search keeps its 60-second default.
 
 ---
 
@@ -198,6 +207,8 @@ bun add @autorag/librarian
 - **No Java required:** Document parsing (HWP/HWPX/HWPML, PDF, DOCX, XLSX/XLS) runs in-process through [`kordoc`](https://github.com/chrisryugj/kordoc).
 - **Rust Toolchain (Optional):** Automatically compiles Jikji (`jikji-cli`) if installed.
 - **MinSync:** Automatically downloaded and installed into `<workspace>/.autorag/bin` on first run.
+- **Everything (Windows only, bundled):** The package ships the portable Everything 1.4.1.1032 and its ES 1.1.0.38 CLI (x64 and ARM64, SHA-256 pinned). On Windows, AutoRAG extracts them into `<workspace>/.autorag/everything/` and runs a private, user-level instance that indexes only your configured search roots: no administrator rights, no Everything service, no whole-drive scan, no HTTP/ETP server, and no change to any Everything you already run. Set `"everything": false` in the config to turn it off. macOS and Linux are not affected.
+- **FSearch (macOS/Linux only, separate install):** Install [`fsearch-cli`](https://github.com/NomaDamas/fsearch-mac) yourself (e.g. `brew install NomaDamas/fsearch-mac/fsearch-mac` (installs the `fsearch-cli` binary); GPL-2.0, spawned as a separate process, never bundled or linked). On macOS and Linux, AutoRAG builds a per-workspace database at `<workspace>/.autorag/fsearch/` indexing only your configured search roots, and keeps a `fsearch-cli watch` daemon live (FSEvents/inotify) for sub-second name search. It never touches the FSearch app's own database. Without fsearch-cli, name search falls back to a slow bounded filesystem walk. Set `"fsearch": false` in the config to turn it off. Windows is not affected (Everything covers it).
 
 ---
 
@@ -245,7 +256,7 @@ PDF pages.
 # Perform a curated search (uses your configured reasoning model)
 autorag search "What are our primary Q3 deliverables?"
 
-# Launch the interactive Terminal UI (beta)
+# Launch the interactive Terminal UI (Pi host: /login, /model, /resume, …)
 autorag tui
 ```
 
@@ -279,11 +290,12 @@ agent.recordFeedbackByNumbers(response.sessionId, [1], [2]);
 | Command | Description |
 |---|---|
 | `autorag init` | Initialize `~/.autorag/config.json` with search roots, document languages, and model settings |
-| `autorag refresh` | Refresh parsed mirrors, MinSync CDC chunks, datasources, and Jikji |
+| `autorag refresh` | Refresh parsed mirrors, MinSync CDC chunks, datasources, Jikji, and the platform file-name index (Everything on Windows, FSearch on macOS/Linux) |
 | `autorag search "<query>"` | Run the librarian agent to curate structured answers |
 | `autorag status` | Inspect corpus freshness, indexing status, and vector readiness |
 | `autorag health` | Check model provider authentication, token validity, and API reachability |
-| `autorag tui` | Open the interactive librarian terminal UI |
+| `autorag models list` | List chat models the pi runtime can resolve (built-ins, `models.json`, custom/extension providers) with provider auth status; never prints credential values |
+| `autorag tui` | Open Pi's interactive librarian TUI (`/login`, `/model`, `/resume`, …) |
 | `autorag duplicates [DIR]` | Read-only scan for exact and near-duplicate document families with `dupey` |
 | `autorag lite ...` | Model-free indexing, retrieval, report generation, and status |
 | `autorag feedback <session>` | Record useful / not-useful feedback by item number |
@@ -325,6 +337,8 @@ AutoRAG Agent stands on the shoulders of fantastic open-source projects:
 - **[Pi Framework](https://github.com/earendil-works/pi-mono)** by [@earendil-works](https://github.com/earendil-works) — The foundational agent framework powering AutoRAG's reasoning loop.
 - **[MinSync](https://github.com/Marker-Inc-Korea/minsync)** — Ultra-fast incremental Change Data Capture (CDC) chunking and local BM25/vector indexing.
 - **[Jikji](https://github.com/NomaDamas/jikji)** by [NomaDamas](https://github.com/NomaDamas) — High-performance find-first local document discovery.
+- **[Everything](https://www.voidtools.com/)** and **[ES](https://github.com/voidtools/ES)** by voidtools (David Carpenter) — Instant Windows file-name indexing and its command-line interface, bundled under the MIT License.
+- **[FSearch](https://github.com/cboxdoerfer/fsearch)** and **[fsearch-cli](https://github.com/NomaDamas/fsearch-mac)** — Everything-style file-name search for macOS/Linux (GPL-2.0-or-later). Never bundled or linked: users install fsearch-cli separately and AutoRAG spawns it as a separate process (mere aggregation per the FSF GPL FAQ).
 - **[dupey](https://github.com/NomaDamas/dupey)** by [NomaDamas](https://github.com/NomaDamas) — Fast duplicate and near-duplicate document family detection.
 - **Federated CLI Authors:** External datasource tools [`lazykatok`](https://github.com/changeroa/lazykatok), [`discrawl`](https://github.com/openclaw/discrawl), [`mailcrawl`](https://github.com/NomaDamas/mailcrawl), [`wacrawl`](https://github.com/openclaw/wacrawl), [`telecrawl`](https://github.com/openclaw/telecrawl), [`slacrawl`](https://github.com/openclaw/slacrawl), [`notcrawl`](https://github.com/openclaw/notcrawl), [`qmd`](https://github.com/tobi/qmd), and [`rclone`](https://rclone.org).
 - **[kordoc](https://github.com/chrisryugj/kordoc)** by [chrisryugj](https://github.com/chrisryugj) — HWP/HWPX/HWPML, PDF, DOCX and XLSX parsing with nested-table fidelity, used as AutoRAG's default document parser.
@@ -360,6 +374,7 @@ Common failures and their fix:
 | A datasource is healthy in its own CLI but absent from results | — | add its tag/scope to `datasourceAccess` |
 | A datasource errors during refresh | `datasource-index-failed` | run that CLI's own `doctor` |
 | MinSync or Jikji missing | `minsync-unavailable`, `jikji-unavailable` | check the Rust toolchain, re-run refresh |
+| Windows file-name search fails during refresh | `everything-index-failed` | read the ES exit code and stderr in the message, then `autorag refresh --method everything --json` |
 
 Native datasource stores stay owned by their CLIs — AutoRAG never rebuilds them. Fix a broken archive with `lazykatok doctor`, `discrawl --json metadata`, `slacrawl --json doctor`, `wacrawl --json doctor`, `telecrawl --json doctor`, `notcrawl doctor`, `qmd status`, or `mailcrawl doctor`, then re-run `autorag refresh --method datasources --json`.
 
@@ -368,3 +383,5 @@ Native datasource stores stay owned by their CLIs — AutoRAG never rebuilds the
 - **AutoRAG 2.0 (AutoRAG Agent):** Released under the [MIT License](LICENSE).
 - **Legacy Python AutoRAG (`legacy/`):** Released under the [Apache License 2.0](legacy/LICENSE).
 - Production third-party notices and licenses are documented in [`NOTICE`](NOTICE).
+- The bundled Windows binaries keep their own licenses: Everything (MIT, plus PCRE BSD-3-Clause) in [`licenses/everything-MIT-and-PCRE-BSD.txt`](licenses/everything-MIT-and-PCRE-BSD.txt) and ES (MIT) in [`licenses/es-MIT.txt`](licenses/es-MIT.txt). Everything's source code is not public; AutoRAG redistributes the unmodified voidtools portable ZIPs.
+- FSearch/fsearch-cli (GPL-2.0-or-later) are **not** distributed with AutoRAG: no code is copied, linked, or bundled. Users install fsearch-cli themselves and AutoRAG communicates with it only through its command-line interface and daemon socket — separate programs, per the [FSF mere-aggregation FAQ](https://www.gnu.org/licenses/gpl-faq.html#MereAggregation). Source: https://github.com/NomaDamas/fsearch-mac.

package/dist/agent/agent.d.ts

@@ -1,8 +1,10 @@
-import { Agent, type AgentTool, type Skill } from "@earendil-works/pi-agent-core";
+import type { Agent, AgentTool, Skill } from "@earendil-works/pi-agent-core";
 import type { Api, Model } from "@earendil-works/pi-ai";
 import { type DatasourceAccessContextOptions } from "../datasource/access-context.js";
 import type { DatasourceIndexResult, DatasourceSkill } from "../datasource/types.js";
 import { type DupeyCliOptions } from "../dupey/index.js";
+import { type EverythingClientOptions, type EverythingSearchRequest, type EverythingSearchResult } from "../everything/index.js";
+import { type FSearchClientOptions, type FSearchFailureReason, type FSearchSearchRequest, type FSearchSearchResult } from "../fsearch/index.js";
 import { type JikjiFailureReason, type JikjiOptions } from "../jikji/index.js";
 import { type LanguageTag } from "../language.js";
 import type { ResultFeedback } from "../memory/memory.js";
@@ -17,18 +19,49 @@ import { RetrievalEngine } from "../retrieval/engine.js";
 import { RetrievalMethodRegistry } from "../retrieval/registry.js";
 import type { CuratedResult, RetrievalDiagnostic, RetrievalOptions, RetrievalResult } from "../retrieval/types.js";
 import { type ScanDuplicateDocumentsDetails } from "./dupey-tool.js";
+import { type AutoRAGFastAnswerDetails } from "./fast-answer-tool.js";
 import { type JikjiFindProviderResult } from "./jikji-find-tool.js";
+import { type AutoRAGPiInteractiveRuntime, type AutoRAGPiSession } from "./pi-session.js";
 import { type RefreshProgressCounts, type RefreshProgressPhase } from "./refresh-progress.js";
 import { type SearchDocumentDiagnostic, type SearchDocumentsResponse, type SearchDocumentsStreamEvent } from "./search-documents.js";
 import { type WatcherFactory, type WatchRefreshHandle } from "./watch-refresh.js";
 import { type WebFetchToolOptions } from "./web-fetch-tool.js";
 import { type WebSearchToolOptions } from "./web-search-tool.js";
+/**
+ * Hard caps on retrieval, baseline prefetch, and the candidate lists handed to
+ * the model. Every field is optional: an omitted field keeps the shipped
+ * default below, so this only exists to let an operator tighten or widen a
+ * specific cap without rebuilding. Values must be positive integers.
+ */
+export interface AutoRAGRetrievalLimits {
+    /** `search_all_documents` merge ceiling when the model omits `topK`. Default 500. */
+    readonly mergedEvidenceCeiling?: number;
+    /** `search_datasource_*` merge default when the model omits `topK`. Default 50. */
+    readonly singleDatasourceTopK?: number;
+    /** MinSync semantic retrieval default `topK`. Default 50. */
+    readonly minSyncTopK?: number;
+    /** MinSync fetch cap when a scope narrows the query. Default 100. */
+    readonly minSyncScopedQueryTopK?: number;
+    /** Instance scopes listed in one datasource tool description. Default 8. */
+    readonly toolDescriptionInstanceScopes?: number;
+    /** Baseline evidence prefetched for the fast answer. */
+    readonly prefetch?: {
+        /** Jikji find candidate count. Default 30. */
+        readonly jikjiTopK?: number;
+        /** MinSync retrieve candidate count. Default 100. */
+        readonly minSyncTopK?: number;
+        /** Max Jikji answer paths rendered into the baseline. Default 100. */
+        readonly jikjiPathLimit?: number;
+        /** Max results rendered per baseline section. Default 100. */
+        readonly sectionLimit?: number;
+    };
+}
 export interface AutoRefreshOptions {
     readonly intervalMs: number;
     readonly immediate?: boolean;
 }
 /** Methods that `refresh` can selectively run. Defaults to all when omitted. */
-export type RefreshMethod = "parsed" | "minsync" | "datasources" | "jikji";
+export type RefreshMethod = "parsed" | "minsync" | "datasources" | "jikji" | "everything" | "fsearch";
 export interface AutoRAGRefreshOptions {
     /** Restrict refresh to specific methods. Defaults to all when undefined. */
     readonly methods?: readonly RefreshMethod[];
@@ -45,11 +78,30 @@ export interface AutoRAGRefreshResult extends Omit<ParsedMirrorSyncResult, "diag
     readonly diagnostics: readonly SearchDocumentDiagnostic[];
     readonly minsync?: AutoRAGMinSyncRefreshResult;
     readonly datasources?: readonly DatasourceIndexResult[];
+    /** Windows-only Everything file-name index outcome; absent on other platforms or when not selected. */
+    readonly everything?: AutoRAGEverythingRefreshResult;
+    /** macOS/Linux-only FSearch file-name index outcome; absent on other platforms or when not selected. */
+    readonly fsearch?: AutoRAGFSearchRefreshResult;
+}
+export interface AutoRAGEverythingRefreshResult {
+    readonly ok: boolean;
+    readonly indexedItems?: number;
+    readonly reason?: string;
+}
+export interface AutoRAGFSearchRefreshResult {
+    readonly ok: boolean;
+    readonly indexedItems?: number;
+    /** Stable failure kind (e.g. "binary-missing") when ok is false. */
+    readonly reason?: FSearchFailureReason;
+    /** Verbatim underlying failure text when ok is false. */
+    readonly message?: string;
 }
 export interface AutoRAGRefreshComponentStatus {
     readonly minsync?: string;
     readonly jikji?: string;
     readonly datasources?: string;
+    readonly everything?: string;
+    readonly fsearch?: string;
 }
 /** Path-opaque snapshot of corpus freshness and the last refresh outcome. */
 export interface AutoRAGRefreshStatus {
@@ -139,6 +191,23 @@ export interface AutoRAGAgentOptions {
     tools?: AgentTool[];
     minSync?: Omit<MinSyncVectorMethodOptions, "root"> | false;
     jikji?: JikjiOptions | false;
+    /**
+     * Windows-only instant file/folder name search through the bundled
+     * voidtools Everything (portable, user-level, folder-only index over
+     * `searchPaths`). Enabled by default on Windows; ignored elsewhere.
+     * `false` disables it. The remaining fields are test seams.
+     */
+    everything?: Omit<EverythingClientOptions, "root" | "folders"> | false;
+    /**
+     * macOS/Linux-only instant file/folder name search through the user's
+     * fsearch-cli (FSearch, GPL — spawned as a separate process, never
+     * bundled). Indexes only `searchPaths` into `<workspace>/.autorag/fsearch/`
+     * and keeps a per-workspace `fsearch-cli watch` daemon live; searches fall
+     * back to a bounded slow filesystem walk when fsearch-cli is not
+     * installed. Enabled by default on macOS/Linux; ignored elsewhere.
+     * `false` disables it. The remaining fields are test seams.
+     */
+    fsearch?: Omit<FSearchClientOptions, "root" | "folders"> | false;
     /**
      * Internet web tools (`web_search` + `web_fetch`), ported from oh-my-pi's
      * provider-chain web module. Default enabled and credential-free: the
@@ -154,11 +223,24 @@ export interface AutoRAGAgentOptions {
     webSearch?: (WebSearchToolOptions & {
         fetch?: WebFetchToolOptions | false;
     }) | false;
+    /**
+     * Post-merge reranking. When set (and not `false`), merged retrieval evidence
+     * is reordered by a dedicated rerank model — OpenRouter by default. A
+     * configured-but-unavailable reranker is reported as a diagnostic and the
+     * merged order is preserved. `false` disables reranking.
+     */
+    rerank?: RerankAgentOptions | false;
     autoRefresh?: AutoRefreshOptions;
     parserOptions?: DefaultParserRegistryOptions;
     dupey?: DupeyCliOptions | false;
     excludeExactDuplicates?: boolean;
     excludePaths?: readonly string[];
+    /**
+     * Hard caps on retrieval, baseline prefetch, and model-facing candidate
+     * lists. Omitted fields keep their shipped defaults — see
+     * {@link AutoRAGRetrievalLimits}. Values must be positive integers.
+     */
+    limits?: AutoRAGRetrievalLimits;
     datasourceSkills?: readonly DatasourceSkill[];
     datasourceAccess?: DatasourceAccessContextOptions;
     /** Non-fatal diagnostics from config/agent construction (e.g. skipped unknown datasources). */
@@ -176,9 +258,33 @@ export interface AutoRAGAgentOptions {
     remoteSession?: boolean;
     /** Two-phase progressive answers with per-phase thinking control. Default enabled. */
     thinking?: AutoRAGThinkingOptions | false;
+    /** pi agent directory for auth/models/extensions. Defaults to ~/.pi/agent. */
+    piAgentDir?: string;
+    /** Optional persistent pi session directory. */
+    piSessionDir?: string;
+    /** Persist one pi session transcript per AutoRAG search. Defaults true. */
+    persistPiSessions?: boolean;
+}
+/** Post-merge reranking options. Mirrors the CLI `RerankConfig` (secrets via env). */
+export interface RerankAgentOptions {
+    /** Provider id. @default "openrouter" */
+    provider?: string;
+    /** Wire model id. @default "voyageai/rerank-3-lite" */
+    model?: string;
+    /** API key. Prefer `apiKeyEnv`; this is a programmatic seam. */
+    apiKey?: string;
+    /** Environment variable holding the provider API key. */
+    apiKeyEnv?: string;
+    /** Override the provider base URL. */
+    baseUrl?: string;
+    /** Return only the top N merged results. */
+    topN?: number;
+    /** Per-request timeout in milliseconds. */
+    timeoutMs?: number;
 }
 export interface AutoRAGSearchSession {
     readonly agent: Agent;
+    readonly piSession?: AutoRAGPiSession["session"];
     prompt(text: string): Promise<void>;
     abort(): Promise<void> | void;
     dispose(): void;
@@ -210,7 +316,7 @@ export declare class AutoRAGAgent {
     private readonly sessions;
     private activeRun;
     private resultCapture;
-    /** This agent's model credential for model-native web search (per instance, never shared). */
+    private interactiveFastAnswerCallback;
     private modelNativeSearchAuth;
     private retrievalTrace;
     private preliminaryCallback;
@@ -233,9 +339,13 @@ export declare class AutoRAGAgent {
     private readonly methodRegistry;
     private readonly retriever;
     private readonly merger;
+    private readonly reranker;
+    private readonly rerankTopN;
     private readonly datasourceFilter;
     private readonly minSyncMethod;
     private readonly jikjiClient;
+    private readonly everythingClient;
+    private readonly fsearchClient;
     private readonly datasourceSkills;
     private readonly datasourceAccessOptions;
     private readonly startupDiagnostics;
@@ -248,10 +358,15 @@ export declare class AutoRAGAgent {
     private readonly droppedCallerToolNames;
     private readonly searchTimeoutMs;
     private readonly maxSearchToolCalls;
+    private readonly piAgentDir;
+    private readonly piSessionDir;
+    private readonly persistPiSessions;
+    private boundPiRuntime;
     /** True when this agent was constructed for an untrusted remote peer. */
     readonly remoteSession: boolean;
     private activeRetrievalOptions;
     private searchToolCallCount;
+    private readonly limits;
     constructor(options: AutoRAGAgentOptions);
     scanDuplicateDocuments(): Promise<ScanDuplicateDocumentsDetails>;
     private withMemoryContext;
@@ -261,6 +376,8 @@ export declare class AutoRAGAgent {
     private recordSearchToolEvent;
     private currentSystemPromptConfig;
     subscribe(listener: Parameters<Agent["subscribe"]>[0]): () => void;
+    createPiInteractiveRuntime(): Promise<AutoRAGPiInteractiveRuntime>;
+    private runInteractivePiQuery;
     abort(): void;
     /**
      * Periodically re-runs the incremental {@link refresh} so parsed mirrors and
@@ -322,12 +439,15 @@ export declare class AutoRAGAgent {
      * via emit_fast_answer, without any further tool calls.
      */
     buildFastAnswerPrompt(query: string, options: RetrievalOptions, baseline: string): string;
+    /** Discovery-tool hint naming only the registered discovery tools; empty when none. */
+    private discoveryHint;
     /**
-     * Verification-phase prompt for two-phase searches. The user already saw
-     * the fast answer; the model now verifies it against sources with thinking
-     * on and finalizes with emit_autorag_results exactly once.
+     * 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.
      */
-    buildRefinementPrompt(query: string, options: RetrievalOptions, fastAnswer: string | undefined): string;
+    buildRefinementPrompt(query: string, options: RetrievalOptions, fastAnswer: AutoRAGFastAnswerDetails | undefined, fastAnswerDelivered: boolean): string;
     buildSearchPrompt(query: string, options: RetrievalOptions, initialRetrievalContext?: string): string;
     refresh(force?: boolean, opts?: AutoRAGRefreshOptions): Promise<AutoRAGRefreshResult>;
     /**
@@ -341,7 +461,7 @@ export declare class AutoRAGAgent {
      */
     getRefreshStatus(): Promise<AutoRAGRefreshStatus>;
     /**
-     * Synchronous per-component readiness snapshot (minsync/jikji/datasources).
+     * Synchronous per-component readiness snapshot (minsync/jikji/datasources/everything).
      * `minsync` is "ready" only after a successful sync wrote its cursor;
      * "configured" means the binary resolved but no index exists yet.
      */
@@ -366,6 +486,23 @@ export declare class AutoRAGAgent {
     private scanMirrorStaleness;
     private exactDuplicateExclusions;
     syncMinSync(force?: boolean): Promise<MinSyncSyncResult | undefined>;
+    /** Provider for the Windows-only everything_search tool. */
+    searchEverything(request: EverythingSearchRequest): Promise<EverythingSearchResult>;
+    /**
+     * Exit this workspace's Everything instance. The instance otherwise stays
+     * running on purpose (live folder monitoring between CLI invocations), so
+     * call this only when the workspace is being torn down. No-op off Windows.
+     */
+    stopEverything(): Promise<void>;
+    /** Provider for the macOS/Linux-only fsearch_search tool. */
+    searchFsearch(request: FSearchSearchRequest): Promise<FSearchSearchResult>;
+    /**
+     * Terminate this workspace's fsearch-cli watch daemon. The daemon otherwise
+     * stays running on purpose (live index updates between CLI invocations), so
+     * call this only when the workspace is being torn down. No-op off
+     * macOS/Linux.
+     */
+    stopFsearch(): Promise<void>;
     prepareJikji(): Promise<readonly AutoRAGJikjiPrepareResult[] | undefined>;
     private executeJikjiPrepare;
     /**
@@ -453,6 +590,12 @@ export declare class AutoRAGAgent {
     private retrievalEngine;
     getRetrievalEngine(): RetrievalEngine;
     getSystemPrompt(): string;
+    /**
+     * Reorder merged evidence with the configured reranker. A configured-but-
+     * unavailable reranker, or a rerank failure, is reported as a diagnostic and
+     * the merged order is preserved — a reranker outage never hides evidence.
+     */
+    private applyRerank;
     private rerankWithMemory;
     private remoteFilteredRetrievalMethod;
     private normalizeRetrievalOptions;

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

@@ -0,0 +1,35 @@
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { Type } from "typebox";
+import type { EverythingSearchRequest, EverythingSearchResult } from "../everything/index.js";
+export declare const EVERYTHING_SEARCH_TOOL_NAME = "everything_search";
+export interface EverythingSearchProvider {
+    searchEverything(request: EverythingSearchRequest): Promise<EverythingSearchResult>;
+}
+export interface EverythingSearchDetails {
+    readonly method: typeof EVERYTHING_SEARCH_TOOL_NAME;
+    readonly resultCount: number;
+    readonly sources: readonly string[];
+    /** Retrieval-trace shape: each hit's absolute path plus its rendered line. */
+    readonly results: readonly {
+        readonly source: string;
+        readonly excerpt: string;
+    }[];
+}
+declare const everythingSearchSchema: Type.TObject<{
+    query: Type.TString;
+    regex: Type.TOptional<Type.TBoolean>;
+    matchCase: Type.TOptional<Type.TBoolean>;
+    matchPath: Type.TOptional<Type.TBoolean>;
+    wholeWord: Type.TOptional<Type.TBoolean>;
+    kind: Type.TOptional<Type.TUnion<[Type.TLiteral<"files">, Type.TLiteral<"folders">]>>;
+    path: Type.TOptional<Type.TString>;
+    sort: Type.TOptional<Type.TUnion<[Type.TLiteral<"name-ascending">, Type.TLiteral<"name-descending">, Type.TLiteral<"path-ascending">, Type.TLiteral<"path-descending">, Type.TLiteral<"size-ascending">, Type.TLiteral<"size-descending">, Type.TLiteral<"date-modified-ascending">, Type.TLiteral<"date-modified-descending">]>>;
+    offset: Type.TOptional<Type.TInteger>;
+    maxResults: Type.TOptional<Type.TInteger>;
+}>;
+/**
+ * Windows-only instant file/folder name search through the bundled voidtools
+ * Everything instance that indexes the configured search folders.
+ */
+export declare function createEverythingSearchTool(provider: EverythingSearchProvider): AgentTool<typeof everythingSearchSchema, EverythingSearchDetails>;
+export {};

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

@@ -0,0 +1,35 @@
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import { Type } from "typebox";
+import type { FSearchSearchRequest, FSearchSearchResult } from "../fsearch/index.js";
+export declare const FSEARCH_SEARCH_TOOL_NAME = "fsearch_search";
+export interface FSearchSearchProvider {
+    searchFsearch(request: FSearchSearchRequest): Promise<FSearchSearchResult>;
+}
+export interface FSearchSearchDetails {
+    readonly method: typeof FSEARCH_SEARCH_TOOL_NAME;
+    readonly resultCount: number;
+    readonly sources: readonly string[];
+    /** Retrieval-trace shape: each hit's absolute path plus its rendered line. */
+    readonly results: readonly {
+        readonly source: string;
+        readonly excerpt: string;
+    }[];
+}
+declare const fsearchSearchSchema: Type.TObject<{
+    query: Type.TString;
+    regex: Type.TOptional<Type.TBoolean>;
+    matchCase: Type.TOptional<Type.TBoolean>;
+    matchPath: Type.TOptional<Type.TBoolean>;
+    kind: Type.TOptional<Type.TUnion<[Type.TLiteral<"files">, Type.TLiteral<"folders">]>>;
+    path: Type.TOptional<Type.TString>;
+    sort: Type.TOptional<Type.TUnion<[Type.TLiteral<"name-ascending">, Type.TLiteral<"name-descending">, Type.TLiteral<"path-ascending">, Type.TLiteral<"path-descending">, Type.TLiteral<"size-ascending">, Type.TLiteral<"size-descending">, Type.TLiteral<"date-modified-ascending">, Type.TLiteral<"date-modified-descending">]>>;
+    offset: Type.TOptional<Type.TInteger>;
+    maxResults: Type.TOptional<Type.TInteger>;
+}>;
+/**
+ * macOS/Linux instant file/folder name search through the user's fsearch-cli
+ * (FSearch) database that indexes the configured search folders. Degrades to
+ * a bounded slow filesystem walk when fsearch-cli is not installed.
+ */
+export declare function createFSearchSearchTool(provider: FSearchSearchProvider): AgentTool<typeof fsearchSearchSchema, FSearchSearchDetails>;
+export {};

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

@@ -46,6 +46,8 @@ export interface JikjiFindProvider {
     }): Promise<JikjiFindProviderResult>;
 }
 export interface JikjiFindDetails {
+    /** Provider diagnostics, including failed roots alongside healthy answers. */
+    readonly diagnostics?: readonly JikjiDiagnostic[];
     readonly method: "jikji_find";
     readonly answerCount: number;
     readonly handoffAction: JikjiHandoffAction | undefined;

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

@@ -0,0 +1,35 @@
+import type { AgentMessage, AgentTool } from "@earendil-works/pi-agent-core";
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { type AgentSession, type AgentSessionRuntime, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export declare const PI_BUILTIN_TOOL_NAMES: readonly ["read", "bash", "edit", "write", "grep", "find", "ls"];
+export interface AutoRAGPiSessionOptions {
+    readonly cwd: string;
+    readonly agentDir?: string;
+    readonly sessionDir?: string;
+    readonly sessionPath?: string;
+    readonly persistSession?: boolean;
+    readonly model: Model<Api>;
+    readonly apiKey?: string;
+    readonly providerApiKeys?: Readonly<Record<string, string>>;
+    readonly getSystemPrompt: () => string;
+    readonly customTools: readonly AgentTool[];
+    readonly remoteSession?: boolean;
+    readonly contextTransform?: (messages: AgentMessage[]) => Promise<AgentMessage[]>;
+}
+export interface AutoRAGPiInteractiveRuntimeOptions extends Omit<AutoRAGPiSessionOptions, "model"> {
+    readonly model?: Model<Api>;
+    readonly inactiveToolNames?: readonly string[];
+    readonly onQuery: (query: string, pi: ExtensionAPI) => void | Promise<void>;
+}
+export interface AutoRAGPiSession {
+    readonly session: AgentSession;
+    readonly baseToolNames: readonly string[];
+    readonly sessionFile: string | undefined;
+}
+/** Creates a pi session with AutoRAG's tools and prompt. */
+export declare function createAutoRAGPiSession(options: AutoRAGPiSessionOptions): Promise<AutoRAGPiSession>;
+export interface AutoRAGPiInteractiveRuntime {
+    readonly runtime: AgentSessionRuntime;
+    readonly dispose: () => Promise<void>;
+}
+export declare function createAutoRAGPiInteractiveRuntime(options: AutoRAGPiInteractiveRuntimeOptions): Promise<AutoRAGPiInteractiveRuntime>;

package/dist/agent/refresh-progress.d.ts

@@ -1,4 +1,4 @@
-export type RefreshProgressPhase = "parsed" | "minsync" | "datasources" | "jikji" | "finalizing";
+export type RefreshProgressPhase = "parsed" | "minsync" | "datasources" | "jikji" | "everything" | "fsearch" | "finalizing";
 export interface RefreshProgressCounts {
     readonly scanned: number;
     readonly written: number;

package/dist/agent/search-documents.d.ts

@@ -10,7 +10,7 @@ export type SearchDocumentDiagnosticSeverity = "info" | "warning" | "error";
  * (#21/#22) does not require another source-breaking type change; codes not yet
  * emitted are still valid members.
  */
-export type SearchDocumentDiagnosticCode = "empty-query" | "no-verified-results" | "unknown-warning" | "caller-tool-dropped" | "minsync-unavailable" | "minsync-staging-excluded" | "minsync-sync-failed" | "embedder-unavailable" | "embedding-identity-mismatch" | "parser-skipped" | "parser-failed" | "parser-warning" | "duplicate-excluded" | "unsupported-file" | "stale-index" | "deleted-mirror" | "pdf-extract-thin" | "retrieval-method-failed" | "jikji-unavailable" | "jikji-prepare-failed" | "jikji-find-failed" | "refresh-failed" | "refresh-interrupted" | "watch-failed" | "watch-limited" | "unknown-datasource-skill" | "missing-final-emit";
+export type SearchDocumentDiagnosticCode = "empty-query" | "no-verified-results" | "unknown-warning" | "caller-tool-dropped" | "minsync-unavailable" | "minsync-staging-excluded" | "minsync-sync-failed" | "embedder-unavailable" | "embedding-identity-mismatch" | "parser-skipped" | "parser-failed" | "parser-warning" | "duplicate-excluded" | "unsupported-file" | "stale-index" | "deleted-mirror" | "pdf-extract-thin" | "retrieval-method-failed" | "rerank-failed" | "jikji-unavailable" | "jikji-prepare-failed" | "jikji-find-failed" | "everything-index-failed" | "fsearch-index-failed" | "fsearch-binary-missing" | "refresh-failed" | "refresh-interrupted" | "watch-failed" | "watch-limited" | "unknown-datasource-skill" | "missing-final-emit" | "model-request-failed";
 export interface SearchDocumentDiagnostic {
     readonly code: SearchDocumentDiagnosticCode;
     readonly severity: SearchDocumentDiagnosticSeverity;

package/dist/cli/commands/health.d.ts

@@ -1,6 +1,5 @@
 import type { Api, Model } from "@earendil-works/pi-ai";
-import type { LoadLocalAutoRAGModelOptions } from "../../agent/local-model.js";
-import { type CliConfig, type ResolvedAgentModelDetailed } from "../config.js";
+import { type CliConfig, type ResolveAgentModelOptions, type ResolvedAgentModelDetailed } from "../config.js";
 import type { CommandContext } from "./types.js";
 export type HealthCategory = "config" | "model_resolution" | "auth_missing" | "provider_unreachable" | "completion_failed" | "timeout" | "ok";
 export interface HealthCoverage {
@@ -83,7 +82,7 @@ export interface HealthDeps {
         cwd?: string;
         env?: NodeJS.ProcessEnv;
     }) => CliConfig;
-    modelResolver?: (config: CliConfig, localOptions?: LoadLocalAutoRAGModelOptions) => ResolvedHealthModel;
+    modelResolver?: (config: CliConfig, options?: ResolveAgentModelOptions) => ResolvedHealthModel | Promise<ResolvedHealthModel>;
     probe?: (input: ProbeInput, signal: AbortSignal) => Promise<ProbeOutput>;
     now?: () => number;
 }

package/dist/cli/commands/models.d.ts

@@ -1,5 +1,24 @@
 import type { ProfileId } from "../../embedding-runtime/types.js";
 import type { CommandContext } from "./types.js";
+/**
+ * One chat model discovered through the pi model runtime (built-in catalog plus
+ * `models.json`, custom, and extension providers). `available` reports whether
+ * the provider has complete auth configuration, including stored `auth.json`
+ * credentials (api-key or OAuth).
+ */
+export interface ModelCatalogEntry {
+    readonly provider: string;
+    readonly id: string;
+    readonly name: string;
+    readonly api: string;
+    readonly available: boolean;
+}
+export interface ModelCatalogOptions {
+    readonly provider?: string;
+    /** Only list models whose provider has complete auth configuration. */
+    readonly available?: boolean;
+    readonly agentDir?: string;
+}
 export interface ModelsCommandDeps {
     prefetchModel?: (profileId?: ProfileId) => Promise<{
         profileId: ProfileId;
@@ -14,5 +33,6 @@ export interface ModelsCommandDeps {
         path: string;
         hash: string;
     }>;
+    listModels?: (options: ModelCatalogOptions) => Promise<readonly ModelCatalogEntry[]>;
 }
 export declare function runModels(ctx: CommandContext, deps?: ModelsCommandDeps): Promise<number>;

package/dist/cli/commands/refresh.d.ts

@@ -2,7 +2,7 @@ import { type RefreshMethod } from "../../agent/agent.js";
 import type { CommandContext } from "./types.js";
 /**
  * `autorag refresh` — parse configured search paths and resync every active
- * index (parsed mirror, MinSync, datasources, jikji). Model-free: no LLM
+ * index (parsed mirror, MinSync, datasources, jikji, and Everything on Windows). Model-free: no LLM
  * is constructed. Output is rendered through the path-opaque refresh renderer;
  * the raw result (which carries absolute `indexPath`) is never printed.
  *

package/dist/cli/commands/search.d.ts

@@ -1,5 +1,5 @@
 import { AutoRAGAgent, type AutoRAGAgentOptions } from "../../agent/agent.js";
-import { type CliConfig, type ResolvedAgentModel } from "../config.js";
+import { type CliConfig, type ResolveAgentModelOptions, type ResolvedAgentModel } from "../config.js";
 import type { CommandContext } from "./types.js";
 /**
  * A recoverable health hint surfaced when `autorag search` fails for a reason
@@ -25,7 +25,7 @@ export declare function classifySearchHealthHint(error: unknown): SearchHealthHi
  */
 export interface SearchDeps {
     agentFactory?: (opts: AutoRAGAgentOptions) => Pick<AutoRAGAgent, "searchDocumentsStream">;
-    modelResolver?: (config: CliConfig) => ResolvedAgentModel;
+    modelResolver?: (config: CliConfig, options?: ResolveAgentModelOptions) => ResolvedAgentModel | Promise<ResolvedAgentModel>;
     /**
      * Stops the on-demand embedding gateway so the process can exit. Without
      * this the semantic MinSync path's loopback gateway keeps the event loop