gnosys 5.12.2 → 5.13.0

package/dist/lib/embedDb.js

@@ -0,0 +1,84 @@
+/**
+ * Central-DB embedding utilities (v5.13.0).
+ *
+ * GnosysDbSearch reads vectors from the memories.embedding column of
+ * gnosys.db, but before v5.13.0 nothing ever wrote that column: the
+ * reindex flow embedded file-store memories into the store-local
+ * embeddings.db, so DB-mode hybrid search could never run its semantic
+ * leg. This module owns the column — full backfill for reindex,
+ * missing-only backfill for Dream/maintenance, and single-memory
+ * embedding for the write-time queue.
+ *
+ * Embeddings are derived, rebuildable data: regenerating them is always
+ * safe, and a sync snapshot refresh replacing them is not a loss.
+ */
+/**
+ * The text recipe — identical to the file-store reindex in hybridSearch.ts
+ * (title, relevance keywords, tags, content) so query-vs-document
+ * similarity behaves the same in both modes.
+ */
+export function embeddingText(m) {
+    let tags = m.tags || "";
+    try {
+        const parsed = JSON.parse(tags);
+        if (Array.isArray(parsed)) {
+            tags = parsed.join(" ");
+        }
+        else if (parsed && typeof parsed === "object") {
+            tags = Object.values(parsed).flat().join(" ");
+        }
+    }
+    catch {
+        // already a plain string
+    }
+    return `${m.title}\n${m.relevance || ""}\n${tags}\n${m.content}`;
+}
+/** View a Float32Array as the Buffer shape memories.embedding stores. */
+export function float32ToBuffer(vec) {
+    return Buffer.from(vec.buffer, vec.byteOffset, vec.byteLength);
+}
+/**
+ * (Re)build the memories.embedding column.
+ *
+ * mode "all" regenerates every memory (reindex semantics); "missing" only
+ * fills NULL rows (write-gap backfill for Dream/maintenance, newest first).
+ * Batched through embedBatch for model efficiency.
+ */
+export async function backfillCentralDbEmbeddings(db, embeddings, opts = {}) {
+    if (!db.isAvailable() || !db.isMigrated())
+        return { embedded: 0, total: 0 };
+    const rows = db.getMemoriesForEmbedding(opts.mode || "missing", opts.limit);
+    const total = rows.length;
+    if (total === 0)
+        return { embedded: 0, total: 0 };
+    const batchSize = opts.batchSize || 32;
+    let embedded = 0;
+    for (let i = 0; i < rows.length; i += batchSize) {
+        const batch = rows.slice(i, i + batchSize);
+        const vectors = await embeddings.embedBatch(batch.map(embeddingText));
+        for (let j = 0; j < batch.length; j++) {
+            db.updateEmbedding(batch[j].id, float32ToBuffer(vectors[j]));
+            embedded++;
+            opts.onProgress?.(embedded, total, batch[j].id);
+        }
+    }
+    return { embedded, total };
+}
+/**
+ * Embed one memory and store its vector. Returns false if the memory
+ * doesn't exist; throws on embedder failure — callers decide how loud.
+ */
+export async function embedMemoryIntoDb(db, embeddings, id) {
+    const mem = db.getMemory(id);
+    if (!mem)
+        return false;
+    const vec = await embeddings.embed(embeddingText({
+        id: mem.id,
+        title: mem.title,
+        relevance: mem.relevance,
+        tags: mem.tags,
+        content: mem.content,
+    }));
+    db.updateEmbedding(id, float32ToBuffer(vec));
+    return true;
+}

