@autorag/librarian 2.2.0 → 2.4.0

package/dist/jikji/client.d.ts

@@ -15,4 +15,5 @@ export declare class JikjiClient {
     private resolveCommand;
     prepare(root: string, options?: JikjiPrepareOptions): Promise<JikjiPrepareResult>;
     find(root: string, query: string, options?: JikjiFindOptions): Promise<JikjiFindResult>;
+    private spawn;
 }

package/dist/memory/check-memory-tool.d.ts

@@ -8,6 +8,7 @@ export interface CheckMemoryDetails {
     signalCount: number;
     topMethod: string | null;
     insightCount: number;
+    contextHintCount: number;
 }
 export declare function createCheckMemoryTool(memory: RetrievalMemory): AgentTool<typeof checkMemorySchema, CheckMemoryDetails>;
 export {};

package/dist/memory/index.d.ts

@@ -1,5 +1,5 @@
 export type { CheckMemoryDetails } from "./check-memory-tool.js";
 export { createCheckMemoryTool } from "./check-memory-tool.js";
-export type { MemoryEntry, ResultFeedback, RetrievalInsight, RetrievalMemoryOptions, SearchAttempt } from "./memory.js";
-export { RetrievalMemory } from "./memory.js";
+export type { ContextValueHint, EvidenceContext, FeedbackIdInput, MemoryEntry, ResultFeedback, RetrievalContextHints, RetrievalInsight, RetrievalMemoryOptions, SearchAttempt, } from "./memory.js";
+export { normalizeSessionEvidenceRef, RetrievalMemory } from "./memory.js";
 export { renderMemoryContext } from "./renderer.js";

package/dist/memory/memory.d.ts

@@ -9,7 +9,16 @@ export interface SignalDefaults {
     readonly implicitCap: number;
     readonly decayHalfLifeMs?: number;
 }
