@autorag/librarian 2.8.0 → 2.9.0

package/NOTICE

@@ -6,16 +6,16 @@ legacy/ package license: Apache-2.0
 
 Third-party production dependencies:
 
-@earendil-works/pi-agent-core@0.86.1
+@earendil-works/pi-agent-core@1.1.0
 License: MIT
 
-@earendil-works/pi-ai@0.86.1
+@earendil-works/pi-ai@1.1.0
 License: MIT
 
-@earendil-works/pi-coding-agent@0.86.1
+@earendil-works/pi-coding-agent@1.1.0
 License: MIT
 
-@earendil-works/pi-tui@0.86.1
+@earendil-works/pi-tui@1.1.0
 License: MIT
 
 @modelcontextprotocol/server@2.3.0

package/README.md

@@ -61,7 +61,7 @@ Three principles drive every design decision in AutoRAG Agent:
 
 AutoRAG Agent orchestrates five integrated subsystems:
 
-1. **Self-Evolving Memory System (`check_memory`):** Before querying, the agent consults historical outcomes stored in `~/.autorag/memory.json` to prioritize retrieval methods that have proven successful for similar queries.
+1. **Retrieval Memory (`check_memory`):** After each answer, cited evidence Jev judges to genuinely support it is stored in `~/.autorag/memory.json`. Later searches receive this conversation's evidence, similar past questions, and long-term insights as **advisory reference** — it never reorders results or overrides current evidence. See [docs/retrieval-memory.md](docs/retrieval-memory.md).
 2. **Pluggable Multi-Method Retrieval:**
    - **BM25 Lexical Search:** Fast keyword ranking via MinSync over parsed markdown mirrors.
    - **Semantic Vector Search:** Dense vector retrieval over CDC chunks via the built-in embedding gateway.
@@ -69,14 +69,14 @@ AutoRAG Agent orchestrates five integrated subsystems:
    - **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.
+   - **Datasource Skills:** Federated retrieval across every configured external datasource.
+3. **Result Merger & Scope Narrowing:** Cross-method deduplication, score normalization, and ordinary query-scope narrowing.
 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.
+5. **Curation:** Structured findings are returned via `emit_autorag_results`; cited evidence that Jev judges to genuinely support the answer is remembered as reference context for later searches ([docs/retrieval-memory.md](docs/retrieval-memory.md)).
 
 ### 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.
+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 orchestration, 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.
 
@@ -118,8 +118,8 @@ cp -R "$AUTORAG_SKILLS/autorag-lite-setup" .claude/skills/
 Run the setup skill once to register the stdio server with the host. Reload the
 agent, then discover the actual tool names and schemas with MCP `tools/list`.
 The normal Lite path is `autorag.status` → `autorag.refresh` when needed →
-`autorag.search`; use `autorag.report`, `autorag.evidence`, and
-`autorag.feedback` for the optional curation lifecycle. Copy `skills/autorag`
+`autorag.search`; use `autorag.report` and `autorag.evidence` for the optional
+curation lifecycle. Copy `skills/autorag`
 and `skills/autorag-setup` only when the agent should also drive the
 model-backed librarian, and `skills/autorag-doctor` for diagnostics. Other
 agents read their own skill directories; copy the same setup folder there and
@@ -166,10 +166,9 @@ hard-code a tool count.
 
 Core Lite tools include `autorag.status`, `autorag.search`,
 `autorag.search.files`, `autorag.datasources.list`, `autorag.datasources.get`,
-`autorag.refresh`, `autorag.report`, `autorag.evidence`, and
-`autorag.feedback`. Configured integrated datasources expose additional scoped
-search tools. Read-only MCP mode omits mutating tools such as refresh, report,
-and feedback.
+`autorag.refresh`, `autorag.report`, and `autorag.evidence`. Configured
+integrated datasources expose additional scoped search tools. Read-only MCP
+mode omits mutating tools such as refresh and report.
 
 ## ⚡ AutoRAG Lite: Model-Free Retrieval Engine
 
@@ -277,15 +276,59 @@ falling back to `["ko", "en"]`. Supported tags: `ko`, `en`, `ja`, `zh-hans`,
 | `.pptx` | built-in PPTX reader |
 | `.eml` | built-in mail reader |
 | `.txt` `.text` `.md` `.markdown` | plain text (CP949/EUC-KR aware) |
