@gmickel/gno 2.6.0 → 2.7.1

package/src/store/vector/status.ts

@@ -3,8 +3,16 @@ import type { Database } from "bun:sqlite";
 
 import { getEmbeddingFingerprint } from "../../embed/fingerprint";
 import { formatDocForEmbedding } from "../../pipeline/contextual";
+import {
+  currentOwnerCount,
+  identityPartitionId,
+  recordedRuntimeCaller,
+  retrievalUse,
+  selectRuntimePartition,
+} from "./runtime-compat";
 import {
   embeddingInputHash,
+  loadSqliteVec,
   SELECTED_VECTOR_PARTITION_PREFIX,
 } from "./variants";
 
@@ -16,6 +24,204 @@ interface Partition {
   dimensions: number;
   state: string;
   activated_epoch: number | null;
+  legacy: number;
+  provenance: string | null;
+  fork: string | null;
+}
+
+export interface VectorPartitionStatus {
+  id: string;
+  model: string;
+  dimensions: number;
+  state: "active" | "shadow";
+  /** Pre-fn-184 runtime-keyed partition awaiting measured re-keying. */
+  legacy: boolean;
+  /**
+   * This caller's retrieval reads this partition, selected by the same rule
+   * queries use (see `vectorRuntime`); status counts use it.
+   */
+  retrieval: boolean;
+  /** `gno vec drop` accepts it: a shadow partition this runtime does not read. */
+  droppable: boolean;
+  /** Current document chunks bound to this partition. */
+  owners: number;
+  /** Runtime that built the partition, e.g. "CUDA, Bun 1.4.2". */
+  provenance: string;
+  /** Runtimes measured (or recorded as the builder) to read this partition. */
+  compatibleRuntimes: string[];
+  /** Runtimes measured incompatible; they need another partition or lexical. */
+  incompatibleRuntimes: string[];
+}
+
+/** The calling process's runtime, resolved exactly as its queries resolve it. */
+export interface VectorRuntimeStatus {
+  /** Runtime label recorded by this caller's last query or embed. */
+  label: string | null;
+  /**
+   * vectors: queries read `partition`; unavailable: queries use lexical
+   * retrieval only; unresolved: no query or embed has resolved this caller
+   * yet (or a verdict is pending).
+   */
+  state: "vectors" | "unavailable" | "unresolved";
+  partition: string | null;
+  reason?: string;
+}
+
+const activated = (p: Partition): boolean =>
+  p.state === "active" && p.activated_epoch !== null;
+
+/** Apply retrieval's selection to the caller recorded for this process. */
+export function vectorRuntimeStatus(
+  db: Database,
+  model: string
+): VectorRuntimeStatus {
+  const caller = recordedRuntimeCaller(db, model);
+  if (!caller) return { label: null, state: "unresolved", partition: null };
+  const use = retrievalUse(
+    db,
+    selectRuntimePartition(db, caller.identity, {
+      fingerprint: caller.runtime,
+      label: caller.label,
+    })
+  );
+  if (use.kind === "vectors")
+    return {
+      label: caller.label,
+      state: "vectors",
+      partition: identityPartitionId(use.identity),
+    };
+  return use.kind === "unavailable"
+    ? {
+        label: caller.label,
+        state: "unavailable",
+        partition: null,
+        reason: use.reason,
+      }
+    : { label: caller.label, state: "unresolved", partition: null };
+}
+
+/** The partition status counts: the caller's retrieval partition, else the fallback. */
+function countedPartition(
+  db: Database,
+  model: string,
+  candidates: Partition[],
+  selection: string | undefined
+): Partition | undefined {
+  const { partition } = vectorRuntimeStatus(db, model);
+  return (
+    candidates.find((p) => p.partition_id === partition) ??
+    retrievalPartition(db, candidates, selection)
+  );
+}
+
+/**
+ * Fallback for a caller that has not resolved yet: the activated primary first,
+ * then an activated confirmed fork, then an activated legacy one, so an
+ * incomplete shadow never reads as lost embeddings. The last embedding
+ * selection, then coverage, breaks ties within a tier.
+ */
+function retrievalPartition(
+  db: Database,
+  candidates: Partition[],
+  selection: string | undefined
+): Partition | undefined {
+  for (const tier of [
+    candidates.filter((p) => activated(p) && !p.legacy && !p.fork),
+    candidates.filter((p) => activated(p) && !p.legacy),
+    candidates.filter(activated),
+  ]) {
+    if (!tier.length) continue;
+    const selected = tier.find((p) => p.partition_id === selection);
+    if (selected) return selected;
+    let best = tier[0]!;
+    let bestOwners = currentOwnerCount(db, best.partition_id);
+    for (const partition of tier.slice(1)) {
+      const owners = currentOwnerCount(db, partition.partition_id);
+      if (owners > bestOwners) [best, bestOwners] = [partition, owners];
+    }
+    return best;
+  }
+  return selection === undefined
+    ? candidates.length === 1
+      ? candidates[0]
+      : undefined
+    : candidates.find((p) => p.partition_id === selection);
+}
+
+function readPartitions(db: Database, model: string | null): Partition[] {
+  return db
+    .query<Partition, [string | null, string | null]>(`
+      SELECT partition_id, version, model, fingerprint, dimensions, state,
+        activated_epoch, legacy, provenance, fork
+      FROM vector_partitions WHERE (? IS NULL OR model = ?)
+      ORDER BY model, partition_id
+    `)
+    .all(model, model);
+}
+
+function readSelections(db: Database): Map<string, string> {
+  return new Map(
+    db
+      .query<{ key: string; value: string }, [string]>(
+        "SELECT key, value FROM schema_meta WHERE key GLOB ?"
+      )
+      .all(`${SELECTED_VECTOR_PARTITION_PREFIX}*`)
+      .map((row) => [
+        row.key.slice(SELECTED_VECTOR_PARTITION_PREFIX.length),
+        row.value,
+      ])
+  );
+}
+
+function hasPartitionTable(db: Database): boolean {
+  return !!db
+    .query(
+      "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'vector_partitions'"
+    )
+    .get();
+}
+
+/** Every partition with its state, owners and provenance (R4). */
+export function listVectorPartitions(
+  db: Database,
+  model?: string
+): VectorPartitionStatus[] {
+  return db.transaction(() => {
+    if (!hasPartitionTable(db)) return [];
+    const partitions = readPartitions(db, model ?? null);
+    const retrieval = new Set<string>();
+    for (const name of new Set(partitions.map((p) => p.model))) {
+      const { partition } = vectorRuntimeStatus(db, name);
+      if (partition) retrieval.add(partition);
+    }
+    const runtimes = db.prepare<{ label: string }, [string, string]>(
+      "SELECT DISTINCT label FROM vector_runtime_verdicts WHERE partition_id = ? AND verdict = ? ORDER BY label"
+    );
+    return partitions.map(
+      (p): VectorPartitionStatus => ({
+        id: p.partition_id,
+        model: p.model,
+        dimensions: p.dimensions,
+        state: activated(p) ? "active" : "shadow",
+        legacy: p.legacy === 1,
+        retrieval: retrieval.has(p.partition_id),
+        // Shadows only (legacy shadows included). An activated partition may be
+        // another runtime's retrieval partition, or a legacy one awaiting its
+        // measured re-key: possibly the only copy of its vectors.
+        droppable: !retrieval.has(p.partition_id) && !activated(p),
+        owners: currentOwnerCount(db, p.partition_id),
+        provenance:
+          p.provenance ??
+          (p.legacy ? "unrecorded (pre-fn-184 key)" : "unrecorded"),
+        compatibleRuntimes: runtimes
+          .all(p.partition_id, "compatible")
+          .map((row) => row.label),
+        incompatibleRuntimes: runtimes
+          .all(p.partition_id, "incompatible")
+          .map((row) => row.label),
+      })
+    );
+  })();
 }
 
 interface OwnerCoverage {
@@ -37,31 +243,9 @@ export function getVariantStatus(
   options?: { embedModel?: string; embedFingerprint?: string }
 ): { backlog: number; embeddedByCollection: Map<string, number> } | null {
   return db.transaction(() => {
-    if (
-      !db
-        .query(
-          "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'vector_partitions'"
-        )
-        .get()
-    )
-      return null;
-    const partitions = db
-      .query<Partition, [string | null, string | null]>(`
-        SELECT partition_id, version, model, fingerprint, dimensions, state, activated_epoch
-        FROM vector_partitions WHERE (? IS NULL OR model = ?)
-      `)
-      .all(options?.embedModel ?? null, options?.embedModel ?? null);
-    const selections = db
-      .query<{ key: string; value: string }, [string]>(
-        "SELECT key, value FROM schema_meta WHERE key GLOB ?"
-      )
-      .all(`${SELECTED_VECTOR_PARTITION_PREFIX}*`);
-    const selected = new Map(
-      selections.map((row) => [
-        row.key.slice(SELECTED_VECTOR_PARTITION_PREFIX.length),
-        row.value,
-      ])
-    );
+    if (!hasPartitionTable(db)) return null;
+    const partitions = readPartitions(db, options?.embedModel ?? null);
+    const selected = readSelections(db);
     const models = new Set(partitions.map((p) => p.model));
     if (options?.embedModel) models.add(options.embedModel);
     else for (const model of selected.keys()) models.add(model);
@@ -70,20 +254,12 @@ export function getVariantStatus(
     for (const model of models) {
       const candidates = partitions.filter((p) => p.model === model);
       const selection = selected.get(model);
-      const activated = candidates.some(
-        (p) => p.state === "active" && p.activated_epoch !== null
-      );
-      if (selection === undefined && !activated) continue;
+      if (selection === undefined && !candidates.some(activated)) continue;
       authoritativeModels.add(model);
       // Resolve one persisted identity per model, never combine alternative
       // partitions of the same model. Unscoped status may accept any model.
       // Stale epochs do not revoke owners whose current inputs still match.
-      const partition =
-        selection === undefined
-          ? candidates.length === 1
-            ? candidates[0]
-            : undefined
-          : candidates.find((p) => p.partition_id === selection);
+      const partition = countedPartition(db, model, candidates, selection);
       if (
         partition &&
         partition.version === 1 &&
@@ -194,3 +370,68 @@ export function getVariantStatus(
     return { backlog, embeddedByCollection };
   })();
 }
+
+const MIN_PARTITION_PREFIX = 8;
+
+type DropResult =
+  | { ok: true; partition: VectorPartitionStatus }
+  | { ok: false; error: string };
+
+/**
+ * Remove an abandoned shadow partition (legacy included) this caller's retrieval does
+ * not use, with its vectors, owners and verdicts. Status prints its hint for
+ * exactly the same `droppable` partitions.
+ */
+export async function dropVectorPartition(
+  db: Database,
+  idPrefix: string
+): Promise<DropResult> {
+  if (idPrefix.length < MIN_PARTITION_PREFIX)
+    return {
+      ok: false,
+      error: `Give at least ${MIN_PARTITION_PREFIX} characters of the partition id (see \`gno status\`)`,
+    };
+  const vecLoaded = await loadSqliteVec(db);
+  return db
+    .transaction((): DropResult => {
+      const matches = listVectorPartitions(db).filter((p) =>
+        p.id.startsWith(idPrefix)
+      );
+      const [partition] = matches;
+      if (!partition || matches.length > 1)
+        return {
+          ok: false,
+          error: matches.length
+            ? `Partition id prefix ${idPrefix} is ambiguous`
+            : `No vector partition ${idPrefix}`,
+        };
+      if (!partition.droppable)
+        return {
+          ok: false,
+          error: partition.retrieval
+            ? `Refusing to drop partition ${partition.id.slice(0, 12)}: this runtime's retrieval uses it`
+            : `Refusing to drop active partition ${partition.id.slice(0, 12)}: other runtimes may read it, or it awaits its one-time re-key`,
+        };
+      const table = `vec_v1_${partition.id}`;
+      if (
+        !vecLoaded &&
+        db.query("SELECT 1 FROM sqlite_master WHERE name = ?").get(table)
+      )
+        return {
+          ok: false,
+          error:
+            "sqlite-vec is unavailable; cannot drop the vector index table",
+        };
+      for (const statement of [
+        "DELETE FROM vector_owners WHERE partition_id = ?",
+        "DELETE FROM vector_variants WHERE partition_id = ?",
+        "DELETE FROM vector_runtime_verdicts WHERE partition_id = ?",
+        "DELETE FROM vector_partitions WHERE partition_id = ?",
+        `DELETE FROM schema_meta WHERE key GLOB '${SELECTED_VECTOR_PARTITION_PREFIX}*' AND value = ?`,
+      ])
+        db.run(statement, [partition.id]);
+      db.exec(`DROP TABLE IF EXISTS ${table}`);
+      return { ok: true, partition };
+    })
+    .immediate();
+}

package/src/store/vector/types.ts

@@ -14,6 +14,8 @@ export interface VectorVariantIdentity {
   contextSize: number;
   truncationPolicy: string;
   dimensions: number;
+  /** Runtime fingerprint of an explicitly confirmed separate partition. */
+  fork?: string;
 }
 
 /** Snapshot carried through asynchronous embedding; write revalidates input. */

package/src/store/vector/variant-search.ts

@@ -2,34 +2,84 @@ import type { Database } from "bun:sqlite";
 
 import type { EmbeddingPort } from "../../llm/types";
 import type {
+  VectorIndexPort,
   VectorSearchOptions,
   VectorSearchResult,
   VectorVariantIdentity,
 } from "./types";
 
-import { getVariantModelFingerprint } from "../../embed/fingerprint";
 import { formatDocForEmbedding } from "../../pipeline/contextual";
 import { buildEligibleDocumentQuery } from "../sqlite/eligibility";
-import { encodeEmbedding } from "./sqlite-vec";
-import { embeddingInputHash, vectorVariantFingerprint } from "./variants";
+import {
+  embeddingPartitionIdentity,
+  identityPartitionId,
+  resolveRuntimePartition,
+  retrievalUse,
+} from "./runtime-compat";
+import { encodeEmbedding, getVectorIndexDatabase } from "./sqlite-vec";
+import { embeddingInputHash } from "./variants";
 
-/** Call after query embedding initialized the port; never infer runtime policy. */
-export function resolveVectorSearchIdentity(
-  port: EmbeddingPort
-): VectorVariantIdentity | undefined {
-  const identity = port.getIdentity?.();
-  if (!identity) return undefined;
-  const dimensions = port.dimensions();
-  return {
-    model: port.modelUri,
-    modelFingerprint: getVariantModelFingerprint(
-      { modelUri: port.modelUri, dimensions },
-      identity
-    ),
-    contextSize: identity.contextSize,
-    truncationPolicy: identity.truncationPolicy,
-    dimensions,
-  };
+/** Fallback/warning code: this runtime may not read the activated vectors. */
+export const VECTOR_RUNTIME_INCOMPATIBLE = "vector_runtime_incompatible";
+
+export type SearchPartition =
+  | { identity?: VectorVariantIdentity; unavailable?: undefined }
+  | {
+      identity?: undefined;
+      /** Why this runtime cannot read vectors; callers phrase the fallback. */
+      unavailable: { reason: string; building: boolean };
+    };
+
+/**
+ * Call after query embedding initialized the port. A runtime that cannot use
+ * an activated partition gets a reason instead of an identity; vector spaces
+ * are never mixed.
+ */
+export async function resolveVectorSearchIdentity(
+  port: EmbeddingPort,
+  vectorIndex: VectorIndexPort
+): Promise<SearchPartition> {
+  const primary = embeddingPartitionIdentity(port);
+  const db = getVectorIndexDatabase(vectorIndex);
+  if (!primary || !db) return { identity: primary };
+  let resolved;
+  try {
+    resolved = await resolveRuntimePartition(db, port, primary);
+  } catch (cause) {
+    return {
+      unavailable: {
+        reason: `the runtime compatibility check failed (${cause instanceof Error ? cause.message : String(cause)})`,
+        building: false,
+      },
+    };
+  }
+  const use = retrievalUse(
+    db,
+    resolved.blocked
+      ? { kind: "blocked", ...resolved.blocked }
+      : { kind: "use", identity: resolved.identity, verdict: resolved.verdict }
+  );
+  if (use.kind === "unavailable")
+    return { unavailable: { reason: use.reason, building: use.building } };
+  return { identity: resolved.identity };
+}
+
+/** Result notice for hybrid retrieval, which falls back to lexical. */
+export function lexicalFallbackNotice(
+  unavailable: NonNullable<SearchPartition["unavailable"]>
+): string {
+  return `Semantic search unavailable for this runtime: ${unavailable.reason}. Using lexical retrieval only; ${unavailable.building ? "finish it with `gno embed`" : "see `gno status`"}.`;
+}
+
+/** vsearch cannot fall back; it says what the caller can do instead. */
+export function vectorSearchUnavailableMessage(
+  unavailable: NonNullable<SearchPartition["unavailable"]>
+): string {
+  return `Vector search unavailable for this runtime: ${unavailable.reason}. ${
+    unavailable.building
+      ? "Finish the partition with `gno embed`, or use `gno query` / `gno search`."
+      : "Use `gno query` or `gno search`, or build a separate partition with `gno embed --new-partition`."
+  }`;
 }
 
 /** Null means legacy authority. Once promoted, unavailable provenance fails closed. */
@@ -66,9 +116,7 @@ function searchVectorVariantsInSnapshot(
     embedding.length !== dimensions
   )
     throw new Error("Query embedding identity does not match vector index");
-  const partitionId = embeddingInputHash(
-    JSON.stringify([model, vectorVariantFingerprint(identity), dimensions])
-  );
+  const partitionId = identityPartitionId(identity);
   const partition = db
     .query<{ state: string; activated_epoch: number | null }, [string]>(
       "SELECT state, activated_epoch FROM vector_partitions WHERE partition_id = ?"

package/src/store/vector/variants.ts

@@ -22,10 +22,30 @@ export function vectorVariantFingerprint(
       identity.modelFingerprint,
       identity.contextSize,
       identity.truncationPolicy,
+      ...(identity.fork ? [identity.fork] : []),
     ])
   );
 }
 
+export function vectorPartitionId(
+  model: string,
+  fingerprint: string,
+  dimensions: number
+): string {
+  return embeddingInputHash(JSON.stringify([model, fingerprint, dimensions]));
+}
+
+/** Storage stays usable without sqlite-vec; search and activation need it. */
+export async function loadSqliteVec(db: Database): Promise<boolean> {
+  try {
+    const sqliteVec = await import("sqlite-vec");
+    sqliteVec.load(db);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 interface OwnerRow {
   documentId: number;
   mirrorHash: string;
@@ -49,7 +69,9 @@ export class VectorVariantStore {
   constructor(
     private readonly db: Database,
     identity: VectorVariantIdentity,
-    readonly searchAvailable: boolean
+    readonly searchAvailable: boolean,
+    /** Readable label of the runtime that creates the partition. */
+    provenance?: string
   ) {
     if (
       !identity.model ||
@@ -64,19 +86,26 @@ export class VectorVariantStore {
     }
     this.identity = Object.freeze({ ...identity });
     this.fingerprint = vectorVariantFingerprint(identity);
-    this.partitionId = embeddingInputHash(
-      JSON.stringify([identity.model, this.fingerprint, identity.dimensions])
+    this.partitionId = vectorPartitionId(
+      identity.model,
+      this.fingerprint,
+      identity.dimensions
     );
     this.tableName = `vec_v1_${this.partitionId}`;
     db.transaction(() => {
       db.run(
         `INSERT OR IGNORE INTO vector_partitions
-        (partition_id, version, model, fingerprint, dimensions) VALUES (?, 1, ?, ?, ?)`,
+        (partition_id, version, model, fingerprint, dimensions, provenance,
+          base_fingerprint, fork)
+        VALUES (?, 1, ?, ?, ?, ?, ?, ?)`,
         [
           this.partitionId,
           identity.model,
           this.fingerprint,
           identity.dimensions,
+          provenance ?? null,
+          vectorVariantFingerprint({ ...identity, fork: undefined }),
+          identity.fork ?? null,
         ]
       );
       if (searchAvailable) {
@@ -349,6 +378,14 @@ export class VectorVariantStore {
           `UPDATE vector_partitions SET state = 'active', activated_epoch = ? WHERE partition_id = ?`,
           [expectedEpoch, this.partitionId]
         );
+        // A complete runtime-independent partition supersedes the pre-fn-184
+        // partitions of its vector space, as the one-time re-key does.
+        if (!this.identity.fork)
+          this.db.run(
+            `UPDATE vector_partitions SET state = 'shadow', activated_epoch = NULL
+            WHERE legacy = 1 AND model = ? AND dimensions = ?`,
+            [this.identity.model, this.identity.dimensions]
+          );
       })
       .immediate();
   }
@@ -448,15 +485,13 @@ export class VectorVariantStore {
 
 export async function createVectorVariantStore(
   db: Database,
-  identity: VectorVariantIdentity
+  identity: VectorVariantIdentity,
+  provenance?: string
 ): Promise<VectorVariantStore> {
-  let searchAvailable = false;
-  try {
-    const sqliteVec = await import("sqlite-vec");
-    sqliteVec.load(db);
-    searchAvailable = true;
-  } catch {
-    // Storage remains usable offline; activation waits for a materialized index.
-  }
-  return new VectorVariantStore(db, identity, searchAvailable);
+  return new VectorVariantStore(
+    db,
+    identity,
+    await loadSqliteVec(db),
+    provenance
+  );
 }

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

@@ -1 +0,0 @@
-80268befd10f0f0d79796dacb845d840b3b3e691d265bdb17e54f3e86b5209ff  gno-browser-clipper-v2.6.0.zip