@autorag/librarian 2.6.3 → 2.8.0

package/dist/mcp/server.d.ts

@@ -0,0 +1,9 @@
+import { McpServer } from "@modelcontextprotocol/server";
+import type { AutoRAGLite } from "../core.js";
+export interface AutoRAGMcpServerOptions {
+    readonly readOnly?: boolean;
+    readonly tools?: readonly string[];
+    /** Test/embedded override; defaults to the current Node platform. */
+    readonly platform?: NodeJS.Platform;
+}
+export declare function createAutoRAGMcpServer(lite: AutoRAGLite, options?: AutoRAGMcpServerOptions): McpServer;

package/dist/minsync/method.d.ts

@@ -32,7 +32,6 @@ export declare class MinSyncVectorMethod implements RetrievalMethod {
     private readonly runtime;
     private readonly defaultTopK;
     private readonly scopedTopK;
-    private installFailed;
     constructor(options: MinSyncVectorMethodOptions);
     describe(): RetrievalMethodDescriptor;
     sync(force?: boolean): Promise<MinSyncSyncResult>;
@@ -47,12 +46,16 @@ export declare class MinSyncVectorMethod implements RetrievalMethod {
     private retrieveUnlocked;
     /**
      * Resolve the MinSync CLI from the user's global PATH first, then the
-     * workspace cache, and finally the verified auto-install fallback.
+     * workspace cache, and finally the verified auto-install fallback. The
+     * auto-install runs only for `sync` (refresh); queries pass
+     * `install: false` so a user's turn never waits on `cargo install`.
      *
      * Returns: string path on success, undefined for missing-binary, or a MinSyncSyncResult
      * for install-failed.
      */
-    protected resolveBinary(): Promise<string | undefined | MinSyncSyncResult>;
+    protected resolveBinary(options?: {
+        readonly install?: boolean;
+    }): Promise<string | undefined | MinSyncSyncResult>;
 }
 export declare class MinSyncHybridMethod extends MinSyncVectorMethod {
     constructor(options: MinSyncHybridMethodOptions);

package/dist/mirror/index.d.ts

@@ -1,5 +1,5 @@
 export type { ParsedMirrorEntry, ParsedMirrorIndex } from "./index-store.js";
 export { emptyMirrorIndex, loadMirrorIndex, saveMirrorIndex } from "./index-store.js";
-export { parsedMirrorIndexPath, parsedMirrorRoot, parsedOutputPath, refreshReadinessPath } from "./paths.js";
+export { isParsedRefreshComplete, parsedMirrorIndexPath, parsedMirrorRoot, parsedOutputPath, refreshReadinessPath, } from "./paths.js";
 export type { ParsedMirrorDiagnostic, ParsedMirrorDiagnosticCode, ParsedMirrorSyncOptions, ParsedMirrorSyncResult, } from "./sync.js";
 export { DEFAULT_MAX_SOURCE_BYTES, detectMirrorStaleness, isPathExcluded, syncParsedMirrors } from "./sync.js";

package/dist/mirror/paths.d.ts

@@ -8,3 +8,9 @@ export declare function parsedMirrorIndexPath(root: string): string;
 export declare function parsedOutputPath(root: string, virtualPath: string): string;
 export declare function refreshReadinessPath(root: string): string;
 export declare function refreshProgressPath(root: string): string;
+/**
+ * Whether a parsed-mirror refresh has completed at least once for the given
+ * workspace. Reads the persisted readiness marker so a separate process (CLI,
+ * MCP server) reaches the same verdict as the process that ran the refresh.
+ */
+export declare function isParsedRefreshComplete(workspacePath: string): boolean;

package/dist/retrieval/engine.d.ts

@@ -15,7 +15,8 @@
  */
 import { DatasourceAccessContext, type DatasourceAccessContextOptions } from "../datasource/access-context.js";
 import { RetrievalMethodRegistry } from "./registry.js";
-import type { Reranker } from "./rerank.js";
+import { type Reranker } from "./rerank.js";
+import { type RetrievalSelection } from "./selection.js";
 import type { RetrievalDiagnostic, RetrievalMethod, RetrievalOptions, RetrievalResult, RetrievalUnsearchedSurface } from "./types.js";
 /** Options for constructing a standalone {@link RetrievalEngine}. */
 export interface RetrievalEngineOptions {
@@ -41,6 +42,14 @@ export interface RetrievalEngineOptions {
      * preservation — matching the existing {@link AutoRAGAgent} behavior.
      */
     readonly isMinSyncBinaryMissing?: () => boolean;
+    /**
+     * Authorized datasource ids from the skill catalog, including datasources
+     * that expose no retrieval methods. {@link retrieveSelected} uses this to
+     * tell an unknown datasource id from an unauthorized one. When omitted, the
+     * engine derives ids from its authorized registered methods; method-less
+     * datasources are then treated as unknown.
+     */
+    readonly authorizedDatasourceIds?: () => readonly string[];
     /**
      * Optional post-merge reranker. When set, merged results are reordered by
      * the reranker after dedup and score normalization. A reranker failure is
@@ -48,6 +57,11 @@ export interface RetrievalEngineOptions {
      * the engine never silently drops evidence because a reranker was down.
      */
     readonly reranker?: Reranker;
+    /**
+     * Number of merged results kept after reranking when the caller omits `topK`.
+     * Only applies when {@link reranker} is set. @default DEFAULT_RERANK_TOP_N
+     */
+    readonly rerankTopN?: number;
 }
 /**
  * Model-free retrieval pipeline.
@@ -79,7 +93,9 @@ export declare class RetrievalEngine {
     private readonly defaultTopK;
     private readonly defaultDedup;
     private readonly isMinSyncBinaryMissing;
+    private readonly authorizedDatasourceIdsProvider;
     private readonly reranker;
+    private readonly rerankTopN;
     constructor(options?: RetrievalEngineOptions);
     /** The underlying method registry. Intentionally public for tooling. */
     getMethodRegistry(): RetrievalMethodRegistry;
@@ -124,6 +140,21 @@ export declare class RetrievalEngine {
         diagnostics: RetrievalDiagnostic[];
         unsearched: RetrievalUnsearchedSurface[];
     }>;
+    /**
+     * Run a selected subset of the registered methods — parallel retrieve,
+     * datasource filter, merge — and return merged results with diagnostics.
+     *
+     * Unlike {@link retrieve}, selection happens BEFORE any backend is invoked:
+     * the eligible method list is reduced first, so an unselected or
+     * unauthorized datasource backend is never spawned. Unknown or unauthorized
+     * method/datasource selections throw {@link RetrievalSelectionError}. The
+     * trusted access context still narrows results/tags/scopes after retrieval.
+     */
+    retrieveSelected(query: string, selection?: RetrievalSelection, options?: RetrievalOptions): Promise<{
+        results: RetrievalResult[];
+        diagnostics: RetrievalDiagnostic[];
+        unsearched: RetrievalUnsearchedSurface[];
+    }>;
     /**
      * Post-check for MinSync binary-missing diagnostic.
      *

package/dist/retrieval/index.d.ts

@@ -2,7 +2,8 @@ export { RetrievalEngine, type RetrievalEngineOptions } from "./engine.js";
 export type { MergeOptions } from "./merger.js";
 export { ParallelRetriever, ResultMerger } from "./merger.js";
 export { RetrievalMethodRegistry } from "./registry.js";
-export { type CreateRerankerOptions, createReranker, DEFAULT_RERANK_API_KEY_ENV, DEFAULT_RERANK_MODEL, DEFAULT_RERANK_PROVIDER, OpenRouterReranker, type OpenRouterRerankerOptions, type Reranker, type RerankerDescriptor, type RerankOptions, } from "./rerank.js";
+export { type CreateRerankerOptions, createReranker, DEFAULT_RERANK_API_KEY_ENV, DEFAULT_RERANK_MODEL, DEFAULT_RERANK_PROVIDER, DEFAULT_RERANK_TOP_N, OpenRouterReranker, type OpenRouterRerankerOptions, type Reranker, type RerankerDescriptor, type RerankOptions, SUPPORTED_RERANK_PROVIDERS, } from "./rerank.js";
 export { matchesVirtualPathScope, normalizeVirtualPath, normalizeVirtualPathScope, virtualPathScopeToRegExp, } from "./scope.js";
+export { type DatasourceCatalogEntry, derivedAuthorizedDatasourceIds, type RetrievalSelection, RetrievalSelectionError, type RetrievalSelectionErrorCode, resolveSelectedMethods, } from "./selection.js";
 export { describeRetrievalError, groupUnsearchedSurfaces, MINSYNC_SURFACE, type RetrievalSkip, retrievalSurfaceFor, } from "./skip.js";
 export type { CuratedResult, NumberedResult, RetrievalDiagnostic, RetrievalDiagnosticCode, RetrievalMethod, RetrievalMethodDescriptor, RetrievalOptions, RetrievalResult, RetrievalUnsearchedSurface, RetrievalWithDiagnostics, } from "./types.js";

package/dist/retrieval/rerank.d.ts

@@ -18,6 +18,10 @@ export declare const DEFAULT_RERANK_MODEL = "voyageai/rerank-3-lite";
 export declare const DEFAULT_RERANK_PROVIDER = "openrouter";
 /** Default environment variable holding the OpenRouter API key. */
 export declare const DEFAULT_RERANK_API_KEY_ENV = "OPENROUTER_API_KEY";
+/** Default number of merged chunks kept after reranking. */
+export declare const DEFAULT_RERANK_TOP_N = 25;
+/** Rerank providers {@link createReranker} can build. */
+export declare const SUPPORTED_RERANK_PROVIDERS: readonly string[];
 /** Static description of a reranker, used for diagnostics and inspection. */
 export interface RerankerDescriptor {
     /** Stable label (e.g. `openrouter`). */
@@ -57,6 +61,8 @@ export interface RerankClient {
             documents: string[];
             topN?: number;
         };
+    }, options?: {
+        signal?: AbortSignal;
     }): Promise<RerankResponse>;
 }
 /** Response body returned by OpenRouter's rerank router. */
@@ -92,9 +98,8 @@ export interface CreateRerankerOptions extends OpenRouterRerankerOptions {
 }
 /**
  * Build the configured reranker. Returns `undefined` when reranking is disabled
- * or absent, or when the provider is unsupported. Provider-agnostic by design:
- * a local reranker implements {@link Reranker} and plugs in here without
- * touching the retrieval pipeline.
+ * or absent. Throws for a provider AutoRAG cannot build (an unsupported
+ * `provider` id is a configuration error, not a silent no-op).
  */
 export declare function createReranker(config: CreateRerankerOptions | false | undefined): Reranker | undefined;
 /**

package/dist/retrieval/selection.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Selection gating for the retrieval pipeline.
+ *
+ * `searchSelected` lets a caller narrow a search to specific datasources,
+ * specific methods, or the local (non-datasource) surfaces *before* any backend
+ * is invoked. This module owns that narrowing so the engine can reuse its
+ * existing parallel-retrieve / datasource-filter / merge chain on the reduced
+ * method list instead of fanning out to every backend and filtering afterwards.
+ *
+ * Security invariants:
+ *  - Unauthorized datasource methods are never selected, whether or not the
+ *    caller passed a selection — an unselected search still excludes them, so
+ *    no denied backend is executed.
+ *  - A caller-supplied selection can only *narrow* the trusted method set; it
+ *    can never widen it. Unknown or unauthorized method/datasource names are
+ *    rejected with a typed error, never silently resolved.
+ *  - The trusted {@link DatasourceAccessContext} remains the sole authority:
+ *    the `authorizedDatasourceIds` catalog is itself built from that context.
+ */
+import type { DatasourceAccessContext } from "../datasource/access-context.js";
+import type { RetrievalMethod } from "./types.js";
+/**
+ * Model-free, credential-free descriptor of one authorized configured
+ * datasource, for catalog/listing surfaces. Carries no credentials, config
+ * paths, or raw instance metadata — only the identity, capability tags, and
+ * the opaque source scope strings the access context authorizes.
+ */
+export interface DatasourceCatalogEntry {
+    /** Stable datasource id, e.g. `"kakao"`. */
+    readonly datasourceId: string;
+    /** Skill name, e.g. `"kakao"`. */
+    readonly name: string;
+    /** Skill kind, e.g. `"chat"` or `"chat-export"`. */
+    readonly type: string;
+    /** Human-readable description. */
+    readonly description: string;
+    /** Authorization tags that made this datasource accessible. */
+    readonly tags: readonly string[];
+    /** Capability names such as `"keyword"`, `"scoped"`, `"polling"`. */
+    readonly capabilities: readonly string[];
+    readonly status: "active" | "stub";
+    /**
+     * Authorized slash-hierarchical source scope strings discovered for this
+     * datasource. Scope-capable datasources expose only sources allowed by the
+     * trusted scope predicate; unscoped datasources expose their opaque sources.
+     */
+    readonly sourceScopes: readonly string[];
+}
+/**
+ * Caller request narrowing which retrieval methods run.
+ *
+ * Semantics (unambiguous, deny-widening):
+ *  - `datasourceIds` omitted ⇒ every authorized datasource method is eligible.
+ *  - `datasourceIds` present ⇒ ONLY methods of those datasources are eligible,
+ *    plus the local (non-datasource) methods only when `local === true`.
+ *  - `local === false` ⇒ no local method is ever eligible.
+ *  - `methods` present ⇒ intersected with the eligible set; every named method
+ *    must exist and (for datasource methods) be authorized.
+ */
+export interface RetrievalSelection {
+    /** Datasource ids to run. Omit to run all authorized datasources. */
+    readonly datasourceIds?: readonly string[];
+    /** Method names to run, intersected with the datasource/local selection. */
+    readonly methods?: readonly string[];
+    /** Whether local (non-datasource) methods run. See the semantics above. */
+    readonly local?: boolean;
+}
+export type RetrievalSelectionErrorCode = "unknown-method" | "unauthorized-method" | "unknown-datasource" | "unauthorized-datasource";
+/** Thrown when a caller selection names an unknown or unauthorized target. */
+export declare class RetrievalSelectionError extends Error {
+    readonly code: RetrievalSelectionErrorCode;
+    constructor(code: RetrievalSelectionErrorCode, message: string);
+}
+/**
+ * Reduce the registered methods to the ones a selection authorizes to run.
+ *
+ * The returned list is built entirely from `methods`; a caller cannot conjure a
+ * method that is not registered. Datasource methods denied by `ctx` are dropped
+ * from the eligible set unconditionally, so they are never invoked. Explicit
+ * selections that name an unknown method or an unauthorized/unknown datasource
+ * throw {@link RetrievalSelectionError} rather than degrading silently.
+ *
+ * @param methods    Every registered retrieval method.
+ * @param ctx        Trusted, server-supplied access context.
+ * @param selection  Caller narrowing request.
+ * @param authorizedDatasourceIds Authorized datasource ids from the catalog;
+ *   used to distinguish an unknown id from an unauthorized one. Method-less
+ *   authorized datasources belong here and select cleanly (yielding nothing).
+ */
+export declare function resolveSelectedMethods(methods: readonly RetrievalMethod[], ctx: DatasourceAccessContext, selection: RetrievalSelection, authorizedDatasourceIds: readonly string[]): RetrievalMethod[];
+/**
+ * Authorized datasource ids derived directly from a method set and access
+ * context. Used as the fallback catalog for a standalone engine that has no
+ * datasource-skill catalog wired in; method-less datasources are unknowable
+ * here and therefore treated as unknown.
+ */
+export declare function derivedAuthorizedDatasourceIds(methods: readonly RetrievalMethod[], ctx: DatasourceAccessContext): string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autorag/librarian",
-  "version": "2.6.3",
+  "version": "2.8.0",
   "description": "Self-evolving librarian agent on Pi framework with pluggable retrieval methods",
   "license": "MIT",
   "repository": {
@@ -21,7 +21,8 @@
     }
   },
   "bin": {
-    "autorag": "dist/cli/index.js"
+    "autorag": "dist/cli/index.js",
+    "autorag-mcp": "dist/mcp/index.js"
   },
   "files": [
     "dist",
@@ -35,7 +36,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "bun build src/index.ts src/core.ts src/cli/index.ts --outdir dist --target node --packages external && tsc -p tsconfig.build.json && node scripts/fixup-dts.mjs",
+    "build": "bun build src/index.ts src/core.ts src/cli/index.ts src/mcp/index.ts --outdir dist --target node --packages external && tsc -p tsconfig.build.json && node scripts/fixup-dts.mjs",
     "prepublishOnly": "bun run typecheck && bun run build",
     "prepare": "bun run build",
     "test": "node scripts/run-test-files.mjs",
@@ -54,10 +55,12 @@
     "@earendil-works/pi-ai": "^0.86.1",
     "@earendil-works/pi-coding-agent": "0.86.1",
     "@earendil-works/pi-tui": "0.86.1",
+    "@modelcontextprotocol/server": "^2.3.0",
     "@openrouter/sdk": "^1.4.21",
     "chardet": "^2.2.0",
     "fast-xml-parser": "^5.11.1",
     "iconv-lite": "^0.7.3",
+    "jev-use": "^0.8.0",
     "jszip": "^3.10.1",
     "kordoc": "^4.15.7",
     "mailparser": "^3.9.20",
@@ -71,11 +74,15 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.5.14",
+    "@modelcontextprotocol/client": "^2.3.0",
     "@types/mailparser": "^3.4.6",
     "@types/node": "^26.4.1",
     "@types/ws": "^8.18.1",
     "typescript": "^7.0.2",
     "vitest": "^5.0.0",
     "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz"
+  },
+  "overrides": {
+    "zod": "3.25.76"
   }
 }

