borgmcp 2.10.2 → 2.11.0

package/src/server-trust.ts

@@ -1,7 +1,7 @@
 import { Buffer } from 'node:buffer';
 import { createHash, timingSafeEqual, X509Certificate } from 'node:crypto';
 import { constants } from 'node:fs';
-import { access, mkdir, open, rename, rm, writeFile } from 'node:fs/promises';
+import { access, lstat, mkdir, open, rename, rm, unlink, writeFile } from 'node:fs/promises';
 import { request as httpsRequest } from 'node:https';
 import { connect as tlsConnect } from 'node:tls';
 import { homedir } from 'node:os';
@@ -15,6 +15,18 @@ import {
   InvitationArtifactTransportError,
   InvitationArtifactTrustError,
 } from './invitation-artifact.js';
+import { atomicWrite0600 } from './seat-store.js';
+import { withEnrollmentOriginLock } from './enrollment-lock.js';
+import {
+  finalizeAcceptedEnrollment,
+  getAcceptedEnrollmentMarker,
+  restoreAcceptedEnrollmentAccounts,
+} from './config.js';
+import type {
+  AcceptedEnrollmentMarker,
+  EnrollmentArtifactBinding,
+  EnrollmentTrustPointer,
+} from './enrollment-types.js';
 
 // CR5 TLS LATTICE: OpenSSL/Node TLS certificate-verification error codes. A raw
 // CA / cert-chain / SAN failure from the pinned transport is a potential MITM and
@@ -57,7 +69,11 @@ export interface BorgServerTrust {
 }
 
 export interface StagedBorgServerTrust extends BorgServerTrust {
-  commitTrust: (activate: () => Promise<void>) => Promise<void>;
+  generationId: string;
+  commitTrust: (activate: (context: {
+    generationId: string;
+    previousPointer: EnrollmentTrustPointer | null;
+  }) => Promise<void>) => Promise<void>;
   discardTrust: () => Promise<void>;
 }
 
@@ -66,6 +82,24 @@ interface ServerTrustConfig {
 }
 
 const trustCache = new Map<string, Promise<BorgServerTrust>>();