-| `.png` `.jpg` `.jpeg` `.bmp` `.tiff` `.webp` | image OCR (opt-in) |
+| `.png` `.jpg` `.jpeg` `.webp` | `kordoc` image OCR (only when `parserOptions.ocr.enabled` is `true`) |
 
-OCR is opt-in and never runs unless enabled, so indexing downloads no model by
-default. When enabled, `languages` selects the recognition languages
-(`ja` → `jpn`, `zh-hans` → `chi_sim`, …) for both standalone images and scanned
-PDF pages.
+`.bmp` and `.tiff` are not parsed: kordoc rejects both as unsupported.
+
+### Making photos and scans searchable
+
+Image files and scanned PDF pages become searchable through one switch,
+`parserOptions.ocr.enabled` (default `false`). It is off by default so indexing
+downloads no recognition model and never runs OCR over a photo library. With it
+off, image files are not parsed at all and scanned pages stay unrecognized.
+
+```json
+{ "languages": ["ko", "en"], "parserOptions": { "ocr": { "enabled": true } } }
+```
+
+`kordoc` owns both inputs. The configured `languages` pick the engine:
+
+| `languages` | Engine | First-use download |
+|---|---|---|
+| only `ko` and/or `en` | kordoc built-in PP-OCRv5 (local CPU) | ~18 MB from Hugging Face, cached in `~/.cache/kordoc/models` |
+| any other tag (`ja`, `zh-hans`, `fr`, `de`, …) | Tesseract, all configured languages at once (`kor+jpn`) | traineddata per language from the jsDelivr CDN, cached in `<workspace>/.autorag/models/tessdata` |
+
+The built-in model has no kana, han, Cyrillic, Thai, Arabic or Devanagari
+characters and drops diacritics in accented Latin text, so those languages need
+Tesseract. Set `parserOptions.ocr.cachePath` to store the Tesseract models
+elsewhere, or `KORDOC_OFFLINE=1` to block the built-in model download. An
+explicit `parserOptions.kordoc.ocr` overrides the language-based choice.
+
+Photos and videos are also reachable through two other paths that are not part
+of this switch: the `clawgallery` datasource (captions and visual search over its
+own folders) and Jikji's media index (`jikji.enableMediaIndex`, file facts such as
+pixel size and format only, no content). Video content is not searchable yet.
 
 ### 2. Search from CLI
 
+`autorag search` needs one chat model. `autorag init` does not pick one, so on
+first run either sign in and choose a model inside the TUI:
+
+```bash
+autorag tui      # then /login (OAuth or API key) and /model
+```
+
+or add the `model` entry to your existing AutoRAG config, preserving its other
+settings. Find provider/model ids with `autorag models list --available`:
+
+```json
+"model": { "provider": "<provider>", "id": "<id>" }
+```
+
+Then run `autorag health`. Do not re-run `autorag init --force` just to select
+a model: it replaces the existing config, including datasource and parser settings.
+Configure the provider's credentials through `/login` or its supported environment variables.
+
 ```bash
 # Perform a curated search (uses your configured reasoning model)
 autorag search "What are our primary Q3 deliverables?"
@@ -312,9 +355,6 @@ for (const result of response.results) {
   console.log(`[${result.number}] ${result.title} (${result.source})`);
   console.log(`    ${result.summary}`);
 }
-
-// Record feedback: Result [1] was useful, [2] was not
-agent.recordFeedbackByNumbers(response.sessionId, [1], [2]);
 ```
 
 ---
@@ -333,7 +373,7 @@ agent.recordFeedbackByNumbers(response.sessionId, [1], [2]);
 | `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 ...` | CLI bootstrap, indexing repair, terminal maintenance, and fallback interface; agents use MCP for normal Lite operation |
-| `autorag feedback <session>` | Record numbered feedback; MCP clients normally use `autorag.feedback`, and the CLI stays available for terminal maintenance |
+| `autorag memory inspect` | Render a read-only, path-opaque snapshot of retrieval memory (judged evidence, curated results, evidence chunks, insights); model-free |
 | `autorag evidence <session>` | Inspect persisted evidence behind numbered results; MCP clients normally use `autorag.evidence`, and the CLI stays available for terminal maintenance |
 | `autorag serve` | Start the P2P query server over SimpleX (opt-in) |
 | `autorag p2p ...` | Manage peer trust, query approvals, and sharing policies |
