@gmickel/gno 2.7.1 → 2.8.1

package/src/store/types.ts

@@ -20,6 +20,7 @@ import type {
   FileRefactorRecoveryReceipt,
   FileRefactorRecoveryReceiptDraft,
 } from "../core/file-refactor-journal";
+import type { LinkWorkspaceSource } from "../core/link-workspace";
 import type { MetadataPredicate, TypedMetadata } from "../core/typed-metadata";
 import type {
   ChunkingPolicyToken,
@@ -113,6 +114,14 @@ export interface CollectionRow {
   egressPolicy: EgressPolicy;
   /** Whether policy was explicit or supplied by a safe default. */
   egressPolicySource: EgressPolicySource;
+  /** Canonical collection root (real path), when resolvable. */
+  realPath?: string | null;
+  /** Effective link workspace root; null means collection-scoped links. */
+  workspaceRoot?: string | null;
+  /** How the workspace root was established. */
+  workspaceSource?: LinkWorkspaceSource;
+  /** Collection-relative prefixes of nested vaults with their own workspace. */
+  workspaceNested?: string[];
   syncedAt: string;
 }
 
@@ -351,6 +360,8 @@ export interface BacklinkRow {
   sourceDocUri: string;
   /** Source document title */
   sourceDocTitle: string | null;
+  /** Collection of the source document */
+  sourceCollection?: string;
   /** Link display text */
   linkText: string | null;
   /** 1-based line number in source */
@@ -731,6 +742,11 @@ export interface FtsSearchOptions extends DocumentEligibilityOptions {
   snippet?: boolean;
   /** Match documents containing ANY positive term instead of ALL of them. */
   anyTerm?: boolean;
+  /**
+   * Drop rows whose raw BM25 score is below this fraction (0-1) of the best
+   * row's score, so matches carried only by near-zero-IDF terms fall away.
+   */
+  minRelativeScore?: number;
 }
 
 /** Managed-memory eligibility query (unbounded, executed in one SQL query). */
@@ -793,6 +809,10 @@ export interface CollectionStatus {
   egressPolicy: EgressPolicy;
   /** Whether policy was explicit or supplied by a safe default. */
   egressPolicySource: EgressPolicySource;
+  /** Effective link workspace root (host path); null when collection-scoped. */
+  workspaceRoot?: string | null;
+  /** How the link workspace was established. */
+  workspaceSource?: LinkWorkspaceSource;
   totalDocuments: number;
   activeDocuments: number;
   errorDocuments: number;
@@ -818,11 +838,11 @@ export interface IndexStatus {
   ftsTokenizer: FtsTokenizer;
   /** Per-collection status */
   collections: CollectionStatus[];
-  /** Total documents across all collections */
+  /** Total documents across the reported collections */
   totalDocuments: number;
   /** Active (non-deleted) documents */
   activeDocuments: number;
-  /** Total chunks across all collections */
+  /** Distinct chunks of active documents across the reported collections */
   totalChunks: number;
   /** Chunks without embeddings */
   embeddingBacklog: number;
@@ -876,6 +896,10 @@ export interface GraphEdgeAudit {
   resolution:
     | "exact-title"
     | "exact-path"
+    /** Only file with that name (or path suffix) in its link workspace. */
+    | "exact-name"
+    /** Won over same-named files by the same-folder / shallower tie-break. */
+    | "tie-break"
     | "path-fallback"
     | "ambiguous-fallback"
     | "similarity";
@@ -1058,6 +1082,8 @@ export interface GetGraphOptions {
   linkedOnly?: boolean;
   /** Top-K similar docs per node (default 5, clamped 1-20) */
   similarTopK?: number;
+  /** Embedding model whose stored vectors score similarity edges */
+  embedModel?: string;
 }
 
 /** Options for seed-scoped one-hop graph neighbor lookup (query-time expansion). */
@@ -1066,6 +1092,12 @@ export interface GetGraphNeighborsOptions {
   seedDocumentIds: number[];
   /** Filter neighbors to a single collection */
   collection?: string;
+  /**
+   * Graph allowlist: every edge's resolved source and target must be in one
+   * of these collections. Takes precedence over `collection`; empty denies
+   * all. Undefined (with no `collection`) is unrestricted.
+   */
+  collections?: string[];
   /** Max edges to return (default 10000) */
   limitEdges?: number;
 }
@@ -1113,6 +1145,11 @@ export interface GraphQueryEdge {
 export interface GraphQueryOptions {
   direction?: GraphQueryDirection;
   edgeType?: DocEdgeType;
+  /**
+   * Collection allowlist: only documents in these collections are visited
+   * (the root must be in scope too). Undefined means every collection.
+   */
+  collections?: string[];
   maxDepth?: number;
   maxNodes?: number;
   frontierLimit?: number;
@@ -1599,6 +1636,14 @@ export interface StorePort {
    */
   getCollections(): Promise<StoreResult<CollectionRow[]>>;
 
+  /**
+   * Re-detect nested vaults below a collection root from its indexed
+   * document directories; returns whether stored membership changed.
+   */
+  refreshCollectionNestedWorkspaces?(
+    collection: string
+  ): Promise<StoreResult<boolean>>;
+
   /**
    * Get all contexts from DB.
    */
@@ -2242,18 +2287,26 @@ export interface StorePort {
   ): Promise<StoreResult<BacklinkRow[]>>;
 
   /**
-   * Resolve link targets to their documents.
-   * Returns array of resolved docs (or null for unresolved) matching input order.
+   * Resolve link targets to their documents with the shared link resolver.
+   * With `source`, plain wiki links from a document inside a link workspace
+   * resolve across the workspace. Returns resolved docs (or null for
+   * unresolved and tied links) matching input order.
    */
   resolveLinks(
     targets: Array<{
       targetRefNorm: string;
       targetCollection: string;
       linkType: "wiki" | "markdown";
+      source?: { collection: string; relPath: string; explicit: boolean };
     }>
   ): Promise<
     StoreResult<
-      Array<{ docid: string; uri: string; title: string | null } | null>
+      Array<{
+        docid: string;
+        uri: string;
+        title: string | null;
+        collection?: string;
+      } | null>
     >
   >;
 
@@ -2340,6 +2393,12 @@ export interface StorePort {
     embedModel?: string;
     embedFingerprint?: string;
     chunking?: Partial<ChunkingParams>;
+    /**
+     * Configured collection names. When given, the collection list and the
+     * document/chunk totals cover only these collections, so a collection
+     * removed from config stops being reported before its rows are pruned.
+     */
+    configuredCollections?: readonly string[];
   }): Promise<StoreResult<IndexStatus>>;
 
   // ─────────────────────────────────────────────────────────────────────────

package/src/store/vector/stats.ts

@@ -34,7 +34,7 @@ export function createVectorStatsPort(db: Database): VectorStatsPort {
       return {
         sql: `
           EXISTS (
-            SELECT 1 FROM documents d
+            SELECT 1 FROM documents d INDEXED BY idx_documents_mirror_hash
             WHERE d.mirror_hash = c.mirror_hash AND d.active = 1 AND d.collection = ?
           )
         `,

package/src/store/vector/status.ts

@@ -148,6 +148,33 @@ function retrievalPartition(
     : candidates.find((p) => p.partition_id === selection);
 }
 
+/**
+ * The activated partition that stored-vector readers (document similarity)
+ * use for `model`, chosen as status counts it. Undefined leaves legacy
+ * `content_vectors` authority, exactly as vector search does before any
+ * partition activates.
+ */
+export function storedVectorPartition(
+  db: Database,
+  model: string
+): { partitionId: string; dimensions: number } | undefined {
+  return db.transaction(() => {
+    if (!hasPartitionTable(db)) return undefined;
+    const partition = countedPartition(
+      db,
+      model,
+      readPartitions(db, model),
+      readSelections(db).get(model)
+    );
+    return partition && activated(partition)
+      ? {
+          partitionId: partition.partition_id,
+          dimensions: partition.dimensions,
+        }
+      : undefined;
+  })();
+}
+
 function readPartitions(db: Database, model: string | null): Partition[] {
   return db
     .query<Partition, [string | null, string | null]>(`

package/src/store/vector/stored-vectors.ts

@@ -0,0 +1,158 @@
+/**
+ * Stored document vectors for document-to-document similarity. Reads the
+ * activated vector partition (legacy `content_vectors` only before any
+ * partition activates) and never loads an embedding model.
+ *
+ * @module src/store/vector/stored-vectors
+ */
+import type { Database } from "bun:sqlite";
+
+import type { VectorSearchResult } from "./types";
+
+import { formatDocForEmbedding } from "../../pipeline/contextual";
+import { decodeEmbedding } from "./sqlite-vec";
+import { storedVectorPartition } from "./status";
+import { embeddingInputHash } from "./variants";
+
+export type StoredVectorSource =
+  | {
+      kind: "partition";
+      model: string;
+      partitionId: string;
+      dimensions: number;
+    }
+  | { kind: "legacy"; model: string };
+
+export function resolveStoredVectorSource(
+  db: Database,
+  model: string
+): StoredVectorSource {
+  const partition = storedVectorPartition(db, model);
+  return partition
+    ? { kind: "partition", model, ...partition }
+    : { kind: "legacy", model };
+}
+
+/** Search options that keep a similarity search in the source's vector space. */
+export function storedVectorSearchOptions(source: StoredVectorSource): {
+  partitionId?: string;
+} {
+  return source.kind === "partition" ? { partitionId: source.partitionId } : {};
+}
+
+export interface StoredVectorDocument {
+  id: number;
+  mirrorHash: string;
+}
+
+interface PartitionVectorRow {
+  documentId: number;
+  text: string;
+  title: string | null;
+  inputHash: string;
+  embedding: Uint8Array;
+}
+
+/**
+ * Chunk vectors of current active documents, ordered by chunk seq, keyed by
+ * document id. Partition vectors count only while their owner still yields
+ * the stored input (the rule vector search applies). `firstChunkOnly` keeps
+ * the lowest-seq vector per document.
+ */
+export function readStoredDocumentVectors(
+  db: Database,
+  source: StoredVectorSource,
+  documents: StoredVectorDocument[],
+  options: { firstChunkOnly?: boolean } = {}
+): Map<number, Float32Array[]> {
+  const vectors = new Map<number, Float32Array[]>();
+  const add = (documentId: number, blob: Uint8Array): void => {
+    const existing = vectors.get(documentId);
+    if (existing && options.firstChunkOnly) return;
+    const embedding = decodeEmbedding(blob);
+    if (existing) existing.push(embedding);
+    else vectors.set(documentId, [embedding]);
+  };
+  if (documents.length === 0) return vectors;
+
+  if (source.kind === "partition") {
+    const rows = db
+      .query<PartitionVectorRow, [string, string]>(`
+        SELECT o.document_id AS documentId, c.text, d.title,
+          v.input_hash AS inputHash, v.embedding
+        FROM vector_owners o
+        JOIN documents d ON d.id = o.document_id AND d.active = 1
+          AND d.mirror_hash = o.mirror_hash
+        JOIN content_chunks c ON c.mirror_hash = o.mirror_hash AND c.seq = o.seq
+        JOIN vector_variants v ON v.variant_id = o.variant_id
+          AND v.partition_id = o.partition_id
+        WHERE o.partition_id = ?
+          AND o.document_id IN (SELECT value FROM json_each(?))
+        ORDER BY o.document_id, o.seq
+      `)
+      .all(
+        source.partitionId,
+        JSON.stringify(documents.map((document) => document.id))
+      );
+    for (const row of rows) {
+      if (options.firstChunkOnly && vectors.has(row.documentId)) continue;
+      const input = formatDocForEmbedding(
+        row.text,
+        row.title ?? undefined,
+        source.model
+      );
+      if (row.inputHash === embeddingInputHash(input))
+        add(row.documentId, row.embedding);
+    }
+    return vectors;
+  }
+
+  const idsByMirror = new Map<string, number[]>();
+  for (const document of documents) {
+    const ids = idsByMirror.get(document.mirrorHash);
+    if (ids) ids.push(document.id);
+    else idsByMirror.set(document.mirrorHash, [document.id]);
+  }
+  const rows = db
+    .query<{ mirrorHash: string; embedding: Uint8Array }, [string, string]>(`
+      SELECT mirror_hash AS mirrorHash, embedding FROM content_vectors
+      WHERE model = ? AND mirror_hash IN (SELECT value FROM json_each(?))
+      ORDER BY mirror_hash, seq
+    `)
+    .all(source.model, JSON.stringify([...idsByMirror.keys()]));
+  for (const row of rows) {
+    for (const id of idsByMirror.get(row.mirrorHash) ?? [])
+      add(id, row.embedding);
+  }
+  return vectors;
+}
+
+/**
+ * Candidate documents of similarity search hits, in hit order. Partition hits
+ * name their exact owners (a title is part of the embedded input, so documents
+ * sharing content can hold different vectors); only those owners count, and
+ * an owner without its own vector never inherits another's score. Legacy
+ * `content_vectors` hits carry no owners and map to the first document with
+ * that content, as before.
+ */
+export function similarityHitDocuments<
+  T extends { id: number; mirrorHash: string | null },
+>(
+  hits: VectorSearchResult[],
+  documents: T[]
+): Array<{ document: T; distance: number }> {
+  const byId = new Map(documents.map((document) => [document.id, document]));
+  const byHash = new Map<string, T>();
+  for (const document of documents) {
+    if (document.mirrorHash && !byHash.has(document.mirrorHash))
+      byHash.set(document.mirrorHash, document);
+  }
+  return hits.flatMap((hit) => {
+    const owners = hit.documentIds
+      ? hit.documentIds.map((id) => byId.get(id))
+      : [byHash.get(hit.mirrorHash)];
+    return owners.flatMap((document) =>
+      document ? [{ document, distance: hit.distance }] : []
+    );
+  });
+}

package/src/store/vector/types.ts

@@ -43,6 +43,12 @@ export interface VectorRow {
 
 export interface VectorSearchOptions {
   embeddingIdentity?: VectorVariantIdentity;
+  /**
+   * Search this activated stored partition directly. Document-to-document
+   * similarity reuses a stored vector, so no runtime identity applies; the
+   * partition must match the port's model and dimensions.
+   */
+  partitionId?: string;
   minScore?: number;
   allowedMirrorHashes?: string[];
   /** Exact active owner/chunk domain, applied before the nearest-neighbor budget. */

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

@@ -103,27 +103,43 @@ function searchVectorVariantsInSnapshot(
     )
     .get(model);
   const identity = options.embeddingIdentity;
-  if (!identity) {
-    if (activated)
-      throw new Error(
-        "Effective embedding identity unavailable after variant activation"
-      );
-    return null;
+  let partitionId: string;
+  if (options.partitionId !== undefined) {
+    const stored = db
+      .query<{ model: string; dimensions: number }, [string]>(
+        "SELECT model, dimensions FROM vector_partitions WHERE partition_id = ?"
+      )
+      .get(options.partitionId);
+    if (
+      stored?.model !== model ||
+      stored.dimensions !== dimensions ||
+      embedding.length !== dimensions
+    )
+      throw new Error("Stored vector partition does not match vector index");
+    partitionId = options.partitionId;
+  } else {
+    if (!identity) {
+      if (activated)
+        throw new Error(
+          "Effective embedding identity unavailable after variant activation"
+        );
+      return null;
+    }
+    if (
+      identity.model !== model ||
+      identity.dimensions !== dimensions ||
+      embedding.length !== dimensions
+    )
+      throw new Error("Query embedding identity does not match vector index");
+    partitionId = identityPartitionId(identity);
   }
-  if (
-    identity.model !== model ||
-    identity.dimensions !== dimensions ||
-    embedding.length !== dimensions
-  )
-    throw new Error("Query embedding identity does not match vector index");
-  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 = ?"
     )
     .get(partitionId);
   if (partition?.state !== "active" || partition.activated_epoch === null) {
-    if (activated)
+    if (activated || options.partitionId !== undefined)
       throw new Error(
         "Selected embedding variant partition has not activated; run gno embed"
       );

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

@@ -1 +0,0 @@
-0566f9eb5eb5db6a1632063e63f37dab01a9d2a0aa3dde5658356926a53c395e  gno-browser-clipper-v2.7.1.zip