package/dist/lib/embedQueue.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Write-time embedding queue (v5.13.0).
+ *
+ * Keeps memories.embedding fresh as memories are written, so semantic
+ * search doesn't drift stale between reindexes. Disabled by default —
+ * the MCP server enables it once its long-lived central-DB handle and
+ * embeddings instance exist. CLI one-shot processes stay disabled (they
+ * exit before the model could load) and rely on reindex / Dream backfill.
+ *
+ * Contract: a memory write must NEVER block on or fail because of
+ * embedding. queueMemoryEmbedding returns immediately; the drain runs on
+ * an unref'd timer, lazily imports the embedder path, logs at most one
+ * stderr warning per process on failure, and drops rather than retries.
+ */
+import type { GnosysDB } from "./db.js";
+import type { GnosysEmbeddings } from "./embeddings.js";
+/** Turn on write-time embedding (serve mode). Getter is called at drain time. */
+export declare function enableWriteTimeEmbedding(dbGetter: () => GnosysDB | null, embeddings: GnosysEmbeddings): void;
+/** Turn off and clear the queue (tests, shutdown). */
+export declare function disableWriteTimeEmbedding(): void;
+export declare function isWriteTimeEmbeddingEnabled(): boolean;
+/**
+ * Queue a memory for embedding. No-op unless enabled. Never throws,
+ * never blocks — safe to call from any write path.
+ */
+export declare function queueMemoryEmbedding(id: string): void;
+/** Await in-flight embedding work. Used by tests and graceful shutdown. */
+export declare function flushWriteTimeEmbeddings(): Promise<void>;

package/dist/lib/embedQueue.js

@@ -0,0 +1,80 @@
+/**
+ * Write-time embedding queue (v5.13.0).
+ *
+ * Keeps memories.embedding fresh as memories are written, so semantic
+ * search doesn't drift stale between reindexes. Disabled by default —
+ * the MCP server enables it once its long-lived central-DB handle and
+ * embeddings instance exist. CLI one-shot processes stay disabled (they
+ * exit before the model could load) and rely on reindex / Dream backfill.
+ *
+ * Contract: a memory write must NEVER block on or fail because of
+ * embedding. queueMemoryEmbedding returns immediately; the drain runs on
+ * an unref'd timer, lazily imports the embedder path, logs at most one
+ * stderr warning per process on failure, and drops rather than retries.
+ */
+let getDb = null;
+let embedder = null;
+const pending = new Set();
+let drainPromise = null;
+let warnedOnce = false;
+/** Turn on write-time embedding (serve mode). Getter is called at drain time. */
+export function enableWriteTimeEmbedding(dbGetter, embeddings) {
+    getDb = dbGetter;
+    embedder = embeddings;
+}
+/** Turn off and clear the queue (tests, shutdown). */
+export function disableWriteTimeEmbedding() {
+    getDb = null;
+    embedder = null;
+    pending.clear();
+}
+export function isWriteTimeEmbeddingEnabled() {
+    return getDb !== null && embedder !== null;
+}
+/**
+ * Queue a memory for embedding. No-op unless enabled. Never throws,
+ * never blocks — safe to call from any write path.
+ */
+export function queueMemoryEmbedding(id) {
+    if (!getDb || !embedder || !id)
+        return;
+    pending.add(id);
+    if (!drainPromise) {
+        drainPromise = new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                drain().finally(() => {
+                    drainPromise = null;
+                    resolve();
+                });
+            }, 25);
+            timer.unref?.();
+        });
+    }
+}
+/** Await in-flight embedding work. Used by tests and graceful shutdown. */
+export async function flushWriteTimeEmbeddings() {
+    while (drainPromise) {
+        await drainPromise;
+    }
+}
+async function drain() {
+    while (pending.size > 0) {
+        const id = pending.values().next().value;
+        pending.delete(id);
+        const db = getDb?.();
+        if (!db || !embedder)
+            return;
+        try {
+            const { embedMemoryIntoDb } = await import("./embedDb.js");
+            await embedMemoryIntoDb(db, embedder, id);
+        }
+        catch (err) {
+            if (!warnedOnce) {
+                warnedOnce = true;
+                console.error(`Gnosys: write-time embedding failed (${err instanceof Error ? err.message : err}). ` +
+                    `New memories will be embedded by the next gnosys_reindex or Dream run instead.`);
+            }
+            return; // drop this round; anything still pending waits for the next queue call
+        }
+    }
+}

package/dist/lib/ftsQuery.d.ts