@@ -347,7 +387,7 @@ Deep dive into AutoRAG Agent's architecture, security, and integration guides:
 - **[MinSync Setup & Embedding QA](docs/minsync-setup.md):** Automatic binary installation, CDC chunking, and EmbeddingGemma verification.
 - **[Local Embedding Runtime & Gateway](docs/embedding-runtime.md):** AutoRAG-owned local gateway, model prefetching, and zero-egress semantic search. Model cards: [`qwen3-embedding-0.6b`](docs/model-cards/qwen3-embedding-0.6b.md), [`embeddinggemma-300m`](docs/model-cards/embeddinggemma-300m.md).
 - **[Datasource Skills Reference](docs/datasource-skills.md):** Full configuration contracts, connection aliases, and connector options.
-- **[Jev Decisions](docs/jev-decisions.md):** Jev query pipeline, **on by default** via OpenRouter: it routes each question to local search, web search, or a direct answer, splits multi-part questions into up to five parallel searches (`openrouter/qwen/qwen3.7-flash`), and ends the run after the fast answer when that answer is complete. Also covers the `jev` judgment tool, backends (OpenRouter, TypeSafe, Vercel AI Gateway), and how to opt out.
+- **[Jev Decisions](docs/jev-decisions.md):** Jev query pipeline, **on by default** via OpenRouter: it routes each question to a direct answer (intrinsic knowledge) or local search (everything needing more information; web search is left to the agent after the fast answer), splits multi-part questions into up to five parallel searches (`openrouter/qwen/qwen3.7-flash`), picks which registered datasources to search before the fast answer, and ends the run after the fast answer when that answer is complete. Also covers the `jev` judgment tool, backends (OpenRouter, TypeSafe, Vercel AI Gateway), and how to opt out.
 - **[Manual QA & Datasource Test Harnesses](docs/manual-qa-datasources.md):** Real-world testing guides for Discord, KakaoTalk, Slack, Notion, and email.
 - **[P2P SimpleX Sharing & Path Standard](docs/p2p-path-standard.md):** Decentralized peer query sharing with SimpleX, PII redaction, and approval queues.
 - **[Supply Chain Security & License Audits](docs/supply-chain.md):** Software bill of materials (SBOM) and dependency gate policies.
@@ -400,7 +440,7 @@ itself through the connected Lite MCP server:
 autorag.status {}
 autorag.refresh {}
 autorag.search {"query":"a word that certainly appears","topK":3}
