@hyperdrive.bot/paseo-server 0.2.8 → 0.3.1

package/dist/server/server/file-explorer/service.js

@@ -5,6 +5,15 @@ import { expandUserPath, resolvePathFromBase } from "../path-utils.js";
 import { IMAGE_MIME_TYPES, isImageMimeType, resolveBinaryMimeType } from "./mime-types.js";
 const TEXT_MIME_TYPES = {
     ".json": "application/json",
+    // HTML is textual, so it classifies as `kind: "text"` and its bytes arrive as UTF-8.
+    // Naming the mime honestly is what lets the client render it instead of showing source.
+    ".html": "text/html",
+    ".htm": "text/html",
+    ".xhtml": "application/xhtml+xml",
+    ".css": "text/css",
+    ".csv": "text/csv",
+    ".xml": "application/xml",
+    ".md": "text/markdown",
 };
 const DEFAULT_TEXT_MIME_TYPE = "text/plain";
 const FILE_TYPE_SAMPLE_BYTES = 8192;

package/dist/server/server/search/extract.d.ts

@@ -0,0 +1,53 @@
+/** Max characters indexed from a single tool input/result block. */
+export declare const TOOL_BLOCK_CAP: number;
+/** Which FTS column a block feeds. */
+export type Lane = "text" | "tool";
+export interface ExtractedBlock {
+    lane: Lane;
+    /** "user" | "assistant" | "system" | "tool" — informational, not indexed. */
+    role: string;
+    text: string;
+    /** True when the source payload exceeded TOOL_BLOCK_CAP and was cut. */
+    truncated: boolean;
+}
+export interface ExtractedRecord {
+    blocks: ExtractedBlock[];
+    /** ISO timestamp for the record, when the provider supplies one. */
+    timestamp: string | null;
+    /** Session id carried in the record, when the provider supplies one. */
+    sid: string | null;
+    /**
+     * The TRUE working directory, read from the record itself.
+     *
+     * This must never be reverse-engineered from Claude's project-dir slug.
+     * The slug replaces every non-alphanumeric character with "-", so it is a
+     * lossy, irreversible encoding: `/home/claudiao/super-repo` and
+     * `/home/claudiao/super/repo` produce the SAME slug. Decoding it back
+     * yields `super/repo`, a directory that does not exist — and since the
+     * command palette resumes a session INTO its cwd, a wrong cwd makes the
+     * hit unresumable. That is the defect that made the old search results
+     * unusable even when they were correct.
+     *
+     * Slug-derived cwd is kept only as a last-resort display fallback for
+     * transcripts that carry no cwd at all.
+     */
+    cwd: string | null;
+}
+export declare function extractClaudeRecord(record: unknown): ExtractedRecord;
+export declare function extractCodexRecord(record: unknown): ExtractedRecord;
+export interface PaseoAgentMeta {
+    agentId: string;
+    provider: string | null;
+    cwd: string | null;
+    title: string | null;
+    /** runtimeInfo.sessionId — the join key into the provider's transcript. */
+    linkedSessionId: string | null;
+    workspaceId: string | null;
+    labels: Record<string, string>;
+    updatedAt: string | null;
+}
+export declare function extractPaseoAgent(record: unknown): {
+    meta: PaseoAgentMeta | null;
+    blocks: ExtractedBlock[];
+};
+//# sourceMappingURL=extract.d.ts.map

package/dist/server/server/search/extract.js

