@gmickel/gno 2.8.2 → 2.8.4

package/src/ingestion/types.ts

@@ -185,9 +185,18 @@ export interface SyncOptions {
   /** Conversion limits override */
   limits?: {
     maxBytes?: number;
+    /** Per-file conversion wall-clock budget (config `conversion.timeoutMs`). */
     timeoutMs?: number;
     maxOutputChars?: number;
+    /** Process memory ceiling while a file converts (`conversion.maxMemoryMb`). */
+    maxMemoryMb?: number;
   };
+  /**
+   * Internal: called once when one file's conversion has run longer than
+   * `SLOW_CONVERSION_NOTICE_MS` (or half its budget, if sooner), naming the
+   * file while it is still running.
+   */
+  onSlowConversion?: (event: SlowConversionEvent) => void;
   /**
    * Max concurrent file processing (default: 1).
    * Higher values improve throughput but increase memory pressure.
@@ -207,6 +216,15 @@ export interface SyncOptions {
   sourceAvailability?: "any" | "local";
 }
 
+/** A file whose conversion is taking longer than the notice threshold. */
+export interface SlowConversionEvent {
+  collection: string;
+  /** Collection-relative path of the file being converted. */
+  relPath: string;
+  elapsedMs: number;
+  budgetMs: number;
+}
+
 export type ContentTypeSource =
   | "frontmatter-type"
   | "prefix"

package/src/llm/native-worker/embedding-identity.ts

@@ -1,9 +1,21 @@
 // Bun has no inode/ctime identity API. Check replacement during hashing/loading.
 import { stat } from "node:fs/promises";
 
-const nativePackage: { version: string } = await Bun.file(
-  new URL("../package.json", import.meta.resolve("node-llama-cpp"))
-).json();
+/**
+ * node-llama-cpp's version, part of the embedding runtime identity. A
+ * standalone compiled executable ships no node-llama-cpp package (it cannot
+ * run local inference), so the lookup must not stop it from loading.
+ */
+const readNativePackage = async (): Promise<{ version: string }> => {
+  try {
+    return (await Bun.file(
+      new URL("../package.json", import.meta.resolve("node-llama-cpp"))
+    ).json()) as { version: string };
+  } catch {
+    return { version: "unavailable" };
+  }
+};
+const nativePackage = await readNativePackage();
 
 export async function fileIdentity(path: string): Promise<string> {
   const info = await stat(path, { bigint: true });

package/src/mcp/http-transport.ts

@@ -17,6 +17,7 @@ import { MCP_SERVER_NAME, VERSION } from "../app/constants";
 import { EgressDeniedError } from "../core/egress-enforcement";
 import { httpMcpRequestNamespace } from "../core/request-receipts";
 import { withInferenceScope } from "../llm/inference-scope";
+import { remoteSafeSessionsError } from "../sessions/types";
 import { createMcpServerSurface, type ToolContext } from "./context";
 import {
   enforceHttpMcpEgress,
@@ -44,6 +45,8 @@ const POLICY_CHANGED_SSE = new TextEncoder().encode(
 export interface HttpMcpTransportRuntime extends HttpMcpSessionRuntime {
   readonly authorizationEpoch?: string;
   readonly isShuttingDown: boolean;
+  /** Adopt config-file collection edits; see ResidentRuntime.refreshConfig. */
+  refreshConfig?(): Promise<void>;
   admitRequest(signal?: AbortSignal): ResidentRequestHandle | null;
 }
 
@@ -281,6 +284,14 @@ export class HttpMcpTransport {
     if (!MCP_HTTP_METHODS.has(request.method)) return methodNotAllowed();
     if (this.#closed || this.#runtime.isShuttingDown)
       return jsonRpcError(503, -32_000, "Resident runtime is unavailable");
+    // Before admission: adopting config-file collection edits moves the
+    // policy epoch, which would void a request already admitted.
+    try {
+      await this.#runtime.refreshConfig?.();
+    } catch (error) {
+      const typed = remoteSafeSessionsError(error);
+      return jsonRpcError(500, -32_000, `${typed.code}: ${typed.message}`);
+    }
     if (!(await this.#acquireCapacity(request.signal))) {
       if (this.#closed || this.#runtime.isShuttingDown)
         return jsonRpcError(503, -32_000, "Resident runtime is unavailable");

package/src/mcp/tools/links.ts

@@ -26,7 +26,7 @@ import { normalizeCollectionName } from "../../core/validation";
 import { getActivePreset } from "../../llm/registry";
 import { createVectorIndexPort } from "../../store/vector";
 import {
-  readStoredDocumentVectors,
+  readSimilaritySourceVectors,
   resolveStoredVectorSource,
   similarityHitDocuments,
   storedVectorSearchOptions,
@@ -415,55 +415,27 @@ export function handleSimilar(
       const preset = getActivePreset(ctx.config);
       const modelUri = preset.embed;
 
-      // Stored chunk vectors from the active partition (NO model loading required)
+      // Similarity source vector (first chunk, unit length) from the active
+      // partition (NO model loading required)
       const db = ctx.store.getRawDb();
       const source = resolveStoredVectorSource(db, modelUri);
 
-      let vectors: Float32Array[];
+      let embedding: Float32Array | undefined;
       try {
-        vectors =
-          readStoredDocumentVectors(db, source, [
-            { id: doc.id, mirrorHash: doc.mirrorHash },
-          ]).get(doc.id) ?? [];
+        embedding = readSimilaritySourceVectors(db, source, [
+          { id: doc.id, mirrorHash: doc.mirrorHash },
+        ]).get(doc.id);
       } catch (e) {
         throw new Error(
           `Invalid stored embedding data: ${e instanceof Error ? e.message : String(e)}`
         );
       }
-      const first = vectors[0];
-      if (!first) {
+      if (!embedding) {
         throw new Error(
           `${MCP_ERRORS.NOT_FOUND.code}: Document has no embeddings. Run: gno embed`
         );
       }
-
-      // Compute average embedding from all chunks
-      const dimensions = first.length;
-      const avgEmbedding = new Float32Array(dimensions);
-      for (const embedding of vectors) {
-        if (embedding.length !== dimensions) {
-          throw new Error(
-            `Invalid stored embedding data: Inconsistent embedding dimensions: expected ${dimensions}, got ${embedding.length}`
-          );
-        }
-        for (let i = 0; i < dimensions; i++) {
-          const current = avgEmbedding[i] ?? 0;
-          avgEmbedding[i] = current + (embedding[i] ?? 0) / vectors.length;
-        }
-      }
-
-      // Normalize the average embedding for cosine similarity
-      let norm = 0;
-      for (let i = 0; i < dimensions; i++) {
-        const val = avgEmbedding[i] ?? 0;
-        norm += val * val;
-      }
-      norm = Math.sqrt(norm);
-      if (norm > 0) {
-        for (let i = 0; i < dimensions; i++) {
-          avgEmbedding[i] = (avgEmbedding[i] ?? 0) / norm;
-        }
-      }
+      const dimensions = embedding.length;
 
       // Create vector index for search
       const vectorResult = await createVectorIndexPort(db, {
@@ -496,7 +468,7 @@ export function handleSimilar(
       // Search for similar documents (larger pool for filtering)
       const candidateLimit = Math.min(limit * 20, 200);
       const searchResult = await vectorIndex.searchNearest(
-        avgEmbedding,
+        embedding,
         candidateLimit,
         storedVectorSearchOptions(source)
       );

package/src/serve/activation-health.ts

@@ -3,6 +3,8 @@
 import type { ActivationStatus } from "../core/activation-status";
 import type { HealthCheck } from "./status-model";
 
+import { isEmptyActivationCollection } from "../core/activation-empty";
+
 function countLabel(count: number, singular: string): string {
   return `${count} ${count === 1 ? singular : `${singular}s`}`;
 }
@@ -10,26 +12,42 @@ function countLabel(count: number, singular: string): string {
 export function buildActivationCheck(
   activation: ActivationStatus
 ): HealthCheck {
+  const ready = activation.collections.filter((collection) => collection.ready);
+  const empty = activation.collections.filter(isEmptyActivationCollection);
+  const emptyDetail =
+    empty.length > 0
+      ? `${countLabel(empty.length, "folder")} ${empty.length === 1 ? "has" : "have"} no documents yet (${empty.map(({ collection }) => collection).join(", ")}): add files, then run update.`
+      : null;
   if (activation.healthy) {
     const semanticReasons = [
       ...new Set(
-        activation.collections.map(
-          ({ semanticAvailability }) => semanticAvailability.code
-        )
+        ready.map(({ semanticAvailability }) => semanticAvailability.code)
       ),
     ];
+    const semanticDetail =
+      ready.length > 0
+        ? `Lexical search is proven. Semantic availability is separate (${semanticReasons.join(", ")}).`
+        : null;
     return {
       id: "retrieval-activation",
       title: "Retrieval proof",
       status: "ok",
-      summary: `${countLabel(activation.collections.length, "folder")} passed lexical retrieval`,
-      detail: `Lexical search is proven. Semantic availability is separate (${semanticReasons.join(", ")}).`,
+      summary:
+        ready.length === 0
+          ? `No documents indexed yet in ${countLabel(empty.length, "folder")}`
+          : empty.length > 0
+            ? `${countLabel(ready.length, "folder")} passed lexical retrieval; ${countLabel(empty.length, "folder")} with no documents yet`
+            : `${countLabel(ready.length, "folder")} passed lexical retrieval`,
+      detail: [semanticDetail, emptyDetail].filter(Boolean).join(" "),
       actionLabel: "Run update",
       actionKind: "sync",
     };
   }
 
-  const failed = activation.collections.filter(({ ready }) => !ready);
+  const failed = activation.collections.filter(
+    (collection) =>
+      !collection.ready && !isEmptyActivationCollection(collection)
+  );
   const first = failed[0];
   const detail = first?.remediation
     ? `${first.collection}: ${first.remediation.stage}/${first.remediation.code}. Run: ${first.remediation.command}`
@@ -41,7 +59,7 @@ export function buildActivationCheck(
     summary: activation.usable
       ? `${countLabel(failed.length, "folder")} failed lexical retrieval`
       : "No folder passed lexical retrieval",
-    detail,
+    detail: [detail, emptyDetail].filter(Boolean).join(" "),
     actionLabel: "Run update",
     actionKind: "sync",
   };

package/src/serve/public/components/BootstrapStatus.tsx

@@ -9,6 +9,7 @@ import {
 
 import type { AppStatusResponse } from "../../status-model";
 
+import { isEmptyActivationCollection } from "../../../core/activation-empty";
 import { buildConnectorActivationCheck } from "../../activation-health";
 import { Button } from "./ui/button";
 import {
@@ -147,9 +148,9 @@ export function BootstrapStatus({
         <Card className="border-border/60 bg-card/70">
           <CardHeader className="pb-3">
             <div className="flex items-center gap-2">
-              {activation.healthy && connectorsHealthy ? (
+              {activation.healthy && activation.usable && connectorsHealthy ? (
                 <CheckCircle2Icon className="size-4 text-emerald-500" />
-              ) : activation.usable ? (
+              ) : activation.usable || activation.healthy ? (
                 <ServerCogIcon className="size-4 text-amber-500" />
               ) : (
                 <AlertCircleIcon className="size-4 text-destructive" />
@@ -158,7 +159,9 @@ export function BootstrapStatus({
             </div>
             <CardDescription>
               {activation.healthy
-                ? "Lexical retrieval proven"
+                ? activation.usable
+                  ? "Lexical retrieval proven"
+                  : "No documents indexed yet"
                 : activation.usable
                   ? `Search usable in ${activation.collections.filter(({ ready }) => ready).length}/${activation.collections.length} folders`
                   : "Retrieval proof failed"}
@@ -179,7 +182,9 @@ export function BootstrapStatus({
                   <p className="text-muted-foreground text-xs">
                     {collection.ready
                       ? `Lexical passed; semantic ${collection.semanticAvailability.code}`
-                      : `${collection.remediation?.stage ?? "index"}/${collection.remediation?.code ?? "index_query_failed"}`}
+                      : isEmptyActivationCollection(collection)
+                        ? "No documents yet. Add files, then run update."
+                        : `${collection.remediation?.stage ?? "index"}/${collection.remediation?.code ?? "index_query_failed"}`}
                   </p>
                   {collection.remediation && (
                     <p className="mt-1 font-mono text-muted-foreground text-xs">

package/src/serve/resident-request.ts

@@ -2,6 +2,23 @@ import type { ResidentRuntime } from "./resident-runtime";
 /** Admission and bounded-reader boundary for resident REST reads. */
 
 import { withInferenceScope } from "../llm/inference-scope";
+import { sessionsErrorResponse } from "./routes/sessions";
+
+/**
+ * Adopt config-file collection edits before a request is admitted (adoption
+ * moves the policy epoch, which would void an admitted request). Returns the
+ * error response when the config cannot be read or is bound elsewhere.
+ */
+export async function refreshResidentConfig(
+  runtime: Pick<ResidentRuntime, "refreshConfig">
+): Promise<Response | null> {
+  try {
+    await runtime.refreshConfig?.();
+    return null;
+  } catch (error) {
+    return sessionsErrorResponse(error);
+  }
+}
 
 function unavailableResponse(): Response {
   return Response.json(
@@ -87,6 +104,8 @@ export async function handleResidentRead(
   request: Request | undefined,
   operation: (signal: AbortSignal) => Promise<Response> | Response
 ): Promise<Response> {
+  const refreshFailure = await refreshResidentConfig(runtime);
+  if (refreshFailure) return refreshFailure;
   const admitted = runtime.admitRequest(request?.signal);
   if (!admitted) return unavailableResponse();
 

package/src/serve/resident-runtime.ts

@@ -51,10 +51,16 @@ import {
 } from "../core/shutdown-budget";
 import { acquireCliWriteLease } from "../core/write-lease";
 import { defaultSyncService, withContentTypeRules } from "../ingestion";
+import { disposeFileProcessor } from "../ingestion/file-processor";
 import { withOwnedInferenceScope } from "../llm/inference-scope";
 import { getActivePreset } from "../llm/registry";
 import { createToolContext, Mutex } from "../mcp/context";
 import { watchedCollections } from "../sessions/config";
+import {
+  adoptServedConfig,
+  readInstanceConfig,
+} from "../sessions/config-refresh";
+import { remoteSafeSessionsError } from "../sessions/types";
 import { SqliteAdapter } from "../store/sqlite/adapter";
 import {
   createServerContext,
@@ -78,6 +84,8 @@ import {
 import { CollectionWatchService as DefaultCollectionWatchService } from "./watch-service";
 
 const OWNER_LOCK_TIMEOUT_MS = 0;
+/** How often an idle resident re-reads its config file for collection edits. */
+const CONFIG_REFRESH_INTERVAL_MS = 2_000;
 
 export type ResidentMode = "serve" | "daemon";
 
@@ -146,6 +154,15 @@ export interface ResidentRuntime {
     provider: (() => HttpMcpTransportStatus) | null
   ): void;
   setPolicySessionInvalidator(invalidator: (() => Promise<void>) | null): void;
+  /**
+   * Adopt collection (and context) edits made to the config file while the
+   * resident runs, with the sessions refresh's binding checks: rejects when
+   * the file is unreadable or bound to another index, leaving the served
+   * config as it was. Other settings keep their restart behaviour. Callers
+   * run it before admitting a request (an adoption moves the policy epoch).
+   * Optional only for test doubles; the real runtime always provides it.
+   */
+  refreshConfig?(): Promise<void>;
   admitRequest(signal?: AbortSignal): ResidentRequestHandle | null;
   withModelLease<T>(operation: () => Promise<T>): Promise<T>;
   markContentMutation(): void;
@@ -472,17 +489,56 @@ export async function startResidentRuntime(
     startBackgroundWork: (operation) => backgroundWork.start(operation),
   });
 
+  const setServedConfig = (config: Config): void => {
+    ctxHolder.config = config;
+    ctxHolder.current = { ...ctxHolder.current, config };
+    ctxHolder.watchService?.updateCollections(
+      watchedCollections(config),
+      withContentTypeRules({}, config)
+    );
+  };
+  const instance = {
+    configPath: actualConfigPath,
+    indexName: canonicalizeIndexName(options.index ?? DEFAULT_INDEX_NAME),
+  };
+  let configRefresh: Promise<void> | undefined;
+  const refreshConfig = (): Promise<void> => {
+    configRefresh ??= (async () => {
+      const file = await readInstanceConfig(
+        instance,
+        deps.loadConfig ?? loadConfig
+      );
+      const served = ctxHolder.config;
+      const next: Config = {
+        ...served,
+        collections: file.collections,
+        contexts: file.contexts,
+      };
+      if (Bun.deepEquals(next, served)) return;
+      await adoptServedConfig(
+        {
+          ...instance,
+          store,
+          config: served,
+          setConfig: setServedConfig,
+          invalidateEgressPolicy: async () => {
+            await ctxHolder.invalidateEgressPolicy?.();
+          },
+          markContentMutation: () => ctxHolder.markContentMutation?.(),
+          markIndexMutation: () => ctxHolder.markIndexMutation?.(),
+        },
+        next
+      );
+    })().finally(() => {
+      configRefresh = undefined;
+    });
+    return configRefresh;
+  };
+
   const mcpContext = createToolContext({
     store,
     getConfig: () => ctxHolder.config,
-    setConfig: (config) => {
-      ctxHolder.config = config;
-      ctxHolder.current = { ...ctxHolder.current, config };
-      ctxHolder.watchService?.updateCollections(
-        watchedCollections(config),
-        withContentTypeRules({}, config)
-      );
-    },
+    setConfig: setServedConfig,
     actualConfigPath,
     indexName: canonicalizeIndexName(options.index ?? DEFAULT_INDEX_NAME),
     toolMutex,
@@ -633,6 +689,7 @@ export async function startResidentRuntime(
     setPolicySessionInvalidator(invalidator) {
       policySessionInvalidator = invalidator;
     },
+    refreshConfig,
     async syncAll(syncOptions = {}) {
       const request = admission.admit();
       if (!request) throw new Error("Resident runtime is shutting down");
@@ -674,8 +731,11 @@ export async function startResidentRuntime(
     dispose(closeSurface) {
       if (disposal) return disposal;
       disposed = true;
+      clearInterval(configRefreshTimer);
       admission.stop();
       jobManager.stop();
+      // A file mid-preparation fails now instead of holding shutdown.
+      disposeFileProcessor();
       admissionState = "draining";
       shutdownState = "graceful";
       disposal = disposeResidentResources({
@@ -725,5 +785,21 @@ export async function startResidentRuntime(
     };
   };
   mcpContext.getResidentStatus = () => runtime.getStatus();
+  // Without requests (a headless daemon) the watcher still follows the file.
+  let lastRefreshError: string | undefined;
+  const configRefreshTimer = setInterval(() => {
+    backgroundWork.start(async () => {
+      try {
+        await refreshConfig();
+        lastRefreshError = undefined;
+      } catch (error) {
+        const message = remoteSafeSessionsError(error).message;
+        if (message !== lastRefreshError)
+          console.warn(`gno ${mode}: config not reloaded: ${message}`);
+        lastRefreshError = message;
+      }
+    });
+  }, CONFIG_REFRESH_INTERVAL_MS);
+  configRefreshTimer.unref?.();
   return { success: true, runtime };
 }

package/src/serve/routes/links.ts

@@ -8,7 +8,7 @@ import type { SqliteAdapter } from "../../store/sqlite/adapter";
 import type { ServerContext } from "../context";
 
 import {
-  readStoredDocumentVectors,
+  readSimilaritySourceVectors,
   resolveStoredVectorSource,
   similarityHitDocuments,
   storedVectorSearchOptions,
@@ -313,7 +313,7 @@ export async function handleDocBacklinks(
  *   ?threshold=0.5 (min similarity score 0-1, default 0.5)
  *   ?crossCollection=true (search across all collections, default false)
  *
- * Algorithm: seq=0 embedding (fallback to first available) -> vector search -> exclude self
+ * Algorithm: first-chunk source vector (readSimilaritySourceVectors) -> vector search -> exclude self
  */
 export async function handleDocSimilar(
   ctx: ServerContext,
@@ -378,18 +378,14 @@ export async function handleDocSimilar(
     } satisfies SimilarDocResponse);
   }
 
-  // Stored vector of the document's first chunk, from the active partition
+  // Similarity source vector (first chunk, unit length), active partition
   const db = store.getRawDb();
   const source = resolveStoredVectorSource(db, ctx.vectorIndex.model);
   let embedding: Float32Array | undefined;
   try {
-    [embedding] =
-      readStoredDocumentVectors(
-        db,
-        source,
-        [{ id: doc.id, mirrorHash: doc.mirrorHash }],
-        { firstChunkOnly: true }
-      ).get(doc.id) ?? [];
+    embedding = readSimilaritySourceVectors(db, source, [
+      { id: doc.id, mirrorHash: doc.mirrorHash },
+    ]).get(doc.id);
   } catch (e) {
     return errorResponse(
       "RUNTIME",
@@ -410,20 +406,6 @@ export async function handleDocSimilar(
       },
     } satisfies SimilarDocResponse);
   }
-  const dimensions = embedding.length;
-
-  // Normalize embedding for cosine similarity
-  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;
-    }
-  }
 
   // Search for similar docs (request extra to account for self-exclusion, filtering)
   const candidateLimit = Math.min(limit * 20, 200);

package/src/serve/server.ts

@@ -28,7 +28,7 @@ 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";
-import { handleResidentRead } from "./resident-request";
+import { handleResidentRead, refreshResidentConfig } from "./resident-request";
 import {
   handleActiveJob,
   handleAsk,
@@ -702,7 +702,8 @@ export async function startServer(
         "/api/collections": {
           GET: async () =>
             withSecurityHeaders(
-              await handleCollections(ctxHolder.config),
+              (await refreshResidentConfig(runtime as ResidentRuntime)) ??
+                (await handleCollections(ctxHolder.config)),
               isDev
             ),
           POST: async (req: Request) => {

package/src/serve/status.ts

@@ -14,6 +14,7 @@ import type {
 
 import { getModelsCachePath } from "../app/constants";
 import { buildContentTypeBoostStatus } from "../config/content-types";
+import { isEmptyActivationCollection } from "../core/activation-empty";
 import {
   type ActivationStatus,
   buildActivationStatus,
@@ -555,7 +556,13 @@ function buildOnboarding(
 ): AppStatusResponse["onboarding"] {
   const foldersReady = activation.collections.length > 0;
   const modelsReady = modelCheck.status === "ok";
-  const indexedReady = activation.healthy;
+  // An empty folder is not a failure, but a workspace with no documents yet
+  // has not finished its first proof.
+  const indexedReady = activation.healthy && activation.usable;
+  const readyCount = activation.collections.filter(({ ready }) => ready).length;
+  const emptyCount = activation.collections.filter(
+    isEmptyActivationCollection
+  ).length;
   const semanticStates = [
     ...new Set(
       activation.collections.map(
@@ -563,10 +570,22 @@ function buildOnboarding(
       )
     ),
   ];
-  const failedActivation = activation.collections.find(({ ready }) => !ready);
-  const activationDetail = failedActivation?.remediation
-    ? `${failedActivation.collection}: ${failedActivation.remediation.stage}/${failedActivation.remediation.code}. Run: ${failedActivation.remediation.command}`
-    : "Run the first sync to populate a searchable lexical index.";
+  const failedActivation =
+    activation.collections.find(
+      (collection) =>
+        !collection.ready && !isEmptyActivationCollection(collection)
+    ) ?? activation.collections.find(({ ready }) => !ready);
+  const activationDetail = !failedActivation?.remediation
+    ? "Run the first sync to populate a searchable lexical index."
+    : isEmptyActivationCollection(failedActivation)
+      ? `${failedActivation.collection} has no documents yet. Add files, then run: ${failedActivation.remediation.command}`
+      : `${failedActivation.collection}: ${failedActivation.remediation.stage}/${failedActivation.remediation.code}. Run: ${failedActivation.remediation.command}`;
+  const emptyNote =
+    emptyCount > 0
+      ? ` ${summarizeCount(emptyCount, "folder")} with no documents yet.`
+      : "";
+  const passedFolders =
+    emptyCount > 0 ? "Every folder with documents" : "Every folder";
 
   const steps = [
     {
@@ -600,7 +619,7 @@ function buildOnboarding(
       title: "Prove lexical retrieval",
       status: indexedReady ? "complete" : foldersReady ? "current" : "upcoming",
       detail: indexedReady
-        ? `${summarizeCount(activation.collections.length, "folder")} passed a corpus-derived lexical proof.`
+        ? `${summarizeCount(readyCount, "folder")} passed a corpus-derived lexical proof.${emptyNote}`
         : activationDetail,
       action: "sync",
     },
@@ -636,8 +655,8 @@ function buildOnboarding(
     stage: "ready",
     headline: "Workspace ready",
     detail: modelsReady
-      ? `Every folder passed lexical retrieval. Local model files are cached; semantic retrieval remains separate (${semanticStates.join(", ")}).`
-      : `Every folder passed lexical retrieval. Semantic retrieval remains an optional next step (${semanticStates.join(", ")}).`,
+      ? `${passedFolders} passed lexical retrieval.${emptyNote} Local model files are cached; semantic retrieval remains separate (${semanticStates.join(", ")}).`
+      : `${passedFolders} passed lexical retrieval.${emptyNote} Semantic retrieval remains an optional next step (${semanticStates.join(", ")}).`,
     suggestedCollections: suggestions,
     steps,
   };

package/src/sessions/config-refresh.ts

@@ -53,9 +53,10 @@ export async function assertInstanceBinding(
  * before it can touch this one.
  */
 export async function readInstanceConfig(
-  instance: SessionsInstance
+  instance: SessionsInstance,
+  load: typeof loadConfig = loadConfig
 ): Promise<Config> {
-  const loaded = await loadConfig(instance.configPath);
+  const loaded = await load(instance.configPath);
   if (!loaded.ok) {
     throw new SessionsError(
       "SESSIONS_RUNTIME_FAILURE",

package/src/store/sqlite/graph-similarity.ts

@@ -6,7 +6,7 @@
 import type { Database } from "bun:sqlite";
 
 import {
-  readStoredDocumentVectors,
+  readSimilaritySourceVectors,
   resolveStoredVectorSource,
 } from "../vector/stored-vectors";
 
@@ -27,13 +27,6 @@ export interface StoredSimilarityEdge {
   score: number;
 }
 
-function unit(vector: Float32Array): Float32Array {
-  let norm = 0;
-  for (const value of vector) norm += value * value;
-  norm = Math.sqrt(norm);
-  return norm > 0 ? vector.map((value) => value / norm) : vector;
-}
-
 function dot(a: Float32Array, b: Float32Array): number {
   let sum = 0;
   for (let i = 0; i < a.length; i++) sum += (a[i] ?? 0) * (b[i] ?? 0);
@@ -61,15 +54,14 @@ export function storedSimilarityEdges(
         ORDER BY docid
       `)
       .all(JSON.stringify(docids));
-    const vectors = readStoredDocumentVectors(
+    const vectors = readSimilaritySourceVectors(
       db,
       resolveStoredVectorSource(db, model),
-      documents,
-      { firstChunkOnly: true }
+      documents
     );
     const nodes = documents.flatMap((document) => {
-      const vector = vectors.get(document.id)?.[0];
-      return vector ? [{ ...document, vector: unit(vector) }] : [];
+      const vector = vectors.get(document.id);
+      return vector ? [{ ...document, vector }] : [];
     });
     const edges: StoredSimilarityEdge[] = [];
     for (const node of nodes) {