@gmickel/gno 2.6.0 → 2.7.0

package/src/embed/variant-retry.ts

@@ -5,7 +5,9 @@ import type { VectorVariantStore } from "../store/vector/variants";
 import { err, ok } from "../store/types";
 import { embedTextsWithRecovery } from "./batch";
 import {
+  type AcquireWriteTurn,
   chunkRetryKey,
+  inWriteTurn,
   isUpsertLockContention,
   upsertVectorsWithContentionRetry,
 } from "./retry";
@@ -30,11 +32,14 @@ export async function embedVariantBatch(params: {
   identityStillCurrent: () => boolean;
   delays?: number[];
   force?: boolean;
+  /** Gate held only around the checkpoint write, never around inference. */
+  acquireWriteTurn?: AcquireWriteTurn;
 }): Promise<{
   embedded: number;
   errors: number;
   contentionErrors: number;
   retryOwners: VectorOwnerInput[];
+  deferred?: boolean;
 }> {
   const { store, embedPort, identityStillCurrent } = params;
   const empty = {
@@ -76,30 +81,34 @@ export async function embedVariantBatch(params: {
     .map((owner) => ({ owner, embedding: vectors.get(owner.inputHash) }));
   if (!rows.length) return { ...empty, retryOwners };
   let written = 0;
-  const persisted = await upsertVectorsWithContentionRetry(
-    {
-      upsertVectors: () => {
-        try {
-          // A contention wait may allow document or runtime mutations. Revalidate each attempt.
-          if (!identityStillCurrent()) return Promise.resolve(ok(undefined));
-          const valid = rows.filter(({ owner }) => isCurrent(store, owner));
-          store.write(valid);
-          written = valid.length;
-          return Promise.resolve(ok(undefined));
-        } catch (cause) {
-          return Promise.resolve(
-            err(
-              "QUERY_FAILED",
-              cause instanceof Error ? cause.message : String(cause),
-              cause
-            )
-          );
-        }
+  const turn = await inWriteTurn(params.acquireWriteTurn, () =>
+    upsertVectorsWithContentionRetry(
+      {
+        upsertVectors: () => {
+          try {
+            // A contention wait may allow document or runtime mutations. Revalidate each attempt.
+            if (!identityStillCurrent()) return Promise.resolve(ok(undefined));
+            const valid = rows.filter(({ owner }) => isCurrent(store, owner));
+            store.write(valid);
+            written = valid.length;
+            return Promise.resolve(ok(undefined));
+          } catch (cause) {
+            return Promise.resolve(
+              err(
+                "QUERY_FAILED",
+                cause instanceof Error ? cause.message : String(cause),
+                cause
+              )
+            );
+          }
+        },
       },
-    },
-    [],
-    params.delays
+      [],
+      params.delays
+    )
   );
+  if (turn.deferred) return { ...empty, deferred: true };
+  const persisted = turn.value;
   if (!persisted.ok)
     return {
       ...empty,

package/src/index.ts

@@ -11,13 +11,32 @@ import { resetModelManager } from "./llm/nodeLlamaCpp/lifecycle";
 import { IMPORT_CHILD_ENV } from "./sessions/import-child-env";
 
 /**
- * Cleanup models and exit.
- * Without this, llama.cpp native threads can keep the process alive.
+ * End `stream` and resolve once its queued writes have reached the OS.
+ * process.exit() drops pending asynchronous pipe writes, so a pipe consumer
+ * would otherwise see output cut at the pipe buffer size. Bun reports no
+ * writableLength and fires an empty write's callback immediately, so end()
+ * is the flush that actually waits. A closed consumer (EPIPE) settles
+ * through the callback or the 'error' event.
+ */
+function flushStream(stream: NodeJS.WriteStream): Promise<void> {
+  if (stream.destroyed || stream.writableEnded) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    stream.once("error", () => resolve());
+    stream.end(() => resolve());
+  });
+}
+
+/**
+ * Cleanup models, flush output, and exit.
+ * Without the explicit exit, llama.cpp native threads can keep the process alive.
  */
 async function cleanupAndExit(code: number): Promise<never> {
   await resetModelManager().catch(() => {
     // Ignore cleanup errors on exit
   });
+  await Promise.all([flushStream(process.stdout), flushStream(process.stderr)]);
   process.exit(code);
 }
 

package/src/llm/native-worker/dispatcher.ts

@@ -15,6 +15,7 @@ import {
   fileIdentity,
   fingerprintModel,
   fingerprintRuntime,
+  runtimeLabel,
 } from "./embedding-identity";
 import { NativeWorkerError } from "./errors";
 import { checkEvaluation } from "./evaluation";
@@ -174,6 +175,7 @@ export class NativeDispatcher {
                   gpu: llama.gpu,
                   cpuMathCores: llama.cpuMathCores,
                 }),
+                runtimeLabel: runtimeLabel(llama.gpu),
               },
             },
           };

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

@@ -31,3 +31,45 @@ export function fingerprintRuntime(settings: Record<string, unknown>): string {
     )
     .digest("hex");
 }
