@gmickel/gno 2.11.0 → 2.12.0

package/src/mcp/tools/index.ts

@@ -37,6 +37,9 @@ import {
   assertInferenceActive,
   acquireInferencePermit,
 } from "../../llm/inference-scope";
+import { envIsSet } from "../../llm/policy";
+import { staleCollectionsMessage } from "../../store/sqlite/adapter";
+import { MCP_ACTIVATION_VERIFICATION_ENV } from "../activation-verification-mode";
 import { exposesHostPaths } from "../context";
 import { profileToolDescription } from "../tool-descriptions-core";
 import {
@@ -175,7 +178,7 @@ export function normalizeTagFilters(tags?: string[]): string[] | undefined {
 
 export const MCP_TOOL_DESCRIPTIONS = {
   search:
-    "BM25 keyword search. Fast exact-term lookup for names, identifiers, error text, and known phrases. Structured results include uri/docid, line when available, and optional user-configured context guidance; use gno_get with fromLine/lineCount or gno_multi_get for full context. For natural-language questions use gno_query (fast=true first).",
+    "BM25 keyword search. Fast lookup of exact text you already have verbatim: identifiers, filenames, error text, and quoted phrases. Structured results include uri/docid, line when available, and optional user-configured context guidance; use gno_get with fromLine/lineCount or gno_multi_get for full context. A question, or a name or topic taken from it, is not exact text: use gno_query (fast=true first).",
   vsearch:
     "Vector semantic search. Finds conceptually similar docs with different wording. Structured results preserve optional user-configured context guidance. Best after embeddings are current; use intent to disambiguate short terms. For questions, gno_query with fast=true adds keyword matching at about the same cost.",
   query:
@@ -1014,6 +1017,7 @@ export async function runTool<T>(
   // Sequential execution via mutex
   const release = await acquireInferencePermit(() => ctx.toolMutex.acquire());
   try {
+    assertConfiguredCollections(ctx, name);
     assertInferenceActive();
     const raw = await (ctx.runWithSnapshot?.(fn) ?? fn());
     assertInferenceActive();
@@ -1084,6 +1088,31 @@ export async function runToolNoMutex<T>(
   }
 }
 
+/** Orientation tools that report the index state instead of reading it. */
+const STALE_CHECK_EXEMPT_TOOLS = new Set(["gno_status", "gno_peek"]);
+
+/**
+ * Refuse a tool call while the index holds collections this config omits
+ * (another client indexed them after this server opened). Status and peek
+ * still run, and a connector proof reads one collection through a subset
+ * config.
+ */
+function assertConfiguredCollections(ctx: ToolContext, name: string): void {
+  // Store-free stand-ins (an uninitialized peek, test doubles) have no index.
+  const store = ctx.store as Partial<ToolContext["store"]> | undefined;
+  if (
+    STALE_CHECK_EXEMPT_TOOLS.has(name) ||
+    typeof store?.staleIndexedCollections !== "function" ||
+    envIsSet(process.env, MCP_ACTIVATION_VERIFICATION_ENV)
+  ) {
+    return;
+  }
+  const stale = store.staleIndexedCollections(
+    ctx.collections.map((collection) => collection.name)
+  );
+  if (stale.length > 0) throw new Error(staleCollectionsMessage(stale));
+}
+
 function parseErrorMessage(message: string): { [x: string]: unknown } {
   const match = message.match(/^([A-Z_]+):\s*(.*)$/);
   if (match) {

package/src/mcp/tools/status.ts

@@ -12,6 +12,10 @@ import { formatChunkingStatus } from "../../core/chunking-status";
 import { OWNER_CONFIG_PATH_FIELDS, withoutFields } from "../../core/host-paths";
 import { formatLinkWorkspace } from "../../core/link-workspace";
 import { formatVectorPartitionLines } from "../../core/vector-partition-status";
+import {
+  type CollectionRootError,
+  withCollectionRootErrors,
+} from "../../ingestion/source-availability/root";
 import { resolveModelUri } from "../../llm/registry";
 import { createStandaloneResidentStatus } from "../../serve/resident-status";
 import { exposesHostPaths } from "../context";
@@ -23,7 +27,10 @@ type StatusInput = Record<string, never>;
 type StatusView = Omit<IndexStatus, "configPath" | "dbPath" | "collections"> &
   Partial<Pick<IndexStatus, "configPath" | "dbPath">> & {
     collections: Array<
-      Omit<CollectionStatus, "path"> & Partial<Pick<CollectionStatus, "path">>
+      Omit<CollectionStatus, "path"> &
+        Partial<Pick<CollectionStatus, "path">> & {
+          rootError?: CollectionRootError;
+        }
     >;
   };
 
@@ -58,6 +65,11 @@ function formatStatus(status: StatusView): string {
       );
       const workspace = formatLinkWorkspace(c);
       if (workspace) lines.push(`    Link workspace: ${workspace}`);
+      if (c.rootError) {
+        lines.push(
+          `    Root unavailable: [${c.rootError.code}] ${c.rootError.message}`
+        );
+      }
     }
   }
 
@@ -113,7 +125,10 @@ export function handleStatus(
 
       // Override configPath with actual path from context
       const status = {
-        ...result.value,
+        ...(await withCollectionRootErrors(
+          result.value,
+          ctx.config.collections
+        )),
         configPath: ctx.actualConfigPath,
         contentTypeBoost: buildContentTypeBoostStatus(
           ctx.config.contentTypes ?? []

package/src/pipeline/query-snippet.ts

@@ -0,0 +1,266 @@
+/**
+ * BM25 result snippets built from stored chunks.
+ *
+ * FTS5 `snippet()` re-tokenizes the whole body of every matched document
+ * before LIMIT, which made long questions take seconds. Snippets are built
+ * for the returned rows only: pick the chunk that best covers the query terms
+ * (terms weighted by rarity across the returned chunks, so a chunk with
+ * "ladder" beats one with only "the" and "does"; lowest seq on ties), then
+ * its best 32-token window, with matching tokens wrapped in `<mark>`/`</mark>`
+ * and `...` where the window cuts the chunk, as `snippet()` did. Chunk choice
+ * uses substring presence of lightly stemmed terms; highlighting uses word
+ * prefixes. Both approximate the index tokenizer and affect display only,
+ * never ranking.
+ *
+ * @module src/pipeline/query-snippet
+ */
+
+/** Tokens per snippet window (the old `snippet(..., 32)` budget). */
+const WINDOW_TOKENS = 32;
+
+/** Repeat hits only break ties between windows with equal term coverage. */
+const HIT_TIEBREAK = 1e-6;
+
+const TOKEN_REGEX = /[\p{L}\p{N}\p{M}]+/gu;
+
+/** Quoted phrase (optionally negated) or a bare token, as the lexical grammar splits them. */
+const QUERY_PART_REGEX = /(-?)"([^"]*)"|(\S+)/g;
+
+const DIACRITIC_REGEX = /\p{M}/gu;
+
+const NON_ASCII_REGEX = /[^\p{ASCII}]/u;
+
+/** Final doubled consonant left by suffix removal (`embedd` -> `embed`). */
+const DOUBLED_CONSONANT_REGEX = /([bdfgkmnprt])\1$/;
+
+/** Suffixes removed from query terms, longest first. */
+const STEM_SUFFIXES = [
+  "ational",
+  "ations",
+  "ation",
+  "ings",
+  "ions",
+  "ers",
+  "ied",
+  "ies",
+  "ing",
+  "ion",
+  "al",
+  "ed",
+  "er",
+  "ly",
+  "e",
+  "s",
+  "y",
+];
+
+const MIN_STEM_LENGTH = 3;
+
+export interface SnippetTerms {
+  /** Lowercase term prefixes (stemmed query words and diacritic-free forms). */
+  prefixes: string[];
+  /** Query word id per prefix; variants of one word share an id. */
+  ids: number[];
+  /** Anchored prefix matcher for one lowercased token. */
+  token: RegExp;
+  idByPrefix: Map<string, number>;
+}
+
+/** Query word ids present in one chunk. */
+export interface ChunkTermSet {
+  seq: number;
+  terms: Set<number>;
+}
+
+interface Token {
+  start: number;
+  end: number;
+  term: number;
+}
+
+const stripDiacritics = (text: string): string =>
+  NON_ASCII_REGEX.test(text)
+    ? text.normalize("NFD").replace(DIACRITIC_REGEX, "")
+    : text;
+
+function stemPrefix(term: string): string {
+  if (term.length <= MIN_STEM_LENGTH) return term;
+  for (const suffix of STEM_SUFFIXES) {
+    if (
+      term.endsWith(suffix) &&
+      term.length - suffix.length >= MIN_STEM_LENGTH
+    ) {
+      const stem = term.slice(0, -suffix.length);
+      return DOUBLED_CONSONANT_REGEX.test(stem) ? stem.slice(0, -1) : stem;
+    }
+  }
+  return term;
+}
+
+/** Positive terms of a lexical query; null when there are none. */
+export function createSnippetTerms(query: string): SnippetTerms | null {
+  const idByPrefix = new Map<string, number>();
+  let nextId = 0;
+  for (const part of query.matchAll(QUERY_PART_REGEX)) {
+    const bare = part[3];
+    if (part[1] === "-" || bare?.startsWith("-")) continue;
+    for (const [word] of (part[2] ?? bare ?? "").matchAll(TOKEN_REGEX)) {
+      const lower = word.toLowerCase();
+      for (const form of new Set([lower, stripDiacritics(lower)])) {
+        const prefix = stemPrefix(form);
+        if (!idByPrefix.has(prefix)) idByPrefix.set(prefix, nextId);
+      }
+      nextId += 1;
+    }
+  }
+  if (idByPrefix.size === 0) return null;
+  const prefixes = [...idByPrefix.keys()].sort((a, b) => b.length - a.length);
+  return {
+    prefixes,
+    ids: prefixes.map((prefix) => idByPrefix.get(prefix) ?? -1),
+    token: new RegExp(`^(?:${prefixes.join("|")})`, "u"),
+    idByPrefix,
+  };
+}
+
+/** In-memory equivalent of the store's chunk term presence query. */
+export function chunkTermPresence(
+  text: string,
+  terms: SnippetTerms
+): boolean[] {
+  const lower = text.toLowerCase();
+  return terms.prefixes.map((prefix) => lower.includes(prefix));
+}
+
+export function presentTermIds(
+  present: boolean[],
+  terms: SnippetTerms
+): Set<number> {
+  const ids = new Set<number>();
+  for (const [index, flag] of present.entries()) {
+    const id = terms.ids[index];
+    if (flag && id !== undefined) ids.add(id);
+  }
+  return ids;
+}
+
+/** Rarity weight per query word across all candidate chunks. */
+export function snippetTermWeights(
+  chunks: Iterable<ChunkTermSet>
+): Map<number, number> {
+  let total = 0;
+  const frequency = new Map<number, number>();
+  for (const { terms } of chunks) {
+    total += 1;
+    for (const term of terms)
+      frequency.set(term, (frequency.get(term) ?? 0) + 1);
+  }
+  const weights = new Map<number, number>();
+  for (const [term, count] of frequency)
+    weights.set(term, Math.log(1 + total / count));
+  return weights;
+}
+
+/** Seq of the chunk with the best weighted coverage (lowest seq on ties). */
+export function pickSnippetSeq(
+  chunks: ChunkTermSet[],
+  weights: Map<number, number>
+): number | undefined {
+  let best: ChunkTermSet | undefined;
+  let bestScore = -1;
+  for (const chunk of chunks) {
+    let score = 0;
+    for (const term of chunk.terms) score += weights.get(term) ?? 0;
+    if (
+      score > bestScore ||
+      (score === bestScore && best && chunk.seq < best.seq)
+    ) {
+      bestScore = score;
+      best = chunk;
+    }
+  }
+  return best?.seq;
+}
+
+function tokenize(text: string, terms: SnippetTerms): Token[] {
+  const tokens: Token[] = [];
+  for (const match of text.matchAll(TOKEN_REGEX)) {
+    const start = match.index;
+    const word = match[0];
+    const prefix = terms.token.exec(stripDiacritics(word.toLowerCase()));
+    tokens.push({
+      start,
+      end: start + word.length,
+      term: prefix ? (terms.idByPrefix.get(prefix[0]) ?? -1) : -1,
+    });
+  }
+  return tokens;
+}
+
+/** Start index of the window with the best weighted term coverage. */
+function bestWindowStart(
+  tokens: Token[],
+  weights: Map<number, number>
+): number {
+  if (tokens.length <= WINDOW_TOKENS) return 0;
+  const counts = new Map<number, number>();
+  let covered = 0;
+  let hits = 0;
+  const add = (term: number, delta: number) => {
+    if (term < 0) return;
+    const count = (counts.get(term) ?? 0) + delta;
+    counts.set(term, count);
+    hits += delta;
+    const weight = weights.get(term) ?? 1;
+    if (delta > 0 && count === 1) covered += weight;
+    if (delta < 0 && count === 0) covered -= weight;
+  };
+  let bestStart = 0;
+  let bestScore = -1;
+  for (let index = 0; index < tokens.length; index += 1) {
+    add(tokens[index]?.term ?? -1, 1);
+    const start = index - WINDOW_TOKENS + 1;
+    if (start > 0) add(tokens[start - 1]?.term ?? -1, -1);
+    if (start < 0) continue;
+    const score = covered + hits * HIT_TIEBREAK;
+    if (score > bestScore) {
+      bestScore = score;
+      bestStart = start;
+    }
+  }
+  // Center the hits inside the chosen window.
+  let first = -1;
+  let last = -1;
+  for (let index = bestStart; index < bestStart + WINDOW_TOKENS; index += 1) {
+    if ((tokens[index]?.term ?? -1) < 0) continue;
+    if (first < 0) first = index;
+    last = index;
+  }
+  if (first < 0) return bestStart;
+  const centered = first - Math.floor((WINDOW_TOKENS - (last - first + 1)) / 2);
+  return Math.max(0, Math.min(centered, tokens.length - WINDOW_TOKENS));
+}
+
+/** The best 32-token window of one chunk, query terms in `<mark>` tags. */
+export function renderChunkSnippet(
+  text: string,
+  terms: SnippetTerms,
+  weights: Map<number, number>
+): string {
+  const tokens = tokenize(text, terms);
+  if (tokens.length === 0) return text;
+  const start = bestWindowStart(tokens, weights);
+  const end = Math.min(tokens.length, start + WINDOW_TOKENS) - 1;
+  const atStart = start === 0;
+  const atEnd = end === tokens.length - 1;
+  let cursor = atStart ? 0 : (tokens[start]?.start ?? 0);
+  let out = atStart ? "" : "...";
+  for (let index = start; index <= end; index += 1) {
+    const token = tokens[index];
+    if (!token || token.term < 0) continue;
+    out += `${text.slice(cursor, token.start)}<mark>${text.slice(token.start, token.end)}</mark>`;
+    cursor = token.end;
+  }
+  out += text.slice(cursor, atEnd ? text.length : (tokens[end]?.end ?? 0));
+  return atEnd ? out : `${out}...`;
+}

package/src/pipeline/search.ts

@@ -8,6 +8,7 @@
 import { join as pathJoin } from "node:path"; // No Bun path utils equivalent
 
 import type { ChunkRow, FtsResult, StorePort } from "../store/types";
+import type { ChunkTermSet, SnippetTerms } from "./query-snippet";
 import type {
   SearchOptions,
   SearchResult,
@@ -31,6 +32,14 @@ import { typedMetadataWarnings } from "./filters";
 import { selectBestChunkForSteering } from "./intent";
 import { hasProjectAffinity } from "./project-affinity";
 import { detectQueryLanguage } from "./query-language";
+import {
+  chunkTermPresence,
+  createSnippetTerms,
+  pickSnippetSeq,
+  presentTermIds,
+  renderChunkSnippet,
+  snippetTermWeights,
+} from "./query-snippet";
 import {
   attachSearchResultContexts,
   attachSupersession,
@@ -44,6 +53,9 @@ import {
 import { attachSearchResultPlannerMetadata } from "./trace-metadata";
 import { SEARCH_RESULT_PLANNER_METADATA } from "./types";
 
+const passageHash = (text: string): string =>
+  new Bun.CryptoHasher("sha256").update(text).digest("hex");
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Score Normalization
 // ─────────────────────────────────────────────────────────────────────────────
@@ -124,11 +136,9 @@ function buildSearchResult(ctx: BuildResultContext): SearchResult {
     snippet = chunk.text;
     snippetRange = { startLine: chunk.startLine, endLine: chunk.endLine };
   } else {
-    // Default: FTS snippet or chunk text, with leading frontmatter stripped
-    const cleaned = cleanDisplaySnippet(
-      fts.snippet ?? chunk?.text ?? "",
-      chunk?.text
-    );
+    // Default: chunk text until attachChunkSnippets replaces it for the final
+    // rows, with leading frontmatter stripped
+    const cleaned = cleanDisplaySnippet(chunk?.text ?? "", chunk?.text);
     snippet = cleaned.text;
     if (chunk) {
       line = chunk.startLine + cleaned.startLineOffset;
@@ -162,10 +172,130 @@ function buildSearchResult(ctx: BuildResultContext): SearchResult {
     graphExpanded: false,
     startLine: chunk.startLine,
     endLine: chunk.endLine,
-    passageHash: new Bun.CryptoHasher("sha256")
-      .update(chunk.text)
-      .digest("hex"),
+    passageHash: passageHash(chunk.text),
+  });
+}
+
+/** Query-word ids present in each chunk of the returned documents. */
+async function readChunkTermSets(
+  store: StorePort,
+  hashes: string[],
+  terms: SnippetTerms,
+  loadedChunks: Map<string, ChunkRow[]> | undefined
+): Promise<{
+  termSets: Map<string, ChunkTermSet[]>;
+  chunks?: Map<string, ChunkRow[]>;
+} | null> {
+  const termSets = new Map<string, ChunkTermSet[]>();
+  const add = (mirrorHash: string, seq: number, present: boolean[]) => {
+    const list = termSets.get(mirrorHash) ?? [];
+    list.push({ seq, terms: presentTermIds(present, terms) });
+    termSets.set(mirrorHash, list);
+  };
+  // In-database presence keeps long documents from being loaded whole.
+  const presence =
+    !loadedChunks && store.getChunkTermPresence
+      ? await store.getChunkTermPresence(hashes, terms.prefixes)
+      : undefined;
+  if (presence?.ok) {
+    for (const row of presence.value) add(row.mirrorHash, row.seq, row.present);
+    return { termSets };
+  }
+  let chunks = loadedChunks;
+  if (!chunks) {
+    const fetched = await store.getChunksBatch(hashes);
+    if (!fetched.ok) return null;
+    chunks = fetched.value;
+  }
+  for (const [mirrorHash, list] of chunks)
+    for (const chunk of list)
+      add(mirrorHash, chunk.seq, chunkTermPresence(chunk.text, terms));
+  return { termSets, chunks };
+}
+
+/**
+ * Default-mode snippets for the returned rows only, built from their stored
+ * chunks (FTS5 snippet() re-tokenized every matched document body). Only the
+ * chosen chunk of each row is loaded; with an intent, the steered chunk is
+ * kept. The snippet, its range and the planner chunk all name that chunk.
+ * Updates results in place so hidden ranking metadata stays attached.
+ */
+async function attachChunkSnippets(
+  store: StorePort,
+  results: SearchResult[],
+  query: string,
+  options: SearchOptions,
+  loadedChunks: Map<string, ChunkRow[]> | undefined
+): Promise<void> {
+  const terms = createSnippetTerms(query);
+  const hashes = [
+    ...new Set(
+      results
+        .map((result) => result.conversion?.mirrorHash)
+        .filter((hash): hash is string => Boolean(hash))
+    ),
+  ];
+  if (!terms || hashes.length === 0) return;
+  const read = await readChunkTermSets(store, hashes, terms, loadedChunks);
+  if (!read) return;
+  const weights = snippetTermWeights([...read.termSets.values()].flat());
+
+  const chosen = results.map((result) => {
+    const mirrorHash = result.conversion?.mirrorHash;
+    if (!mirrorHash) return undefined;
+    const steeredSeq = result[SEARCH_RESULT_PLANNER_METADATA]?.seq;
+    const candidates = read.termSets.get(mirrorHash) ?? [];
+    const seq = pickSnippetSeq(
+      options.intent
+        ? candidates.filter((entry) => entry.seq === steeredSeq)
+        : candidates,
+      weights
+    );
+    return seq === undefined ? undefined : { mirrorHash, seq };
   });
+  let chunks = read.chunks;
+  if (!chunks) {
+    const fetched = store.getChunksBySequenceBatch
+      ? await store.getChunksBySequenceBatch(
+          chosen.filter((key) => key !== undefined)
+        )
+      : await store.getChunksBatch(hashes);
+    if (!fetched.ok) return;
+    chunks = fetched.value;
+  }
+  const getChunk = createChunkLookup(chunks);
+
+  for (const [index, result] of results.entries()) {
+    const key = chosen[index];
+    const chunk = key ? getChunk(key.mirrorHash, key.seq) : undefined;
+    if (!(key && chunk)) continue;
+    const cleaned = cleanDisplaySnippet(
+      renderChunkSnippet(chunk.text, terms, weights),
+      chunk.text
+    );
+    result.line = chunk.startLine + cleaned.startLineOffset;
+    result.snippet = cleaned.text;
+    result.snippetLanguage = chunk.language ?? undefined;
+    result.snippetRange = { startLine: result.line, endLine: chunk.endLine };
+    const coordinates = {
+      mirrorHash: key.mirrorHash,
+      seq: chunk.seq,
+      startLine: chunk.startLine,
+      endLine: chunk.endLine,
+      passageHash: passageHash(chunk.text),
+    };
+    const metadata = result[SEARCH_RESULT_PLANNER_METADATA];
+    if (metadata) {
+      Object.assign(metadata, coordinates);
+    } else {
+      attachSearchResultPlannerMetadata(result, {
+        retrievalRank: 0,
+        sources: ["bm25"],
+        graphExpanded: false,
+        ...coordinates,
+      });
+    }
+  }
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -207,8 +337,7 @@ export async function searchBm25(
   const detection = detectQueryLanguage(query);
   const queryLanguage = options.lang ?? detection.bcp47;
 
-  // Run FTS search
-  // Disable FTS snippet when --full or --line-numbers (we use raw text instead)
+  // Run FTS search (ranking only; snippets come from chunks of the final rows)
   const ftsResult = await store.searchFts(query, {
     limit: retrievalLimit,
     collection: options.collection,
@@ -216,7 +345,6 @@ export async function searchBm25(
     exclude: options.exclude,
     relPathPrefix: options.retrievalScope?.relPathPrefix,
     language: options.lang,
-    snippet: !(options.full || options.lineNumbers),
     tagsAll: options.tagsAll,
     tagsAny: options.tagsAny,
     since: temporalRange.since,
@@ -265,10 +393,9 @@ export async function searchBm25(
       ftsResult.value.map((f) => f.mirrorHash).filter((h): h is string => !!h)
     ),
   ];
+  const needsAllChunks = Boolean(options.intent || options.exclude?.length);
   const chunksMapResult =
-    store.getChunksBySequenceBatch &&
-    !options.intent &&
-    !options.exclude?.length
+    store.getChunksBySequenceBatch && !needsAllChunks
       ? await store.getChunksBySequenceBatch(
           ftsResult.value
             .filter((row) => !!row.mirrorHash)
@@ -278,6 +405,10 @@ export async function searchBm25(
   const getChunk = chunksMapResult.ok
     ? createChunkLookup(chunksMapResult.value)
     : () => undefined;
+  const allChunks =
+    chunksMapResult.ok && (needsAllChunks || !store.getChunksBySequenceBatch)
+      ? chunksMapResult.value
+      : undefined;
 
   // Dedup: multiple docs can share mirror_hash (content-addressed storage)
   // Track seen uri+seq to eliminate duplicate rows from join fan-out
@@ -326,11 +457,7 @@ export async function searchBm25(
 
     const excluded =
       matchesExcludedText(
-        [
-          fts.title ?? "",
-          fts.recordSourcePath ?? fts.relPath ?? "",
-          fts.snippet ?? "",
-        ],
+        [fts.title ?? "", fts.recordSourcePath ?? fts.relPath ?? ""],
         options.exclude
       ) ||
       matchesExcludedChunks(
@@ -464,6 +591,9 @@ export async function searchBm25(
   }
 
   const finalResults = filteredResults.slice(0, limit);
+  if (!(options.full || options.lineNumbers)) {
+    await attachChunkSnippets(store, finalResults, query, options, allChunks);
+  }
   for (const [index, result] of finalResults.entries()) {
     const metadata = result[SEARCH_RESULT_PLANNER_METADATA];
     if (metadata) metadata.retrievalRank = index + 1;

package/src/sdk/client.ts

@@ -189,6 +189,7 @@ import {
   withContentTypeRules,
 } from "../ingestion";
 import { updateFrontmatterTags } from "../ingestion/frontmatter";
+import { withCollectionRootErrors } from "../ingestion/source-availability/root";
 import {
   withInferenceScope,
   finishInferenceCleanup,
@@ -210,7 +211,10 @@ import { runAutomationProfile } from "../sessions/automation";
 import { assertSessionBinding } from "../sessions/binding";
 import { SessionsService } from "../sessions/service";
 import { SESSIONS_VALIDATION_CODES, SessionsError } from "../sessions/types";
-import { SqliteAdapter } from "../store/sqlite/adapter";
+import {
+  SqliteAdapter,
+  staleCollectionsMessage,
+} from "../store/sqlite/adapter";
 import { openScopedIndexStore } from "../store/sqlite/scoped-index";
 import { createVectorIndexPort } from "../store/vector";
 import {
@@ -462,6 +466,14 @@ class GnoClientImpl implements GnoClient {
     if (!this.isOpen()) {
       throw sdkError("RUNTIME", "GNO client is closed");
     }
+    // Another client may have indexed a collection this config omits since
+    // this one opened; never read it.
+    const stale = this.store.staleIndexedCollections(
+      this.config.collections.map(({ name }) => name)
+    );
+    if (stale.length > 0) {
+      throw sdkError("RUNTIME", staleCollectionsMessage(stale));
+    }
   }
 
   private getCollections(collection?: string) {
@@ -1541,7 +1553,7 @@ class GnoClientImpl implements GnoClient {
       })
     );
     return {
-      ...status,
+      ...(await withCollectionRootErrors(status, this.config.collections)),
       contentTypeBoost: buildContentTypeBoostStatus(
         this.config.contentTypes ?? []
       ),

package/src/sdk/types.ts

@@ -90,6 +90,7 @@ import type {
   SectionTargetV1,
 } from "../core/sections";
 import type { SyncResult } from "../ingestion";
+import type { CollectionRootError } from "../ingestion/source-availability/root";
 import type { DownloadPolicy } from "../llm/policy";
 import type {
   AskOptions,
@@ -193,7 +194,11 @@ export type GnoVectorSearchOptions = Omit<
 export type GnoContextInput = Omit<ContextCapsuleBuildInput, "indexName"> &
   GnoProjectHintOptions;
 export type GnoContextResult = ContextCapsuleV1;
-export type GnoIndexStatus = IndexStatus & {
+export type GnoIndexStatus = Omit<IndexStatus, "collections"> & {
+  /** `rootError` is set while a collection's folder is missing or unreadable. */
+  collections: Array<
+    IndexStatus["collections"][number] & { rootError?: CollectionRootError }
+  >;
   contentTypeBoost: ContentTypeBoostStatus;
 };
 export type GnoContextVerificationResult = ContextCapsuleVerification;

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

@@ -29,7 +29,7 @@ interface Option {
 }
 
 const options: Option[] = [
-  { id: "fast", label: "Fast", timing: "BM25", icon: Rabbit },
+  { id: "fast", label: "Fast", timing: "<1s", icon: Rabbit },
   { id: "balanced", label: "Balanced", timing: "~2s", icon: Gauge },
   { id: "thorough", label: "Thorough", timing: "~5s", icon: Sparkles },
 ];