@gmickel/gno 2.6.0 → 2.7.1

package/src/serve/routes/sessions.ts

@@ -42,6 +42,7 @@ import {
   type SessionHarness,
   type SessionImportReceipt,
   remoteSafeSessionsError,
+  SessionsError,
   type SessionsErrorCode,
   SESSIONS_VALIDATION_CODES,
 } from "../../sessions/types";
@@ -185,11 +186,14 @@ function instanceIdentity(ctxHolder: ContextHolder): {
 }
 
 /** Refuse an archive config opened against a different index (and vice versa). */
-async function assertInstanceBinding(ctxHolder: ContextHolder): Promise<void> {
+async function assertInstanceBinding(
+  ctxHolder: ContextHolder,
+  config: Config = ctxHolder.config
+): Promise<void> {
   const { configPath, indexName } = instanceIdentity(ctxHolder);
-  if (!ctxHolder.config.sessions) return;
+  if (!config.sessions) return;
   await assertSessionBinding({
-    config: ctxHolder.config,
+    config,
     configPath,
     indexName,
     dbPath: getIndexDbPath(indexName),
@@ -245,10 +249,48 @@ async function adoptConfig(
   ctxHolder.markIndexMutation?.();
 }
 
+/**
+ * Read this instance's config file, binding checked: unreadable is an error,
+ * never served stale, and a config rebound to another index is refused
+ * before it can touch this one.
+ */
+async function readConfigFile(ctxHolder: ContextHolder): Promise<Config> {
+  const loaded = await loadConfig(instanceIdentity(ctxHolder).configPath);
+  if (!loaded.ok) {
+    throw new SessionsError(
+      "SESSIONS_RUNTIME_FAILURE",
+      "The server could not read its config file; fix the file (gno doctor shows the error) and reload."
+    );
+  }
+  await assertInstanceBinding(ctxHolder, loaded.value);
+  return loaded.value;
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Handlers
 // ─────────────────────────────────────────────────────────────────────────────
 
+/**
+ * Adopt the config file when it changed underneath the running server, for
+ * example after `gno sessions source add/remove` on the same pair. Runs
+ * before the status read is admitted: adopting new collections moves the
+ * authorization epoch, which would void a read already in flight. Returns an
+ * error response, or null when the served config is current.
+ */
+export async function refreshSessionsConfig(
+  ctxHolder: ContextHolder,
+  store: SqliteAdapter
+): Promise<Response | null> {
+  try {
+    const config = await readConfigFile(ctxHolder);
+    if (Bun.deepEquals(config, ctxHolder.config)) return null;
+    await adoptConfig(ctxHolder, store, config);
+    return null;
+  } catch (error) {
+    return sessionsErrorResponse(error);
+  }
+}
+
 /** GET /api/sessions/status */
 export async function handleSessionsStatus(
   ctxHolder: ContextHolder
@@ -427,8 +469,22 @@ export async function handleSessionsRemoveSource(
   try {
     const { configPath } = instanceIdentity(ctxHolder);
     await assertInstanceBinding(ctxHolder);
-    const config = await removeSessionSource({ configPath, id });
-    await adoptConfig(ctxHolder, store, config);
+    const config = await removeSessionSource({ configPath, id }).catch(
+      (error: unknown) => {
+        // Already unregistered (for example from the CLI): the goal holds.
+        if (
+          error instanceof SessionsError &&
+          error.code === "SESSIONS_UNKNOWN_SOURCE"
+        ) {
+          return readConfigFile(ctxHolder);
+        }
+        throw error;
+      }
+    );
+    // A no-op remove leaves the served config current; adopting it anyway
+    // would reset the egress policy under concurrent reads.
+    if (!Bun.deepEquals(config, ctxHolder.config))
+      await adoptConfig(ctxHolder, store, config);
   } catch (error) {
     return sessionsErrorResponse(error);
   }

package/src/serve/server.ts

@@ -1,11 +1,4 @@
 import type { HttpGatewayOverrides } from "../mcp/http-security";
-/**
- * Bun.serve() web server for GNO web UI.
- * Uses Bun's fullstack dev server with HTML imports.
- * Opens DB once at startup, closes on shutdown.
- *
- * @module src/serve/server
- */
 import type { RequestPeerServer } from "./request-locality";
 import type { ResidentRuntime } from "./resident-runtime";
 import type { ContextHolder } from "./routes/api";
@@ -23,6 +16,14 @@ import {
   handlePdfjsVendorRequest,
   isPdfjsVendorPath,
 } from "./fn112-routes";
+/**
+ * Bun.serve() web server for GNO web UI.
+ * Uses Bun's fullstack dev server with HTML imports.
+ * Opens DB once at startup, closes on shutdown.
+ *
+ * @module src/serve/server
+ */
+import { withRemoteHostPathRedaction } from "./host-path-redaction";
 import { PDFJS_ASSET_CACHE_CONTROL } from "./pdfjs-assets";
 // HTML import - Bun handles bundling TSX/CSS automatically via routes
 import homepage from "./public/index.html";
@@ -115,6 +116,7 @@ import {
   handleSessionsInit,
   handleSessionsRemoveSource,
   handleSessionsStatus,
+  refreshSessionsConfig,
 } from "./routes/sessions";
 
 /** `/api/sessions/automation/:id[/...]` path parameter. */
@@ -571,7 +573,7 @@ export async function startServer(
       development: isDev,
 
       // Static routes - Bun handles HTML bundling and /_bun/* assets automatically
-      routes: {
+      routes: withRemoteHostPathRedaction({
         "/mcp": gateway.route,
         ...clipperRoutesForBind(
           isHttpGatewayLoopbackBind(gatewayConfig.host),
@@ -860,9 +862,10 @@ export async function startServer(
         "/api/sessions/status": {
           GET: async (req: Request) =>
             withSecurityHeaders(
-              await handleResidentRead(runtime as ResidentRuntime, req, () =>
-                handleSessionsStatus(ctxHolder)
-              ),
+              (await refreshSessionsConfig(ctxHolder, store)) ??
+                (await handleResidentRead(runtime as ResidentRuntime, req, () =>
+                  handleSessionsStatus(ctxHolder)
+                )),
               isDev
             ),
         },
@@ -1743,7 +1746,7 @@ export async function startServer(
             );
           },
         },
-      },
+      }),
       // Production catch-all: /vendor/pdfjs prefix, then hashed SPA chunks
       // (gzip + immutable) and the private SPA source — the same factory the
       // tests mount (no test-only fallback path).

package/src/serve/status-model.ts

@@ -1,6 +1,10 @@
 import type { ContentTypeBoostStatus } from "../config/content-types";
 import type { ActivationStatus } from "../core/activation-status";
 import type { ChunkingStatus } from "../store/chunking";
+import type {
+  VectorPartitionStatus,
+  VectorRuntimeStatus,
+} from "../store/vector/status";
 
 export type HealthCheckStatus = "ok" | "warn" | "error";
 
@@ -14,9 +18,13 @@ export type HealthActionKind =
 
 export type OnboardingStepStatus = "complete" | "current" | "upcoming";
 
+/**
+ * Host path fields below (`path`, `configPath`, `dbPath`) reach same-host
+ * callers only; a remote caller's response omits them.
+ */
 export interface StatusCollection {
   name: string;
-  path: string;
+  path?: string;
   documentCount: number;
   chunkCount: number;
   embeddedCount: number;
@@ -24,7 +32,7 @@ export interface StatusCollection {
 
 export interface SuggestedCollection {
   label: string;
-  path: string;
+  path?: string;
   reason: string;
 }
 
@@ -109,6 +117,16 @@ export interface ResidentStatus {
     content: number;
     index: number;
   };
+  /** Present only while a background job is in trouble. */
+  backgroundIssues?: BackgroundIssue[];
+}
+
+/** A resident background job that keeps failing, has stopped retrying, or overruns. */
+export interface BackgroundIssue {
+  job: "embed" | "resident";
+  state: "failing" | "parked" | "overrunning" | "unresponsive";
+  consecutiveFailures: number;
+  runningSeconds: number | null;
 }
 
 export interface BackgroundServiceState {
@@ -153,7 +171,7 @@ export interface BootstrapState {
     summary: string;
   };
   cache: {
-    path: string;
+    path?: string;
     totalSizeBytes: number;
     totalSizeLabel: string;
   };
@@ -169,7 +187,7 @@ export interface BootstrapState {
       role: "embed" | "rerank" | "expand" | "gen";
       uri: string;
       cached: boolean;
-      path: string | null;
+      path?: string | null;
       sizeBytes: number | null;
       statusLabel: string;
     }>;
@@ -180,12 +198,14 @@ export interface AppStatusResponse {
   chunking?: ChunkingStatus;
   resident: ResidentStatus;
   indexName: string;
-  configPath: string;
-  dbPath: string;
+  configPath?: string;
+  dbPath?: string;
   collections: StatusCollection[];
   totalDocuments: number;
   totalChunks: number;
   embeddingBacklog: number;
+  vectorPartitions?: VectorPartitionStatus[];
+  vectorRuntime?: VectorRuntimeStatus;
   lastUpdated: string | null;
   recentErrors: number;
   healthy: boolean;

package/src/serve/status.ts

@@ -95,11 +95,6 @@ function summarizeCount(
   return `${count} ${count === 1 ? singular : plural}`;
 }
 
-function toDisplayPath(path: string): string {
-  const home = homedir();
-  return path.startsWith(home) ? `~${path.slice(home.length)}` : path;
-}
-
 function extractEstimatedFootprint(name: string): string | null {
   const match = name.match(SIZE_REGEX);
   return match ? match[0] : null;
@@ -432,11 +427,11 @@ async function buildDiskCheck(
       title: "Disk",
       status: "warn",
       summary: "Disk space could not be inspected",
-      detail: `GNO could not read filesystem capacity near ${toDisplayPath(getModelsCachePath())}.`,
+      detail: "GNO could not read filesystem capacity for the model cache.",
     };
   }
 
-  const summary = `${formatBytes(snapshot.freeBytes)} free near ${toDisplayPath(snapshot.path)}`;
+  const summary = `${formatBytes(snapshot.freeBytes)} free for the model cache`;
 
   if (snapshot.freeBytes < DISK_ERROR_BYTES) {
     return {
@@ -734,6 +729,8 @@ export async function buildAppStatus(
     totalDocuments: status.activeDocuments,
     totalChunks: status.totalChunks,
     embeddingBacklog: status.embeddingBacklog,
+    vectorPartitions: status.vectorPartitions,
+    vectorRuntime: status.vectorRuntime,
     chunking: status.chunking,
     lastUpdated: status.lastUpdatedAt,
     recentErrors: status.recentErrors,

package/src/serve/watch-reconciliation-shared.ts

@@ -45,6 +45,9 @@ export const WATCHER_MAX_SUPPRESSION_ENTRIES = 4_096;
 /** Bounded retry delay after failed classification/sync. */
 export const WATCHER_RETRY_BACKOFF_MS = 500;
 
+/** Retry delay while another writer holds the shared writer lease. */
+export const WATCHER_LEASE_RETRY_MS = 5_000;
+
 /**
  * Single fixed budget for fallback classification across visited directories,
  * candidates, removals, dirty dirs, and aggregate store rows.

package/src/serve/watch-service-events.ts

@@ -219,7 +219,8 @@ export function requeueAfterFailure(
   collectionName: string,
   exact: string[],
   dirty: string[],
-  forceFlags?: PendingForceFlags
+  forceFlags?: PendingForceFlags,
+  delayMs = WATCHER_RETRY_BACKOFF_MS
 ): void {
   queueWithoutSchedule(host, collectionName, exact, dirty, forceFlags);
   if (host.disposed()) {
@@ -241,7 +242,7 @@ export function requeueAfterFailure(
       host.timers.delete(collectionName);
       host.retryScheduled.delete(collectionName);
       startFlush(host, collectionName);
-    }, WATCHER_RETRY_BACKOFF_MS)
+    }, delayMs)
   );
 }
 

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;
@@ -1937,7 +1946,7 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
       const db = this.ensureOpen();
       const rows = db
         .query<DbDocumentRow, [string, string]>(
-          `SELECT * FROM documents
+          `SELECT * FROM documents INDEXED BY idx_documents_record_source_path
            WHERE collection = ? AND record_source_path = ?
            ORDER BY rel_path ASC, id ASC`
         )
@@ -3317,7 +3326,7 @@ export class SqliteAdapter implements StorePort, SqliteDbProvider {
 
         const docs = db
           .query<DocInfo, [string]>(
-            "SELECT id, rel_path, title FROM documents WHERE mirror_hash = ? AND active = 1"
+            "SELECT id, rel_path, title FROM documents INDEXED BY idx_documents_mirror_hash WHERE mirror_hash = ? AND active = 1"
           )
           .all(mirrorHash);
 
@@ -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/sqlite/change-journal-store.ts

@@ -180,7 +180,7 @@ const enforceInTransaction = (
     db
       .query<{ sequence: number | null }, [number]>(
         `SELECT MAX(sequence) AS sequence
-         FROM document_changes
+         FROM document_changes INDEXED BY idx_document_changes_retention
          WHERE observed_at_ms <= ?`
       )
       .get(ageBoundary)?.sequence ?? state.retention_floor;

package/src/store/sqlite/legacy-vector-ownership.ts

@@ -9,7 +9,8 @@ export type LegacyTitleSnapshot = Map<string, (string | null)[]>;
 function activeTitle(db: Database, mirror: string): TitleRow | null {
   return db
     .query<TitleRow, [string]>(`
-    SELECT title FROM documents WHERE mirror_hash = ? AND active = 1
+    SELECT title FROM documents INDEXED BY idx_documents_mirror_hash
+    WHERE mirror_hash = ? AND active = 1
     ORDER BY id LIMIT 1
   `)
     .get(mirror);

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) */