package/skills/autorag/SKILL.md

@@ -47,15 +47,20 @@ refresh is enabled by default and can be disabled with
 to `workspacePath`) that refresh keeps out of the parsed mirror and MinSync.
 A folder entry excludes everything under it. Removing an entry and running
 `autorag refresh --method minsync` indexes the file again. Excluded sources are
-recorded as `user-excluded` skips, so they are not reported as stale.
+recorded as `user-excluded` skips, so they are not reported as stale. Jikji
+indexes the source folders directly and is not refreshed here, so AutoRAG also
+drops excluded paths from the `jikji_find` answer pack and the baseline prefetch
+at retrieval time; the on-disk `.jikji_agent_map.md` stays complete, and direct
+file reads remain available.
 
 `status` is model-free and path-opaque. `health` resolves the single model,
 checks credential presence, and normally probes one live completion. If the
 model, authentication, configuration, or indexes are unhealthy, use
 `autorag-setup` rather than guessing private provider details.
 
-MinSync and Jikji should normally be healthy. MinSync and Jikji
-auto-install on first use by default. If they are missing or stale, run a full
+MinSync and Jikji should normally be healthy. Answering a question never
+builds or installs them: `autorag refresh` auto-installs both by default and
+builds their indexes incrementally. If they are missing or stale, run a full
 `autorag refresh` or return to setup rather than silently degrading to
 lexical-only search.
 