@@ -0,0 +1,25 @@
+/**
+ * FTS5 MATCH query construction — shared by the central-DB search (db.ts),
+ * the per-store search index (search.ts), and archive search (archive.ts).
+ *
+ * FTS5 treats space-separated bare terms as implicit AND, so the long
+ * descriptive queries the tool docs encourage ("auth JWT session tokens
+ * refresh") return zero results unless EVERY term matches. Callers use
+ * these helpers to try AND first (precision), then retry with OR
+ * (recall) when AND finds nothing — BM25 still ranks the best-covered
+ * memories first in the OR pass.
+ *
+ * Every term is emitted as a quoted phrase, which also makes previously
+ * syntax-error-prone input (hyphens, colons, FTS5 keywords like NOT)
+ * safe. A trailing `*` is preserved as an FTS5 prefix query (`"term"*`).
+ */
+/**
+ * Split a raw query into sanitized terms. Drops quote characters and any
+ * token with no letters or digits (pure punctuation can't match anything
+ * under the unicode61 tokenizer).
+ */
+export declare function ftsTerms(query: string): string[];
+/** Implicit-AND MATCH expression: all terms must match. */
+export declare function ftsAndQuery(terms: string[]): string;
+/** OR MATCH expression: any term may match; BM25 ranks fuller matches higher. */
+export declare function ftsOrQuery(terms: string[]): string;

package/dist/lib/ftsQuery.js

