@gmickel/gno 2.6.0 → 2.7.0

package/src/serve/watch-service-run-flush.ts

@@ -14,6 +14,7 @@ import type { WatchQueueHost } from "./watch-service-events";
 import type { CollectionPending } from "./watch-service-state";
 import type { WatcherSnapshot, WatcherSnapshotFs } from "./watch-snapshot";
 
+import { WATCHER_LEASE_RETRY_MS } from "./watch-reconciliation-shared";
 import {
   requeueAfterFailure,
   requeueGenerationReconcile,
@@ -65,6 +66,11 @@ export interface RunFlushContext {
   snapshotFs?: WatcherSnapshotFs;
   /** Test seam: lower snapshot entry ceiling for overflow→full proofs. */
   snapshotEntryCeiling?: number;
+  /**
+   * Shared writer lease for this flush; null when another writer holds it,
+   * which leaves the work queued for the retry timer instead of waiting.
+   */
+  acquireWriteLease?: () => Promise<(() => Promise<void>) | null>;
 }
 
 /**
@@ -86,19 +92,44 @@ export async function runOwnedCollectionFlush(
     return;
   }
 
+  ctx.syncing.add(collectionName);
+  let releaseLease: (() => Promise<void>) | null = null;
+  if (ctx.acquireWriteLease) {
+    releaseLease = await ctx.acquireWriteLease();
+    if (!releaseLease || ctx.disposed()) {
+      ctx.syncing.delete(collectionName);
+      await releaseLease?.();
+      if (!ctx.disposed()) {
+        requeueAfterFailure(
+          ctx.queueHost,
+          collectionName,
+          [],
+          [],
+          undefined,
+          WATCHER_LEASE_RETRY_MS
+        );
+      }
+      return;
+    }
+  }
+
   const collection = ctx
     .collections()
     .find((entry) => entry.name === collectionName);
   if (!collection) {
+    await releaseLease?.();
+    ctx.syncing.delete(collectionName);
     ctx.pendingByCollection.delete(collectionName);
     ctx.flushDeadlineAt.delete(collectionName);
     return;
   }
 
-  const taken = takePending(pending);
+  // Events that arrived while the lease was being taken join this flush.
+  const taken = takePending(
+    ctx.pendingByCollection.get(collectionName) ?? pending
+  );
   ctx.pendingByCollection.set(collectionName, emptyPending());
   ctx.flushDeadlineAt.delete(collectionName);
-  ctx.syncing.add(collectionName);
 
   const ownerGeneration = ctx.collectionGenerations.get(collectionName) ?? 0;
   const ownerRoot = normalize(collection.path);
@@ -219,6 +250,8 @@ export async function runOwnedCollectionFlush(
       throw outcome.error;
     }
   } finally {
+    // Release before any follow-up flush below tries to take the lease again.
+    await releaseLease?.();
     ctx.syncing.delete(collectionName);
     ctx.clearLifecycleTombstones(collectionName);
     ctx.pruneSuppression();

package/src/serve/watch-service.ts

@@ -108,6 +108,8 @@ interface CollectionWatchServiceOptions {
    * Production leaves this unset (uses WATCHER_SNAPSHOT_ENTRY_CEILING).
    */
   snapshotEntryCeiling?: number;
+  /** Shared writer lease taken (no wait) around each flush's writes. */
+  acquireWriteLease?: () => Promise<(() => Promise<void>) | null>;
 }
 
 export class CollectionWatchService {
@@ -146,6 +148,7 @@ export class CollectionWatchService {
     | undefined;
   readonly #snapshotFs: WatcherSnapshotFs | undefined;
   readonly #snapshotEntryCeiling: number | undefined;
+  readonly #acquireWriteLease: CollectionWatchServiceOptions["acquireWriteLease"];
   #nextCollectionGeneration = 0;
   #disposed = false;
   #lastEventAt: string | null = null;
@@ -169,6 +172,7 @@ export class CollectionWatchService {
     this.#buildSnapshot = options.buildSnapshot;
     this.#snapshotFs = options.snapshotFs;
     this.#snapshotEntryCeiling = options.snapshotEntryCeiling;
+    this.#acquireWriteLease = options.acquireWriteLease;
   }
 
   start(): void {
@@ -394,6 +398,7 @@ export class CollectionWatchService {
       },
       snapshotFs: this.#snapshotFs,
       snapshotEntryCeiling: this.#snapshotEntryCeiling,
+      acquireWriteLease: this.#acquireWriteLease,
     });
   }
 

package/src/store/migrations/031-runtime-independent-vectors.ts