@@ -0,0 +1,222 @@
+// MARRA CUSTOMIZATION — universal transcript text extraction for session FTS.
+//
+// One job: turn a raw transcript record (whatever the provider's shape) into
+// zero or more `ExtractedBlock`s of searchable text. Nothing here touches the
+// filesystem or SQLite, so it is trivially unit-testable per provider.
+//
+// Two text lanes, deliberately kept apart:
+//   • "text"  — prose a human or the assistant actually wrote.
+//   • "tool"  — tool names, tool inputs, tool results.
+// They land in separate FTS5 columns so the ranker can weight typed prose
+// above tool spew. Searching a phrase you typed should surface the message
+// where you typed it, not the 400 grep hits that happen to contain it.
+//
+// Tool payloads are capped per block (see TOOL_BLOCK_CAP). Measured on the
+// real 4.6 GB corpus: tool traffic is 92% of all indexable text, and capping
+// at 8 KB cuts it 64% (1.12 GB → 0.40 GB) while keeping the identifying head
+// of every result — the command, the path, the first ~100 lines of output.
+// Nobody finds anything by searching the 700th KB of a file dump. Blocks that
+// were cut set `truncated`, so coverage claims stay honest.
+/** Max characters indexed from a single tool input/result block. */
+export const TOOL_BLOCK_CAP = 8 * 1024;
+const EMPTY = { blocks: [], timestamp: null, sid: null, cwd: null };
+function cap(raw) {
+    if (raw.length <= TOOL_BLOCK_CAP)
+        return { text: raw, truncated: false };
+    return { text: raw.slice(0, TOOL_BLOCK_CAP), truncated: true };
+}
+/** JSON.stringify that never throws (cycles, BigInt, exotic values). */
+function safeStringify(value) {
+    if (typeof value === "string")
+        return value;
+    if (value === null || value === undefined)
+        return "";
+    try {
+        return JSON.stringify(value) ?? "";
+    }
+    catch {
+        return String(value);
+    }
+}
+function pushProse(out, role, text) {
+    if (typeof text !== "string")
+        return;
+    const trimmed = text.trim();
+    if (trimmed.length === 0)
+        return;
+    out.push({ lane: "text", role, text: trimmed, truncated: false });
+}
+function pushTool(out, role, raw) {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0)
+        return;
+    const { text, truncated } = cap(trimmed);
+    out.push({ lane: "tool", role, text, truncated });
+}
+// ---------------------------------------------------------------------------
+// Claude Code — ~/.claude/projects/<cwd-slug>/<sid>.jsonl
+// ---------------------------------------------------------------------------
+//
+// One JSON object per line. Conversation records carry `message: { role,
+// content }` where content is a string or an array of Anthropic content
+// blocks. Non-conversation lines (hook attachments, queue-operation,
+// custom-title) have no `message` and are skipped — they are 74% of the raw
+// bytes and contain nothing a human typed.
+export function extractClaudeRecord(record) {
+    if (typeof record !== "object" || record === null)
+        return EMPTY;
+    const rec = record;
+    const message = rec.message;
+    if (typeof message !== "object" || message === null)
+        return EMPTY;
+    const msg = message;
+    const role = typeof msg.role === "string" ? msg.role : "unknown";
+    const timestamp = typeof rec.timestamp === "string" ? rec.timestamp : null;
+    const sid = typeof rec.sessionId === "string" ? rec.sessionId : null;
+    // The authoritative cwd. Present on ~74% of records; the indexer keeps the
+    // first non-null it sees per file.
+    const cwd = typeof rec.cwd === "string" && rec.cwd.length > 0 ? rec.cwd : null;
+    const blocks = [];
+    const content = msg.content;
+    if (typeof content === "string") {
+        pushProse(blocks, role, content);
+        return { blocks, timestamp, sid, cwd };
+    }
+    if (!Array.isArray(content))
+        return { blocks, timestamp, sid, cwd };
+    for (const block of content) {
+        pushClaudeContentBlock(blocks, role, block);
+    }
+    return { blocks, timestamp, sid, cwd };
+}
+/** Route a single Anthropic content block into the right lane. */
+function pushClaudeContentBlock(out, role, block) {
+    // Some records carry bare strings inside the content array.
+    if (typeof block === "string") {
+        pushProse(out, role, block);
+        return;
+    }
+    if (typeof block !== "object" || block === null)
+        return;
+    const b = block;
+    switch (b.type) {
+        case "text":
+            pushProse(out, role, b.text);
+            return;
+        case "thinking":
+            pushProse(out, "thinking", b.thinking);
+            return;
+        case "tool_use": {
+            const name = typeof b.name === "string" ? b.name : "tool";
+            pushTool(out, "tool_use", `${name} ${safeStringify(b.input)}`);
+            return;
+        }
+        case "tool_result":
+            pushTool(out, "tool_result", safeStringify(b.content));
+            return;
+        default:
+            return;
+    }
+}
+// ---------------------------------------------------------------------------
+// Codex CLI — ~/.codex/sessions/**/rollout-*.jsonl
+// ---------------------------------------------------------------------------
+//
+// UNVERIFIED AGAINST REAL DATA. `~/.codex/` on the dev box holds only
+// `prompts/` — zero session rollouts — so this adapter is unit-tested against
+// a fixture and MUST be re-validated the first time a real Codex session
+// exists. It is written defensively: unknown shapes yield no blocks rather
+// than garbage.
+//
+// Codex rollout lines wrap a payload: `{ type, payload: { type, role,
+// content: [{ type: "input_text" | "output_text", text }] } }`, with function
+// calls as `function_call` / `function_call_output`.
+export function extractCodexRecord(record) {
+    if (typeof record !== "object" || record === null)
+        return EMPTY;
+    const rec = record;
+    const payloadRaw = typeof rec.payload === "object" && rec.payload !== null ? rec.payload : rec;
+    const p = payloadRaw;
+    const timestamp = typeof rec.timestamp === "string" ? rec.timestamp : null;
+    const sid = typeof rec.session_id === "string" ? rec.session_id : null;
+    const cwd = typeof rec.cwd === "string" && rec.cwd.length > 0 ? rec.cwd : null;
+    const role = typeof p.role === "string" ? p.role : "unknown";
+    const blocks = [];
+    pushCodexPayload(blocks, role, p);
+    return { blocks, timestamp, sid, cwd };
+}
+/** Route one Codex rollout payload into the right lane. */
+function pushCodexPayload(out, role, p) {
+    switch (typeof p.type === "string" ? p.type : "") {
+        case "function_call": {
+            const name = typeof p.name === "string" ? p.name : "tool";
+            pushTool(out, "tool_use", `${name} ${safeStringify(p.arguments)}`);
+            return;
+        }
+        case "function_call_output":
+            pushTool(out, "tool_result", safeStringify(p.output));
+            return;
+        case "reasoning":
+            for (const s of Array.isArray(p.summary) ? p.summary : []) {
+                if (typeof s === "object" && s !== null) {
+                    pushProse(out, "thinking", s.text);
+                }
+            }
+            return;
+        default:
+            pushCodexContent(out, role, p.content);
+    }
+}
+function pushCodexContent(out, role, content) {
+    if (typeof content === "string") {
+        pushProse(out, role, content);
+        return;
+    }
+    if (!Array.isArray(content))
+        return;
+    for (const block of content) {
+        if (typeof block === "string") {
+            pushProse(out, role, block);
+            continue;
+        }
+        if (typeof block !== "object" || block === null)
+            continue;
+        // input_text / output_text / text all carry `.text`.
+        pushProse(out, role, block.text);
+    }
+}
+export function extractPaseoAgent(record) {
+    if (typeof record !== "object" || record === null)
+        return { meta: null, blocks: [] };
+    const r = record;
+    const agentId = typeof r.id === "string" ? r.id : null;
+    if (!agentId)
+        return { meta: null, blocks: [] };
+    const runtime = typeof r.runtimeInfo === "object" && r.runtimeInfo !== null
+        ? r.runtimeInfo
+        : {};
+    const rawLabels = typeof r.labels === "object" && r.labels !== null ? r.labels : {};
+    const labels = {};
+    for (const [k, v] of Object.entries(rawLabels)) {
+        if (typeof v === "string")
+            labels[k] = v;
+    }
+    const meta = {
+        agentId,
+        provider: typeof r.provider === "string" ? r.provider : null,
+        cwd: typeof r.cwd === "string" ? r.cwd : null,
+        title: typeof r.title === "string" ? r.title : null,
+        linkedSessionId: typeof runtime.sessionId === "string" ? runtime.sessionId : null,
+        workspaceId: typeof r.workspaceId === "string" ? r.workspaceId : null,
+        labels,
+        updatedAt: typeof r.updatedAt === "string" ? r.updatedAt : null,
+    };
+    const blocks = [];
+    pushProse(blocks, "title", meta.title);
+    const labelText = Object.entries(labels)
+        .map(([k, v]) => `${k}:${v}`)
+        .join(" ");
+    pushProse(blocks, "labels", labelText);
+    return { meta, blocks };
+}
+//# sourceMappingURL=extract.js.map

