onadit 0.0.1 → 1.0.0

package/dist/src/server/routes/search.js

@@ -0,0 +1,689 @@
+/**
+ * POST /search route — Slice 7: hybrid retrieval + reranking + degraded mode.
+ *
+ * Zod-validated request body per PRD Section 4.
+ * Uses hybrid (vector + lexical) retrieval with deterministic reranking.
+ * Implicit cold-tier fallback when top results score < 0.4.
+ */
+import { z } from "zod";
+import { hybridSearch } from "../../retrieval/hybrid.js";
+import { rerank } from "../../retrieval/reranker.js";
+import { lexicalSearch, lexicalSearchTables } from "../../retrieval/lexical.js";
+import { isRiftBasicMetadata } from "../../providers/basic-metadata-extraction.js";
+import { RIFT_NONE_VECTOR_EXCLUSION_CLAUSE } from "../../providers/placeholder-embed.js";
+import { getTable, TABLE_NAMES } from "../../storage/tables.js";
+import { resolveCwdRoot, escapeLike } from "../../retrieval/cwd.js";
+import { demoteReports, fetchDocSourcePaths, fetchDocFields, isReportCandidateTable, } from "../../retrieval/report-demotion.js";
+import { applyLocatorBoost, isLocatorTarget, locatorIntentFired, } from "../../retrieval/locator-boost.js";
+import { applyFeedbackRanking, feedbackRankingEnabled, } from "../../retrieval/feedback-ranking.js";
+import { buildCompactHit, buildExpandedHit, fetchParentKeysForRanked, fetchRawRowsForRanked, fetchRowByIdForTier, fetchRowsByIdAcrossTables, fetchRowsByIdInTables, tablesForTier, } from "../../retrieval/compact.js";
+import { groupByParent, rankedKey } from "../../retrieval/group-by-parent.js";
+import { collapseConversationDuplicates, convDedupEnabled, poolHasChunkMarkers, } from "../../retrieval/conversation-dedup.js";
+const COLD_TIER_THRESHOLD = 0.4;
+const TIER_VALUES = ["hot", "cold", "digest", "document", "structured_doc"];
+/**
+ * /search request schema.
+ *
+ * Two modes:
+ * - Retrieval mode: `query` is required. Runs hybrid search + rerank.
+ * - Exact-ID mode: `detail` of `"full"` or `"middle"` + `id` — skips
+ *   retrieval entirely and fetches the row by id. Trust contract: this
+ *   never silently falls back to ranked search. With `tier` (and optionally
+ *   `source_table`) the lookup is scoped to the backing table(s); without
+ *   `tier`, the route scans every supported table and returns either the
+ *   unique match, an explicit `id_not_found`, or an explicit `ambiguous_id`
+ *   error. `detail="middle"` returns the same exact-row response shape with
+ *   a bounded head+tail excerpt instead of the full body — preserves the
+ *   evidence bookends a fact-checker needs while bounding context spend.
+ *
+ * `query` becomes optional in exact-ID mode. If both `query` and `id` are
+ * provided with a non-"summary" detail, the id wins — ranked retrieval is
+ * never run as a fallback. This is by design after the REX where a caller
+ * passed `query + id + detail="full"` and got a wrong-body response.
+ */
+const SearchRequestSchema = z
+    .object({
+    query: z.string().min(1).optional(),
+    // Opt-in native reader positions keep the compact agent payload stable.
+    include_passage: z.boolean().default(false),
+    scope: z
+        .enum(["all", "clients", "projects", "conversations", "documents"])
+        .default("all"),
+    client: z.string().optional(),
+    since: z.string().datetime().optional(),
+    top_k: z.number().int().positive().default(10),
+    cwd: z.string().optional(),
+    detail: z.enum(["summary", "middle", "full"]).default("summary"),
+    /** With detail="middle"|"full", expand a single hit by id (bypasses ranking). */
+    id: z.string().optional(),
+    /** Tier of the id being expanded. Optional — narrows the lookup. */
+    tier: z.enum(TIER_VALUES).optional(),
+    /**
+     * Authoritative backing table for the id. When provided, disambiguates
+     * rows that share an id across the cloud/local structured-doc tables.
+     * Optional — absent requests scan every supported table.
+     */
+    source_table: z.enum(TABLE_NAMES).optional(),
+})
+    .refine((d) => !!d.query || ((d.detail === "full" || d.detail === "middle") && !!d.id), {
+    message: 'Either `query` is required, or provide `id` + `detail="full"` (or `detail="middle"`) for direct lookup.',
+})
+    .refine((d) => {
+    // If both tier and source_table are provided in expansion mode, the
+    // source_table must be one the tier can legitimately resolve to.
+    // This catches callers that hand-craft pointers with inconsistent
+    // tier/source_table hints (e.g., tier=hot + source_table=digests).
+    if (!d.tier || !d.source_table)
+        return true;
+    const valid = {
+        hot: ["conversations_hot"],
+        cold: ["conversations_cold"],
+        digest: ["digests"],
+        document: ["structured_docs", "structured_docs_local"],
+        structured_doc: ["structured_docs", "structured_docs_local"],
+    };
+    return valid[d.tier].includes(d.source_table);
+}, {
+    message: "`source_table` is not compatible with the provided `tier`.",
+    path: ["source_table"],
+});
+export function registerSearchRoute(server, embedding, localEmbedding, sourceDirs, selfReportsRoot, dataDir) {
+    server.post("/search", async (request, reply) => {
+        const parsed = SearchRequestSchema.safeParse(request.body);
+        if (!parsed.success) {
+            return reply.code(400).send({
+                error: "validation_error",
+                details: parsed.error.issues,
+            });
+        }
+        const { query, include_passage: includePassage, scope, client, since, top_k, cwd, detail, id: expandId, tier: expandTier, source_table: expandSourceTable, } = parsed.data;
+        const searchScope = scope;
+        // --- Exact-ID mode: direct id-based fetch, never falls back to ranking ---
+        // Triggered whenever `detail="full"` + `id` are provided. The trust
+        // contract is strict: return the exact row, or fail loudly. Four sub-cases:
+        //   1. `tier` + `source_table` — direct fetch from that table. Powers the
+        //      round-trippable `expand` pointers carried by every compact hit
+        //      (which always include `source_table`).
+        //   2. `tier` without `source_table` — scan the tier's candidate tables;
+        //      the result must be unique. Multiple matches → 409 `ambiguous_id`
+        //      (matters for `document` / `structured_doc`, which map to both the
+        //      cloud and local structured-docs tables). Zero → 404 `id_not_found`.
+        //   3. `source_table` without `tier` — direct fetch from that table.
+        //   4. Neither `tier` nor `source_table` — scan every supported table.
+        //      Exactly one match returns the row; zero → 404 `id_not_found`;
+        //      multiple → 409 `ambiguous_id` with the candidate tables.
+        if ((detail === "full" || detail === "middle") && expandId) {
+            if (expandTier) {
+                // With an explicit `source_table`, the lookup is already scoped to
+                // one table — first-match is unambiguous. Without one, fall through
+                // to a multi-table scan so a tier that maps to multiple backing
+                // tables (document / structured_doc → cloud + local) gets the same
+                // ambiguity guarantee as the bare-id path. We never want to silently
+                // return the cloud row when a local row with the same id exists.
+                if (expandSourceTable) {
+                    const fetched = await fetchRowByIdForTier(expandId, expandTier, expandSourceTable);
+                    if (!fetched) {
+                        return reply.code(404).send({
+                            error: "id_not_found",
+                            id: expandId,
+                            tier: expandTier,
+                            source_table: expandSourceTable,
+                        });
+                    }
+                    const hit = await buildExpandedHit(fetched.row, fetched.sourceTable, {
+                        ...(query ? { query } : {}),
+                        expandRoute: "/search",
+                        includePassage,
+                        detail,
+                    });
+                    return {
+                        results: [hit],
+                        degraded: false,
+                        cwd_matched: false,
+                        cwd_scope_applied_to: [],
+                    };
+                }
+                const tierTables = tablesForTier(expandTier);
+                const tierMatches = await fetchRowsByIdInTables(expandId, tierTables);
+                if (tierMatches.length === 0) {
+                    return reply.code(404).send({
+                        error: "id_not_found",
+                        id: expandId,
+                        tier: expandTier,
+                    });
+                }
+                if (tierMatches.length > 1) {
+                    return reply.code(409).send({
+                        error: "ambiguous_id",
+                        id: expandId,
+                        tier: expandTier,
+                        message: "Multiple rows share this id across this tier's backing tables. Pass `source_table` to disambiguate.",
+                        candidates: tierMatches.map((m) => ({ source_table: m.sourceTable })),
+                    });
+                }
+                const onlyTierMatch = tierMatches[0];
+                const hit = await buildExpandedHit(onlyTierMatch.row, onlyTierMatch.sourceTable, {
+                    ...(query ? { query } : {}),
+                    expandRoute: "/search",
+                    includePassage,
+                    detail,
+                });
+                return {
+                    results: [hit],
+                    degraded: false,
+                    cwd_matched: false,
+                    cwd_scope_applied_to: [],
+                };
+            }
+            if (expandSourceTable) {
+                // Direct table fetch — no tier needed when caller already named the
+                // authoritative table.
+                const escaped = expandId.replace(/'/g, "''");
+                const rows = (await getTable(expandSourceTable)
+                    .query()
+                    .where(`id = '${escaped}'`)
+                    .limit(1)
+                    .toArray());
+                if (rows.length === 0) {
+                    return reply.code(404).send({
+                        error: "id_not_found",
+                        id: expandId,
+                        source_table: expandSourceTable,
+                    });
+                }
+                const hit = await buildExpandedHit(rows[0], expandSourceTable, {
+                    ...(query ? { query } : {}),
+                    expandRoute: "/search",
+                    includePassage,
+                    detail,
+                });
+                return {
+                    results: [hit],
+                    degraded: false,
+                    cwd_matched: false,
+                    cwd_scope_applied_to: [],
+                };
+            }
+            // No tier, no source_table — scan every table. Must be uniquely-resolvable.
+            const matches = await fetchRowsByIdAcrossTables(expandId);
+            if (matches.length === 0) {
+                return reply.code(404).send({
+                    error: "id_not_found",
+                    id: expandId,
+                });
+            }
+            if (matches.length > 1) {
+                return reply.code(409).send({
+                    error: "ambiguous_id",
+                    id: expandId,
+                    message: "Multiple rows share this id across tables. Pass `source_table` (or `tier`) to disambiguate.",
+                    candidates: matches.map((m) => ({ source_table: m.sourceTable })),
+                });
+            }
+            const only = matches[0];
+            const hit = await buildExpandedHit(only.row, only.sourceTable, {
+                ...(query ? { query } : {}),
+                expandRoute: "/search",
+                includePassage,
+                detail,
+            });
+            return {
+                results: [hit],
+                degraded: false,
+                cwd_matched: false,
+                cwd_scope_applied_to: [],
+            };
+        }
+        if (!query) {
+            // Defensive: the refine() above guarantees this branch is unreachable,
+            // but TypeScript's narrowing can't see that through the schema.
+            return reply.code(400).send({
+                error: "validation_error",
+                details: [{ message: "query is required" }],
+            });
+        }
+        // Resolve cwd to a configured source root for project-scoped search
+        const cwdMatch = cwd && sourceDirs ? resolveCwdRoot(cwd, sourceDirs) : null;
+        const sourcePathPrefix = cwdMatch?.rootPath;
+        // 1. Retrieve candidates.
+        //    - With a cloud embedding provider: hybrid (vector + lexical).
+        //    - Without one: INTENTIONAL lexical-only mode. This is the no-key
+        //      activation path — keyword search over the imported archive — and is
+        //      NOT degraded (degraded is reserved for a vector path that was
+        //      attempted and failed). `mode` distinguishes the two for callers.
+        const candidates = [];
+        let finalDegraded = false;
+        let finalDegradedReason;
+        const mode = embedding ? "hybrid" : "lexical";
+        if (embedding) {
+            const cloudResult = await hybridSearch(query, embedding, { scope: searchScope, client, since, top_k, ...(sourcePathPrefix ? { sourcePathPrefix } : {}) });
+            candidates.push(...cloudResult.candidates);
+            finalDegraded = cloudResult.degraded;
+            finalDegradedReason = cloudResult.degraded_reason;
+        }
+        else {
+            // Lexical-only: BM25 over the same tables hybrid covers (structured_docs
+            // + conversations_hot + digests), plus conversations_cold (which the
+            // default lexical table set omits) when the scope includes conversations.
+            const fetchK = Math.max(top_k * 3, 30);
+            const lexHits = await lexicalSearch(query, {
+                scope: searchScope,
+                top_k: fetchK,
+                ...(client ? { client } : {}),
+                ...(since ? { since } : {}),
+                ...(sourcePathPrefix ? { sourcePathPrefix } : {}),
+            });
+            for (const h of lexHits)
+                candidates.push(lexicalHitToCandidate(h));
+            if (searchScope === "all" || searchScope === "conversations") {
+                const coldLex = await lexicalSearchTables(query, ["conversations_cold"], {
+                    top_k: fetchK,
+                    ...(since ? { since } : {}),
+                });
+                const seen = new Set(candidates.map((c) => c.id));
+                for (const h of coldLex) {
+                    if (!seen.has(h.id))
+                        candidates.push(lexicalHitToCandidate(h));
+                }
+            }
+        }
+        // 1b. Search local table if local embedding is configured
+        const scopeIncludesDocs = searchScope === "all" ||
+            searchScope === "documents" ||
+            searchScope === "clients" ||
+            searchScope === "projects";
+        if (localEmbedding && scopeIncludesDocs) {
+            try {
+                const localCandidates = await searchLocalTable(query, localEmbedding, { scope: searchScope, ...(client ? { client } : {}), ...(since ? { since } : {}), top_k, ...(sourcePathPrefix ? { sourcePathPrefix } : {}) });
+                const existingIds = new Set(candidates.map((c) => c.id));
+                for (const lc of localCandidates) {
+                    if (!existingIds.has(lc.id)) {
+                        candidates.push(lc);
+                    }
+                }
+            }
+            catch (err) {
+                if (!finalDegraded) {
+                    finalDegraded = true;
+                    finalDegradedReason = `local search failed: ${err instanceof Error ? err.message : String(err)}`;
+                }
+            }
+        }
+        // 2. Rerank candidates
+        const rerankInput = candidates.map((c) => {
+            const entry = {
+                id: c.id,
+                content: c.content,
+                raw_sim: c.raw_sim,
+                raw_bm25: c.raw_bm25,
+                source_table: c.source_table,
+                retrieval_method: c.retrieval_method,
+            };
+            if (c.indexed_at)
+                entry.indexed_at = c.indexed_at;
+            if (c.quality)
+                entry.quality = c.quality;
+            return entry;
+        });
+        let ranked = rerank(rerankInput);
+        // 3. Implicit cold-tier fallback: if top results score < 0.4,
+        //    also search conversations_cold (only for scopes that include conversations)
+        const scopeIncludesConversations = searchScope === "all" || searchScope === "conversations";
+        const needsColdFallback = embedding &&
+            scopeIncludesConversations &&
+            (ranked.length === 0 || ranked[0].score < COLD_TIER_THRESHOLD);
+        if (needsColdFallback) {
+            const coldOpts = {
+                top_k,
+                degraded: finalDegraded,
+            };
+            if (since)
+                coldOpts.since = since;
+            const coldResult = await searchColdTier(query, embedding, coldOpts);
+            // Propagate cold-tier degradation
+            if (coldResult.degraded && !finalDegraded) {
+                finalDegraded = true;
+                finalDegradedReason = coldResult.degraded_reason;
+            }
+            // Deduplicate against existing results
+            const existingIds = new Set(ranked.map((r) => r.id));
+            const newCold = coldResult.candidates.filter((c) => !existingIds.has(c.id));
+            if (newCold.length > 0) {
+                const coldRanked = rerank(newCold);
+                ranked = [...ranked, ...coldRanked].sort((a, b) => b.score - a.score);
+            }
+        }
+        // 3b. Retrieval-feedback ranking (Slice 16; flag-gated, OFF by default →
+        //     ship path unchanged). Applies the bounded, positive-only B_feed
+        //     learned from opened/cited evidence as a re-score over the full pool,
+        //     BEFORE report-demotion / chunk-grouping / the top_k slice so it can
+        //     change which candidates survive. Skipped entirely when the flag is
+        //     off, dataDir is absent, or the ledger is empty — no extra DB fetch.
+        //     Global scope in v0 (see applyFeedbackRanking): event project/intent
+        //     are agent-supplied + usually absent, so a narrow scope would silently
+        //     match nothing.
+        let feedbackApplied = [];
+        if (dataDir && feedbackRankingEnabled()) {
+            const fb = await applyFeedbackRanking(dataDir, ranked);
+            ranked = fb.ranked;
+            feedbackApplied = fb.applied;
+        }
+        // 4. Report-as-memory demotion: in the default mixed surface
+        //    (scope:"all" only), push generated reports/snapshots behind non-report
+        //    evidence so they stop impersonating memory. Stable reorder, scores
+        //    unchanged. Deliberately gated to "all" — the eval only validated the
+        //    mixed default. Explicit doc-like scopes (documents/clients/projects)
+        //    are left untouched: a client's reports/ folder may be the real source
+        //    of truth there, and we only proved this on "all". Skipped when there
+        //    are no docs to classify.
+        if (searchScope === "all" && ranked.some((r) => isReportCandidateTable(r.source_table))) {
+            // PR2 locator-relevance — two levers, both UNEARNED on the current index
+            // and kept default-OFF (ship path unchanged). They fire only on
+            // locator-intent queries ("find the doc/file…", "where is…"), so
+            // discussion-query doc-intrusion is untouched. Mechanically: boost climbs
+            // the rerank loss for a field-matched report (reads path/slug/title only,
+            // never body/BM25, so body-only decoys can't be promoted); the exception
+            // stops a field-matched report from being demoted behind every
+            // conversation.
+            //
+            // WHY STILL OFF — re-evaluated 2026-06-30 against the live beta.27 index
+            // (scripts/eval-retrieval.ts): both levers only REORDER candidates already
+            // in the pool, but the eval's locator targets (reports + trackers) weren't
+            // retrieved at all, so all four ablation cells were identical
+            // (hit@1 0% · MRR 0.000) — flipping these on is a provable no-op here. The
+            // historical "0→75%" gain was measured on a June-2026 index that has since
+            // drifted and does not reproduce. The real gap is retrieval COVERAGE, not
+            // ranking: don't default-on until locator targets are actually retrievable
+            // (canonical-file indexing / write-time index cards) AND a fresh eval shows
+            // a real gain.
+            const locatorFired = locatorIntentFired(query);
+            const boostOn = process.env["RIFT_LOCATOR_BOOST"] === "1" && locatorFired;
+            const exceptionOn = process.env["RIFT_LOCATOR_DEMOTE_EXCEPTION"] === "1" && locatorFired;
+            if (boostOn || exceptionOn) {
+                const docFields = await fetchDocFields(ranked);
+                if (boostOn)
+                    ranked = applyLocatorBoost(query, ranked, docFields);
+                const docPaths = new Map();
+                for (const [id, f] of docFields)
+                    if (f.source_path)
+                        docPaths.set(id, f.source_path);
+                const isExempt = exceptionOn
+                    ? (id) => {
+                        const f = docFields.get(id);
+                        return f !== undefined && isLocatorTarget(query, f);
+                    }
+                    : undefined;
+                ranked = demoteReports(ranked, docPaths, searchScope, selfReportsRoot, isExempt);
+            }
+            else {
+                const docPaths = await fetchDocSourcePaths(ranked);
+                ranked = demoteReports(ranked, docPaths, searchScope, selfReportsRoot);
+            }
+        }
+        // 5. Collapse chunk siblings: a long doc/conversation indexed as multiple
+        //    chunk rows yields ONE representative hit (the best-scoring chunk) plus
+        //    a section count, instead of flooding top-k. parentKeyForRow returns
+        //    null for unmarked/legacy rows, so with RIFT_CHUNKING off (no marked
+        //    rows) this is provably a no-op. Key the WHOLE deep pool with a
+        //    projection-only query (no content/embedding) so grouping can collapse
+        //    siblings before the top-k slice; full rows are then fetched only for
+        //    the surviving representatives.
+        const parentKeyById = await fetchParentKeysForRanked(ranked);
+        const grouped = groupByParent(ranked, (r) => parentKeyById.get(rankedKey(r)) ?? null);
+        // 6. Collapse near-duplicate CONVERSATION captures: the same task captured
+        //    across sessions lands as DISTINCT conversation rows (distinct ids →
+        //    distinct parent keys), so groupByParent never merges them and they
+        //    crowd top-k. This pass folds near-identical conversation bodies into one
+        //    representative + a duplicate count. Flag-gated (RIFT_CONV_DEDUP) and a
+        //    provable no-op when off: collapseConversationDuplicates is never called.
+        //    Skipped when the pool has chunk markers — dedup would compare best-chunk
+        //    text and could false-merge distinct conversations (see conversation-dedup).
+        const convDedup = convDedupEnabled() && !poolHasChunkMarkers(grouped)
+            ? collapseConversationDuplicates(grouped.ranked, { stopAfterKept: top_k })
+            : null;
+        const dedupRanked = convDedup?.ranked ?? grouped.ranked;
+        const topRanked = dedupRanked.slice(0, top_k);
+        const rawRows = await fetchRawRowsForRanked(topRanked);
+        const topResults = topRanked.map((r) => buildCompactHit(r, rawRows.get(rankedKey(r)), {
+            query,
+            detail,
+            expandRoute: "/search",
+            includePassage,
+            siblingCount: grouped.siblingCountById.get(rankedKey(r)),
+            duplicateCount: convDedup?.duplicateCountById.get(rankedKey(r)),
+        }));
+        // Build cwd observability fields
+        const cwdScopeAppliedTo = [];
+        if (cwdMatch) {
+            cwdScopeAppliedTo.push("structured_docs");
+            if (localEmbedding && scopeIncludesDocs) {
+                cwdScopeAppliedTo.push("structured_docs_local");
+            }
+        }
+        const response = {
+            results: topResults,
+            mode,
+            degraded: finalDegraded,
+            cwd_matched: !!cwdMatch,
+            cwd_scope_applied_to: cwdScopeAppliedTo,
+        };
+        if (finalDegradedReason)
+            response.degraded_reason = finalDegradedReason;
+        // Dogfood/explain surface: only present when feedback ranking actually moved
+        // something, so a flag-off (or no-learned-signal) response stays unchanged.
+        if (feedbackApplied.length > 0) {
+            response.feedback_boosts_applied = feedbackApplied;
+        }
+        return response;
+    });
+}
+/**
+ * Adapt a lexical `SearchResult` into a `HybridResult` for the shared rerank
+ * path. Lexical-only, so `raw_sim` is 0 and the BM25 score carries the signal
+ * (the reranker normalizes BM25 into S_sim when no vector score is present).
+ */
+function lexicalHitToCandidate(h) {
+    const entry = {
+        id: h.id,
+        content: h.content,
+        raw_sim: 0,
+        raw_bm25: h.score,
+        source_table: h.source_table,
+        retrieval_method: "lexical",
+    };
+    if (h.indexed_at)
+        entry.indexed_at = h.indexed_at;
+    if (h.quality)
+        entry.quality = h.quality;
+    return entry;
+}
+/**
+ * Search conversations_cold for cold-tier fallback.
+ * Returns rerank-ready candidates and degradation status.
+ */
+async function searchColdTier(query, embedding, opts) {
+    const fetchK = opts.top_k * 3;
+    // Lexical search on cold tier
+    const lexOpts = { top_k: fetchK };
+    if (opts.since)
+        lexOpts.since = opts.since;
+    const lexResults = await lexicalSearchTables(query, ["conversations_cold"], lexOpts);
+    // Vector search on cold tier (if not already degraded)
+    const vectorResults = [];
+    let coldDegraded = false;
+    let coldDegradedReason;
+    if (!opts.degraded) {
+        try {
+            const queryVec = await embedding.embed(query);
+            const coldTable = getTable("conversations_cold");
+            // Exclude no-key placeholder rows: compaction/rebuild preserve the
+            // `rift-none` marker into conversations_cold, so an old no-key row moved
+            // to cold must not re-enter semantic search after a real key is connected.
+            const clauses = [RIFT_NONE_VECTOR_EXCLUSION_CLAUSE];
+            if (opts.since) {
+                clauses.push(`indexed_at >= '${opts.since.replace(/'/g, "''")}'`);
+            }
+            let vq = coldTable
+                .query()
+                .nearestTo(queryVec)
+                .distanceType("cosine")
+                .limit(fetchK);
+            if (clauses.length > 0) {
+                vq = vq.where(clauses.join(" AND "));
+            }
+            const vRows = await vq.toArray();
+            for (const row of vRows) {
+                const entry = {
+                    id: row.id,
+                    content: row.content || row.summary || "",
+                    score: 1 - (row._distance ?? 0),
+                };
+                const ts = row.indexed_at;
+                if (ts)
+                    entry.indexed_at = ts;
+                // Drop placeholder `quality` on no-AI basic rows so the reranker treats
+                // them as quality-neutral rather than ranking on a fake label.
+                const q = row.quality;
+                if (q && !isRiftBasicMetadata(row.metadata_provider)) {
+                    entry.quality = q;
+                }
+                vectorResults.push(entry);
+            }
+        }
+        catch (err) {
+            // Cold-tier vector failure: surface degradation
+            coldDegraded = true;
+            coldDegradedReason = `cold-tier vector search failed: ${err instanceof Error ? err.message : String(err)}`;
+        }
+    }
+    // Merge and tag retrieval method
+    const vectorIds = new Set(vectorResults.map((r) => r.id));
+    const lexicalById = new Map(lexResults.map((r) => [r.id, r]));
+    const merged = new Map();
+    for (const vr of vectorResults) {
+        const lexMatch = lexicalById.get(vr.id);
+        const entry = {
+            id: vr.id,
+            content: vr.content,
+            raw_sim: vr.score,
+            raw_bm25: lexMatch?.score ?? 0,
+            source_table: "conversations_cold",
+            retrieval_method: lexMatch ? "hybrid" : "vector",
+        };
+        if (vr.indexed_at)
+            entry.indexed_at = vr.indexed_at;
+        if (vr.quality)
+            entry.quality = vr.quality;
+        merged.set(vr.id, entry);
+    }
+    for (const lr of lexResults) {
+        if (!merged.has(lr.id)) {
+            const entry = {
+                id: lr.id,
+                content: lr.content,
+                raw_sim: 0,
+                raw_bm25: lr.score,
+                source_table: "conversations_cold",
+                retrieval_method: vectorIds.has(lr.id) ? "hybrid" : "lexical",
+            };
+            if (lr.indexed_at)
+                entry.indexed_at = lr.indexed_at;
+            if (lr.quality)
+                entry.quality = lr.quality;
+            merged.set(lr.id, entry);
+        }
+    }
+    const result = {
+        candidates: Array.from(merged.values()),
+        degraded: coldDegraded,
+    };
+    if (coldDegradedReason)
+        result.degraded_reason = coldDegradedReason;
+    return result;
+}
+/**
+ * Search the local-embedding table (structured_docs_local).
+ * Runs vector search with the local embedding provider + lexical search,
+ * then merges into hybrid candidates. Same pattern as searchColdTier.
+ */
+async function searchLocalTable(query, localEmbedding, opts) {
+    const fetchK = opts.top_k * 3;
+    const tableName = "structured_docs_local";
+    // Build WHERE clauses (same logic as cloud structured_docs)
+    const clauses = [];
+    if (opts.scope === "documents")
+        clauses.push("source_scope = 'document'");
+    else if (opts.scope === "clients")
+        clauses.push("source_scope = 'client'");
+    else if (opts.scope === "projects")
+        clauses.push("source_scope = 'project'");
+    if (opts.client)
+        clauses.push(`client_name = '${opts.client.replace(/'/g, "''")}'`);
+    if (opts.sourcePathPrefix)
+        clauses.push(`source_path LIKE '${escapeLike(opts.sourcePathPrefix).replace(/'/g, "''")}%' ESCAPE '\\'`);
+    if (opts.since)
+        clauses.push(`indexed_at >= '${opts.since.replace(/'/g, "''")}'`);
+    // Vector search with local embedding
+    const vectorResults = [];
+    const queryVec = await localEmbedding.embed(query);
+    const table = getTable(tableName);
+    let vq = table.query().nearestTo(queryVec).distanceType("cosine").limit(fetchK);
+    if (clauses.length > 0)
+        vq = vq.where(clauses.join(" AND "));
+    const vRows = await vq.toArray();
+    for (const row of vRows) {
+        const entry = {
+            id: row.id,
+            content: row.content || "",
+            score: 1 - (row._distance ?? 0),
+        };
+        const ts = row.indexed_at;
+        if (ts)
+            entry.indexed_at = ts;
+        vectorResults.push(entry);
+    }
+    // Lexical search on same table — pass scope so fetchRows applies the same
+    // source_scope/client/sourcePathPrefix filters as the vector path above.
+    const lexResults = await lexicalSearchTables(query, [tableName], {
+        top_k: fetchK,
+        scope: opts.scope,
+        since: opts.since,
+        client: opts.client,
+        sourcePathPrefix: opts.sourcePathPrefix,
+    });
+    // Merge vector + lexical
+    const vectorIds = new Set(vectorResults.map((r) => r.id));
+    const lexicalById = new Map(lexResults.map((r) => [r.id, r]));
+    const merged = [];
+    for (const vr of vectorResults) {
+        const lexMatch = lexicalById.get(vr.id);
+        const entry = {
+            id: vr.id,
+            content: vr.content,
+            raw_sim: vr.score,
+            raw_bm25: lexMatch?.score ?? 0,
+            source_table: tableName,
+            retrieval_method: lexMatch ? "hybrid" : "vector",
+        };
+        if (vr.indexed_at)
+            entry.indexed_at = vr.indexed_at;
+        merged.push(entry);
+    }
+    for (const lr of lexResults) {
+        if (!vectorIds.has(lr.id)) {
+            const entry = {
+                id: lr.id,
+                content: lr.content,
+                raw_sim: 0,
+                raw_bm25: lr.score,
+                source_table: tableName,
+                retrieval_method: "lexical",
+            };
+            if (lr.indexed_at)
+                entry.indexed_at = lr.indexed_at;
+            merged.push(entry);
+        }
+    }
+    return merged;
+}
+//# sourceMappingURL=search.js.map