@@ -71,7 +76,10 @@ autorag search "what were the key findings in the Q3 report" --top-k 5 --json --
 
 `--json --debug` includes `answer`, numbered `results` (`number`, `title`,
 `summary`, optional `source`), and `sessionId`. Use that `sessionId` for
-feedback. `--json` without `--debug` is only `answer` plus `results`.
+feedback. `--json` without `--debug` is only `answer` plus `results`. Every
+bracketed `[n]` citation in `answer` resolves to a `results[].number` of the
+same response; an unmatched citation is removed and reported as a
+`citation-without-result` diagnostic.
 
 To inspect the exact persisted evidence behind numbered results, use:
 
@@ -98,6 +106,19 @@ AutoRAG. The search loop can use Jikji, MinSync lexical/vector/hybrid retrieval,
 direct source reading as appropriate. If search fails because of model,
 provider, auth, or timeout problems, diagnose with `autorag health --json`.
 
+Every search is two-phase: a fast answer, then verification. With Jev on (the
+default, OpenRouter), Jev first routes the question:
+
+- General knowledge or small talk is answered directly.
+- Private-data questions use local search; public current facts use web search.
+- A multi-part question is split into up to five parallel search queries.
+
+After the fast answer, Jev ends the run if the answer is complete and
+evidence-backed. So `results` may come straight from the fast answer, with no
+verification phase. `--debug` diagnostics show the decision: `query-routed`
+(branch and queries), `follow-up-skipped` (fast answer final), or
+`query-route-fallback` (Jev unavailable, single local search).
+
 Record feedback so retrieval memory can learn. Numbers refer to the returned
 knowledge units. Supply at least one feedback list:
 

