@autorag/librarian 2.13.4 → 2.13.6

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/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

package/dist/cli/config.d.ts

@@ -1,10 +1,10 @@
 import type { Api, Model } from "@earendil-works/pi-ai";
 import { ModelRuntime } from "@earendil-works/pi-coding-agent";
 import type { AutoRAGAgentOptions, AutoRAGRefreshLimits, AutoRAGRetrievalLimits } from "../agent/agent.js";
-import type { JevBackendName } from "../agent/jev-extension.js";
 import { type LoadLocalAutoRAGModelOptions } from "../agent/local-model.js";
 import { type PermissionMode } from "../agent/permission-gate.js";
 import type { DecompositionModel } from "../agent/query-decomposition.js";
+import { type SllmDecisionModel } from "../agent/sllm-decision.js";
 import { type DatasourcesConfig } from "../datasource/skills/factory.js";
 import type { EnsureMinSyncBinaryOptions, MinSyncEmbedderConfig } from "../minsync/index.js";
 export declare const DEFAULT_CONFIG_FILENAME = "config.json";
@@ -55,20 +55,36 @@ export interface WebSearchCliConfig {
     } | false;
 }
 /**
- * Jev decision-tool config. Absent disables the tool; `enabled: false` disables
- * it explicitly. 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`), and the hosted Dazzi Models
- * `dazzi` backend uses the credential stored by `/login`.
+ * Decision-model config. The decision model is required: an absent section or `{}` uses
+ * {@link defaultJevBackend}, and there is no opt-out. It is either Jev (`backend` names `dazzi` or a pi
+ * provider with decision models) or the small chat LLM (`backend: "sllm"`, see {@link JevCliConfig.sllm}).
+ * Secrets never appear here: a pi provider's credential comes from its
+ * environment variable (`OPENROUTER_API_KEY`, `OPENAI_API_KEY`, ...) or pi's
+ * `auth.json`, and the hosted Dazzi Models `dazzi` backend uses the credential
+ * stored by `/login`.
  */
 export interface JevCliConfig {
-    enabled?: boolean;
-    /** Force one backend (`openrouter`, `typesafe`, `vercel`, or `dazzi`); omit to let the first credential present win. */
-    backend?: JevBackendName;
-    /** Model id sent with every call, e.g. `jev-latest`. */
+    /**
+     * `dazzi`, or a pi provider with decision models: `openrouter`, `openai`, `typesafe`,
+     * `vercel-ai-gateway`, `cloudflare-workers-ai`, or `opencode` (`autorag models list --decision`).
+     * `sllm` decides with the small chat LLM ({@link JevCliConfig.sllm}) and never calls Jev.
+     */
+    backend?: string;
+    /** Jev model id within the backend, e.g. `openai/gpt-6-luna-decisions` on OpenRouter. Not valid with `backend: "sllm"`. */
     model?: string;
     /** Escalate verdicts below this confidence (0-1). Default: per-source thresholds. */
     confidenceThreshold?: number;
+    /**
+     * The small chat LLM (sLLM). It is the decision model when `backend` is `sllm`, and otherwise the
+     * fallback a session moves to when Jev is unavailable. Absent or `{}` uses the question-decomposition model.
+     */
+    sllm?: JevSllmConfig;
+    /** Move to the sLLM when Jev is unavailable. Default true; `false` fails the session instead. Ignored with `backend: "sllm"`. */
+    fallback?: boolean;
+}
+/** The sLLM; same model reference shape and auth rules as the top-level `model`. */
+export interface JevSllmConfig {
+    model?: AgentModelConfig;
 }
 /** Question-decomposition config. Secrets stay in env/pi auth like the main model. */
 export interface QueryDecompositionConfig {
@@ -76,19 +92,17 @@ export interface QueryDecompositionConfig {
     model?: AgentModelConfig;
 }
 /**
- * Post-merge reranking config. Routes merged evidence through a dedicated
- * rerank model. `provider` is `openrouter` (default) or the hosted Dazzi Models
- * plan (`dazzi`); each provider supplies its own default `model`. OpenRouter
- * reads its key from `apiKeyEnv`; Dazzi uses the credential stored by `/login`.
- * Secrets never appear here — only the environment-variable name that holds a
- * provider API key.
+ * Post-merge reranking config. Opt-in: reranking runs only when a `model` is named, and a block without one is treated
+ * as off (reported once at startup). `provider` is `openrouter` (default) or the hosted Dazzi Models plan (`dazzi`).
+ * OpenRouter reads its key from `apiKeyEnv`; Dazzi uses the credential stored by `/login`. Secrets never appear
+ * here, only the environment-variable name that holds a provider API key.
  */
 export interface RerankConfig {
-    /** `false` disables reranking. Missing means enabled when the block is present. */
+    /** `false` disables reranking. Missing means enabled when the block is present and names a model. */
     enabled?: boolean;
     /** Provider id (`openrouter` or `dazzi`). @default "openrouter" */
     provider?: string;
-    /** Wire model id. @default "voyageai/rerank-3-lite" (`openrouter`) / "qwen/qwen3-reranker-8b" (`dazzi`) */
+    /** Wire model id. Required to turn reranking on; there is no default model. */
     model?: string;
     /** Environment variable holding the provider API key (`openrouter` only). @default "OPENROUTER_API_KEY" */
     apiKeyEnv?: string;
@@ -156,13 +170,13 @@ export interface CliConfig {
     } | false;
     webSearch?: WebSearchCliConfig;
     /**
-     * Jev query routing (direct / local), the decomposition check, the
-     * post-fast-answer follow-up check, and the `jev` tool. On by default with
-     * the OpenRouter backend; `false` or `enabled: false` disables it. Secrets
-     * never appear here: `jev-use` reads the backend key from its own
-     * environment variable.
+     * Jev, the required decision model: query routing, the decomposition
+     * check, the post-fast-answer follow-up check, citation and evidence
+     * judgment, the `auto` permission gate, and the `jev` tool. Absent or `{}`
+     * uses the default backend. Secrets never appear here: `jev-use` reads the
+     * backend key from its own environment variable.
      */
-    jev?: JevCliConfig | false;
+    jev?: JevCliConfig;
     /**
      * Question decomposition for the Jev query pipeline. `model` names the LLM
      * that splits one question into at most five search queries; absent or `{}`
@@ -256,7 +270,7 @@ export declare function normalizeJevConfig(raw: unknown): JevCliConfig;
  * Jev backend used when the config names none (absent section or `{}`): the
  * hosted Dazzi Models plan when the user is signed in, else OpenRouter.
  */
-export declare function defaultJevBackend(agentDir?: string): JevBackendName;
+export declare function defaultJevBackend(agentDir?: string): string;
 /** The OpenRouter fallback decomposition model, used when not signed in to Dazzi Models. */
 export declare const OPENROUTER_QUERY_DECOMPOSITION_MODEL: AgentModelConfig;
 /**
@@ -268,13 +282,11 @@ export declare const OPENROUTER_QUERY_DECOMPOSITION_MODEL: AgentModelConfig;
 export declare function defaultQueryDecompositionModel(agentDir?: string): AgentModelConfig;
 /** Validate the `queryDecomposition` config section (`false` = decompose with the session model). */
 export declare function normalizeQueryDecompositionConfig(raw: unknown): QueryDecompositionConfig | false;
-/** Normalize and validate the `rerank` config section, filling in defaults. */
-export declare function normalizeRerankConfig(raw: unknown, path: string): RerankConfig | false;
 /**
- * Rerank block `autorag init` writes when none is given: the hosted Dazzi
- * Models reranker when signed in, else OpenRouter's.
+ * Normalize and validate the `rerank` config section, filling in the provider, key-env, and `topN` defaults. It never
+ * invents a model: reranking is opt-in and runs only on a model the operator names.
  */
-export declare function defaultRerankConfig(agentDir?: string): RerankConfig;
+export declare function normalizeRerankConfig(raw: unknown, path: string): RerankConfig | false;
 export declare function buildAgentOptions(config: CliConfig, agentDir?: string): Omit<AutoRAGAgentOptions, "model">;
 /**
  * Extra resolution inputs beyond the local codex-runtime options. `agentDir`
@@ -343,6 +355,13 @@ export declare function validateAgentConfigFile(configPath: string, options?: Re
  * returns undefined so the agent's own model decomposes.
  */
 export declare function resolveQueryDecompositionModel(config: CliConfig, options?: ResolveAgentModelOptions): Promise<DecompositionModel | undefined>;
+/**
+ * Resolve the sLLM and its credential through the same chain as the agent model. `jev.sllm.model` names it;
+ * absent, it is the question-decomposition model (its configured one, else {@link defaultQueryDecompositionModel}).
+ * It decides in Jev's place when `jev.backend` is `sllm`, and otherwise is Jev's fallback; `jev.fallback: false`
+ * returns undefined for the fallback, so a session without Jev fails.
+ */
+export declare function resolveSllmDecisionModel(config: CliConfig, options?: ResolveAgentModelOptions): Promise<SllmDecisionModel | undefined>;
 export declare function resolveAgentModelDetailed(config: CliConfig, options?: ResolveAgentModelOptions): Promise<ResolvedAgentModelDetailed>;
 export declare function readRawConfigObject(path: string): Record<string, unknown>;
 /** Atomically replace a config file, preserving the caller's JSON object. */