@autorag/librarian 2.13.3 → 2.13.5

package/dist/agent/decision-backends.d.ts

@@ -0,0 +1,49 @@
+import type { ClassifierApi, ClassifierContext, ClassifierModel, ClassifierResult, ModelsClassifierOptions } from "@earendil-works/pi-ai";
+import { type BackendRequest, type BackendResponse, type JevBackend } from "jev-use";
+/**
+ * Decision models come from pi's model catalog: pi-ai ships every provider's typed-question
+ * ("classifier") models next to its chat models, with the transport for each wire dialect
+ * (System One on TypeSafe, OpenRouter, Vercel AI Gateway, Cloudflare Workers AI, and OpenCode;
+ * OpenAI's Decisions API for GPT-6 Luna), and pi's runtime adds the credentials in `auth.json` and
+ * the provider `baseUrl` overrides in `models.json` (a proxy or gateway speaking the same dialect).
+ * {@link PiDecisionBackend} puts one of those models behind jev-use's backend contract, so the
+ * jev-use engine (screening, escalation) and every AutoRAG judgment stay unchanged.
+ */
+/**
+ * The decision model asked on each provider when the config names none. OpenRouter stays on
+ * `typesafe/jev-1.13`, the model AutoRAG's routing and permission thresholds were calibrated on.
+ */
+export declare const DECISION_PROVIDER_DEFAULT_MODELS: Readonly<Record<string, string>>;
+/** The pi providers tried, in this order, when the caller names no decision backend. */
+export declare const DECISION_PROVIDER_ORDER: readonly string[];
+/** What {@link PiDecisionBackend} reads from pi's model runtime. pi's `ModelRuntime` is one. */
+export interface DecisionModelRuntime {
+    getModelsOfType(type: "classifier", provider?: string): readonly ClassifierModel<ClassifierApi>[];
+    classify(model: ClassifierModel<ClassifierApi>, context: ClassifierContext, options?: ModelsClassifierOptions): Promise<ClassifierResult>;
+}
+export interface PiDecisionBackendOptions {
+    /** pi provider id with decision models: `openrouter`, `openai`, `typesafe`, `vercel-ai-gateway`, `cloudflare-workers-ai`, or `opencode`. */
+    readonly provider: string;
+    /** Decision model id within the provider. Default: {@link DECISION_PROVIDER_DEFAULT_MODELS}, else the provider's first. */
+    readonly model?: string;
+    /** pi's runtime; built from `agentDir` on the first call when omitted. */
+    readonly runtime?: DecisionModelRuntime;
+    /** Pi agent home whose `auth.json` and `models.json` the runtime reads. Default: Pi's agent dir. */
+    readonly agentDir?: string;
+    /** Environment the provider credential is read from, ahead of `process.env`. */
+    readonly env?: Record<string, string | undefined>;
+}
+/**
+ * One decision model from pi's catalog, as a jev-use backend. Missing credentials, an unknown model,
+ * and provider errors surface as `BackendError`s with the provider's own message, which the jev-use
+ * engine turns into `unreachable` escalations and the session check into a typed reason.
+ */
+export declare class PiDecisionBackend implements JevBackend {
+    readonly name: string;
+    private readonly modelId;
+    private readonly runtime;
+    private readonly agentDir;
+    private readonly env;
+    constructor(options: PiDecisionBackendOptions);
+    judge(request: BackendRequest): Promise<BackendResponse>;
+}

package/dist/agent/decision-model-check.d.ts

