@gmickel/gno 2.6.0 → 2.7.0

package/spec/output-schemas/search-result.schema.json

@@ -78,7 +78,7 @@
       "properties": {
         "absPath": {
           "type": "string",
-          "description": "Absolute path (included with --source or in MCP)"
+          "description": "Absolute source path. Host path: local callers only (CLI, stdio MCP, same-host Web UI/REST); omitted for remote REST and HTTP MCP callers, which identify the document by uri + relPath."
         },
         "relPath": {
           "type": "string",

package/spec/output-schemas/search-results.schema.json

@@ -237,7 +237,7 @@
           "properties": {
             "absPath": {
               "type": "string",
-              "description": "Absolute filesystem path when resolvable from collection root + relPath. Default field on gno search --json (no --source flag). Omitted when unresolvable; consumers fall back to the URI tail for display and disable file-open."
+              "description": "Absolute filesystem path when resolvable from collection root + relPath. Default field on gno search --json (no --source flag). Omitted when unresolvable, and always omitted for remote REST and HTTP MCP callers (host paths reach only CLI, stdio MCP and same-host Web UI/REST callers); consumers fall back to uri + relPath for display and disable file-open."
             },
             "relPath": {
               "type": "string",

package/spec/output-schemas/status.schema.json

@@ -150,6 +150,104 @@
       "description": "Chunks awaiting embedding",
       "minimum": 0
     },
+    "vectorPartitions": {
+      "type": "array",
+      "description": "Vector partitions of the embedding model; omitted when none exist",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "id",
+          "model",
+          "dimensions",
+          "state",
+          "legacy",
+          "retrieval",
+          "droppable",
+          "owners",
+          "provenance",
+          "compatibleRuntimes",
+          "incompatibleRuntimes"
+        ],
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "Partition id (drop with `gno vec drop <id-prefix>`)"
+          },
+          "model": {
+            "type": "string",
+            "description": "Embedding model URI"
+          },
+          "dimensions": {
+            "type": "integer",
+            "minimum": 1
+          },
+          "state": {
+            "type": "string",
+            "enum": ["active", "shadow"],
+            "description": "active = activated for retrieval; shadow = incomplete or abandoned"
+          },
+          "legacy": {
+            "type": "boolean",
+            "description": "Pre-runtime-independent key, awaiting measured re-keying"
+          },
+          "retrieval": {
+            "type": "boolean",
+            "description": "Status counts use this partition: the activated runtime-independent partition every compatible runtime reads"
+          },
+          "droppable": {
+            "type": "boolean",
+            "description": "`gno vec drop` accepts it; never the partition this runtime's retrieval uses"
+          },
+          "owners": {
+            "type": "integer",
+            "minimum": 0,
+            "description": "Current chunks bound to this partition"
+          },
+          "provenance": {
+            "type": "string",
+            "description": "Runtime that built the partition, e.g. \"CUDA, Bun 1.4.2\""
+          },
+          "compatibleRuntimes": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "Runtimes measured (or recorded as the builder) to read this partition"
+          },
+          "incompatibleRuntimes": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "Runtimes measured incompatible; they read another partition or use lexical retrieval only"
+          }
+        }
+      }
+    },
+    "vectorRuntime": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["label", "state", "partition"],
+      "description": "This process's runtime, resolved by the same selection rule its queries use",
+      "properties": {
+        "label": {
+          "type": ["string", "null"],
+          "description": "Runtime recorded by this caller's last query or embed"
+        },
+        "state": {
+          "type": "string",
+          "enum": ["vectors", "unavailable", "unresolved"],
+          "description": "vectors: queries read `partition`; unavailable: lexical retrieval only; unresolved: no query or embed has resolved this caller yet"
+        },
+        "partition": {
+          "type": ["string", "null"]
+        },
+        "reason": {
+          "type": "string"
+        }
+      }
+    },
     "recentErrors": {
       "type": "integer",
       "description": "Recent ingest errors in the last 24 hours",

package/src/cli/commands/doctor.ts

@@ -12,6 +12,10 @@ import { arch, platform } from "node:os";
 
 import type { Config } from "../../config/types";
 import type { ActivationStatus } from "../../core/activation-status";
+import type {
+  VectorPartitionStatus,
+  VectorRuntimeStatus,
+} from "../../store/vector/status";
 
 import { getIndexDbPath, getModelsCachePath } from "../../app/constants";
 import {
@@ -26,6 +30,7 @@ import {
   readFindingsRunStatus,
   resolveFindingsSchedule,
 } from "../../core/findings-run-state";
+import { formatVectorPartitionLines } from "../../core/vector-partition-status";
 import { getCodeChunkingStatus } from "../../ingestion/chunker";
 import { ModelCache } from "../../llm/cache";
 import { getActivePreset, resolveModelUri } from "../../llm/registry";
@@ -57,6 +62,9 @@ export interface DoctorCheck {
   details?: string[];
   /** Embedding fingerprint diagnostics for machine consumers */
   embeddingFingerprint?: EmbeddingFingerprintHealth;
+  /** Vector partitions; `retrieval` marks the one status and search use */
+  vectorPartitions?: VectorPartitionStatus[];
+  vectorRuntime?: VectorRuntimeStatus;
 }
 
 export interface EmbeddingFingerprintGroup {
@@ -261,16 +269,18 @@ function describeFingerprintGroup(group: EmbeddingFingerprintGroup): string {
 async function checkEmbeddingFingerprints(
   config: Config,
   indexName?: string
-): Promise<DoctorCheck> {
+): Promise<DoctorCheck[]> {
   const dbPath = getIndexDbPath(indexName);
   try {
     await stat(dbPath);
   } catch {
-    return {
-      name: "embedding-fingerprint",
-      status: "warn",
-      message: "Database not found. Run: gno init",
-    };
+    return [
+      {
+        name: "embedding-fingerprint",
+        status: "warn",
+        message: "Database not found. Run: gno init",
+      },
+    ];
   }
 
   const store = new SqliteAdapter();
@@ -283,12 +293,14 @@ async function checkEmbeddingFingerprints(
     config.busyTimeoutMs ?? DEFAULT_BUSY_TIMEOUT_MS
   );
   if (!openResult.ok) {
-    return {
-      name: "embedding-fingerprint",
-      status: "warn",
-      message: `Fingerprint health unavailable: ${openResult.error.message}`,
-      details: ["Run: gno doctor --json", "Then run: gno embed"],
-    };
+    return [
+      {
+        name: "embedding-fingerprint",
+        status: "warn",
+        message: `Fingerprint health unavailable: ${openResult.error.message}`,
+        details: ["Run: gno doctor --json", "Then run: gno embed"],
+      },
+    ];
   }
 
   try {
@@ -297,12 +309,14 @@ async function checkEmbeddingFingerprints(
     const currentFingerprint = getStoredEmbeddingFingerprint(db, model);
     const statusResult = await store.getStatus({ embedModel: model });
     if (!statusResult.ok) {
-      return {
-        name: "embedding-fingerprint",
-        status: "warn",
-        message: `Fingerprint health unavailable: ${statusResult.error.message}`,
-        details: ["Run: gno embed"],
-      };
+      return [
+        {
+          name: "embedding-fingerprint",
+          status: "warn",
+          message: `Fingerprint health unavailable: ${statusResult.error.message}`,
+          details: ["Run: gno embed"],
+        },
+      ];
     }
 
     const legacyChunks =
@@ -389,13 +403,33 @@ async function checkEmbeddingFingerprints(
       }
     }
 
-    return {
+    const fingerprintCheck: DoctorCheck = {
       name: "embedding-fingerprint",
       status: hasWarnings ? "warn" : "ok",
       message,
       details: details.length > 0 ? details : undefined,
       embeddingFingerprint: health,
     };
+    const partitions = statusResult.value.vectorPartitions;
+    if (!partitions) return [fingerprintCheck];
+    const runtime = statusResult.value.vectorRuntime;
+    const partitionLines = formatVectorPartitionLines(partitions, runtime);
+    const retrieval = partitions.find((p) => p.retrieval);
+    return [
+      fingerprintCheck,
+      {
+        name: "vector-partitions",
+        status: partitionLines.length ? "warn" : "ok",
+        message: retrieval
+          ? `this runtime's retrieval uses ${retrieval.id.slice(0, 12)} (${retrieval.state}, ${retrieval.owners} chunks, ${retrieval.provenance}); ${partitions.length - 1} other partition(s)`
+          : runtime?.state === "unavailable"
+            ? `this runtime uses lexical retrieval only: ${runtime.reason}`
+            : `this runtime has not resolved a partition yet; ${partitions.length} partition(s)`,
+        details: partitionLines.length ? partitionLines.slice(1) : undefined,
+        vectorPartitions: partitions,
+        vectorRuntime: runtime,
+      },
+    ];
   } finally {
     await store.close();
   }
@@ -669,7 +703,7 @@ export async function doctor(
   checks.push(checkCodeChunking());
 
   // Embedding fingerprint freshness
-  checks.push(await checkEmbeddingFingerprints(config, options.indexName));
+  checks.push(...(await checkEmbeddingFingerprints(config, options.indexName)));
 
   // Scheduled findings pass (daemon-only, opt-in)
   checks.push(await checkFindingsPass(config, options.indexName));

package/src/cli/commands/embed.ts

@@ -7,6 +7,9 @@
 
 import type { Database } from "bun:sqlite";
 
+// node:readline/promises is the platform line-input API; Bun has no equivalent
+import { createInterface } from "node:readline/promises";
+
 import type { EmbeddingPort } from "../../llm/types";
 import type { StoreResult } from "../../store/types";
 
@@ -77,8 +80,10 @@ export interface EmbedOptions extends CliWriteLeaseOptions {
   force?: boolean;
   /** Show what would be done without embedding */
   dryRun?: boolean;
-  /** Skip confirmation prompts */
+  /** Skip confirmation prompts (never confirms a separate vector partition) */
   yes?: boolean;
+  /** Explicitly confirm building a separate vector partition */
+  newPartition?: boolean;
   /** Output as JSON */
   json?: boolean;
   /** Verbose error logging */
@@ -450,6 +455,24 @@ async function initEmbedContext(
   return { ok: true, config, modelUri, store };
 }
 
+async function confirmSeparatePartition(message: string): Promise<boolean> {
+  process.stderr.write(`${message}\n`);
+  const prompt = createInterface({
+    input: process.stdin,
+    output: process.stderr,
+  });
+  try {
+    const answer = await prompt.question(
+      "Build the separate partition? [y/N] "
+    );
+    return /^(?:y|yes)$/i.test(answer.trim());
+  } catch {
+    return false;
+  } finally {
+    prompt.close();
+  }
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Main Command
 // ─────────────────────────────────────────────────────────────────────────────
@@ -574,7 +597,7 @@ export async function embed(options: EmbedOptions = {}): Promise<EmbedResult> {
         }
         vectorIndex = vectorResult.value;
 
-        const prepared = await prepareEmbeddingBacklog({
+        const backlogDeps = {
           statsPort: stats,
           embedPort,
           vectorIndex,
@@ -582,7 +605,22 @@ export async function embed(options: EmbedOptions = {}): Promise<EmbedResult> {
           collection: options.collection,
           batchSize,
           force,
-        });
+          allowNewPartition: options.newPartition,
+        };
+        let prepared = await prepareEmbeddingBacklog(backlogDeps);
+        if (
+          !prepared.ok &&
+          prepared.error.code === "VECTOR_PARTITION_FORK" &&
+          !dryRun &&
+          !options.json &&
+          !options.yes &&
+          process.stdin.isTTY &&
+          (await confirmSeparatePartition(prepared.error.message))
+        )
+          prepared = await prepareEmbeddingBacklog({
+            ...backlogDeps,
+            allowNewPartition: true,
+          });
         if (!prepared.ok)
           return { success: false, error: prepared.error.message };
         if (prepared.value.variantStore) {

package/src/cli/commands/query.ts

@@ -37,6 +37,7 @@ import {
   createVectorIndexPort,
   type VectorIndexPort,
 } from "../../store/vector";
+import { VECTOR_RUNTIME_INCOMPATIBLE } from "../../store/vector/variant-search";
 import { getGlobals } from "../program";
 import {
   createProgressRenderer,
@@ -517,6 +518,10 @@ export function formatQuery(
   }
   // Output explain to stderr if present (async but best-effort)
   outputExplainToStderr(result.data);
+  if (options.format !== "json")
+    for (const warning of result.data.meta.warnings ?? [])
+      if (warning.code === VECTOR_RUNTIME_INCOMPATIBLE)
+        process.stderr.write(`Warning: ${warning.message}\n`);
 
   // Use shared formatter for consistent output
   // Dynamic import to keep module loading fast

package/src/cli/commands/status.ts

@@ -8,6 +8,7 @@
 import type { ContentTypeBoostStatus } from "../../config/content-types";
 import type { ActivationStatus } from "../../core/activation-status";
 import type { MemoryStatus } from "../../core/memory-diagnostics";
+import type { BackgroundIssue } from "../../serve/status-model";
 import type { IndexStatus } from "../../store/types";
 
 import { getIndexDbPath, getModelsCachePath } from "../../app/constants";
@@ -24,11 +25,18 @@ import {
   buildMemoryStatus,
   formatMemoryStatusLines,
 } from "../../core/memory-diagnostics";
+import { formatVectorPartitionLines } from "../../core/vector-partition-status";
 import { ModelCache } from "../../llm/cache";
 import { getActivePreset, resolveModelUri } from "../../llm/registry";
 import { getConnectorVerificationTargets } from "../../serve/connectors";
 import { createStandaloneResidentStatus } from "../../serve/resident-status";
 import { SqliteAdapter } from "../../store/sqlite/adapter";
+import {
+  formatBackgroundIssue,
+  residentIssues,
+  resolveProcessPaths,
+  statusProcess,
+} from "../detach";
 
 /**
  * Options for status command.
@@ -54,9 +62,35 @@ export type StatusResult =
       activation: ActivationStatus;
       contentTypeBoost: ContentTypeBoostStatus;
       memory: MemoryStatus;
+      backgroundIssues: ResidentBackgroundIssue[];
     }
   | { success: false; error: string };
 
+/** A background issue reported by (or about) a running detached resident. */
+export type ResidentBackgroundIssue = BackgroundIssue & {
+  process: "serve" | "daemon";
+  pid: number;
+};
+
+/**
+ * Ask each detached resident for its background issues. Each request is
+ * bounded (500ms), so a hung resident is reported, never waited on.
+ */
+async function collectResidentIssues(): Promise<ResidentBackgroundIssue[]> {
+  const statuses = await Promise.all(
+    (["serve", "daemon"] as const).map((kind) =>
+      statusProcess({ kind, ...resolveProcessPaths(kind) })
+    )
+  );
+  return statuses.flatMap((processStatus) =>
+    residentIssues(processStatus).map((issue) => ({
+      process: processStatus.cmd,
+      pid: processStatus.pid ?? 0,
+      ...issue,
+    }))
+  );
+}
+
 function connectorProjectionLine(activation: ActivationStatus): string | null {
   const { projected, total, truncated } = activation.connectorProjection;
   if (!truncated) {
@@ -117,6 +151,12 @@ function formatTerminal(
   if (indexStatus.embeddingBacklog > 0) {
     lines.push(`Embedding backlog: ${indexStatus.embeddingBacklog} chunks`);
   }
+  lines.push(
+    ...formatVectorPartitionLines(
+      indexStatus.vectorPartitions,
+      indexStatus.vectorRuntime
+    )
+  );
 
   const chunking = formatChunkingStatus(indexStatus.chunking);
   if (chunking) lines.push(chunking);
@@ -205,6 +245,11 @@ function formatMarkdown(
   lines.push(`- **Documents**: ${indexStatus.activeDocuments}`);
   lines.push(`- **Chunks**: ${indexStatus.totalChunks}`);
   lines.push(`- **Embedding backlog**: ${indexStatus.embeddingBacklog}`);
+  for (const line of formatVectorPartitionLines(
+    indexStatus.vectorPartitions,
+    indexStatus.vectorRuntime
+  ))
+    lines.push(`- ${line.trim()}`);
   if (indexStatus.typedMetadata)
     lines.push(
       `- **Typed metadata**: ${indexStatus.typedMetadata.pending} pending sync, ${indexStatus.typedMetadata.invalid} invalid`
@@ -318,6 +363,7 @@ export async function status(
       activation,
       contentTypeBoost: buildContentTypeBoostStatus(config.contentTypes ?? []),
       memory: await buildMemoryStatus(store, config.collections),
+      backgroundIssues: await collectResidentIssues(),
     };
   } finally {
     await store.close();
@@ -356,6 +402,8 @@ export function formatStatus(
         totalDocuments: s.activeDocuments,
         totalChunks: s.totalChunks,
         embeddingBacklog: s.embeddingBacklog,
+        vectorPartitions: s.vectorPartitions,
+        vectorRuntime: s.vectorRuntime,
         typedMetadata: s.typedMetadata,
         chunking: s.chunking,
         lastUpdated: s.lastUpdatedAt,
@@ -363,6 +411,9 @@ export function formatStatus(
         contentTypeBoost: result.contentTypeBoost,
         activation: result.activation,
         memory: result.memory,
+        ...(result.backgroundIssues.length
+          ? { backgroundIssues: result.backgroundIssues }
+          : {}),
       },
       null,
       2
@@ -378,10 +429,17 @@ export function formatStatus(
     );
   }
 
-  return formatTerminal(
-    result.status,
-    result.activation,
-    result.contentTypeBoost,
-    result.memory
+  const issueLines = result.backgroundIssues.map(
+    (issue) =>
+      `  ${issue.process} (pid ${issue.pid}): ${formatBackgroundIssue(issue)}`
   );
+  return [
+    formatTerminal(
+      result.status,
+      result.activation,
+      result.contentTypeBoost,
+      result.memory
+    ),
+    ...(issueLines.length ? ["", "Background issues:", ...issueLines] : []),
+  ].join("\n");
 }

package/src/cli/commands/vec.ts

@@ -13,6 +13,10 @@ import {
   createVectorIndexPort,
   createVectorStatsPort,
 } from "../../store/vector";
+import {
+  dropVectorPartition,
+  type VectorPartitionStatus,
+} from "../../store/vector/status";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Types
@@ -294,3 +298,53 @@ export function formatVecRebuild(
 
   return `Vec index rebuilt: ${result.count.toLocaleString()} vectors`;
 }
+
+export type VecDropResult =
+  | { success: true; partition: VectorPartitionStatus }
+  | { success: false; error: string };
+
+/**
+ * Drop an abandoned vector partition (shadow or legacy). Active partitions
+ * that retrieval uses are refused.
+ */
+export async function vecDrop(
+  partition: string,
+  options: VecOptions = {}
+): Promise<VecDropResult> {
+  if (!(await isInitialized(options.configPath)))
+    return { success: false, error: "GNO not initialized. Run: gno init" };
+  const configResult = await loadConfig(options.configPath);
+  if (!configResult.ok)
+    return { success: false, error: configResult.error.message };
+  const store = new SqliteAdapter();
+  const openResult = await store.open(
+    getIndexDbPath(options.indexName),
+    configResult.value.ftsTokenizer,
+    configResult.value.busyTimeoutMs
+  );
+  if (!openResult.ok)
+    return { success: false, error: openResult.error.message };
+  try {
+    const dropped = await dropVectorPartition(store.getRawDb(), partition);
+    return dropped.ok
+      ? { success: true, partition: dropped.partition }
+      : { success: false, error: dropped.error };
+  } finally {
+    await store.close();
+  }
+}
+
+export function formatVecDrop(
+  result: VecDropResult,
+  options: { json?: boolean }
+): string {
+  if (!result.success) {
+    return options.json
+      ? JSON.stringify({ error: { code: "RUNTIME", message: result.error } })
+      : `Error: ${result.error}`;
+  }
+  const { partition } = result;
+  return options.json
+    ? JSON.stringify({ dropped: partition }, null, 2)
+    : `Dropped ${partition.state} partition ${partition.id.slice(0, 12)} (${partition.provenance}, ${partition.owners} chunks)`;
+}

package/src/cli/detach.ts

@@ -20,7 +20,7 @@ import { mkdir, stat, unlink } from "node:fs/promises";
 // node:path — no Bun path utils.
 import { dirname, join } from "node:path";
 
-import type { ResidentStatus } from "../serve/status-model";
+import type { BackgroundIssue, ResidentStatus } from "../serve/status-model";
 
 import { VERSION, resolveDirs } from "../app/constants";
 import { toAbsolutePath } from "../config/paths";
@@ -840,6 +840,34 @@ export async function statusProcess(
   };
 }
 
+/** Issues a running detached resident reports, or that it failed to answer at all. */
+export function residentIssues(status: ProcessStatus): BackgroundIssue[] {
+  if (!status.running) return [];
+  if (!status.resident)
+    return [
+      {
+        job: "resident",
+        state: "unresponsive",
+        consecutiveFailures: 0,
+        runningSeconds: null,
+      },
+    ];
+  return status.resident.backgroundIssues ?? [];
+}
+
+export function formatBackgroundIssue(issue: BackgroundIssue): string {
+  switch (issue.state) {
+    case "unresponsive":
+      return "resident did not answer its status request within 500ms (busy or hung)";
+    case "failing":
+      return `background embed failing (${issue.consecutiveFailures} failed passes in a row; details in the log)`;
+    case "parked":
+      return `background embed parked after ${issue.consecutiveFailures} failed passes; pending chunks wait for new changes or \`gno embed\``;
+    case "overrunning":
+      return `background embed pass running for ${issue.runningSeconds ?? 0}s`;
+  }
+}
+
 /**
  * Inspect the pid-file for a "live-foreign" signal — a live pid whose
  * recorded gno version disagrees with the currently running binary. Returns

package/src/cli/errors.ts

@@ -9,15 +9,19 @@
 // Error Types
 // ─────────────────────────────────────────────────────────────────────────────
 
-export type CliErrorCode =
-  | "VALIDATION"
-  | "RUNTIME"
-  | "NOT_RUNNING"
-  | "BUSY"
-  | "AUDIT_FINDINGS"
-  | "AUDIT_PARTIAL"
-  | "CONTEXT_STALE"
-  | "CONTEXT_CONFLICT";
+/** Every code the CLI error model can emit; `error.schema.json` must list each. */
+export const CLI_ERROR_CODES = [
+  "VALIDATION",
+  "RUNTIME",
+  "NOT_RUNNING",
+  "BUSY",
+  "AUDIT_FINDINGS",
+  "AUDIT_PARTIAL",
+  "CONTEXT_STALE",
+  "CONTEXT_CONFLICT",
+] as const;
+
+export type CliErrorCode = (typeof CLI_ERROR_CODES)[number];
 
 export interface CliErrorOptions {
   details?: Record<string, unknown>;