package/skills/autorag-doctor/SKILL.md

@@ -87,36 +87,41 @@ Rules:
 
 ## 3. Prove searchability
 
-Indexing without retrieval is a failed run. Probe retrieval per datasource with
-the model-free path, then once end to end:
+Indexing without retrieval is a failed run. Probe retrieval per datasource
+through the model-free MCP tools, then once end to end:
+
+```text
+autorag.status {}
+autorag.search {"query":"a word that certainly appears","topK":3}
+autorag.search {"query":"recent topic","tags":["discord"],"topK":3}
+autorag.search {"query":"recent mail subject","scope":"/mailcrawl/**","topK":3}
+```
 
 ```bash
-autorag lite retrieve "a word that certainly appears" --top-k 3 --json --debug
-autorag lite retrieve "recent topic" --tags discord --top-k 3 --json --debug
-autorag lite retrieve "recent mail subject" --scope "/mailcrawl/**" --top-k 3 --json --debug
 autorag search "summarize the collection" --top-k 3 --json --debug
 ```
 
-- **Always pass `--debug` when diagnosing, and read the diagnostics.** A run
+- **Always read the `diagnostics` returned by MCP `autorag.search`.** A run
   that silently dropped a whole retrieval method still looks successful, just
   with fewer results; only the diagnostics name it (`minsync-unavailable`,
-  `retrieval-method-failed`). `autorag search --json` hides `diagnostics`,
-  `sessionId`, and per-result evidence unless `--debug` is set. `lite retrieve
-  --json` always carries the `diagnostics` array, but its human-readable output
-  hides it without `--debug`.
+  `retrieval-method-failed`). The model-backed CLI `autorag search --json`
+  hides `diagnostics`, `sessionId`, and per-result evidence unless `--debug` is
+  set, so pass `--debug` when diagnosing that path.
 - A method missing from the returned `method` values means that method
   contributed nothing. During a full MinSync re-sync this is expected: the
   store is being rebuilt, `minsync status` reports `NotSynced`, and local-file
   hits stay absent until it finishes. Confirm with `minsync status` before
   treating it as a failure, and never kill a running sync to "fix" it.