@@ -0,0 +1,92 @@
+import { type JevJudge, type JevJudgeOptions } from "./jev-extension.js";
+/**
+ * AutoRAG cannot answer without its decision model (Jev, or the small chat LLM when `jev.backend` is `sllm`): routing, the follow-up check, citation and
+ * evidence judgment, and the permission gate all ask it, in yes/no and choice questions. The first
+ * question of every session therefore puts one tiny probe of each kind to the decision model. When Jev
+ * cannot answer, the configured small chat LLM (sLLM) is probed and serves the session in its place,
+ * reported as degraded; when neither answers, the run ends with {@link DecisionModelUnavailableError}
+ * instead of a pipeline that guesses.
+ */
+/** Error code every surface reports when the session's decision model cannot be used. */
+export declare const DECISION_MODEL_UNAVAILABLE_CODE = "decision-model-unavailable";
+/** Question id of the availability probe. */
+export declare const DECISION_MODEL_PROBE_QUESTION_ID = "decision_model_probe";
+/** Question id of the choice probe, asked in the same call. */
+export declare const DECISION_MODEL_CHOICE_PROBE_QUESTION_ID = "decision_model_choice_probe";
+/** Why the decision model could not be used. */
+export type DecisionModelFailureReason = 
+/** The caller tried to turn the decision model off (`jev: false`). */
+"disabled"
+/** No credential for the backend: an unset API key or a missing sign-in. */
+ | "missing-credential"
+/** The backend rejected the credential (HTTP 401/403). */
+ | "unauthorized"
+/** The backend account has no credit left (HTTP 402). */
+ | "payment-required"
+/** The backend does not serve the configured model (HTTP 404, or "does not exist"). */
+ | "model-not-found"
+/** The backend is throttling (HTTP 429). */
+ | "rate-limited"
+/** Network failure, timeout, or a 5xx from the backend. */
+ | "unreachable"
+/** The backend rejected a yes/no or choice question (HTTP 400/422): the model cannot answer what AutoRAG asks. */
+ | "unsupported-question"
+/** The backend answered, but not with a usable verdict. */
+ | "invalid-response";
+export interface DecisionModelFailure {
+    readonly reason: DecisionModelFailureReason;
+    /** The backend's own error text, verbatim. */
+    readonly detail: string;
+    /** Backend name, when one was resolved. */
+    readonly backend?: string;
+    /** Model id the backend reported or was asked for. */
+    readonly model?: string;
+}
+/**
+ * The session's decision model cannot be used, so AutoRAG cannot answer. Carries a stable `code`
+ * ({@link DECISION_MODEL_UNAVAILABLE_CODE}) and the decision model's `reason` a host can branch on;
+ * `attempts` lists every model tried, the decision model first and the sLLM fallback after it. The
+ * message names the code, each failure with the backend's own error, and what to do about it.
+ */
+export declare class DecisionModelUnavailableError extends Error {
+    readonly code = "decision-model-unavailable";
+    readonly reason: DecisionModelFailureReason;
+    readonly detail: string;
+    readonly backend?: string;
+    readonly model?: string;
+    readonly attempts: readonly DecisionModelFailure[];
+    constructor(failure: DecisionModelFailure, fallback?: DecisionModelFailure);
+}
+/** Map a backend's error text to a reason. HTTP status wins over wording. */
+export declare function classifyDecisionModelFailure(detail: string): DecisionModelFailureReason;
+/** The decision model that answered the probe. */
+export interface DecisionModelStatus {
+    readonly backend: string;
+    readonly model?: string;
+    /** Set when the sLLM fallback answered: why the decision model itself could not. */
+    readonly fallbackFrom?: DecisionModelFailure;
+}
+/**
+ * Put the probe questions to the decision model. Resolves with the backend and model that answered;
+ * throws {@link DecisionModelUnavailableError} when no backend could be built, or it gave no
+ * probability to the yes/no probe or no option to the choice probe. Whether the answers are "right"
+ * does not matter: answers to both prove the model is reachable, authorized, served, and able to
+ * answer the kinds of question AutoRAG asks.
+ */
+export declare function checkDecisionModel(judge: JevJudge): Promise<DecisionModelStatus>;
+/** The session's decision model: the judge every caller asks, and the check that picks what it asks. */
+export interface DecisionModels {
+    /** Asks the model the latest {@link DecisionModels.check} selected: Jev, or the sLLM fallback when Jev could not answer. */
+    readonly judge: JevJudge;
+    /**
+     * Probe Jev; when it is unavailable and a fallback is configured, probe the fallback. The first that
+     * answers serves every later judgment until the next check. Throws {@link DecisionModelUnavailableError}
+     * with every failure when none answers.
+     */
+    check(): Promise<DecisionModelStatus>;
+}
+/**
+ * The session's decision model from `options`: Jev (`options.backend`), with `options.sllm` behind it as
+ * the fallback, or the small chat LLM alone when `options.backend` is `"sllm"`.
+ */
+export declare function createDecisionModels(options: JevJudgeOptions): DecisionModels;