+
+/** Environment that shapes the native runtime identity of an embedding. */
+const RUNTIME_ENV = [
+  "GNO_LLAMA_GPU",
+  "NODE_LLAMA_CPP_GPU",
+  "GNO_EMBED_CONTEXT_SIZE",
+  "GNO_EMBED_CONTEXTS",
+  "GNO_EMBED_THREADS",
+] as const;
+
+/**
+ * What a process can know about its embedding runtime without loading the
+ * model: status looks up the identity a caller with this key last resolved.
+ */
+export function runtimeCallerKey(
+  model: string,
+  env: NodeJS.ProcessEnv = process.env
+): string {
+  return new Bun.CryptoHasher("sha256")
+    .update(
+      JSON.stringify([
+        model,
+        Bun.version,
+        nativePackage.version,
+        process.platform,
+        process.arch,
+        RUNTIME_ENV.map((name) => env[name] ?? null),
+      ])
+    )
+    .digest("hex");
+}
+
+const BACKEND_LABELS: Record<string, string> = {
+  cuda: "CUDA",
+  metal: "Metal",
+  vulkan: "Vulkan",
+};
+
+/** Readable provenance for status output; identity stays the fingerprint. */
+export function runtimeLabel(gpu: string | false): string {
+  return `${gpu ? (BACKEND_LABELS[gpu] ?? gpu) : "CPU"}, Bun ${Bun.version}`;
+}

package/src/llm/native-worker/protocol.ts

