@gmickel/gno 2.8.2 → 2.8.3

package/README.md

@@ -139,7 +139,7 @@ See the [guide](docs/COMPILED-CONTEXT.md).
 
 <!-- public-truth:current-version -->
 
-> Current source version: **v2.8.2**. See [CHANGELOG.md](./CHANGELOG.md).
+> Current source version: **v2.8.3**. See [CHANGELOG.md](./CHANGELOG.md).
 
 <!-- /public-truth -->
 

package/browser-extension/artifacts/gno-browser-clipper-v2.8.3.zip.sha256

@@ -0,0 +1 @@
+7fe15ce08a24f4dae4ac6694f62bb26d94bbc47d6abc09826f29267ace10558d  gno-browser-clipper-v2.8.3.zip

package/browser-extension/dist/manifest.json

@@ -21,5 +21,5 @@
   "content_security_policy": {
     "extension_pages": "script-src 'self'; object-src 'none'; connect-src http://127.0.0.1:*"
   },
-  "version": "2.8.2"
+  "version": "2.8.3"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmickel/gno",
-  "version": "2.8.2",
+  "version": "2.8.3",
   "description": "Local semantic search for your documents. Index Markdown, PDF, and Office files with hybrid BM25 + vector search.",
   "keywords": [
     "embeddings",
@@ -197,7 +197,15 @@
     "mammoth": "1.12.2",
     "mdast-util-from-markdown": "2.0.3",
     "mdast-util-gfm": "3.1.0",
+    "mdast-util-gfm-autolink-literal": "2.0.1",
+    "mdast-util-gfm-footnote": "2.1.0",
+    "mdast-util-gfm-strikethrough": "2.0.0",
+    "mdast-util-gfm-task-list-item": "2.0.0",
     "micromark-extension-gfm": "3.0.0",
+    "micromark-extension-gfm-autolink-literal": "2.1.0",
+    "micromark-extension-gfm-footnote": "2.1.0",
+    "micromark-extension-gfm-strikethrough": "2.1.0",
+    "micromark-extension-gfm-task-list-item": "2.1.0",
     "mime-types": "2.1.35",
     "minimatch": "10.2.6",
     "nanoid": "6.0.1",

package/spec/cli.md

@@ -987,7 +987,10 @@ resolves to a regular file inside the workspace, at most 200,000 files), no
 file is opened, and no graph edge is created. Wiki targets match files by the workspace
 link rules; a non-Markdown target needs its extension, `.md` is optional. A
 Markdown link matches only the file at its resolved path (NFC,
-case-insensitive). A
+case-insensitive); as for wiki links, `.md` is optional, so `[x](Note)` matches
+an unindexed `Note.md`. An indexed `Note.md` (compared under the same NFC,
+Unicode-lowercase key) is not outside the index, and Markdown link resolution
+itself stays exact-path, so that link remains in `links.local-targets`. A
 target missing from the listing stays unresolved; an unreadable folder or the
 file bound makes the listing incomplete, which the `links.outside-index` rule
 message states once.
@@ -995,7 +998,12 @@ message states once.
 The wiki link parser reads Obsidian's table-escaped alias `[[Note\|Alias]]`
 as target `Note` with alias `Alias`. Markdown link text may contain balanced
 square brackets (`[see [1]](note.md)`); a destination containing a square
-bracket is not a link.
+bracket is not a link. Markdown links follow CommonMark, as Obsidian renders
+them: a `[` escaped with a backslash (`\[clause](see section 4)`) opens no
+link, and an inline destination with an unescaped space is plain text unless
+it is wrapped in angle brackets. `[x](<my note.md>)` and `[x](my%20note.md)`
+both link to `my note.md`; a link title (`[x](note.md "Title")`) is not part
+of the target.
 
 The JSON contract is versioned as `gno://schemas/audit-report@1.0`. Finding IDs
 are stable SHA-256 identities derived from rule, normalized subject/location,
