@gmickel/gno 2.10.1 → 2.11.0

package/src/core/metadata-discovery.ts

@@ -0,0 +1,169 @@
+/**
+ * Typed metadata discovery: which keys the indexed documents carry, with
+ * their observed types, document counts and most common values, so a caller
+ * can write a `filter` predicate for metadata it has not seen.
+ *
+ * @module src/core/metadata-discovery
+ */
+
+export type MetadataValue = string | number | boolean;
+
+export interface MetadataKeySummary {
+  key: string;
+  /** Observed value types, e.g. `string`, `number`, `string[]`. */
+  types: string[];
+  /** Documents that carry the key. */
+  documents: number;
+  /** Most common values (array members count individually), count desc. */
+  values: { value: MetadataValue; documents: number }[];
+  /** True when more distinct values exist than `values` lists. */
+  valuesTruncated: boolean;
+}
+
+export interface MetadataSummary {
+  collection: string | null;
+  /** Active documents in scope, and how many carry typed metadata. */
+  documents: number;
+  documentsWithMetadata: number;
+  keys: MetadataKeySummary[];
+}
+
+export const DEFAULT_METADATA_VALUE_LIMIT = 10;
+export const MAX_METADATA_VALUE_LIMIT = 100;
+
+const typeOf = (value: unknown): string | null => {
+  if (Array.isArray(value)) {
+    const member = value.length > 0 ? typeOf(value[0]) : "string";
+    return member ? `${member}[]` : null;
+  }
+  return typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean"
+    ? typeof value
+    : null;
+};
+
+/**
+ * Summarize stored typed metadata JSON. Keys sort by document count then
+ * name; values by document count then their JSON text, so output is stable.
+ */
+export function summarizeTypedMetadata(
+  input: {
+    collection: string | null;
+    documents: number;
+    metadata: string[];
+  },
+  valueLimit = DEFAULT_METADATA_VALUE_LIMIT
+): MetadataSummary {
+  const keys = new Map<
+    string,
+    { types: Set<string>; documents: number; values: Map<string, number> }
+  >();
+  let documentsWithMetadata = 0;
+  for (const json of input.metadata) {
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(json);
+    } catch {
+      continue;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      continue;
+    const entries = Object.entries(parsed);
+    if (entries.length === 0) continue;
+    documentsWithMetadata += 1;
+    for (const [key, value] of entries) {
+      const type = typeOf(value);
+      if (!type) continue;
+      const summary = keys.get(key) ?? {
+        types: new Set<string>(),
+        documents: 0,
+        values: new Map<string, number>(),
+      };
+      summary.types.add(type);
+      summary.documents += 1;
+      const members = new Set(
+        (Array.isArray(value) ? value : [value]).map((member) =>
+          JSON.stringify(member)
+        )
+      );
+      for (const member of members)
+        summary.values.set(member, (summary.values.get(member) ?? 0) + 1);
+      keys.set(key, summary);
+    }
+  }
+  return {
+    collection: input.collection,
+    documents: input.documents,
+    documentsWithMetadata,
+    keys: [...keys.entries()]
+      .map(([key, summary]) => {
+        const values = [...summary.values.entries()].sort(
+          ([leftText, left], [rightText, right]) =>
+            right - left || (leftText < rightText ? -1 : 1)
+        );
+        return {
+          key,
+          types: [...summary.types].sort(),
+          documents: summary.documents,
+          values: values.slice(0, valueLimit).map(([text, documents]) => ({
+            value: JSON.parse(text) as MetadataValue,
+            documents,
+          })),
+          valuesTruncated: values.length > valueLimit,
+        };
+      })
+      .sort(
+        (left, right) =>
+          right.documents - left.documents || (left.key < right.key ? -1 : 1)
+      ),
+  };
+}
+
+/** Shared read for every surface; `values` caps listed values per key. */
+export async function readMetadataSummary(
+  store: {
+    getTypedMetadataDocuments(options?: {
+      collection?: string;
+    }): Promise<
+      | { ok: true; value: { documents: number; metadata: string[] } }
+      | { ok: false; error: { message: string } }
+    >;
+  },
+  options: { collection?: string; values?: number } = {}
+): Promise<MetadataSummary> {
+  const values = options.values ?? DEFAULT_METADATA_VALUE_LIMIT;
+  if (
+    !Number.isInteger(values) ||
+    values < 1 ||
+    values > MAX_METADATA_VALUE_LIMIT
+  )
+    throw new RangeError(
+      `values must be an integer from 1 to ${MAX_METADATA_VALUE_LIMIT}`
+    );
+  const result = await store.getTypedMetadataDocuments({
+    collection: options.collection,
+  });
+  if (!result.ok) throw new Error(result.error.message);
+  return summarizeTypedMetadata(
+    { collection: options.collection ?? null, ...result.value },
+    values
+  );
+}
+
+/** Plain-text rendering shared by the CLI terminal output and MCP text. */
+export function formatMetadataSummary(summary: MetadataSummary): string {
+  const scope = summary.collection ? ` in ${summary.collection}` : "";
+  const header = `${summary.documentsWithMetadata} of ${summary.documents} documents${scope} carry typed metadata`;
+  if (summary.keys.length === 0) return `${header}.`;
+  const lines = [`${header}:`, ""];
+  for (const key of summary.keys) {
+    const values = key.values
+      .map((item) => `${JSON.stringify(item.value)} (${item.documents})`)
+      .join(", ");
+    lines.push(
+      `${key.key} [${key.types.join(", ")}] ${key.documents} ${key.documents === 1 ? "doc" : "docs"}${values ? `: ${values}${key.valuesTruncated ? ", ..." : ""}` : ""}`
+    );
+  }
+  return lines.join("\n");
+}