-autorag.search {"query":"recent topic","tags":["discord"],"topK":3}
+autorag.search {"query":"recent topic","scope":"/discord/local/**","topK":3}
 ```
 
 The CLI equivalents remain available for terminal repair, but do not use them
@@ -413,9 +453,10 @@ Common failures and their fix:
 | Results are missing recent files | `stale-index` | `autorag refresh --method parsed,minsync --json` |
 | Semantic search returns nothing after changing the embedder | `embedding-identity-mismatch` | `autorag index rebuild --method minsync` |
 | Gateway will not start, a previous run was killed | `lock-conflict` | `autorag gateway stop`, then retry |
-| A datasource is healthy in its own CLI but absent from results | — | add its tag/scope to `datasourceAccess` |
+| A datasource is healthy in its own CLI but absent from results | — | confirm it is configured under `datasources` and connected through its native CLI |
 | 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 |
+| MinSync binary missing (search and refresh fail with `MinSync is required ...`) | — | `cargo install minsync`, or leave `minSync.autoInstall` on and re-run refresh |
+| Jikji missing | `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` |
 | Every search does a full local search and verification, even for small talk | `query-route-fallback` | set `OPENROUTER_API_KEY` (Jev routing and decomposition are on by default) |
 

package/dist/agent/agent.d.ts

@@ -1,13 +1,12 @@
-import type { Agent, AgentTool, Skill } from "@earendil-works/pi-agent-core";
+import type { Agent, AgentTool } 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 Embedder } from "../embedding-runtime/gateway-embedder.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";
 import { type MinSyncSyncResult, type MinSyncVectorMethodOptions } from "../minsync/index.js";
 import { type ParsedMirrorSyncResult } from "../mirror/sync.js";
 import type { PolicyResolver } from "../p2p/policy-filter.js";
@@ -19,14 +18,15 @@ 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 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";
-import { type QueryRoute } from "./query-routing.js";
 import { type RefreshProgressCounts, type RefreshProgressPhase } from "./refresh-progress.js";
 import { type SearchDocumentDiagnostic, type SearchDocumentsResponse, type SearchDocumentsStreamEvent } from "./search-documents.js";
+import { type SelfConfigOptions } from "./self-config.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";
@@ -190,7 +190,7 @@ export interface AutoRAGAgentOptions {
     memoryPath?: string;
     workspacePath?: string;
     tools?: AgentTool[];
-    minSync?: Omit<MinSyncVectorMethodOptions, "root"> | false;
+    minSync?: Omit<MinSyncVectorMethodOptions, "root">;
     jikji?: JikjiOptions | false;
     /**
      * Windows-only instant file/folder name search through the bundled
@@ -237,8 +237,8 @@ export interface AutoRAGAgentOptions {
     /**
      * Jev (TypeSafe's judgment model: typed questions in, calibrated
      * probabilities out). When set, the two-phase search asks Jev before the
-     * fast answer whether the question needs local search, web search, or a
-     * direct answer, and whether to decompose it; after the fast answer, whether
+     * fast answer whether the question is answerable from intrinsic knowledge
+     * (direct answer) or needs local search, and whether to decompose it; after the fast answer, whether
      * verification is needed. It also exposes the `jev` tool. Always omitted for
      * remote P2P sessions.
      *
@@ -247,6 +247,20 @@ export interface AutoRAGAgentOptions {
      * off, so library callers never make paid network calls they did not ask for.
      */
     jev?: JevToolOptions | false;
+    /**
+     * Embedder used to find similar past questions in memory (semantic half of
+     * the hybrid search). Defaults to the local embedding gateway; `false` keeps
+     * memory search keyword-only.
+     */
+    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.
+     */
+    selfConfig?: SelfConfigOptions;
     /**
      * Question decomposition used by the Jev query pipeline. `model` (with its
      * `apiKey`) is the LLM that splits one question into at most five search
@@ -266,7 +280,6 @@ export interface AutoRAGAgentOptions {
      */
     limits?: AutoRAGRetrievalLimits;
     datasourceSkills?: readonly DatasourceSkill[];
-    datasourceAccess?: DatasourceAccessContextOptions;
     /** Non-fatal diagnostics from config/agent construction (e.g. skipped unknown datasources). */
     startupDiagnostics?: readonly SearchDocumentDiagnostic[];
     /** Maximum time a model/tool search may run before it is aborted. */
@@ -349,6 +362,8 @@ export declare class AutoRAGAgent {
     private interactiveFastAnswerCallback;
     private modelNativeSearchAuth;
     private retrievalTrace;
+    /** Evidence every retrieval tool returned this run; emit tools resolve model-cited ids against it. */
+    private readonly evidenceLedger;
     private preliminaryCallback;
     /** Per-phase thinking levels of the two-phase search. */
     private readonly fastThinkingLevel;
@@ -367,13 +382,11 @@ export declare class AutoRAGAgent {
     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;
     private readonly datasourceAgentSkills;
     private readonly parserOptions;
@@ -382,8 +395,10 @@ export declare class AutoRAGAgent {
     private readonly jevExtension;
     /** Jev judge shared by the `jev` tool and the query router; undefined when disabled. */
     private readonly jevJudge;
+    /** Self-configuration, enabled only with Jev on a local session. */
+    private readonly selfConfig;
     private readonly queryDecompositionModel;
-    /** Web search routing for the pipeline's web branch; undefined when web tools are off. */
+    /** Web search options for the agent's `web_search` / `web_fetch` tools; undefined when web tools are off. */
     private readonly webSearchOptions;
     /** Routing diagnostics for the in-flight search; reset per run. */
     private routingDiagnostics;
@@ -398,6 +413,17 @@ export declare class AutoRAGAgent {
     private readonly persistPiSessions;
     private readonly updateNotice;
     private boundPiRuntime;
+    /** Embeds past questions for similar-question search; undefined keeps memory search keyword-only. */
+    private readonly memoryEmbedder;
+    private readonly memoryVectorPath;
+    /** Every retrieval result of the in-flight run with the query/method that surfaced it. */
+    private readonly evidenceOrigins;
+    /** Search-tool queries by tool call id, read back when the call ends. */
+    private readonly searchToolQueries;
+    /** Identifies this agent's conversation: everything judged in it is "current" memory. */
+    private readonly conversationId;
+    /** The memory context loaded for the in-flight run; cleared whenever a run starts. */
+    private memoryContextCache;
     /** True when this agent was constructed for an untrusted remote peer. */
     readonly remoteSession: boolean;
     private activeRetrievalOptions;
@@ -405,7 +431,42 @@ export declare class AutoRAGAgent {
     private readonly limits;
     constructor(options: AutoRAGAgentOptions);
     scanDuplicateDocuments(): Promise<ScanDuplicateDocumentsDetails>;
+    /**
+     * Reference memory for the current question: everything judged earlier in
+     * this conversation, up to 25 similar past questions, and matching
+     * long-term insights. Computed once per run (the datasource check and every
+     * model turn share it) so the similar-question search and its embedder call
+     * are not repeated and a fallback is reported once. Remote peers never read it.
+     */
+    private loadMemoryContextFor;
     private withMemoryContext;
+    /**
+     * Where evidence came from, or undefined when this run may not see it.
+     * Datasource chunks carry a virtual path rooted at the skill name
+     * (`/kakao/default/...`), but the model sometimes maps a datasource hit to a
+     * bare chunk id. The evidence method then still names the datasource
+     * (`search_datasource_kakao_work`, `datasource:kakao`, `kakao-work-lexical`):
+     * both sides collapse every non-alphanumeric to `_` exactly like generated
+     * tool names, and a datasource id that appears as a whole token attributes
+     * it; longer ids are checked first so `kakao-work` wins over `kakao`.
+     * Indexed files are absolute paths under a search path; web evidence is a URL.
+     * Memory is global (shared across workspaces and configs), so evidence from
+     * an unconfigured datasource, and evidence with no recognizable origin, is
+     * never attributed.
+     */
+    private evidenceAttribution;
+    /** Options shared by the prompt injection and the `check_memory` tool; rebuilt on every call because datasource configuration follows live settings. */
+    private memoryContextOptions;
+    /** Remember which query and method surfaced each retrieval result, so cited evidence can be traced back. */
+    private rememberEvidenceOrigins;
+    /**
+     * After the final answer: map every cited evidence back to the search query
+     * and method that found it, ask Jev (one batched call, evidence judged in
+     * parallel) whether it really supports the answer sentence it backs, and
+     * keep only what clears the threshold. Remote peers and runs without Jev
+     * store nothing; a failed judgment stores nothing and says why.
+     */
+    private recordJudgedEvidence;
     private resolveSessionModel;
     private createSearchSession;
     private configureSearchSession;
@@ -425,10 +486,6 @@ export declare class AutoRAGAgent {
     }): void;
     stopAutoRefresh(): void;
     private runAutoRefreshTick;
-    submitFeedback(sessionId: string | undefined, satisfied: boolean): void;
-    recordResultFeedback(feedback: ResultFeedback[]): void;
-    recordFeedbackByNumbers(sessionId: string, usefulNumbers: number[], notUsefulNumbers?: number[]): void;
-    recordFeedbackByIds(usefulFeedbackIds: readonly string[], notUsefulFeedbackIds?: readonly string[]): void;
     getResultRegistry(sessionId?: string): ReadonlyMap<number, CuratedResult>;
     searchDocuments(query: string, options?: RetrievalOptions): Promise<SearchDocumentsResponse>;
     /**
@@ -438,43 +495,36 @@ export declare class AutoRAGAgent {
      * stop by calling {@link abort}.
      */
     searchDocumentsStream(query: string, options?: RetrievalOptions): AsyncGenerator<SearchDocumentsStreamEvent, void, void>;
-    private datasourceAccessContext;
     /**
-     * Build the Pi agent-skill list for datasource skills authorized by the
-     * trusted, server-bound access context. Only authorized skills become
-     * model-visible; unauthorized skills are omitted entirely (default-deny).
+     * Build the Pi agent-skill list for every configured datasource skill. All
+     * configured skills are model-visible; a connection is removed from the
+     * model surface by removing it from the config, not by a permission layer.
      */
-    private buildAuthorizedDatasourceSkills;
+    private buildDatasourceAgentSkills;
     /**
      * Per-connection tool specs for the generated `search_datasource_<id>`
-     * tools, built from the same trusted config and access context as
-     * {@link buildAuthorizedDatasourceSkills}. One spec per authorized
-     * datasource skill; duplicate ids collapse to the first registration.
+     * tools, one per configured datasource skill; duplicate ids collapse to the
+     * first registration.
      */
     private singleDatasourceToolSpecs;
     /**
-     * Authorized configured datasource descriptors for catalog/listing surfaces.
-     *
-     * Built from the same trusted, server-bound access context as
-     * {@link buildAuthorizedDatasourceSkills}: only tag-authorized datasources
-     * are listed — including ones that expose no retrieval methods — and each
-     * entry carries only identity, capability tags, and authorized source scope
-     * strings (never credentials, config paths, or raw instance metadata).
-     * Duplicate datasource ids collapse to the first registration.
+     * Configured datasource descriptors for catalog/listing surfaces: every
+     * configured datasource is listed — including ones that expose no retrieval
+     * methods — and each entry carries only identity, capability tags, and
+     * source scope strings (never credentials, config paths, or raw instance
+     * metadata). Duplicate datasource ids collapse to the first registration.
      */
     listDatasources(): DatasourceCatalogEntry[];
     /**
-     * Opaque source scope strings for one datasource that the trusted context
-     * authorizes. Datasources without the `scoped` capability expose their
-     * sources unfiltered (they are gated only at the tag level).
+     * Opaque source scope strings for one datasource. Sources containing a `#`
+     * fragment are invalid and skipped.
      */
