ocean-brain 0.7.4 → 0.8.0

package/dist/mcp.js

@@ -1,226 +1,12 @@
 #!/usr/bin/env node
 
 // src/mcp.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs from "fs";
+import path from "path";
 import { fileURLToPath } from "url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z3 } from "zod";
-
-// src/mcp-write-safety.ts
-import crypto from "crypto";
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { z } from "zod";
-var destructiveMcpWriteFields = {
-  dryRun: z.boolean().optional().default(true).describe("Preview the destructive change first. Commit only after dry-run returns operation.operationId and operation.confirmToken."),
-  operationId: z.string().optional().describe("Dry-run response operation.operationId. Required when dryRun is false."),
-  confirmToken: z.string().optional().describe("Dry-run response operation.confirmToken. Required when dryRun is false."),
-  force: z.boolean().optional().default(false).describe("Explicitly confirm a bulk destructive change when the preview says force is required.")
-};
-var confirmedMcpWriteFields = {
-  dryRun: z.boolean().optional().default(true).describe("Preview the write first. Commit only after dry-run returns operation.operationId and operation.confirmToken."),
-  operationId: z.string().optional().describe("Dry-run response operation.operationId. Required when dryRun is false."),
-  confirmToken: z.string().optional().describe("Dry-run response operation.confirmToken. Required when dryRun is false.")
-};
-var McpCliWriteSafetyError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "McpCliWriteSafetyError";
-    this.code = code;
-  }
-};
-var DEFAULT_TTL_MS = 10 * 60 * 1e3;
-var DEFAULT_ROOT_DIR = path.resolve(os.homedir(), ".ocean-brain", "mcp-write-safety");
-var createError = (code, message) => new McpCliWriteSafetyError(code, message);
-var ensureDirExists = (dirPath) => {
-  fs.mkdirSync(dirPath, { recursive: true });
-};
-var hashToken = (token) => crypto.createHash("sha256").update(token).digest("hex");
-var toPublicPendingOperation = (operation) => ({
-  actor: operation.actor,
-  affectedIds: operation.affectedIds,
-  createdAt: operation.createdAt,
-  estimatedChangeCount: operation.estimatedChangeCount,
-  expiresAt: operation.expiresAt,
-  force: operation.force,
-  ...operation.operationFingerprint ? { operationFingerprint: operation.operationFingerprint } : {},
-  operationId: operation.operationId,
-  risk: operation.risk,
-  summary: operation.summary,
-  toolName: operation.toolName
-});
-var parsePendingOperation = (raw) => JSON.parse(raw);
-var defaultMcpWriteSafetyDir = () => {
-  return path.resolve(process.env.OCEAN_BRAIN_MCP_WRITE_SAFETY_DIR || DEFAULT_ROOT_DIR);
-};
-var formatMcpGraphqlError = (error) => {
-  const suffix = [];
-  if (error.extensions?.code) {
-    suffix.push(`code=${error.extensions.code}`);
-  }
-  if (error.extensions?.operationId) {
-    suffix.push(`operationId=${error.extensions.operationId}`);
-  }
-  if (suffix.length === 0) {
-    return `GraphQL error: ${error.message}`;
-  }
-  return `GraphQL error: ${error.message} (${suffix.join(", ")})`;
-};
-var createMcpWriteSafetyCoordinator = (options = {}) => {
-  const rootDir = path.resolve(options.rootDir ?? defaultMcpWriteSafetyDir());
-  const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
-  const now = options.now ?? (() => /* @__PURE__ */ new Date());
-  const randomBytes = options.randomBytes ?? ((size) => crypto.randomBytes(size));
-  const pendingDir = path.resolve(rootDir, "pending");
-  const logPath = path.resolve(rootDir, "operations.jsonl");
-  const appendLog = (entry) => {
-    ensureDirExists(rootDir);
-    fs.appendFileSync(logPath, `${JSON.stringify(entry)}
-`, "utf-8");
-  };
-  const buildLogEntry = (operation, phase, detail) => ({
-    actor: operation.actor,
-    affectedIds: operation.affectedIds,
-    estimatedChangeCount: operation.estimatedChangeCount,
-    force: operation.force,
-    operationId: operation.operationId,
-    phase,
-    risk: operation.risk,
-    summary: operation.summary,
-    timestamp: now().toISOString(),
-    toolName: operation.toolName,
-    ...detail ? { detail } : {}
-  });
-  const getPendingPath = (operationId) => path.resolve(pendingDir, `${operationId}.json`);
-  const cleanupExpiredOperations = () => {
-    if (!fs.existsSync(pendingDir)) {
-      return;
-    }
-    for (const fileName of fs.readdirSync(pendingDir)) {
-      const filePath = path.resolve(pendingDir, fileName);
-      const pendingOperation = parsePendingOperation(fs.readFileSync(filePath, "utf-8"));
-      if (new Date(pendingOperation.expiresAt).getTime() > now().getTime()) {
-        continue;
-      }
-      fs.rmSync(filePath, { force: true });
-      appendLog(buildLogEntry(toPublicPendingOperation(pendingOperation), "expired"));
-    }
-  };
-  const listPendingOperations = () => {
-    cleanupExpiredOperations();
-    if (!fs.existsSync(pendingDir)) {
-      return [];
-    }
-    return fs.readdirSync(pendingDir).map((fileName) => path.resolve(pendingDir, fileName)).map((filePath) => parsePendingOperation(fs.readFileSync(filePath, "utf-8"))).map(toPublicPendingOperation).sort((left, right) => left.createdAt.localeCompare(right.createdAt));
-  };
-  const prepareOperation = (input) => {
-    ensureDirExists(pendingDir);
-    const operationId = `mcpw_${randomBytes(8).toString("hex")}`;
-    const confirmToken = `confirm_${randomBytes(12).toString("hex")}`;
-    const currentTime = now();
-    const createdAt = currentTime.toISOString();
-    const expiresAt = new Date(currentTime.getTime() + ttlMs).toISOString();
-    const pendingOperation = {
-      actor: input.actor,
-      affectedIds: input.affectedIds,
-      confirmTokenHash: hashToken(confirmToken),
-      createdAt,
-      estimatedChangeCount: input.estimatedChangeCount,
-      expiresAt,
-      force: Boolean(input.force),
-      ...input.operationFingerprint ? { operationFingerprint: input.operationFingerprint } : {},
-      operationId,
-      risk: input.risk,
-      summary: input.summary,
-      toolName: input.toolName
-    };
-    fs.writeFileSync(getPendingPath(operationId), JSON.stringify(pendingOperation, null, 2), "utf-8");
-    appendLog(buildLogEntry(toPublicPendingOperation(pendingOperation), "prepared"));
-    return {
-      ...toPublicPendingOperation(pendingOperation),
-      confirmToken
-    };
-  };
-  const requireConfirmedOperation = (request, expected) => {
-    if (!request.operationId || !request.confirmToken) {
-      throw createError(
-        "CONFIRMATION_REQUIRED",
-        "A destructive MCP write requires operationId and confirmToken after a dry run."
-      );
-    }
-    const pendingPath = getPendingPath(request.operationId);
-    if (!fs.existsSync(pendingPath)) {
-      throw createError("INVALID_CONFIRMATION", "The write confirmation was not found or has already been consumed.");
-    }
-    const pendingOperation = parsePendingOperation(fs.readFileSync(pendingPath, "utf-8"));
-    const publicPendingOperation = toPublicPendingOperation(pendingOperation);
-    if (new Date(pendingOperation.expiresAt).getTime() <= now().getTime()) {
-      fs.rmSync(pendingPath, { force: true });
-      appendLog(buildLogEntry(publicPendingOperation, "expired"));
-      throw createError("CONFIRMATION_EXPIRED", "The write confirmation expired. Run dryRun again.");
-    }
-    if (pendingOperation.toolName !== expected.toolName) {
-      appendLog(buildLogEntry(publicPendingOperation, "rejected", "tool_mismatch"));
-      throw createError("INVALID_CONFIRMATION", "The write confirmation does not match this MCP tool.");
-    }
-    if (expected.operationFingerprint && pendingOperation.operationFingerprint !== expected.operationFingerprint) {
-      appendLog(buildLogEntry(publicPendingOperation, "rejected", "operation_fingerprint_mismatch"));
-      throw createError("INVALID_CONFIRMATION", "The write confirmation does not match this MCP operation.");
-    }
-    if (pendingOperation.confirmTokenHash !== hashToken(request.confirmToken)) {
-      appendLog(buildLogEntry(publicPendingOperation, "rejected", "token_mismatch"));
-      throw createError("INVALID_CONFIRMATION", "The write confirmation token is invalid.");
-    }
-    fs.rmSync(pendingPath, { force: true });
-    appendLog(buildLogEntry(publicPendingOperation, "confirmed"));
-    return publicPendingOperation;
-  };
-  const ensureDestructiveWriteRequest = (request, input) => {
-    if (request.dryRun ?? true) {
-      return {
-        kind: "dry-run",
-        operation: prepareOperation({
-          ...input,
-          force: request.force ?? input.force
-        })
-      };
-    }
-    return {
-      kind: "confirmed",
-      operation: requireConfirmedOperation(request, {
-        toolName: input.toolName,
-        operationFingerprint: input.operationFingerprint
-      })
-    };
-  };
-  const recordWriteResult = (operation, success, detail) => {
-    appendLog(buildLogEntry(operation, success ? "executed" : "failed", detail));
-  };
-  const getStatus = () => {
-    const pendingOperations = listPendingOperations();
-    return {
-      confirmationTtlMs: ttlMs,
-      logPath,
-      pendingDir,
-      pendingOperationCount: pendingOperations.length,
-      pendingOperations,
-      rootDir,
-      writeToolsEnabled: false
-    };
-  };
-  return {
-    ensureDestructiveWriteRequest,
-    getStatus,
-    listPendingOperations,
-    prepareOperation,
-    recordWriteResult,
-    requireConfirmedOperation
-  };
-};
+import { z as z2 } from "zod";
 
 // src/mcp-note-output.ts
 var formatBackReferenceLink = (backReference) => {
@@ -272,69 +58,65 @@ var formatMcpReadNoteOutput = ({
 };
 
 // src/mcp-intent-write-tools.ts
-import crypto2 from "crypto";
-import { z as z2 } from "zod";
-var markdownPatchSelectorSchema = z2.discriminatedUnion("type", [
-  z2.object({
-    type: z2.literal("exact_text"),
-    text: z2.string(),
-    before: z2.string().optional(),
-    after: z2.string().optional()
+import { z } from "zod";
+var markdownPatchSelectorSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("exact_text"),
+    text: z.string(),
+    before: z.string().optional(),
+    after: z.string().optional()
   }),
-  z2.object({
-    type: z2.literal("match_candidate"),
-    text: z2.string(),
-    matchIndex: z2.number().int().nonnegative(),
-    lineStart: z2.number().int().positive(),
-    matchSha256: z2.string(),
-    surroundingHash: z2.string(),
-    positionHint: z2.enum(["first", "last"]).optional()
+  z.object({
+    type: z.literal("match_candidate"),
+    text: z.string(),
+    matchIndex: z.number().int().nonnegative(),
+    lineStart: z.number().int().positive(),
+    matchSha256: z.string(),
+    surroundingHash: z.string(),
+    positionHint: z.enum(["first", "last"]).optional()
   })
 ]);
-var markdownPatchOperationSchema = z2.discriminatedUnion("type", [
-  z2.object({
-    type: z2.literal("replace"),
-    replacement: z2.string()
+var markdownPatchOperationSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("replace"),
+    replacement: z.string()
   }),
-  z2.object({
-    type: z2.literal("insert_before"),
-    insertion: z2.string()
+  z.object({
+    type: z.literal("insert_before"),
+    insertion: z.string()
   }),
-  z2.object({
-    type: z2.literal("insert_after"),
-    insertion: z2.string()
+  z.object({
+    type: z.literal("insert_after"),
+    insertion: z.string()
   })
 ]);
-var markdownAppendPlacementSchema = z2.discriminatedUnion("type", [
-  z2.object({
-    type: z2.literal("end")
+var markdownAppendPlacementSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("end")
   }),
-  z2.object({
-    type: z2.literal("after_heading"),
-    heading: z2.string(),
-    level: z2.number().int().min(1).max(6).optional()
+  z.object({
+    type: z.literal("after_heading"),
+    heading: z.string(),
+    level: z.number().int().min(1).max(6).optional()
   })
 ]);
-var markdownWritePolicySchema = z2.object({
-  allowNoop: z2.boolean().optional(),
-  maxChangedChars: z2.number().int().nonnegative().optional(),
-  maxChangedLines: z2.number().int().nonnegative().optional(),
-  diffPreviewMaxChars: z2.number().int().nonnegative().optional(),
-  preserveTags: z2.union([z2.boolean(), z2.literal("warn")]).optional(),
-  preserveReferences: z2.union([z2.boolean(), z2.literal("warn")]).optional()
+var markdownWritePolicySchema = z.object({
+  allowNoop: z.boolean().optional(),
+  preserveTags: z.union([z.boolean(), z.literal("warn")]).optional(),
+  preserveReferences: z.union([z.boolean(), z.literal("warn")]).optional()
 }).optional();
 var MCP_METADATA_PROPERTY_PATCH_LIMIT = 50;
 var normalizeMetadataPropertyKey = (key) => key.trim().toLowerCase().replace(/\s+/g, "-");
-var metadataPropertyPatchSchema = z2.object({
-  set: z2.array(z2.object({
-    key: z2.string().min(1).describe("Property key from ocean_brain_list_properties."),
-    value: z2.string().describe("String value: select option.value, date YYYY-MM-DD, boolean true/false, number finite string, url http(s).")
+var metadataPropertyPatchSchema = z.object({
+  set: z.array(z.object({
+    key: z.string().min(1).describe("Property key from ocean_brain_list_properties."),
+    value: z.string().describe("String value: select option.value, date YYYY-MM-DD, boolean true/false, number finite string, url http(s).")
   })).max(MCP_METADATA_PROPERTY_PATCH_LIMIT).optional().describe("Set up to 50 property values. Keys must be unique."),
-  deleteKeys: z2.array(z2.string().min(1)).max(MCP_METADATA_PROPERTY_PATCH_LIMIT).optional().describe("Remove up to 50 property values from this note. Keys must be unique and not also in set.")
+  deleteKeys: z.array(z.string().min(1)).max(MCP_METADATA_PROPERTY_PATCH_LIMIT).optional().describe("Remove up to 50 property values from this note. Keys must be unique and not also in set.")
 }).superRefine((patch, context) => {
   if ((patch.set?.length ?? 0) === 0 && (patch.deleteKeys?.length ?? 0) === 0) {
     context.addIssue({
-      code: z2.ZodIssueCode.custom,
+      code: z.ZodIssueCode.custom,
       message: "properties must include set or deleteKeys."
     });
     return;
@@ -344,7 +126,7 @@ var metadataPropertyPatchSchema = z2.object({
     const key = normalizeMetadataPropertyKey(item.key);
     if (setKeys.has(key)) {
       context.addIssue({
-        code: z2.ZodIssueCode.custom,
+        code: z.ZodIssueCode.custom,
         message: `properties.set contains duplicate key ${key}.`
       });
     }
@@ -355,154 +137,41 @@ var metadataPropertyPatchSchema = z2.object({
     const key = normalizeMetadataPropertyKey(rawKey);
     if (deleteKeys.has(key)) {
       context.addIssue({
-        code: z2.ZodIssueCode.custom,
+        code: z.ZodIssueCode.custom,
         message: `properties.deleteKeys contains duplicate key ${key}.`
       });
     }
     if (setKeys.has(key)) {
       context.addIssue({
-        code: z2.ZodIssueCode.custom,
+        code: z.ZodIssueCode.custom,
         message: `properties cannot set and delete ${key} in one request.`
       });
     }
     deleteKeys.add(key);
   }
 }).optional();
-var sha256 = (value) => crypto2.createHash("sha256").update(value).digest("hex");
-var isRecord = (value) => {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-};
-var stableJsonStringify = (value) => {
-  if (Array.isArray(value)) {
-    return `[${value.map(stableJsonStringify).join(",")}]`;
-  }
-  if (isRecord(value)) {
-    const properties = Object.keys(value).filter((key) => value[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${stableJsonStringify(value[key])}`);
-    return `{${properties.join(",")}}`;
-  }
-  return JSON.stringify(value) ?? "null";
-};
-var normalizeServerUrl = (serverUrl) => {
-  try {
-    const url = new URL(serverUrl);
-    url.hash = "";
-    return url.toString().replace(/\/$/, "");
-  } catch {
-    return serverUrl.replace(/\/$/, "");
-  }
-};
-var normalizeIntentWritePayloadForFingerprint = (toolName, payload) => {
-  const normalizedPayload = { ...payload };
-  if (toolName === "ocean_brain_append_note_markdown") {
-    normalizedPayload.placement ??= { type: "end" };
-    normalizedPayload.separator ??= "\n\n";
-  }
-  return normalizedPayload;
-};
-var createIntentWriteOperationFingerprint = (serverUrl, token, toolName, payload) => {
-  return sha256(stableJsonStringify({
-    payload: normalizeIntentWritePayloadForFingerprint(toolName, payload),
-    serverUrl: normalizeServerUrl(serverUrl),
-    tokenDigest: token ? sha256(token) : null,
-    toolName
-  }));
-};
-var getErrorDetail = (error) => {
-  return error instanceof Error ? error.message : "Unknown MCP write error";
-};
-var requireCommitConfirmationFields = (request) => {
-  if (request.dryRun !== false) {
-    return;
-  }
-  if (!request.operationId || !request.confirmToken) {
-    throw new Error("Commit mode requires both operationId and confirmToken from the dry-run response.");
-  }
-};
-var resolvePayloadWithBaseline = async (fetchNoteWriteBaseline, writeToken, id, payload) => {
-  if (typeof payload.expectedUpdatedAt === "string" || typeof payload.baseMarkdownSha256 === "string") {
-    return payload;
-  }
-  const baseline = await fetchNoteWriteBaseline(id, writeToken);
-  return {
-    ...payload,
-    expectedUpdatedAt: baseline.updatedAt
-  };
-};
-var prepareConfirmedWriteOperation = (writeSafety, result, input) => {
-  if (result.status !== "dry_run") {
-    return result;
-  }
-  return {
-    ...result,
-    operation: writeSafety.prepareOperation({
-      actor: "mcp-bearer",
-      affectedIds: input.affectedIds,
-      estimatedChangeCount: result.proposed?.changedLineCount ?? 1,
-      operationFingerprint: input.operationFingerprint,
-      risk: "high-impact",
-      summary: input.summary,
-      toolName: input.toolName
-    })
-  };
-};
-var requireConfirmedWriteOperation = (writeSafety, request, input) => {
-  const intent = writeSafety.ensureDestructiveWriteRequest(
-    request,
-    {
-      actor: "mcp-bearer",
-      affectedIds: input.affectedIds,
-      estimatedChangeCount: 1,
-      operationFingerprint: input.operationFingerprint,
-      risk: "high-impact",
-      summary: input.summary,
-      toolName: input.toolName
-    }
-  );
-  if (intent.kind !== "confirmed") {
-    throw new Error("Expected a confirmed MCP write operation.");
-  }
-  return intent.operation;
-};
-var executeConfirmedWrite = async (writeSafety, operation, request) => {
-  try {
-    const result = await request();
-    writeSafety.recordWriteResult(
-      operation,
-      result.status === "applied",
-      result.status === "applied" ? void 0 : result.reason
-    );
-    return result;
-  } catch (error) {
-    writeSafety.recordWriteResult(operation, false, getErrorDetail(error));
-    throw error;
-  }
-};
 var registerIntentWriteTools = (server, {
-  fetchNoteWriteBaseline,
   jsonRequest: jsonRequest2,
   requireWriteToken: requireWriteToken2,
   serverUrl,
   token,
-  tools,
-  writeSafety
+  tools
 }) => {
   server.tool(
     tools.patchNoteMarkdown,
-    "Patch a small part of an Ocean Brain note. Dry-run is the default; commit requires operationId and confirmToken from the dry-run result.",
+    "Patch a specific part of a note, like finding text with `rg` and editing only that match. Use for localized edits: fix one sentence, replace one paragraph, insert before/after exact text, or edit one section. Do not use for whole-note rewrites; use ocean_brain_replace_note_markdown instead.",
     {
-      id: z2.string().describe("Note ID to patch"),
-      expectedUpdatedAt: z2.string().optional().describe("Expected note updatedAt from a prior read. Auto-fetched when omitted unless baseMarkdownSha256 is provided."),
-      baseMarkdownSha256: z2.string().optional().describe("SHA-256 of the current markdown. Optional alternative to expectedUpdatedAt."),
-      intent: z2.string().describe("Human-readable reason for the patch."),
+      id: z.string().describe("Note ID to patch"),
+      expectedUpdatedAt: z.string().optional().describe("Expected note updatedAt from the read you based this edit on. Required unless baseMarkdownSha256 is provided."),
+      baseMarkdownSha256: z.string().optional().describe("SHA-256 of the current markdown. Optional alternative to expectedUpdatedAt."),
+      intent: z.string().describe("Human-readable reason for the patch."),
       selector: markdownPatchSelectorSchema.describe("Exact text or previously returned match candidate."),
       operation: markdownPatchOperationSchema.describe("replace, insert_before, or insert_after."),
-      policy: markdownWritePolicySchema,
-      ...confirmedMcpWriteFields
+      policy: markdownWritePolicySchema
     },
-    async ({ id, expectedUpdatedAt, baseMarkdownSha256, intent, selector, operation, policy, dryRun, operationId, confirmToken }) => {
+    async ({ id, expectedUpdatedAt, baseMarkdownSha256, intent, selector, operation, policy }) => {
       const writeToken = requireWriteToken2(token, tools.patchNoteMarkdown);
-      requireCommitConfirmationFields({ dryRun, operationId, confirmToken });
-      const payload = await resolvePayloadWithBaseline(fetchNoteWriteBaseline, writeToken, id, {
+      const payload = {
         id,
         ...expectedUpdatedAt ? { expectedUpdatedAt } : {},
         ...baseMarkdownSha256 ? { baseMarkdownSha256 } : {},
@@ -510,43 +179,8 @@ var registerIntentWriteTools = (server, {
         selector,
         operation,
         ...policy ? { policy } : {}
-      });
-      const operationFingerprint = createIntentWriteOperationFingerprint(serverUrl, writeToken, tools.patchNoteMarkdown, payload);
-      if (dryRun ?? true) {
-        const result2 = await jsonRequest2(serverUrl, writeToken, "/api/mcp/notes/patch-markdown", {
-          ...payload,
-          dryRun: true
-        });
-        return {
-          content: [{
-            type: "text",
-            text: JSON.stringify(prepareConfirmedWriteOperation(writeSafety, result2, {
-              affectedIds: [id],
-              operationFingerprint,
-              summary: intent,
-              toolName: tools.patchNoteMarkdown
-            }), null, 2)
-          }]
-        };
-      }
-      const confirmedOperation = requireConfirmedWriteOperation(
-        writeSafety,
-        { dryRun, operationId, confirmToken },
-        {
-          affectedIds: [id],
-          operationFingerprint,
-          summary: intent,
-          toolName: tools.patchNoteMarkdown
-        }
-      );
-      const result = await executeConfirmedWrite(
-        writeSafety,
-        confirmedOperation,
-        () => jsonRequest2(serverUrl, writeToken, "/api/mcp/notes/patch-markdown", {
-          ...payload,
-          dryRun: false
-        })
-      );
+      };
+      const result = await jsonRequest2(serverUrl, writeToken, "/api/mcp/notes/patch-markdown", payload);
       return {
         content: [{
           type: "text",
@@ -557,22 +191,20 @@ var registerIntentWriteTools = (server, {
   );
   server.tool(
     tools.appendNoteMarkdown,
-    "Append markdown to a note without replacing existing body content. Dry-run is the default; commit requires operationId and confirmToken.",
+    "Append markdown without changing existing content, like `cat addition.md >> note.md`. Use for adding logs, status updates, meeting notes, or new sections at the end or after a heading. Do not use to modify or replace existing body content.",
     {
-      id: z2.string().describe("Note ID to append to"),
-      expectedUpdatedAt: z2.string().optional().describe("Expected note updatedAt from a prior read. Auto-fetched when omitted unless baseMarkdownSha256 is provided."),
-      baseMarkdownSha256: z2.string().optional().describe("SHA-256 of the current markdown. Optional alternative to expectedUpdatedAt."),
-      intent: z2.string().describe("Human-readable reason for the append."),
-      insertion: z2.string().describe("Markdown to append. Tags are body tokens such as [@tag] or [#tag]."),
+      id: z.string().describe("Note ID to append to"),
+      expectedUpdatedAt: z.string().optional().describe("Expected note updatedAt from the read you based this edit on. Required unless baseMarkdownSha256 is provided."),
+      baseMarkdownSha256: z.string().optional().describe("SHA-256 of the current markdown. Optional alternative to expectedUpdatedAt."),
+      intent: z.string().describe("Human-readable reason for the append."),
+      insertion: z.string().describe("Markdown to append. Tags are body tokens such as [@tag] or [#tag]."),
       placement: markdownAppendPlacementSchema.optional().describe("Default is end. after_heading requires one unique matching heading."),
-      separator: z2.enum(["\n\n", "\n"]).optional().describe("Separator inserted around appended markdown. Defaults to a blank line."),
-      policy: markdownWritePolicySchema,
-      ...confirmedMcpWriteFields
+      separator: z.enum(["\n\n", "\n"]).optional().describe("Separator inserted around appended markdown. Defaults to a blank line."),
+      policy: markdownWritePolicySchema
     },
-    async ({ id, expectedUpdatedAt, baseMarkdownSha256, intent, insertion, placement, separator, policy, dryRun, operationId, confirmToken }) => {
+    async ({ id, expectedUpdatedAt, baseMarkdownSha256, intent, insertion, placement, separator, policy }) => {
       const writeToken = requireWriteToken2(token, tools.appendNoteMarkdown);
-      requireCommitConfirmationFields({ dryRun, operationId, confirmToken });
-      const payload = await resolvePayloadWithBaseline(fetchNoteWriteBaseline, writeToken, id, {
+      const payload = {
         id,
         ...expectedUpdatedAt ? { expectedUpdatedAt } : {},
         ...baseMarkdownSha256 ? { baseMarkdownSha256 } : {},
@@ -581,43 +213,8 @@ var registerIntentWriteTools = (server, {
         ...placement ? { placement } : {},
         ...separator ? { separator } : {},
         ...policy ? { policy } : {}
-      });
-      const operationFingerprint = createIntentWriteOperationFingerprint(serverUrl, writeToken, tools.appendNoteMarkdown, payload);
-      if (dryRun ?? true) {
-        const result2 = await jsonRequest2(serverUrl, writeToken, "/api/mcp/notes/append-markdown", {
-          ...payload,
-          dryRun: true
-        });
-        return {
-          content: [{
-            type: "text",
-            text: JSON.stringify(prepareConfirmedWriteOperation(writeSafety, result2, {
-              affectedIds: [id],
-              operationFingerprint,
-              summary: intent,
-              toolName: tools.appendNoteMarkdown
-            }), null, 2)
-          }]
-        };
-      }
-      const confirmedOperation = requireConfirmedWriteOperation(
-        writeSafety,
-        { dryRun, operationId, confirmToken },
-        {
-          affectedIds: [id],
-          operationFingerprint,
-          summary: intent,
-          toolName: tools.appendNoteMarkdown
-        }
-      );
-      const result = await executeConfirmedWrite(
-        writeSafety,
-        confirmedOperation,
-        () => jsonRequest2(serverUrl, writeToken, "/api/mcp/notes/append-markdown", {
-          ...payload,
-          dryRun: false
-        })
-      );
+      };
+      const result = await jsonRequest2(serverUrl, writeToken, "/api/mcp/notes/append-markdown", payload);
       return {
         content: [{
           type: "text",
@@ -628,62 +225,24 @@ var registerIntentWriteTools = (server, {
   );
   server.tool(
     tools.updateNoteMetadata,
-    "Update note title/layout/properties. For properties, call ocean_brain_list_properties first. Use existing property key and string value only; do not send valueType. select=option.value, date=YYYY-MM-DD, boolean=true/false, number=finite string, url=http(s). Use deleteKeys to remove values. Definitions are not created.",
+    "Update note metadata only: title, layout, or properties. This does not edit the note body. For properties, call ocean_brain_list_properties first. Use existing property key and string value only; do not send valueType. select=option.value, date=YYYY-MM-DD, boolean=true/false, number=finite string, url=http(s). Use deleteKeys to remove values. Definitions are not created.",
     {
-      id: z2.string().describe("Note ID to update"),
-      expectedUpdatedAt: z2.string().optional().describe("Expected note updatedAt from a prior read. Auto-fetched when omitted."),
-      title: z2.string().optional().describe("New note title"),
-      layout: z2.enum(["narrow", "wide", "full"]).optional().describe("New note layout"),
-      properties: metadataPropertyPatchSchema.describe("Patch existing shared property values. Include set and/or deleteKeys; empty patches are rejected."),
-      ...confirmedMcpWriteFields
+      id: z.string().describe("Note ID to update"),
+      expectedUpdatedAt: z.string().describe("Expected note updatedAt from the read you based this metadata edit on. Required to prevent stale writes."),
+      title: z.string().optional().describe("New note title"),
+      layout: z.enum(["narrow", "wide", "full"]).optional().describe("New note layout"),
+      properties: metadataPropertyPatchSchema.describe("Patch existing shared property values. Include set and/or deleteKeys; empty patches are rejected.")
     },
-    async ({ id, expectedUpdatedAt, title, layout, properties, dryRun, operationId, confirmToken }) => {
+    async ({ id, expectedUpdatedAt, title, layout, properties }) => {
       const writeToken = requireWriteToken2(token, tools.updateNoteMetadata);
-      requireCommitConfirmationFields({ dryRun, operationId, confirmToken });
-      const payload = await resolvePayloadWithBaseline(fetchNoteWriteBaseline, writeToken, id, {
+      const payload = {
         id,
         ...expectedUpdatedAt ? { expectedUpdatedAt } : {},
         ...title !== void 0 ? { title } : {},
         ...layout ? { layout } : {},
         ...properties ? { properties } : {}
-      });
-      const summary = properties ? `Update note ${id} metadata and properties` : `Update note ${id} metadata`;
-      const operationFingerprint = createIntentWriteOperationFingerprint(serverUrl, writeToken, tools.updateNoteMetadata, payload);
-      if (dryRun ?? true) {
-        const result2 = await jsonRequest2(serverUrl, writeToken, "/api/mcp/notes/metadata", {
-          ...payload,
-          dryRun: true
-        });
-        return {
-          content: [{
-            type: "text",
-            text: JSON.stringify(prepareConfirmedWriteOperation(writeSafety, result2, {
-              affectedIds: [id],
-              operationFingerprint,
-              summary,
-              toolName: tools.updateNoteMetadata
-            }), null, 2)
-          }]
-        };
-      }
-      const confirmedOperation = requireConfirmedWriteOperation(
-        writeSafety,
-        { dryRun, operationId, confirmToken },
-        {
-          affectedIds: [id],
-          operationFingerprint,
-          summary,
-          toolName: tools.updateNoteMetadata
-        }
-      );
-      const result = await executeConfirmedWrite(
-        writeSafety,
-        confirmedOperation,
-        () => jsonRequest2(serverUrl, writeToken, "/api/mcp/notes/metadata", {
-          ...payload,
-          dryRun: false
-        })
-      );
+      };
+      const result = await jsonRequest2(serverUrl, writeToken, "/api/mcp/notes/metadata", payload);
       return {
         content: [{
           type: "text",
@@ -694,63 +253,26 @@ var registerIntentWriteTools = (server, {
   );
   server.tool(
     tools.replaceNoteMarkdown,
-    "Replace a note body as a high-impact full overwrite. Dry-run returns a full diff; commit requires operationId and confirmToken.",
+    "Replace the entire note body, like overwriting a markdown file with `cat new.md > note.md`. Use when the user explicitly asks to rewrite, replace, regenerate, restructure, or overwrite the whole note. Do not use for localized edits such as fixing one sentence, changing one paragraph, or inserting under a heading; use ocean_brain_patch_note_markdown instead.",
     {
-      id: z2.string().describe("Note ID to replace"),
-      expectedUpdatedAt: z2.string().optional().describe("Expected note updatedAt from a prior read. Auto-fetched when omitted unless baseMarkdownSha256 is provided."),
-      baseMarkdownSha256: z2.string().optional().describe("SHA-256 of the current markdown. Optional alternative to expectedUpdatedAt."),
-      intent: z2.string().describe("Human-readable reason for the full replace."),
-      replacement: z2.string().describe("Complete replacement markdown body. Tags are body tokens such as [@tag] or [#tag]."),
-      policy: markdownWritePolicySchema,
-      ...confirmedMcpWriteFields
+      id: z.string().describe("Note ID to replace"),
+      expectedUpdatedAt: z.string().optional().describe("Expected note updatedAt from the read you based this edit on. Required unless baseMarkdownSha256 is provided."),
+      baseMarkdownSha256: z.string().optional().describe("SHA-256 of the current markdown. Optional alternative to expectedUpdatedAt."),
+      intent: z.string().describe("Human-readable reason for the full replace."),
+      replacement: z.string().describe("Complete replacement markdown body. Tags are body tokens such as [@tag] or [#tag]."),
+      policy: markdownWritePolicySchema
     },
-    async ({ id, expectedUpdatedAt, baseMarkdownSha256, intent, replacement, policy, dryRun, operationId, confirmToken }) => {
+    async ({ id, expectedUpdatedAt, baseMarkdownSha256, intent, replacement, policy }) => {
       const writeToken = requireWriteToken2(token, tools.replaceNoteMarkdown);
-      requireCommitConfirmationFields({ dryRun, operationId, confirmToken });
-      const payload = await resolvePayloadWithBaseline(fetchNoteWriteBaseline, writeToken, id, {
+      const payload = {
         id,
         ...expectedUpdatedAt ? { expectedUpdatedAt } : {},
         ...baseMarkdownSha256 ? { baseMarkdownSha256 } : {},
         intent,
         replacement,
         ...policy ? { policy } : {}
-      });
-      const operationFingerprint = createIntentWriteOperationFingerprint(serverUrl, writeToken, tools.replaceNoteMarkdown, payload);
-      if (dryRun ?? true) {
-        const result2 = await jsonRequest2(serverUrl, writeToken, "/api/mcp/notes/replace-markdown", {
-          ...payload,
-          dryRun: true
-        });
-        return {
-          content: [{
-            type: "text",
-            text: JSON.stringify(prepareConfirmedWriteOperation(writeSafety, result2, {
-              affectedIds: [id],
-              operationFingerprint,
-              summary: intent,
-              toolName: tools.replaceNoteMarkdown
-            }), null, 2)
-          }]
-        };
-      }
-      const confirmedOperation = requireConfirmedWriteOperation(
-        writeSafety,
-        { dryRun, operationId, confirmToken },
-        {
-          affectedIds: [id],
-          operationFingerprint,
-          summary: intent,
-          toolName: tools.replaceNoteMarkdown
-        }
-      );
-      const result = await executeConfirmedWrite(
-        writeSafety,
-        confirmedOperation,
-        () => jsonRequest2(serverUrl, writeToken, "/api/mcp/notes/replace-markdown", {
-          ...payload,
-          dryRun: false
-        })
-      );
+      };
+      const result = await jsonRequest2(serverUrl, writeToken, "/api/mcp/notes/replace-markdown", payload);
       return {
         content: [{
           type: "text",
@@ -787,10 +309,24 @@ var formatPropertyQueryResponse = ({
 });
 
 // src/mcp.ts
-var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  fs2.readFileSync(path2.resolve(__dirname, "..", "package.json"), "utf-8")
+  fs.readFileSync(path.resolve(__dirname, "..", "package.json"), "utf-8")
 );
+if (!pkg.oceanBrain?.mcpCompatibilityVersion) {
+  throw new Error("Ocean Brain MCP compatibility version is required in package metadata.");
+}
+var OCEAN_BRAIN_MCP_VERSION_HEADER = "X-Ocean-Brain-MCP-Version";
+var OCEAN_BRAIN_MCP_COMPATIBILITY_VERSION_HEADER = "X-Ocean-Brain-MCP-Compatibility-Version";
+var OCEAN_BRAIN_MCP_CLIENT_VERSION_HEADER = "X-Ocean-Brain-MCP-Client-Version";
+var OCEAN_BRAIN_MCP_COMPATIBILITY_VERSION = pkg.oceanBrain.mcpCompatibilityVersion;
+var createMcpRequestHeaders = (token) => ({
+  "Content-Type": "application/json",
+  [OCEAN_BRAIN_MCP_VERSION_HEADER]: OCEAN_BRAIN_MCP_COMPATIBILITY_VERSION,
+  [OCEAN_BRAIN_MCP_COMPATIBILITY_VERSION_HEADER]: OCEAN_BRAIN_MCP_COMPATIBILITY_VERSION,
+  [OCEAN_BRAIN_MCP_CLIENT_VERSION_HEADER]: pkg.version,
+  ...token ? { Authorization: `Bearer ${token}` } : {}
+});
 var OCEAN_BRAIN_MCP_TOOLS = {
   searchNotes: "ocean_brain_search_notes",
   readNote: "ocean_brain_read_note",
@@ -806,22 +342,34 @@ var OCEAN_BRAIN_MCP_TOOLS = {
   listNotesByTag: "ocean_brain_list_notes_by_tag",
   listNotesByTags: "ocean_brain_list_notes_by_tags",
   listRecentNotes: "ocean_brain_list_recent_notes",
-  writeSafetyStatus: "ocean_brain_write_safety_status",
   findNoteCleanupCandidates: "ocean_brain_find_note_cleanup_candidates",
   createTag: "ocean_brain_create_tag",
   deleteNote: "ocean_brain_delete_note"
 };
-var noteLayoutSchema = z3.enum(["narrow", "wide", "full"]);
-var tagMatchModeSchema = z3.enum(["and", "or"]);
-var propertyValueTypeSchema = z3.enum(["text", "url", "number", "date", "boolean", "select"]);
-var propertyFilterOperatorSchema = z3.enum(["equals", "before", "after", "exists", "notExists"]);
-var viewSortBySchema = z3.enum(["updatedAt", "createdAt", "title"]);
-var viewSortOrderSchema = z3.enum(["asc", "desc"]);
-var propertyFilterSchema = z3.object({
-  key: z3.string().describe("Property key from ocean_brain_list_properties, e.g. state"),
+var noteLayoutSchema = z2.enum(["narrow", "wide", "full"]);
+var tagMatchModeSchema = z2.enum(["and", "or"]);
+var propertyValueTypeSchema = z2.enum(["text", "url", "number", "date", "boolean", "select"]);
+var propertyFilterOperatorSchema = z2.enum(["equals", "before", "after", "exists", "notExists"]);
+var viewSortBySchema = z2.enum(["updatedAt", "createdAt", "title"]);
+var viewSortOrderSchema = z2.enum(["asc", "desc"]);
+var formatMcpGraphqlError = (error) => {
+  const suffix = [];
+  if (error.extensions?.code) {
+    suffix.push(`code=${error.extensions.code}`);
+  }
+  if (error.extensions?.operationId) {
+    suffix.push(`operationId=${error.extensions.operationId}`);
+  }
+  if (suffix.length === 0) {
+    return `GraphQL error: ${error.message}`;
+  }
+  return `GraphQL error: ${error.message} (${suffix.join(", ")})`;
+};
+var propertyFilterSchema = z2.object({
+  key: z2.string().describe("Property key from ocean_brain_list_properties, e.g. state"),
   valueType: propertyValueTypeSchema.describe("Property value type from the property definition"),
   operator: propertyFilterOperatorSchema.describe("Filter operator. before/after are only valid for date or number properties."),
-  value: z3.string().nullable().optional().describe("Filter value. Required unless operator is exists or notExists. select=option.value, date=YYYY-MM-DD, boolean=true/false, number=finite, url=http(s).")
+  value: z2.string().nullable().optional().describe("Filter value. Required unless operator is exists or notExists. select=option.value, date=YYYY-MM-DD, boolean=true/false, number=finite, url=http(s).")
 });
 var normalizeOceanBrainTagName = (name) => {
   const trimmedName = name.trim();
@@ -860,14 +408,14 @@ var fetchOceanBrainTags = async (serverUrl, token, query) => {
 async function graphql(serverUrl, token, query, variables) {
   const response = await fetch(`${serverUrl}/graphql/mcp`, {
     method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      ...token ? { Authorization: `Bearer ${token}` } : {}
-    },
+    headers: createMcpRequestHeaders(token),
     body: JSON.stringify({ query, variables })
   });
   if (!response.ok) {
-    throw new Error(`GraphQL request failed: ${response.status} ${response.statusText}`);
+    const errorBody = await response.json().catch(() => void 0);
+    throw new Error(
+      errorBody?.message ? `GraphQL request failed: ${errorBody.code || response.status} ${errorBody.message}` : `GraphQL request failed: ${response.status} ${response.statusText}`
+    );
   }
   const result = await response.json();
   if (result.errors?.length) {
@@ -878,10 +426,7 @@ async function graphql(serverUrl, token, query, variables) {
 async function jsonRequest(serverUrl, token, pathName, body) {
   const response = await fetch(`${serverUrl}${pathName}`, {
     method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      ...token ? { Authorization: `Bearer ${token}` } : {}
-    },
+    headers: createMcpRequestHeaders(token),
     body: JSON.stringify(body)
   });
   const result = await response.json();
@@ -890,30 +435,23 @@ async function jsonRequest(serverUrl, token, pathName, body) {
   }
   return result;
 }
-var fetchMcpNoteWriteBaseline = async (serverUrl, token, id, request = jsonRequest) => {
-  const result = await request(serverUrl, token, "/api/mcp/notes/baseline", { id });
-  return result.note;
-};
 var requireWriteToken = (token, toolName) => {
   if (token) {
     return token;
   }
   throw new Error(`${toolName} requires an MCP bearer token. Set --token or --token-file.`);
 };
-async function startMcpServer(serverUrl, token, options = {}) {
+async function startMcpServer(serverUrl, token) {
   const server = new McpServer({
     name: "ocean-brain",
     version: pkg.version
   });
-  const writeSafety = createMcpWriteSafetyCoordinator({
-    rootDir: options.writeSafetyDir ?? defaultMcpWriteSafetyDir()
-  });
   server.tool(
     OCEAN_BRAIN_MCP_TOOLS.searchNotes,
     "Search Ocean Brain notes by keyword. Returns matching note titles and tags. Use ocean_brain_read_note to get full content for a specific note.",
     {
-      query: z3.string().describe("Search keyword"),
-      limit: z3.number().optional().default(10).describe("Max results (default: 10)")
+      query: z2.string().describe("Search keyword"),
+      limit: z2.number().optional().default(10).describe("Max results (default: 10)")
     },
     async ({ query, limit }) => {
       const data = await graphql(serverUrl, token, `
@@ -953,8 +491,8 @@ async function startMcpServer(serverUrl, token, options = {}) {
     OCEAN_BRAIN_MCP_TOOLS.readNote,
     "Read an Ocean Brain note by ID. Returns properties, tags, truncated content by default (1000 chars), and a back-reference summary. Set maxLength to 0 only when full content is necessary.",
     {
-      id: z3.string().describe("Note ID"),
-      maxLength: z3.number().optional().default(1e3).describe("Max content length in characters. 0 for full content. (default: 1000)")
+      id: z2.string().describe("Note ID"),
+      maxLength: z2.number().optional().default(1e3).describe("Max content length in characters. 0 for full content. (default: 1000)")
     },
     async ({ id, maxLength }) => {
       const data = await graphql(serverUrl, token, `
@@ -993,8 +531,8 @@ async function startMcpServer(serverUrl, token, options = {}) {
     OCEAN_BRAIN_MCP_TOOLS.createNote,
     "Create an Ocean Brain note from markdown. Search/read first to avoid duplicates; prefer patching an existing note when the intent is a local change.",
     {
-      title: z3.string().describe("Note title"),
-      markdown: z3.string().optional().default("").describe("Markdown body for the new note. In MCP markdown, tags must use [@tag] or [#tag]. Defaults to an empty note body."),
+      title: z2.string().describe("Note title"),
+      markdown: z2.string().optional().default("").describe("Markdown body for the new note. In MCP markdown, tags must use [@tag] or [#tag]. Defaults to an empty note body."),
       layout: noteLayoutSchema.optional().describe("Optional note layout: narrow, wide, or full. Prefer wide for most notes unless the user explicitly wants narrow or full.")
     },
     async ({ title, markdown, layout }) => {
@@ -1014,11 +552,11 @@ async function startMcpServer(serverUrl, token, options = {}) {
   );
   server.tool(
     OCEAN_BRAIN_MCP_TOOLS.updateNote,
-    "Legacy full-field note update through the MCP write path. Prefer patch/append/metadata tools for small changes; use this only when intentionally replacing provided fields.",
+    "Legacy full-field note update kept for backward compatibility. Prefer ocean_brain_patch_note_markdown for localized body edits, ocean_brain_append_note_markdown for additions, ocean_brain_replace_note_markdown for whole-body rewrites, and ocean_brain_update_note_metadata for title/layout/properties. Use this only when a legacy client needs combined field updates.",
     {
-      id: z3.string().describe("Note ID to update"),
-      title: z3.string().optional().describe("New note title"),
-      markdown: z3.string().optional().describe("Replacement markdown body. In MCP markdown, tags must use [@tag] or [#tag]."),
+      id: z2.string().describe("Note ID to update"),
+      title: z2.string().optional().describe("New note title"),
+      markdown: z2.string().optional().describe("Replacement markdown body. In MCP markdown, tags must use [@tag] or [#tag]."),
       layout: noteLayoutSchema.optional().describe("Optional note layout: narrow, wide, or full. Prefer wide for most notes unless the user explicitly wants narrow or full.")
     },
     async ({ id, title, markdown, layout }) => {
@@ -1038,13 +576,11 @@ async function startMcpServer(serverUrl, token, options = {}) {
     }
   );
   registerIntentWriteTools(server, {
-    fetchNoteWriteBaseline: (id, writeToken) => fetchMcpNoteWriteBaseline(serverUrl, writeToken, id),
     jsonRequest,
     requireWriteToken,
     serverUrl,
     token,
-    tools: OCEAN_BRAIN_MCP_TOOLS,
-    writeSafety
+    tools: OCEAN_BRAIN_MCP_TOOLS
   });
   server.tool(
     OCEAN_BRAIN_MCP_TOOLS.listTags,
@@ -1079,9 +615,9 @@ async function startMcpServer(serverUrl, token, options = {}) {
     OCEAN_BRAIN_MCP_TOOLS.listProperties,
     "List shared Ocean Brain property definitions. Use this before property queries so keys, value types, and select option values are valid.",
     {
-      query: z3.string().optional().default("").describe("Optional property key/name search query"),
-      limit: z3.number().optional().default(50).describe("Max results (default: 50, server max: 100)"),
-      offset: z3.number().optional().default(0).describe("Pagination offset (default: 0)")
+      query: z2.string().optional().default("").describe("Optional property key/name search query"),
+      limit: z2.number().optional().default(50).describe("Max results (default: 50, server max: 100)"),
+      offset: z2.number().optional().default(0).describe("Pagination offset (default: 0)")
     },
     async ({ query, limit, offset }) => {
       const data = await graphql(serverUrl, token, `
@@ -1118,9 +654,9 @@ async function startMcpServer(serverUrl, token, options = {}) {
     OCEAN_BRAIN_MCP_TOOLS.listNotesByTag,
     "List Ocean Brain notes for a specific tag name. The tool accepts either @tag or tag and resolves it to the canonical Ocean Brain tag name first.",
     {
-      tag: z3.string().describe("Tag name to inspect. You can pass @project or project."),
-      limit: z3.number().optional().default(20).describe("Max results (default: 20)"),
-      offset: z3.number().optional().default(0).describe("Pagination offset (default: 0)")
+      tag: z2.string().describe("Tag name to inspect. You can pass @project or project."),
+      limit: z2.number().optional().default(20).describe("Max results (default: 20)"),
+      offset: z2.number().optional().default(0).describe("Pagination offset (default: 0)")
     },
     async ({ tag, limit, offset }) => {
       const normalizedTag = normalizeOceanBrainTagName(tag);
@@ -1183,10 +719,10 @@ async function startMcpServer(serverUrl, token, options = {}) {
     OCEAN_BRAIN_MCP_TOOLS.listNotesByTags,
     "List Ocean Brain notes for multiple tag names. Supports AND/OR matching and resolves each input tag to the canonical Ocean Brain tag name first.",
     {
-      tags: z3.array(z3.string()).min(1).describe("Tag names to inspect. You can pass @project or project values."),
+      tags: z2.array(z2.string()).min(1).describe("Tag names to inspect. You can pass @project or project values."),
       mode: tagMatchModeSchema.optional().default("and").describe("Tag match mode. Use and for intersection, or for union. Defaults to and."),
-      limit: z3.number().optional().default(20).describe("Max results (default: 20)"),
-      offset: z3.number().optional().default(0).describe("Pagination offset (default: 0)")
+      limit: z2.number().optional().default(20).describe("Max results (default: 20)"),
+      offset: z2.number().optional().default(0).describe("Pagination offset (default: 0)")
     },
     async ({ tags, mode, limit, offset }) => {
       const normalizedTags = normalizeOceanBrainTagNames(tags);
@@ -1260,15 +796,15 @@ async function startMcpServer(serverUrl, token, options = {}) {
     OCEAN_BRAIN_MCP_TOOLS.queryNotesByProperties,
     "Call ocean_brain_list_properties first. Requires >=1 propertyFilter; use search/recent for broad lists. Use key/valueType from the property definition. Values are strings: select=option.value, date=YYYY-MM-DD, boolean=true/false, number=finite, url=http(s). exists/notExists need no value. Property filters use AND; tagNames use mode. Summaries are returned by default; use propertyKeys for needed property details.",
     {
-      propertyFilters: z3.array(propertyFilterSchema).min(1).max(10).describe("Required property filters. Multiple property filters are combined with AND."),
-      tagNames: z3.array(z3.string()).optional().default([]).describe("Optional tag filters. You can pass @project, #project, or project."),
+      propertyFilters: z2.array(propertyFilterSchema).min(1).max(10).describe("Required property filters. Multiple property filters are combined with AND."),
+      tagNames: z2.array(z2.string()).optional().default([]).describe("Optional tag filters. You can pass @project, #project, or project."),
       mode: tagMatchModeSchema.optional().default("and").describe("Tag match mode for tagNames only. Property filters are always combined with AND."),
       sortBy: viewSortBySchema.optional().default("updatedAt").describe("Sort field (default: updatedAt)"),
       sortOrder: viewSortOrderSchema.optional().default("desc").describe("Sort order (default: desc)"),
-      includeProperties: z3.boolean().optional().default(false).describe("Include returned note properties. Defaults to false to reduce tokens."),
-      propertyKeys: z3.array(z3.string()).optional().default([]).describe("Property keys to include in output; automatically includes properties."),
-      limit: z3.number().optional().default(20).describe("Max results (default: 20, server max: 50)"),
-      offset: z3.number().optional().default(0).describe("Pagination offset (default: 0)")
+      includeProperties: z2.boolean().optional().default(false).describe("Include returned note properties. Defaults to false to reduce tokens."),
+      propertyKeys: z2.array(z2.string()).optional().default([]).describe("Property keys to include in output; automatically includes properties."),
+      limit: z2.number().optional().default(20).describe("Max results (default: 20, server max: 50)"),
+      offset: z2.number().optional().default(0).describe("Pagination offset (default: 0)")
     },
     async ({ propertyFilters, tagNames, mode, sortBy, sortOrder, includeProperties, propertyKeys, limit, offset }) => {
       const shouldIncludeProperties = includeProperties || propertyKeys.length > 0;
@@ -1327,7 +863,7 @@ async function startMcpServer(serverUrl, token, options = {}) {
     OCEAN_BRAIN_MCP_TOOLS.listRecentNotes,
     "List recently updated Ocean Brain notes. Returns titles and tags only. Use ocean_brain_read_note to get full content for a specific note.",
     {
-      limit: z3.number().optional().default(10).describe("Max results (default: 10)")
+      limit: z2.number().optional().default(10).describe("Max results (default: 10)")
     },
     async ({ limit }) => {
       const data = await graphql(serverUrl, token, `
@@ -1361,40 +897,13 @@ async function startMcpServer(serverUrl, token, options = {}) {
       };
     }
   );
-  server.tool(
-    OCEAN_BRAIN_MCP_TOOLS.writeSafetyStatus,
-    "Inspect pending destructive write confirmations and local operation log state for enabled Ocean Brain MCP write tools.",
-    {},
-    async () => {
-      return {
-        content: [{
-          type: "text",
-          text: JSON.stringify({
-            ...writeSafety.getStatus(),
-            destructiveWriteTools: [OCEAN_BRAIN_MCP_TOOLS.deleteNote],
-            writeTools: [
-              OCEAN_BRAIN_MCP_TOOLS.createNote,
-              OCEAN_BRAIN_MCP_TOOLS.updateNote,
-              OCEAN_BRAIN_MCP_TOOLS.patchNoteMarkdown,
-              OCEAN_BRAIN_MCP_TOOLS.appendNoteMarkdown,
-              OCEAN_BRAIN_MCP_TOOLS.updateNoteMetadata,
-              OCEAN_BRAIN_MCP_TOOLS.replaceNoteMarkdown,
-              OCEAN_BRAIN_MCP_TOOLS.createTag,
-              OCEAN_BRAIN_MCP_TOOLS.deleteNote
-            ],
-            writeToolsEnabled: true
-          }, null, 2)
-        }]
-      };
-    }
-  );
   server.tool(
     OCEAN_BRAIN_MCP_TOOLS.findNoteCleanupCandidates,
-    "Find Ocean Brain note cleanup candidates for temporary or draft notes before deletion. Use this before ocean_brain_delete_note.",
+    "Find Ocean Brain note cleanup candidates for temporary or draft notes before deletion. This is optional discovery; ocean_brain_delete_note moves a single note to trash directly.",
     {
-      keywords: z3.string().optional().default("temp tmp draft test wip").describe("Keywords that mark a note as a cleanup candidate. Comma or space separated."),
-      limit: z3.number().optional().default(20).describe("Max results (default: 20)"),
-      offset: z3.number().optional().default(0).describe("Pagination offset (default: 0)")
+      keywords: z2.string().optional().default("temp tmp draft test wip").describe("Keywords that mark a note as a cleanup candidate. Comma or space separated."),
+      limit: z2.number().optional().default(20).describe("Max results (default: 20)"),
+      offset: z2.number().optional().default(0).describe("Pagination offset (default: 0)")
     },
     async ({ keywords, limit, offset }) => {
       const normalizedKeywords = keywords.split(/[,\s]+/).map((keyword) => keyword.trim()).filter(Boolean);
@@ -1437,7 +946,7 @@ async function startMcpServer(serverUrl, token, options = {}) {
     OCEAN_BRAIN_MCP_TOOLS.createTag,
     "Create an Ocean Brain tag through the MCP write path. The tool accepts either @tag or tag and creates the canonical Ocean Brain tag if it does not already exist.",
     {
-      name: z3.string().describe("Tag name to create. You can pass @project or project.")
+      name: z2.string().describe("Tag name to create. You can pass @project or project.")
     },
     async ({ name }) => {
       const writeToken = requireWriteToken(token, OCEAN_BRAIN_MCP_TOOLS.createTag);
@@ -1454,92 +963,23 @@ async function startMcpServer(serverUrl, token, options = {}) {
   );
   server.tool(
     OCEAN_BRAIN_MCP_TOOLS.deleteNote,
-    "Delete an Ocean Brain note safely through a dry-run and confirmation flow. Start with dryRun=true, then call again with dryRun=false, operationId, and confirmToken.",
+    "Move an Ocean Brain note to trash, like `mv note.md trash/`. This is a recoverable trash move, not permanent deletion. Deleted-note tag names are kept as restore metadata; orphan tags are not a blocking condition.",
     {
-      id: z3.string().describe("Note ID to delete"),
-      ...destructiveMcpWriteFields
+      id: z2.string().describe("Note ID to move to trash")
     },
-    async ({ id, dryRun, operationId, confirmToken, force }) => {
+    async ({ id }) => {
       const writeToken = requireWriteToken(token, OCEAN_BRAIN_MCP_TOOLS.deleteNote);
-      const data = await graphql(serverUrl, writeToken, `
-                query ($id: ID!) {
-                    noteCleanupPreview(id: $id) {
-                        id
-                        title
-                        updatedAt
-                        pinned
-                        tagNames
-                        reminderCount
-                        backReferences {
-                            id
-                            title
-                        }
-                        orphanedTagNames
-                        requiresForce
-                        forceReasons
-                    }
-                }
-            `, { id });
-      const preview = data?.noteCleanupPreview;
-      if (!preview) {
-        return {
-          content: [{
-            type: "text",
-            text: JSON.stringify({
-              deleted: false,
-              reason: "NOTE_NOT_FOUND",
-              id
-            }, null, 2)
-          }]
-        };
-      }
-      const intent = writeSafety.ensureDestructiveWriteRequest(
-        { dryRun, operationId, confirmToken, force },
-        {
-          actor: "mcp-bearer",
-          affectedIds: [preview.id],
-          estimatedChangeCount: 1,
-          force: preview.requiresForce,
-          risk: "destructive",
-          summary: `Delete note ${preview.id} (${preview.title})`,
-          toolName: OCEAN_BRAIN_MCP_TOOLS.deleteNote
-        }
-      );
-      if (intent.kind === "dry-run") {
-        return {
-          content: [{
-            type: "text",
-            text: JSON.stringify({
-              mode: "dry-run",
-              preview,
-              operation: intent.operation
-            }, null, 2)
-          }]
-        };
-      }
-      if (intent.operation.force && !force) {
-        throw new Error(`${OCEAN_BRAIN_MCP_TOOLS.deleteNote} requires force=true because ${preview.forceReasons.join(", ")}.`);
-      }
       try {
-        const result = await jsonRequest(serverUrl, writeToken, "/api/mcp/notes/delete", {
-          id: preview.id
-        });
-        writeSafety.recordWriteResult(intent.operation, true);
+        const result = await jsonRequest(serverUrl, writeToken, "/api/mcp/notes/delete", { id });
         return {
           content: [{
             type: "text",
-            text: JSON.stringify({
-              mode: "commit",
-              preview,
-              operation: intent.operation,
-              result
-            }, null, 2)
+            text: JSON.stringify(result, null, 2)
           }]
         };
       } catch (error) {
         const message = error instanceof Error ? error.message : "Unknown MCP note delete error";
-        writeSafety.recordWriteResult(intent.operation, false, message);
-        throw error;
+        throw new Error(message);
       }
     }
   );
@@ -1547,7 +987,11 @@ async function startMcpServer(serverUrl, token, options = {}) {
   await server.connect(transport);
 }
 export {
+  OCEAN_BRAIN_MCP_CLIENT_VERSION_HEADER,
+  OCEAN_BRAIN_MCP_COMPATIBILITY_VERSION,
+  OCEAN_BRAIN_MCP_COMPATIBILITY_VERSION_HEADER,
   OCEAN_BRAIN_MCP_TOOLS,
-  fetchMcpNoteWriteBaseline,
+  OCEAN_BRAIN_MCP_VERSION_HEADER,
+  createMcpRequestHeaders,
   startMcpServer
 };