@@ -0,0 +1,42 @@
+/**
+ * FTS5 MATCH query construction — shared by the central-DB search (db.ts),
+ * the per-store search index (search.ts), and archive search (archive.ts).
+ *
+ * FTS5 treats space-separated bare terms as implicit AND, so the long
+ * descriptive queries the tool docs encourage ("auth JWT session tokens
+ * refresh") return zero results unless EVERY term matches. Callers use
+ * these helpers to try AND first (precision), then retry with OR
+ * (recall) when AND finds nothing — BM25 still ranks the best-covered
+ * memories first in the OR pass.
+ *
+ * Every term is emitted as a quoted phrase, which also makes previously
+ * syntax-error-prone input (hyphens, colons, FTS5 keywords like NOT)
+ * safe. A trailing `*` is preserved as an FTS5 prefix query (`"term"*`).
+ */
+/**
+ * Split a raw query into sanitized terms. Drops quote characters and any
+ * token with no letters or digits (pure punctuation can't match anything
+ * under the unicode61 tokenizer).
+ */
+export function ftsTerms(query) {
+    return query
+        .replace(/['"]/g, "")
+        .split(/\s+/)
+        .filter((t) => /[\p{L}\p{N}]/u.test(t));
+}
+/** Render one term as a safe FTS5 phrase, preserving trailing-`*` prefix queries. */
+function ftsPhrase(term) {
+    const prefixMatch = term.match(/^(.*?)\*+$/);
+    if (prefixMatch && /[\p{L}\p{N}]/u.test(prefixMatch[1])) {
+        return `"${prefixMatch[1]}"*`;
+    }
+    return `"${term}"`;
+}
+/** Implicit-AND MATCH expression: all terms must match. */
+export function ftsAndQuery(terms) {
+    return terms.map(ftsPhrase).join(" ");
+}
+/** OR MATCH expression: any term may match; BM25 ranks fuller matches higher. */
+export function ftsOrQuery(terms) {
+    return terms.map(ftsPhrase).join(" OR ");
+}

package/dist/lib/hybridSearch.d.ts

@@ -20,6 +20,8 @@ export declare class GnosysHybridSearch {
     private storePath;
     /** v2.0: When set, hybrid search uses SQLite directly */
     private dbSearch;
+    /** v5.13.0: kept for central-DB embedding backfill (reindexCentralDb) */
+    private gnosysDb;
     constructor(search: GnosysSearch, embeddings: GnosysEmbeddings, resolver: GnosysResolver, storePath: string, gnosysDb?: GnosysDB);
     /**
      * Main hybrid search entry point.
@@ -48,6 +50,17 @@ export declare class GnosysHybridSearch {
      * Returns count of files indexed.
      */
     reindex(onProgress?: (current: number, total: number, filePath: string) => void): Promise<number>;
+    /**
+     * v5.13.0: (re)build the central-DB memories.embedding column — the
+     * vectors GnosysDbSearch actually reads. Before this, reindex only
+     * embedded file-store memories into the store-local embeddings.db, so
+     * DB-mode semantic search could never activate. Returns counts; no-op
+     * ({0,0}) when no migrated central DB is attached.
+     */
+    reindexCentralDb(onProgress?: (current: number, total: number, id: string) => void): Promise<{
+        embedded: number;
+        total: number;
+    }>;
     /**
      * Load full content for search results (used by Ask engine).
      * Handles both active memories and archived memories.
@@ -57,6 +70,14 @@ export declare class GnosysHybridSearch {
      * Check if embeddings are available.
      */
     hasEmbeddings(): boolean;
+    /**
+     * True when hybrid/semantic search can actually run its semantic leg.
+     * Mirrors the embedQuery gate in hybridSearch(): in DB mode, stored
+     * central-DB vectors are what matter (the query embedder loads the
+     * local model on demand); in legacy file mode, the store-local
+     * embeddings.db must be populated.
+     */
+    canRunSemantic(): boolean;
     /**
      * Get embedding count.
      */

package/dist/lib/hybridSearch.js

@@ -19,6 +19,8 @@ export class GnosysHybridSearch {
     storePath;
     /** v2.0: When set, hybrid search uses SQLite directly */
     dbSearch = null;
+    /** v5.13.0: kept for central-DB embedding backfill (reindexCentralDb) */
+    gnosysDb = null;
     constructor(search, embeddings, resolver, storePath, gnosysDb) {
         this.search = search;
         this.embeddings = embeddings;
@@ -27,6 +29,7 @@ export class GnosysHybridSearch {
         // v2.0: If GnosysDB is migrated, create a DB search adapter
         if (gnosysDb?.isAvailable() && gnosysDb?.isMigrated()) {
             this.dbSearch = new GnosysDbSearch(gnosysDb);
+            this.gnosysDb = gnosysDb;
         }
     }
     /**
@@ -36,7 +39,11 @@ export class GnosysHybridSearch {
     async hybridSearch(query, limit = 15, mode = "hybrid") {
         // v2.0 DB-backed fast path: run entirely from gnosys.db
         if (this.dbSearch) {
-            const embedQuery = this.embeddings.hasEmbeddings()
+            // v5.13.0: gate the semantic leg on stored central-DB vectors — the
+            // query embedder loads the local model on demand, so the store-local
+            // embeddings.db (the old gate) is irrelevant in DB mode. A machine
+            // that only syncs gnosys.db gets semantic search once vectors exist.
+            const embedQuery = this.dbSearch.hasEmbeddings()
                 ? (text) => this.embeddings.embed(text)
                 : undefined;
             return this.dbSearch.hybridSearch(query, limit, mode, embedQuery);
@@ -230,6 +237,22 @@ export class GnosysHybridSearch {
         }
         return indexed;
     }
+    /**
+     * v5.13.0: (re)build the central-DB memories.embedding column — the
+     * vectors GnosysDbSearch actually reads. Before this, reindex only
+     * embedded file-store memories into the store-local embeddings.db, so
+     * DB-mode semantic search could never activate. Returns counts; no-op
+     * ({0,0}) when no migrated central DB is attached.
+     */
+    async reindexCentralDb(onProgress) {
+        if (!this.gnosysDb)
+            return { embedded: 0, total: 0 };
+        const { backfillCentralDbEmbeddings } = await import("./embedDb.js");
+        return backfillCentralDbEmbeddings(this.gnosysDb, this.embeddings, {
+            mode: "all",
+            onProgress,
+        });
+    }
     /**
      * Load full content for search results (used by Ask engine).
      * Handles both active memories and archived memories.
@@ -284,6 +307,19 @@ export class GnosysHybridSearch {
             return this.dbSearch.hasEmbeddings();
         return this.embeddings.hasEmbeddings();
     }
+    /**
+     * True when hybrid/semantic search can actually run its semantic leg.
+     * Mirrors the embedQuery gate in hybridSearch(): in DB mode, stored
+     * central-DB vectors are what matter (the query embedder loads the
+     * local model on demand); in legacy file mode, the store-local
+     * embeddings.db must be populated.
+     */
+    canRunSemantic() {
+        if (this.dbSearch) {
+            return this.dbSearch.hasEmbeddings();
+        }
+        return this.embeddings.hasEmbeddings();
+    }
     /**
      * Get embedding count.
      */

package/dist/lib/hybridSearchCommand.js

@@ -67,6 +67,11 @@ export async function runHybridSearchCommand(getResolver, query, opts) {
     const embeddings = new GnosysEmbeddings(storePath);
     const hybridSearch = new GnosysHybridSearch(search, embeddings, resolver, storePath);
     const mode = opts.mode;
+    // v5.12.3: hybrid used to degrade to keyword-only silently when the
+    // semantic leg can't run. Warn on stderr so --json stdout stays clean.
+    if (mode !== "keyword" && !hybridSearch.canRunSemantic()) {
+        console.error(`⚠ Semantic embeddings unavailable — ${mode} search will run keyword-only. Run 'gnosys reindex' to build embeddings.`);
+    }
     const results = await hybridSearch.hybridSearch(query, parseInt(opts.limit, 10), mode);
     if (results.length === 0) {
         outputResult(!!opts.json, { query, mode, results: [] }, () => {

package/dist/lib/reindexCommand.js

@@ -24,7 +24,33 @@ export async function runReindexCommand(getResolver) {
         const count = await hybridSearch.reindex((current, total, filePath) => {
             process.stdout.write(`\r  Indexing: ${current}/${total} — ${filePath.substring(0, 60)}`);
         });
+        // v5.13.0: also (re)build the central-DB embedding column — the vectors
+        // DB-mode hybrid/semantic search actually reads. Own handle: the
+        // resolver-based hybridSearch above only covers file stores.
+        let dbEmbedded = 0;
+        let dbTotal = 0;
+        const { GnosysDB } = await import("./db.js");
+        const centralDb = GnosysDB.openCentral();
+        try {
+            if (centralDb.isAvailable() && centralDb.isMigrated()) {
+                const { backfillCentralDbEmbeddings } = await import("./embedDb.js");
+                const result = await backfillCentralDbEmbeddings(centralDb, embeddings, {
+                    mode: "all",
+                    onProgress: (current, total, id) => {
+                        process.stdout.write(`\r  Central DB: ${current}/${total} — ${id.substring(0, 40)}          `);
+                    },
+                });
+                dbEmbedded = result.embedded;
+                dbTotal = result.total;
+            }
+        }
+        finally {
+            centralDb.close();
+        }
         console.log(`\n\nReindex complete: ${count} memories embedded.`);
+        if (dbTotal > 0) {
+            console.log(`Central DB: ${dbEmbedded}/${dbTotal} memories embedded.`);
+        }
         console.log("Hybrid and semantic search are now available.");
     }
     finally {

package/dist/lib/resolver.d.ts

@@ -46,6 +46,23 @@ export declare class GnosysResolver {
      * Discover and initialize all store layers.
      */
     resolve(): Promise<ResolvedStore[]>;
+    /**
+     * Load the env-configured store tiers (optional `GNOSYS_STORES`, personal
+     * `GNOSYS_PERSONAL`, global `GNOSYS_GLOBAL`) onto `this.stores`.
+     *
+     * Shared by {@link resolve} and {@link resolveForProject}: a per-tool
+     * `projectRoot` call must STILL see personal/global, otherwise cross-project
+     * and global memories are unreachable — you couldn't write `store: "global"`
+     * / `"personal"` nor read them back from another project. Since every tool
+     * is told to always pass `projectRoot`, omitting these here silently
+     * disabled the entire cross-project tier system.
+     *
+     * Global is loaded whenever `GNOSYS_GLOBAL` is set, creating its directory on
+     * demand (parity with personal) so a configured-but-empty global store still
+     * works. It remains write-only-when-explicitly-targeted: {@link getWriteTarget}
+     * never auto-selects it.
+     */
+    private loadEnvTiers;
     /**
      * Get all stores in precedence order.
      */

package/dist/lib/resolver.js

@@ -79,8 +79,13 @@ export class GnosysResolver {
             }
         }
         catch {
-            // Store doesn't exist at projectRoot — fall through to empty resolver
+            // No project store at projectRoot — still load the env tiers below.
         }
+        // Even when scoped to a projectRoot, load the personal/global/optional
+        // tiers so cross-project + global memories stay reachable (write store:
+        // "global"/"personal", and read them back from any project). Without this,
+        // the universal "always pass projectRoot" guidance silently disabled them.
+        await resolver.loadEnvTiers();
         return resolver;
     }
     /**
@@ -104,7 +109,30 @@ export class GnosysResolver {
                 path: projectPath,
             });
         }
-        // 2. Optional stores (GNOSYS_STORES — colon-separated)
+        // 2-4. Env-configured tiers (optional, personal, global). Shared with
+        //       resolveForProject so passing a projectRoot does NOT strip the
+        //       cross-project tiers.
+        await this.loadEnvTiers();
+        return this.stores;
+    }
+    /**
+     * Load the env-configured store tiers (optional `GNOSYS_STORES`, personal
+     * `GNOSYS_PERSONAL`, global `GNOSYS_GLOBAL`) onto `this.stores`.
+     *
+     * Shared by {@link resolve} and {@link resolveForProject}: a per-tool
+     * `projectRoot` call must STILL see personal/global, otherwise cross-project
+     * and global memories are unreachable — you couldn't write `store: "global"`
+     * / `"personal"` nor read them back from another project. Since every tool
+     * is told to always pass `projectRoot`, omitting these here silently
+     * disabled the entire cross-project tier system.
+     *
+     * Global is loaded whenever `GNOSYS_GLOBAL` is set, creating its directory on
+     * demand (parity with personal) so a configured-but-empty global store still
+     * works. It remains write-only-when-explicitly-targeted: {@link getWriteTarget}
+     * never auto-selects it.
+     */
+    async loadEnvTiers() {
+        // Optional stores (GNOSYS_STORES — colon-separated, read-only)
         const optionalPaths = process.env.GNOSYS_STORES;
         if (optionalPaths) {
             const paths = optionalPaths.split(":").filter(Boolean);
@@ -124,7 +152,7 @@ export class GnosysResolver {
                 }
             }
         }
-        // 3. Personal store (GNOSYS_PERSONAL)
+        // Personal store (GNOSYS_PERSONAL — writable fallback target)
         const personalPath = process.env.GNOSYS_PERSONAL;
         if (personalPath) {
             const p = path.resolve(personalPath);
@@ -138,24 +166,22 @@ export class GnosysResolver {
                 path: p,
             });
         }
-        // 4. Global store (GNOSYS_GLOBAL)
-        //    Writable, but only when explicitly targeted — never auto-selected.
+        // Global store (GNOSYS_GLOBAL — writable, but never auto-selected). Loaded
+        // whenever set; store.init() creates the dir on demand (parity with
+        // personal), so a configured-but-empty GNOSYS_GLOBAL still works.
         const globalPath = process.env.GNOSYS_GLOBAL;
         if (globalPath) {
             const p = path.resolve(globalPath);
-            if (await this.isValidStore(p)) {
-                const store = new GnosysStore(p);
-                await store.init();
-                this.stores.push({
-                    layer: "global",
-                    label: "global",
-                    store,
-                    writable: true,
-                    path: p,
-                });
-            }
+            const store = new GnosysStore(p);
+            await store.init();
+            this.stores.push({
+                layer: "global",
+                label: "global",
+                store,
+                writable: true,
+                path: p,
+            });
         }
-        return this.stores;
     }
     /**
      * Get all stores in precedence order.

package/dist/lib/search.js

@@ -11,6 +11,7 @@ catch {
     // better-sqlite3 native module not available — search degrades gracefully
 }
 import path from "path";
+import { ftsTerms, ftsAndQuery, ftsOrQuery } from "./ftsQuery.js";
 export class GnosysSearch {
     db = null;
     constructor(storePath) {
@@ -133,9 +134,8 @@ export class GnosysSearch {
     search(query, limit = 20) {
         if (!this.db)
             return [];
-        // FTS5 query — escape special characters
-        const safeQuery = query.replace(/['"]/g, "").trim();
-        if (!safeQuery)
+        const terms = ftsTerms(query);
+        if (terms.length === 0)
             return [];
         const stmt = this.db.prepare(`
       SELECT
@@ -149,7 +149,12 @@ export class GnosysSearch {
       LIMIT ?
     `);
         try {
-            return stmt.all(safeQuery, limit);
+            // v5.12.3: AND first (precision), OR retry when AND finds nothing —
+            // multi-word queries previously required every term to match.
+            const results = stmt.all(ftsAndQuery(terms), limit);
+            if (results.length > 0 || terms.length === 1)
+                return results;
+            return stmt.all(ftsOrQuery(terms), limit);
         }
         catch {
             // If FTS5 query fails, fall back to simple LIKE search
@@ -163,7 +168,7 @@ export class GnosysSearch {
         WHERE content LIKE ? OR title LIKE ? OR tags LIKE ?
         LIMIT ?
       `);
-            const pattern = `%${safeQuery}%`;
+            const pattern = `%${terms.join(" ")}%`;
             return likeStmt.all(pattern, pattern, pattern, limit);
         }
     }
@@ -175,8 +180,8 @@ export class GnosysSearch {
     discover(query, limit = 20) {
         if (!this.db)
             return [];
-        const safeQuery = query.replace(/['"]/g, "").trim();
-        if (!safeQuery)
+        const terms = ftsTerms(query);
+        if (terms.length === 0)
             return [];
         // Search primarily on relevance + title + tags (not content body)
         // FTS5 column filter: {relevance title tags}
@@ -191,24 +196,32 @@ export class GnosysSearch {
       ORDER BY rank
       LIMIT ?
     `);
-        try {
-            // Try column-filtered search on relevance/title/tags first
-            const colQuery = `{relevance title tags} : ${safeQuery}`;
-            const results = stmt.all(colQuery, limit);
-            if (results.length > 0)
-                return results;
-            // Fall back to full-text search if column filter finds nothing
-            return stmt.all(safeQuery, limit);
-        }
-        catch {
-            // If FTS5 column filter syntax fails, fall back to full search
+        const tryRun = (match) => {
             try {
-                return stmt.all(safeQuery, limit);
+                return stmt.all(match, limit);
             }
             catch {
                 return [];
             }
-        }
+        };
+        // v5.12.3: precision-to-recall ladder. AND on the metadata columns,
+        // AND anywhere, then OR retries — multi-word queries previously
+        // required every term to match, so long queries returned nothing.
+        // Parens scope the column filter to the whole expression (a bare
+        // `{cols} : a b` only filtered the first term).
+        const colScoped = (expr) => `{relevance title tags} : (${expr})`;
+        const andExpr = ftsAndQuery(terms);
+        let results = tryRun(colScoped(andExpr));
+        if (results.length > 0)
+            return results;
+        results = tryRun(andExpr);
+        if (results.length > 0 || terms.length === 1)
+            return results;
+        const orExpr = ftsOrQuery(terms);
+        results = tryRun(colScoped(orExpr));
+        if (results.length > 0)
+            return results;
+        return tryRun(orExpr);
     }
     close() {
         this.db?.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gnosys",
-  "version": "5.12.2",
+  "version": "5.13.0",
   "description": "Gnosys — Persistent Memory for AI Agents. Sandbox-first runtime, central SQLite brain, federated search, Dream Mode, Web Knowledge Base, Obsidian export.",
   "type": "module",
   "main": "dist/index.js",