-    private authorizedSourceScopes;
+    private datasourceSourceScopes;
     /**
-     * Resolve an authorized datasource agent skill by model-visible name for the
-     * `load_datasource_skill` tool. Returns `undefined` for unknown or
-     * unauthorized names — model/tool input can never widen authorization.
+     * Resolve a configured datasource agent skill by model-visible name for the
+     * `load_datasource_skill` tool. Returns `undefined` for unknown names.
      */
-    loadDatasourceSkill(name: string): Skill | undefined;
+    loadDatasourceSkill(name: string): DatasourceAgentSkill | undefined;
     private indexDatasources;
     /** Path-opaque component diagnostics for the search response. */
     private collectComponentDiagnostics;
@@ -487,30 +537,39 @@ export declare class AutoRAGAgent {
     private shouldFollowUp;
     /**
      * Jev query pipeline, run before the fast answer. Jev picks the branch
-     * (local search, web search, or a direct answer) and whether the question
+     * (direct answer or local search) and whether the question
      * needs decomposition; a "yes" splits it into at most five search queries
-     * with the configured decomposition model (default: the session model).
-     * Without Jev, and on any routing failure, this is today's single local
-     * search for the original question.
+     * with the configured decomposition model (default: the session model). On
+     * the local branch, Jev also judges, per registered datasource, whether it
+     * must be searched (in parallel with decomposition). Without Jev, and on any
+     * routing failure, this is today's single local search for the original
+     * question with no datasource search.
      */
     private planQuery;
     /**
-     * Baseline local evidence for the fast answer. Jikji and MinSync run for
-     * every search query in parallel (MinSync itself queues per workspace), the
-     * per-query hits are interleaved and deduplicated into one pool, and that
-     * pool is reranked against the original question.
+     * Jev datasource check for the local branch: one `noul` per configured
+     * datasource that has retrieval methods, with where similar past questions
+     * were answered (from retrieval memory) in the state. Returns the ids to
+     * search with every query before the rerank; a failed check searches none.
+     */
+    private selectSearchDatasources;
+    /**
+     * Baseline local evidence for the fast answer. Jikji, MinSync, and every
+     * Jev-selected datasource run for every search query in parallel (MinSync
+     * itself queues per workspace), the per-query hits are interleaved and
+     * deduplicated into one pool, and that pool is reranked against the
+     * original question.
      */
     private prefetchInitialRetrievalContext;
-    /** Baseline web evidence for the fast answer: one web search per query, all in parallel. */
-    private prefetchWebContext;
     /**
-     * Rerank the pre-fast-answer baseline pool — Jikji answer paths plus MinSync
-     * chunks — down to the configured `rerank.topN`. With decomposition the pool
-     * merges every search query's hits (interleaved), capped at the same
-     * per-source sizes as a single query so the rerank request does not grow
-     * with the query count. Returns `undefined` when reranking is
-     * disabled/unavailable or the pool is empty, so the caller keeps the
-     * unranked sections; a rerank failure never blocks the fast answer.
+     * Rerank the pre-fast-answer baseline pool — Jikji answer paths, MinSync
+     * chunks, and Jev-selected datasource chunks — down to the configured
+     * `rerank.topN`. With decomposition the pool merges every search query's
+     * hits (interleaved), capped at the same per-source sizes as a single query
+     * so the rerank request does not grow with the query count. Returns
+     * `undefined` when reranking is disabled/unavailable or the pool is empty,
+     * so the caller keeps the unranked sections; a rerank failure never blocks
+     * the fast answer.
      */
     private rerankPrefetchPool;
     /**
@@ -527,13 +586,19 @@ export declare class AutoRAGAgent {
     buildDirectAnswerPrompt(query: string): string;
     /** Discovery-tool hint naming only the registered discovery tools; empty when none. */
     private discoveryHint;
+    /**
+     * Verification-phase nudge toward the internet. Jev no longer routes to web
+     * search, so the agent decides after the fast answer: when local evidence is
+     * missing, thin, or possibly stale, it searches the web. Empty when web tools are off.
+     */
+    private webFallbackHint;
     /**
      * 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: AutoRAGFastAnswerDetails | undefined, fastAnswerDelivered: boolean, route?: QueryRoute): 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>;
     /**
@@ -571,7 +636,7 @@ export declare class AutoRAGAgent {
      */
     private scanMirrorStaleness;
     private exactDuplicateExclusions;
-    syncMinSync(force?: boolean): Promise<MinSyncSyncResult | undefined>;
+    syncMinSync(force?: boolean): Promise<MinSyncSyncResult>;
     /** Provider for the Windows-only everything_search tool. */
     searchEverything(request: EverythingSearchRequest): Promise<EverythingSearchResult>;
     /**
@@ -660,10 +725,9 @@ export declare class AutoRAGAgent {
      * Search one datasource connection only. Only the target connection's
      * retrieval methods are registered with the retriever, so no other
      * datasource CLI is spawned at all and only that connection's hits are
-     * returned. Access is still gated by the trusted datasource context: an
-     * unknown or unauthorized `datasourceId` yields an empty result set.
+     * returned. An unknown `datasourceId` yields an empty result set.
      *
-     * This backs the generated `search_datasource_<id>` tools; every authorized
+     * This backs the generated `search_datasource_<id>` tools; every configured
      * connection has one. Cross-datasource fan-out is
      * {@link searchAllDocuments}, which spans every retrieval method.
      */
@@ -679,7 +743,7 @@ export declare class AutoRAGAgent {
     /**
      * The standalone retrieval engine for this agent's method pipeline.
      * Built on first access using the agent's registered methods and configured
-     * datasource access context. Model-free — no agent state required.
+     * datasource catalog. Model-free — no agent state required.
      */
     private retrievalEngine;
     getRetrievalEngine(): RetrievalEngine;
@@ -690,7 +754,6 @@ export declare class AutoRAGAgent {
      * the merged order is preserved — a reranker outage never hides evidence.
      */
     private applyRerank;
-    private rerankWithMemory;
     private remoteFilteredRetrievalMethod;
     private normalizeRetrievalOptions;
     private resolveRetrievalScope;

package/dist/agent/citations.d.ts

@@ -10,6 +10,29 @@ 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