package/dist/server/server/search/index-store.d.ts

@@ -0,0 +1,83 @@
+/** Bump when the schema or extraction changes in a way that invalidates rows. */
+export declare const INDEX_SCHEMA_VERSION = 1;
+export interface FileState {
+    path: string;
+    size: number;
+    mtimeMs: number;
+    /** Bytes already consumed. Next pass reads from here. */
+    offset: number;
+}
+export interface ChunkInput {
+    path: string;
+    sid: string;
+    source: string;
+    cwd: string;
+    timestamp: string | null;
+    /** Typed prose. Empty string when this chunk is tool-only. */
+    text: string;
+    /** Tool names, inputs, results. Empty string when prose-only. */
+    tool: string;
+    truncated: boolean;
+}
+export interface SearchHit {
+    sid: string;
+    source: string;
+    cwd: string;
+    timestamp: string;
+    snippet: string;
+    path: string;
+    /** True when the winning snippet came from tool traffic, not typed prose. */
+    fromTool: boolean;
+    score: number;
+}
+export interface IndexStats {
+    files: number;
+    chunks: number;
+    truncatedChunks: number;
+    bytesConsumed: number;
+}
+export declare class SessionIndexStore {
+    private readonly db;
+    private insertChunkStmt;
+    private upsertFileStmt;
+    constructor(dbPath: string, options?: {
+        readOnly?: boolean;
+    });
+    private migrate;
+    /** Byte offsets already consumed, keyed by path. */
+    getFileStates(): Map<string, FileState>;
+    /**
+     * Drop every chunk for a file. Used when a transcript is rewritten or
+     * truncated (size shrank), where the append-only assumption no longer holds
+     * and resuming from the old offset would index garbage.
+     */
+    forgetFile(path: string): void;
+    /** Drop files that no longer exist on disk, so search never offers a dead session. */
+    pruneMissing(existingPaths: Set<string>): number;
+    /** Append chunks and record the new offset for a file, atomically. */
+    commitFile(state: FileState, source: string, sid: string, cwd: string, chunks: ChunkInput[]): void;
+    stats(): IndexStats;
+    /**
+     * FTS5 MATCH over both lanes, ranked with typed prose weighted above tool
+     * traffic. Returns at most one hit per session (the best-scoring chunk), so
+     * the palette shows 20 distinct sessions rather than 20 hits in one file.
+     */
+    search(params: {
+        query: string;
+        limit?: number;
+        sources?: string[];
+    }): SearchHit[];
+    close(): void;
+}
+/**
+ * Turn user input into a safe FTS5 MATCH expression.
+ *
+ * Users type prose, not query DSL. Raw input reaches FTS5's parser and a bare
+ * `-` or an unbalanced `"` throws mid-keystroke, which reads as "search is
+ * broken". Every token is quoted (making it a literal) and multi-token input
+ * becomes an implicit AND, which is what people expect from a search box.
+ * A trailing `*` on the last token gives prefix matching so results appear
+ * while still typing.
+ */
+export declare function toMatchExpression(raw: string): string | null;
+//# sourceMappingURL=index-store.d.ts.map

