searchsocket 0.4.0 → 0.5.0

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import fs10 from "fs";
+import fs8 from "fs";
 import fsp from "fs/promises";
-import path14 from "path";
+import path12 from "path";
 import { execSync as execSync2 } from "child_process";
 import { config as dotenvConfig } from "dotenv";
 import chokidar from "chokidar";
@@ -12,7 +12,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "searchsocket",
-  version: "0.4.0",
+  version: "0.5.0",
   description: "Semantic site search and MCP retrieval for SvelteKit static sites",
   license: "MIT",
   author: "Greg Priday <greg@siteorigin.com>",
@@ -58,6 +58,11 @@ var package_default = {
       types: "./dist/client.d.ts",
       import: "./dist/client.js",
       require: "./dist/client.cjs"
+    },
+    "./scroll": {
+      types: "./dist/scroll.d.ts",
+      import: "./dist/scroll.js",
+      require: "./dist/scroll.cjs"
     }
   },
   scripts: {
@@ -65,15 +70,16 @@ var package_default = {
     clean: "rm -rf dist",
     typecheck: "tsc --noEmit",
     test: "vitest run",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
+    "test:quality": "SEARCHSOCKET_QUALITY_TESTS=1 vitest run tests/quality.test.ts"
   },
   engines: {
     node: ">=20"
   },
   packageManager: "pnpm@10.29.2",
   dependencies: {
-    "@libsql/client": "^0.17.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
+    "@upstash/search": "^0.1.7",
     cheerio: "^1.2.0",
     chokidar: "^5.0.0",
     commander: "^14.0.3",
@@ -91,6 +97,7 @@ var package_default = {
     "@types/express": "^5.0.6",
     "@types/node": "^25.2.2",
     "@types/turndown": "^5.0.6",
+    jsdom: "^28.1.0",
     tsup: "^8.5.1",
     typescript: "^5.9.3",
     vitest: "^4.0.18"
@@ -164,29 +171,18 @@ var searchSocketConfigSchema = z.object({
     prependTitle: z.boolean().optional(),
     pageSummaryChunk: z.boolean().optional()
   }).optional(),
-  embeddings: z.object({
-    provider: z.literal("jina").optional(),
-    model: z.string().min(1).optional(),
-    apiKey: z.string().min(1).optional(),
-    apiKeyEnv: z.string().min(1).optional(),
-    batchSize: z.number().int().positive().optional(),
-    concurrency: z.number().int().positive().optional(),
-    pricePer1kTokens: z.number().positive().optional()
-  }).optional(),
-  vector: z.object({
-    dimension: z.number().int().positive().optional(),
-    turso: z.object({
-      url: z.string().url().optional(),
-      authToken: z.string().min(1).optional(),
-      urlEnv: z.string().optional(),
-      authTokenEnv: z.string().optional(),
-      localPath: z.string().optional()
-    }).optional()
+  upstash: z.object({
+    url: z.string().url().optional(),
+    token: z.string().min(1).optional(),
+    urlEnv: z.string().min(1).optional(),
+    tokenEnv: z.string().min(1).optional()
   }).optional(),
-  rerank: z.object({
-    enabled: z.boolean().optional(),
-    topN: z.number().int().positive().optional(),
-    model: z.string().optional()
+  search: z.object({
+    semanticWeight: z.number().min(0).max(1).optional(),
+    inputEnrichment: z.boolean().optional(),
+    reranking: z.boolean().optional(),
+    dualSearch: z.boolean().optional(),
+    pageSearchWeight: z.number().min(0).max(1).optional()
   }).optional(),
   ranking: z.object({
     enableIncomingLinkBoost: z.boolean().optional(),
@@ -196,11 +192,12 @@ var searchSocketConfigSchema = z.object({
     aggregationDecay: z.number().min(0).max(1).optional(),
     minChunkScoreRatio: z.number().min(0).max(1).optional(),
     minScore: z.number().min(0).max(1).optional(),
+    scoreGapThreshold: z.number().min(0).max(1).optional(),
     weights: z.object({
       incomingLinks: z.number().optional(),
       depth: z.number().optional(),
-      rerank: z.number().optional(),
-      aggregation: z.number().optional()
+      aggregation: z.number().optional(),
+      titleMatch: z.number().optional()
     }).optional()
   }).optional(),
   api: z.object({
@@ -222,8 +219,7 @@ var searchSocketConfigSchema = z.object({
     }).optional()
   }).optional(),
   state: z.object({
-    dir: z.string().optional(),
-    writeMirror: z.boolean().optional()
+    dir: z.string().optional()
   }).optional()
 });
 
@@ -277,24 +273,16 @@ function createDefaultConfig(projectId) {
       prependTitle: true,
       pageSummaryChunk: true
     },
-    embeddings: {
-      provider: "jina",
-      model: "jina-embeddings-v5-text-small",
-      apiKeyEnv: "JINA_API_KEY",
-      batchSize: 64,
-      concurrency: 4
+    upstash: {
+      urlEnv: "UPSTASH_SEARCH_REST_URL",
+      tokenEnv: "UPSTASH_SEARCH_REST_TOKEN"
     },
-    vector: {
-      turso: {
-        urlEnv: "TURSO_DATABASE_URL",
-        authTokenEnv: "TURSO_AUTH_TOKEN",
-        localPath: ".searchsocket/vectors.db"
-      }
-    },
-    rerank: {
-      enabled: true,
-      topN: 20,
-      model: "jina-reranker-v3"
+    search: {
+      semanticWeight: 0.75,
+      inputEnrichment: true,
+      reranking: true,
+      dualSearch: true,
+      pageSearchWeight: 0.3
     },
     ranking: {
       enableIncomingLinkBoost: true,
@@ -303,12 +291,13 @@ function createDefaultConfig(projectId) {
       aggregationCap: 5,
       aggregationDecay: 0.5,
       minChunkScoreRatio: 0.5,
-      minScore: 0,
+      minScore: 0.3,
+      scoreGapThreshold: 0.4,
       weights: {
         incomingLinks: 0.05,
         depth: 0.03,
-        rerank: 1,
-        aggregation: 0.1
+        aggregation: 0.1,
+        titleMatch: 0.15
       }
     },
     api: {
@@ -326,8 +315,7 @@ function createDefaultConfig(projectId) {
       }
     },
     state: {
-      dir: ".searchsocket",
-      writeMirror: false
+      dir: ".searchsocket"
     }
   };
 }
@@ -435,21 +423,13 @@ ${issues}`
       ...defaults.chunking,
       ...parsed.chunking
     },
-    embeddings: {
-      ...defaults.embeddings,
-      ...parsed.embeddings
+    upstash: {
+      ...defaults.upstash,
+      ...parsed.upstash
     },
-    vector: {
-      ...defaults.vector,
-      ...parsed.vector,
-      turso: {
-        ...defaults.vector.turso,
-        ...parsed.vector?.turso
-      }
-    },
-    rerank: {
-      ...defaults.rerank,
-      ...parsed.rerank
+    search: {
+      ...defaults.search,
+      ...parsed.search
     },
     ranking: {
       ...defaults.ranking,
@@ -541,7 +521,8 @@ function writeMinimalConfig(cwd) {
     return target;
   }
   const content = `export default {
-  embeddings: { apiKeyEnv: "JINA_API_KEY" }
+  // Upstash Search credentials (set via env vars or directly here)
+  // upstash: { urlEnv: "UPSTASH_SEARCH_REST_URL", tokenEnv: "UPSTASH_SEARCH_REST_TOKEN" }
 };
 `;
   fs.writeFileSync(target, content, "utf8");
@@ -704,576 +685,246 @@ import fs2 from "fs";
 import path2 from "path";
 function ensureStateDirs(cwd, stateDir, scope) {
   const statePath = path2.resolve(cwd, stateDir);
-  const pagesPath = path2.join(statePath, "pages", scope.scopeName);
-  fs2.mkdirSync(pagesPath, { recursive: true });
-  return { statePath, pagesPath };
-}
-
-// src/embeddings/jina.ts
-import pLimit from "p-limit";
-function sleep(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-var JinaEmbeddingsProvider = class {
-  apiKey;
-  batchSize;
-  concurrency;
-  defaultTask;
-  constructor(options) {
-    if (!Number.isInteger(options.batchSize) || options.batchSize <= 0) {
-      throw new Error(`Invalid batchSize: ${options.batchSize}. batchSize must be a positive integer.`);
-    }
-    if (!Number.isInteger(options.concurrency) || options.concurrency <= 0) {
-      throw new Error(`Invalid concurrency: ${options.concurrency}. concurrency must be a positive integer.`);
-    }
-    this.apiKey = options.apiKey;
-    this.batchSize = options.batchSize;
-    this.concurrency = options.concurrency;
-    this.defaultTask = options.task ?? "retrieval.passage";
-  }
-  estimateTokens(text) {
-    const normalized = text.trim();
-    if (!normalized) {
-      return 0;
-    }
-    const wordCount = normalized.match(/[A-Za-z0-9_]+/g)?.length ?? 0;
-    const punctuationCount = normalized.match(/[^\s\w]/g)?.length ?? 0;
-    const cjkCount = normalized.match(/[\u3400-\u9fff]/g)?.length ?? 0;
-    const charEstimate = Math.ceil(normalized.length / 4);
-    const lexicalEstimate = Math.ceil(wordCount * 1.25 + punctuationCount * 0.45 + cjkCount * 1.6);
-    return Math.max(1, Math.max(charEstimate, lexicalEstimate));
-  }
-  async embedTexts(texts, modelId, task) {
-    if (texts.length === 0) {
-      return [];
-    }
-    const batches = [];
-    for (let i = 0; i < texts.length; i += this.batchSize) {
-      batches.push({
-        index: i,
-        values: texts.slice(i, i + this.batchSize)
-      });
-    }
-    const outputs = new Array(batches.length);
-    const limit = pLimit(this.concurrency);
-    await Promise.all(
-      batches.map(
-        (batch, position) => limit(async () => {
-          outputs[position] = await this.embedWithRetry(batch.values, modelId, task ?? this.defaultTask);
-        })
-      )
-    );
-    return outputs.flat();
-  }
-  async embedWithRetry(texts, modelId, task) {
-    const maxAttempts = 5;
-    let attempt = 0;
-    while (attempt < maxAttempts) {
-      attempt += 1;
-      let response;
-      try {
-        response = await fetch("https://api.jina.ai/v1/embeddings", {
-          method: "POST",
-          headers: {
-            "content-type": "application/json",
-            authorization: `Bearer ${this.apiKey}`
-          },
-          body: JSON.stringify({
-            model: modelId,
-            input: texts,
-            task
-          })
-        });
-      } catch (error) {
-        if (attempt >= maxAttempts) {
-          throw error;
-        }
-        await sleep(Math.min(2 ** attempt * 300, 5e3));
-        continue;
-      }
-      if (!response.ok) {
-        const retryable = response.status === 429 || response.status >= 500;
-        if (!retryable || attempt >= maxAttempts) {
-          const errorBody = await response.text();
-          throw new Error(`Jina embeddings failed (${response.status}): ${errorBody}`);
-        }
-        await sleep(Math.min(2 ** attempt * 300, 5e3));
-        continue;
-      }
-      const payload = await response.json();
-      if (!payload.data || !Array.isArray(payload.data)) {
-        throw new Error("Invalid Jina embeddings response format");
-      }
-      return payload.data.map((entry) => entry.embedding);
-    }
-    throw new Error("Unreachable retry state");
-  }
-};
-
-// src/embeddings/factory.ts
-function createEmbeddingsProvider(config) {
-  if (config.embeddings.provider !== "jina") {
-    throw new SearchSocketError(
-      "CONFIG_MISSING",
-      `Unsupported embeddings provider ${config.embeddings.provider}`
-    );
-  }
-  const apiKey = config.embeddings.apiKey ?? process.env[config.embeddings.apiKeyEnv];
-  if (!apiKey) {
-    throw new SearchSocketError(
-      "CONFIG_MISSING",
-      `Missing embeddings API key: provide embeddings.apiKey or set env var ${config.embeddings.apiKeyEnv}`
-    );
-  }
-  return new JinaEmbeddingsProvider({
-    apiKey,
-    batchSize: config.embeddings.batchSize,
-    concurrency: config.embeddings.concurrency
-  });
+  fs2.mkdirSync(statePath, { recursive: true });
+  return { statePath };
 }
 
 // src/indexing/pipeline.ts
-import path12 from "path";
-
-// src/vector/factory.ts
-import fs3 from "fs";
-import path3 from "path";
+import path10 from "path";
 
-// src/core/serverless.ts
-function isServerless() {
-  return !!(process.env.VERCEL || process.env.NETLIFY || process.env.AWS_LAMBDA_FUNCTION_NAME || process.env.FUNCTIONS_WORKER || process.env.CF_PAGES);
+// src/vector/upstash.ts
+function chunkIndexName(scope) {
+  return `${scope.projectId}--${scope.scopeName}`;
 }
-
-// src/vector/turso.ts
-var TursoVectorStore = class {
+function pageIndexName(scope) {
+  return `${scope.projectId}--${scope.scopeName}--pages`;
+}
+var UpstashSearchStore = class {
   client;
-  dimension;
-  chunksReady = false;
-  registryReady = false;
-  pagesReady = false;
   constructor(opts) {
     this.client = opts.client;
-    this.dimension = opts.dimension;
-  }
-  async ensureRegistry() {
-    if (this.registryReady) return;
-    await this.client.execute(`
-      CREATE TABLE IF NOT EXISTS registry (
-        scope_key   TEXT PRIMARY KEY,
-        project_id  TEXT NOT NULL,
-        scope_name  TEXT NOT NULL,
-        model_id    TEXT NOT NULL,
-        last_indexed_at TEXT NOT NULL,
-        vector_count INTEGER,
-        last_estimate_tokens INTEGER,
-        last_estimate_cost_usd REAL,
-        last_estimate_changed_chunks INTEGER
-      )
-    `);
-    const estimateCols = [
-      { name: "last_estimate_tokens", def: "INTEGER" },
-      { name: "last_estimate_cost_usd", def: "REAL" },
-      { name: "last_estimate_changed_chunks", def: "INTEGER" }
-    ];
-    for (const col of estimateCols) {
-      try {
-        await this.client.execute(`ALTER TABLE registry ADD COLUMN ${col.name} ${col.def}`);
-      } catch (error) {
-        if (error instanceof Error && !error.message.includes("duplicate column")) {
-          throw error;
-        }
-      }
-    }
-    this.registryReady = true;
-  }
-  async ensureChunks(dim) {
-    if (this.chunksReady) return;
-    const exists = await this.chunksTableExists();
-    if (exists) {
-      const currentDim = await this.getChunksDimension();
-      if (currentDim !== null && currentDim !== dim) {
-        await this.client.batch([
-          "DROP INDEX IF EXISTS idx",
-          "DROP TABLE IF EXISTS chunks"
-        ]);
-      }
-    }
-    await this.client.batch([
-      `CREATE TABLE IF NOT EXISTS chunks (
-        id             TEXT PRIMARY KEY,
-        project_id     TEXT NOT NULL,
-        scope_name     TEXT NOT NULL,
-        url            TEXT NOT NULL,
-        path           TEXT NOT NULL,
-        title          TEXT NOT NULL,
-        section_title  TEXT NOT NULL DEFAULT '',
-        heading_path   TEXT NOT NULL DEFAULT '[]',
-        snippet        TEXT NOT NULL DEFAULT '',
-        chunk_text     TEXT NOT NULL DEFAULT '',
-        ordinal        INTEGER NOT NULL DEFAULT 0,
-        content_hash   TEXT NOT NULL DEFAULT '',
-        model_id       TEXT NOT NULL DEFAULT '',
-        depth          INTEGER NOT NULL DEFAULT 0,
-        incoming_links INTEGER NOT NULL DEFAULT 0,
-        route_file     TEXT NOT NULL DEFAULT '',
-        tags           TEXT NOT NULL DEFAULT '[]',
-        description    TEXT NOT NULL DEFAULT '',
-        keywords       TEXT NOT NULL DEFAULT '[]',
-        embedding      F32_BLOB(${dim})
-      )`,
-      `CREATE INDEX IF NOT EXISTS idx ON chunks (libsql_vector_idx(embedding, 'metric=cosine'))`
-    ]);
-    this.chunksReady = true;
-  }
-  async ensurePages() {
-    if (this.pagesReady) return;
-    await this.client.execute(`
-      CREATE TABLE IF NOT EXISTS pages (
-        project_id       TEXT NOT NULL,
-        scope_name       TEXT NOT NULL,
-        url              TEXT NOT NULL,
-        title            TEXT NOT NULL,
-        markdown         TEXT NOT NULL,
-        route_file       TEXT NOT NULL DEFAULT '',
-        route_resolution TEXT NOT NULL DEFAULT 'exact',
-        incoming_links   INTEGER NOT NULL DEFAULT 0,
-        outgoing_links   INTEGER NOT NULL DEFAULT 0,
-        depth            INTEGER NOT NULL DEFAULT 0,
-        tags             TEXT NOT NULL DEFAULT '[]',
-        indexed_at       TEXT NOT NULL,
-        PRIMARY KEY (project_id, scope_name, url)
-      )
-    `);
-    this.pagesReady = true;
   }
-  async chunksTableExists() {
-    try {
-      await this.client.execute("SELECT 1 FROM chunks LIMIT 0");
-      return true;
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("no such table")) {
-        return false;
-      }
-      throw error;
-    }
+  chunkIndex(scope) {
+    return this.client.index(chunkIndexName(scope));
   }
-  /**
-   * Read the current F32_BLOB dimension from the chunks table schema.
-   * Returns null if the table doesn't exist or the dimension can't be parsed.
-   */
-  async getChunksDimension() {
-    try {
-      const rs = await this.client.execute(
-        "SELECT sql FROM sqlite_master WHERE type='table' AND name='chunks'"
-      );
-      if (rs.rows.length === 0) return null;
-      const sql = rs.rows[0].sql;
-      const match = sql.match(/F32_BLOB\((\d+)\)/i);
-      return match ? parseInt(match[1], 10) : null;
-    } catch {
-      return null;
-    }
+  pageIndex(scope) {
+    return this.client.index(pageIndexName(scope));
   }
-  /**
-   * Drop all SearchSocket tables (chunks, registry, pages) and their indexes.
-   * Used by `clean --remote` for a full reset.
-   */
-  async dropAllTables() {
-    await this.client.batch([
-      "DROP INDEX IF EXISTS idx",
-      "DROP TABLE IF EXISTS chunks",
-      "DROP TABLE IF EXISTS registry",
-      "DROP TABLE IF EXISTS pages"
-    ]);
-    this.chunksReady = false;
-    this.registryReady = false;
-    this.pagesReady = false;
-  }
-  async upsert(records, _scope) {
-    if (records.length === 0) return;
-    const dim = this.dimension ?? records[0].vector.length;
-    await this.ensureChunks(dim);
+  async upsertChunks(chunks, scope) {
+    if (chunks.length === 0) return;
+    const index = this.chunkIndex(scope);
     const BATCH_SIZE = 100;
-    for (let i = 0; i < records.length; i += BATCH_SIZE) {
-      const batch = records.slice(i, i + BATCH_SIZE);
-      const stmts = batch.map((r) => ({
-        sql: `INSERT OR REPLACE INTO chunks
-              (id, project_id, scope_name, url, path, title, section_title,
-               heading_path, snippet, chunk_text, ordinal, content_hash, model_id, depth,
-               incoming_links, route_file, tags, description, keywords, embedding)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, vector(?))`,
-        args: [
-          r.id,
-          r.metadata.projectId,
-          r.metadata.scopeName,
-          r.metadata.url,
-          r.metadata.path,
-          r.metadata.title,
-          r.metadata.sectionTitle,
-          JSON.stringify(r.metadata.headingPath),
-          r.metadata.snippet,
-          r.metadata.chunkText,
-          r.metadata.ordinal,
-          r.metadata.contentHash,
-          r.metadata.modelId,
-          r.metadata.depth,
-          r.metadata.incomingLinks,
-          r.metadata.routeFile,
-          JSON.stringify(r.metadata.tags),
-          r.metadata.description ?? "",
-          JSON.stringify(r.metadata.keywords ?? []),
-          JSON.stringify(r.vector)
-        ]
-      }));
-      await this.client.batch(stmts);
-    }
-  }
-  async query(queryVector, opts, scope) {
-    const dim = this.dimension ?? queryVector.length;
-    await this.ensureChunks(dim);
-    const queryJson = JSON.stringify(queryVector);
-    const rs = await this.client.execute({
-      sql: `SELECT c.id, c.project_id, c.scope_name, c.url, c.path, c.title,
-                   c.section_title, c.heading_path, c.snippet, c.chunk_text,
-                   c.ordinal, c.content_hash,
-                   c.model_id, c.depth, c.incoming_links, c.route_file, c.tags,
-                   c.description, c.keywords,
-                   vector_distance_cos(c.embedding, vector(?)) AS distance
-            FROM vector_top_k('idx', vector(?), ?) AS v
-            JOIN chunks AS c ON c.rowid = v.id`,
-      args: [queryJson, queryJson, opts.topK]
+    for (let i = 0; i < chunks.length; i += BATCH_SIZE) {
+      const batch = chunks.slice(i, i + BATCH_SIZE);
+      await index.upsert(batch);
+    }
+  }
+  async search(query, opts, scope) {
+    const index = this.chunkIndex(scope);
+    const results = await index.search({
+      query,
+      limit: opts.limit,
+      semanticWeight: opts.semanticWeight,
+      inputEnrichment: opts.inputEnrichment,
+      reranking: opts.reranking,
+      filter: opts.filter
     });
-    let hits = [];
-    for (const row of rs.rows) {
-      const projectId = row.project_id;
-      const scopeName = row.scope_name;
-      if (projectId !== scope.projectId || scopeName !== scope.scopeName) {
-        continue;
-      }
-      const rowPath = row.path;
-      if (opts.pathPrefix) {
-        const rawPrefix = opts.pathPrefix.startsWith("/") ? opts.pathPrefix : `/${opts.pathPrefix}`;
-        const prefix = rawPrefix.endsWith("/") ? rawPrefix : `${rawPrefix}/`;
-        const normalizedPath = rowPath.replace(/\/$/, "");
-        const normalizedPrefix = rawPrefix.replace(/\/$/, "");
-        if (normalizedPath !== normalizedPrefix && !rowPath.startsWith(prefix)) {
-          continue;
-        }
-      }
-      const tags = JSON.parse(row.tags || "[]");
-      if (opts.tags && opts.tags.length > 0) {
-        if (!opts.tags.every((t) => tags.includes(t))) {
-          continue;
-        }
+    return results.map((doc) => ({
+      id: doc.id,
+      score: doc.score,
+      metadata: {
+        projectId: doc.metadata?.projectId ?? "",
+        scopeName: doc.metadata?.scopeName ?? "",
+        url: doc.content.url,
+        path: doc.metadata?.path ?? "",
+        title: doc.content.title,
+        sectionTitle: doc.content.sectionTitle,
+        headingPath: doc.content.headingPath ? doc.content.headingPath.split(" > ").filter(Boolean) : [],
+        snippet: doc.metadata?.snippet ?? "",
+        chunkText: doc.content.text,
+        ordinal: doc.metadata?.ordinal ?? 0,
+        contentHash: doc.metadata?.contentHash ?? "",
+        depth: doc.metadata?.depth ?? 0,
+        incomingLinks: doc.metadata?.incomingLinks ?? 0,
+        routeFile: doc.metadata?.routeFile ?? "",
+        tags: doc.content.tags ? doc.content.tags.split(",").filter(Boolean) : [],
+        description: doc.metadata?.description || void 0,
+        keywords: doc.metadata?.keywords ? doc.metadata.keywords.split(",").filter(Boolean) : void 0
       }
-      const distance = row.distance;
-      const score = 1 - distance;
-      const description = row.description || void 0;
-      const keywords = (() => {
-        const raw = row.keywords || "[]";
-        const parsed = JSON.parse(raw);
-        return parsed.length > 0 ? parsed : void 0;
-      })();
-      hits.push({
-        id: row.id,
-        score,
-        metadata: {
-          projectId,
-          scopeName,
-          url: row.url,
-          path: rowPath,
-          title: row.title,
-          sectionTitle: row.section_title,
-          headingPath: JSON.parse(row.heading_path || "[]"),
-          snippet: row.snippet,
-          chunkText: row.chunk_text || "",
-          ordinal: row.ordinal || 0,
-          contentHash: row.content_hash,
-          modelId: row.model_id,
-          depth: row.depth,
-          incomingLinks: row.incoming_links,
-          routeFile: row.route_file,
-          tags,
-          description,
-          keywords
-        }
+    }));
+  }
+  async searchPages(query, opts, scope) {
+    const index = this.pageIndex(scope);
+    let results;
+    try {
+      results = await index.search({
+        query,
+        limit: opts.limit,
+        semanticWeight: opts.semanticWeight,
+        inputEnrichment: opts.inputEnrichment,
+        reranking: true,
+        filter: opts.filter
       });
+    } catch {
+      return [];
     }
-    hits.sort((a, b) => b.score - a.score);
-    return hits;
+    return results.map((doc) => ({
+      id: doc.id,
+      score: doc.score,
+      title: doc.content.title,
+      url: doc.content.url,
+      description: doc.content.description ?? "",
+      tags: doc.content.tags ? doc.content.tags.split(",").filter(Boolean) : [],
+      depth: doc.metadata?.depth ?? 0,
+      incomingLinks: doc.metadata?.incomingLinks ?? 0,
+      routeFile: doc.metadata?.routeFile ?? ""
+    }));
   }
   async deleteByIds(ids, scope) {
     if (ids.length === 0) return;
+    const index = this.chunkIndex(scope);
     const BATCH_SIZE = 500;
     for (let i = 0; i < ids.length; i += BATCH_SIZE) {
       const batch = ids.slice(i, i + BATCH_SIZE);
-      const placeholders = batch.map(() => "?").join(", ");
-      await this.client.execute({
-        sql: `DELETE FROM chunks WHERE project_id = ? AND scope_name = ? AND id IN (${placeholders})`,
-        args: [scope.projectId, scope.scopeName, ...batch]
-      });
+      await index.delete(batch);
     }
   }
   async deleteScope(scope) {
-    await this.ensureRegistry();
     try {
-      await this.client.execute({
-        sql: `DELETE FROM chunks WHERE project_id = ? AND scope_name = ?`,
-        args: [scope.projectId, scope.scopeName]
-      });
-    } catch (error) {
-      if (error instanceof Error && !error.message.includes("no such table")) {
-        throw error;
-      }
+      const chunkIdx = this.chunkIndex(scope);
+      await chunkIdx.deleteIndex();
+    } catch {
     }
     try {
-      await this.client.execute({
-        sql: `DELETE FROM pages WHERE project_id = ? AND scope_name = ?`,
-        args: [scope.projectId, scope.scopeName]
-      });
-    } catch (error) {
-      if (error instanceof Error && !error.message.includes("no such table")) {
-        throw error;
-      }
+      const pageIdx = this.pageIndex(scope);
+      await pageIdx.deleteIndex();
+    } catch {
     }
-    await this.client.execute({
-      sql: `DELETE FROM registry WHERE project_id = ? AND scope_name = ?`,
-      args: [scope.projectId, scope.scopeName]
-    });
   }
-  async listScopes(scopeProjectId) {
-    await this.ensureRegistry();
-    const rs = await this.client.execute({
-      sql: `SELECT project_id, scope_name, model_id, last_indexed_at, vector_count,
-                   last_estimate_tokens, last_estimate_cost_usd, last_estimate_changed_chunks
-            FROM registry WHERE project_id = ?`,
-      args: [scopeProjectId]
-    });
-    return rs.rows.map((row) => ({
-      projectId: row.project_id,
-      scopeName: row.scope_name,
-      modelId: row.model_id,
-      lastIndexedAt: row.last_indexed_at,
-      vectorCount: row.vector_count,
-      lastEstimateTokens: row.last_estimate_tokens,
-      lastEstimateCostUSD: row.last_estimate_cost_usd,
-      lastEstimateChangedChunks: row.last_estimate_changed_chunks
-    }));
-  }
-  async recordScope(info) {
-    await this.ensureRegistry();
-    const key = `${info.projectId}:${info.scopeName}`;
-    await this.client.execute({
-      sql: `INSERT OR REPLACE INTO registry
-            (scope_key, project_id, scope_name, model_id, last_indexed_at, vector_count,
-             last_estimate_tokens, last_estimate_cost_usd, last_estimate_changed_chunks)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-      args: [
-        key,
-        info.projectId,
-        info.scopeName,
-        info.modelId,
-        info.lastIndexedAt,
-        info.vectorCount ?? null,
-        info.lastEstimateTokens ?? null,
-        info.lastEstimateCostUSD ?? null,
-        info.lastEstimateChangedChunks ?? null
-      ]
-    });
+  async listScopes(projectId) {
+    const allIndexes = await this.client.listIndexes();
+    const prefix = `${projectId}--`;
+    const scopeNames = /* @__PURE__ */ new Set();
+    for (const name of allIndexes) {
+      if (name.startsWith(prefix) && !name.endsWith("--pages")) {
+        const scopeName = name.slice(prefix.length);
+        scopeNames.add(scopeName);
+      }
+    }
+    const scopes = [];
+    for (const scopeName of scopeNames) {
+      const scope = {
+        projectId,
+        scopeName,
+        scopeId: `${projectId}:${scopeName}`
+      };
+      try {
+        const info = await this.chunkIndex(scope).info();
+        scopes.push({
+          projectId,
+          scopeName,
+          lastIndexedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          documentCount: info.documentCount
+        });
+      } catch {
+        scopes.push({
+          projectId,
+          scopeName,
+          lastIndexedAt: "unknown",
+          documentCount: 0
+        });
+      }
+    }
+    return scopes;
   }
   async getContentHashes(scope) {
-    const exists = await this.chunksTableExists();
-    if (!exists) return /* @__PURE__ */ new Map();
-    const rs = await this.client.execute({
-      sql: `SELECT id, content_hash FROM chunks WHERE project_id = ? AND scope_name = ?`,
-      args: [scope.projectId, scope.scopeName]
-    });
     const map = /* @__PURE__ */ new Map();
-    for (const row of rs.rows) {
-      map.set(row.id, row.content_hash);
+    const index = this.chunkIndex(scope);
+    let cursor = "0";
+    try {
+      for (; ; ) {
+        const result = await index.range({ cursor, limit: 100 });
+        for (const doc of result.documents) {
+          if (doc.metadata?.contentHash) {
+            map.set(doc.id, doc.metadata.contentHash);
+          }
+        }
+        if (!result.nextCursor || result.nextCursor === "0") break;
+        cursor = result.nextCursor;
+      }
+    } catch {
     }
     return map;
   }
   async upsertPages(pages, scope) {
     if (pages.length === 0) return;
-    await this.ensurePages();
-    for (const page of pages) {
-      if (page.projectId !== scope.projectId || page.scopeName !== scope.scopeName) {
-        throw new Error(
-          `Page scope mismatch: page has ${page.projectId}:${page.scopeName} but scope is ${scope.projectId}:${scope.scopeName}`
-        );
-      }
-    }
-    const BATCH_SIZE = 100;
+    const index = this.pageIndex(scope);
+    const BATCH_SIZE = 50;
     for (let i = 0; i < pages.length; i += BATCH_SIZE) {
       const batch = pages.slice(i, i + BATCH_SIZE);
-      const stmts = batch.map((p) => ({
-        sql: `INSERT OR REPLACE INTO pages
-              (project_id, scope_name, url, title, markdown, route_file,
-               route_resolution, incoming_links, outgoing_links, depth, tags, indexed_at)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        args: [
-          p.projectId,
-          p.scopeName,
-          p.url,
-          p.title,
-          p.markdown,
-          p.routeFile,
-          p.routeResolution,
-          p.incomingLinks,
-          p.outgoingLinks,
-          p.depth,
-          JSON.stringify(p.tags),
-          p.indexedAt
-        ]
+      const docs = batch.map((p) => ({
+        id: p.url,
+        content: {
+          title: p.title,
+          url: p.url,
+          type: "page",
+          description: p.description ?? "",
+          keywords: (p.keywords ?? []).join(","),
+          summary: p.summary ?? "",
+          tags: p.tags.join(",")
+        },
+        metadata: {
+          markdown: p.markdown,
+          projectId: p.projectId,
+          scopeName: p.scopeName,
+          routeFile: p.routeFile,
+          routeResolution: p.routeResolution,
+          incomingLinks: p.incomingLinks,
+          outgoingLinks: p.outgoingLinks,
+          depth: p.depth,
+          indexedAt: p.indexedAt
+        }
       }));
-      await this.client.batch(stmts);
+      await index.upsert(docs);
     }
   }
   async getPage(url, scope) {
-    await this.ensurePages();
-    const rs = await this.client.execute({
-      sql: `SELECT * FROM pages WHERE project_id = ? AND scope_name = ? AND url = ?`,
-      args: [scope.projectId, scope.scopeName, url]
-    });
-    if (rs.rows.length === 0) return null;
-    const row = rs.rows[0];
-    return {
-      url: row.url,
-      title: row.title,
-      markdown: row.markdown,
-      projectId: row.project_id,
-      scopeName: row.scope_name,
-      routeFile: row.route_file,
-      routeResolution: row.route_resolution,
-      incomingLinks: row.incoming_links,
-      outgoingLinks: row.outgoing_links,
-      depth: row.depth,
-      tags: JSON.parse(row.tags || "[]"),
-      indexedAt: row.indexed_at
-    };
+    const index = this.pageIndex(scope);
+    try {
+      const results = await index.fetch([url]);
+      const doc = results[0];
+      if (!doc) return null;
+      return {
+        url: doc.content.url,
+        title: doc.content.title,
+        markdown: doc.metadata.markdown,
+        projectId: doc.metadata.projectId,
+        scopeName: doc.metadata.scopeName,
+        routeFile: doc.metadata.routeFile,
+        routeResolution: doc.metadata.routeResolution,
+        incomingLinks: doc.metadata.incomingLinks,
+        outgoingLinks: doc.metadata.outgoingLinks,
+        depth: doc.metadata.depth,
+        tags: doc.content.tags ? doc.content.tags.split(",").filter(Boolean) : [],
+        indexedAt: doc.metadata.indexedAt,
+        summary: doc.content.summary || void 0,
+        description: doc.content.description || void 0,
+        keywords: doc.content.keywords ? doc.content.keywords.split(",").filter(Boolean) : void 0
+      };
+    } catch {
+      return null;
+    }
   }
   async deletePages(scope) {
-    await this.ensurePages();
-    await this.client.execute({
-      sql: `DELETE FROM pages WHERE project_id = ? AND scope_name = ?`,
-      args: [scope.projectId, scope.scopeName]
-    });
-  }
-  async getScopeModelId(scope) {
-    await this.ensureRegistry();
-    const rs = await this.client.execute({
-      sql: `SELECT model_id FROM registry WHERE project_id = ? AND scope_name = ?`,
-      args: [scope.projectId, scope.scopeName]
-    });
-    if (rs.rows.length === 0) return null;
-    return rs.rows[0].model_id;
+    try {
+      const index = this.pageIndex(scope);
+      await index.reset();
+    } catch {
+    }
   }
   async health() {
     try {
-      await this.client.execute("SELECT 1");
+      await this.client.info();
       return { ok: true };
     } catch (error) {
       return {
@@ -1282,40 +933,34 @@ var TursoVectorStore = class {
       };
     }
   }
+  async dropAllIndexes(projectId) {
+    const allIndexes = await this.client.listIndexes();
+    const prefix = `${projectId}--`;
+    for (const name of allIndexes) {
+      if (name.startsWith(prefix)) {
+        try {
+          const index = this.client.index(name);
+          await index.deleteIndex();
+        } catch {
+        }
+      }
+    }
+  }
 };
 
 // src/vector/factory.ts
-async function createVectorStore(config, cwd) {
-  const turso = config.vector.turso;
-  const remoteUrl = turso.url ?? process.env[turso.urlEnv];
-  if (remoteUrl) {
-    const { createClient: createClient2 } = await import("@libsql/client/http");
-    const authToken = turso.authToken ?? process.env[turso.authTokenEnv];
-    const client2 = createClient2({
-      url: remoteUrl,
-      authToken
-    });
-    return new TursoVectorStore({
-      client: client2,
-      dimension: config.vector.dimension
-    });
-  }
-  if (isServerless()) {
+async function createUpstashStore(config) {
+  const url = config.upstash.url ?? process.env[config.upstash.urlEnv];
+  const token = config.upstash.token ?? process.env[config.upstash.tokenEnv];
+  if (!url || !token) {
     throw new SearchSocketError(
       "VECTOR_BACKEND_UNAVAILABLE",
-      `No remote vector database URL found (checked vector.turso.url and env var "${turso.urlEnv}"). Local SQLite storage is not available in serverless environments. Set ${turso.urlEnv} or pass vector.turso.url directly.`
+      `Missing Upstash Search credentials. Set ${config.upstash.urlEnv} and ${config.upstash.tokenEnv} environment variables, or pass upstash.url and upstash.token in your config.`
     );
   }
-  const { createClient } = await import("@libsql/client");
-  const localPath = path3.resolve(cwd, turso.localPath);
-  fs3.mkdirSync(path3.dirname(localPath), { recursive: true });
-  const client = createClient({
-    url: `file:${localPath}`
-  });
-  return new TursoVectorStore({
-    client,
-    dimension: config.vector.dimension
-  });
+  const { Search } = await import("@upstash/search");
+  const client = new Search({ url, token });
+  return new UpstashSearchStore({ client });
 }
 
 // src/utils/hash.ts
@@ -1328,7 +973,7 @@ function sha256(input) {
 }
 
 // src/utils/path.ts
-import path4 from "path";
+import path3 from "path";
 function normalizeUrlPath(rawPath) {
   let out = rawPath.trim();
   if (!out.startsWith("/")) {
@@ -1340,15 +985,8 @@ function normalizeUrlPath(rawPath) {
   }
   return out;
 }
-function urlPathToMirrorRelative(urlPath) {
-  const normalized = normalizeUrlPath(urlPath);
-  if (normalized === "/") {
-    return "index.md";
-  }
-  return `${normalized.slice(1)}.md`;
-}
 function staticHtmlFileToUrl(filePath, rootDir) {
-  const relative = path4.relative(rootDir, filePath).replace(/\\/g, "/");
+  const relative = path3.relative(rootDir, filePath).replace(/\\/g, "/");
   if (relative === "index.html") {
     return "/";
   }
@@ -1621,7 +1259,7 @@ function buildEmbeddingText(chunk, prependTitle) {
 
 ${chunk.chunkText}`;
 }
-function chunkMirrorPage(page, config, scope) {
+function chunkPage(page, config, scope) {
   const sections = parseHeadingSections(page.markdown, config.chunking.headingPathDepth);
   const rawChunks = sections.flatMap((section) => splitSection(section, config.chunking));
   const chunks = [];
@@ -1831,59 +1469,8 @@ function extractFromMarkdown(url, markdown, title) {
   };
 }
 
-// src/indexing/mirror.ts
-import fs4 from "fs/promises";
-import path5 from "path";
-function yamlString(value) {
-  return JSON.stringify(value);
-}
-function yamlArray(values) {
-  return `[${values.map((v) => JSON.stringify(v)).join(", ")}]`;
-}
-function buildMirrorMarkdown(page) {
-  const frontmatterLines = [
-    "---",
-    `url: ${yamlString(page.url)}`,
-    `title: ${yamlString(page.title)}`,
-    `scope: ${yamlString(page.scope)}`,
-    `routeFile: ${yamlString(page.routeFile)}`,
-    `routeResolution: ${yamlString(page.routeResolution)}`,
-    `generatedAt: ${yamlString(page.generatedAt)}`,
-    `incomingLinks: ${page.incomingLinks}`,
-    `outgoingLinks: ${page.outgoingLinks}`,
-    `depth: ${page.depth}`,
-    `tags: ${yamlArray(page.tags)}`,
-    "---",
-    ""
-  ];
-  return `${frontmatterLines.join("\n")}${normalizeMarkdown(page.markdown)}`;
-}
-function stripGeneratedAt(content) {
-  return content.replace(/^generatedAt: .*$/m, "");
-}
-async function writeMirrorPage(statePath, scope, page) {
-  const relative = urlPathToMirrorRelative(page.url);
-  const outputPath = path5.join(statePath, "pages", scope.scopeName, relative);
-  await fs4.mkdir(path5.dirname(outputPath), { recursive: true });
-  const newContent = buildMirrorMarkdown(page);
-  try {
-    const existing = await fs4.readFile(outputPath, "utf8");
-    if (stripGeneratedAt(existing) === stripGeneratedAt(newContent)) {
-      return outputPath;
-    }
-  } catch {
-  }
-  await fs4.writeFile(outputPath, newContent, "utf8");
-  return outputPath;
-}
-async function cleanMirrorForScope(statePath, scope) {
-  const target = path5.join(statePath, "pages", scope.scopeName);
-  await fs4.rm(target, { recursive: true, force: true });
-  await fs4.mkdir(target, { recursive: true });
-}
-
 // src/indexing/route-mapper.ts
-import path6 from "path";
+import path4 from "path";
 import fg from "fast-glob";
 function segmentToRegex(segment) {
   if (segment.startsWith("(") && segment.endsWith(")")) {
@@ -1904,7 +1491,7 @@ function segmentToRegex(segment) {
   return { regex: `/${segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, score: 10 };
 }
 function routeFileToPattern(routeFile, cwd) {
-  const relative = path6.relative(cwd, routeFile).replace(/\\/g, "/");
+  const relative = path4.relative(cwd, routeFile).replace(/\\/g, "/");
   const withoutPrefix = relative.replace(/^src\/routes\/?/, "");
   const withoutPage = withoutPrefix.replace(/\/\+page\.[^/]+$/, "");
   const segments = withoutPage.split("/").filter(Boolean);
@@ -1959,11 +1546,11 @@ function mapUrlToRoute(urlPath, patterns) {
 
 // src/indexing/sources/build/index.ts
 import { load as cheerioLoad } from "cheerio";
-import pLimit2 from "p-limit";
+import pLimit from "p-limit";
 
 // src/indexing/sources/build/manifest-parser.ts
-import fs5 from "fs/promises";
-import path7 from "path";
+import fs3 from "fs/promises";
+import path5 from "path";
 
 // src/utils/pattern.ts
 function matchUrlPattern(url, pattern) {
@@ -2007,10 +1594,10 @@ function routeIdToUrl(routeId) {
   return routeId.split("/").filter((seg) => !(seg.startsWith("(") && seg.endsWith(")"))).join("/") || "/";
 }
 async function parseManifest(cwd, outputDir) {
-  const manifestPath = path7.resolve(cwd, outputDir, "server", "manifest-full.js");
+  const manifestPath = path5.resolve(cwd, outputDir, "server", "manifest-full.js");
   let content;
   try {
-    content = await fs5.readFile(manifestPath, "utf8");
+    content = await fs3.readFile(manifestPath, "utf8");
   } catch {
     throw new SearchSocketError(
       "BUILD_MANIFEST_NOT_FOUND",
@@ -2074,8 +1661,8 @@ function isExcluded(url, patterns) {
 
 // src/indexing/sources/build/preview-server.ts
 import net from "net";
-import path8 from "path";
-import fs6 from "fs";
+import path6 from "path";
+import fs4 from "fs";
 import { spawn } from "child_process";
 function findFreePort() {
   return new Promise((resolve, reject) => {
@@ -2114,8 +1701,8 @@ async function waitForReady(url, timeout, child) {
   );
 }
 async function startPreviewServer(cwd, options, logger3) {
-  const viteBin = path8.join(cwd, "node_modules", ".bin", "vite");
-  if (!fs6.existsSync(viteBin)) {
+  const viteBin = path6.join(cwd, "node_modules", ".bin", "vite");
+  if (!fs4.existsSync(viteBin)) {
     throw new SearchSocketError(
       "BUILD_SERVER_FAILED",
       `vite binary not found at ${viteBin}. Ensure vite is installed.`
@@ -2189,7 +1776,7 @@ async function discoverPages(server, buildConfig, pipelineMaxPages) {
   const visited = /* @__PURE__ */ new Set();
   const pages = [];
   const queue = [];
-  const limit = pLimit2(8);
+  const limit = pLimit(8);
   for (const seed of seedUrls) {
     const normalized = normalizeUrlPath(seed);
     if (!visited.has(normalized) && !isExcluded(normalized, exclude)) {
@@ -2271,7 +1858,7 @@ async function loadBuildPages(cwd, config, maxPages) {
   const selected = typeof maxCount === "number" ? expanded.slice(0, maxCount) : expanded;
   const server = await startPreviewServer(cwd, { previewTimeout: buildConfig.previewTimeout }, logger);
   try {
-    const concurrencyLimit = pLimit2(8);
+    const concurrencyLimit = pLimit(8);
     const results = await Promise.allSettled(
       selected.map(
         (route) => concurrencyLimit(async () => {
@@ -2311,11 +1898,11 @@ async function loadBuildPages(cwd, config, maxPages) {
 }
 
 // src/indexing/sources/content-files.ts
-import fs7 from "fs/promises";
-import path9 from "path";
+import fs5 from "fs/promises";
+import path7 from "path";
 import fg2 from "fast-glob";
 function filePathToUrl(filePath, baseDir) {
-  const relative = path9.relative(baseDir, filePath).replace(/\\/g, "/");
+  const relative = path7.relative(baseDir, filePath).replace(/\\/g, "/");
   const segments = relative.split("/").filter(Boolean);
   if (/(^|\/)\+page\.svelte$/.test(relative)) {
     const routeSegments = segments.slice();
@@ -2340,7 +1927,7 @@ async function loadContentFilesPages(cwd, config, maxPages) {
   if (!contentConfig) {
     throw new Error("content-files config is missing");
   }
-  const baseDir = path9.resolve(cwd, contentConfig.baseDir);
+  const baseDir = path7.resolve(cwd, contentConfig.baseDir);
   const files = await fg2(contentConfig.globs, {
     cwd: baseDir,
     absolute: true,
@@ -2350,12 +1937,12 @@ async function loadContentFilesPages(cwd, config, maxPages) {
   const selected = typeof limit === "number" ? files.slice(0, limit) : files;
   const pages = [];
   for (const filePath of selected) {
-    const raw = await fs7.readFile(filePath, "utf8");
+    const raw = await fs5.readFile(filePath, "utf8");
     const markdown = filePath.endsWith(".md") ? raw : normalizeSvelteToMarkdown(raw);
     pages.push({
       url: filePathToUrl(filePath, baseDir),
       markdown,
-      sourcePath: path9.relative(cwd, filePath).replace(/\\/g, "/"),
+      sourcePath: path7.relative(cwd, filePath).replace(/\\/g, "/"),
       outgoingLinks: []
     });
   }
@@ -2365,7 +1952,7 @@ async function loadContentFilesPages(cwd, config, maxPages) {
 // src/indexing/sources/crawl.ts
 import { gunzipSync } from "zlib";
 import { load as cheerioLoad2 } from "cheerio";
-import pLimit3 from "p-limit";
+import pLimit2 from "p-limit";
 var logger2 = new Logger();
 function extractLocs(xml) {
   const $ = cheerioLoad2(xml, { xmlMode: true });
@@ -2450,7 +2037,7 @@ async function loadCrawledPages(config, maxPages) {
   const routes = await resolveRoutes(config);
   const maxCount = typeof maxPages === "number" ? Math.max(0, Math.floor(maxPages)) : void 0;
   const selected = typeof maxCount === "number" ? routes.slice(0, maxCount) : routes;
-  const concurrencyLimit = pLimit3(8);
+  const concurrencyLimit = pLimit2(8);
   const results = await Promise.allSettled(
     selected.map(
       (route) => concurrencyLimit(async () => {
@@ -2483,11 +2070,11 @@ async function loadCrawledPages(config, maxPages) {
 }
 
 // src/indexing/sources/static-output.ts
-import fs8 from "fs/promises";
-import path10 from "path";
+import fs6 from "fs/promises";
+import path8 from "path";
 import fg3 from "fast-glob";
 async function loadStaticOutputPages(cwd, config, maxPages) {
-  const outputDir = path10.resolve(cwd, config.source.staticOutputDir);
+  const outputDir = path8.resolve(cwd, config.source.staticOutputDir);
   const htmlFiles = await fg3(["**/*.html"], {
     cwd: outputDir,
     absolute: true
@@ -2496,11 +2083,11 @@ async function loadStaticOutputPages(cwd, config, maxPages) {
   const selected = typeof limit === "number" ? htmlFiles.slice(0, limit) : htmlFiles;
   const pages = [];
   for (const filePath of selected) {
-    const html = await fs8.readFile(filePath, "utf8");
+    const html = await fs6.readFile(filePath, "utf8");
     pages.push({
       url: staticHtmlFileToUrl(filePath, outputDir),
       html,
-      sourcePath: path10.relative(cwd, filePath).replace(/\\/g, "/"),
+      sourcePath: path8.relative(cwd, filePath).replace(/\\/g, "/"),
       outgoingLinks: []
     });
   }
@@ -2508,8 +2095,8 @@ async function loadStaticOutputPages(cwd, config, maxPages) {
 }
 
 // src/indexing/robots.ts
-import fs9 from "fs/promises";
-import path11 from "path";
+import fs7 from "fs/promises";
+import path9 from "path";
 function parseRobotsTxt(content, userAgent = "Searchsocket") {
   const lines = content.split(/\r?\n/);
   const agentGroups = /* @__PURE__ */ new Map();
@@ -2563,7 +2150,7 @@ function isBlockedByRobots(urlPath, rules) {
 }
 async function loadRobotsTxtFromDir(dir) {
   try {
-    const content = await fs9.readFile(path11.join(dir, "robots.txt"), "utf8");
+    const content = await fs7.readFile(path9.join(dir, "robots.txt"), "utf8");
     return parseRobotsTxt(content);
   } catch {
     return null;
@@ -2588,7 +2175,12 @@ function nonNegativeOrZero(value) {
   }
   return Math.max(0, value);
 }
-function rankHits(hits, config) {
+function normalizeForTitleMatch(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, "").replace(/\s+/g, " ").trim();
+}
+function rankHits(hits, config, query) {
+  const normalizedQuery = query ? normalizeForTitleMatch(query) : "";
+  const titleMatchWeight = config.ranking.weights.titleMatch;
   return hits.map((hit) => {
     let score = Number.isFinite(hit.score) ? hit.score : Number.NEGATIVE_INFINITY;
     if (config.ranking.enableIncomingLinkBoost) {
@@ -2599,6 +2191,12 @@ function rankHits(hits, config) {
       const depthBoost = 1 / (1 + nonNegativeOrZero(hit.metadata.depth));
       score += depthBoost * config.ranking.weights.depth;
     }
+    if (normalizedQuery && titleMatchWeight > 0) {
+      const normalizedTitle = normalizeForTitleMatch(hit.metadata.title);
+      if (normalizedQuery.length > 0 && normalizedTitle.length > 0 && (normalizedTitle.includes(normalizedQuery) || normalizedQuery.includes(normalizedTitle))) {
+        score += titleMatchWeight;
+      }
+    }
     return {
       hit,
       finalScore: Number.isFinite(score) ? score : Number.NEGATIVE_INFINITY
@@ -2608,6 +2206,30 @@ function rankHits(hits, config) {
     return Number.isNaN(delta) ? 0 : delta;
   });
 }
+function trimByScoreGap(results, config) {
+  if (results.length === 0) return results;
+  const threshold = config.ranking.scoreGapThreshold;
+  const minScore = config.ranking.minScore;
+  if (minScore > 0 && results.length > 0) {
+    const sortedScores = results.map((r) => r.pageScore).sort((a, b) => a - b);
+    const mid = Math.floor(sortedScores.length / 2);
+    const median = sortedScores.length % 2 === 0 ? (sortedScores[mid - 1] + sortedScores[mid]) / 2 : sortedScores[mid];
+    if (median < minScore) return [];
+  }
+  if (threshold > 0 && results.length > 1) {
+    for (let i = 1; i < results.length; i++) {
+      const prev = results[i - 1].pageScore;
+      const current = results[i].pageScore;
+      if (prev > 0) {
+        const gap = (prev - current) / prev;
+        if (gap >= threshold) {
+          return results.slice(0, i);
+        }
+      }
+    }
+  }
+  return results;
+}
 function findPageWeight(url, pageWeights) {
   let bestPattern = "";
   let bestWeight = 1;
@@ -2662,6 +2284,61 @@ function aggregateByPage(ranked, config) {
     return Number.isNaN(delta) ? 0 : delta;
   });
 }
+function mergePageAndChunkResults(pageHits, rankedChunks, config) {
+  if (pageHits.length === 0) return rankedChunks;
+  const w = config.search.pageSearchWeight;
+  const pageScoreMap = /* @__PURE__ */ new Map();
+  for (const ph of pageHits) {
+    pageScoreMap.set(ph.url, ph);
+  }
+  const pagesWithChunks = /* @__PURE__ */ new Set();
+  const merged = rankedChunks.map((ranked) => {
+    const url = ranked.hit.metadata.url;
+    const pageHit = pageScoreMap.get(url);
+    if (pageHit) {
+      pagesWithChunks.add(url);
+      const blended = (1 - w) * ranked.finalScore + w * pageHit.score;
+      return {
+        hit: ranked.hit,
+        finalScore: Number.isFinite(blended) ? blended : ranked.finalScore
+      };
+    }
+    return ranked;
+  });
+  for (const [url, pageHit] of pageScoreMap) {
+    if (pagesWithChunks.has(url)) continue;
+    const syntheticScore = pageHit.score * w;
+    const syntheticHit = {
+      id: `page:${url}`,
+      score: pageHit.score,
+      metadata: {
+        projectId: "",
+        scopeName: "",
+        url: pageHit.url,
+        path: pageHit.url,
+        title: pageHit.title,
+        sectionTitle: "",
+        headingPath: [],
+        snippet: pageHit.description || pageHit.title,
+        chunkText: pageHit.description || pageHit.title,
+        ordinal: 0,
+        contentHash: "",
+        depth: pageHit.depth,
+        incomingLinks: pageHit.incomingLinks,
+        routeFile: pageHit.routeFile,
+        tags: pageHit.tags
+      }
+    };
+    merged.push({
+      hit: syntheticHit,
+      finalScore: Number.isFinite(syntheticScore) ? syntheticScore : 0
+    });
+  }
+  return merged.sort((a, b) => {
+    const delta = b.finalScore - a.finalScore;
+    return Number.isNaN(delta) ? 0 : delta;
+  });
+}
 
 // src/utils/time.ts
 function nowIso() {
@@ -2672,34 +2349,41 @@ function hrTimeMs(start) {
 }
 
 // src/indexing/pipeline.ts
-var EMBEDDING_PRICE_PER_1K_TOKENS_USD = {
-  "jina-embeddings-v3": 2e-5,
-  "jina-embeddings-v5-text-small": 5e-5
-};
-var DEFAULT_EMBEDDING_PRICE_PER_1K = 5e-5;
+function buildPageSummary(page, maxChars = 3500) {
+  const parts = [page.title];
+  if (page.description) {
+    parts.push(page.description);
+  }
+  if (page.keywords && page.keywords.length > 0) {
+    parts.push(page.keywords.join(", "));
+  }
+  const plainBody = page.markdown.replace(/```[\s\S]*?```/g, " ").replace(/`([^`]+)`/g, "$1").replace(/!?\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/^#{1,6}\s+/gm, "").replace(/[>*_|~\-]/g, " ").replace(/\s+/g, " ").trim();
+  if (plainBody) {
+    parts.push(plainBody);
+  }
+  const joined = parts.join("\n\n");
+  if (joined.length <= maxChars) return joined;
+  return joined.slice(0, maxChars).trim();
+}
 var IndexPipeline = class _IndexPipeline {
   cwd;
   config;
-  embeddings;
-  vectorStore;
+  store;
   logger;
   constructor(options) {
     this.cwd = options.cwd;
     this.config = options.config;
-    this.embeddings = options.embeddings;
-    this.vectorStore = options.vectorStore;
+    this.store = options.store;
     this.logger = options.logger;
   }
   static async create(options = {}) {
-    const cwd = path12.resolve(options.cwd ?? process.cwd());
+    const cwd = path10.resolve(options.cwd ?? process.cwd());
     const config = options.config ?? await loadConfig({ cwd, configPath: options.configPath });
-    const embeddings = options.embeddingsProvider ?? createEmbeddingsProvider(config);
-    const vectorStore = options.vectorStore ?? await createVectorStore(config, cwd);
+    const store = options.store ?? await createUpstashStore(config);
     return new _IndexPipeline({
       cwd,
       config,
-      embeddings,
-      vectorStore,
+      store,
       logger: options.logger ?? new Logger()
     });
   }
@@ -2719,25 +2403,17 @@ var IndexPipeline = class _IndexPipeline {
       stageTimingsMs[name] = Math.round(hrTimeMs(start));
     };
     const scope = resolveScope(this.config, options.scopeOverride);
-    const { statePath } = ensureStateDirs(this.cwd, this.config.state.dir, scope);
+    ensureStateDirs(this.cwd, this.config.state.dir, scope);
     const sourceMode = options.sourceOverride ?? this.config.source.mode;
-    this.logger.info(`Indexing scope "${scope.scopeName}" (source: ${sourceMode}, model: ${this.config.embeddings.model})`);
+    this.logger.info(`Indexing scope "${scope.scopeName}" (source: ${sourceMode}, backend: upstash-search)`);
     if (options.force) {
       this.logger.info("Force mode enabled \u2014 full rebuild");
-      await cleanMirrorForScope(statePath, scope);
     }
     if (options.dryRun) {
       this.logger.info("Dry run \u2014 no writes will be performed");
     }
     const manifestStart = stageStart();
-    const existingHashes = await this.vectorStore.getContentHashes(scope);
-    const existingModelId = await this.vectorStore.getScopeModelId(scope);
-    if (existingModelId && existingModelId !== this.config.embeddings.model && !options.force) {
-      throw new SearchSocketError(
-        "EMBEDDING_MODEL_MISMATCH",
-        `Scope ${scope.scopeName} uses model ${existingModelId}. Re-run with --force to migrate.`
-      );
-    }
+    const existingHashes = options.force ? /* @__PURE__ */ new Map() : await this.store.getContentHashes(scope);
     stageEnd("manifest", manifestStart);
     this.logger.debug(`Manifest: ${existingHashes.size} existing chunk hashes loaded`);
     const sourceStart = stageStart();
@@ -2775,11 +2451,11 @@ var IndexPipeline = class _IndexPipeline {
       let robotsRules = null;
       if (sourceMode === "static-output") {
         robotsRules = await loadRobotsTxtFromDir(
-          path12.resolve(this.cwd, this.config.source.staticOutputDir)
+          path10.resolve(this.cwd, this.config.source.staticOutputDir)
         );
       } else if (sourceMode === "build" && this.config.source.build) {
         robotsRules = await loadRobotsTxtFromDir(
-          path12.resolve(this.cwd, this.config.source.build.outputDir)
+          path10.resolve(this.cwd, this.config.source.build.outputDir)
         );
       } else if (sourceMode === "crawl" && this.config.source.crawl) {
         robotsRules = await fetchRobotsTxt(this.config.source.crawl.baseUrl);
@@ -2866,9 +2542,9 @@ var IndexPipeline = class _IndexPipeline {
     }
     stageEnd("links", linkStart);
     this.logger.debug(`Link analysis: computed incoming links for ${incomingLinkCount.size} pages (${stageTimingsMs["links"]}ms)`);
-    const mirrorStart = stageStart();
-    this.logger.info("Writing mirror pages...");
-    const mirrorPages = [];
+    const pagesStart = stageStart();
+    this.logger.info("Building indexed pages...");
+    const pages = [];
     let routeExact = 0;
     let routeBestEffort = 0;
     const precomputedRoutes = /* @__PURE__ */ new Map();
@@ -2897,7 +2573,7 @@ var IndexPipeline = class _IndexPipeline {
       } else {
         routeExact += 1;
       }
-      const mirror = {
+      const indexedPage = {
         url: page.url,
         title: page.title,
         scope: scope.scopeName,
@@ -2912,35 +2588,38 @@ var IndexPipeline = class _IndexPipeline {
         description: page.description,
         keywords: page.keywords
       };
-      mirrorPages.push(mirror);
-      if (this.config.state.writeMirror) {
-        await writeMirrorPage(statePath, scope, mirror);
-      }
-      this.logger.event("markdown_written", { url: page.url });
+      pages.push(indexedPage);
+      this.logger.event("page_indexed", { url: page.url });
     }
     if (!options.dryRun) {
-      const pageRecords = mirrorPages.map((mp) => ({
-        url: mp.url,
-        title: mp.title,
-        markdown: mp.markdown,
-        projectId: scope.projectId,
-        scopeName: scope.scopeName,
-        routeFile: mp.routeFile,
-        routeResolution: mp.routeResolution,
-        incomingLinks: mp.incomingLinks,
-        outgoingLinks: mp.outgoingLinks,
-        depth: mp.depth,
-        tags: mp.tags,
-        indexedAt: mp.generatedAt
-      }));
-      await this.vectorStore.deletePages(scope);
-      await this.vectorStore.upsertPages(pageRecords, scope);
+      const pageRecords = pages.map((p) => {
+        const summary = buildPageSummary(p);
+        return {
+          url: p.url,
+          title: p.title,
+          markdown: p.markdown,
+          projectId: scope.projectId,
+          scopeName: scope.scopeName,
+          routeFile: p.routeFile,
+          routeResolution: p.routeResolution,
+          incomingLinks: p.incomingLinks,
+          outgoingLinks: p.outgoingLinks,
+          depth: p.depth,
+          tags: p.tags,
+          indexedAt: p.generatedAt,
+          summary,
+          description: p.description,
+          keywords: p.keywords
+        };
+      });
+      await this.store.deletePages(scope);
+      await this.store.upsertPages(pageRecords, scope);
     }
-    stageEnd("mirror", mirrorStart);
-    this.logger.info(`Mirrored ${mirrorPages.length} page${mirrorPages.length === 1 ? "" : "s"} (${routeExact} exact, ${routeBestEffort} best-effort) (${stageTimingsMs["mirror"]}ms)`);
+    stageEnd("pages", pagesStart);
+    this.logger.info(`Indexed ${pages.length} page${pages.length === 1 ? "" : "s"} (${routeExact} exact, ${routeBestEffort} best-effort) (${stageTimingsMs["pages"]}ms)`);
     const chunkStart = stageStart();
     this.logger.info("Chunking pages...");
-    let chunks = mirrorPages.flatMap((page) => chunkMirrorPage(page, this.config, scope));
+    let chunks = pages.flatMap((page) => chunkPage(page, this.config, scope));
     const maxChunks = typeof options.maxChunks === "number" ? Math.max(0, Math.floor(options.maxChunks)) : void 0;
     if (typeof maxChunks === "number") {
       chunks = chunks.slice(0, maxChunks);
@@ -2972,125 +2651,61 @@ var IndexPipeline = class _IndexPipeline {
     });
     const deletes = [...existingHashes.keys()].filter((chunkKey) => !currentChunkMap.has(chunkKey));
     this.logger.info(`Changes detected: ${changedChunks.length} changed, ${deletes.length} deleted, ${chunks.length - changedChunks.length} unchanged`);
-    const embedStart = stageStart();
-    const chunkTokenEstimates = /* @__PURE__ */ new Map();
-    for (const chunk of changedChunks) {
-      chunkTokenEstimates.set(chunk.chunkKey, this.embeddings.estimateTokens(buildEmbeddingText(chunk, this.config.chunking.prependTitle)));
-    }
-    const estimatedTokens = changedChunks.reduce(
-      (sum, chunk) => sum + (chunkTokenEstimates.get(chunk.chunkKey) ?? 0),
-      0
-    );
-    const pricePer1k = this.config.embeddings.pricePer1kTokens ?? EMBEDDING_PRICE_PER_1K_TOKENS_USD[this.config.embeddings.model] ?? DEFAULT_EMBEDDING_PRICE_PER_1K;
-    const estimatedCostUSD = estimatedTokens / 1e3 * pricePer1k;
-    let newEmbeddings = 0;
-    const vectorsByChunk = /* @__PURE__ */ new Map();
+    const upsertStart = stageStart();
+    let documentsUpserted = 0;
     if (!options.dryRun && changedChunks.length > 0) {
-      this.logger.info(`Embedding ${changedChunks.length} chunk${changedChunks.length === 1 ? "" : "s"} (~${estimatedTokens.toLocaleString()} tokens, ~$${estimatedCostUSD.toFixed(6)})...`);
-      const embeddings = await this.embeddings.embedTexts(
-        changedChunks.map((chunk) => buildEmbeddingText(chunk, this.config.chunking.prependTitle)),
-        this.config.embeddings.model,
-        "retrieval.passage"
-      );
-      if (embeddings.length !== changedChunks.length) {
-        throw new SearchSocketError(
-          "VECTOR_BACKEND_UNAVAILABLE",
-          `Embedding provider returned ${embeddings.length} vectors for ${changedChunks.length} chunks.`
-        );
-      }
-      for (let i = 0; i < changedChunks.length; i += 1) {
-        const chunk = changedChunks[i];
-        const embedding = embeddings[i];
-        if (!chunk || !embedding || embedding.length === 0 || embedding.some((value) => !Number.isFinite(value))) {
-          throw new SearchSocketError(
-            "VECTOR_BACKEND_UNAVAILABLE",
-            `Embedding provider returned an invalid vector for chunk index ${i}.`
-          );
-        }
-        vectorsByChunk.set(chunk.chunkKey, embedding);
-        newEmbeddings += 1;
-        this.logger.event("embedded_new", { chunkKey: chunk.chunkKey });
-      }
-    }
-    stageEnd("embedding", embedStart);
-    if (changedChunks.length > 0) {
-      this.logger.info(`Embedded ${newEmbeddings} chunk${newEmbeddings === 1 ? "" : "s"} (${stageTimingsMs["embedding"]}ms)`);
-    } else {
-      this.logger.info("No chunks to embed \u2014 all up to date");
-    }
-    const syncStart = stageStart();
-    if (!options.dryRun) {
-      this.logger.info("Syncing vectors...");
-      const upserts = [];
-      for (const chunk of changedChunks) {
-        const vector = vectorsByChunk.get(chunk.chunkKey);
-        if (!vector) {
-          continue;
-        }
-        upserts.push({
+      this.logger.info(`Upserting ${changedChunks.length} chunk${changedChunks.length === 1 ? "" : "s"} to Upstash Search...`);
+      const UPSTASH_CONTENT_LIMIT = 4096;
+      const FIELD_OVERHEAD = 200;
+      const MAX_TEXT_CHARS = UPSTASH_CONTENT_LIMIT - FIELD_OVERHEAD;
+      const docs = changedChunks.map((chunk) => {
+        const title = chunk.title;
+        const sectionTitle = chunk.sectionTitle ?? "";
+        const url = chunk.url;
+        const tags = chunk.tags.join(",");
+        const headingPath = chunk.headingPath.join(" > ");
+        const otherFieldsLen = title.length + sectionTitle.length + url.length + tags.length + headingPath.length;
+        const textBudget = Math.max(500, UPSTASH_CONTENT_LIMIT - otherFieldsLen - 50);
+        const text = buildEmbeddingText(chunk, this.config.chunking.prependTitle).slice(0, textBudget);
+        return {
           id: chunk.chunkKey,
-          vector,
+          content: { title, sectionTitle, text, url, tags, headingPath },
           metadata: {
             projectId: scope.projectId,
             scopeName: scope.scopeName,
-            url: chunk.url,
             path: chunk.path,
-            title: chunk.title,
-            sectionTitle: chunk.sectionTitle ?? "",
-            headingPath: chunk.headingPath,
             snippet: chunk.snippet,
-            chunkText: chunk.chunkText.slice(0, 4e3),
             ordinal: chunk.ordinal,
             contentHash: chunk.contentHash,
-            modelId: this.config.embeddings.model,
             depth: chunk.depth,
             incomingLinks: chunk.incomingLinks,
             routeFile: chunk.routeFile,
-            tags: chunk.tags,
-            description: chunk.description,
-            keywords: chunk.keywords
+            description: chunk.description ?? "",
+            keywords: (chunk.keywords ?? []).join(",")
           }
-        });
-      }
-      if (upserts.length > 0) {
-        await this.vectorStore.upsert(upserts, scope);
-        this.logger.event("upserted", { count: upserts.length });
-      }
-      if (deletes.length > 0) {
-        await this.vectorStore.deleteByIds(deletes, scope);
-        this.logger.event("deleted", { count: deletes.length });
-      }
-    }
-    stageEnd("sync", syncStart);
-    this.logger.debug(`Sync complete (${stageTimingsMs["sync"]}ms)`);
-    const finalizeStart = stageStart();
-    if (!options.dryRun) {
-      const scopeInfo = {
-        projectId: scope.projectId,
-        scopeName: scope.scopeName,
-        modelId: this.config.embeddings.model,
-        lastIndexedAt: nowIso(),
-        vectorCount: chunks.length,
-        lastEstimateTokens: estimatedTokens,
-        lastEstimateCostUSD: Number(estimatedCostUSD.toFixed(8)),
-        lastEstimateChangedChunks: changedChunks.length
-      };
-      await this.vectorStore.recordScope(scopeInfo);
-      this.logger.event("registry_updated", {
-        scope: scope.scopeName,
-        vectorCount: chunks.length
+        };
       });
+      await this.store.upsertChunks(docs, scope);
+      documentsUpserted = docs.length;
+      this.logger.event("upserted", { count: docs.length });
+    }
+    if (!options.dryRun && deletes.length > 0) {
+      await this.store.deleteByIds(deletes, scope);
+      this.logger.event("deleted", { count: deletes.length });
+    }
+    stageEnd("upsert", upsertStart);
+    if (changedChunks.length > 0) {
+      this.logger.info(`Upserted ${documentsUpserted} document${documentsUpserted === 1 ? "" : "s"} (${stageTimingsMs["upsert"]}ms)`);
+    } else {
+      this.logger.info("No chunks to upsert \u2014 all up to date");
     }
-    stageEnd("finalize", finalizeStart);
     this.logger.info("Done.");
     return {
-      pagesProcessed: mirrorPages.length,
+      pagesProcessed: pages.length,
       chunksTotal: chunks.length,
       chunksChanged: changedChunks.length,
-      newEmbeddings,
+      documentsUpserted,
       deletes: deletes.length,
-      estimatedTokens,
-      estimatedCostUSD: Number(estimatedCostUSD.toFixed(8)),
       routeExact,
       routeBestEffort,
       stageTimingsMs
@@ -3106,142 +2721,33 @@ import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js
 import { z as z3 } from "zod";
 
 // src/search/engine.ts
-import path13 from "path";
+import path11 from "path";
 import { z as z2 } from "zod";
-
-// src/rerank/jina.ts
-function sleep2(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-var JinaReranker = class {
-  apiKey;
-  model;
-  maxRetries;
-  constructor(options) {
-    this.apiKey = options.apiKey;
-    this.model = options.model;
-    this.maxRetries = options.maxRetries ?? 2;
-  }
-  async rerank(query, candidates, topN) {
-    if (candidates.length === 0) {
-      return [];
-    }
-    const body = {
-      model: this.model,
-      query,
-      documents: candidates.map((candidate) => candidate.text),
-      top_n: topN ?? candidates.length,
-      return_documents: false
-    };
-    let attempt = 0;
-    while (attempt <= this.maxRetries) {
-      attempt += 1;
-      let response;
-      try {
-        response = await fetch("https://api.jina.ai/v1/rerank", {
-          method: "POST",
-          headers: {
-            "content-type": "application/json",
-            authorization: `Bearer ${this.apiKey}`
-          },
-          body: JSON.stringify(body)
-        });
-      } catch (error) {
-        if (attempt <= this.maxRetries) {
-          await sleep2(Math.min(300 * 2 ** attempt, 4e3));
-          continue;
-        }
-        throw error;
-      }
-      if (!response.ok) {
-        const retryable = response.status === 429 || response.status >= 500;
-        if (retryable && attempt <= this.maxRetries) {
-          await sleep2(Math.min(300 * 2 ** attempt, 4e3));
-          continue;
-        }
-        const errorBody = await response.text();
-        throw new Error(`Jina rerank failed (${response.status}): ${errorBody}`);
-      }
-      const payload = await response.json();
-      const rawResults = payload.results ?? payload.data ?? [];
-      if (!Array.isArray(rawResults)) {
-        throw new Error("Invalid Jina rerank response format");
-      }
-      return rawResults.flatMap((item) => {
-        const index = item.index;
-        if (typeof index !== "number" || index < 0 || index >= candidates.length) {
-          return [];
-        }
-        const candidate = candidates[index];
-        if (!candidate) {
-          return [];
-        }
-        const score = typeof item.relevance_score === "number" ? item.relevance_score : item.score ?? 0;
-        return [
-          {
-            id: candidate.id,
-            score
-          }
-        ];
-      }).sort((a, b) => b.score - a.score);
-    }
-    throw new Error("Jina rerank request failed after retries");
-  }
-};
-
-// src/rerank/factory.ts
-function createReranker(config) {
-  if (!config.rerank.enabled) {
-    return null;
-  }
-  const apiKey = config.embeddings.apiKey ?? process.env[config.embeddings.apiKeyEnv];
-  if (!apiKey) {
-    return null;
-  }
-  return new JinaReranker({
-    apiKey,
-    model: config.rerank.model
-  });
-}
-
-// src/search/engine.ts
 var requestSchema = z2.object({
   q: z2.string().trim().min(1),
   topK: z2.number().int().positive().max(100).optional(),
   scope: z2.string().optional(),
   pathPrefix: z2.string().optional(),
   tags: z2.array(z2.string()).optional(),
-  rerank: z2.boolean().optional(),
-  groupBy: z2.enum(["page", "chunk"]).optional(),
-  stream: z2.boolean().optional()
+  groupBy: z2.enum(["page", "chunk"]).optional()
 });
 var SearchEngine = class _SearchEngine {
   cwd;
   config;
-  embeddings;
-  vectorStore;
-  reranker;
+  store;
   constructor(options) {
     this.cwd = options.cwd;
     this.config = options.config;
-    this.embeddings = options.embeddings;
-    this.vectorStore = options.vectorStore;
-    this.reranker = options.reranker;
+    this.store = options.store;
   }
   static async create(options = {}) {
-    const cwd = path13.resolve(options.cwd ?? process.cwd());
+    const cwd = path11.resolve(options.cwd ?? process.cwd());
     const config = options.config ?? await loadConfig({ cwd, configPath: options.configPath });
-    const embeddings = options.embeddingsProvider ?? createEmbeddingsProvider(config);
-    const vectorStore = options.vectorStore ?? await createVectorStore(config, cwd);
-    const reranker = options.reranker === void 0 ? createReranker(config) : options.reranker;
+    const store = options.store ?? await createUpstashStore(config);
     return new _SearchEngine({
       cwd,
       config,
-      embeddings,
-      vectorStore,
-      reranker
+      store
     });
   }
   getConfig() {
@@ -3255,142 +2761,90 @@ var SearchEngine = class _SearchEngine {
     const input = parsed.data;
     const totalStart = process.hrtime.bigint();
     const resolvedScope = resolveScope(this.config, input.scope);
-    await this.assertModelCompatibility(resolvedScope);
     const topK = input.topK ?? 10;
-    const wantsRerank = Boolean(input.rerank);
     const groupByPage = (input.groupBy ?? "page") === "page";
     const candidateK = groupByPage ? Math.max(topK * 10, 50) : Math.max(50, topK);
-    const embedStart = process.hrtime.bigint();
-    const queryEmbeddings = await this.embeddings.embedTexts([input.q], this.config.embeddings.model, "retrieval.query");
-    const queryVector = queryEmbeddings[0];
-    if (!queryVector || queryVector.length === 0 || queryVector.some((value) => !Number.isFinite(value))) {
-      throw new SearchSocketError("VECTOR_BACKEND_UNAVAILABLE", "Unable to create query embedding.");
-    }
-    const embedMs = hrTimeMs(embedStart);
-    const vectorStart = process.hrtime.bigint();
-    const hits = await this.vectorStore.query(
-      queryVector,
-      {
-        topK: candidateK,
-        pathPrefix: input.pathPrefix,
-        tags: input.tags
-      },
-      resolvedScope
-    );
-    const vectorMs = hrTimeMs(vectorStart);
-    const ranked = rankHits(hits, this.config);
-    let usedRerank = false;
-    let rerankMs = 0;
-    let ordered = ranked;
-    if (wantsRerank) {
-      const rerankStart = process.hrtime.bigint();
-      ordered = await this.rerankHits(input.q, ranked, topK);
-      rerankMs = hrTimeMs(rerankStart);
-      usedRerank = true;
-    }
-    const results = this.buildResults(ordered, topK, groupByPage);
+    const filterParts = [];
+    if (input.pathPrefix) {
+      const prefix = input.pathPrefix.startsWith("/") ? input.pathPrefix : `/${input.pathPrefix}`;
+      filterParts.push(`url GLOB '${prefix}*'`);
+    }
+    if (input.tags && input.tags.length > 0) {
+      for (const tag of input.tags) {
+        filterParts.push(`tags GLOB '*${tag}*'`);
+      }
+    }
+    const filter = filterParts.length > 0 ? filterParts.join(" AND ") : void 0;
+    const useDualSearch = this.config.search.dualSearch && groupByPage;
+    const searchStart = process.hrtime.bigint();
+    let ranked;
+    if (useDualSearch) {
+      const chunkLimit = Math.max(topK * 10, 100);
+      const pageLimit = 20;
+      const [pageHits, chunkHits] = await Promise.all([
+        this.store.searchPages(
+          input.q,
+          {
+            limit: pageLimit,
+            semanticWeight: this.config.search.semanticWeight,
+            inputEnrichment: this.config.search.inputEnrichment,
+            filter
+          },
+          resolvedScope
+        ),
+        this.store.search(
+          input.q,
+          {
+            limit: chunkLimit,
+            semanticWeight: this.config.search.semanticWeight,
+            inputEnrichment: this.config.search.inputEnrichment,
+            reranking: false,
+            filter
+          },
+          resolvedScope
+        )
+      ]);
+      const rankedChunks = rankHits(chunkHits, this.config, input.q);
+      ranked = mergePageAndChunkResults(pageHits, rankedChunks, this.config);
+    } else {
+      const hits = await this.store.search(
+        input.q,
+        {
+          limit: candidateK,
+          semanticWeight: this.config.search.semanticWeight,
+          inputEnrichment: this.config.search.inputEnrichment,
+          reranking: this.config.search.reranking,
+          filter
+        },
+        resolvedScope
+      );
+      ranked = rankHits(hits, this.config, input.q);
+    }
+    const searchMs = hrTimeMs(searchStart);
+    const results = this.buildResults(ranked, topK, groupByPage, input.q);
     return {
       q: input.q,
       scope: resolvedScope.scopeName,
       results,
       meta: {
         timingsMs: {
-          embed: Math.round(embedMs),
-          vector: Math.round(vectorMs),
-          rerank: Math.round(rerankMs),
+          search: Math.round(searchMs),
           total: Math.round(hrTimeMs(totalStart))
-        },
-        usedRerank,
-        modelId: this.config.embeddings.model
-      }
-    };
-  }
-  async *searchStreaming(request) {
-    const parsed = requestSchema.safeParse(request);
-    if (!parsed.success) {
-      throw new SearchSocketError("INVALID_REQUEST", parsed.error.issues[0]?.message ?? "Invalid request", 400);
-    }
-    const input = parsed.data;
-    const wantsRerank = Boolean(input.rerank);
-    if (!wantsRerank) {
-      const response = await this.search(request);
-      yield { phase: "initial", data: response };
-      return;
-    }
-    const totalStart = process.hrtime.bigint();
-    const resolvedScope = resolveScope(this.config, input.scope);
-    await this.assertModelCompatibility(resolvedScope);
-    const topK = input.topK ?? 10;
-    const groupByPage = (input.groupBy ?? "page") === "page";
-    const candidateK = groupByPage ? Math.max(topK * 10, 50) : Math.max(50, topK);
-    const embedStart = process.hrtime.bigint();
-    const queryEmbeddings = await this.embeddings.embedTexts([input.q], this.config.embeddings.model, "retrieval.query");
-    const queryVector = queryEmbeddings[0];
-    if (!queryVector || queryVector.length === 0 || queryVector.some((value) => !Number.isFinite(value))) {
-      throw new SearchSocketError("VECTOR_BACKEND_UNAVAILABLE", "Unable to create query embedding.");
-    }
-    const embedMs = hrTimeMs(embedStart);
-    const vectorStart = process.hrtime.bigint();
-    const hits = await this.vectorStore.query(
-      queryVector,
-      {
-        topK: candidateK,
-        pathPrefix: input.pathPrefix,
-        tags: input.tags
-      },
-      resolvedScope
-    );
-    const vectorMs = hrTimeMs(vectorStart);
-    const ranked = rankHits(hits, this.config);
-    const initialResults = this.buildResults(ranked, topK, groupByPage);
-    yield {
-      phase: "initial",
-      data: {
-        q: input.q,
-        scope: resolvedScope.scopeName,
-        results: initialResults,
-        meta: {
-          timingsMs: {
-            embed: Math.round(embedMs),
-            vector: Math.round(vectorMs),
-            rerank: 0,
-            total: Math.round(hrTimeMs(totalStart))
-          },
-          usedRerank: false,
-          modelId: this.config.embeddings.model
-        }
-      }
-    };
-    const rerankStart = process.hrtime.bigint();
-    const reranked = await this.rerankHits(input.q, ranked, topK);
-    const rerankMs = hrTimeMs(rerankStart);
-    const rerankedResults = this.buildResults(reranked, topK, groupByPage);
-    yield {
-      phase: "reranked",
-      data: {
-        q: input.q,
-        scope: resolvedScope.scopeName,
-        results: rerankedResults,
-        meta: {
-          timingsMs: {
-            embed: Math.round(embedMs),
-            vector: Math.round(vectorMs),
-            rerank: Math.round(rerankMs),
-            total: Math.round(hrTimeMs(totalStart))
-          },
-          usedRerank: true,
-          modelId: this.config.embeddings.model
         }
       }
     };
   }
-  buildResults(ordered, topK, groupByPage) {
-    const minScore = this.config.ranking.minScore;
+  ensureSnippet(hit) {
+    const snippet = hit.hit.metadata.snippet;
+    if (snippet && snippet.length >= 30) return snippet;
+    const chunkText = hit.hit.metadata.chunkText;
+    if (chunkText) return toSnippet(chunkText);
+    return snippet || "";
+  }
+  buildResults(ordered, topK, groupByPage, _query) {
     if (groupByPage) {
       let pages = aggregateByPage(ordered, this.config);
-      if (minScore > 0) {
-        pages = pages.filter((p) => p.pageScore >= minScore);
-      }
+      pages = trimByScoreGap(pages, this.config);
       const minRatio = this.config.ranking.minChunkScoreRatio;
       return pages.slice(0, topK).map((page) => {
         const bestScore = page.bestChunk.finalScore;
@@ -3400,12 +2854,12 @@ var SearchEngine = class _SearchEngine {
           url: page.url,
           title: page.title,
           sectionTitle: page.bestChunk.hit.metadata.sectionTitle || void 0,
-          snippet: page.bestChunk.hit.metadata.snippet,
+          snippet: this.ensureSnippet(page.bestChunk),
           score: Number(page.pageScore.toFixed(6)),
           routeFile: page.routeFile,
           chunks: meaningful.length > 1 ? meaningful.map((c) => ({
             sectionTitle: c.hit.metadata.sectionTitle || void 0,
-            snippet: c.hit.metadata.snippet,
+            snippet: this.ensureSnippet(c),
             headingPath: c.hit.metadata.headingPath,
             score: Number(c.finalScore.toFixed(6))
           })) : void 0
@@ -3413,6 +2867,7 @@ var SearchEngine = class _SearchEngine {
       });
     } else {
       let filtered = ordered;
+      const minScore = this.config.ranking.minScore;
       if (minScore > 0) {
         filtered = ordered.filter((entry) => entry.finalScore >= minScore);
       }
@@ -3420,7 +2875,7 @@ var SearchEngine = class _SearchEngine {
         url: hit.metadata.url,
         title: hit.metadata.title,
         sectionTitle: hit.metadata.sectionTitle || void 0,
-        snippet: hit.metadata.snippet,
+        snippet: this.ensureSnippet({ hit, finalScore }),
         score: Number(finalScore.toFixed(6)),
         routeFile: hit.metadata.routeFile
       }));
@@ -3429,7 +2884,7 @@ var SearchEngine = class _SearchEngine {
   async getPage(pathOrUrl, scope) {
     const resolvedScope = resolveScope(this.config, scope);
     const urlPath = this.resolveInputPath(pathOrUrl);
-    const page = await this.vectorStore.getPage(urlPath, resolvedScope);
+    const page = await this.store.getPage(urlPath, resolvedScope);
     if (!page) {
       throw new SearchSocketError("INVALID_REQUEST", `Indexed page not found for ${urlPath}`, 404);
     }
@@ -3450,7 +2905,7 @@ var SearchEngine = class _SearchEngine {
     };
   }
   async health() {
-    return this.vectorStore.health();
+    return this.store.health();
   }
   resolveInputPath(pathOrUrl) {
     try {
@@ -3462,94 +2917,10 @@ var SearchEngine = class _SearchEngine {
     const withoutQueryOrHash = pathOrUrl.split(/[?#]/)[0] ?? pathOrUrl;
     return normalizeUrlPath(withoutQueryOrHash);
   }
-  async assertModelCompatibility(scope) {
-    const modelId = await this.vectorStore.getScopeModelId(scope);
-    if (modelId && modelId !== this.config.embeddings.model) {
-      throw new SearchSocketError(
-        "EMBEDDING_MODEL_MISMATCH",
-        `Scope ${scope.scopeName} was indexed with ${modelId}. Current config uses ${this.config.embeddings.model}. Re-index with --force.`
-      );
-    }
-  }
-  async rerankHits(query, ranked, topK) {
-    if (!this.config.rerank.enabled) {
-      throw new SearchSocketError(
-        "INVALID_REQUEST",
-        "rerank=true requested but rerank.enabled is not set to true.",
-        400
-      );
-    }
-    if (!this.reranker) {
-      throw new SearchSocketError(
-        "CONFIG_MISSING",
-        `rerank=true requested but ${this.config.embeddings.apiKeyEnv} is not set.`,
-        400
-      );
-    }
-    const pageGroups = /* @__PURE__ */ new Map();
-    for (const entry of ranked) {
-      const url = entry.hit.metadata.url;
-      const group = pageGroups.get(url);
-      if (group) group.push(entry);
-      else pageGroups.set(url, [entry]);
-    }
-    const MAX_CHUNKS_PER_PAGE = 5;
-    const MIN_CHUNKS_PER_PAGE = 1;
-    const MIN_CHUNK_SCORE_RATIO = 0.5;
-    const MAX_DOC_CHARS = 2e3;
-    const pageCandidates = [];
-    for (const [url, chunks] of pageGroups) {
-      const byScore = [...chunks].sort((a, b) => b.finalScore - a.finalScore);
-      const bestScore = byScore[0].finalScore;
-      const scoreFloor = Number.isFinite(bestScore) ? bestScore * MIN_CHUNK_SCORE_RATIO : Number.NEGATIVE_INFINITY;
-      const selected = byScore.filter(
-        (c, i) => i < MIN_CHUNKS_PER_PAGE || c.finalScore >= scoreFloor
-      ).slice(0, MAX_CHUNKS_PER_PAGE);
-      selected.sort((a, b) => (a.hit.metadata.ordinal ?? 0) - (b.hit.metadata.ordinal ?? 0));
-      const first = selected[0].hit.metadata;
-      const parts = [first.title];
-      if (first.description) {
-        parts.push(first.description);
-      }
-      if (first.keywords && first.keywords.length > 0) {
-        parts.push(first.keywords.join(", "));
-      }
-      const body = selected.map((c) => c.hit.metadata.chunkText || c.hit.metadata.snippet).join("\n\n");
-      parts.push(body);
-      let text = parts.join("\n\n");
-      if (text.length > MAX_DOC_CHARS) {
-        text = text.slice(0, MAX_DOC_CHARS);
-      }
-      pageCandidates.push({ id: url, text });
-    }
-    const maxCandidates = Math.max(topK, this.config.rerank.topN);
-    const cappedCandidates = pageCandidates.slice(0, maxCandidates);
-    const reranked = await this.reranker.rerank(
-      query,
-      cappedCandidates,
-      maxCandidates
-    );
-    const scoreByUrl = new Map(reranked.map((e) => [e.id, e.score]));
-    return ranked.map((entry) => {
-      const pageScore = scoreByUrl.get(entry.hit.metadata.url);
-      const base = Number.isFinite(entry.finalScore) ? entry.finalScore : Number.NEGATIVE_INFINITY;
-      if (pageScore === void 0 || !Number.isFinite(pageScore)) {
-        return { ...entry, finalScore: base };
-      }
-      const combined = pageScore * this.config.ranking.weights.rerank + base * 1e-3;
-      return {
-        ...entry,
-        finalScore: Number.isFinite(combined) ? combined : base
-      };
-    }).sort((a, b) => {
-      const delta = b.finalScore - a.finalScore;
-      return Number.isNaN(delta) ? 0 : delta;
-    });
-  }
 };
 
 // src/mcp/server.ts
-function createServer(engine, config) {
+function createServer(engine) {
   const server = new McpServer({
     name: "searchsocket-mcp",
     version: "0.1.0"
@@ -3557,15 +2928,14 @@ function createServer(engine, config) {
   server.registerTool(
     "search",
     {
-      description: "Semantic site search. Returns url/title/snippet/score/routeFile for each match. Supports optional scope, pathPrefix, tags, topK, and rerank. Enable rerank for better relevance on natural-language queries.",
+      description: "Semantic site search powered by Upstash Search. Returns url/title/snippet/score/routeFile for each match. Supports optional scope, pathPrefix, tags, topK, and groupBy.",
       inputSchema: {
         query: z3.string().min(1),
         scope: z3.string().optional(),
         topK: z3.number().int().positive().max(100).optional(),
         pathPrefix: z3.string().optional(),
         tags: z3.array(z3.string()).optional(),
-        groupBy: z3.enum(["page", "chunk"]).optional(),
-        rerank: z3.boolean().optional().describe("Enable reranking for better relevance (uses Jina Reranker). Defaults to true when rerank is enabled in config.")
+        groupBy: z3.enum(["page", "chunk"]).optional()
       }
     },
     async (input) => {
@@ -3575,8 +2945,7 @@ function createServer(engine, config) {
         scope: input.scope,
         pathPrefix: input.pathPrefix,
         tags: input.tags,
-        groupBy: input.groupBy,
-        rerank: input.rerank ?? config.rerank.enabled
+        groupBy: input.groupBy
       });
       return {
         content: [
@@ -3704,10 +3073,10 @@ async function runMcpServer(options = {}) {
     config
   });
   if (resolvedTransport === "http") {
-    await startHttpServer(() => createServer(engine, config), config, options);
+    await startHttpServer(() => createServer(engine), config, options);
     return;
   }
-  const server = createServer(engine, config);
+  const server = createServer(engine);
   const stdioTransport = new StdioServerTransport();
   await server.connect(stdioTransport);
 }
@@ -3746,9 +3115,6 @@ function parseDurationMs(value) {
       throw new SearchSocketError("INVALID_REQUEST", `Unsupported duration unit: ${unit}`, 400);
   }
 }
-function formatUsd(value) {
-  return `$${value.toFixed(6)}`;
-}
 function printIndexSummary(stats) {
   process.stdout.write(`pages processed: ${stats.pagesProcessed}
 `);
@@ -3756,13 +3122,9 @@ function printIndexSummary(stats) {
 `);
   process.stdout.write(`chunks changed: ${stats.chunksChanged}
 `);
-  process.stdout.write(`embeddings created: ${stats.newEmbeddings}
+  process.stdout.write(`documents upserted: ${stats.documentsUpserted}
 `);
   process.stdout.write(`deletes: ${stats.deletes}
-`);
-  process.stdout.write(`estimated tokens: ${stats.estimatedTokens}
-`);
-  process.stdout.write(`estimated cost (USD): ${formatUsd(stats.estimatedCostUSD)}
 `);
   process.stdout.write(`route mapping: ${stats.routeExact} exact, ${stats.routeBestEffort} best-effort
 `);
@@ -3776,7 +3138,7 @@ function collectWatchPaths(config, cwd) {
   const paths = ["src/routes/**"];
   if (config.source.mode === "content-files" && config.source.contentFiles) {
     for (const pattern of config.source.contentFiles.globs) {
-      paths.push(path14.join(config.source.contentFiles.baseDir, pattern));
+      paths.push(path12.join(config.source.contentFiles.baseDir, pattern));
     }
   }
   if (config.source.mode === "static-output") {
@@ -3789,25 +3151,22 @@ function collectWatchPaths(config, cwd) {
     paths.push("searchsocket.config.ts");
     paths.push(config.source.build.outputDir);
   }
-  return paths.map((value) => path14.resolve(cwd, value));
+  return paths.map((value) => path12.resolve(cwd, value));
 }
 function ensureStateDir(cwd) {
-  const target = path14.join(cwd, ".searchsocket");
-  fs10.mkdirSync(target, { recursive: true });
+  const target = path12.join(cwd, ".searchsocket");
+  fs8.mkdirSync(target, { recursive: true });
   return target;
 }
 function ensureGitignore(cwd) {
-  const gitignorePath = path14.join(cwd, ".gitignore");
+  const gitignorePath = path12.join(cwd, ".gitignore");
   const entries = [
-    ".searchsocket/vectors.db",
-    ".searchsocket/vectors.db-shm",
-    ".searchsocket/vectors.db-wal",
     ".searchsocket/manifest.json",
     ".searchsocket/registry.json"
   ];
   let content = "";
-  if (fs10.existsSync(gitignorePath)) {
-    content = fs10.readFileSync(gitignorePath, "utf8");
+  if (fs8.existsSync(gitignorePath)) {
+    content = fs8.readFileSync(gitignorePath, "utf8");
   }
   const lines = content.split("\n");
   const missing = entries.filter((entry) => !lines.some((line) => line.trim() === entry));
@@ -3818,10 +3177,10 @@ function ensureGitignore(cwd) {
 # SearchSocket local state
 ${missing.join("\n")}
 `;
-  fs10.writeFileSync(gitignorePath, content.trimEnd() + block, "utf8");
+  fs8.writeFileSync(gitignorePath, content.trimEnd() + block, "utf8");
 }
 function readScopesFromFile(filePath) {
-  const raw = fs10.readFileSync(filePath, "utf8");
+  const raw = fs8.readFileSync(filePath, "utf8");
   return new Set(
     raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
   );
@@ -3845,8 +3204,8 @@ function readRemoteGitBranches(cwd) {
   }
 }
 async function loadResolvedConfigForDev(cwd, configPath) {
-  const resolvedConfigPath = path14.resolve(cwd, configPath ?? "searchsocket.config.ts");
-  if (fs10.existsSync(resolvedConfigPath)) {
+  const resolvedConfigPath = path12.resolve(cwd, configPath ?? "searchsocket.config.ts");
+  if (fs8.existsSync(resolvedConfigPath)) {
     return loadConfig({ cwd, configPath });
   }
   return mergeConfig(cwd, {});
@@ -3893,7 +3252,7 @@ var program = new Command();
 program.name("searchsocket").description("Semantic site search and MCP retrieval for SvelteKit").version(package_default.version).option("-C, --cwd <path>", "working directory", process.cwd()).option("--config <path>", "config path (defaults to searchsocket.config.ts)");
 program.command("init").description("Create searchsocket.config.ts and .searchsocket state directory").action(async (_opts, command) => {
   const root = getRootOptions(command).cwd ?? process.cwd();
-  const cwd = path14.resolve(root);
+  const cwd = path12.resolve(root);
   const configPath = writeMinimalConfig(cwd);
   const stateDir = ensureStateDir(cwd);
   ensureGitignore(cwd);
@@ -3911,9 +3270,9 @@ program.command("init").description("Create searchsocket.config.ts and .searchso
   process.stdout.write("// searchsocketVitePlugin({ enabled: true, changedOnly: true })\n");
   process.stdout.write("// or env-driven: SEARCHSOCKET_AUTO_INDEX=1 pnpm build\n");
 });
-program.command("index").description("Index site content into markdown mirror + vector store").option("--scope <name>", "scope override").option("--changed-only", "only process changed chunks", true).option("--no-changed-only", "re-index regardless of previous manifest").option("--force", "force full mirror rebuild and re-upsert", false).option("--dry-run", "compute plan and cost, no API writes", false).option("--source <mode>", "source mode override: static-output|crawl|content-files|build").option("--max-pages <n>", "limit pages processed").option("--max-chunks <n>", "limit chunks processed").option("--quiet", "suppress all output except errors and warnings", false).option("--verbose", "verbose output", false).option("--json", "emit JSON logs and summary", false).action(async (opts, command) => {
+program.command("index").description("Index site content into Upstash Search").option("--scope <name>", "scope override").option("--changed-only", "only process changed chunks", true).option("--no-changed-only", "re-index regardless of previous manifest").option("--force", "force full rebuild", false).option("--dry-run", "compute plan, no writes", false).option("--source <mode>", "source mode override: static-output|crawl|content-files|build").option("--max-pages <n>", "limit pages processed").option("--max-chunks <n>", "limit chunks processed").option("--quiet", "suppress all output except errors and warnings", false).option("--verbose", "verbose output", false).option("--json", "emit JSON logs and summary", false).action(async (opts, command) => {
   const rootOpts = getRootOptions(command);
-  const cwd = path14.resolve(rootOpts?.cwd ?? process.cwd());
+  const cwd = path12.resolve(rootOpts?.cwd ?? process.cwd());
   await runIndexCommand({
     cwd,
     configPath: rootOpts?.config,
@@ -3929,16 +3288,16 @@ program.command("index").description("Index site content into markdown mirror +
     json: opts.json
   });
 });
-program.command("status").description("Show scope, indexing state, backend health, and recent cost estimate").option("--scope <name>", "scope override").action(async (opts, command) => {
+program.command("status").description("Show scope, indexing state, and backend health").option("--scope <name>", "scope override").action(async (opts, command) => {
   const rootOpts = getRootOptions(command);
-  const cwd = path14.resolve(rootOpts?.cwd ?? process.cwd());
+  const cwd = path12.resolve(rootOpts?.cwd ?? process.cwd());
   const config = await loadConfig({ cwd, configPath: rootOpts?.config });
   const scope = resolveScope(config, opts.scope);
-  let vectorStore;
+  let store;
   let health = { ok: false, details: "not checked" };
   try {
-    vectorStore = await createVectorStore(config, cwd);
-    health = await vectorStore.health();
+    store = await createUpstashStore(config);
+    health = await store.health();
   } catch (error) {
     health = {
       ok: false,
@@ -3946,24 +3305,22 @@ program.command("status").description("Show scope, indexing state, backend healt
     };
     process.stdout.write(`project: ${config.project.id}
 `);
-    process.stdout.write(`vector health: error (${health.details})
+    process.stdout.write(`backend health: error (${health.details})
 `);
     process.exitCode = 1;
     return;
   }
   let scopeRegistry = [];
   let scopeInfo;
-  let hashes = /* @__PURE__ */ new Map();
   try {
-    scopeRegistry = await vectorStore.listScopes(config.project.id);
+    scopeRegistry = await store.listScopes(config.project.id);
     scopeInfo = scopeRegistry.find((entry) => entry.scopeName === scope.scopeName);
-    hashes = await vectorStore.getContentHashes(scope);
   } catch (error) {
     process.stdout.write(`project: ${config.project.id}
 `);
     process.stdout.write(`resolved scope: ${scope.scopeName}
 `);
-    process.stdout.write(`vector health: error (${error instanceof Error ? error.message : "unknown error"})
+    process.stdout.write(`backend health: error (${error instanceof Error ? error.message : "unknown error"})
 `);
     process.exitCode = 1;
     return;
@@ -3972,25 +3329,15 @@ program.command("status").description("Show scope, indexing state, backend healt
 `);
   process.stdout.write(`resolved scope: ${scope.scopeName}
 `);
-  process.stdout.write(`embedding model: ${config.embeddings.model}
-`);
-  const tursoUrl = process.env[config.vector.turso.urlEnv];
-  const vectorMode = tursoUrl ? `remote (${tursoUrl})` : `local (${config.vector.turso.localPath})`;
-  process.stdout.write(`vector backend: turso/libsql (${vectorMode})
+  process.stdout.write(`backend: upstash-search
 `);
-  process.stdout.write(`vector health: ${health.ok ? "ok" : `error (${health.details ?? "n/a"})`}
+  process.stdout.write(`backend health: ${health.ok ? "ok" : `error (${health.details ?? "n/a"})`}
 `);
   if (scopeInfo) {
     process.stdout.write(`last indexed (${scope.scopeName}): ${scopeInfo.lastIndexedAt ?? "never"}
 `);
-    process.stdout.write(`tracked chunks: ${hashes.size}
-`);
-    if (scopeInfo.lastEstimateTokens != null) {
-      process.stdout.write(`last estimated tokens: ${scopeInfo.lastEstimateTokens}
-`);
-    }
-    if (scopeInfo.lastEstimateCostUSD != null) {
-      process.stdout.write(`last estimated cost: ${formatUsd(scopeInfo.lastEstimateCostUSD)}
+    if (scopeInfo.documentCount != null) {
+      process.stdout.write(`documents: ${scopeInfo.documentCount}
 `);
     }
   } else {
@@ -4001,7 +3348,7 @@ program.command("status").description("Show scope, indexing state, backend healt
     process.stdout.write("\nregistry scopes:\n");
     for (const item of scopeRegistry) {
       process.stdout.write(
-        `  - ${item.scopeName} model=${item.modelId} lastIndexedAt=${item.lastIndexedAt} vectors=${item.vectorCount ?? "unknown"}
+        `  - ${item.scopeName} lastIndexedAt=${item.lastIndexedAt} documents=${item.documentCount ?? "unknown"}
 `
       );
     }
@@ -4009,7 +3356,7 @@ program.command("status").description("Show scope, indexing state, backend healt
 });
 program.command("dev").description("Watch content files/routes and incrementally reindex on changes").option("--scope <name>", "scope override").option("--mcp", "start MCP server (http transport) alongside watcher", false).option("--mcp-port <n>", "MCP HTTP port", "3338").option("--mcp-path <path>", "MCP HTTP path", "/mcp").option("--verbose", "verbose logs", false).action(async (opts, command) => {
   const rootOpts = getRootOptions(command);
-  const cwd = path14.resolve(rootOpts?.cwd ?? process.cwd());
+  const cwd = path12.resolve(rootOpts?.cwd ?? process.cwd());
   const config = await loadResolvedConfigForDev(cwd, rootOpts?.config);
   const watchPaths = collectWatchPaths(config, cwd);
   process.stdout.write("starting searchsocket dev watcher...\n");
@@ -4076,45 +3423,44 @@ ${watchPaths.map((entry) => `  - ${entry}`).join("\n")}
     });
   });
 });
-program.command("clean").description("Delete local state and optionally delete remote vectors for a scope").option("--scope <name>", "scope override").option("--remote", "delete remote scope vectors", false).action(async (opts, command) => {
+program.command("clean").description("Delete local state and optionally delete remote indexes for a scope").option("--scope <name>", "scope override").option("--remote", "delete remote scope indexes", false).action(async (opts, command) => {
   const rootOpts = getRootOptions(command);
-  const cwd = path14.resolve(rootOpts?.cwd ?? process.cwd());
+  const cwd = path12.resolve(rootOpts?.cwd ?? process.cwd());
   const config = await loadConfig({ cwd, configPath: rootOpts?.config });
-  const scope = resolveScope(config, opts.scope);
-  const statePath = path14.join(cwd, config.state.dir);
+  const statePath = path12.join(cwd, config.state.dir);
   await fsp.rm(statePath, { recursive: true, force: true });
   process.stdout.write(`deleted local state directory: ${statePath}
 `);
   if (opts.remote) {
-    const vectorStore = await createVectorStore(config, cwd);
-    await vectorStore.dropAllTables();
-    process.stdout.write(`dropped all remote tables (chunks, registry, pages)
+    const store = await createUpstashStore(config);
+    await store.dropAllIndexes(config.project.id);
+    process.stdout.write(`dropped all remote indexes for project ${config.project.id}
 `);
   }
 });
 program.command("prune").description("List/delete stale scopes (dry-run by default)").option("--apply", "apply deletions", false).option("--scopes-file <path>", "file containing active scopes").option("--older-than <duration>", "ttl cutoff like 30d").action(async (opts, command) => {
   const rootOpts = getRootOptions(command);
-  const cwd = path14.resolve(rootOpts?.cwd ?? process.cwd());
+  const cwd = path12.resolve(rootOpts?.cwd ?? process.cwd());
   const config = await loadConfig({ cwd, configPath: rootOpts?.config });
   const baseScope = resolveScope(config);
-  let vectorStore;
+  let store;
   let scopes;
   try {
-    vectorStore = await createVectorStore(config, cwd);
-    scopes = await vectorStore.listScopes(config.project.id);
+    store = await createUpstashStore(config);
+    scopes = await store.listScopes(config.project.id);
   } catch (error) {
     process.stderr.write(
-      `error: failed to access Turso vector store: ${error instanceof Error ? error.message : String(error)}
+      `error: failed to access Upstash Search: ${error instanceof Error ? error.message : String(error)}
 `
     );
     process.exitCode = 1;
     return;
   }
-  process.stdout.write(`using remote registry
+  process.stdout.write(`using Upstash Search
 `);
   let keepScopes = /* @__PURE__ */ new Set();
   if (opts.scopesFile) {
-    keepScopes = readScopesFromFile(path14.resolve(cwd, opts.scopesFile));
+    keepScopes = readScopesFromFile(path12.resolve(cwd, opts.scopesFile));
   } else {
     keepScopes = readRemoteGitBranches(cwd);
   }
@@ -4132,7 +3478,7 @@ program.command("prune").description("List/delete stale scopes (dry-run by defau
       staleByList = !keepScopes.has(entry.scopeName);
     }
     let staleByTtl = false;
-    if (olderThanMs) {
+    if (olderThanMs && entry.lastIndexedAt !== "unknown") {
       staleByTtl = now - Date.parse(entry.lastIndexedAt) > olderThanMs;
     }
     if (keepScopes.size > 0 && olderThanMs) {
@@ -4168,7 +3514,7 @@ program.command("prune").description("List/delete stale scopes (dry-run by defau
       scopeId: `${config.project.id}:${entry.scopeName}`
     };
     try {
-      await vectorStore.deleteScope(scope);
+      await store.deleteScope(scope);
       deleted += 1;
     } catch (error) {
       process.stdout.write(
@@ -4185,7 +3531,7 @@ program.command("prune").description("List/delete stale scopes (dry-run by defau
 });
 program.command("doctor").description("Validate config, env vars, provider connectivity, and local write access").action(async (_opts, command) => {
   const rootOpts = getRootOptions(command);
-  const cwd = path14.resolve(rootOpts?.cwd ?? process.cwd());
+  const cwd = path12.resolve(rootOpts?.cwd ?? process.cwd());
   const checks = [];
   let config = null;
   try {
@@ -4199,23 +3545,21 @@ program.command("doctor").description("Validate config, env vars, provider conne
     });
   }
   if (config) {
-    const embKey = process.env[config.embeddings.apiKeyEnv];
+    const upstashUrl = config.upstash.url ?? process.env[config.upstash.urlEnv];
+    const upstashToken = config.upstash.token ?? process.env[config.upstash.tokenEnv];
     checks.push({
-      name: `env ${config.embeddings.apiKeyEnv}`,
-      ok: Boolean(embKey),
-      details: embKey ? void 0 : "missing"
+      name: `env ${config.upstash.urlEnv}`,
+      ok: Boolean(upstashUrl),
+      details: upstashUrl ? void 0 : "missing"
+    });
+    checks.push({
+      name: `env ${config.upstash.tokenEnv}`,
+      ok: Boolean(upstashToken),
+      details: upstashToken ? void 0 : "missing"
     });
-    {
-      const tursoUrl = process.env[config.vector.turso.urlEnv];
-      checks.push({
-        name: "turso/libsql",
-        ok: true,
-        details: tursoUrl ? `remote: ${tursoUrl}` : `local file: ${config.vector.turso.localPath}`
-      });
-    }
     if (config.source.mode === "static-output") {
-      const outputDir = path14.resolve(cwd, config.source.staticOutputDir);
-      const exists = fs10.existsSync(outputDir);
+      const outputDir = path12.resolve(cwd, config.source.staticOutputDir);
+      const exists = fs8.existsSync(outputDir);
       checks.push({
         name: "source: static output dir",
         ok: exists,
@@ -4224,15 +3568,15 @@ program.command("doctor").description("Validate config, env vars, provider conne
     } else if (config.source.mode === "build") {
       const buildConfig = config.source.build;
       if (buildConfig) {
-        const manifestPath = path14.resolve(cwd, buildConfig.outputDir, "server", "manifest-full.js");
-        const manifestExists = fs10.existsSync(manifestPath);
+        const manifestPath = path12.resolve(cwd, buildConfig.outputDir, "server", "manifest-full.js");
+        const manifestExists = fs8.existsSync(manifestPath);
         checks.push({
           name: "source: build manifest",
           ok: manifestExists,
           details: manifestExists ? manifestPath : `${manifestPath} not found (run \`vite build\` first)`
         });
-        const viteBin = path14.resolve(cwd, "node_modules", ".bin", "vite");
-        const viteExists = fs10.existsSync(viteBin);
+        const viteBin = path12.resolve(cwd, "node_modules", ".bin", "vite");
+        const viteExists = fs8.existsSync(viteBin);
         checks.push({
           name: "source: vite binary",
           ok: viteExists,
@@ -4249,7 +3593,7 @@ program.command("doctor").description("Validate config, env vars, provider conne
       const contentConfig = config.source.contentFiles;
       if (contentConfig) {
         const fg4 = await import("fast-glob");
-        const baseDir = path14.resolve(cwd, contentConfig.baseDir);
+        const baseDir = path12.resolve(cwd, contentConfig.baseDir);
         const files = await fg4.default(contentConfig.globs, { cwd: baseDir, onlyFiles: true });
         checks.push({
           name: "source: content files",
@@ -4264,61 +3608,26 @@ program.command("doctor").description("Validate config, env vars, provider conne
         });
       }
     }
-    try {
-      const provider = createEmbeddingsProvider(config);
-      await provider.embedTexts(["searchsocket doctor ping"], config.embeddings.model);
-      checks.push({ name: "embedding provider connectivity", ok: true });
-    } catch (error) {
-      checks.push({
-        name: "embedding provider connectivity",
-        ok: false,
-        details: error instanceof Error ? error.message : "unknown error"
-      });
-    }
     let store = null;
     try {
-      store = await createVectorStore(config, cwd);
+      store = await createUpstashStore(config);
       const health = await store.health();
       checks.push({
-        name: "vector backend connectivity",
+        name: "upstash search connectivity",
         ok: health.ok,
         details: health.details
       });
     } catch (error) {
       checks.push({
-        name: "vector backend connectivity",
+        name: "upstash search connectivity",
         ok: false,
         details: error instanceof Error ? error.message : "unknown error"
       });
     }
-    if (store) {
-      try {
-        const testScope = {
-          projectId: config.project.id,
-          scopeName: "_searchsocket_doctor_probe",
-          scopeId: `${config.project.id}:_searchsocket_doctor_probe`
-        };
-        await store.recordScope({
-          projectId: testScope.projectId,
-          scopeName: testScope.scopeName,
-          modelId: config.embeddings.model,
-          lastIndexedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          vectorCount: 0
-        });
-        await store.deleteScope(testScope);
-        checks.push({ name: "vector backend write permission", ok: true });
-      } catch (error) {
-        checks.push({
-          name: "vector backend write permission",
-          ok: false,
-          details: error instanceof Error ? error.message : "write test failed"
-        });
-      }
-    }
     try {
       const scope = resolveScope(config);
       const { statePath } = ensureStateDirs(cwd, config.state.dir, scope);
-      const testPath = path14.join(statePath, ".write-test");
+      const testPath = path12.join(statePath, ".write-test");
       await fsp.writeFile(testPath, "ok\n", "utf8");
       await fsp.rm(testPath, { force: true });
       checks.push({ name: "state directory writable", ok: true });
@@ -4347,7 +3656,7 @@ program.command("doctor").description("Validate config, env vars, provider conne
 });
 program.command("mcp").description("Run SearchSocket MCP server").option("--transport <transport>", "stdio|http", "stdio").option("--port <n>", "HTTP port", "3338").option("--path <path>", "HTTP path", "/mcp").action(async (opts, command) => {
   const rootOpts = getRootOptions(command);
-  const cwd = path14.resolve(rootOpts?.cwd ?? process.cwd());
+  const cwd = path12.resolve(rootOpts?.cwd ?? process.cwd());
   await runMcpServer({
     cwd,
     configPath: rootOpts?.config,
@@ -4356,9 +3665,9 @@ program.command("mcp").description("Run SearchSocket MCP server").option("--tran
     httpPath: opts.path
   });
 });
-program.command("search").description("Quick local CLI search against indexed vectors").requiredOption("--q <query>", "search query").option("--scope <name>", "scope override").option("--top-k <n>", "top K results", "10").option("--path-prefix <prefix>", "path prefix filter").option("--rerank", "enable configured reranker", false).action(async (opts, command) => {
+program.command("search").description("Quick CLI search against Upstash Search").requiredOption("--q <query>", "search query").option("--scope <name>", "scope override").option("--top-k <n>", "top K results", "10").option("--path-prefix <prefix>", "path prefix filter").action(async (opts, command) => {
   const rootOpts = getRootOptions(command);
-  const cwd = path14.resolve(rootOpts?.cwd ?? process.cwd());
+  const cwd = path12.resolve(rootOpts?.cwd ?? process.cwd());
   const engine = await SearchEngine.create({
     cwd,
     configPath: rootOpts?.config
@@ -4367,14 +3676,13 @@ program.command("search").description("Quick local CLI search against indexed ve
     q: opts.q,
     scope: opts.scope,
     topK: parsePositiveInt(opts.topK, "--top-k"),
-    pathPrefix: opts.pathPrefix,
-    rerank: opts.rerank
+    pathPrefix: opts.pathPrefix
   });
   process.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
 });
 async function main() {
-  dotenvConfig({ path: path14.resolve(process.cwd(), ".env") });
+  dotenvConfig({ path: path12.resolve(process.cwd(), ".env") });
   await program.parseAsync(process.argv);
 }
 main().catch((error) => {