package/dist/agent/dupey-tool.d.ts

@@ -4,6 +4,8 @@ import type { DupeyScanResult } from "../dupey/index.js";
 export declare const SCAN_DUPLICATE_DOCUMENTS_TOOL_NAME = "scan_duplicate_documents";
 export interface ScanDuplicateDocumentsDetails {
     readonly scans: readonly DupeyScanResult[];
+    /** Roots inside a cloud or network folder: `dupey scan` opens file contents, so they were not scanned. */
+    readonly skippedRoots: readonly string[];
     readonly familyCount: number;
     readonly exactDuplicateCount: number;
 }

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

@@ -17,6 +17,7 @@ export interface EverythingSearchDetails {
 }
 declare const everythingSearchSchema: Type.TObject<{
     query: Type.TString;
+    alternatives: Type.TOptional<Type.TArray<Type.TString>>;
     regex: Type.TOptional<Type.TBoolean>;
     matchCase: Type.TOptional<Type.TBoolean>;
     matchPath: Type.TOptional<Type.TBoolean>;

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

@@ -17,6 +17,7 @@ export interface FSearchSearchDetails {
 }
 declare const fsearchSearchSchema: Type.TObject<{
     query: Type.TString;
+    alternatives: Type.TOptional<Type.TArray<Type.TString>>;
     regex: Type.TOptional<Type.TBoolean>;
     matchCase: Type.TOptional<Type.TBoolean>;
     matchPath: Type.TOptional<Type.TBoolean>;

package/dist/agent/index.d.ts

@@ -2,8 +2,10 @@ export type { AutoRAGAgentOptions, AutoRefreshOptions } from "./agent.js";
 export { AutoRAGAgent } from "./agent.js";
 export { CONVERT_FILES_TOOL_NAME, type ConvertFilesDetails, createConvertFilesTool, createListFileConversionsTool, type FileConversionProvider, LIST_FILE_CONVERSIONS_TOOL_NAME, } from "./convert-tool.js";
 export { buildDatasourceSkillsPrompt, createLoadDatasourceSkillTool, type DatasourceSkillProvider, datasourceSkillLocation, formatDatasourceSkillInvocation, LOAD_DATASOURCE_SKILL_TOOL_NAME, type LoadDatasourceSkillDetails, toDatasourceAgentSkill, } from "./datasource-skill.js";
+export { DECISION_PROVIDER_DEFAULT_MODELS, type DecisionModelRuntime, PiDecisionBackend, type PiDecisionBackendOptions, } from "./decision-backends.js";
+export { DECISION_MODEL_UNAVAILABLE_CODE, type DecisionModelFailure, type DecisionModelFailureReason, DecisionModelUnavailableError, } from "./decision-model-check.js";
 export { createScanDuplicateDocumentsTool, SCAN_DUPLICATE_DOCUMENTS_TOOL_NAME, type ScanDuplicateDocumentsDetails, type ScanDuplicateDocumentsProvider, } from "./dupey-tool.js";
-export { createJevExtension, JEV_TOOL_NAME, type JevBackendName, type JevToolOptions, } from "./jev-extension.js";
+export { createJevExtension, JEV_TOOL_NAME, type JevToolOptions, } from "./jev-extension.js";
 export { createJikjiFindTool, JIKJI_FIND_TOOL_NAME, type JikjiFindDetails, type JikjiFindPerRootPolicy, type JikjiFindProvider, type JikjiFindProviderResult, type MergedJikjiPolicy, } from "./jikji-find-tool.js";
 export type { AutoRAGEmittedResult, AutoRAGMappingEntry, AutoRAGResultsDetails, } from "./results.js";
 export { reportSchema } from "./results.js";
@@ -11,4 +13,5 @@ export { createSearchAllDocumentsTool, SEARCH_ALL_DOCUMENTS_TOOL_NAME, type Sear
 export type { SearchDocumentDiagnostic, SearchDocumentDiagnosticCode, SearchDocumentDiagnosticSeverity, SearchDocumentEvidence, SearchDocumentResult, SearchDocumentsResponse, SearchDocumentsStreamEvent, SearchDocumentWarning, } from "./search-documents.js";
 export { createSearchMinSyncDocumentsTool, SEARCH_MINSYNC_DOCUMENTS_TOOL_NAME, type SearchMinSyncDocumentsDetails, } from "./search-minsync-tool.js";
 export { createSingleDatasourceSearchTools, formatDatasourceResults, SEARCH_SINGLE_DATASOURCE_TOOL_PREFIX, type SearchSingleDatasourceDetails, type SingleDatasourceSearchProvider, type SingleDatasourceToolSpec, singleDatasourceToolName, } from "./search-single-datasource-tool.js";
+export { SLLM_BACKEND, SLLM_DECISION_TOOL_NAME, SllmDecisionBackend, type SllmDecisionModel } from "./sllm-decision.js";
 export { buildSystemPrompt, type SystemPromptConfig } from "./system-prompt.js";

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

@@ -1,46 +1,41 @@
 import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
 import { type JevBackend, type Judgment, type Question, type State } from "jev-use";
+import { type SllmDecisionModel } from "./sllm-decision.js";
 /** `jev` tool name, kept in AutoRAG's reserved set and system prompt. */
 export declare const JEV_TOOL_NAME = "jev";
 /**
- * Jev backends the `jev-use` engine resolves from the environment, in
- * auto-select order: TypeSafe -> OpenRouter -> Vercel AI Gateway. `dazzi` is
- * the hosted Dazzi Models plan, built here rather than resolved by jev-use.
- */
-export type JevBackendName = "typesafe" | "openrouter" | "vercel" | "dazzi";
-/**
- * OpenRouter's live Jev model id. `jev-use` 0.8.0 ships `typesafe/jev-latest`,
- * which OpenRouter rejects with HTTP 400 ("Model ... does not exist"), so the
- * OpenRouter path is pinned here.
- */
-export declare const OPENROUTER_DEFAULT_MODEL = "typesafe/jev-1.13";
-/**
- * Options for the `jev` decision tool. Secrets never appear here: `jev-use`
- * reads the backend credential from its own environment variable
- * (`TYPESAFE_API_KEY`, `OPENROUTER_API_KEY`, or `AI_GATEWAY_API_KEY`).
+ * Options for the decision model. Secrets never appear here: a pi provider's credential comes from
+ * its environment variable (`OPENROUTER_API_KEY`, `OPENAI_API_KEY`, `TYPESAFE_API_KEY`,
+ * `AI_GATEWAY_API_KEY`, `CLOUDFLARE_API_KEY`, `OPENCODE_API_KEY`) or pi's `auth.json`, and the
+ * hosted `dazzi` backend uses the `/login` credential.
  */
 export interface JevToolOptions {
     /**
-     * Force one backend by name; omit to let the first credential present win.
-     * A ready-made `jev-use` backend instance is a programmatic seam (tests,
-     * custom transports); config only accepts names.
-     */
-    readonly backend?: JevBackendName | JevBackend;
-    /**
-     * Wire model id sent with every call. Omit for the backend default;
-     * OpenRouter is pinned to {@link OPENROUTER_DEFAULT_MODEL} because
-     * `jev-use` 0.8.0's own default (`typesafe/jev-latest`) is not a live
-     * OpenRouter model id.
+     * The decision backend: `dazzi`, or any pi provider whose catalog carries decision models
+     * (`openrouter`, `openai`, `typesafe`, `vercel-ai-gateway`, `cloudflare-workers-ai`, or `opencode`),
+     * or `"sllm"` to decide with the small chat LLM in {@link JevToolOptions.sllm} and never
+     * call Jev.
+     * Omit to take the Dazzi plan when signed in, else the first of
+     * {@link DECISION_PROVIDER_ORDER} whose API key is set. A ready-made `jev-use` backend instance is a
+     * programmatic seam (tests, custom transports); config only accepts names.
      */
+    readonly backend?: string | JevBackend;
+    /** Decision model id within the backend, e.g. `openai/gpt-6-luna-decisions` on OpenRouter. Omit for the backend default. */
     readonly model?: string;
     /** Escalate verdicts below this confidence. Default: per-source thresholds. */
     readonly confidenceThreshold?: number;
+    /**
+     * The small chat LLM (sLLM): the decision model when `backend` is `"sllm"`, otherwise the
+     * fallback the session moves to when the session check finds the decision model unavailable. A
+     * `jev-use` backend instance is the programmatic seam. Omit for no fallback.
+     */
+    readonly sllm?: SllmDecisionModel | JevBackend;
 }
-/** {@link JevToolOptions} plus the environment `jev-use` resolves credentials from. */
+/** {@link JevToolOptions} plus where credentials are read from. */
 export interface JevJudgeOptions extends JevToolOptions {
-    /** Environment consulted for the backend credential. Default `process.env`. */
+    /** Environment consulted for the backend credential, ahead of `process.env`. */
     readonly env?: Record<string, string | undefined>;
-    /** Pi agent home whose `auth.json` holds the Dazzi `/login` credential. Default: Pi's agent dir. */
+    /** Pi agent home: `auth.json` (credentials, the Dazzi `/login`) and `models.json`. Default: Pi's agent dir. */
     readonly agentDir?: string;
 }
 /**
@@ -51,11 +46,11 @@ export interface JevJudgeOptions extends JevToolOptions {
 export type JevJudge = (state: State, questions: Question[], options?: {
     readonly confidenceThreshold?: number;
 }) => Promise<Judgment>;
+/** The `jev-use` backend for the small chat LLM: a ready-made backend instance is used as is. */
+export declare function sllmBackend(sllm: SllmDecisionModel | JevBackend): JevBackend;
 /**
- * Builds the Jev judge shared by the `jev` tool and the query router. The
- * `jev-use` client is created lazily on the first call, so no credential
- * resolves at construction time, and the per-backend model default (the
- * OpenRouter pin, or `jev-1.13` on the hosted plan) applies to every caller.
+ * Builds a Jev judge over one decision backend. The backend is built lazily on the first call, so
+ * no credential resolves at construction time; a missing one rejects that call with a named error.
  */
 export declare function createJevJudge(options?: JevJudgeOptions): JevJudge;
 /**

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

@@ -14,7 +14,10 @@ export interface MergedJikjiPolicy {
     readonly forbiddenTools: readonly string[];
     readonly allowedFollowups: readonly string[];
     readonly agentShouldNotRerank: boolean;
+    /** True only when every root's envelope allowed raw fallback. */
     readonly rawFallbackAllowed: boolean;
+    /** Smallest `max_raw_fallback_commands` any root reported; undefined when none did. */
+    readonly maxRawFallbackCommands?: number;
 }
 /**
  * Per-root policy summary for one successful (ok) root, captured BEFORE the
@@ -55,6 +58,8 @@ export interface JikjiFindDetails {
     readonly handoffAction: JikjiHandoffAction | undefined;
     readonly stopAfterFind: boolean | undefined;
     readonly rawFallbackAllowed: boolean | undefined;
+    /** Raw shell commands jikji allows once raw fallback is open (`max_raw_fallback_commands`). */
+    readonly maxRawFallbackCommands: number | undefined;
     readonly sources: readonly string[];
     readonly candidates: readonly JikjiCandidate[];
     readonly evidencePack: readonly JikjiEvidence[];

package/dist/agent/name-candidates.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Parallel file-name search over several candidate names.
+ *
+ * File-name search is cheap (an index lookup), but the right name is rarely
+ * known: the user's word, its translation, an abbreviation, a likely
+ * extension. Instead of one call per guess, every candidate is searched at the
+ * same time and the hits are merged, with each hit labelled by the candidates
+ * that found it.
+ */
+/** Candidates searched in one call; the rest are reported as dropped, never silently ignored. */
+export declare const MAX_NAME_CANDIDATES = 8;
+export interface NameCandidates {
+    readonly candidates: readonly string[];
+    /** Distinct candidates beyond {@link MAX_NAME_CANDIDATES} that were not searched. */
+    readonly dropped: number;
+}
+/**
+ * The query first, then the alternatives, trimmed and without repeats. Case
+ * variants count as one candidate unless the search is case-sensitive.
+ */
+export declare function collectNameCandidates(query: string, alternatives?: readonly string[], options?: {
+    readonly matchCase?: boolean;
+}): NameCandidates;
+/** What one file-name search returned: hits, or a failure that names why. Backends' own results satisfy it. */
+export type NameSearchResult = {
+    readonly ok: true;
+    readonly results: readonly {
+        readonly path: string;
+    }[];
+} | {
+    readonly ok: false;
+    readonly reason: string;
+    readonly message: string;
+};
+/** A search that threw, reported as the failure of its own candidate. */
+export interface NameSearchFailure {
+    readonly ok: false;
+    readonly reason: string;
+    readonly message: string;
+}
+/** `Result` is the backend's own result type, so callers keep fields such as `backend` and `total`. */
+export interface NameSearchOutcome<Result extends NameSearchResult = NameSearchResult> {
+    readonly candidate: string;
+    readonly result: Result | NameSearchFailure;
+}
+/**
+ * Search every candidate at once. A search that throws fails only its own
+ * candidate; the others still return.
+ */
+export declare function searchNameCandidates<Result extends NameSearchResult>(candidates: readonly string[], search: (candidate: string) => Promise<Result>): Promise<NameSearchOutcome<Result>[]>;
+export interface MergedNameHit<Entry extends {
+    readonly path: string;
+}> {
+    readonly entry: Entry;
+    /** Every candidate that found this path, in candidate order. */
+    readonly candidates: readonly string[];
+}
+/**
+ * One list of hits, each path once. The name indexes (Everything, FSearch) match
+ * names exactly and return their hits in a sort order, not by relevance, so no
+ * hit is "better" than another within one candidate. What does carry signal is
+ * how many of the searched names found a path: those come first. Within the
+ * same count, the candidates' lists are interleaved position by position, so the
+ * cut at `limit` is shared among the candidates instead of one filling it.
+ */
+export declare function mergeNameHits<Entry extends {
+    readonly path: string;
+}>(outcomes: readonly {
+    readonly candidate: string;
+    readonly result: {
+        readonly ok: true;
+        readonly results: readonly Entry[];
+    } | NameSearchFailure;
+}[], limit: number): MergedNameHit<Entry>[];
+/** One hit as a numbered line; `foundBy` is shown only when several names were searched. */
+export declare function renderNameHitLine(index: number, entry: {
+    readonly path: string;
+    readonly type: string;
+    readonly size?: number | undefined;
+    readonly dateModified?: string | undefined;
+}, foundBy?: readonly string[]): string;
+/** Lines that say which candidates failed and which were never searched; empty when everything ran. */
+export declare function renderNameSearchProblems(outcomes: readonly {
+    readonly candidate: string;
+    readonly result: {
+        readonly ok: true;
+    } | NameSearchFailure;
+}[], dropped: number): string[];

package/dist/agent/permission-gate.d.ts

@@ -46,11 +46,8 @@ export declare class PermissionController {
 }
 export interface PermissionGateOptions {
     readonly controller: PermissionController;
-    /**
-     * Jev, which classifies every gated call. Without one the gate cannot classify, so in `ask` and `auto` it
-     * asks the user about every `bash`, `write`, and `edit` call.
-     */
-    readonly judge?: JevJudge;
+    /** Jev, which classifies every gated call in `auto`. */
+    readonly judge: JevJudge;
     /**
      * What the user has said in this conversation: the first question, every follow-up, every steer. Jev judges
      * the call against all of it. The host feeds it from the user's own input, so AutoRAG's internal phase

package/dist/agent/query-routing.d.ts

@@ -161,6 +161,6 @@ export interface PastSearchHint {
  * withheld when a configured datasource already uses that id
  * ({@link DatasourceSelection.webIdTaken}), so a question id never names two
  * candidates. Never throws: a missing credential or an unreachable backend
- * searches nothing, which is the behavior without Jev.
+ * searches nothing.
  */
 export declare function selectDatasources(judge: JevJudge, query: string, datasources: readonly DatasourceCandidate[], pastSearches?: readonly PastSearchHint[], options?: SelectDatasourcesOptions): Promise<DatasourceSelection>;

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

@@ -9,7 +9,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-staging-excluded" | "minsync-file-skipped" | "minsync-sync-failed" | "minsync-lock-held" | "embedder-unavailable" | "embedding-identity-mismatch" | "lexical-tokenizer-unavailable" | "parser-skipped" | "parser-failed" | "parser-crashed" | "source-changed" | "source-vanished" | "source-unreadable" | "source-read-failed" | "mirror-write-failed" | "parser-warning" | "duplicate-excluded" | "unsupported-file" | "stale-index" | "deleted-mirror" | "search-root-unavailable" | "mass-delete-suppressed" | "walk-truncated" | "directory-unreadable" | "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" | "no-final-answer" | "model-request-failed" | "tool-call-burst" | "query-routed" | "query-route-fallback" | "query-decomposition-failed" | "follow-up-skipped" | "follow-up-check-fallback" | "datasources-selected" | "datasource-selection-fallback" | "web-datasource-id-taken" | "web-search-failed" | "citation-without-result" | "line-reference-unverified" | "citation-irrelevant" | "citation-relevance-fallback" | "evidence-judged" | "evidence-judgment-fallback" | "memory-search-fallback" | "self-config-unavailable" | "self-config-rolled-back" | "organize-skill-unavailable" | "embedding-unavailable";
+export type SearchDocumentDiagnosticCode = "empty-query" | "no-verified-results" | "unknown-warning" | "caller-tool-dropped" | "minsync-staging-excluded" | "minsync-file-skipped" | "minsync-sync-failed" | "minsync-lock-held" | "embedder-unavailable" | "embedding-identity-mismatch" | "parser-skipped" | "parser-failed" | "parser-crashed" | "source-changed" | "source-vanished" | "source-unreadable" | "source-read-failed" | "mirror-write-failed" | "parser-warning" | "duplicate-excluded" | "unsupported-file" | "stale-index" | "deleted-mirror" | "search-root-unavailable" | "mass-delete-suppressed" | "walk-truncated" | "directory-unreadable" | "cloud-download-deferred" | "cloud-placeholder-skipped" | "cloud-evict-failed" | "cloud-fingerprint-failed" | "pdf-extract-thin" | "retrieval-method-failed" | "rerank-failed" | "rerank-disabled" | "jikji-unavailable" | "jikji-prepare-failed" | "jikji-cloud-root-skipped" | "jikji-find-failed" | "jikji-discover-failed" | "jikji-unsupported-version" | "everything-index-failed" | "fsearch-index-failed" | "fsearch-binary-missing" | "refresh-failed" | "refresh-interrupted" | "watch-failed" | "watch-limited" | "unknown-datasource-skill" | "no-final-answer" | "model-request-failed" | "tool-call-burst" | "decision-model-checked" | "decision-model-fallback" | "query-routed" | "query-route-fallback" | "query-decomposition-failed" | "follow-up-skipped" | "follow-up-check-fallback" | "datasources-selected" | "datasource-selection-fallback" | "web-datasource-id-taken" | "web-search-failed" | "citation-without-result" | "line-reference-unverified" | "citation-irrelevant" | "citation-relevance-fallback" | "evidence-judged" | "evidence-judgment-fallback" | "memory-search-fallback" | "self-config-unavailable" | "self-config-rolled-back" | "organize-skill-unavailable" | "embedding-unavailable";
 export interface SearchDocumentDiagnostic {
     readonly code: SearchDocumentDiagnosticCode;
     readonly severity: SearchDocumentDiagnosticSeverity;

package/dist/agent/sllm-decision.d.ts

@@ -0,0 +1,34 @@
+import type { Api, Model } from "@earendil-works/pi-ai";
+import { type BackendRequest, type BackendResponse, type JevBackend } from "jev-use";
+/**
+ * The decision model's fallback: a small chat LLM (sLLM) answering Jev's typed questions. It is
+ * used only when the session check finds Jev unavailable. A chat model's probabilities are its own
+ * estimate, not a calibrated decision head, so a session on it is reported as degraded.
+ *
+ * Every request builds its own answer format: a tool whose arguments are one required key per
+ * question (the wire-safe key of its id), holding `yes` for a yes/no question or one named
+ * probability per option or level for a choice or score question, plus a confidence. The tool asks
+ * for JSON-schema constrained sampling, which providers that support it enforce; the prompt carries
+ * the same format as an example reply for the rest. The reply is read from the tool call, or else
+ * from the JSON the text holds, leniently. Answers that are missing or malformed are asked again
+ * once, alone; whatever is still unanswered then goes back to Jev's engine as unanswered, and the
+ * answers that were read are kept.
+ */
+/** The small LLM and the credential used only for fallback decisions. */
+export interface SllmDecisionModel {
+    readonly model: Model<Api>;
+    readonly apiKey?: string;
+}
+/** `jev.backend` value, and the backend name, of the small LLM deciding in Jev's place. */
+export declare const SLLM_BACKEND = "sllm";
+/** The tool the small LLM answers through. */
+export declare const SLLM_DECISION_TOOL_NAME = "submit_decisions";
+/** The small-LLM fallback behind jev-use's backend contract. */
+export declare class SllmDecisionBackend implements JevBackend {
+    readonly name = "sllm";
+    private readonly target;
+    constructor(target: SllmDecisionModel);
+    judge(request: BackendRequest): Promise<BackendResponse>;
+    /** One request for `pending`: its own tool and example, temperature 0, reasoning off. */
+    private ask;
+}

package/dist/agent/token-count.d.ts

@@ -0,0 +1,4 @@
+/** Tokens in `text`, never fewer than the chars/4 guess so prose keeps the budget it had. */
+export declare function estimateTextTokens(text: string): number;
+/** How many tokens the pieces add beyond their chars/4 guesses; zero for prose. */
+export declare function tokensBeyondCharGuess(parts: readonly string[]): number;

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

@@ -1,10 +1,11 @@
 import type { DupeyScanResult } from "../../dupey/index.js";
+import { type CloudFileProbe } from "../../filesystem/cloud-placeholder.js";
 import type { CommandContext } from "./types.js";
-export type DuplicateScanner = (path: string) => Promise<DupeyScanResult>;
+export type DuplicateScanner = (path: string, excludeDirs: readonly string[]) => Promise<DupeyScanResult>;
 /**
  * `autorag duplicates` — scan configured roots for exact and near duplicate
  * document families. Never deletes or moves source files.
  *
  * Exit codes: 0 on success, 2 on config error, 1 on runtime error.
  */
-export declare function runDuplicates(ctx: CommandContext, scanner?: DuplicateScanner): Promise<number>;
+export declare function runDuplicates(ctx: CommandContext, scanner?: DuplicateScanner, cloudProbe?: CloudFileProbe | undefined): Promise<number>;

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

@@ -16,6 +16,8 @@ export interface ModelCatalogOptions {
     readonly provider?: string;
     /** Only list models whose provider has complete auth configuration. */
     readonly available?: boolean;
+    /** List decision models (the `jev.backend`/`jev.model` candidates) instead of chat models. */
+    readonly decision?: boolean;
     readonly agentDir?: string;
 }
 export interface ModelsCommandDeps {

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

@@ -1,6 +1,8 @@
 import { AutoRAGAgent, type AutoRAGAgentOptions } from "../../agent/agent.js";
 import { type CliConfig, type ResolveAgentModelOptions, type ResolvedAgentModel } from "../config.js";
 import type { CommandContext } from "./types.js";
+/** Exit status of a search whose session decision model cannot answer: AutoRAG is unusable until it can. */
+export declare const DECISION_MODEL_UNAVAILABLE_EXIT_CODE = 3;
 /**
  * A recoverable health hint surfaced when `autorag search` fails for a reason
  * that `autorag health` can diagnose. The classifier only produces hints for