@@ -1472,6 +1480,33 @@ individual virtual document. The closed `record.adapter` identity contains the
 adapter ID, version, and configuration fingerprint. `get` and `multi-get`
 preserve the same fields.
 
+Every file is indexed under the per-file budget `conversion.timeoutMs`
+(default 60000) and `conversion.maxMemoryMb` (default half of physical memory,
+at least 2048; process resident memory). Conversion and every post-conversion
+phase (metadata, code regions, change-journal structure, chunking, link
+extraction) run in one worker per process, one file at a time; the worker is
+terminated at either limit, mid-phase, and replaced for the next file.
+Database reads and writes stay on the main thread. A standalone compiled
+executable, which cannot start the worker, runs the phases in a child process
+of itself (internal environment flag) under the same limits; the child's
+resident memory counts toward `conversion.maxMemoryMb` (Linux `/proc`, `ps`
+elsewhere; time only on Windows). A processor that cannot start fails the file
+with `ISOLATION_UNAVAILABLE`; nothing is prepared without the budget. The
+child is SIGKILLed on process exit, SIGTERM, SIGINT (via the CLI's exit
+path) and resident shutdown; on Linux it also carries a parent-death signal,
+so it dies with a SIGKILLed parent, and elsewhere it exits at its next step
+once its parent is gone.
+A file over either limit is recorded with error code `TIMEOUT` or
+`MEMORY_LIMIT` (the message names the running phase), stays unindexed, and is
+retried by the next sync; the rest of the run continues. `update` and `index` always print such a
+file in terminal output as `[CODE] <relPath>: <message>` (other per-file
+errors stay `--verbose` only), and write
+`Still converting <collection>/<relPath> after <n>s (budget <m>s)` to stderr
+once a file has been processing for 10 seconds or half its budget, whichever
+is sooner.
+`gno status` lists stopped files under "Stopped at conversion budget" in
+terminal output (JSON output is unchanged).
+
 File/export adapter iteration has a 60-second deadline in addition to the byte,
 record, metadata, and total-character caps. A partial import that retains valid
 siblings exits successfully but is never silent: terminal output includes the