package/src/ingestion/sync.ts

@@ -1,5 +1,6 @@
 // node:fs/promises for realpath/stat (no Bun equivalent for canonical paths or file stats)
-import { realpath, stat } from "node:fs/promises";
+// opendir proves a root can be listed; Bun has no directory-handle API.
+import { opendir, realpath, stat } from "node:fs/promises";
 /**
  * Sync service - orchestrates file ingestion.
  * Walks collections, converts files, chunks content, updates store.
@@ -389,6 +390,22 @@ class Semaphore {
   }
 }
 
+/** Null when the collection root can be listed; otherwise why it cannot. */
+async function unavailableRootMessage(root: string): Promise<string | null> {
+  try {
+    const directory = await opendir(root);
+    try {
+      // The open is lazy; the first read is what needs list permission.
+      await directory.read();
+    } finally {
+      await directory.close();
+    }
+    return null;
+  } catch (cause) {
+    return `Collection root could not be resolved (${cause instanceof Error ? cause.message : String(cause)}); indexed documents were kept`;
+  }
+}
+
 function summarizePathResults(
   collection: string,
   results: FileSyncResult[],
@@ -1174,6 +1191,7 @@ export class SyncService {
     const directoryAvailability = memoizeDirectoryAvailability(
       this.directoryAvailabilityFactory(availabilityMode)
     );
+    let rootUnavailable: string | null = null;
 
     for (const relPath of relPaths) {
       const recordDocumentsResult = await store.listRecordDocuments(
@@ -1285,6 +1303,19 @@ export class SyncService {
           });
           continue;
         }
+        // A file is only proven deleted while its collection root can be
+        // listed. Checked per absence: the root can vanish mid-batch.
+        const rootError = await unavailableRootMessage(collection.path);
+        if (rootError) {
+          rootUnavailable = rootError;
+          results.push({
+            relPath,
+            status: "error",
+            errorCode: "SOURCE_AVAILABILITY_UNKNOWN",
+            errorMessage: rootError,
+          });
+          continue;
+        }
         const inactive = await this.inactivateOneAbsentSource(
           collection,
           store,
@@ -1436,6 +1467,23 @@ export class SyncService {
       syncOptions.projectTypedEdges === false
         ? []
         : await this.projectTypedEdges(store, syncOptions, projectionSourceIds);
+    if (rootUnavailable) {
+      // Collection-level, as a full sync reports it, so status, summaries and
+      // the watcher's error path all carry the root and the original error.
+      errors.unshift({
+        relPath: "",
+        code: "SOURCE_AVAILABILITY_UNKNOWN",
+        message: rootUnavailable,
+      });
+      await store
+        .recordError({
+          collection: collection.name,
+          relPath: "",
+          code: "SOURCE_AVAILABILITY_UNKNOWN",
+          message: rootUnavailable,
+        })
+        .catch(() => undefined);
+    }
     return {
       ...summarizePathResults(
         collection.name,

package/src/ingestion/walker.ts

@@ -289,9 +289,17 @@ export class FileWalker implements WalkerPort {
     let rootReal: string;
     try {
       rootReal = await realpath(rootAbs);
-    } catch {
-      // Root doesn't exist
-      return { entries: [], skipped: [] };
+    } catch (error) {
+      // An unmounted drive or offline sync folder proves nothing about its
+      // files, so the root is an unproven prefix, never an empty listing.
+      skipped.push({
+        absPath: rootAbs,
+        relPath: "",
+        reason: "SOURCE_AVAILABILITY_UNKNOWN",
+        unprovenPrefix: true,
+        message: `Collection root could not be resolved (${error instanceof Error ? error.message : String(error)}); indexed documents were kept`,
+      });
+      return { entries, skipped };
     }
 
     const matches = new Set<string>();

package/src/mcp/http-egress.ts

@@ -48,6 +48,7 @@ export const MCP_HTTP_EGRESS_TOOLS = {
   gno_job_status: "metadata",
   gno_links: "metadata",
   gno_list_jobs: "metadata",
+  gno_list_metadata: "metadata",
   gno_list_tags: "metadata",
   gno_move_note: "metadata",
   gno_multi_get: "source",

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

@@ -18,9 +18,9 @@ import { type McpToolProfile, mcpToolProfileAllowlist } from "./tool-profile";
 
 export const MCP_CORE_TOOL_DESCRIPTIONS: Readonly<Record<string, string>> = {
   gno_query:
-    "Call first for a question about the indexed documents when the answer may be worded differently from the question. Runs hybrid retrieval: BM25 plus vector search, fused, with bounded one-hop graph expansion and optional query expansion and reranking. Returns ranked results, each with uri, docid, score, snippet, and usually a line anchor to read next with gno_get fromLine/lineCount; meta reports the mode actually used (bm25_only when vectors are unavailable) and whether expansion and reranking ran. Set fast=true for a quick lookup, thorough=true when recall matters, and intent to disambiguate a short term. A context field on a result is configured guidance; cite the source lines.",
+    "Call first for a question about the indexed documents when the answer may be worded differently from the question. Runs hybrid retrieval: BM25 plus vector search, fused, with bounded one-hop graph expansion and optional query expansion and reranking. Returns ranked results, each with uri, docid, score, snippet, and usually a line anchor to read next with gno_get fromLine/lineCount; meta reports the mode actually used (bm25_only when vectors are unavailable) and whether expansion and reranking ran. Start with fast=true (no expansion or reranking, typically under a second on a warm server); when that misses, call again without fast to add expansion and reranking; set thorough=true when recall matters and intent to disambiguate a short term. A context field on a result is configured guidance; cite the source lines.",
   gno_search:
-    "Call when you know the exact words: a name, identifier, filename, error message, or quoted phrase. Runs BM25 keyword matching only, so it needs no model and answers fast. Returns ranked results with uri, docid, score, snippet, and a line anchor when available; the match sits at that line, so read it with gno_get fromLine/lineCount. Call gno_query when the wording is uncertain.",
+    "Call when you know the exact words: a name, identifier, filename, error message, or quoted phrase. Runs BM25 keyword matching only, so it needs no model and answers fast. Returns ranked results with uri, docid, score, snippet, and a line anchor when available; the match sits at that line, so read it with gno_get fromLine/lineCount. For a question asked in words, call gno_query with fast=true instead.",
   gno_get:
     "Call to read one document a result named: pass its gno:// URI, #docid, or collection/path as ref. With fromLine and lineCount it returns only that range; start from the result's line anchor with a small count before fetching the whole file. Returns the content with line numbers plus uri, docid, title, totalLines, returnedLines, and the source path and modifiedAt.",
   gno_multi_get:

package/src/mcp/tool-profile.ts

@@ -17,6 +17,8 @@ import type {
  * @module src/mcp/tool-profile
  */
 
+import { z } from "zod";
+
 import { withInferenceScope } from "../llm/inference-scope";
 
 export const MCP_TOOL_PROFILES = ["core", "full"] as const;
@@ -129,6 +131,19 @@ export function createProfileToolRegistrar(
             : (cb as ToolCallback<StandardSchemaWithJSON>)(args[0], request)
       );
     };
-    server.registerTool(name, config, wrapped as unknown as typeof cb);
+    server.registerTool(
+      name,
+      { ...config, inputSchema: rejectUnknownKeys(config.inputSchema) },
+      wrapped as unknown as typeof cb
+    );
   };
 }
+
+/**
+ * Unknown argument keys fail validation with the key named instead of being
+ * dropped: a misspelled scope or receipt key must not silently widen a read
+ * or skip a write fence.
+ */
+function rejectUnknownKeys<T>(schema: T): T {
+  return (schema instanceof z.ZodObject ? schema.strict() : schema) as T;
+}

package/src/mcp/tools/get.ts

@@ -25,6 +25,7 @@ import {
   evidenceFromExactDocument,
   RetrievalTraceSession,
 } from "../../core/retrieval-trace-session";
+import { supersedingUri } from "../../pipeline/result-context";
 import { openScopedIndexStore } from "../../store/sqlite/scoped-index";
 import { runTool, type ToolResult } from "./index";
 
@@ -59,6 +60,8 @@ interface GetResponse {
     mirrorHash?: string;
   };
   record?: RecordEvidenceMetadata;
+  /** URI of the current fact when a newer memory fact superseded this one. */
+  supersededBy?: string;
   capabilities: DocumentCapabilities;
 }
 
@@ -104,6 +107,9 @@ function formatGetResponse(data: GetResponse): string {
   if (data.title) {
     lines.push(`Title: ${data.title}`);
   }
+  if (data.supersededBy) {
+    lines.push(`Superseded by: ${data.supersededBy}`);
+  }
   lines.push(`Lines: ${data.totalLines}`);
   if (data.source.absPath) {
     lines.push(`Path: ${data.source.absPath}`);
@@ -226,7 +232,11 @@ export function handleGet(
           }
         }
 
+        const successor = await supersedingUri(scoped.store, doc.uri);
         const response: GetResponse = {
+          ...(successor
+            ? { supersededBy: decorateUriForIndex(successor, scoped.indexName) }
+            : {}),
           docid: doc.docid,
           uri: decorateUriForIndex(doc.uri, scoped.indexName),
           title: doc.title ?? undefined,

package/src/mcp/tools/index.ts

@@ -21,6 +21,11 @@ import {
   compiledContextCheckSchema,
 } from "../../core/compiled-context";
 import { withoutHostPaths } from "../../core/host-paths";
+import {
+  formatMetadataSummary,
+  MAX_METADATA_VALUE_LIMIT,
+  readMetadataSummary,
+} from "../../core/metadata-discovery";
 import { NOTE_PRESETS, type NotePresetId } from "../../core/note-presets";
 import { RETRIEVAL_TRACE_METADATA } from "../../core/retrieval-trace-session";
 import { normalizeTag } from "../../core/tags";
@@ -170,11 +175,11 @@ 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. Use gno_query when wording is uncertain.",
+    "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).",
   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. Use gno_query for default hybrid retrieval.",
+    "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:
-    "Hybrid search (BM25 + vector + default bounded graph expansion + optional query expansion/reranking). Recommended default. Structured results preserve optional user-configured context guidance with source identity. Use intent for ambiguous terms, queryModes to combine term/intent/hyde strategies, fast=true or graph=false for quick lookup, thorough=true when recall matters, and candidateLimit to trade latency for coverage.",
+    "Hybrid search (BM25 + vector + default bounded graph expansion + optional query expansion/reranking). Recommended default for natural-language questions: start with fast=true (hybrid without expansion/rerank, typically under a second on a warm server); when that misses, retry without fast (adds expansion and reranking, a few seconds); thorough=true when recall matters. Structured results preserve optional user-configured context guidance with source identity. Use intent for ambiguous terms, queryModes to combine term/intent/hyde strategies, graph=false to skip graph expansion, and candidateLimit to trade latency for coverage.",
   queryDiagnose:
     "Diagnose why one target document does or does not appear for a query. Use when an important doc is missing, a filter may exclude it, or you need stage-by-stage BM25/vector/fusion/graph/rerank evidence before changing retrieval strategy.",
   get: "Retrieve one document by gno:// URI, docid (#abc123), or collection/path. After search results include line, pass fromLine and lineCount to fetch only the relevant range before expanding to the full document.",
@@ -632,7 +637,7 @@ export const queryInputSchema = z.object({
     .boolean()
     .default(false)
     .describe(
-      "Skip query expansion, graph expansion, and reranking (~0.7s). Use for quick lookups"
+      "Skip query expansion, graph expansion, and reranking (typically under a second on a warm server). Use first for natural-language questions"
     ),
   thorough: z
     .boolean()
@@ -756,6 +761,20 @@ const listJobsInputSchema = z.object({
     .describe("Max jobs to return"),
 });
 
+const listMetadataInputSchema = z.object({
+  collection: z
+    .string()
+    .optional()
+    .describe("Only documents in this collection"),
+  values: z
+    .number()
+    .int()
+    .min(1)
+    .max(MAX_METADATA_VALUE_LIMIT)
+    .optional()
+    .describe("Common values listed per key (default 10)"),
+});
+
 const listTagsInputSchema = z.object({
   collection: z
     .string()
@@ -1373,6 +1392,22 @@ export function registerTools(server: McpServer, ctx: ToolContext): void {
     (args) => handleTraceShow(args, ctx)
   );
 
+  registerTool(
+    "gno_list_metadata",
+    {
+      description:
+        "List the typed metadata keys indexed documents carry, with observed types, document counts and the most common values. Call before writing a filter predicate on custom metadata you have not seen.",
+      inputSchema: listMetadataInputSchema,
+    },
+    (args) =>
+      runTool(
+        ctx,
+        "gno_list_metadata",
+        () => readMetadataSummary(ctx.store, args),
+        formatMetadataSummary
+      )
+  );
+
   registerTool(
     "gno_list_tags",
     {

package/src/mcp/tools/multi-get.ts

@@ -16,6 +16,7 @@ import {
   type RecordEvidenceMetadata,
 } from "../../core/record-metadata";
 import { parseRef } from "../../core/ref-parser";
+import { supersedingUri } from "../../pipeline/result-context";
 import { openScopedIndexStore } from "../../store/sqlite/scoped-index";
 import { runTool, type ToolResult } from "./index";
 
@@ -27,6 +28,8 @@ interface MultiGetInput {
 }
 
 interface DocumentResult {
+  /** URI of the current fact when a newer memory fact superseded this one. */
+  supersededBy?: string;
   docid: string;
   uri: string;
   title?: string;
@@ -108,6 +111,9 @@ function formatMultiGetResponse(data: MultiGetResponse): string {
     if (doc.title) {
       lines.push(`Title: ${doc.title}`);
     }
+    if (doc.supersededBy) {
+      lines.push(`Superseded by: ${doc.supersededBy}`);
+    }
     lines.push(
       `Lines: ${doc.totalLines}${doc.truncated ? " (truncated)" : ""}`
     );
@@ -250,7 +256,16 @@ export function handleMultiGet(
             }
           }
 
+          const successor = await supersedingUri(scoped.store, doc.uri);
           documents.push({
+            ...(successor
+              ? {
+                  supersededBy: decorateUriForIndex(
+                    successor,
+                    scoped.indexName
+                  ),
+                }
+              : {}),
             docid: doc.docid,
             uri: decorateUriForIndex(doc.uri, scoped.indexName),
             title: doc.title ?? undefined,

package/src/mcp/tools/query.ts

@@ -20,7 +20,7 @@ import type {
 import type { VectorIndexPort } from "../../store/vector";
 import type { ToolContext } from "../server";
 
-import { decorateUriForIndex, parseUri } from "../../app/constants";
+import { decorateResultUris, parseUri } from "../../app/constants";
 import { createNonTtyProgressRenderer } from "../../cli/progress";
 import {
   fingerprintContentTypeMetadataRules,
@@ -103,8 +103,7 @@ function enrichWithAbsPath(
     }
 
     return {
-      ...r,
-      uri: decorateUriForIndex(r.uri, ctx.indexName),
+      ...decorateResultUris(r, ctx.indexName),
       source: {
         ...r.source,
         absPath: pathJoin(collection.path, r.source.relPath),
@@ -144,6 +143,9 @@ function formatSearchResults(data: SearchResults): string {
     if (r.title) {
       lines.push(`  Title: ${r.title}`);
     }
+    if (r.supersededBy) {
+      lines.push(`  Superseded by: ${r.supersededBy}`);
+    }
     if (r.snippet) {
       const snippetPreview = r.snippet.slice(0, 200).replace(/\n/g, " ");
       lines.push(`  ${snippetPreview}${r.snippet.length > 200 ? "..." : ""}`);

package/src/mcp/tools/search.ts

@@ -10,7 +10,7 @@ import type { RetrievalTraceSession } from "../../core/retrieval-trace-session";
 import type { SearchResult, SearchResults } from "../../pipeline/types";
 import type { ToolContext } from "../server";
 
-import { decorateUriForIndex, parseUri } from "../../app/constants";
+import { decorateResultUris, parseUri } from "../../app/constants";
 import { normalizeContentTypes } from "../../config";
 import { resolveRemoteProjectAffinity } from "../../core/project-affinity-surface";
 import {
@@ -66,8 +66,7 @@ function enrichWithAbsPath(
     }
 
     return {
-      ...r,
-      uri: decorateUriForIndex(r.uri, ctx.indexName),
+      ...decorateResultUris(r, ctx.indexName),
       source: {
         ...r.source,
         absPath: pathJoin(collection.path, r.source.relPath),
@@ -93,6 +92,9 @@ function formatSearchResults(data: SearchResults): string {
     if (r.title) {
       lines.push(`  Title: ${r.title}`);
     }
+    if (r.supersededBy) {
+      lines.push(`  Superseded by: ${r.supersededBy}`);
+    }
     if (r.snippet) {
       const snippetPreview = r.snippet.slice(0, 200).replace(/\n/g, " ");
       lines.push(`  ${snippetPreview}${r.snippet.length > 200 ? "..." : ""}`);

package/src/mcp/tools/vsearch.ts

@@ -10,7 +10,7 @@ import type { EmbeddingPort } from "../../llm/types";
 import type { SearchResult, SearchResults } from "../../pipeline/types";
 import type { ToolContext } from "../server";
 
-import { decorateUriForIndex, parseUri } from "../../app/constants";
+import { decorateResultUris, parseUri } from "../../app/constants";
 import { createNonTtyProgressRenderer } from "../../cli/progress";
 import { resolveRemoteProjectAffinity } from "../../core/project-affinity-surface";
 import {
@@ -77,8 +77,7 @@ function enrichWithAbsPath(
     }
 
     return {
-      ...r,
-      uri: decorateUriForIndex(r.uri, ctx.indexName),
+      ...decorateResultUris(r, ctx.indexName),
       source: {
         ...r.source,
         absPath: pathJoin(collection.path, r.source.relPath),
@@ -106,6 +105,9 @@ function formatSearchResults(data: SearchResults): string {
     if (r.title) {
       lines.push(`  Title: ${r.title}`);
     }
+    if (r.supersededBy) {
+      lines.push(`  Superseded by: ${r.supersededBy}`);
+    }
     if (r.snippet) {
       const snippetPreview = r.snippet.slice(0, 200).replace(/\n/g, " ");
       lines.push(`  ${snippetPreview}${r.snippet.length > 200 ? "..." : ""}`);

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

@@ -53,43 +53,51 @@ const refactorPreviewActionSchema = z.literal("preview");
 const refactorApplyActionSchema = z.literal("apply");
 
 export const renameNoteInputSchema = z.discriminatedUnion("action", [
-  z.object({
-    action: refactorPreviewActionSchema,
-    ref: z.string().min(1, "ref cannot be empty"),
-    name: z.string().min(1, "name cannot be empty"),
-  }),
-  z.object({
-    action: refactorApplyActionSchema,
-    ref: z.string().min(1, "ref cannot be empty"),
-    name: z.string().min(1, "name cannot be empty"),
-    schemaVersion: z.literal(FILE_REFACTOR_SCHEMA_VERSION),
-    planDigest: z
-      .string()
-      .regex(/^[a-f0-9]{64}$/, "planDigest must be a lowercase SHA-256"),
-    confirmation: z.literal(FILE_REFACTOR_APPLY_CONFIRMATION),
-    confirm: z.literal(true),
-  }),
+  z
+    .object({
+      action: refactorPreviewActionSchema,
+      ref: z.string().min(1, "ref cannot be empty"),
+      name: z.string().min(1, "name cannot be empty"),
+    })
+    .strict(),
+  z
+    .object({
+      action: refactorApplyActionSchema,
+      ref: z.string().min(1, "ref cannot be empty"),
+      name: z.string().min(1, "name cannot be empty"),
+      schemaVersion: z.literal(FILE_REFACTOR_SCHEMA_VERSION),
+      planDigest: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/, "planDigest must be a lowercase SHA-256"),
+      confirmation: z.literal(FILE_REFACTOR_APPLY_CONFIRMATION),
+      confirm: z.literal(true),
+    })
+    .strict(),
 ]);
 
 export const moveNoteInputSchema = z.discriminatedUnion("action", [
-  z.object({
-    action: refactorPreviewActionSchema,
-    ref: z.string().min(1, "ref cannot be empty"),
-    folderPath: z.string().min(1, "folderPath cannot be empty"),
-    name: z.string().optional(),
-  }),
-  z.object({
-    action: refactorApplyActionSchema,
-    ref: z.string().min(1, "ref cannot be empty"),
-    folderPath: z.string().min(1, "folderPath cannot be empty"),
-    name: z.string().optional(),
-    schemaVersion: z.literal(FILE_REFACTOR_SCHEMA_VERSION),
-    planDigest: z
-      .string()
-      .regex(/^[a-f0-9]{64}$/, "planDigest must be a lowercase SHA-256"),
-    confirmation: z.literal(FILE_REFACTOR_APPLY_CONFIRMATION),
-    confirm: z.literal(true),
-  }),
+  z
+    .object({
+      action: refactorPreviewActionSchema,
+      ref: z.string().min(1, "ref cannot be empty"),
+      folderPath: z.string().min(1, "folderPath cannot be empty"),
+      name: z.string().optional(),
+    })
+    .strict(),
+  z
+    .object({
+      action: refactorApplyActionSchema,
+      ref: z.string().min(1, "ref cannot be empty"),
+      folderPath: z.string().min(1, "folderPath cannot be empty"),
+      name: z.string().optional(),
+      schemaVersion: z.literal(FILE_REFACTOR_SCHEMA_VERSION),
+      planDigest: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/, "planDigest must be a lowercase SHA-256"),
+      confirmation: z.literal(FILE_REFACTOR_APPLY_CONFIRMATION),
+      confirm: z.literal(true),
+    })
+    .strict(),
 ]);
 
 export type RenameNoteInput = z.infer<typeof renameNoteInputSchema>;