-export interface EvidenceChunkRecord extends NormalizedEvidenceRef {
+export interface EvidenceContext {
+    readonly retrieverMix?: readonly string[];
+    readonly parserType?: string;
+    readonly documentType?: string;
+    readonly documentArea?: string;
+    readonly evidenceType?: string;
+    readonly evidenceLocation?: string;
+    readonly confidence?: number;
+}
+export interface EvidenceChunkRecord extends NormalizedEvidenceRef, EvidenceContext {
     readonly excerptHash: string;
     readonly firstSeenAt: number;
     readonly lastSeenAt: number;
@@ -24,6 +33,7 @@ export interface CuratedResultRecord {
     readonly summary: string;
     readonly resultHash: string;
     readonly evidenceIds: readonly string[];
+    readonly confidence?: number;
     readonly createdAt: number;
 }
 export interface FeedbackSignal {
@@ -53,6 +63,19 @@ export interface MethodHint {
     readonly confidence: number;
     readonly reason: string;
 }
+export interface ContextValueHint {
+    readonly value: string;
+    readonly score: number;
+    readonly confidence: number;
+}
+export interface RetrievalContextHints {
+    readonly documentAreas: readonly ContextValueHint[];
+    readonly documentTypes: readonly ContextValueHint[];
+    readonly evidenceTypes: readonly ContextValueHint[];
+    readonly evidenceLocations: readonly ContextValueHint[];
+    readonly parserTypes: readonly ContextValueHint[];
+    readonly retrieverMix: readonly ContextValueHint[];
+}
 export interface RetrievalInsight {
     readonly id: string;
     readonly clusterKey: string;
@@ -107,7 +130,7 @@ export interface ResultFeedback {
     source: string;
     useful: boolean;
 }
-export interface SessionEvidenceRef extends NormalizedEvidenceRef {
+export interface SessionEvidenceRef extends NormalizedEvidenceRef, EvidenceContext {
     readonly metadata?: Record<string, unknown>;
 }
 export interface SessionCuratedResultInput {
@@ -117,6 +140,7 @@ export interface SessionCuratedResultInput {
     readonly content: string;
     readonly method: string;
     readonly source: string;
+    readonly confidence?: number;
     readonly evidenceRefs: readonly SessionEvidenceRef[];
 }
 export interface SessionRecordInput {
@@ -132,6 +156,10 @@ export interface NumberedFeedbackInput {
         readonly useful: boolean;
     }[];
 }
+export interface FeedbackIdInput {
+    readonly feedbackId: string;
+    readonly useful: boolean;
+}
 export interface RetrievalMemoryOptions {
     storagePath: string;
     insightExtractor?: InsightExtractor;
@@ -150,8 +178,10 @@ export declare class RetrievalMemory {
     getSignalCount(): number;
     recordCuratedResultsSession(input: SessionRecordInput): void;
     recordNumberedFeedback(input: NumberedFeedbackInput): boolean;
+    recordFeedbackByIds(feedback: readonly FeedbackIdInput[]): boolean;
     recordWeakSignal(query: string, method: string, source: "followup" | "retry"): void;
-    getMethodHints(query: string): MethodHint[];
+    getMethodHints(_query: string): MethodHint[];
+    getContextHints(_query: string): RetrievalContextHints;
     getInsights(query: string): RetrievalInsight[];
     getMethodPriority(query: string): Array<{
         method: string;

package/dist/memory/renderer.d.ts

@@ -1,6 +1,7 @@
-import type { MethodHint, RetrievalInsight } from "./memory.js";
+import type { MethodHint, RetrievalContextHints, RetrievalInsight } from "./memory.js";
 export declare function renderMemoryContext(hints: readonly MethodHint[], opts?: {
     maxHints?: number;
     insights?: readonly RetrievalInsight[];
     maxInsights?: number;
+    contextHints?: RetrievalContextHints;
 }): string;

package/dist/minsync/client.d.ts

@@ -3,12 +3,16 @@ export interface MinSyncClientOptions {
     readonly binaryPath: string;
     readonly workspacePath: string;
     readonly embedder?: MinSyncEmbedderConfig;
+    readonly maxChunkSize?: number;
 }
+export type MinSyncQueryMode = "vector" | "bm25" | "hybrid";
 export declare class MinSyncClient {
     private readonly binaryPath;
     private readonly workspacePath;
     private readonly embedder;
+    private readonly maxChunkSize;
     constructor(options: MinSyncClientOptions);
     sync(): Promise<MinSyncSyncResult>;
-    query(text: string, topK: number): Promise<readonly MinSyncQueryHit[]>;
+    query(text: string, topK: number, mode?: MinSyncQueryMode): Promise<readonly MinSyncQueryHit[]>;
+    private spawn;
 }

package/dist/minsync/embedder-config.d.ts

@@ -7,6 +7,7 @@ import type { MinSyncEmbedderConfig } from "./types.js";
 export declare const MINSYNC_CONFIG_DIR = ".minsync";
 export declare const MINSYNC_CONFIG_FILE = "config.toml";
 export declare function minSyncConfigPath(workspacePath: string): string;
+export declare function configuredMaxChunkSize(workspacePath: string): number | undefined;
 /**
  * Atomically rewrite allowlisted embedder fields in MinSync config.toml.
  * Reads the existing file, merges the allowlisted fields from `embedder`,
@@ -19,4 +20,6 @@ export declare function minSyncConfigPath(workspacePath: string): string;
  *
  * Returns true if the file was rewritten, false if the file does not exist.
  */
-export declare function rewriteEmbedderConfig(workspacePath: string, embedder: MinSyncEmbedderConfig): boolean;
+export declare function rewriteEmbedderConfig(workspacePath: string, embedder: MinSyncEmbedderConfig, chunkerConfig?: {
+    readonly maxChunkSize?: number;
+}): boolean;

package/dist/minsync/index.d.ts

@@ -1,7 +1,7 @@
-export { MinSyncClient, type MinSyncClientOptions } from "./client.js";
+export { MinSyncClient, type MinSyncClientOptions, type MinSyncQueryMode } from "./client.js";
 export { MINSYNC_CONFIG_DIR, MINSYNC_CONFIG_FILE, minSyncConfigPath, rewriteEmbedderConfig, } from "./embedder-config.js";
-export { type EnsureMinSyncBinaryOptions, ensureMinSyncBinary, executableName, fetchLatestMinSyncRelease, type InstalledMinSyncBinary, type MinSyncRelease, type MinSyncReleaseAsset, MinSyncReleaseError, selectReleaseAsset, } from "./installer.js";
-export { MinSyncVectorMethod, type MinSyncVectorMethodOptions } from "./method.js";
+export { type EnsureMinSyncBinaryOptions, ensureMinSyncBinary, executableName, fetchLatestMinSyncRelease, type InstalledMinSyncBinary, MINSYNC_VERSION, type MinSyncRelease, type MinSyncReleaseAsset, MinSyncReleaseError, selectReleaseAsset, } from "./installer.js";
+export { MinSyncBM25Method, type MinSyncBM25MethodOptions, MinSyncHybridMethod, type MinSyncHybridMethodOptions, MinSyncVectorMethod, type MinSyncVectorMethodOptions, } from "./method.js";
 export { MINSYNC_FILES_SUBDIR, MINSYNC_SUBDIR, minSyncDocumentPath, minSyncWorkspaceRoot } from "./paths.js";
-export type { MinSyncEmbedderConfig, MinSyncOptions, MinSyncQueryHit, MinSyncSyncResult } from "./types.js";
+export type { MinSyncChunkerConfig, MinSyncEmbedderConfig, MinSyncOptions, MinSyncQueryHit, MinSyncSyncResult, } from "./types.js";
 export { buildMinSyncPathMap, type MinSyncWorkspaceEntry, type MinSyncWorkspaceSyncResult, syncMinSyncWorkspace, } from "./workspace.js";

package/dist/minsync/installer.d.ts

@@ -1,3 +1,4 @@
+export declare const MINSYNC_VERSION = "0.3.0";
 export interface MinSyncReleaseAsset {
     readonly name: string;
     readonly downloadUrl: string;

package/dist/minsync/method.d.ts

@@ -1,4 +1,6 @@
+import { type BM25Status, type BM25SyncResult } from "../retrieval/methods/bm25.js";
 import type { RetrievalMethod, RetrievalMethodDescriptor, RetrievalOptions, RetrievalResult } from "../retrieval/types.js";
+import type { MinSyncQueryMode } from "./client.js";
 import { type EnsureMinSyncBinaryOptions } from "./installer.js";
 import type { MinSyncEmbedderConfig, MinSyncSyncResult } from "./types.js";
 export interface MinSyncVectorMethodOptions {
@@ -8,7 +10,11 @@ export interface MinSyncVectorMethodOptions {
     readonly installer?: Omit<EnsureMinSyncBinaryOptions, "root">;
     readonly autoInstall?: boolean;
     readonly embedder?: MinSyncEmbedderConfig;
+    readonly maxChunkSize?: number;
+    readonly mode?: MinSyncQueryMode;
 }
+export type MinSyncBM25MethodOptions = Omit<MinSyncVectorMethodOptions, "mode">;
+export type MinSyncHybridMethodOptions = Omit<MinSyncVectorMethodOptions, "mode">;
 export declare class MinSyncVectorMethod implements RetrievalMethod {
     private readonly root;
     private readonly binaryPath;
@@ -16,6 +22,8 @@ export declare class MinSyncVectorMethod implements RetrievalMethod {
     private readonly installer;
     private readonly autoInstall;
     private readonly embedder;
+    private readonly maxChunkSize;
+    private readonly mode;
     constructor(options: MinSyncVectorMethodOptions);
     describe(): RetrievalMethodDescriptor;
     sync(): Promise<MinSyncSyncResult>;
@@ -33,5 +41,18 @@ export declare class MinSyncVectorMethod implements RetrievalMethod {
      * Returns: string path on success, undefined for missing-binary, or a MinSyncSyncResult
      * for install-failed.
      */
-    private resolveBinary;
+    protected resolveBinary(): Promise<string | undefined | MinSyncSyncResult>;
+}
+export declare class MinSyncBM25Method extends MinSyncVectorMethod {
+    private status;
+    constructor(options: MinSyncBM25MethodOptions);
+    describe(): RetrievalMethodDescriptor;
+    retrieve(query: string, options: RetrievalOptions): Promise<RetrievalResult[]>;
+    syncFromMinSync(result: MinSyncSyncResult): BM25SyncResult;
+    getStatus(): BM25Status;
+    private resolveBinaryForRetrieve;
+}
+export declare class MinSyncHybridMethod extends MinSyncVectorMethod {
+    constructor(options: MinSyncHybridMethodOptions);
+    describe(): RetrievalMethodDescriptor;
 }

package/dist/minsync/types.d.ts

@@ -13,12 +13,17 @@ export interface MinSyncEmbedderConfig {
     readonly maxRetries?: number;
     readonly maxConcurrent?: number;
 }
+/** MinSync chunker settings exposed by AutoRAG's public configuration. */
+export interface MinSyncChunkerConfig {
+    readonly maxChunkSize?: number;
+}
 export interface MinSyncOptions {
     readonly root: string;
     readonly binaryPath?: string;
     readonly workspacePath?: string;
     readonly autoInstall?: boolean;
     readonly embedder?: MinSyncEmbedderConfig;
+    readonly maxChunkSize?: number;
 }
 export interface MinSyncSyncResult {
     readonly ok: boolean;

package/dist/mirror/sync.d.ts

@@ -10,8 +10,10 @@ export interface ParsedMirrorSyncOptions {
     readonly force?: boolean;
     /** Override max source size for parse attempts (bytes). */
     readonly maxSourceBytes?: number;
+    /** Absolute source paths omitted from parsed mirrors (for example exact duplicate copies). */
+    readonly excludeSourcePaths?: ReadonlySet<string>;
 }
-export type ParsedMirrorDiagnosticCode = "unsupported-file" | "parser-skipped" | "parser-failed" | "deleted-mirror" | "stale-index";
+export type ParsedMirrorDiagnosticCode = "unsupported-file" | "parser-skipped" | "parser-failed" | "pdf-java-version" | "duplicate-excluded" | "deleted-mirror" | "stale-index" | "pdf-extract-thin" | "pdf-hybrid-unavailable";
 /** Path-opaque refresh diagnostic. `source` is an opaque virtual path, never a real fs path. */
 export interface ParsedMirrorDiagnostic {
     readonly code: ParsedMirrorDiagnosticCode;

package/dist/observability/run-log.d.ts

@@ -3,8 +3,7 @@ export type AutoRAGRunEvent = {
     timestamp: string;
     sessionId: string;
     queryLength: number;
-    orchestratorModel: string;
-    explorerModel: string;
+    model: string;
 } | {
     event: "search_completed";
     timestamp: string;
@@ -21,30 +20,6 @@ export type AutoRAGRunEvent = {
     sessionId: string;
     failureCount: number;
     errorTypes: string[];
-} | {
-    event: "dispatch_rejected";
-    schemaVersion: 1;
-    sessionId: string;
-    toolCallId: string | null;
-    sequence: number;
-    timestamp: string;
-    dispatchKind: "launch" | "admin" | "control" | "mutation" | "schedule" | "hybrid" | "unknown";
-    code: string;
-    field: string;
-    forceCorrectable: boolean;
-} | {
-    event: "dispatch_autofilled";
-    schemaVersion: 1;
-    sessionId: string;
-    toolCallId: string | null;
-    sequence: number;
-    timestamp: string;
-    dispatchKind: "launch";
-    fields: {
-        artifacts: boolean;
-        agentScope: boolean;
-        leafModelFillCount: number;
-    };
 };
 export declare class AutoRAGRunLogger {
     private readonly path;

package/dist/parser/defaults.d.ts

@@ -1,8 +1,10 @@
 import { type HwpParserOptions } from "./hwp.js";
 import { type OcrParserOptions } from "./ocr.js";
+import { type OpendataloaderPdfParserOptions } from "./opendataloader-pdf.js";
 import { ParserRegistry } from "./registry.js";
 export interface DefaultParserRegistryOptions {
     readonly ocr?: OcrParserOptions;
     readonly hwp?: HwpParserOptions;
+    readonly thinExtract?: OpendataloaderPdfParserOptions["thinExtract"];
 }
 export declare function createDefaultParserRegistry(options?: DefaultParserRegistryOptions): ParserRegistry;

package/dist/parser/index.d.ts

@@ -4,8 +4,8 @@ export { ParseError } from "./errors.js";
 export { HwpParser, type HwpParserOptions } from "./hwp.js";
 export { ImageOcrParser, type OcrEngine, type OcrEngineInput, type OcrParserOptions } from "./ocr.js";
 export { DocxParser, PptxParser, XlsxParser } from "./office.js";
-export { OpendataloaderPdfParser, type PdfConverter } from "./opendataloader-pdf.js";
+export { OpendataloaderPdfParser, type OpendataloaderPdfParserOptions, type PdfConverter, } from "./opendataloader-pdf.js";
 export { PlainTextParser } from "./plain-text.js";
 export { ParserRegistry } from "./registry.js";
 export type { HwpExtractionLimits, HwpExtractor } from "./rhwp-adapter.js";
-export { type ParseInput, type ParseOutput, Parser } from "./types.js";
+export { type ParseDiagnostic, type ParseDiagnosticCode, type ParseInput, type ParseOutput, Parser, } from "./types.js";

package/dist/parser/opendataloader-pdf.d.ts

@@ -10,6 +10,16 @@ export interface OpendataloaderPdfParserOptions {
         readonly hybridMode?: string;
         readonly maxBytes?: number;
     };
+    /** Quality gate for multi-page PDFs whose local markdown yield is abnormally thin. */
+    readonly thinExtract?: {
+        readonly enabled?: boolean;
+        readonly minPages?: number;
+        readonly minChars?: number;
+        readonly minCharsPerPage?: number;
+        readonly timeoutMs?: number;
+        readonly hybrid?: string;
+        readonly hybridMode?: string;
+    };
 }
 export declare class OpendataloaderPdfParser extends Parser {
     readonly name = "opendataloader-pdf";

package/dist/parser/types.d.ts

@@ -6,6 +6,13 @@ export interface ParseInput {
 export interface ParseOutput {
     readonly markdown: string;
     readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly diagnostics?: readonly ParseDiagnostic[];
+}
+export type ParseDiagnosticCode = "pdf-extract-thin" | "pdf-hybrid-unavailable";
+export interface ParseDiagnostic {
+    readonly code: ParseDiagnosticCode;
+    readonly severity: "warning";
+    readonly message: string;
 }
 export declare abstract class Parser {
     abstract readonly name: string;

package/dist/process/portable-spawn.d.ts

@@ -0,0 +1,10 @@
+export interface PortableSpawnCommand {
+    readonly command: string;
+    readonly args: readonly string[];
+}
+/**
+ * Windows does not execute Unix shebang files or extensionless scripts through
+ * child_process.spawn. Resolve test/dev script entrypoints through their
+ * interpreter while leaving native executables untouched.
+ */
+export declare function portableSpawnCommand(command: string, args: readonly string[], platform?: NodeJS.Platform): PortableSpawnCommand;

package/dist/retrieval/index.d.ts

@@ -1,7 +1,7 @@
 export type { MergeOptions } from "./merger.js";
 export { ParallelRetriever, ResultMerger } from "./merger.js";
-export type { BM25Engine, BM25FallbackMode, BM25MethodOptions, BM25ReadinessState, BM25Status, BM25SyncResult, } from "./methods/bm25.js";
-export { BM25Method, BM25UnavailableError } from "./methods/bm25.js";
+export type { BM25Engine, BM25ReadinessState, BM25Status, BM25SyncResult } from "./methods/bm25.js";
+export { BM25_SUBDIR, BM25UnavailableError, hasLegacyBm25Artifacts, removeLegacyBm25Artifacts, } from "./methods/bm25.js";
 export { RetrievalMethodRegistry } from "./registry.js";
 export { matchesVirtualPathScope, normalizeVirtualPath, normalizeVirtualPathScope, virtualPathScopeToRegExp, } from "./scope.js";
 export type { CuratedResult, NumberedResult, RetrievalDiagnostic, RetrievalDiagnosticCode, RetrievalMethod, RetrievalMethodDescriptor, RetrievalOptions, RetrievalResult, RetrievalWithDiagnostics, } from "./types.js";

package/dist/retrieval/methods/bm25.d.ts

@@ -1,15 +1,6 @@
-import type { RetrievalMethod, RetrievalMethodDescriptor, RetrievalOptions, RetrievalResult } from "../types.js";
-export type BM25ReadinessState = "disabled" | "dependency_unavailable" | "index_missing" | "indexing" | "ready" | "degraded_fallback" | "error";
-export type BM25Engine = "tantivy" | "typescript-fallback" | "none";
-export type BM25FallbackMode = "typescript" | "disabled";
-export interface BM25MethodOptions {
-    readonly root: string;
-    readonly indexPath?: string;
-    readonly enabled?: boolean;
-    readonly fallback?: BM25FallbackMode;
-    readonly forceEngine?: Exclude<BM25Engine, "none">;
-    readonly importBinding?: () => Promise<TantivyBinding>;
-}
+export type BM25ReadinessState = "disabled" | "dependency_unavailable" | "index_missing" | "indexing" | "ready" | "error";
+/** Local BM25 is always MinSync-backed when enabled. */
+export type BM25Engine = "minsync" | "none";
 export interface BM25SyncResult {
     readonly indexPath: string;
     readonly indexedChunks: number;
@@ -21,32 +12,12 @@ export interface BM25Status {
     readonly engine: BM25Engine;
     readonly message?: string;
 }
-type TantivyBinding = typeof import("@pngwasi/node-tantivy-binding");
+/** Legacy AutoRAG-local BM25 artifact directory. Never an active index. */
 export declare const BM25_SUBDIR: string;
 export declare class BM25UnavailableError extends Error {
     readonly readiness: BM25ReadinessState;
     constructor(readiness: BM25ReadinessState, message: string);
 }
-export declare class BM25Method implements RetrievalMethod {
-    private readonly root;
-    private readonly indexPath;
-    private readonly fallback;
-    private readonly forceEngine;
-    private readonly importBinding;
-    private status;
-    constructor(options: BM25MethodOptions);
-    describe(): RetrievalMethodDescriptor;
-    getStatus(): BM25Status;
-    sync(): Promise<BM25SyncResult>;
-    retrieve(query: string, options: RetrievalOptions): Promise<RetrievalResult[]>;
-    private writeTantivyIndex;
-    private retrieveTantivy;
-    private writeFallbackIndex;
-    private retrieveFallback;
-    private readFallbackIndex;
-    private hasFallbackIndex;
-    private tantivyIndexPath;
-    private fallbackIndexPath;
-    private syncResult;
-}
-export {};
+/** Remove leftover `.autorag/bm25` artifacts from the pre-MinSync BM25 path. */
+export declare function removeLegacyBm25Artifacts(root: string): void;
+export declare function hasLegacyBm25Artifacts(root: string): boolean;

package/dist/ui/browse.d.ts

@@ -0,0 +1,11 @@
+export interface BrowseEntry {
+    readonly name: string;
+    readonly path: string;
+    readonly directory: boolean;
+}
+export interface BrowseResult {
+    readonly path: string;
+    readonly parent: string | null;
+    readonly entries: readonly BrowseEntry[];
+}
+export declare function browseDirectory(inputPath: string | undefined): BrowseResult;

package/dist/ui/catalog.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Operator-facing connection catalog for the local datasource UI.
+ *
+ * Each built-in factory key gets a small form: paths, env-var *names*,
+ * feed/repo lists, and optional CLI binary paths. Secret values are never
+ * catalog fields.
+ */
+export declare const LOCAL_FOLDERS_ID = "local-folders";
+export type CatalogFieldKind = "text" | "path" | "path-list" | "env" | "textarea" | "select" | "checkbox";
+export interface CatalogField {
+    readonly key: string;
+    readonly label: string;
+    readonly kind: CatalogFieldKind;
+    readonly help?: string;
+    readonly required?: boolean;
+    readonly placeholder?: string;
+    readonly options?: readonly {
+        readonly value: string;
+        readonly label: string;
+    }[];
+}
+export interface DatasourceTypeCatalog {
+    readonly type: string;
+    readonly title: string;
+    readonly summary: string;
+    readonly defaultTags: readonly string[];
+    readonly binaryName?: string;
+    readonly installHint?: string;
+    readonly fields: readonly CatalogField[];
+}
+export declare const DATASOURCE_TYPE_CATALOG: readonly DatasourceTypeCatalog[];
+export declare function getDatasourceType(type: string): DatasourceTypeCatalog | undefined;
+export type SourcePickerKind = "folders" | "index" | "datasource";
+export interface SourcePickerEntry {
+    readonly type: string;
+    readonly title: string;
+    readonly summary: string;
+    readonly kind: SourcePickerKind;
+    readonly binaryName?: string;
+    readonly installHint?: string;
+    /** False for sources that cannot attach a second account (KakaoTalk). */
+    readonly supportsMultiple: boolean;
+    readonly extras: readonly PickerExtra[];
+}
+export type PickerExtraKind = "text" | "textarea" | "select" | "path";
+export interface PickerExtra {
+    readonly key: string;
+    readonly label: string;
+    readonly kind: PickerExtraKind;
+    readonly placeholder?: string;
+    readonly help?: string;
+    readonly choices?: "rclone-remotes" | "mail-accounts";
+    readonly allowOther?: boolean;
+    /** Asked in the coding-agent prompt when this extra is left blank. */
+    readonly question: string;
+}
+export declare const SOURCE_PICKER: readonly SourcePickerEntry[];
+export declare function getPickerEntry(type: string): SourcePickerEntry | undefined;
+export declare function assertCatalogCoversBuiltins(): void;

package/dist/ui/config-store.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Trusted config mutations for the local datasource UI.
+ *
+ * Reads/writes the operator `config.json` on disk. Never persists secret
+ * values — only env-var names, paths, and lists. Enabling a connection
+ * recomputes `datasourceAccess` from catalog tags + `/${alias}/**` scopes.
+ */
+import { DATASOURCE_TYPE_CATALOG, SOURCE_PICKER } from "./catalog.js";
+import { type ProbeResult } from "./probe.js";
+export interface ConnectionInput {
+    readonly alias: string;
+    readonly type: string;
+    readonly enabled?: boolean;
+    readonly instanceId?: string;
+    readonly connector?: Record<string, unknown>;
+    readonly tags?: readonly string[];
+}
+export interface UiConnection {
+    readonly alias: string;
+    readonly type: string;
+    readonly enabled: boolean;
+    readonly instanceId?: string;
+    readonly connector: Record<string, unknown>;
+    readonly tags: readonly string[];
+    readonly probe: ProbeResult;
+}
+export interface UiState {
+    readonly searchPaths: readonly string[];
+    readonly connections: readonly UiConnection[];
+    readonly catalog: typeof DATASOURCE_TYPE_CATALOG;
+    readonly picker: typeof SOURCE_PICKER;
+    readonly access: {
+        readonly allowedTags: readonly string[];
+        readonly allowedScopes: readonly string[];
+    };
+}
+export declare function listUiState(configPath: string, env?: NodeJS.ProcessEnv): UiState;
+export declare function upsertConnection(configPath: string, input: ConnectionInput): UiState;
+export declare function toggleConnection(configPath: string, alias: string, enabled: boolean): UiState;
+export declare function removeConnection(configPath: string, alias: string): UiState;
+export declare function setSearchPaths(configPath: string, searchPaths: readonly string[]): UiState;
+export declare function normalizeAlias(alias: string): string;
+export declare function stripSecrets<T>(value: T): T;

package/dist/ui/discover.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Best-effort local account/remote discovery for the datasource UI.
+ * Spawns operator CLIs with a short timeout. Failures return empty lists.
+ */
+export interface Choice {
+    readonly value: string;
+    readonly label: string;
+}
+export type DiscoverRun = (binary: string, args: readonly string[]) => Promise<{
+    ok: boolean;
+    stdout: string;
+}>;
+export declare function listRcloneRemotes(run?: DiscoverRun): Promise<readonly Choice[]>;
+export declare function listMailAccounts(run?: DiscoverRun): Promise<readonly Choice[]>;
+export declare function listHimalayaAccounts(run?: DiscoverRun): Promise<readonly Choice[]>;
+export declare function choicesForType(type: string, run?: DiscoverRun): Promise<{
+    rcloneRemotes: readonly Choice[];
+    mailAccounts: readonly Choice[];
+}>;

package/dist/ui/html.d.ts

@@ -0,0 +1,2 @@
+import type { UiState } from "./config-store.js";
+export declare function renderUiPage(state: UiState): string;

package/dist/ui/probe.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Local, side-effect-free connection probes for the datasource UI.
+ *
+ * Checks env-var presence, path existence, and CLI binaries on PATH.
+ * Never returns secret values.
+ */
+export type ProbeStatus = "ready" | "auth-missing" | "binary-missing" | "path-missing" | "not-configured" | "unknown-type";
+export interface ProbeResult {
+    readonly ok: boolean;
+    readonly status: ProbeStatus;
+    readonly detail: string;
+}
+export interface ProbeConnectionInput {
+    readonly alias: string;
+    readonly type: string;
+    readonly enabled?: boolean;
+    readonly connector?: Record<string, unknown>;
+}
+export interface ProbeDeps {
+    readonly env?: NodeJS.ProcessEnv;
+    readonly pathExists?: (path: string) => boolean;
+    readonly binaryExists?: (binaryName: string, binaryPath?: string) => boolean;
+}
+export declare function probeConnection(input: ProbeConnectionInput, deps?: ProbeDeps): ProbeResult;

package/dist/ui/prompt.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Short copy-paste prompt for a coding agent.
+ *
+ * The operator picks a type, names it, and may fill optional extras
+ * (repos, remotes, mailbox). Blank extras become questions the agent
+ * must ask the user.
+ */
+export interface RegistrationPromptInput {
+    readonly type: string;
+    readonly alias?: string;
+    readonly note?: string;
+    readonly extras?: Readonly<Record<string, string>>;
+}
+export interface RegistrationPrompt {
+    readonly type: string;
+    readonly title: string;
+    readonly alias: string;
+    readonly prompt: string;
+    readonly questions: readonly string[];
+}
+export declare function buildRegistrationPrompt(input: RegistrationPromptInput): RegistrationPrompt;

package/dist/ui/server.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Loopback-only HTTP server for the datasource UI.
+ *
+ * Binds 127.0.0.1 / ::1, requires a session token, and never returns secret
+ * connector values. This is a trusted local control plane — the same trust
+ * boundary as editing config.json by hand.
+ */
+export interface StartUiServerOptions {
+    readonly configPath: string;
+    readonly host?: string;
+    readonly port?: number;
+    readonly token: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly allowRemote?: boolean;
+    readonly publicOrigin?: string;
+    readonly corsOrigins?: readonly string[];
+}
+export interface UiServer {
+    readonly url: string;
+    readonly origin: string;
+    readonly host: string;
+    readonly port: number;
+    readonly token: string;
+    close(): Promise<void>;
+}
+export declare function isLoopbackHost(host: string): boolean;
+export declare function isLoopbackAddress(address: string | undefined): boolean;
+export declare function startUiServer(options: StartUiServerOptions): Promise<UiServer>;