@@ -0,0 +1,29 @@
+/** Runtime details become provenance; existing partitions await measured re-keying. */
+import type { Migration } from "./runner";
+
+export const migration: Migration = {
+  version: 31,
+  name: "runtime_independent_vectors",
+  up(db): void {
+    db.exec(`
+      ALTER TABLE vector_partitions ADD COLUMN provenance TEXT;
+      ALTER TABLE vector_partitions ADD COLUMN legacy INTEGER NOT NULL DEFAULT 0;
+      -- Vector-defining key shared by a primary and its confirmed forks.
+      ALTER TABLE vector_partitions ADD COLUMN base_fingerprint TEXT;
+      -- Runtime fingerprint of a confirmed separate partition; NULL = primary.
+      ALTER TABLE vector_partitions ADD COLUMN fork TEXT;
+      UPDATE vector_partitions SET legacy = 1;
+      CREATE TABLE vector_runtime_verdicts (
+        partition_id TEXT NOT NULL,
+        runtime TEXT NOT NULL,
+        label TEXT NOT NULL,
+        verdict TEXT NOT NULL CHECK (verdict IN ('compatible', 'incompatible')),
+        min_cosine REAL NOT NULL,
+        samples INTEGER NOT NULL CHECK (samples >= 0),
+        sample_ms REAL NOT NULL,
+        PRIMARY KEY (partition_id, runtime)
+      );
+
+    `);
+  },
+};

package/src/store/migrations/032-vector-runtime-callers.ts

