@arnilo/prism-coding-agent 0.2.5 → 0.2.7

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

package/dist/repository/indexed-search.js

@@ -0,0 +1,313 @@
+/**
+ * Phase 26 Task 2: host-indexed repository search seam.
+ *
+ * `createIndexedRepositoryOperations` composes a host-owned incremental index
+ * backend with an existing literal `RepositoryOperations` fallback. `repo_search`
+ * stays bounded literal by default; `indexed_literal`/`semantic` modes are
+ * explicit and never fall back silently when the index is missing, stale, or
+ * failed. Index output is untrusted: every hit is containment-checked,
+ * bounded, and labeled `untrusted_index` on the result.
+ */
+import { isAbsolute, join, resolve } from "node:path";
+import { DEFAULT_MAX_INDEX_QUERY_TIMEOUT_MS, DEFAULT_MAX_INDEX_SNIPPET_BYTES, DEFAULT_MAX_INDEX_STALE_MAX_AGE_MS, DEFAULT_MAX_INDEX_UPDATE_BYTES, DEFAULT_MAX_INDEX_UPDATE_FILES, DEFAULT_MAX_REPO_RESULTS, HARD_MAX_INDEX_QUERY_TIMEOUT_MS, HARD_MAX_INDEX_SNIPPET_BYTES, HARD_MAX_INDEX_STALE_MAX_AGE_MS, HARD_MAX_INDEX_UPDATE_BYTES, HARD_MAX_INDEX_UPDATE_FILES, HARD_MAX_REPO_RESULTS, validateCodingLimit, } from "../limits.js";
+import { isPathInsideRoot } from "./path.js";
+export const INDEX_STATES = ["empty", "building", "ready", "stale", "failed"];
+export function resolveIndexLimits(options) {
+    return {
+        maxUpdateFiles: validateCodingLimit("maxUpdateFiles", options?.maxUpdateFiles ?? DEFAULT_MAX_INDEX_UPDATE_FILES, HARD_MAX_INDEX_UPDATE_FILES),
+        maxUpdateBytes: validateCodingLimit("maxUpdateBytes", options?.maxUpdateBytes ?? DEFAULT_MAX_INDEX_UPDATE_BYTES, HARD_MAX_INDEX_UPDATE_BYTES),
+        maxResults: validateCodingLimit("maxResults", options?.maxResults ?? DEFAULT_MAX_REPO_RESULTS, HARD_MAX_REPO_RESULTS),
+        maxSnippetBytes: validateCodingLimit("maxSnippetBytes", options?.maxSnippetBytes ?? DEFAULT_MAX_INDEX_SNIPPET_BYTES, HARD_MAX_INDEX_SNIPPET_BYTES),
+        staleMaxAgeMs: validateCodingLimit("staleMaxAgeMs", options?.staleMaxAgeMs ?? DEFAULT_MAX_INDEX_STALE_MAX_AGE_MS, HARD_MAX_INDEX_STALE_MAX_AGE_MS),
+        queryTimeoutMs: validateCodingLimit("queryTimeoutMs", options?.queryTimeoutMs ?? DEFAULT_MAX_INDEX_QUERY_TIMEOUT_MS, HARD_MAX_INDEX_QUERY_TIMEOUT_MS),
+    };
+}
+export class IndexError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "IndexError";
+    }
+}
+const MAX_IDENTITY_BYTES = 512;
+const MAX_REVISION_BYTES = 4096;
+function assertRelativeRepoPath(path) {
+    if (typeof path !== "string" || path.length === 0) {
+        throw new IndexError("ERR_PRISM_INDEX_UNTRUSTED", "index reported an invalid path");
+    }
+    if (path.startsWith("/") || path.includes("\\") || isAbsolute(path) || path === ".." || path.startsWith("../") || path.includes("/../")) {
+        throw new IndexError("ERR_PRISM_INDEX_UNTRUSTED", "index reported a path outside the repository");
+    }
+    return path;
+}
+function assertBoundedIdentity(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || Buffer.byteLength(value, "utf8") > MAX_IDENTITY_BYTES) {
+        throw new IndexError("ERR_PRISM_INDEX_LIMIT", `${label} exceeds the identity bound`);
+    }
+    return value;
+}
+function assertBoundedRevision(value) {
+    if (typeof value !== "string" || value.length === 0 || Buffer.byteLength(value, "utf8") > MAX_REVISION_BYTES) {
+        throw new IndexError("ERR_PRISM_INDEX_LIMIT", "sourceRevision is required and bounded");
+    }
+    return value;
+}
+function truncateUtf8(value, maxBytes) {
+    if (Buffer.byteLength(value, "utf8") <= maxBytes)
+        return value;
+    let end = 0;
+    let bytes = 0;
+    for (const char of value) {
+        const size = Buffer.byteLength(char, "utf8");
+        if (bytes + size > maxBytes)
+            break;
+        bytes += size;
+        end += char.length;
+    }
+    return value.slice(0, end);
+}
+function isFresh(status, staleMaxAgeMs, requireSourceRevision) {
+    switch (status.state) {
+        case "failed":
+            return new IndexError("ERR_PRISM_INDEX_FAILED", "index is failed; no search is served");
+        case "empty":
+            return new IndexError("ERR_PRISM_INDEX_STALE", "index has no data; update it before querying");
+        case "building":
+            return new IndexError("ERR_PRISM_INDEX_STALE", "index is still building");
+        case "ready":
+        case "stale":
+            break;
+        default:
+            return new IndexError("ERR_PRISM_INDEX_FAILED", "index reported an unknown state");
+    }
+    if (status.updatedAt === undefined) {
+        return new IndexError("ERR_PRISM_INDEX_STALE", "index does not attest a freshness timestamp");
+    }
+    if (Date.now() - status.updatedAt > staleMaxAgeMs) {
+        return new IndexError("ERR_PRISM_INDEX_STALE", "index is stale; refresh it before querying");
+    }
+    if (requireSourceRevision && status.sourceRevision === undefined) {
+        return new IndexError("ERR_PRISM_INDEX_STALE", "index does not attest a source revision");
+    }
+    return null;
+}
+function isIndexMode(mode) {
+    return mode === "indexed_literal" || mode === "semantic";
+}
+/**
+ * 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 function createIndexedRepositoryOperations(cwd, options) {
+    const allowed = new Set(options.allowedModes ?? ["literal"]);
+    const resolved = resolveIndexLimits(options.limits);
+    const staleMaxAgeMs = options.stale?.maxAgeMs ?? resolved.staleMaxAgeMs;
+    const requireSourceRevision = options.stale?.requireSourceRevision === true;
+    const root = resolve(cwd);
+    const backend = options.index;
+    async function checkFresh() {
+        let status;
+        try {
+            status = await backend.status();
+        }
+        catch {
+            throw new IndexError("ERR_PRISM_INDEX_FAILED", "index status failed");
+        }
+        const stale = isFresh(status, staleMaxAgeMs, requireSourceRevision);
+        if (stale)
+            throw stale;
+        return status;
+    }
+    function validateHit(hit, scope) {
+        const path = assertRelativeRepoPath(hit.path);
+        const absolute = join(root, ...path.split("/"));
+        if (!isPathInsideRoot(root, absolute)) {
+            throw new IndexError("ERR_PRISM_INDEX_UNTRUSTED", "index reported a path outside the repository root");
+        }
+        if (scope !== undefined && scope !== "." && path !== scope && !path.startsWith(`${scope}/`)) {
+            throw new IndexError("ERR_PRISM_INDEX_UNTRUSTED", "index reported a result outside the requested path scope");
+        }
+        if (typeof hit.score !== "number" || !Number.isFinite(hit.score) || hit.score < 0 || hit.score > 1) {
+            throw new IndexError("ERR_PRISM_INDEX_UNTRUSTED", "index reported an invalid score");
+        }
+        const snippet = typeof hit.snippet === "string" ? truncateUtf8(hit.snippet, resolved.maxSnippetBytes) : "";
+        return {
+            path,
+            line: 0,
+            column: 0,
+            text: snippet,
+            before: [],
+            after: [],
+            score: hit.score,
+        };
+    }
+    return {
+        async search(request) {
+            const mode = request.mode ?? "literal";
+            if (!isIndexMode(mode))
+                return options.fallback.search(request);
+            if (!allowed.has(mode)) {
+                throw new IndexError("ERR_PRISM_INDEX_UNSUPPORTED", `search mode ${mode} is not enabled on this composite`);
+            }
+            if (mode === "semantic" && backend.capabilities.semantic !== true) {
+                throw new IndexError("ERR_PRISM_INDEX_UNSUPPORTED", "semantic search is not supported by this index backend");
+            }
+            const status = await checkFresh();
+            let scope;
+            if (request.path !== undefined && request.path !== "" && request.path !== ".") {
+                scope = assertRelativeRepoPath(request.path);
+            }
+            const timeoutMs = Math.min(request.deadlineMs ?? resolved.queryTimeoutMs, resolved.queryTimeoutMs);
+            const deadlineAt = Date.now() + timeoutMs;
+            const maxResults = Math.min(resolved.maxResults, validateCodingLimit("maxMatches", request.maxMatches ?? resolved.maxResults, HARD_MAX_REPO_RESULTS));
+            let queryResult;
+            try {
+                queryResult = await Promise.race([
+                    backend.search({
+                        query: request.query,
+                        mode,
+                        path: scope,
+                        maxResults,
+                        signal: request.signal,
+                        deadlineMs: timeoutMs,
+                    }),
+                    new Promise((_, reject) => {
+                        const timer = setTimeout(() => reject(new IndexError("ERR_PRISM_INDEX_TIMEOUT", "index query timed out")), timeoutMs + 5);
+                        timer.unref();
+                    }),
+                ]);
+            }
+            catch (error) {
+                if (error instanceof IndexError)
+                    throw error;
+                if (request.signal?.aborted)
+                    throw new IndexError("ERR_PRISM_INDEX_TIMEOUT", "index query aborted");
+                throw new IndexError("ERR_PRISM_INDEX_FAILED", "index query failed");
+            }
+            if (Date.now() > deadlineAt) {
+                throw new IndexError("ERR_PRISM_INDEX_TIMEOUT", "index query exceeded the deadline");
+            }
+            const seen = new Set();
+            const matches = [];
+            for (const hit of queryResult.hits) {
+                if (matches.length >= maxResults)
+                    break;
+                const match = validateHit(hit, scope);
+                if (seen.has(match.path))
+                    continue; // duplicate paths: keep first
+                seen.add(match.path);
+                matches.push(match);
+            }
+            return {
+                matches,
+                truncated: queryResult.truncated || queryResult.hits.length > matches.length,
+                truncatedBy: queryResult.truncated || queryResult.hits.length > matches.length ? "index" : null,
+                scannedBytes: 0,
+                scannedFiles: 0,
+                scannedEntries: 0,
+                filesSkippedBinary: 0,
+                filesSkippedOversize: 0,
+                indexed: {
+                    mode,
+                    state: status.state,
+                    sourceRevision: status.sourceRevision,
+                    updatedAt: status.updatedAt,
+                },
+                untrusted_index: true,
+            };
+        },
+        list: (request) => options.fallback.list(request),
+        glob: (request) => options.fallback.glob(request),
+        index: {
+            async update(request) {
+                assertBoundedRevision(request.sourceRevision);
+                assertBoundedIdentity(request.repositoryId, "repositoryId");
+                assertBoundedIdentity(request.worktreeId, "worktreeId");
+                if (!Array.isArray(request.changes) || request.changes.length > resolved.maxUpdateFiles) {
+                    throw new IndexError("ERR_PRISM_INDEX_LIMIT", `update exceeds the ${resolved.maxUpdateFiles} change cap`);
+                }
+                let totalBytes = Buffer.byteLength(request.sourceRevision, "utf8");
+                const updates = [];
+                const removals = [];
+                for (const change of request.changes) {
+                    assertRelativeRepoPath(change.path);
+                    if (change.oldPath !== undefined)
+                        assertRelativeRepoPath(change.oldPath);
+                    if (change.bytes !== undefined && (typeof change.bytes !== "number" || !Number.isFinite(change.bytes) || change.bytes < 0)) {
+                        throw new IndexError("ERR_PRISM_INDEX_LIMIT", "change bytes must be a non-negative finite number");
+                    }
+                    totalBytes += Buffer.byteLength(change.path, "utf8") + (change.oldPath ? Buffer.byteLength(change.oldPath, "utf8") : 0);
+                    if (totalBytes > resolved.maxUpdateBytes) {
+                        throw new IndexError("ERR_PRISM_INDEX_LIMIT", `update exceeds the ${resolved.maxUpdateBytes} byte cap`);
+                    }
+                    if (change.kind === "delete") {
+                        removals.push(change.path);
+                    }
+                    else if (change.kind === "rename") {
+                        removals.push(change.oldPath);
+                        updates.push({ path: change.path, kind: "add", bytes: change.bytes });
+                    }
+                    else {
+                        updates.push(change);
+                    }
+                }
+                try {
+                    if (updates.length > 0)
+                        await backend.update({
+                            repositoryId: request.repositoryId,
+                            worktreeId: request.worktreeId,
+                            sourceRevision: request.sourceRevision,
+                            changes: updates,
+                        });
+                    if (removals.length > 0)
+                        await backend.remove({ paths: removals });
+                }
+                catch {
+                    throw new IndexError("ERR_PRISM_INDEX_FAILED", "index update failed");
+                }
+            },
+            async remove(request) {
+                if (!Array.isArray(request.paths) || request.paths.length > resolved.maxUpdateFiles) {
+                    throw new IndexError("ERR_PRISM_INDEX_LIMIT", `remove exceeds the ${resolved.maxUpdateFiles} path cap`);
+                }
+                const paths = request.paths.map((p) => assertRelativeRepoPath(p));
+                try {
+                    await backend.remove({ paths });
+                }
+                catch {
+                    throw new IndexError("ERR_PRISM_INDEX_FAILED", "index remove failed");
+                }
+            },
+            async status() {
+                let status;
+                try {
+                    status = await backend.status();
+                }
+                catch {
+                    throw new IndexError("ERR_PRISM_INDEX_FAILED", "index status failed");
+                }
+                if (!INDEX_STATES.includes(status.state)) {
+                    throw new IndexError("ERR_PRISM_INDEX_FAILED", "index reported an unknown state");
+                }
+                return status;
+            },
+            async dispose() {
+                try {
+                    await backend.dispose();
+                }
+                catch {
+                    throw new IndexError("ERR_PRISM_INDEX_FAILED", "index dispose failed");
+                }
+            },
+        },
+    };
+}
+/** Stable repo-relative label used in errors; kept for tests and docs. */
+export function indexErrorCode(error) {
+    return error instanceof IndexError ? error.code : undefined;
+}
+//# sourceMappingURL=indexed-search.js.map