@arnilo/prism-coding-agent 0.2.4 → 0.2.6

package/dist/process/types.d.ts

@@ -11,6 +11,8 @@ export interface ProcessSandboxHandle {
     }): Promise<{
         exitCode: number | null;
     }>;
+    /** Opaque non-secret reattachment ref for durable process recovery (plan 026 Task 5). */
+    readonly ref?: string;
 }
 export interface ProcessSandboxStartRequest {
     readonly file: string;
@@ -21,8 +23,7 @@ export interface ProcessSandboxStartRequest {
     readonly signal?: AbortSignal;
     readonly timeout?: number;
 }
-/**
- * Optional sandbox backend for ProcessSessions.
+/** Optional sandbox backend for ProcessSessions.
  * Presence of `startProcess` = long-running capable; absence fails closed.
  */
 export interface ProcessSandboxBackend {
@@ -31,8 +32,67 @@ export interface ProcessSandboxBackend {
         readonly state: string;
     }>;
 }
+/** Bounded terminal geometry + TERM for interactive PTY sessions (frozen caps in limits.ts). */
+export interface ProcessTerminalRequest {
+    /** 1..maxTerminalColumns (default 120; host-configured max wins when smaller). */
+    readonly columns?: number;
+    /** 1..maxTerminalRows (default 40; host-configured max wins when smaller). */
+    readonly rows?: number;
+    /** TERM string, UTF-8 bytes <= maxTerminalTermBytes (default "xterm-256color"). */
+    readonly term?: string;
+}
+/** Bounded resize dimensions for an interactive PTY session. */
+export interface ProcessTerminalResize {
+    readonly columns: number;
+    readonly rows: number;
+}
+/**
+ * Host PTY handle (mirrors ProcessSandboxHandle) plus optional bounded resize
+ * and backend metadata. Capability is explicit: the session handle exposes
+ * `resize` only when the backend declared `capabilities.resize`.
+ */
+export interface ProcessPtyHandle {
+    write(data: Uint8Array): Promise<void>;
+    signal(name: string): Promise<void>;
+    kill(): Promise<void>;
+    release(): Promise<void>;
+    resize?(dimensions: ProcessTerminalResize): Promise<void>;
+    /** Bounded host metadata (UTF-8 JSON bytes <= maxPtyBackendMetadataBytes), surfaced via session metadata(). */
+    readonly metadata?: Readonly<Record<string, string>>;
+    /** Opaque non-secret reattachment ref for durable process recovery (plan 026 Task 5). */
+    readonly ref?: string;
+    wait(options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<{
+        exitCode: number | null;
+    }>;
+}
+export interface ProcessPtyStartRequest {
+    readonly file: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+    readonly env?: Readonly<Record<string, string>>;
+    readonly columns: number;
+    readonly rows: number;
+    readonly term: string;
+    readonly onData?: (data: Buffer) => void;
+    readonly signal?: AbortSignal;
+}
+/**
+ * Host-selected PTY backend. Capability and metadata are explicit, never
+ * duck-typed: `pty: true` requires a backend whose `startPty` is present
+ * (otherwise `ERR_PRISM_PROCESS_PTY_UNSUPPORTED` before process creation) and
+ * `capabilities.resize` must be true for the session handle to expose resize.
+ */
+export interface ProcessPtyBackend {
+    startPty?(request: ProcessPtyStartRequest): Promise<ProcessPtyHandle>;
+    readonly capabilities?: {
+        readonly resize: boolean;
+    };
+}
 export type ProcessSessionState = "starting" | "running" | "exited" | "killed" | "released" | "expired" | "unknown";
-export type ProcessSessionErrorCode = "ERR_PRISM_PROCESS_POLICY" | "ERR_PRISM_PROCESS_OWNERSHIP" | "ERR_PRISM_PROCESS_STATE" | "ERR_PRISM_PROCESS_LIMIT" | "ERR_PRISM_PROCESS_PTY_UNSUPPORTED" | "ERR_PRISM_PROCESS_UNSUPPORTED";
+export type ProcessSessionErrorCode = "ERR_PRISM_PROCESS_POLICY" | "ERR_PRISM_PROCESS_OWNERSHIP" | "ERR_PRISM_PROCESS_STATE" | "ERR_PRISM_PROCESS_LIMIT" | "ERR_PRISM_PROCESS_PTY_UNSUPPORTED" | "ERR_PRISM_PROCESS_PTY_BACKEND" | "ERR_PRISM_PROCESS_PTY_LIMIT" | "ERR_PRISM_PROCESS_UNSUPPORTED";
 export declare class ProcessSessionError extends Error {
     readonly code: ProcessSessionErrorCode;
     constructor(code: ProcessSessionErrorCode, message: string);
@@ -43,6 +103,13 @@ export interface ProcessSessionLimits {
     readonly maxLifetimeMs?: number;
     readonly maxOutputChunkBytes?: number;
     readonly maxTotalOutputBytes?: number;
+    /** Phase 26: PTY terminal bounds (defaults/hard caps frozen in limits.ts). */
+    readonly maxTerminalColumns?: number;
+    readonly maxTerminalRows?: number;
+    readonly maxTerminalTermBytes?: number;
+    readonly maxTerminalResizesPerMinute?: number;
+    readonly maxPtyAttachTimeoutMs?: number;
+    readonly maxPtyBackendMetadataBytes?: number;
 }
 export interface ResolvedProcessSessionLimits {
     readonly maxSessions: number;
@@ -50,6 +117,12 @@ export interface ResolvedProcessSessionLimits {
     readonly maxLifetimeMs: number;
     readonly maxOutputChunkBytes: number;
     readonly maxTotalOutputBytes: number;
+    readonly maxTerminalColumns: number;
+    readonly maxTerminalRows: number;
+    readonly maxTerminalTermBytes: number;
+    readonly maxTerminalResizesPerMinute: number;
+    readonly maxPtyAttachTimeoutMs: number;
+    readonly maxPtyBackendMetadataBytes: number;
 }
 export declare function resolveProcessSessionLimits(limits?: ProcessSessionLimits): ResolvedProcessSessionLimits;
 export interface ProcessStartRequest {
@@ -57,13 +130,22 @@ export interface ProcessStartRequest {
     readonly args?: readonly string[];
     readonly cwd?: string;
     readonly env?: Readonly<Record<string, string>>;
-    /** Default false. true on unsupported platform → ERR_PRISM_PROCESS_PTY_UNSUPPORTED. */
+    /**
+     * Default false. true without a host ptyBackend.startPty →
+     * ERR_PRISM_PROCESS_PTY_UNSUPPORTED before process creation; backend
+     * failures → ERR_PRISM_PROCESS_PTY_BACKEND; terminal/resize/attach bounds →
+     * ERR_PRISM_PROCESS_PTY_LIMIT.
+     */
     readonly pty?: boolean;
+    /** Bounded terminal geometry + TERM for pty: true sessions. */
+    readonly terminal?: ProcessTerminalRequest;
     readonly lifetimeMs?: number;
     /** Owner string for this session; defaults to registry ownership key. */
     readonly owner?: string;
     /** When true, run cancel releases instead of killing (default kill). */
     readonly releaseOnCancel?: boolean;
+    /** Abortable start: an aborted signal fails the start before spawn persists. */
+    readonly signal?: AbortSignal;
 }
 export interface ProcessOutputChunk {
     readonly data: string;
@@ -85,6 +167,16 @@ export interface ProcessSessionMetadata {
     readonly exitedAt?: string;
     readonly state: ProcessSessionState;
     readonly releaseOnCancel: boolean;
+    /** True when the session runs through the host ptyBackend. */
+    readonly pty: boolean;
+    /** Resolved terminal geometry + TERM for PTY sessions (bounded at start). */
+    readonly terminal?: {
+        readonly columns: number;
+        readonly rows: number;
+        readonly term: string;
+    };
+    /** Bounded backend metadata (validated <= maxPtyBackendMetadataBytes at start). */
+    readonly ptyBackendMetadata?: Readonly<Record<string, string>>;
 }
 export interface ProcessSession {
     readonly id: string;
@@ -103,6 +195,8 @@ export interface ProcessSession {
     signal(name: "SIGTERM" | "SIGINT" | "SIGHUP"): Promise<void>;
     kill(): Promise<void>;
     release(): Promise<void>;
+    /** Present only when the host backend declared `capabilities.resize` (PTY sessions). */
+    resize?(dimensions: ProcessTerminalResize): Promise<void>;
 }
 export type CodingProcessEvent = {
     readonly type: "process_started" | "process_exited" | "process_killed" | "process_released" | "process_expired" | "process_unknown";
@@ -128,6 +222,17 @@ export interface ProcessSessions {
     reconcile(): Promise<{
         readonly markedUnknown: number;
     }>;
+    /**
+     * Durable process recovery (plan 026 Task 5): reconcile durable recovery
+     * records against the live registry — attach-if-attested via the host
+     * recovery backend, otherwise `starting|running` records atomically become
+     * `unknown`. Never fabricates an exit code and never probes PIDs. Requires
+     * `checkpoints` + `leases` + `ownerId` at construction, else
+     * ERR_PRISM_RECOVERY_UNSUPPORTED. O(owned records).
+     */
+    recover(options?: {
+        signal?: AbortSignal;
+    }): Promise<import("./recovery.js").ProcessRecoveryReport>;
     dispose(): Promise<void>;
 }
 export interface CreateProcessSessionsOptions {
@@ -143,4 +248,23 @@ export interface CreateProcessSessionsOptions {
      * (`ERR_PRISM_PROCESS_UNSUPPORTED`). Native spawn only when sandbox omitted.
      */
     readonly sandbox?: ProcessSandboxBackend;
+    /**
+     * Phase 26: optional host-selected PTY backend. `pty: true` delegates only
+     * to this backend; absent backend or missing startPty fails closed with
+     * `ERR_PRISM_PROCESS_PTY_UNSUPPORTED` before process creation.
+     */
+    readonly ptyBackend?: ProcessPtyBackend;
+    /**
+     * Phase 26 durable process recovery: intent is persisted before spawn and
+     * lifecycle transitions are CAS-written under LeaseStore fencing. All three
+     * of `checkpoints`, `leases`, and `ownerId` must be present together — a
+     * partial recovery configuration fails closed at construction. `recover()`
+     * is attach-if-attested via `recoveryBackend`; otherwise starting/running
+     * records atomically become unknown (no fabricated exit, no PID probing).
+     */
+    readonly checkpoints?: import("@arnilo/prism").CheckpointStore;
+    readonly leases?: import("@arnilo/prism").LeaseStore;
+    readonly ownerId?: string;
+    readonly recoveryBackend?: import("./recovery.js").ProcessRecoveryBackend;
+    readonly recoveryLimits?: import("./recovery.js").ProcessRecoveryLimits;
 }

package/dist/process/types.js

@@ -1,4 +1,4 @@
-import { DEFAULT_MAX_PROCESS_INPUT_BYTES, DEFAULT_MAX_PROCESS_LIFETIME_MS, DEFAULT_MAX_PROCESS_OUTPUT_CHUNK_BYTES, DEFAULT_MAX_PROCESS_SESSIONS, DEFAULT_MAX_PROCESS_TOTAL_OUTPUT_BYTES, HARD_MAX_PROCESS_INPUT_BYTES, HARD_MAX_PROCESS_LIFETIME_MS, HARD_MAX_PROCESS_OUTPUT_CHUNK_BYTES, HARD_MAX_PROCESS_SESSIONS, HARD_MAX_PROCESS_TOTAL_OUTPUT_BYTES, validateCodingLimit, } from "../limits.js";
+import { DEFAULT_MAX_PROCESS_INPUT_BYTES, DEFAULT_MAX_PROCESS_LIFETIME_MS, DEFAULT_MAX_PROCESS_OUTPUT_CHUNK_BYTES, DEFAULT_MAX_PROCESS_SESSIONS, DEFAULT_MAX_PROCESS_TOTAL_OUTPUT_BYTES, DEFAULT_MAX_PTY_ATTACH_TIMEOUT_MS, DEFAULT_MAX_PTY_BACKEND_METADATA_BYTES, DEFAULT_MAX_TERMINAL_COLUMNS, DEFAULT_MAX_TERMINAL_RESIZES_PER_MINUTE, DEFAULT_MAX_TERMINAL_ROWS, DEFAULT_MAX_TERMINAL_TERM_BYTES, HARD_MAX_PROCESS_INPUT_BYTES, HARD_MAX_PROCESS_LIFETIME_MS, HARD_MAX_PROCESS_OUTPUT_CHUNK_BYTES, HARD_MAX_PROCESS_SESSIONS, HARD_MAX_PROCESS_TOTAL_OUTPUT_BYTES, HARD_MAX_PTY_ATTACH_TIMEOUT_MS, HARD_MAX_PTY_BACKEND_METADATA_BYTES, HARD_MAX_TERMINAL_COLUMNS, HARD_MAX_TERMINAL_RESIZES_PER_MINUTE, HARD_MAX_TERMINAL_ROWS, HARD_MAX_TERMINAL_TERM_BYTES, validateCodingLimit, } from "../limits.js";
 export class ProcessSessionError extends Error {
     code;
     constructor(code, message) {
@@ -14,6 +14,12 @@ export function resolveProcessSessionLimits(limits) {
         maxLifetimeMs: validateCodingLimit("maxLifetimeMs", limits?.maxLifetimeMs ?? DEFAULT_MAX_PROCESS_LIFETIME_MS, HARD_MAX_PROCESS_LIFETIME_MS),
         maxOutputChunkBytes: validateCodingLimit("maxOutputChunkBytes", limits?.maxOutputChunkBytes ?? DEFAULT_MAX_PROCESS_OUTPUT_CHUNK_BYTES, HARD_MAX_PROCESS_OUTPUT_CHUNK_BYTES),
         maxTotalOutputBytes: validateCodingLimit("maxTotalOutputBytes", limits?.maxTotalOutputBytes ?? DEFAULT_MAX_PROCESS_TOTAL_OUTPUT_BYTES, HARD_MAX_PROCESS_TOTAL_OUTPUT_BYTES),
+        maxTerminalColumns: validateCodingLimit("maxTerminalColumns", limits?.maxTerminalColumns ?? DEFAULT_MAX_TERMINAL_COLUMNS, HARD_MAX_TERMINAL_COLUMNS),
+        maxTerminalRows: validateCodingLimit("maxTerminalRows", limits?.maxTerminalRows ?? DEFAULT_MAX_TERMINAL_ROWS, HARD_MAX_TERMINAL_ROWS),
+        maxTerminalTermBytes: validateCodingLimit("maxTerminalTermBytes", limits?.maxTerminalTermBytes ?? DEFAULT_MAX_TERMINAL_TERM_BYTES, HARD_MAX_TERMINAL_TERM_BYTES),
+        maxTerminalResizesPerMinute: validateCodingLimit("maxTerminalResizesPerMinute", limits?.maxTerminalResizesPerMinute ?? DEFAULT_MAX_TERMINAL_RESIZES_PER_MINUTE, HARD_MAX_TERMINAL_RESIZES_PER_MINUTE),
+        maxPtyAttachTimeoutMs: validateCodingLimit("maxPtyAttachTimeoutMs", limits?.maxPtyAttachTimeoutMs ?? DEFAULT_MAX_PTY_ATTACH_TIMEOUT_MS, HARD_MAX_PTY_ATTACH_TIMEOUT_MS),
+        maxPtyBackendMetadataBytes: validateCodingLimit("maxPtyBackendMetadataBytes", limits?.maxPtyBackendMetadataBytes ?? DEFAULT_MAX_PTY_BACKEND_METADATA_BYTES, HARD_MAX_PTY_BACKEND_METADATA_BYTES),
     };
 }
 //# sourceMappingURL=types.js.map

package/dist/repository/glob.d.ts

@@ -0,0 +1,4 @@
+import type { RepositoryGlobRequest, RepositoryGlobResult, ResolvedRepositoryLimits } from "./types.js";
+import type { RepositoryWalk } from "./walk.js";
+export declare function globLocal(request: RepositoryGlobRequest, defaults: ResolvedRepositoryLimits, walk: RepositoryWalk): Promise<RepositoryGlobResult>;
+/** Local filesystem repository operations (default backend). */

package/dist/repository/glob.js

@@ -0,0 +1,143 @@
+/** Repository glob family (0.2.5 plan 025 Task 1 split).
+ * Moved verbatim from repository.ts; public surface unchanged behind the barrel. */
+import { HARD_MAX_REPO_DEPTH, HARD_MAX_REPO_ENTRIES, HARD_MAX_REPO_RESULTS, validateCodingLimit, validateCodingLimitAllowZero, } from "../limits.js";
+import { expandGlobBraces, matchGlobPattern, validateGlobPattern } from "../glob-match.js";
+import { lstat } from "node:fs/promises";
+import { RepositoryError } from "./types.js";
+import { resolveRepoPath } from "./path.js";
+export async function globLocal(request, defaults, walk) {
+    try {
+        validateGlobPattern(request.pattern, defaults.maxPatternBytes, { braceExpansion: request.braceExpansion === true });
+    }
+    catch (error) {
+        throw new RepositoryError(error instanceof Error ? error.message : String(error));
+    }
+    // Opt-in bounded brace expansion: textual alternatives only (never touches the
+    // filesystem); bounds enforced by expandGlobBraces (max alternatives / bytes).
+    const patterns = request.braceExpansion === true ? expandGlobBraces(request.pattern) : [request.pattern];
+    const resolved = await resolveRepoPath(request.root, request.path);
+    const maxResults = validateCodingLimit("maxResults", request.maxResults ?? defaults.maxResults, HARD_MAX_REPO_RESULTS);
+    const offset = validateCodingLimitAllowZero("offset", request.offset ?? 0, HARD_MAX_REPO_ENTRIES);
+    const maxDepth = validateCodingLimit("maxDepth", request.maxDepth ?? defaults.maxDepth, HARD_MAX_REPO_DEPTH);
+    const exclude = new Set(request.exclude ?? defaults.exclude);
+    const deadlineAt = request.deadlineMs !== undefined ? Date.now() + request.deadlineMs : Date.now() + defaults.maxTimeMs;
+    const collected = [];
+    let scannedEntries = 0;
+    let scannedFiles = 0;
+    let seen = 0;
+    let truncated = false;
+    let truncatedBy = null;
+    const matchesAnyPattern = (relativePath) => {
+        for (const p of patterns) {
+            if (matchGlobPattern(p, relativePath))
+                return true;
+        }
+        return false;
+    };
+    const maybeCollect = (relativePath) => {
+        if (!matchesAnyPattern(relativePath))
+            return false;
+        if (seen < offset) {
+            seen++;
+            return false;
+        }
+        if (collected.length >= maxResults) {
+            truncated = true;
+            truncatedBy = "results";
+            return true;
+        }
+        collected.push(relativePath);
+        seen++;
+        return truncated;
+    };
+    try {
+        const startStat = await lstat(resolved.absolute);
+        if (!startStat.isDirectory()) {
+            scannedEntries = 1;
+            if (startStat.isFile()) {
+                scannedFiles = 1;
+                if (matchesAnyPattern(resolved.relative)) {
+                    if (offset === 0 && maxResults > 0)
+                        collected.push(resolved.relative);
+                    else if (offset === 0 && maxResults === 0) {
+                        truncated = true;
+                        truncatedBy = "results";
+                    }
+                }
+            }
+            return {
+                paths: collected,
+                truncated,
+                truncatedBy,
+                scannedEntries,
+                scannedFiles,
+                offset,
+                nextOffset: undefined,
+            };
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new RepositoryError(`cannot open path: ${message}`);
+    }
+    try {
+        for await (const event of walk(resolved.rootReal, resolved.absolute, {
+            maxDepth,
+            maxEntries: defaults.maxEntries,
+            maxFiles: defaults.maxFiles,
+            exclude,
+            includeHidden: request.includeHidden === true,
+            signal: request.signal,
+            deadlineAt,
+        })) {
+            if (event.type === "limit") {
+                truncated = true;
+                truncatedBy = event.truncatedBy;
+                break;
+            }
+            scannedEntries++;
+            if (event.entry.kind === "file")
+                scannedFiles++;
+            if (event.entry.kind !== "file")
+                continue;
+            if (maybeCollect(event.entry.path))
+                break;
+        }
+    }
+    catch (error) {
+        if (error instanceof RepositoryError && error.message === "Operation aborted") {
+            return {
+                paths: collected,
+                truncated: true,
+                truncatedBy: "abort",
+                scannedEntries,
+                scannedFiles,
+                offset,
+                nextOffset: collected.length > 0 || offset > 0 ? offset + collected.length : undefined,
+            };
+        }
+        if (error instanceof RepositoryError && error.message === "Repository operation exceeded time limit") {
+            return {
+                paths: collected,
+                truncated: true,
+                truncatedBy: "time",
+                scannedEntries,
+                scannedFiles,
+                offset,
+                nextOffset: offset + collected.length,
+            };
+        }
+        throw error;
+    }
+    return {
+        paths: collected,
+        truncated,
+        truncatedBy,
+        scannedEntries,
+        scannedFiles,
+        offset,
+        nextOffset: truncated ? offset + collected.length : undefined,
+    };
+}
+/** Local filesystem repository operations (default backend). */
+//# sourceMappingURL=glob.js.map

package/dist/repository/indexed-search.d.ts

@@ -0,0 +1,121 @@
+import type { RepositoryOperations } from "./types.js";
+/** Frozen index state machine: empty | building | ready | stale | failed. */
+export type IndexState = "empty" | "building" | "ready" | "stale" | "failed";
+export declare const INDEX_STATES: readonly IndexState[];
+export interface IndexResourceDiagnostics {
+    readonly entries: number;
+    readonly bytes: number;
+    readonly lastUpdatedAt?: number;
+}
+export interface RepositoryIndexStatus {
+    readonly state: IndexState;
+    /** Source revision the index was built from; required when `requireSourceRevision`. */
+    readonly sourceRevision?: string;
+    /** Indexed-at timestamp (epoch ms); used for the staleness age check. */
+    readonly updatedAt?: number;
+    readonly diagnostics?: IndexResourceDiagnostics;
+}
+export type IndexFileChangeKind = "add" | "edit" | "delete" | "rename";
+export interface IndexFileChange {
+    /** Repository-relative path (forward slashes, no leading slash, no `..`). */
+    readonly path: string;
+    readonly kind: IndexFileChangeKind;
+    /** Rename source path (repository-relative). */
+    readonly oldPath?: string;
+    readonly bytes?: number;
+}
+export interface RepositoryIndexUpdateRequest {
+    /** Optional host identity scoping (bounded; never credential-bearing). */
+    readonly repositoryId?: string;
+    readonly worktreeId?: string;
+    /** Revision the changes apply on top of. */
+    readonly sourceRevision: string;
+    readonly changes: readonly IndexFileChange[];
+}
+export interface RepositoryIndexRemoveRequest {
+    /** Repository-relative paths to drop from the index. */
+    readonly paths: readonly string[];
+}
+export interface IndexSearchHit {
+    /** Repository-relative path (validated for containment). */
+    readonly path: string;
+    /** Relevance in [0,1]; non-finite or out-of-range scores fail closed. */
+    readonly score: number;
+    /** Snippet text (bounded; treated as untrusted prompt-injection surface). */
+    readonly snippet: string;
+}
+export interface RepositoryIndexQueryRequest {
+    readonly query: string;
+    readonly mode: "indexed_literal" | "semantic";
+    /** Optional repository-relative scope filter. */
+    readonly path?: string;
+    readonly maxResults: number;
+    readonly signal?: AbortSignal;
+    readonly deadlineMs?: number;
+}
+export interface RepositoryIndexQueryResult {
+    readonly hits: readonly IndexSearchHit[];
+    readonly truncated: boolean;
+}
+export interface RepositoryIndexBackend {
+    /** Explicit capability declaration; semantic mode is never duck-typed. */
+    readonly capabilities: {
+        readonly semantic: boolean;
+    };
+    update(request: RepositoryIndexUpdateRequest): Promise<void>;
+    remove(request: RepositoryIndexRemoveRequest): Promise<void>;
+    search(request: RepositoryIndexQueryRequest): Promise<RepositoryIndexQueryResult>;
+    status(): Promise<RepositoryIndexStatus>;
+    dispose(): Promise<void>;
+}
+export interface ResolvedIndexLimits {
+    readonly maxUpdateFiles: number;
+    readonly maxUpdateBytes: number;
+    readonly maxResults: number;
+    readonly maxSnippetBytes: number;
+    readonly staleMaxAgeMs: number;
+    readonly queryTimeoutMs: number;
+}
+export interface IndexLimitOptions {
+    readonly maxUpdateFiles?: number;
+    readonly maxUpdateBytes?: number;
+    readonly maxResults?: number;
+    readonly maxSnippetBytes?: number;
+    readonly staleMaxAgeMs?: number;
+    readonly queryTimeoutMs?: number;
+}
+export declare function resolveIndexLimits(options?: IndexLimitOptions): ResolvedIndexLimits;
+export declare class IndexError extends Error {
+    readonly code: "ERR_PRISM_INDEX_UNSUPPORTED" | "ERR_PRISM_INDEX_STALE" | "ERR_PRISM_INDEX_FAILED" | "ERR_PRISM_INDEX_LIMIT" | "ERR_PRISM_INDEX_TIMEOUT" | "ERR_PRISM_INDEX_UNTRUSTED";
+    constructor(code: "ERR_PRISM_INDEX_UNSUPPORTED" | "ERR_PRISM_INDEX_STALE" | "ERR_PRISM_INDEX_FAILED" | "ERR_PRISM_INDEX_LIMIT" | "ERR_PRISM_INDEX_TIMEOUT" | "ERR_PRISM_INDEX_UNTRUSTED", message: string);
+}
+export interface IndexedRepositoryOptions {
+    /** Host-owned incremental index backend (never started or built implicitly). */
+    readonly index: RepositoryIndexBackend;
+    /** Literal fallback (e.g. createGitAwareRepositoryOperations) for mode "literal". */
+    readonly fallback: RepositoryOperations;
+    /** Modes this composite accepts; default literal only. `indexed_literal`/`semantic` must be listed explicitly. */
+    readonly allowedModes?: readonly ("literal" | "indexed_literal" | "semantic")[];
+    readonly stale?: {
+        readonly maxAgeMs?: number;
+        /** Require the index to attest a sourceRevision before serving queries. */
+        readonly requireSourceRevision?: boolean;
+    };
+    readonly limits?: IndexLimitOptions;
+}
+export interface IndexFacade {
+    update(request: RepositoryIndexUpdateRequest): Promise<void>;
+    remove(request: RepositoryIndexRemoveRequest): Promise<void>;
+    status(): Promise<RepositoryIndexStatus>;
+    dispose(): Promise<void>;
+}
+/**
+ * Compose a host index with a literal fallback. Mode "literal" is routed to
+ * `fallback` unchanged; indexed modes are served only by the host backend with
+ * freshness checks, result validation, and no silent fallback.
+ */
+export declare function createIndexedRepositoryOperations(cwd: string, options: IndexedRepositoryOptions): RepositoryOperations & {
+    readonly index: IndexFacade;
+};
+/** Stable repo-relative label used in errors; kept for tests and docs. */
+export declare function indexErrorCode(error: unknown): string | undefined;