@@ -0,0 +1,17 @@
+/** Identity each caller (process runtime + env) last resolved, for status. */
+import type { Migration } from "./runner";
+
+export const migration: Migration = {
+  version: 32,
+  name: "vector_runtime_callers",
+  up(db): void {
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS vector_runtime_callers (
+        caller TEXT PRIMARY KEY,
+        runtime TEXT NOT NULL,
+        label TEXT NOT NULL,
+        identity TEXT NOT NULL
+      );
+    `);
+  },
+};

package/src/store/migrations/index.ts

@@ -44,6 +44,8 @@ import { migration as m027 } from "./027-memory-scopes";
 import { migration as m028 } from "./028-vector-variants";
 import { migration as m029 } from "./029-graph-reference-state";
 import { migration as m030 } from "./030-typed-metadata";
+import { migration as m031 } from "./031-runtime-independent-vectors";
+import { migration as m032 } from "./032-vector-runtime-callers";
 
 /** All migrations in order */
 export const migrations = [
@@ -77,4 +79,6 @@ export const migrations = [
   m028,
   m029,
   m030,
+  m031,
+  m032,
 ];

package/src/store/sqlite/adapter.ts

@@ -158,7 +158,11 @@ import { getSchemaVersion, migrations, runMigrations } from "../migrations";
 import { err, ok } from "../types";
 import { getStoredEmbeddingFingerprint } from "../vector/freshness";
 import { modelTableName } from "../vector/sqlite-vec";
-import { getVariantStatus } from "../vector/status";
+import {
+  getVariantStatus,
+  listVectorPartitions,
+  vectorRuntimeStatus,
+} from "../vector/status";
 import {
   deleteSavedCapsuleRegistration as deleteStoredSavedCapsuleRegistration,
   getSavedCapsuleRegistration as getStoredSavedCapsuleRegistration,
@@ -711,6 +715,11 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
     }
   }
 
+  /** Set this connection's SQLite busy_timeout (resident event-loop bound). */
+  setBusyTimeout(ms: number): void {
+    this.db?.exec(`PRAGMA busy_timeout = ${Math.max(0, Math.floor(ms))}`);
+  }
+
   /** Cap subsequent SQLite lock waits to the resident settlement deadline. */
   beginShutdown(deadline: number): void {
     this.shutdownDeadline = deadline;
@@ -5893,6 +5902,10 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
         (embedModel ? getStoredEmbeddingFingerprint(db, embedModel) : null);
 
       const variantStatus = getVariantStatus(db, options);
+      const vectorPartitions = listVectorPartitions(
+        db,
+        embedModel ?? undefined
+      );
 
       // Get version
       const versionRow = db
@@ -6077,6 +6090,14 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
             ? (variantStatus.embeddedByCollection.get(s.name) ?? 0)
             : s.embedded_count,
         })),
+        ...(vectorPartitions.length
+          ? {
+              vectorPartitions,
+              ...(embedModel
+                ? { vectorRuntime: vectorRuntimeStatus(db, embedModel) }
+                : {}),
+            }
+          : {}),
         totalDocuments: totalsRow?.total ?? 0,
         activeDocuments: totalsRow?.active ?? 0,
         totalChunks: chunkCount,

package/src/store/types.ts

@@ -26,6 +26,10 @@ import type {
   ChunkingStatus,
   PendingChunkingMirror,
 } from "./chunking";
+import type {
+  VectorPartitionStatus,
+  VectorRuntimeStatus,
+} from "./vector/status";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Error Types
@@ -61,7 +65,9 @@ export type StoreErrorCode =
   | "VEC_SEARCH_UNAVAILABLE"
   | "VEC_SEARCH_FAILED"
   | "VEC_REBUILD_FAILED"
-  | "VEC_SYNC_FAILED";
+  | "VEC_SYNC_FAILED"
+  /** Embedding would build a separate vector partition without confirmation. */
+  | "VECTOR_PARTITION_FORK";
 
 /** Store error with structured details */
 export interface StoreError {
@@ -820,6 +826,10 @@ export interface IndexStatus {
   totalChunks: number;
   /** Chunks without embeddings */
   embeddingBacklog: number;
+  /** Vector partitions of the status model; counts use the `retrieval` one. */
+  vectorPartitions?: VectorPartitionStatus[];
+  /** This process's runtime, resolved by retrieval's own selection rule. */
+  vectorRuntime?: VectorRuntimeStatus;
   /** Configuration and applied cached layouts; separate from source freshness. */
   chunking?: ChunkingStatus;
   /** Recent ingest errors (last 24h) */

package/src/store/vector/lazy.ts

@@ -5,7 +5,7 @@ import type { EmbeddingPort } from "../../llm/types";
 import type { VectorIndexPort } from "./types";
 
 import { getStoredEmbeddingDimensions } from "./freshness";
-import { createVectorIndexPort } from "./sqlite-vec";
+import { bindVectorIndexDatabase, createVectorIndexPort } from "./sqlite-vec";
 
 export async function createLazyVectorIndex(
   db: Database,
@@ -35,47 +35,50 @@ export async function createLazyVectorIndex(
     });
     return loading;
   };
-  return {
-    model,
-    get dimensions() {
-      return current?.dimensions ?? embedPort.dimensions();
+  return bindVectorIndexDatabase(
+    {
+      model,
+      get dimensions() {
+        return current?.dimensions ?? embedPort.dimensions();
+      },
+      get searchAvailable() {
+        return current?.searchAvailable ?? true;
+      },
+      get loadError() {
+        return current?.loadError;
+      },
+      get guidance() {
+        return current?.guidance;
+      },
+      get vecDirty() {
+        return current?.vecDirty ?? dirty;
+      },
+      set vecDirty(value) {
+        dirty = value;
+        if (current) current.vecDirty = value;
+      },
+      async upsertVectors(rows) {
+        return (await get()).upsertVectors(rows);
+      },
+      async upsertVectorsChecked(rows, checkpoint) {
+        const port = await get();
+        if (!port.upsertVectorsChecked)
+          throw new Error("Atomic vector checkpoint unavailable");
+        return port.upsertVectorsChecked(rows, checkpoint);
+      },
+      async deleteVectorsForMirror(hash) {
+        return (await get()).deleteVectorsForMirror(hash);
+      },
+      async searchNearest(embedding, k, options) {
+        return (await get()).searchNearest(embedding, k, options);
+      },
+      async rebuildVecIndex() {
+        return (await get()).rebuildVecIndex();
+      },
+      async syncVecIndex() {
+        return (await get()).syncVecIndex();
+      },
     },
-    get searchAvailable() {
-      return current?.searchAvailable ?? true;
-    },
-    get loadError() {
-      return current?.loadError;
-    },
-    get guidance() {
-      return current?.guidance;
-    },
-    get vecDirty() {
-      return current?.vecDirty ?? dirty;
-    },
-    set vecDirty(value) {
-      dirty = value;
-      if (current) current.vecDirty = value;
-    },
-    async upsertVectors(rows) {
-      return (await get()).upsertVectors(rows);
-    },
-    async upsertVectorsChecked(rows, checkpoint) {
-      const port = await get();
-      if (!port.upsertVectorsChecked)
-        throw new Error("Atomic vector checkpoint unavailable");
-      return port.upsertVectorsChecked(rows, checkpoint);
-    },
-    async deleteVectorsForMirror(hash) {
-      return (await get()).deleteVectorsForMirror(hash);
-    },
-    async searchNearest(embedding, k, options) {
-      return (await get()).searchNearest(embedding, k, options);
-    },
-    async rebuildVecIndex() {
-      return (await get()).rebuildVecIndex();
-    },
-    async syncVecIndex() {
-      return (await get()).syncVecIndex();
-    },
-  };
+    db
+  );
 }