+type EnrollmentTrustFaultPoint =
+  | 'after-account-activation'
+  | 'after-pointer-publish'
+  | 'before-marker-finalize'
+  | 'during-pointer-rollback';
+let enrollmentTrustFaultsForTest = new Set<EnrollmentTrustFaultPoint>();
+
+function injectEnrollmentTrustFault(point: EnrollmentTrustFaultPoint): void {
+  if (enrollmentTrustFaultsForTest.has(point)) throw new Error(`injected ${point} failure`);
+}
+
+function invalidateOriginTrustCache(origin: string): void {
+  for (const key of trustCache.keys()) {
+    if (key === origin || key.startsWith(`${origin}\0`) || key.endsWith(`\0${origin}`)) {
+      trustCache.delete(key);
+    }
+  }
+}
 
 function serverDataDirectory(): string {
   return resolve(process.env.BORG_SERVER_DATA_DIR ?? join(homedir(), '.borg', 'server'));
@@ -76,6 +110,24 @@ function remoteTrustDirectory(origin: string): string {
   return join(homedir(), '.borg', 'server-trust', key);
 }
 
+function trustGenerationsDirectory(origin: string): string {
+  return join(remoteTrustDirectory(origin), 'generations');
+}
+
+function trustGenerationDirectory(origin: string, generationId: string): string {
+  return join(trustGenerationsDirectory(origin), generationId);
+}
+
+function trustPointerPath(origin: string): string {
+  return join(remoteTrustDirectory(origin), 'current.json');
+}
+
+function trustGenerationId(origin: string, certificate: string, identity: string): string {
+  return createHash('sha256')
+    .update(origin).update('\0').update(identity).update('\0').update(certificate)
+    .digest('hex');
+}
+
 async function trustFilesExist(directory: string): Promise<boolean> {
   try {
     await Promise.all([access(join(directory, 'ca.crt')), access(join(directory, 'server.json'))]);
@@ -85,6 +137,11 @@ async function trustFilesExist(directory: string): Promise<boolean> {
   }
 }
 
+async function remoteTrustStateExists(origin: string): Promise<boolean> {
+  try { await access(trustPointerPath(origin)); return true; } catch { /* continue */ }
+  return trustFilesExist(remoteTrustDirectory(origin));
+}
+
 async function readTrustFile(path: string): Promise<string> {
   let handle;
   try {
@@ -109,6 +166,16 @@ async function readTrustFile(path: string): Promise<string> {
   }
 }
 
+async function assertPrivateDirectory(path: string): Promise<void> {
+  const metadata = await lstat(path);
+  if (!metadata.isDirectory() || metadata.isSymbolicLink() || (metadata.mode & 0o077) !== 0) {
+    throw new Error('Borg server trust directories must be private real directories');
+  }
+  if (typeof process.getuid === 'function' && metadata.uid !== process.getuid()) {
+    throw new Error('Borg server trust directories must be owned by the current user');
+  }
+}
+
 async function syncPath(path: string): Promise<void> {
   const handle = await open(path, 'r');
   try {
@@ -153,6 +220,119 @@ function verifyCaIdentity(certificate: string, expected: string): string {
   return `spki-sha256:${actual.toString('hex')}`;
 }
 
+async function readGeneration(
+  origin: string,
+  generationId: string,
+): Promise<{ certificate: string; identity: string }> {
+  if (!/^[a-f0-9]{64}$/.test(generationId)) throw new Error('Borg server trust pointer is invalid');
+  const directory = trustGenerationDirectory(origin, generationId);
+  const [certificate, configText] = await Promise.all([
+    readTrustFile(join(directory, 'ca.crt')),
+    readTrustFile(join(directory, 'server.json')),
+  ]);
+  const config = decodeTrustConfig(configText);
+  const identity = verifyCaIdentity(certificate, config.ca_spki_sha256);
+  if (trustGenerationId(origin, certificate, identity) !== generationId) {
+    throw new Error('Borg server trust generation digest is invalid');
+  }
+  return { certificate, identity };
+}
+
+async function readTrustPointer(origin: string): Promise<EnrollmentTrustPointer | null> {
+  try { await assertPrivateDirectory(remoteTrustDirectory(origin)); } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null;
+    throw error;
+  }
+  let raw: string;
+  try {
+    raw = await readTrustFile(trustPointerPath(origin));
+  } catch (error) {
+    if (error instanceof Error && /were not found/.test(error.message)) return null;
+    throw error;
+  }
+  let pointer: Partial<EnrollmentTrustPointer>;
+  try { pointer = JSON.parse(raw) as Partial<EnrollmentTrustPointer>; } catch {
+    throw new Error('Borg server trust pointer is invalid');
+  }
+  if (
+    pointer.version !== 1 || pointer.origin !== origin ||
+    typeof pointer.generationId !== 'string' || !/^[a-f0-9]{64}$/.test(pointer.generationId) ||
+    typeof pointer.trustIdentity !== 'string'
+  ) throw new Error('Borg server trust pointer is invalid');
+  return pointer as EnrollmentTrustPointer;
+}
+
+async function publishTrustPointer(pointer: EnrollmentTrustPointer): Promise<void> {
+  const root = remoteTrustDirectory(pointer.origin);
+  await mkdir(root, { recursive: true, mode: 0o700 });
+  await assertPrivateDirectory(root);
+  await atomicWrite0600(trustPointerPath(pointer.origin), `${JSON.stringify(pointer)}\n`);
+  invalidateOriginTrustCache(pointer.origin);
+}
+
+async function removeTrustPointer(origin: string): Promise<void> {
+  try { await unlink(trustPointerPath(origin)); } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+  }
+  await syncPath(remoteTrustDirectory(origin));
+  invalidateOriginTrustCache(origin);
+}
+
+async function publishGeneration(
+  origin: string,
+  certificate: string,
+  identity: string,
+): Promise<string> {
+  const generationId = trustGenerationId(origin, certificate, identity);
+  const generations = trustGenerationsDirectory(origin);
+  const target = trustGenerationDirectory(origin, generationId);
+  await mkdir(generations, { recursive: true, mode: 0o700 });
+  await assertPrivateDirectory(resolve(remoteTrustDirectory(origin), '..'));
+  await assertPrivateDirectory(remoteTrustDirectory(origin));
+  await assertPrivateDirectory(generations);
+  if (await trustFilesExist(target)) {
+    const verified = await readGeneration(origin, generationId);
+    if (verified.identity !== identity) throw new Error('Borg server trust generation identity changed');
+    return generationId;
+  }
+  const temporary = `${target}.tmp-${process.pid}-${Date.now()}`;
+  try {
+    await mkdir(temporary, { mode: 0o700 });
+    const certificatePath = join(temporary, 'ca.crt');
+    const configPath = join(temporary, 'server.json');
+    await writeFile(certificatePath, certificate, { mode: 0o600, flag: 'wx' });
+    await syncPath(certificatePath);
+    await writeFile(configPath, JSON.stringify({
+      ca_spki_sha256: identity.replace(/^spki-sha256:/, ''),
+    }), { mode: 0o600, flag: 'wx' });
+    await syncPath(configPath);
+    await syncPath(temporary);
+    await rename(temporary, target);
+    await syncPath(generations);
+    const verified = await readGeneration(origin, generationId);
+    if (verified.identity !== identity) throw new Error('Borg server trust generation identity changed');
+    return generationId;
+  } catch (error) {
+    await rm(temporary, { recursive: true, force: true }).catch(() => undefined);
+    throw error;
+  }
+}
+
+async function migrateLegacyRemoteTrust(origin: string): Promise<EnrollmentTrustPointer | null> {
+  const directory = remoteTrustDirectory(origin);
+  if (!await trustFilesExist(directory)) return null;
+  const [certificate, configText] = await Promise.all([
+    readTrustFile(join(directory, 'ca.crt')),
+    readTrustFile(join(directory, 'server.json')),
+  ]);
+  const config = decodeTrustConfig(configText);
+  const identity = verifyCaIdentity(certificate, config.ca_spki_sha256);
+  const generationId = await publishGeneration(origin, certificate, identity);
+  const pointer: EnrollmentTrustPointer = { version: 1, origin, generationId, trustIdentity: identity };
+  await publishTrustPointer(pointer);
+  return pointer;
+}
+
 function responseHeaders(rawHeaders: string[]): Headers {
   const headers = new Headers();
   for (let index = 0; index < rawHeaders.length; index += 2) {
@@ -214,6 +394,10 @@ export function createPinnedServerFetch(origin: string, caCertificate: string):
         headers: Object.fromEntries(headers.entries()),
         ca: caCertificate,
         rejectUnauthorized: true,
+        // The pinned CA is the authority boundary. OpenSSL still validates
+        // the complete chain; only the leaf's address SAN check is skipped
+        // so a DHCP change does not require reissuing the leaf certificate.
+        checkServerIdentity: () => undefined,
         minVersion: 'TLSv1.3',
       }, (incoming) => {
         const status = incoming.statusCode ?? 500;
@@ -266,32 +450,48 @@ export async function loadBorgServerTrust(
   origin: string,
   dataDirectory?: string,
 ): Promise<BorgServerTrust> {
-  const requestedDirectory = dataDirectory ?? serverDataDirectory();
-  const key = `${requestedDirectory}\0${origin}`;
-  let pending = trustCache.get(key);
-  if (!pending) {
-    pending = (async () => {
-      const remoteDirectory = remoteTrustDirectory(origin);
-      const directory = dataDirectory === undefined && await trustFilesExist(remoteDirectory)
-        ? remoteDirectory
-        : dataDirectory === undefined && !(await trustFilesExist(requestedDirectory))
-          ? remoteDirectory
-          : requestedDirectory;
-      const [certificate, configText] = await Promise.all([
-        readTrustFile(join(directory, 'ca.crt')),
-        readTrustFile(join(directory, 'server.json')),
-      ]);
-      const config = decodeTrustConfig(configText);
-      const identity = verifyCaIdentity(certificate, config.ca_spki_sha256);
-      return {
-        identity,
-        fetchImpl: createPinnedServerFetch(origin, certificate),
-      };
-    })();
-    trustCache.set(key, pending);
-    pending.catch(() => trustCache.delete(key));
+  const useRemoteState = dataDirectory === undefined && await remoteTrustStateExists(origin);
+  if (dataDirectory !== undefined || !useRemoteState && await trustFilesExist(serverDataDirectory())) {
+    const directory = dataDirectory ?? serverDataDirectory();
+    const key = `legacy\0${directory}\0${origin}`;
+    let pending = trustCache.get(key);
+    if (!pending) {
+      pending = (async () => {
+        const [certificate, configText] = await Promise.all([
+          readTrustFile(join(directory, 'ca.crt')),
+          readTrustFile(join(directory, 'server.json')),
+        ]);
+        const config = decodeTrustConfig(configText);
+        const identity = verifyCaIdentity(certificate, config.ca_spki_sha256);
+        return { identity, fetchImpl: createPinnedServerFetch(origin, certificate) };
+      })();
+      trustCache.set(key, pending);
+      pending.catch(() => trustCache.delete(key));
+    }
+    return pending;
   }
-  return pending;
+  return withEnrollmentOriginLock(origin, async () => {
+    await recoverAcceptedEnrollment(origin);
+    const pointer = await readTrustPointer(origin) ?? await migrateLegacyRemoteTrust(origin);
+    if (!pointer) throw new Error('Borg server trust files were not found');
+    const key = `${origin}\0${pointer.generationId}\0${pointer.trustIdentity}`;
+    let pending = trustCache.get(key);
+    if (!pending) {
+      pending = (async () => {
+        const generation = await readGeneration(origin, pointer.generationId);
+        if (generation.identity !== pointer.trustIdentity) {
+          throw new Error('Borg server trust pointer identity does not match its generation');
+        }
+        return {
+          identity: generation.identity,
+          fetchImpl: createPinnedServerFetch(origin, generation.certificate),
+        };
+      })();
+      trustCache.set(key, pending);
+      pending.catch(() => trustCache.delete(key));
+    }
+    return pending;
+  });
 }
 
 function pemCertificate(raw: Buffer): string {
@@ -369,63 +569,189 @@ export async function stageBorgServerTrust(
   certificate: string,
   identity: string,
 ): Promise<StagedBorgServerTrust> {
-  const directory = remoteTrustDirectory(origin);
-  const parent = resolve(directory, '..');
-  await mkdir(parent, { recursive: true, mode: 0o700 });
-  const suffix = `${process.pid}-${Date.now()}`;
-  const temporaryDirectory = `${directory}.tmp-${suffix}`;
-  const temporaryCertificate = join(temporaryDirectory, 'ca.crt');
-  const temporaryConfig = join(temporaryDirectory, 'server.json');
+  let generationId: string;
   try {
-    await mkdir(temporaryDirectory, { recursive: false, mode: 0o700 });
-    await Promise.all([
-      writeFile(temporaryCertificate, certificate, { mode: 0o600, flag: 'wx' }),
-      writeFile(temporaryConfig, JSON.stringify({ ca_spki_sha256: identity.replace(/^spki-sha256:/, '') }), { mode: 0o600, flag: 'wx' }),
-    ]);
-    await Promise.all([syncPath(temporaryCertificate), syncPath(temporaryConfig), syncPath(temporaryDirectory)]);
+    generationId = await withEnrollmentOriginLock(origin, () =>
+      publishGeneration(origin, certificate, identity));
   } catch {
-    await rm(temporaryDirectory, { recursive: true, force: true });
     throw new InvitationArtifactStorageError();
   }
-  let committed = false;
+  return stagedTrustFromGeneration(origin, generationId, identity, certificate);
+}
+
+function stagedTrustFromGeneration(
+  origin: string,
+  generationId: string,
+  identity: string,
+  certificate: string,
+): StagedBorgServerTrust {
+  let finalized = false;
   return {
     identity,
+    generationId,
     fetchImpl: createPinnedServerFetch(origin, certificate),
     commitTrust: async (activate) => {
-      if (committed) return;
-      const backupDirectory = `${directory}.backup-${suffix}`;
-      let backedUp = false;
-      try {
-        await rename(directory, backupDirectory).then(() => { backedUp = true; }).catch((error: unknown) => {
-          if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
-        });
-        await rename(temporaryDirectory, directory);
-        await syncPath(resolve(directory, '..'));
-        await activate();
-        committed = true;
-        await rm(backupDirectory, { recursive: true, force: true }).catch(() => undefined);
-      } catch (error) {
-        await rm(directory, { recursive: true, force: true });
-        await rm(temporaryDirectory, { recursive: true, force: true });
-        if (backedUp) {
-          await rename(backupDirectory, directory);
-          await syncPath(resolve(directory, '..'));
+      if (finalized) return;
+      await withEnrollmentOriginLock(origin, async () => {
+        const previousPointer = await readTrustPointer(origin) ?? await migrateLegacyRemoteTrust(origin);
+        let activated = false;
+        try {
+          await activate({ generationId, previousPointer });
+          const accepted = await getAcceptedEnrollmentMarker(origin);
+          if (
+            !accepted || accepted.generationId !== generationId ||
+            accepted.trustIdentity !== identity
+          ) throw new Error('Borg enrollment activation did not publish its accepted marker');
+          activated = true;
+          injectEnrollmentTrustFault('after-account-activation');
+          await publishTrustPointer({ version: 1, origin, generationId, trustIdentity: identity });
+          injectEnrollmentTrustFault('after-pointer-publish');
+          const verified = await readGeneration(origin, generationId);
+          if (verified.identity !== identity) throw new Error('published Borg trust generation changed');
+          injectEnrollmentTrustFault('before-marker-finalize');
+          await finalizeAcceptedEnrollment(origin, identity, generationId);
+          finalized = true;
+        } catch (error) {
+          let marker;
+          try { marker = await getAcceptedEnrollmentMarker(origin); } catch {
+            throw new InvitationArtifactRecoveryError();
+          }
+          // Activation is one atomic account-map replacement, but a durable
+          // backend may report an error after rename and before/while syncing
+          // the parent directory. The accepted marker, not the callback's
+          // return value, is therefore the authority for whether rollback is
+          // required.
+          if (!marker && !activated) throw error;
+          if (!marker) throw new InvitationArtifactRecoveryError();
+          try {
+            await restoreEnrollmentPointer(marker);
+            await restoreAcceptedEnrollmentAccounts(marker);
+          } catch {
+            throw new InvitationArtifactRecoveryError();
+          }
+          throw new InvitationArtifactRecoveryError();
         }
-        throw new InvitationArtifactRecoveryError();
-      }
+      });
     },
     discardTrust: async () => {
-      if (committed) return;
-      await rm(temporaryDirectory, { recursive: true, force: true });
+      if (finalized) return;
+      await withEnrollmentOriginLock(origin, async () => {
+        const pointer = await readTrustPointer(origin);
+        if (pointer?.generationId === generationId) return;
+        await rm(trustGenerationDirectory(origin, generationId), { recursive: true, force: true });
+        await syncPath(trustGenerationsDirectory(origin)).catch(() => undefined);
+      });
     },
   };
 }
 
+async function restoreEnrollmentPointer(marker: {
+  origin: string;
+  previousPointer: EnrollmentTrustPointer | null;
+}): Promise<void> {
+  injectEnrollmentTrustFault('during-pointer-rollback');
+  if (marker.previousPointer === null) {
+    await removeTrustPointer(marker.origin);
+    if (await readTrustPointer(marker.origin) !== null) throw new Error('Borg trust pointer rollback failed');
+    return;
+  }
+  const previous = await readGeneration(marker.origin, marker.previousPointer.generationId);
+  if (previous.identity !== marker.previousPointer.trustIdentity) {
+    throw new Error('Borg previous trust generation is invalid');
+  }
+  await publishTrustPointer(marker.previousPointer);
+  const restored = await readTrustPointer(marker.origin);
+  if (restored?.generationId !== marker.previousPointer.generationId) {
+    throw new Error('Borg trust pointer rollback failed');
+  }
+}
+
+async function recoverAcceptedEnrollment(origin: string): Promise<void> {
+  const marker = await getAcceptedEnrollmentMarker(origin);
+  if (!marker) return;
+  try {
+    const generation = await readGeneration(origin, marker.generationId);
+    if (generation.identity !== marker.trustIdentity) throw new Error('Borg enrollment generation identity changed');
+    await publishTrustPointer({
+      version: 1,
+      origin,
+      generationId: marker.generationId,
+      trustIdentity: marker.trustIdentity,
+    });
+    await finalizeAcceptedEnrollment(origin, marker.trustIdentity, marker.generationId);
+  } catch {
+    try {
+      await restoreEnrollmentPointer(marker);
+      await restoreAcceptedEnrollmentAccounts(marker);
+    } catch {
+      throw new InvitationArtifactRecoveryError();
+    }
+    throw new InvitationArtifactRecoveryError();
+  }
+}
+
+/** Verify the exact persisted artifact binding before any resumed network I/O. */
+export async function loadStagedBorgServerTrust(
+  origin: string,
+  binding: EnrollmentArtifactBinding,
+): Promise<StagedBorgServerTrust> {
+  return withEnrollmentOriginLock(origin, async () => {
+    if (
+      binding.endpoint !== origin || binding.trustIdentity !== `spki-sha256:${binding.caSpkiSha256}`
+    ) throw new InvitationArtifactTrustError();
+    let generation: { certificate: string; identity: string };
+    try { generation = await readGeneration(origin, binding.stagedGenerationId); } catch {
+      throw new InvitationArtifactRecoveryError();
+    }
+    if (generation.identity !== binding.trustIdentity) throw new InvitationArtifactTrustError();
+    return stagedTrustFromGeneration(
+      origin,
+      binding.stagedGenerationId,
+      generation.identity,
+      generation.certificate,
+    );
+  });
+}
+
+/** Explicit operator recovery restores the exact accepted journal that was reviewed. */
+export async function restoreBorgServerEnrollment(expected: AcceptedEnrollmentMarker): Promise<boolean> {
+  return withEnrollmentOriginLock(expected.origin, async () => {
+    const marker = await getAcceptedEnrollmentMarker(expected.origin);
+    if (!marker || JSON.stringify(marker) !== JSON.stringify(expected)) return false;
+    await restoreEnrollmentPointer(expected);
+    await restoreAcceptedEnrollmentAccounts(expected);
+    return true;
+  });
+}
+
+export async function clearStagedBorgServerTrust(
+  origin: string,
+  generationId: string | undefined,
+): Promise<void> {
+  if (!generationId) return;
+  await withEnrollmentOriginLock(origin, async () => {
+    const pointer = await readTrustPointer(origin);
+    if (pointer?.generationId === generationId) {
+      throw new InvitationArtifactRecoveryError();
+    }
+    await rm(trustGenerationDirectory(origin, generationId), { recursive: true, force: true });
+    await syncPath(trustGenerationsDirectory(origin)).catch(() => undefined);
+  });
+}
+
 export function __clearServerTrustCacheForTest(): void {
   trustCache.clear();
 }
 
+export function __setEnrollmentTrustFaultForTest(
+  points: EnrollmentTrustFaultPoint | EnrollmentTrustFaultPoint[] | null,
+): void {
+  enrollmentTrustFaultsForTest = new Set(points === null ? [] : Array.isArray(points) ? points : [points]);
+}
+
 export async function clearBorgServerTrust(origin: string): Promise<void> {
-  await rm(remoteTrustDirectory(origin), { recursive: true, force: true });
-  trustCache.delete(`${serverDataDirectory()}\0${origin}`);
+  await withEnrollmentOriginLock(origin, async () => {
+    await rm(remoteTrustDirectory(origin), { recursive: true, force: true });
+    invalidateOriginTrustCache(origin);
+  });
 }

package/src/tool-manifest.ts

@@ -348,9 +348,9 @@ export const TOOL_MANIFEST: ToolManifestEntry[] = [
             properties: {
               name: {
                 type: 'string',
-                description: 'Cube name (lowercase letters, digits, hyphens; max 64 chars).',
-                pattern: '^[a-z0-9-]+$',
-                maxLength: 64,
+                description: 'Cube name (starts with a letter or digit; letters, digits, spaces, dots, underscores, or hyphens; max 120 UTF-8 bytes).',
+                pattern: '^[A-Za-z0-9][A-Za-z0-9 ._-]*$',
+                maxLength: 120,
               },
               cube_directive: { type: 'string', description: 'Project-specific Markdown shown to every drone when it refreshes cube context.' },
               template: {
@@ -363,17 +363,11 @@ export const TOOL_MANIFEST: ToolManifestEntry[] = [
         },
         {
           name: 'borg_update-cube',
-          description: 'Update a cube\'s name, cube_directive, and/or message_taxonomy. Pass only what changes.',
+          description: 'Update a cube\'s cube_directive and/or message_taxonomy. Pass only what changes.',
           inputSchema: {
             type: 'object',
             properties: {
               cube_id: { type: 'string', description: 'UUID of the cube to update.' },
-              name: {
-                type: 'string',
-                description: 'New name (optional). Lowercase letters, digits, hyphens; max 64 chars.',
-                pattern: '^[a-z0-9-]+$',
-                maxLength: 64,
-              },
               cube_directive: { type: 'string', description: 'New cube directive markdown (optional).' },
               message_taxonomy: {
                 type: 'array',