@@ -112,6 +112,7 @@ export const EmbeddingIdentitySchema = z.strictObject({
   truncationPolicy: z.string().min(1),
   modelFingerprint: z.string().regex(/^[a-f0-9]{64}$/),
   runtimeFingerprint: z.string().regex(/^[a-f0-9]{64}$/),
+  runtimeLabel: z.string().min(1),
 });
 const metadata = z.strictObject({
   dimensions: id.optional(),

package/src/llm/types.ts

@@ -95,7 +95,10 @@ export interface EmbeddingIdentity {
   /** Versioned policy including the effective token limit. */
   truncationPolicy: string;
   modelFingerprint: string;
+  /** Runtime provenance (Bun, binding, backend, threads); not vector identity. */
   runtimeFingerprint: string;
+  /** Readable provenance such as "CUDA, Bun 1.4.2". */
+  runtimeLabel?: string;
 }
 
 export interface EmbeddingPort {

package/src/mcp/context.ts

@@ -120,6 +120,15 @@ export interface ToolContext {
   runWithSnapshot?<T>(operation: () => Promise<T>): Promise<T>;
 }
 
+/**
+ * Host absolute paths reach only stdio callers, which run on the owner's
+ * machine. Every Streamable HTTP request runs inside an egress context,
+ * whatever its peer, so HTTP callers get URIs and relative paths only.
+ */
+export const exposesHostPaths = (
+  ctx: Pick<ToolContext, "getEgressContext">
+): boolean => ctx.getEgressContext?.() === undefined;
+
 export interface CreateToolContextOptions {
   store: SqliteAdapter;
   getConfig: () => Config;

package/src/mcp/resources/index.ts

@@ -21,6 +21,7 @@ import { resolveEffectiveIndex } from "../../core/indexed-reference";
 import { normalizeTag, validateTag } from "../../core/tags";
 import { normalizeCollectionName } from "../../core/validation";
 import { openScopedIndexStore } from "../../store/sqlite/scoped-index";
+import { exposesHostPaths } from "../context";
 
 // Tags resource URI prefix
 const TAGS_URI = `${URI_PREFIX}tags`;
@@ -53,15 +54,15 @@ function formatResourceContent(
   ctx: ToolContext,
   indexName = ctx.indexName
 ): string {
-  // Find collection for absPath
+  // Host path for stdio callers; HTTP callers see the relative path.
   const uriParsed = parseUri(doc.uri);
-  let absPath = doc.relPath;
-  if (uriParsed) {
+  let source = doc.relPath;
+  if (uriParsed && exposesHostPaths(ctx)) {
     const collection = ctx.collections.find(
       (c) => c.name === uriParsed.collection
     );
     if (collection) {
-      absPath = pathJoin(collection.path, doc.relPath);
+      source = pathJoin(collection.path, doc.relPath);
     }
   }
 
@@ -72,7 +73,7 @@ function formatResourceContent(
   const displayUri = decorateUriForIndex(doc.uri, indexName);
   const header = `<!-- ${displayUri}
      docid: ${doc.docid}
-     source: ${absPath}
+     source: ${source}
      mime: ${doc.sourceMime}${langLine}
 -->
 

package/src/mcp/tool-descriptions-core.ts

@@ -32,7 +32,7 @@ export const MCP_CORE_TOOL_DESCRIPTIONS: Readonly<Record<string, string>> = {
   gno_recall:
     "Call before answering about the user's preferences, decisions, people, or prior work, and before gno_remember to find the predecessor of a changed fact. Retrieves current facts from a memory-managed collection for the explicit scopes you pass; superseded facts are excluded. Returns at most 8 facts within 512 tokens by default, each with text, scopes, provenance, gno:// cite, and content hash, plus a content-free receipt. Pass that receipt to gno_remember when a stored fact derives from this recall. An empty result names the command that stores the first fact.",
   gno_capture:
-    "Call to create a new note from text the user wants kept: pass collection and content (or a presetId scaffold), optionally title, path or folderPath, tags, and source provenance. Writes the file to disk with source: frontmatter, syncs it for keyword search, and returns a receipt with uri, docid, relPath, absPath, contentHash, collisionPolicyResult, and sync and embed status. Embedding is a separate step (embed.status stays short of completed until gno_index or gno_embed runs), so vector search sees the note later. An existing target follows collisionPolicy: error, open_existing, or create_with_suffix.",
+    "Call to create a new note from text the user wants kept: pass collection and content (or a presetId scaffold), optionally title, path or folderPath, tags, and source provenance. Writes the file to disk with source: frontmatter, syncs it for keyword search, and returns a receipt with uri, docid, relPath, absPath (stdio only), contentHash, collisionPolicyResult, and sync and embed status. Embedding is a separate step (embed.status stays short of completed until gno_index or gno_embed runs), so vector search sees the note later. An existing target follows collisionPolicy: error, open_existing, or create_with_suffix.",
   gno_remember:
     "Call when the user states a durable preference, decision, or fact worth recalling later; documents go through gno_capture and existing notes through file edits. Stores one fact in a memory-managed collection under the explicit scopes you pass. Without decision it returns likely matches and writes nothing; decision=add writes a new fact; decision=supersede replaces predecessorUri after a hash check, one successor per fact. Returns outcome (candidates, existing, added, or superseded) with the stored record; an exact duplicate returns the existing record. Text that replays a recall receipt span or declares a gno:// origin is rejected. The fact is lexically searchable when the call returns.",
 };

package/src/mcp/tools/capture.ts

@@ -47,7 +47,6 @@ interface CaptureInput extends Omit<
 
 type McpCaptureResult = CaptureReceipt & {
   docid: string;
-  absPath: string;
   overwritten: boolean;
   serverInstanceId: string;
   request?: RequestReceiptInfo;
@@ -80,7 +79,7 @@ function formatCaptureResult(result: McpCaptureResult): string {
   const lines: string[] = [];
   lines.push(`Doc: ${result.docid}`);
   lines.push(`URI: ${result.uri}`);
-  lines.push(`Path: ${result.absPath}`);
+  if (result.absPath) lines.push(`Path: ${result.absPath}`);
   lines.push(`Created: ${result.created ? "yes" : "no"}`);
   lines.push(`Opened existing: ${result.openedExisting ? "yes" : "no"}`);
   lines.push(`Overwritten: ${result.overwritten ? "yes" : "no"}`);
@@ -216,7 +215,6 @@ export function handleCapture(
       return {
         ...published.receipt,
         docid: published.receipt.docid ?? "",
-        absPath: published.receipt.absPath ?? "",
         overwritten: published.receipt.overwritten ?? false,
         serverInstanceId: ctx.serverInstanceId,
         ...(published.request ? { request: published.request } : {}),

package/src/mcp/tools/index.ts

@@ -20,6 +20,7 @@ import {
   compiledContextPreviewSchema,
   compiledContextCheckSchema,
 } from "../../core/compiled-context";
+import { withoutHostPaths } from "../../core/host-paths";
 import { NOTE_PRESETS, type NotePresetId } from "../../core/note-presets";
 import { RETRIEVAL_TRACE_METADATA } from "../../core/retrieval-trace-session";
 import { normalizeTag } from "../../core/tags";
@@ -31,6 +32,7 @@ import {
   assertInferenceActive,
   acquireInferencePermit,
 } from "../../llm/inference-scope";
+import { exposesHostPaths } from "../context";
 import { profileToolDescription } from "../tool-descriptions-core";
 import {
   createProfileToolRegistrar,
@@ -972,6 +974,10 @@ export interface ToolResult {
 // DRY Helper: Exception Firewall + Mutex + Response Shaping
 // ─────────────────────────────────────────────────────────────────────────────
 
+/** Tool data as the current caller may see it (no host paths over HTTP). */
+const forCaller = <T>(ctx: ToolContext, data: T): T =>
+  exposesHostPaths(ctx) ? data : withoutHostPaths(data);
+
 export async function runTool<T>(
   ctx: ToolContext,
   name: string,
@@ -990,12 +996,13 @@ export async function runTool<T>(
   const release = await acquireInferencePermit(() => ctx.toolMutex.acquire());
   try {
     assertInferenceActive();
-    const data = await (ctx.runWithSnapshot?.(fn) ?? fn());
+    const raw = await (ctx.runWithSnapshot?.(fn) ?? fn());
     assertInferenceActive();
     const traceMetadata =
-      data !== null && typeof data === "object"
-        ? (data as Record<PropertyKey, unknown>)[RETRIEVAL_TRACE_METADATA]
+      raw !== null && typeof raw === "object"
+        ? (raw as Record<PropertyKey, unknown>)[RETRIEVAL_TRACE_METADATA]
         : undefined;
+    const data = forCaller(ctx, raw);
     return {
       content: [{ type: "text", text: formatText(data) }],
       structuredContent: data as { [x: string]: unknown },
@@ -1039,7 +1046,7 @@ export async function runToolNoMutex<T>(
 
   try {
     assertInferenceActive();
-    const data = await (ctx.runWithSnapshot?.(fn) ?? fn());
+    const data = forCaller(ctx, await (ctx.runWithSnapshot?.(fn) ?? fn()));
     assertInferenceActive();
     return {
       content: [{ type: "text", text: formatText(data) }],

package/src/mcp/tools/memory-remember.ts

@@ -127,7 +127,7 @@ export function formatRememberResult(result: RememberResult): string {
       lines.push(`Outcome: ${result.outcome}`);
       lines.push(`URI: ${result.record.uri}`);
       lines.push(`Hash: ${result.record.contentHash}`);
-      lines.push(`Path: ${result.absPath}`);
+      if (result.absPath) lines.push(`Path: ${result.absPath}`);
       lines.push(`Sync: ${result.sync.status}`);
       if (result.record.supersedes.length > 0) {
         lines.push(`Supersedes: ${result.record.supersedes.join(", ")}`);

package/src/mcp/tools/status.ts

@@ -9,6 +9,7 @@ import type { ToolContext } from "../server";
 
 import { buildContentTypeBoostStatus } from "../../config/content-types";
 import { formatChunkingStatus } from "../../core/chunking-status";
+import { formatVectorPartitionLines } from "../../core/vector-partition-status";
 import { resolveModelUri } from "../../llm/registry";
 import { createStandaloneResidentStatus } from "../../serve/resident-status";
 import { runTool, type ToolResult } from "./index";
@@ -59,6 +60,9 @@ function formatStatus(status: IndexStatus): string {
   if (status.embeddingBacklog > 0) {
     lines.push(`Embedding backlog: ${status.embeddingBacklog} chunks`);
   }
+  lines.push(
+    ...formatVectorPartitionLines(status.vectorPartitions, status.vectorRuntime)
+  );
 
   const chunking = formatChunkingStatus(status.chunking);
   if (chunking) lines.push(chunking);

package/src/pipeline/hybrid.ts

@@ -33,7 +33,11 @@ import {
   withInferenceScope,
 } from "../llm/inference-scope";
 import { err, ok } from "../store/types";
-import { resolveVectorSearchIdentity } from "../store/vector/variant-search";
+import {
+  lexicalFallbackNotice,
+  resolveVectorSearchIdentity,
+  VECTOR_RUNTIME_INCOMPATIBLE,
+} from "../store/vector/variant-search";
 import { createChunkLookup } from "./chunk-lookup";
 import {
   attachAuxiliaryScoreMetadata,
@@ -284,7 +288,10 @@ async function searchVectorChunks(
     allowedMirrorHashes?: string[];
     eligibility?: VectorSearchOptions["eligibility"];
   }
-): Promise<{ ok: true; chunks: ChunkId[] } | { ok: false; reason: string }> {
+): Promise<
+  | { ok: true; chunks: ChunkId[] }
+  | { ok: false; reason: string; notice?: string }
+> {
   if (!vectorIndex.searchAvailable) {
     return { ok: false, reason: "vector_unavailable" };
   }
@@ -298,12 +305,19 @@ async function searchVectorChunks(
     return { ok: false, reason: "vector_embed_error" };
   }
 
+  const partition = await resolveVectorSearchIdentity(embedPort, vectorIndex);
+  if (partition.unavailable)
+    return {
+      ok: false,
+      reason: VECTOR_RUNTIME_INCOMPATIBLE,
+      notice: lexicalFallbackNotice(partition.unavailable),
+    };
   const queryEmbedding = new Float32Array(embedResult.value);
   const searchResult = await vectorIndex.searchNearest(
     queryEmbedding,
     options.limit,
     {
-      embeddingIdentity: resolveVectorSearchIdentity(embedPort),
+      embeddingIdentity: partition.identity,
       minScore: options.minScore,
       allowedMirrorHashes: options.allowedMirrorHashes,
       eligibility: options.eligibility,
@@ -630,6 +644,7 @@ async function searchHybridWithHydration(
   // Vector search
   let vecCount = 0;
   let vectorsUsed = false;
+  let vectorNotice: string | undefined;
   const vectorAvailable =
     (vectorIndex?.searchAvailable && embedPort !== null) ?? false;
   if (!vectorAvailable) {
@@ -662,8 +677,10 @@ async function searchHybridWithHydration(
         }
       );
 
-      if (!vectorResult.ok) counters.fallbackEvents.push(vectorResult.reason);
-      else vectorsUsed = true;
+      if (!vectorResult.ok) {
+        counters.fallbackEvents.push(vectorResult.reason);
+        vectorNotice = vectorResult.notice;
+      } else vectorsUsed = true;
       const vecChunks = vectorResult.ok ? vectorResult.chunks : [];
       vecCount = vecChunks.length;
       vectorTraceChunks.push(...vecChunks);
@@ -691,8 +708,14 @@ async function searchHybridWithHydration(
       );
 
       assertInferenceResult(embedResult);
+      const partition = embedResult.ok
+        ? await resolveVectorSearchIdentity(embedPort, vectorIndex)
+        : undefined;
       if (!embedResult.ok) {
         counters.fallbackEvents.push("vector_embed_error");
+      } else if (partition?.unavailable) {
+        counters.fallbackEvents.push(VECTOR_RUNTIME_INCOMPATIBLE);
+        vectorNotice = lexicalFallbackNotice(partition.unavailable);
       } else {
         if (embedResult.value.batchFailed) {
           counters.fallbackEvents.push("vector_embed_batch_fallback");
@@ -709,7 +732,7 @@ async function searchHybridWithHydration(
             new Float32Array(embedding),
             variant.limit,
             {
-              embeddingIdentity: resolveVectorSearchIdentity(embedPort),
+              embeddingIdentity: partition?.identity,
               allowedMirrorHashes: options.retrievalScope?.allowedMirrorHashes,
               eligibility: vectorEligibility,
             }
@@ -1390,6 +1413,11 @@ async function searchHybridWithHydration(
       trace: diagnoseTrace,
     },
   };
+  if (vectorNotice)
+    output.meta.warnings = [
+      ...(output.meta.warnings ?? []),
+      { code: VECTOR_RUNTIME_INCOMPATIBLE, message: vectorNotice },
+    ];
   const fallbackCodes = [...new Set(counters.fallbackEvents)].sort();
   const capabilityOutcomes = [
     { capability: "lexical_search", status: "used" as const },
@@ -1400,7 +1428,9 @@ async function searchHybridWithHydration(
             status: "failed" as const,
             reasonCode: fallbackCodes.includes("vector_embed_error")
               ? "vector_embed_error"
-              : "vector_search_error",
+              : vectorNotice
+                ? VECTOR_RUNTIME_INCOMPATIBLE
+                : "vector_search_error",
           }
         : { capability: "semantic_search", status: "used" as const }
       : {

package/src/pipeline/vsearch.ts

@@ -21,7 +21,10 @@ import {
 } from "../llm/inference-scope";
 import { getContentBatch } from "../store/content-batch";
 import { err, ok } from "../store/types";
-import { resolveVectorSearchIdentity } from "../store/vector/variant-search";
+import {
+  resolveVectorSearchIdentity,
+  vectorSearchUnavailableMessage,
+} from "../store/vector/variant-search";
 import { createChunkLookup } from "./chunk-lookup";
 import {
   applyContentTypeBoost,
@@ -144,7 +147,16 @@ async function searchVectorWithEmbeddingOwned(
 
   let embeddingIdentity;
   try {
-    embeddingIdentity = resolveVectorSearchIdentity(deps.embedPort);
+    const partition = await resolveVectorSearchIdentity(
+      deps.embedPort,
+      vectorIndex
+    );
+    if (partition.unavailable)
+      return err(
+        "VEC_SEARCH_UNAVAILABLE",
+        vectorSearchUnavailableMessage(partition.unavailable)
+      );
+    embeddingIdentity = partition.identity;
   } catch (cause) {
     return err(
       "QUERY_FAILED",