@@ -2976,7 +3011,11 @@ misconfigured `findings` block (see [Daemon Mode](../docs/DAEMON.md#scheduled-fi
 The `embedding-fingerprint` check is additive doctor-only diagnostics. It uses
 the active embed model and stored vector dimensions to report the current
 freshness fingerprint, pending/stale chunks, legacy empty-fingerprint vectors,
-and stored fingerprint groups. Stale, legacy, and mixed groups are warnings;
+and stored fingerprint groups. On an index with an activated vector partition
+for the embed model (every index `gno embed` wrote since 2.7), the groups are
+that partition with its current chunk count and there are no legacy vectors;
+legacy `content_vectors` groups are read only before any partition activates.
+Stale, legacy, and mixed groups are warnings;
 recover with `gno embed`, or `gno embed --force` if vectors still look stale.
 
 The additive `activation` object uses the same contract as `gno status` and
@@ -3988,7 +4027,10 @@ gno similar <doc> [-n, --limit <num>] [--threshold <num>] [--cross-collection] [
 
 - Finds documents semantically similar to the source document
 - Requires embeddings to be generated (`gno embed`)
-- Uses average document embedding for comparison
+- Source vector: the stored vector of the document's first chunk (the
+  lowest-seq chunk whose vector is current), read from the active vector
+  partition. `gno_similar` (MCP), `GET /api/doc/:id/similar` (REST) and graph
+  similarity edges use the same rule, so scores match across surfaces
 - By default, limits results to same collection
 
 **Output (JSON):**
@@ -4203,6 +4245,9 @@ gno changes --follow --jsonl [--cursor <cursor>] [--collection <name>]
   old/new identity and hash snapshots, normalized structural deltas, pagination,
   cursor-expiry, and retention-truncation disclosure.
 - The journal never returns source bodies.
+- Link additions and removals in `structureDelta.links` are recorded only for
+  Markdown sources, matching link extraction; content changes of other
+  documents (code, text, converted files, records) are still journaled.
 
 **Follow mode (`--follow --jsonl`)** streams journal events as they land and is
 the durable automation input for consumers that resume across restarts.
@@ -4444,6 +4489,21 @@ gno serve --detach --stop
 
 ---
 
+#### Config reload while running
+
+A running `gno serve` or `gno daemon` re-reads its config file before each
+request (REST, Web UI, HTTP MCP, daemon status) and every 2 seconds, and adopts
+changes to `collections` and `contexts` made by the CLI (`gno collection
+add/remove`) or by hand: status, MCP `gno_status`, the watcher and search scope
+follow without a restart. A newly added collection is watched from then on; its
+existing files are indexed by `gno update` (or the next start's initial sync).
+An adoption that changes the collection set or policies moves the egress policy
+epoch as a REST collection change does. The checks are the sessions config
+refresh's: an unreadable config file answers an error (`500`, sessions code
+`SESSIONS_RUNTIME_FAILURE`), never the stale config, and a config bound to
+another index is refused. Other settings (models, gateway, sessions sources
+outside the sessions routes) keep their restart behaviour.
+
 ### gno daemon
 
 Start a headless long-running watcher process for continuous indexing.
@@ -4483,6 +4543,8 @@ is blocked.
 
 - Opens DB once at startup
 - Loads config and requires at least one configured collection
+- Follows collection edits to the config file while running (see
+  [Config reload](#config-reload-while-running))
 - Starts the same watcher + embed scheduler used by `gno serve`
 - Exact contained eligible paths always use targeted content-hash sync.
   Ambiguous temp/directory/missing-name/recursive-delete events use bounded,

package/spec/mcp.md

@@ -2188,12 +2188,11 @@ Find semantically similar documents using vector embeddings.
 
 **Algorithm:**
 
-1. Get all chunks for the source document
-2. Retrieve each chunk's stored embedding from the active vector partition (legacy `content_vectors` only before any partition activates); no model is loaded
-3. Compute average embedding across all chunks
-4. Search for nearest neighbors using sqlite-vec
-5. Exclude self and filter by collection if not crossCollection
-6. Return top N similar documents with scores
+1. Take the stored vector of the source document's first chunk (the lowest-seq chunk whose vector is current) from the active vector partition (legacy `content_vectors` only before any partition activates); no model is loaded. This is the same source vector `gno similar`, `GET /api/doc/:id/similar` and graph similarity edges use, so scores match across surfaces
+2. Normalize it to unit length
+3. Search for nearest neighbors using sqlite-vec
+4. Exclude self and filter by collection if not crossCollection
+5. Return top N similar documents with scores
 
 **Errors:**
 

package/src/cli/commands/daemon.ts

@@ -16,6 +16,7 @@ import {
   resolveHttpGatewayConfig,
 } from "../../mcp/http-security";
 import { startBackgroundRuntime } from "../../serve/background-runtime";
+import { refreshResidentConfig } from "../../serve/resident-request";
 import { handleResidentStatus, handleStatus } from "../../serve/routes/api";
 import { createMcpHttpGateway } from "../../serve/routes/mcp";
 import { SessionsError } from "../../sessions/types";
@@ -106,6 +107,8 @@ export const authorizeDaemonStatus = async (
 ): Promise<Response> => {
   const authorization = await gateway.security.authorize(request, server);
   if (!authorization.ok) return authorization.response;
+  const refreshFailure = await refreshResidentConfig(runtime);
+  if (refreshFailure) return refreshFailure;
   try {
     enforceCollectionEgress({
       collections: runtime.config.collections,
@@ -132,13 +135,15 @@ export const authorizeDaemonStatus = async (
   }
 };
 
-export function handleDaemonAppStatus(
+export async function handleDaemonAppStatus(
   runtime: ResidentRuntime,
   host: string
-): Promise<Response> | Response {
+): Promise<Response> {
   if (!isHttpGatewayLoopbackBind(host)) {
     return new Response(null, { status: 404 });
   }
+  const refreshFailure = await refreshResidentConfig(runtime);
+  if (refreshFailure) return refreshFailure;
   return handleStatus(runtime.ctxHolder.current, {
     getResidentStatus: () => runtime.getStatus(),
   });

package/src/cli/commands/doctor.ts

@@ -31,6 +31,7 @@ import {
   resolveFindingsSchedule,
 } from "../../core/findings-run-state";
 import { formatVectorPartitionLines } from "../../core/vector-partition-status";
+import { getEmbeddingFingerprint } from "../../embed/fingerprint";
 import { getCodeChunkingStatus } from "../../ingestion/chunker";
 import { ModelCache } from "../../llm/cache";
 import { getActivePreset, resolveModelUri } from "../../llm/registry";
@@ -42,6 +43,8 @@ import {
   getLoadAttempts,
 } from "../../store/sqlite/setup";
 import { getStoredEmbeddingFingerprint } from "../../store/vector/freshness";
+import { currentOwnerCount } from "../../store/vector/runtime-compat";
+import { storedVectorPartition } from "../../store/vector/status";
 import {
   buildDoctorActivation,
   checkConnectorActivation,
@@ -319,10 +322,14 @@ async function checkEmbeddingFingerprints(
       ];
     }
 
-    const legacyChunks =
-      db
-        .query<{ count: number }, [string]>(
-          `
+    // An index embedded since 2.7 keeps its vectors in the active partition;
+    // legacy `content_vectors` count only before any partition activates.
+    const partition = storedVectorPartition(db, model);
+    const legacyChunks = partition
+      ? 0
+      : (db
+          .query<{ count: number }, [string]>(
+            `
           SELECT COUNT(*) as count
           FROM content_vectors v
           JOIN content_chunks c
@@ -336,12 +343,23 @@ async function checkEmbeddingFingerprints(
                 AND d.active = 1
             )
         `
-        )
-        .get(model)?.count ?? 0;
-
-    const groups = db
-      .query<{ model: string; fingerprint: string; count: number }, []>(
-        `
+          )
+          .get(model)?.count ?? 0);
+
+    const groups = partition
+      ? [
+          {
+            model,
+            fingerprint: getEmbeddingFingerprint({
+              modelUri: model,
+              dimensions: partition.dimensions,
+            }),
+            count: currentOwnerCount(db, partition.partitionId),
+          },
+        ]
+      : db
+          .query<{ model: string; fingerprint: string; count: number }, []>(
+            `
         SELECT
           v.model as model,
           v.embed_fingerprint as fingerprint,
@@ -358,18 +376,18 @@ async function checkEmbeddingFingerprints(
         GROUP BY v.model, v.embed_fingerprint
         ORDER BY count DESC, v.model ASC, v.embed_fingerprint ASC
       `
-      )
-      .all()
-      .map((group) => ({
-        model: group.model,
-        fingerprint: group.fingerprint,
-        count: group.count,
-        current:
-          group.model === model && group.fingerprint === currentFingerprint,
-        legacy: group.fingerprint === "",
-      }));
-
-    const mixedGroups = groups.length;
+          )
+          .all();
+    const fingerprintGroups = groups.map((group) => ({
+      model: group.model,
+      fingerprint: group.fingerprint,
+      count: group.count,
+      current:
+        group.model === model && group.fingerprint === currentFingerprint,
+      legacy: group.fingerprint === "",
+    }));
+
+    const mixedGroups = fingerprintGroups.length;
     const pendingChunks = statusResult.value.embeddingBacklog;
     const hasWarnings =
       pendingChunks > 0 || legacyChunks > 0 || mixedGroups > 1;
@@ -380,7 +398,7 @@ async function checkEmbeddingFingerprints(
       pendingChunks,
       legacyChunks,
       mixedGroups,
-      groups,
+      groups: fingerprintGroups,
     };
 
     const message =
@@ -392,7 +410,7 @@ async function checkEmbeddingFingerprints(
     if (hasWarnings) {
       details.push("Run: gno embed");
       details.push("If vectors still look stale, run: gno embed --force");
-      for (const group of groups) {
+      for (const group of fingerprintGroups) {
         const label = describeFingerprintGroup(group);
         const fingerprint = group.legacy
           ? "(empty)"

package/src/cli/commands/index-cmd.ts

@@ -28,7 +28,11 @@ import {
   withContentTypeRules,
 } from "../../ingestion";
 import { type EmbedResult, embedStageOutcome } from "./embed";
-import { formatSyncResultLines, initStore } from "./shared";
+import {
+  formatSyncResultLines,
+  initStore,
+  reportSlowConversion,
+} from "./shared";
 
 /**
  * Options for index command.
@@ -202,7 +206,11 @@ export async function index(options: IndexOptions = {}): Promise<IndexResult> {
           collections,
           store,
           withContentTypeRules(
-            { gitPull: options.gitPull, runUpdateCmd: true },
+            {
+              gitPull: options.gitPull,
+              runUpdateCmd: true,
+              onSlowConversion: reportSlowConversion,
+            },
             config
           )
         );

package/src/cli/commands/links.ts

@@ -587,21 +587,17 @@ export async function similar(
     }
     const db = store.getRawDb();
 
-    // Stored vector of the document's first chunk, from the active partition
+    // Similarity source vector (first chunk, unit length), active partition
     const {
-      readStoredDocumentVectors,
+      readSimilaritySourceVectors,
       resolveStoredVectorSource,
       similarityHitDocuments,
       storedVectorSearchOptions,
     } = await import("../../store/vector/stored-vectors.js");
     const source = resolveStoredVectorSource(db, modelPreset.embed);
-    const [embedding] =
-      readStoredDocumentVectors(
-        db,
-        source,
-        [{ id: doc.id, mirrorHash: doc.mirrorHash }],
-        { firstChunkOnly: true }
-      ).get(doc.id) ?? [];
+    const embedding = readSimilaritySourceVectors(db, source, [
+      { id: doc.id, mirrorHash: doc.mirrorHash },
+    ]).get(doc.id);
 
     if (!embedding) {
       return {
@@ -610,20 +606,7 @@ export async function similar(
         isValidation: true,
       };
     }
-
-    // Normalize embedding for cosine similarity
     const dimensions = embedding.length;
-    let norm = 0;
-    for (let i = 0; i < dimensions; i++) {
-      const val = embedding[i] ?? 0;
-      norm += val * val;
-    }
-    norm = Math.sqrt(norm);
-    if (norm > 0) {
-      for (let i = 0; i < dimensions; i++) {
-        embedding[i] = (embedding[i] ?? 0) / norm;
-      }
-    }
 
     // Create vector index port for search
     const { createVectorIndexPort } =

package/src/cli/commands/shared.ts

@@ -6,7 +6,7 @@
  */
 
 import type { Collection, Config } from "../../config/types";
-import type { SyncResult } from "../../ingestion";
+import type { SlowConversionEvent, SyncResult } from "../../ingestion";
 import type { SearchResults } from "../../pipeline/types";
 
 import {
@@ -20,6 +20,7 @@ import {
   loadConfig,
   writeConfigWarningsToStderr,
 } from "../../config";
+import { BUDGET_ERROR_CODES } from "../../ingestion/file-processor";
 import { SqliteAdapter } from "../../store/sqlite/adapter";
 import { assertCliSessionBinding } from "../session-binding";
 
@@ -164,6 +165,21 @@ export function decorateSearchResultsForIndex(
   };
 }
 
+/**
+ * Name a file whose conversion is still running past the notice threshold,
+ * so an operator can see which file a slow run is working on (stderr, so
+ * JSON output on stdout stays parseable).
+ */
+export function reportSlowConversion(event: SlowConversionEvent): void {
+  process.stderr.write(
+    `Still converting ${event.collection}/${event.relPath} after ${formatSeconds(event.elapsedMs)} (budget ${formatSeconds(event.budgetMs)})\n`
+  );
+}
+
+/** Seconds with one decimal below ten seconds, whole seconds above. */
+const formatSeconds = (ms: number): string =>
+  ms < 10_000 ? `${(ms / 1000).toFixed(1)}s` : `${Math.round(ms / 1000)}s`;
+
 /**
  * Format sync result lines (shared between update and index commands).
  */
@@ -194,6 +210,15 @@ export function formatSyncResultLines(
     if (c.filesErrored > 0) {
       lines.push(`  ${c.filesErrored} errors`);
     }
+    // A file stopped at its conversion budget is always named, not only in
+    // verbose output: it stays unindexed until a later run finishes it.
+    if (!options.verbose) {
+      for (const err of c.errors) {
+        if (BUDGET_ERROR_CODES.has(err.code)) {
+          lines.push(`    [${err.code}] ${err.relPath}: ${err.message}`);
+        }
+      }
+    }
     if (c.filesMarkedInactive > 0) {
       lines.push(`  ${c.filesMarkedInactive} marked inactive`);
     }

package/src/cli/commands/status.ts

@@ -27,6 +27,7 @@ import {
   formatMemoryStatusLines,
 } from "../../core/memory-diagnostics";
 import { formatVectorPartitionLines } from "../../core/vector-partition-status";
+import { BUDGET_ERROR_CODES } from "../../ingestion/file-processor";
 import { ModelCache } from "../../llm/cache";
 import { getActivePreset, resolveModelUri } from "../../llm/registry";
 import { getConnectorVerificationTargets } from "../../serve/connectors";
@@ -64,9 +65,56 @@ export type StatusResult =
       contentTypeBoost: ContentTypeBoostStatus;
       memory: MemoryStatus;
       backgroundIssues: ResidentBackgroundIssue[];
+      /** Files whose latest conversion stopped at the per-file budget. */
+      budgetStops: BudgetStop[];
     }
   | { success: false; error: string };
 
+/** A file left unindexed because its conversion overran its budget. */
+export interface BudgetStop {
+  collection: string;
+  relPath: string;
+  code: string;
+  message: string;
+}
+
+/** Most recent ingest errors inspected for budget stops. */
+const BUDGET_STOP_SCAN_LIMIT = 100;
+/** Most budget stops listed in status output. */
+const MAX_BUDGET_STOPS = 10;
+
+/**
+ * Files whose latest indexing attempt stopped at the conversion budget, from
+ * the recent error log, kept only while the document still carries that code.
+ */
+async function collectBudgetStops(store: SqliteAdapter): Promise<BudgetStop[]> {
+  const recent = await store.getRecentErrors(BUDGET_STOP_SCAN_LIMIT);
+  if (!recent.ok) return [];
+  const stops: BudgetStop[] = [];
+  const seen = new Set<string>();
+  for (const row of recent.value) {
+    const key = `${row.collection}\u0000${row.relPath}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    if (!BUDGET_ERROR_CODES.has(row.code)) continue;
+    const document = await store.getDocument(row.collection, row.relPath);
+    if (
+      document.ok &&
+      document.value?.active &&
+      document.value.lastErrorCode === row.code
+    ) {
+      stops.push({
+        collection: row.collection,
+        relPath: row.relPath,
+        code: row.code,
+        message: row.message,
+      });
+      if (stops.length >= MAX_BUDGET_STOPS) break;
+    }
+  }
+  return stops;
+}
+
 /** A background issue reported by (or about) a running detached resident. */
 export type ResidentBackgroundIssue = BackgroundIssue & {
   process: "serve" | "daemon";
@@ -368,6 +416,7 @@ export async function status(
       contentTypeBoost: buildContentTypeBoostStatus(config.contentTypes ?? []),
       memory: await buildMemoryStatus(store, config.collections),
       backgroundIssues: await collectResidentIssues(),
+      budgetStops: await collectBudgetStops(store),
     };
   } finally {
     await store.close();
@@ -439,6 +488,10 @@ export function formatStatus(
     (issue) =>
       `  ${issue.process} (pid ${issue.pid}): ${formatBackgroundIssue(issue)}`
   );
+  const stopLines = result.budgetStops.map(
+    (stop) =>
+      `  ${stop.collection}/${stop.relPath} [${stop.code}] ${stop.message}`
+  );
   return [
     formatTerminal(
       result.status,
@@ -446,6 +499,13 @@ export function formatStatus(
       result.contentTypeBoost,
       result.memory
     ),
+    ...(stopLines.length
+      ? [
+          "",
+          "Stopped at conversion budget (retried by the next update):",
+          ...stopLines,
+        ]
+      : []),
     ...(issueLines.length ? ["", "Background issues:", ...issueLines] : []),
   ].join("\n");
 }

package/src/cli/commands/update.ts

@@ -15,7 +15,11 @@ import {
   type SyncResult,
   withContentTypeRules,
 } from "../../ingestion";
-import { formatSyncResultLines, initStore } from "./shared";
+import {
+  formatSyncResultLines,
+  initStore,
+  reportSlowConversion,
+} from "./shared";
 
 /**
  * Options for update command.
@@ -66,6 +70,7 @@ export async function update(
           {
             gitPull: options.gitPull,
             runUpdateCmd: true,
+            onSlowConversion: reportSlowConversion,
           },
           config
         )

package/src/cli/commands/vec.ts

@@ -13,10 +13,16 @@ import {
   createVectorIndexPort,
   createVectorStatsPort,
 } from "../../store/vector";
+import {
+  rebuildPartitionIndex,
+  syncPartitionIndex,
+} from "../../store/vector/partition-index";
 import {
   dropVectorPartition,
+  storedVectorPartition,
   type VectorPartitionStatus,
 } from "../../store/vector/status";
+import { loadSqliteVec } from "../../store/vector/variants";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Types
@@ -76,7 +82,9 @@ function inferDimensions(
 // ─────────────────────────────────────────────────────────────────────────────
 
 /**
- * Sync vec0 index with content_vectors (add missing, remove orphans).
+ * Sync the vec0 index with stored vectors (add missing, remove orphans): the
+ * active vector partition's variants, or legacy `content_vectors` on an
+ * index that never activated a partition.
  */
 export async function vecSync(
   options: VecOptions = {}
@@ -112,6 +120,21 @@ export async function vecSync(
   try {
     const db = store.getRawDb();
 
+    const partition = storedVectorPartition(db, modelUri);
+    if (partition) {
+      if (!(await loadSqliteVec(db))) {
+        return {
+          success: false,
+          error: "sqlite-vec not available. Cannot sync index.",
+        };
+      }
+      return {
+        success: true,
+        ...syncPartitionIndex(db, partition),
+        model: modelUri,
+      };
+    }
+
     // Infer dimensions from stored vectors for this model
     const dimensions = inferDimensions(db, modelUri);
     if (dimensions === null) {
@@ -154,7 +177,9 @@ export async function vecSync(
 }
 
 /**
- * Rebuild vec0 index from content_vectors (drop + recreate + repopulate).
+ * Rebuild the vec0 index (drop + recreate + repopulate) from the active
+ * vector partition's variants, or from legacy `content_vectors` on an index
+ * that never activated a partition.
  */
 export async function vecRebuild(
   options: VecOptions = {}
@@ -190,6 +215,21 @@ export async function vecRebuild(
   try {
     const db = store.getRawDb();
 
+    const partition = storedVectorPartition(db, modelUri);
+    if (partition) {
+      if (!(await loadSqliteVec(db))) {
+        return {
+          success: false,
+          error: "sqlite-vec not available. Cannot rebuild index.",
+        };
+      }
+      return {
+        success: true,
+        count: rebuildPartitionIndex(db, partition),
+        model: modelUri,
+      };
+    }
+
     // Infer dimensions from stored vectors for this model
     const dimensions = inferDimensions(db, modelUri);
     if (dimensions === null) {