-- `lite retrieve` needs no model, so it isolates retrieval from model failures.
-- Use `--tags` / `--scope` to force one datasource; they can only narrow
-  trusted access, never grant it. A datasource absent from `datasourceAccess`
-  returns nothing no matter how healthy its store is — fix the config, not the
-  store.
-- `autorag evidence SESSION --json` (session id comes from `--json --debug`)
-  shows the exact chunk behind a numbered result; use it to confirm a hit is
-  real and its source is readable.
+- MCP `autorag.search` needs no model, so it isolates retrieval from model
+  failures.
+- Use the MCP `tags` / `scope` arguments to force one datasource; they can only
+  narrow trusted access, never grant it. A datasource absent from
+  `datasourceAccess` returns nothing no matter how healthy its store is — fix
+  the config, not the store.
+- `autorag.evidence {"sessionId":"...","resultNumber":N}` shows the exact chunk
+  behind a numbered result; use it to confirm a hit is real and its source is
+  readable. The CLI `autorag evidence SESSION --json` remains for terminal
+  repair.
 - Local-file hits must map to an absolute, existing path. Datasource hits keep
   source-native identities such as `/kakao/personal/chunks/42`; those are not
   filesystem paths and must never be passed to `cat`.
@@ -217,6 +222,10 @@ timer, or Task Scheduler).
 | `unknown-datasource-skill` | Config name is not a known template | Fix the name or add `"type"` |
 | `retrieval-method-failed` | One method errored during the query | Read `--debug` diagnostics |
 | `auth-error` | Credentials missing or rejected | Report the env var name |
+| `query-route-fallback` | Jev routing unavailable (often `OPENROUTER_API_KEY` unset); searched local with the original question | `test -n "$OPENROUTER_API_KEY"`; report the env var name, never its value |
+| `query-decomposition-failed` | Decomposition model call failed; searched the original question | Check `queryDecomposition.model` resolves (`autorag models list --provider openrouter`) |
+| `follow-up-check-fallback` | Jev post-fast-answer check unavailable; the run verified | Same as `query-route-fallback` |
+| `query-routed` / `follow-up-skipped` | Info: Jev's branch and queries / fast answer judged final | None; working as intended |
 
 ## Report