@gmickel/gno 1.17.0 → 1.18.0

package/src/mcp/tools/embed.ts

@@ -9,6 +9,7 @@ import type { ToolContext } from "../server";
 import { MCP_ERRORS } from "../../core/errors";
 import { acquireWriteLock, type WriteLockHandle } from "../../core/file-lock";
 import { JobError } from "../../core/job-manager";
+import { recordIndexMutation } from "../../core/mutation-generations";
 import { embedBacklog } from "../../embed";
 import { LlmAdapter } from "../../llm/nodeLlamaCpp/adapter";
 import { resolveModelUri } from "../../llm/registry";
@@ -81,64 +82,73 @@ export function handleEmbed(
           "embed",
           lock,
           async () => {
-            // Create LLM adapter with offline policy (fail-fast, no download)
-            const llm = new LlmAdapter(ctx.config);
-            const embedResult = await llm.createEmbeddingPort(modelUri, {
-              policy: { offline: true, allowDownload: false },
-            });
-
-            if (!embedResult.ok) {
-              throw new Error(
-                `MODEL_NOT_FOUND: Embedding model not cached. ` +
-                  `Model: ${modelUri}. ` +
-                  `Run 'gno models pull embed' first.`
-              );
-            }
-
-            const embedPort = embedResult.value;
-
+            const lease = ctx.acquireModelLease?.();
             try {
-              // Initialize and get dimensions from port interface
-              const initResult = await embedPort.init();
-              if (!initResult.ok) {
-                throw new Error(initResult.error.message);
-              }
-              const dimensions = embedPort.dimensions();
-
-              // Create vector index port
-              const db = ctx.store.getRawDb();
-              const vectorResult = await createVectorIndexPort(db, {
-                model: modelUri,
-                dimensions,
-              });
-              if (!vectorResult.ok) {
-                throw new Error(vectorResult.error.message);
-              }
-              const vectorIndex = vectorResult.value;
-
-              // Create stats port for backlog
-              const statsPort = createVectorStatsPort(db);
-
-              // Run embedding
-              const result = await embedBacklog({
-                statsPort,
-                embedPort,
-                vectorIndex,
-                collection: collection?.name,
-                modelUri,
-                batchSize: 32,
+              // Create LLM adapter with offline policy (fail-fast, no download)
+              const llm = new LlmAdapter(ctx.config);
+              const embedResult = await llm.createEmbeddingPort(modelUri, {
+                policy: { offline: true, allowDownload: false },
               });
 
-              if (!result.ok) {
-                throw new Error(result.error.message);
+              if (!embedResult.ok) {
+                throw new Error(
+                  `MODEL_NOT_FOUND: Embedding model not cached. ` +
+                    `Model: ${modelUri}. ` +
+                    `Run 'gno models pull embed' first.`
+                );
               }
 
-              return {
-                kind: "embed" as const,
-                value: result.value,
-              };
+              const embedPort = embedResult.value;
+
+              try {
+                // Initialize and get dimensions from port interface
+                const initResult = await embedPort.init();
+                if (!initResult.ok) {
+                  throw new Error(initResult.error.message);
+                }
+                const dimensions = embedPort.dimensions();
+
+                // Create vector index port
+                const db = ctx.store.getRawDb();
+                const vectorResult = await createVectorIndexPort(db, {
+                  model: modelUri,
+                  dimensions,
+                });
+                if (!vectorResult.ok) {
+                  throw new Error(vectorResult.error.message);
+                }
+                const vectorIndex = vectorResult.value;
+
+                // Create stats port for backlog
+                const statsPort = createVectorStatsPort(db);
+
+                // Run embedding
+                const result = await embedBacklog({
+                  statsPort,
+                  embedPort,
+                  vectorIndex,
+                  collection: collection?.name,
+                  modelUri,
+                  batchSize: 32,
+                });
+
+                if (!result.ok) {
+                  throw new Error(result.error.message);
+                }
+                recordIndexMutation(
+                  result.value.embedded,
+                  ctx.markIndexMutation
+                );
+
+                return {
+                  kind: "embed" as const,
+                  value: result.value,
+                };
+              } finally {
+                await embedPort.dispose();
+              }
             } finally {
-              await embedPort.dispose();
+              lease?.release();
             }
           }
         );

package/src/mcp/tools/index-cmd.ts

@@ -10,6 +10,10 @@ import type { ToolContext } from "../server";
 import { MCP_ERRORS } from "../../core/errors";
 import { acquireWriteLock, type WriteLockHandle } from "../../core/file-lock";
 import { JobError } from "../../core/job-manager";
+import {
+  recordContentMutation,
+  recordIndexMutation,
+} from "../../core/mutation-generations";
 import { normalizeCollectionName } from "../../core/validation";
 import { embedBacklog } from "../../embed";
 import { defaultSyncService, withContentTypeRules } from "../../ingestion";
@@ -115,86 +119,96 @@ export function handleIndex(
           "index",
           lock,
           async () => {
-            // Phase 1: Sync
-            const syncResult = collection
-              ? await defaultSyncService
-                  .syncCollection(collection, ctx.store, options)
-                  .then((r) => ({
-                    collections: [r],
-                    totalDurationMs: r.durationMs,
-                    totalFilesProcessed: r.filesProcessed,
-                    totalFilesAdded: r.filesAdded,
-                    totalFilesUpdated: r.filesUpdated,
-                    totalFilesErrored: r.filesErrored,
-                    totalFilesSkipped: r.filesSkipped,
-                  }))
-              : await defaultSyncService.syncAll(
-                  ctx.collections,
-                  ctx.store,
-                  options
-                );
-
-            // Phase 2: Embed
-            const llm = new LlmAdapter(ctx.config);
-            const embedResult = await llm.createEmbeddingPort(modelUri, {
-              policy: { offline: true, allowDownload: false },
-            });
-
-            if (!embedResult.ok) {
-              throw new Error(
-                `MODEL_NOT_FOUND: Embedding model not cached. ` +
-                  `Model: ${modelUri}. ` +
-                  `Run 'gno models pull embed' first.`
-              );
-            }
-
-            const embedPort = embedResult.value;
-
+            const lease = ctx.acquireModelLease?.();
             try {
-              // Initialize and get dimensions from port interface
-              const initResult = await embedPort.init();
-              if (!initResult.ok) {
-                throw new Error(initResult.error.message);
-              }
-              const dimensions = embedPort.dimensions();
-
-              // Create vector index port
-              const db = ctx.store.getRawDb();
-              const vectorResult = await createVectorIndexPort(db, {
-                model: modelUri,
-                dimensions,
-              });
-              if (!vectorResult.ok) {
-                throw new Error(vectorResult.error.message);
-              }
-              const vectorIndex = vectorResult.value;
-
-              // Create stats port for backlog
-              const statsPort = createVectorStatsPort(db);
-
-              // Run embedding
-              const backlogResult = await embedBacklog({
-                statsPort,
-                embedPort,
-                vectorIndex,
-                collection: collection?.name,
-                modelUri,
-                batchSize: 32,
+              // Phase 1: Sync
+              const syncResult = collection
+                ? await defaultSyncService
+                    .syncCollection(collection, ctx.store, options)
+                    .then((r) => ({
+                      collections: [r],
+                      totalDurationMs: r.durationMs,
+                      totalFilesProcessed: r.filesProcessed,
+                      totalFilesAdded: r.filesAdded,
+                      totalFilesUpdated: r.filesUpdated,
+                      totalFilesErrored: r.filesErrored,
+                      totalFilesSkipped: r.filesSkipped,
+                    }))
+                : await defaultSyncService.syncAll(
+                    ctx.collections,
+                    ctx.store,
+                    options
+                  );
+              recordContentMutation(syncResult, ctx.markContentMutation);
+
+              // Phase 2: Embed
+              const llm = new LlmAdapter(ctx.config);
+              const embedResult = await llm.createEmbeddingPort(modelUri, {
+                policy: { offline: true, allowDownload: false },
               });
 
-              if (!backlogResult.ok) {
-                throw new Error(backlogResult.error.message);
+              if (!embedResult.ok) {
+                throw new Error(
+                  `MODEL_NOT_FOUND: Embedding model not cached. ` +
+                    `Model: ${modelUri}. ` +
+                    `Run 'gno models pull embed' first.`
+                );
               }
 
-              return {
-                kind: "index" as const,
-                value: {
-                  sync: syncResult,
-                  embed: backlogResult.value,
-                },
-              };
+              const embedPort = embedResult.value;
+
+              try {
+                // Initialize and get dimensions from port interface
+                const initResult = await embedPort.init();
+                if (!initResult.ok) {
+                  throw new Error(initResult.error.message);
+                }
+                const dimensions = embedPort.dimensions();
+
+                // Create vector index port
+                const db = ctx.store.getRawDb();
+                const vectorResult = await createVectorIndexPort(db, {
+                  model: modelUri,
+                  dimensions,
+                });
+                if (!vectorResult.ok) {
+                  throw new Error(vectorResult.error.message);
+                }
+                const vectorIndex = vectorResult.value;
+
+                // Create stats port for backlog
+                const statsPort = createVectorStatsPort(db);
+
+                // Run embedding
+                const backlogResult = await embedBacklog({
+                  statsPort,
+                  embedPort,
+                  vectorIndex,
+                  collection: collection?.name,
+                  modelUri,
+                  batchSize: 32,
+                });
+
+                if (!backlogResult.ok) {
+                  throw new Error(backlogResult.error.message);
+                }
+                recordIndexMutation(
+                  backlogResult.value.embedded,
+                  ctx.markIndexMutation
+                );
+
+                return {
+                  kind: "index" as const,
+                  value: {
+                    sync: syncResult,
+                    embed: backlogResult.value,
+                  },
+                };
+              } finally {
+                await embedPort.dispose();
+              }
             } finally {
-              await embedPort.dispose();
+              lease?.release();
             }
           }
         );

package/src/mcp/tools/index.ts

@@ -83,6 +83,21 @@ export const MCP_TOOL_DESCRIPTIONS = {
     "Verify a saved Context Capsule without rebuilding or mutating it. Reports unchanged, stale, missing, reranked, and fingerprint drift states against the active index.",
 } as const;
 
+/** Tool names whose execution mutates disk, config, or index state. */
+export const MCP_WRITE_TOOL_NAMES = new Set([
+  "gno_capture",
+  "gno_add_collection",
+  "gno_sync",
+  "gno_embed",
+  "gno_index",
+  "gno_remove_collection",
+  "gno_clear_collection_embeddings",
+  "gno_create_folder",
+  "gno_rename_note",
+  "gno_move_note",
+  "gno_duplicate_note",
+]);
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Shared Input Schemas
 // ─────────────────────────────────────────────────────────────────────────────
@@ -829,8 +844,9 @@ export async function runTool<T>(
 
   // Sequential execution via mutex
   const release = await ctx.toolMutex.acquire();
+  const modelLease = ctx.acquireModelLease?.();
   try {
-    const data = await fn();
+    const data = await (ctx.runWithSnapshot?.(fn) ?? fn());
     return {
       content: [{ type: "text", text: formatText(data) }],
       structuredContent: data as { [x: string]: unknown },
@@ -846,6 +862,7 @@ export async function runTool<T>(
       structuredContent: parsedError,
     };
   } finally {
+    modelLease?.release();
     release();
   }
 }
@@ -869,8 +886,9 @@ export async function runToolNoMutex<T>(
     };
   }
 
+  const modelLease = ctx.acquireModelLease?.();
   try {
-    const data = await fn();
+    const data = await (ctx.runWithSnapshot?.(fn) ?? fn());
     return {
       content: [{ type: "text", text: formatText(data) }],
       structuredContent: data as { [x: string]: unknown },
@@ -885,6 +903,8 @@ export async function runToolNoMutex<T>(
       content: [{ type: "text", text: `Error: ${message}` }],
       structuredContent: parsedError,
     };
+  } finally {
+    modelLease?.release();
   }
 }
 

package/src/mcp/tools/remove-collection.ts

@@ -89,6 +89,8 @@ export function handleRemoveCollection(
         if (!mutationResult.ok) {
           throw mapConfigError(mutationResult.code, mutationResult.error);
         }
+        ctx.markContentMutation?.();
+        ctx.markIndexMutation?.();
 
         const result: RemoveCollectionResult = {
           removed: true,

package/src/mcp/tools/status.ts

@@ -8,6 +8,7 @@ import type { IndexStatus } from "../../store/types";
 import type { ToolContext } from "../server";
 
 import { resolveModelUri } from "../../llm/registry";
+import { createStandaloneResidentStatus } from "../../serve/resident-status";
 import { runTool, type ToolResult } from "./index";
 
 type StatusInput = Record<string, never>;
@@ -22,6 +23,14 @@ function formatStatus(status: IndexStatus): string {
   lines.push(`Config: ${status.configPath}`);
   lines.push(`Database: ${status.dbPath}`);
   lines.push(`Health: ${status.healthy ? "OK" : "DEGRADED"}`);
+  if ("resident" in status) {
+    const resident = status.resident as NonNullable<
+      ReturnType<NonNullable<ToolContext["getResidentStatus"]>>
+    >;
+    lines.push(
+      `Runtime: ${resident.mode}${resident.resident ? ` (${resident.transport.activeSessions} sessions)` : " (standalone)"}`
+    );
+  }
   lines.push("");
 
   if (status.collections.length === 0) {
@@ -78,6 +87,8 @@ export function handleStatus(
       return {
         ...result.value,
         configPath: ctx.actualConfigPath,
+        resident:
+          ctx.getResidentStatus?.() ?? createStandaloneResidentStatus("stdio"),
       };
     },
     formatStatus

package/src/mcp/tools/sync.ts

@@ -11,6 +11,7 @@ import type { ToolContext } from "../server";
 import { MCP_ERRORS } from "../../core/errors";
 import { acquireWriteLock, type WriteLockHandle } from "../../core/file-lock";
 import { JobError } from "../../core/job-manager";
+import { recordContentMutation } from "../../core/mutation-generations";
 import { normalizeCollectionName } from "../../core/validation";
 import { defaultSyncService, withContentTypeRules } from "../../ingestion";
 import { runTool, type ToolResult } from "./index";
@@ -113,20 +114,21 @@ export function handleSync(
           "sync",
           lock,
           async () => {
-            if (collection) {
-              const result = await defaultSyncService.syncCollection(
-                collection,
-                ctx.store,
-                options
-              );
-              return wrapSingleSync(result);
-            }
-
-            return defaultSyncService.syncAll(
-              ctx.collections,
-              ctx.store,
-              options
-            );
+            const result = collection
+              ? wrapSingleSync(
+                  await defaultSyncService.syncCollection(
+                    collection,
+                    ctx.store,
+                    options
+                  )
+                )
+              : await defaultSyncService.syncAll(
+                  ctx.collections,
+                  ctx.store,
+                  options
+                );
+            recordContentMutation(result, ctx.markContentMutation);
+            return result;
           }
         );
 

package/src/mcp/tools/workspace-write.ts

@@ -27,6 +27,7 @@ import {
   planMoveRefactor,
   planRenameRefactor,
 } from "../../core/file-refactors";
+import { recordContentMutation } from "../../core/mutation-generations";
 import { defaultSyncService, withContentTypeRules } from "../../ingestion";
 import { runTool, type ToolResult } from "./index";
 
@@ -210,11 +211,12 @@ export function handleRenameNote(
         const currentPath = join(collection.path, doc.relPath);
         const nextPath = join(collection.path, plan.nextRelPath);
         await renameFilePath(currentPath, nextPath);
-        await defaultSyncService.syncCollection(
+        const syncResult = await defaultSyncService.syncCollection(
           collection,
           ctx.store,
           withContentTypeRules({ runUpdateCmd: false }, ctx.config)
         );
+        recordContentMutation(syncResult, ctx.markContentMutation);
         return {
           uri: plan.nextUri,
           relPath: plan.nextRelPath,
@@ -255,11 +257,12 @@ export function handleMoveNote(
         const nextPath = join(collection.path, plan.nextRelPath);
         await mkdir(dirname(nextPath), { recursive: true });
         await renameFilePath(currentPath, nextPath);
-        await defaultSyncService.syncCollection(
+        const syncResult = await defaultSyncService.syncCollection(
           collection,
           ctx.store,
           withContentTypeRules({ runUpdateCmd: false }, ctx.config)
         );
+        recordContentMutation(syncResult, ctx.markContentMutation);
         return {
           uri: plan.nextUri,
           relPath: plan.nextRelPath,
@@ -308,11 +311,12 @@ export function handleDuplicateNote(
         const nextPath = join(collection.path, plan.nextRelPath);
         await mkdir(dirname(nextPath), { recursive: true });
         await copyFilePath(currentPath, nextPath);
-        await defaultSyncService.syncCollection(
+        const syncResult = await defaultSyncService.syncCollection(
           collection,
           ctx.store,
           withContentTypeRules({ runUpdateCmd: false }, ctx.config)
         );
+        recordContentMutation(syncResult, ctx.markContentMutation);
         return {
           uri: plan.nextUri,
           relPath: plan.nextRelPath,