package/dist/server/server/search/index-store.js

@@ -0,0 +1,241 @@
+// MARRA CUSTOMIZATION — SQLite FTS5 store for universal session search.
+//
+// Replaces the `recall` CLI, which failed structurally rather than by bad
+// tuning: it spawned a subprocess per keystroke, re-indexed its whole Tantivy
+// store on every spawn, and took a global writer lock while doing it. On a
+// loaded host (39-agent fleet, load ~100) every cmd+K keystroke timed out, so
+// the feature was disabled by default in 73ae98f3.
+//
+// All three of those go away here:
+//   • no subprocess      — node:sqlite is in-process (verified FTS5 on v24)
+//   • no reindex-per-query — writes happen only in the background indexer
+//   • no global lock     — WAL, and the query path is read-only
+//
+// Schema notes:
+//   `files`  — one row per transcript file, carrying the byte offset we have
+//              consumed. Transcripts are append-only, so a pass reads only
+//              [offset, EOF). The 214 MB monster is read once, ever.
+//   `chunks` — FTS5, two indexed columns so typed prose can outrank tool spew.
+//              `unicode61 remove_diacritics 2` is required, not cosmetic:
+//              without it "periodo" does not match "Período" and PT-BR search
+//              silently half-works.
+import { DatabaseSync } from "node:sqlite";
+/** Bump when the schema or extraction changes in a way that invalidates rows. */
+export const INDEX_SCHEMA_VERSION = 1;
+/** bm25 weights: typed prose counts 10x a tool payload hit. */
+const WEIGHT_TEXT = 10.0;
+const WEIGHT_TOOL = 1.0;
+const MIN_QUERY_LEN = 2;
+const DEFAULT_LIMIT = 20;
+const MAX_LIMIT = 100;
+export class SessionIndexStore {
+    constructor(dbPath, options = {}) {
+        this.insertChunkStmt = null;
+        this.upsertFileStmt = null;
+        this.db = new DatabaseSync(dbPath, options.readOnly ? { readOnly: true } : {});
+        if (!options.readOnly) {
+            this.db.exec("PRAGMA journal_mode = WAL");
+            // Durability is not worth the fsync cost here: the index is a derived
+            // cache. A torn write costs a re-index of that file, nothing more.
+            this.db.exec("PRAGMA synchronous = NORMAL");
+            this.migrate();
+        }
+    }
+    migrate() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS meta (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS files (
+        path   TEXT PRIMARY KEY,
+        source TEXT NOT NULL,
+        sid    TEXT NOT NULL,
+        cwd    TEXT NOT NULL,
+        size   INTEGER NOT NULL,
+        mtime  INTEGER NOT NULL,
+        offset INTEGER NOT NULL
+      );
+      CREATE VIRTUAL TABLE IF NOT EXISTS chunks USING fts5(
+        text,
+        tool,
+        path      UNINDEXED,
+        sid       UNINDEXED,
+        source    UNINDEXED,
+        cwd       UNINDEXED,
+        ts        UNINDEXED,
+        truncated UNINDEXED,
+        tokenize = 'unicode61 remove_diacritics 2'
+      );
+    `);
+        const row = this.db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+        const current = row ? Number.parseInt(row.value, 10) : 0;
+        if (current !== INDEX_SCHEMA_VERSION) {
+            // Derived data — a schema change just rebuilds rather than migrating.
+            this.db.exec("DELETE FROM chunks; DELETE FROM files;");
+            this.db
+                .prepare("INSERT OR REPLACE INTO meta (key, value) VALUES ('schema_version', ?)")
+                .run(String(INDEX_SCHEMA_VERSION));
+        }
+    }
+    /** Byte offsets already consumed, keyed by path. */
+    getFileStates() {
+        const rows = this.db.prepare("SELECT path, size, mtime, offset FROM files").all();
+        const map = new Map();
+        for (const r of rows) {
+            map.set(r.path, { path: r.path, size: r.size, mtimeMs: r.mtime, offset: r.offset });
+        }
+        return map;
+    }
+    /**
+     * Drop every chunk for a file. Used when a transcript is rewritten or
+     * truncated (size shrank), where the append-only assumption no longer holds
+     * and resuming from the old offset would index garbage.
+     */
+    forgetFile(path) {
+        this.db.prepare("DELETE FROM chunks WHERE path = ?").run(path);
+        this.db.prepare("DELETE FROM files WHERE path = ?").run(path);
+    }
+    /** Drop files that no longer exist on disk, so search never offers a dead session. */
+    pruneMissing(existingPaths) {
+        const rows = this.db.prepare("SELECT path FROM files").all();
+        let dropped = 0;
+        for (const r of rows) {
+            if (!existingPaths.has(r.path)) {
+                this.forgetFile(r.path);
+                dropped += 1;
+            }
+        }
+        return dropped;
+    }
+    /** Append chunks and record the new offset for a file, atomically. */
+    commitFile(state, source, sid, cwd, chunks) {
+        this.insertChunkStmt ?? (this.insertChunkStmt = this.db.prepare(`INSERT INTO chunks (text, tool, path, sid, source, cwd, ts, truncated)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`));
+        this.upsertFileStmt ?? (this.upsertFileStmt = this.db.prepare(`INSERT INTO files (path, source, sid, cwd, size, mtime, offset)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(path) DO UPDATE SET
+         size = excluded.size, mtime = excluded.mtime, offset = excluded.offset`));
+        this.db.exec("BEGIN");
+        try {
+            for (const c of chunks) {
+                this.insertChunkStmt.run(c.text, c.tool, c.path, c.sid, c.source, c.cwd, c.timestamp ?? "", c.truncated ? 1 : 0);
+            }
+            this.upsertFileStmt.run(state.path, source, sid, cwd, state.size, Math.floor(state.mtimeMs), state.offset);
+            this.db.exec("COMMIT");
+        }
+        catch (err) {
+            this.db.exec("ROLLBACK");
+            throw err;
+        }
+    }
+    stats() {
+        const f = this.db.prepare("SELECT COUNT(*) c, COALESCE(SUM(offset),0) b FROM files").get();
+        const ch = this.db.prepare("SELECT COUNT(*) c FROM chunks").get();
+        // FTS5 stores every column value as text, so the integer 1 written by
+        // commitFile comes back as '1' or 1 depending on the binding path. CAST
+        // makes the comparison independent of that — without it this counter
+        // silently reads 0 and we would under-report truncation.
+        const tr = this.db
+            .prepare("SELECT COUNT(*) c FROM chunks WHERE CAST(truncated AS INTEGER) = 1")
+            .get();
+        return { files: f.c, chunks: ch.c, truncatedChunks: tr.c, bytesConsumed: f.b };
+    }
+    /**
+     * FTS5 MATCH over both lanes, ranked with typed prose weighted above tool
+     * traffic. Returns at most one hit per session (the best-scoring chunk), so
+     * the palette shows 20 distinct sessions rather than 20 hits in one file.
+     */
+    search(params) {
+        const query = params.query.trim();
+        if (query.length < MIN_QUERY_LEN)
+            return [];
+        const limit = Math.min(Math.max(params.limit ?? DEFAULT_LIMIT, 1), MAX_LIMIT);
+        const matchExpr = toMatchExpression(query);
+        if (!matchExpr)
+            return [];
+        const sourceFilter = params.sources && params.sources.length > 0
+            ? ` AND source IN (${params.sources.map(() => "?").join(",")})`
+            : "";
+        // Rank first, then pick the best chunk per session. Over-fetch so that a
+        // single chatty session cannot crowd out the rest of the result set.
+        const sql = `
+      SELECT sid, source, cwd, ts,
+             snippet(chunks, 0, '‹', '›', '…', 14) AS snip_text,
+             snippet(chunks, 1, '‹', '›', '…', 14) AS snip_tool,
+             path,
+             bm25(chunks, ${WEIGHT_TEXT}, ${WEIGHT_TOOL}) AS score
+      FROM chunks
+      WHERE chunks MATCH ?${sourceFilter}
+      ORDER BY score
+      LIMIT ?
+    `;
+        const args = [matchExpr];
+        if (params.sources && params.sources.length > 0)
+            args.push(...params.sources);
+        args.push(limit * 20);
+        let rows;
+        try {
+            rows = this.db.prepare(sql).all(...args);
+        }
+        catch {
+            // Malformed MATCH expression (unbalanced quote mid-typing, etc.) — an
+            // empty result is the honest answer, not a 500 in the palette.
+            return [];
+        }
+        const bySession = new Map();
+        for (const r of rows) {
+            const sid = String(r.sid ?? "");
+            if (!sid || bySession.has(sid))
+                continue;
+            bySession.set(sid, toSearchHit(sid, r));
+            if (bySession.size >= limit)
+                break;
+        }
+        return [...bySession.values()];
+    }
+    close() {
+        this.db.close();
+    }
+}
+/**
+ * Map one ranked FTS5 row to a hit. The prose snippet wins when the term
+ * appeared in typed text; the tool snippet is the fallback, flagged so the UI
+ * can say where the match came from.
+ */
+function toSearchHit(sid, r) {
+    const snipText = String(r.snip_text ?? "").trim();
+    const snipTool = String(r.snip_tool ?? "").trim();
+    const fromTool = snipText.length === 0;
+    return {
+        sid,
+        source: String(r.source ?? ""),
+        cwd: String(r.cwd ?? ""),
+        timestamp: String(r.ts ?? ""),
+        snippet: (fromTool ? snipTool : snipText).replace(/\s+/g, " ").slice(0, 300),
+        path: String(r.path ?? ""),
+        fromTool,
+        score: Number(r.score ?? 0),
+    };
+}
+/**
+ * Turn user input into a safe FTS5 MATCH expression.
+ *
+ * Users type prose, not query DSL. Raw input reaches FTS5's parser and a bare
+ * `-` or an unbalanced `"` throws mid-keystroke, which reads as "search is
+ * broken". Every token is quoted (making it a literal) and multi-token input
+ * becomes an implicit AND, which is what people expect from a search box.
+ * A trailing `*` on the last token gives prefix matching so results appear
+ * while still typing.
+ */
+export function toMatchExpression(raw) {
+    const tokens = raw
+        .trim()
+        .split(/\s+/)
+        .map((t) => t.replace(/"/g, ""))
+        .filter((t) => t.length > 0);
+    if (tokens.length === 0)
+        return null;
+    return tokens.map((t, i) => (i === tokens.length - 1 ? `"${t}"*` : `"${t}"`)).join(" AND ");
+}
+//# sourceMappingURL=index-store.js.map

package/dist/server/server/search/indexer.d.ts

@@ -0,0 +1,69 @@
+import type pino from "pino";
+import { SessionIndexStore } from "./index-store.js";
+import { type ExtractedRecord } from "./extract.js";
+export interface DiscoveredFile {
+    path: string;
+    source: string;
+    sid: string;
+    cwd: string;
+}
+/**
+ * How a provider lays out a file on disk.
+ *
+ * "jsonl" — append-only, one JSON record per line. Incremental byte offsets
+ *           apply; this is the case that makes a 214 MB transcript cheap.
+ * "json"  — a single pretty-printed JSON document per file, REWRITTEN in
+ *           place on every update (paseo agent records are 46 lines each).
+ *           Byte offsets are meaningless here: a partial read is invalid JSON,
+ *           so these files are always parsed whole and replaced wholesale.
+ */
+export type SourceFormat = "jsonl" | "json";
+export interface SourceAdapter {
+    name: string;
+    /** On-disk layout. Defaults to "jsonl". */
+    format?: SourceFormat;
+    /** Enumerate transcript files for this provider. Missing root → []. */
+    discover(): Promise<DiscoveredFile[]>;
+    /** Parse one raw record into extractable blocks. */
+    extract(record: unknown): ExtractedRecord;
+}
+export declare function createClaudeAdapter(root?: string): SourceAdapter;
+export declare function createCodexAdapter(root?: string): SourceAdapter;
+export declare function createPaseoAdapter(root?: string): SourceAdapter;
+export declare function defaultAdapters(): SourceAdapter[];
+export interface IndexPassResult {
+    /** Files left mid-read because they hit maxBytesPerFile this pass. */
+    filesPartial: number;
+    filesScanned: number;
+    filesUpdated: number;
+    filesReset: number;
+    filesPruned: number;
+    bytesRead: number;
+    chunksAdded: number;
+    errors: number;
+    durationMs: number;
+}
+export interface IndexPassOptions {
+    adapters?: SourceAdapter[];
+    logger?: pino.Logger;
+    /** Abort cooperatively between files (daemon shutdown). */
+    signal?: AbortSignal;
+    /** Bytes per file per pass. Keeps the first pass over a 214 MB file bounded. */
+    maxBytesPerFile?: number;
+}
+/**
+ * One incremental pass over every discovered transcript. Safe to call
+ * repeatedly; work is proportional to bytes appended since the last call, not
+ * to corpus size.
+ */
+export declare function runIndexPass(store: SessionIndexStore, options?: IndexPassOptions): Promise<IndexPassResult>;
+/**
+ * Default on-disk location for the index (a derived cache, safe to delete).
+ *
+ * MUST resolve through `resolvePaseoHome()` and not `os.homedir()`: a daemon
+ * started with PASEO_HOME pointing elsewhere (tests, a second instance, an
+ * isolated E2E run) would otherwise write its index into the real ~/.paseo and
+ * silently share state with the user's live daemon.
+ */
+export declare function defaultIndexPath(): string;
+//# sourceMappingURL=indexer.d.ts.map