borgmcp 2.7.3 → 2.9.0

package/src/assimilate-cmd.ts

@@ -277,7 +277,7 @@ export interface AssimilateDeps {
   detectLocalServer: () => Promise<string | null>;
   connectServer: (
     apiUrl: string,
-    enrollment?: { invitation: string },
+    enrollment?: { invitation: string; confirmReplacement?: () => Promise<boolean> },
   ) => Promise<{
     token: string;
     trustIdentity: string;
@@ -361,6 +361,11 @@ function affirmative(answer: string): boolean {
   return normalized === '' || normalized === 'y' || normalized === 'yes';
 }
 
+function strictAffirmative(answer: string): boolean {
+  const normalized = answer.trim().toLowerCase();
+  return normalized === 'y' || normalized === 'yes';
+}
+
 async function selectAssimilationAuthority(
   flags: AssimilateFlags,
   deps: AssimilateDeps,
@@ -475,6 +480,14 @@ function reportServerFailure(
     );
     return 1;
   }
+  if (error instanceof BorgServerError && error.code === 'LOCAL_CREDENTIAL_EXISTS') {
+    deps.stderr(
+      `A local enrollment for ${apiUrl} already exists and was not replaced. ` +
+        `Re-run ${localAssimilateCommand(apiUrl, true, mode)} and explicitly confirm replacement ` +
+        'only if the first enrolled client should be abandoned.\n',
+    );
+    return 1;
+  }
   if (error instanceof LegacySessionCredentialCollisionError) {
     const recovery = mode === 'cube-init'
       ? localAssimilateCommand(error.origin, true, mode)
@@ -729,8 +742,14 @@ export async function runAssimilate(
             );
             return 1;
           }
-          try {
-            serverAuth = await deps.connectServer(authority.apiUrl, { invitation });
+           try {
+             serverAuth = await deps.connectServer(authority.apiUrl, {
+               invitation,
+               confirmReplacement: async () => strictAffirmative(await deps.prompt(
+                 `A local enrollment for ${authority.apiUrl} already exists. Replacing it will orphan ` +
+                   'the first enrolled client. Replace it? [y/N]: ',
+               )),
+             });
           } finally {
             // Strings cannot be zeroized in JavaScript, but drop this command's
             // reference immediately after the exchange instead of retaining the
@@ -1492,7 +1511,7 @@ export async function runAssimilate(
       deps.stderr(
         'Borg could not enumerate this repository’s existing worktrees, so it did not risk creating a colliding sibling.\n' +
         'Run `git worktree list` from this repository and resolve the reported Git error, then rerun `borg assimilate`.\n' +
-        'A seat was reserved and remains pending; rerunning after fixing the worktree issue resumes that seat.\n',
+        'A local drone reservation was created and remains pending; rerunning after fixing the worktree issue resumes that reservation.\n',
       );
       return 1;
     }
@@ -1565,13 +1584,13 @@ export async function runAssimilate(
           ? `Git left branch ${residualBranch} without a registered worktree; Borg preserved it.\n`
           : '') +
         'Run `git worktree list` and `git status` to inspect repository state, resolve the reported Git error, then rerun `borg assimilate`.\n' +
-        'A seat was reserved and remains pending; rerunning after fixing the worktree issue resumes that seat.\n',
+        'A local drone reservation was created and remains pending; rerunning after fixing the worktree issue resumes that reservation.\n',
       );
       return 1;
     }
     deps.stderr(
       `spawned sibling worktree at ${candidate} on branch ${wtBranch} (${startRef}); ` +
-      `the original dir keeps its active seat — run \`borg reset-local-seat\` there if that binding is stale.\n`
+      `the original dir keeps its active drone binding — run \`borg reset-local-seat\` there if that binding is stale.\n`
     );
     deps.chdir(candidate);
     deps.stderr(renderWorktreeSteeringNote(candidate, wtBranch, projectRoot));

package/src/assimilate-deps.ts

@@ -241,6 +241,9 @@ export function buildDefaultAssimilateDeps(
     connectServer: async (apiUrl, enrollment) => {
       if (enrollment) {
         return enrollLocalBorgServer(apiUrl, enrollment.invitation, {
+          ...(enrollment.confirmReplacement === undefined
+            ? {}
+            : { confirmReplacement: enrollment.confirmReplacement }),
           clientName: osHostname(),
         });
       }

package/src/cli-help.ts

@@ -74,9 +74,8 @@ export function clientSubcommandHelpText(
 export function setupNextStepsText(): string {
   return (
     `◼ Next steps:\n` +
-    `1. Run \`borg server setup\` to prepare the local server.\n` +
-    `2. Run \`borg server start\` and leave that terminal open.\n` +
-    `3. In a second terminal, cd into your project and run \`borg assimilate\`.\n`
+    `1. Run \`borg server start\` and leave that terminal open.\n` +
+    `2. In a second terminal, cd into your project's Git repository and run \`borg assimilate\`.\n`
   );
 }
 

package/src/config.ts

@@ -447,6 +447,7 @@ export async function activatePendingServerEnrollment(
     credential: string;
     clientId: string;
     serverCapabilities: ServerCapability[];
+    allowReplacement?: boolean;
   },
 ): Promise<void> {
   validateServerCredentialBinding(input.origin, input.trustIdentity);
@@ -471,6 +472,9 @@ export async function activatePendingServerEnrollment(
     } catch {
       throw new Error('pending Borg server enrollment does not match the verified response');
     }
+    if (!input.allowReplacement && await backend.get(serverCredentialAccount(input.origin, input.trustIdentity))) {
+      throw new Error('local Borg server enrollment already exists');
+    }
     // Already inside the single store lock — use the UNLOCKED write body so we do
     // not re-acquire (and self-deadlock on) CREDENTIALS_LOCK (CR3b).
     await writeServerCredentialRecord(backend, {

package/src/drone-lifecycle.ts

@@ -12,6 +12,7 @@
  */
 
 export const DRONE_EVICTED_CODE = 'DRONE_EVICTED';
+export const CUBE_DELETED_CODE = 'CUBE_DELETED';
 
 export class DroneEvictedError extends Error {
   constructor(
@@ -22,11 +23,19 @@ export class DroneEvictedError extends Error {
   }
 }
 
+export class CubeDeletedError extends Error {
+  constructor(public readonly cubeName?: string) {
+    super('This cube was deleted.');
+    this.name = 'CubeDeletedError';
+  }
+}
+
 /**
  * Marker the agent's /loop + role playbook branch on. Single-sourced so the
  * SSE wake sentinel (log-stream) and the tool-result funnel (index) agree.
  */
 export const EVICTED_RESULT_MARKER = '[CUBE-EVICTED]';
+export const CUBE_DELETED_RESULT_MARKER = '[CUBE-DELETED]';
 
 /**
  * The recognizable tool RESULT the agent sees when an authed call returns the
@@ -43,6 +52,22 @@ export function formatEvictedToolResult(cubeName?: string): string {
   );
 }
 
+export function formatCubeDeletedToolResult(cubeName?: string): string {
+  const cube = cubeName ?? 'the selected cube';
+  return (
+    `${CUBE_DELETED_RESULT_MARKER} Cube ${cube} was deleted.\n\n` +
+    'Borg has stopped listening for activity for this cube. Do not retry this request or restart the loop.\n\n' +
+    'Your worktree and project files are unchanged. Finish any local file safety checks, then end this agent session.'
+  );
+}
+
+export function formatCubeDeletedErrorToolResult(
+  error: CubeDeletedError,
+  activeCubeName?: string,
+): string {
+  return formatCubeDeletedToolResult(error.cubeName ?? activeCubeName);
+}
+
 /**
  * Extract the structured error code from a worker error body. The worker error
  * funnel (sanitizeError → createHttpError) emits `{ code, message }`; some

package/src/first-run-server.ts

@@ -1,3 +1,4 @@
+import { spawn } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -14,10 +15,12 @@ const CLIENT_PACKAGE = 'borgmcp';
 const SERVER_PACKAGE = 'borgmcp-server';
 const SHARED_PACKAGE = 'borgmcp-shared';
 const DEFAULT_CONNECT_COMMAND = 'borg assimilate --host <host>';
+const CLIENT_ONBOARDING_ENV = 'BORG_CLIENT_ONBOARDING';
+export const HINT_SUPPORTED_FROM = '0.8.1';
 
 export type FirstRunServerInstallResult =
-  | { kind: 'present'; server: InstalledPackage }
-  | { kind: 'installed'; server: InstalledPackage }
+  | { kind: 'present'; server: InstalledPackage; suppressClientNextSteps?: boolean }
+  | { kind: 'installed'; server: InstalledPackage; suppressClientNextSteps?: boolean }
   | { kind: 'declined' | 'non-interactive' | 'failed' };
 
 export interface FirstRunServerInstallDeps {
@@ -32,7 +35,8 @@ export interface FirstRunServerInstallDeps {
     version: string,
     options?: { ignoreScripts?: boolean },
   ): Promise<void>;
-  confirm(message: string): Promise<'yes' | 'no' | 'eof' | 'interrupted'>;
+  runServerSetup(server: InstalledPackage, options?: { onboardingHint?: boolean }): Promise<number>;
+  confirm(message: string, defaultYes?: boolean): Promise<'yes' | 'no' | 'eof' | 'interrupted'>;
   isTTY(): boolean;
   stdout(text: string): void;
   stderr(text: string): void;
@@ -84,6 +88,18 @@ export function buildDefaultFirstRunServerInstallDeps(): FirstRunServerInstallDe
     publishedPackage: update.publishedPackage,
     publishedVersions: update.publishedVersions,
     installGlobal: update.installGlobal,
+    runServerSetup: (server, options = {}) => new Promise((resolve) => {
+      const childEnv = { ...process.env };
+      delete childEnv[CLIENT_ONBOARDING_ENV];
+      if (options.onboardingHint) childEnv[CLIENT_ONBOARDING_ENV] = '1';
+      const child = spawn(server.binPath, ['setup'], {
+        stdio: 'inherit',
+        shell: false,
+        env: childEnv,
+      });
+      child.once('error', () => resolve(1));
+      child.once('exit', (code) => resolve(code ?? 1));
+    }),
     confirm: update.confirm,
     isTTY: update.isTTY,
     stdout: update.stdout,
@@ -100,6 +116,7 @@ export function buildDefaultFirstRunServerInstallDeps(): FirstRunServerInstallDe
 export async function offerFirstRunServerInstall(
   deps: FirstRunServerInstallDeps = buildDefaultFirstRunServerInstallDeps(),
   connectCommand = DEFAULT_CONNECT_COMMAND,
+  options: { initializeServer?: boolean } = {},
 ): Promise<FirstRunServerInstallResult> {
   let installed: InstalledPackage | null;
   try {
@@ -112,7 +129,15 @@ export async function offerFirstRunServerInstall(
     );
     return { kind: 'failed' };
   }
-  if (installed) return { kind: 'present', server: installed };
+  if (installed) {
+    return initializeServerIfRequested(
+      installed,
+      deps,
+      options.initializeServer,
+      'present',
+      shouldSuppressClientNextSteps(installed.version),
+    );
+  }
 
   if (!deps.isTTY()) {
     deps.stderr(
@@ -140,9 +165,11 @@ export async function offerFirstRunServerInstall(
   const command = exactInstallCommand(target.version);
   const decision = await deps.confirm(
     `No local ${SERVER_PACKAGE} installation was found. ` +
-    `Install ${SERVER_PACKAGE}@${target.version}, which uses ${SHARED_PACKAGE}@${target.sharedVersion}, now?\n` +
+      `Install ${SERVER_PACKAGE}@${target.version}, the local coordination server, ` +
+      `which uses ${SHARED_PACKAGE}@${target.sharedVersion}, now?\n` +
     `Command: ${command}\n` +
-    `Continue? [y/N] `,
+      `Install it now? [Y/n] `,
+      true,
   );
   if (decision !== 'yes') {
     const reason = decision === 'interrupted'
@@ -172,7 +199,43 @@ export async function offerFirstRunServerInstall(
 
   deps.stdout(
     `Installed ${SERVER_PACKAGE}@${target.version} with ${SHARED_PACKAGE}@${target.sharedVersion}.\n` +
-    `Next, run \`borg server setup\`, then run \`borg server start\` in a terminal you keep open.\n`,
+    (options.initializeServer
+      ? `The local server package is ready.\n`
+      : `Next, run \`borg server setup\`, then run \`borg server start\` in a terminal you keep open.\n`),
+  );
+  return initializeServerIfRequested(installed, deps, options.initializeServer, 'installed');
+}
+
+async function initializeServerIfRequested(
+  server: InstalledPackage,
+  deps: FirstRunServerInstallDeps,
+  requested: boolean | undefined,
+  kind: 'present' | 'installed',
+  suppressClientNextSteps = false,
+): Promise<FirstRunServerInstallResult> {
+  if (!requested) return { kind, server, ...(suppressClientNextSteps ? { suppressClientNextSteps: true } : {}) };
+  try {
+    const exitCode = await deps.runServerSetup(server, { onboardingHint: !suppressClientNextSteps });
+    if (exitCode === 0) {
+      return { kind, server, ...(suppressClientNextSteps ? { suppressClientNextSteps: true } : {}) };
+    }
+  } catch (error) {
+    deps.stderr(`Local server setup could not be completed. ${error instanceof Error ? error.message : String(error)}\n`);
+  }
+  deps.stderr(
+    'Run `borg server setup` to retry local server initialization, then run `borg server start`.\n',
   );
-  return { kind: 'installed', server: installed };
+  return { kind: 'failed' };
+}
+
+function shouldSuppressClientNextSteps(version: unknown): boolean {
+  if (!isExactSemver(version)) return false;
+  const installedParts = version.split('.').slice(0, 3).map(Number);
+  const supportedParts = HINT_SUPPORTED_FROM.split('.').map(Number);
+  for (let index = 0; index < 3; index += 1) {
+    if (installedParts[index] !== supportedParts[index]) {
+      return installedParts[index] < supportedParts[index];
+    }
+  }
+  return false;
 }

package/src/index.ts

@@ -20,6 +20,7 @@ import {
 } from '@modelcontextprotocol/sdk/types.js';
 
 import { assertRoleMatches } from './role-match.js';
+import { CubeDeletionConfirmationError } from './server-errors.js';
 
 import {
   getCubeInfo,
@@ -103,7 +104,9 @@ import {
 } from './roster-render.js';
 import { resolveWorkingRepo } from './working-repo.js';
 import {
+  CubeDeletedError,
   DroneEvictedError,
+  formatCubeDeletedErrorToolResult,
   formatEvictedToolResult,
 } from './drone-lifecycle.js';
 import {
@@ -1048,7 +1051,11 @@ export async function main() {
         case 'borg_delete-cube': {
           const cubeId = args?.cube_id as string;
           if (!cubeId) throw new Error('cube_id is required');
-          await deleteCube(cubeId);
+          const confirmCubeId = args?.confirm_cube_id as string | undefined;
+          if (confirmCubeId !== cubeId) {
+            throw new CubeDeletionConfirmationError(cubeId, confirmCubeId);
+          }
+          await deleteCube(cubeId, confirmCubeId);
           return { content: [{ type: 'text', text: `Deleted cube ${cubeId} (and all its roles, drones, log entries).` }] };
         }
 
@@ -1261,6 +1268,13 @@ export async function main() {
           isError: true,
         };
       }
+      if (error instanceof CubeDeletedError) {
+        const active = await getActiveCube();
+        return {
+          content: [{ type: 'text', text: formatCubeDeletedErrorToolResult(error, active?.name) }],
+          isError: true,
+        };
+      }
 
       const localManageResult = formatLocalManageToolResult(error);
       if (localManageResult) return localManageResult;

package/src/log-stream.ts

@@ -40,6 +40,8 @@ import {
   type LocalServerCursor,
 } from './local-server-cursor.js';
 import {
+  CubeDeletedError,
+  CUBE_DELETED_CODE,
   DroneEvictedError,
   DRONE_EVICTED_CODE,
   EVICTED_RESULT_MARKER,
@@ -573,7 +575,7 @@ async function runLoop(testDeps: RunLoopTestDeps = {}): Promise<void> {
       // loop quiesces cleanly. The agent's graceful shutdown (TaskStop Monitor,
       // no /loop reschedule) is driven separately by the EVICTED tool-result it
       // already received on the authed call that produced this verdict.
-      if (err instanceof DroneEvictedError || err instanceof BorgServerError) {
+      if (err instanceof CubeDeletedError || err instanceof DroneEvictedError || err instanceof BorgServerError) {
         if (active.localSessionCredentialRef) {
           markSeatRejected(active.localSessionCredentialRef);
         }
@@ -591,15 +593,15 @@ async function runLoop(testDeps: RunLoopTestDeps = {}): Promise<void> {
           streamState.ownership = await readOwnershipSnapshot(active.cubeId, active.droneId);
           continue;
         }
-        if (err instanceof DroneEvictedError) {
+        if (err instanceof DroneEvictedError || err instanceof CubeDeletedError) {
           if (lease) await lease.release().catch(() => {});
           lease = null;
           leaseKey = null;
           streamState.connected = false;
           streamState.ownership = await readOwnershipSnapshot(active.cubeId, active.droneId);
-          process.stderr.write(
-            `[borg-mcp log stream] drone evicted — stream terminated (no reconnect).\n`
-          );
+          process.stderr.write(err instanceof CubeDeletedError
+            ? '[borg-mcp log stream] cube deleted — stream terminated (no reconnect).\n'
+            : '[borg-mcp log stream] drone evicted — stream terminated (no reconnect).\n');
         }
         throw new TerminalStreamError();
       }
@@ -939,6 +941,10 @@ export async function streamOnce(
         if (active.localSessionCredentialRef) markSeatRejected(active.localSessionCredentialRef);
         throw new DroneEvictedError();
       }
+      if (code === CUBE_DELETED_CODE) {
+        if (active.localSessionCredentialRef) markSeatRejected(active.localSessionCredentialRef);
+        throw new CubeDeletedError();
+      }
       // client#42: an expired resume cursor is RECOVERABLE, not terminal. The
       // pointed-at entry was pruned server-side, so retrying the SAME cursor
       // 410s forever (a wedged, silently-dead wake path). Reset the stream's
@@ -1010,6 +1016,13 @@ export async function streamOnce(
         break;
       }
 
+      if (event.type === 'error') {
+        if (active.localSessionCredentialRef) markSeatRejected(active.localSessionCredentialRef);
+        if (event.code === CUBE_DELETED_CODE) throw new CubeDeletedError();
+        if (event.code === DRONE_EVICTED_CODE) throw new DroneEvictedError();
+        throw new BorgServerError('CREDENTIAL_REJECTED', 'Borg server terminated the stream');
+      }
+
       if (event.type === 'heartbeat') {
         streamState.lastHeartbeatAt = nowIso;
         // First/baseline heartbeat absorb: until this session has seen
@@ -1198,6 +1211,7 @@ export type ParsedEvent =
   | { type: 'bookmark'; as_of: string | null }
   // gh#877 Path-A: terminal eviction control frame (wake hint, zero authority).
   | { type: 'eviction'; id: string | null; cube_id: string | null; reason: string | null }
+  | { type: 'error'; code: ErrorCode }
   | { type: 'unknown'; raw: string };
 
 /**
@@ -1357,6 +1371,13 @@ function parseEventBlock(block: string): ParsedEvent | null {
     }
     return { type: 'eviction', id: id || null, cube_id, reason };
   }
+  if (eventName === 'error') {
+    try {
+      return { type: 'error', code: decodeProtocolErrorEnvelope(JSON.parse(dataStr)).error.code };
+    } catch {
+      return { type: 'unknown', raw: block };
+    }
+  }
   return { type: 'unknown', raw: block };
 }
 

package/src/remote-client.ts

@@ -16,6 +16,7 @@ import {
 import { randomUUID } from 'node:crypto';
 import {
   createProtocolEnvelope,
+  decodeDeleteCubeResponse,
   decodeDroneRuntimeMetadataState,
   decodeEvictDroneResult,
   decodeProtocolEnvelope,
@@ -23,6 +24,7 @@ import {
   decodeReassignDroneResult,
   decodeUpdateDroneRuntimeMetadataResponse,
   ErrorCode,
+  ProtocolContractError,
   type AgentKind,
   type EvictDroneResult,
   type ReassignDroneResult,
@@ -30,7 +32,12 @@ import {
 import { consolePrefix } from './console-prefix.js';
 import { debugLog } from './debug.js';
 import { assertUuidShape } from './evict-drone.js';
-import { DroneEvictedError, DRONE_EVICTED_CODE } from './drone-lifecycle.js';
+import {
+  CubeDeletedError,
+  CUBE_DELETED_CODE,
+  DroneEvictedError,
+  DRONE_EVICTED_CODE,
+} from './drone-lifecycle.js';
 import type { MessageTaxonomy, MessageTaxonomyClass } from 'borgmcp-shared/templates';
 import { getTemplate, type Template, type TemplateRole } from 'borgmcp-shared/templates';
 import { parseRoleSections } from 'borgmcp-shared/role-section';
@@ -41,8 +48,10 @@ import { loadBorgServerTrust, type ServerFetch } from './server-trust.js';
 import {
   BorgServerError,
   BorgServerHttpError,
+  BorgProtocolMismatchError,
   BorgServerTrustError,
   BorgServerUnreachableError,
+  CubeDeletionConfirmationError,
   LocalManageCredentialUnavailableError,
   LocalManageRequiredError,
 } from './server-errors.js';
@@ -226,6 +235,12 @@ async function decodeLocalProtocolResponse<T>(
       // CR5: a TYPED transport-timeout verdict (message kept for call-site parity).
       throw new BorgServerUnreachableError('Local Borg server request timed out');
     }
+    if (
+      error instanceof ProtocolContractError &&
+      error.code === ErrorCode.UNSUPPORTED_PROTOCOL_VERSION
+    ) {
+      throw new BorgProtocolMismatchError();
+    }
     throw error;
   } finally {
     clearTimeout(timeout);
@@ -329,6 +344,9 @@ async function localManageRequest<T>(
         }),
     }), true, decodePayload);
   } catch (error) {
+    if (error instanceof CubeDeletedError) {
+      throw new CubeDeletedError(operation.cubeName);
+    }
     if (
       error instanceof BorgServerHttpError &&
       error.status === 403 &&
@@ -704,6 +722,7 @@ async function authedFetch(
     // terminal controls. Decode only the bounded protocol error code for typed
     // branching; never surface the server-provided message or details.
     let code: ErrorCode | undefined;
+    let protocolMismatch = false;
     try {
       const body = await readBoundedResponseBody(
         response,
@@ -713,7 +732,13 @@ async function authedFetch(
       const parsed = JSON.parse(body);
       try {
         code = decodeProtocolErrorEnvelope(parsed).error.code;
-      } catch {
+      } catch (error) {
+        if (
+          error instanceof ProtocolContractError &&
+          error.code === ErrorCode.UNSUPPORTED_PROTOCOL_VERSION
+        ) {
+          protocolMismatch = true;
+        }
         if (
           parsed !== null && typeof parsed === 'object' &&
           parsed.error !== null && typeof parsed.error === 'object' &&
@@ -738,10 +763,15 @@ async function authedFetch(
       code = undefined;
     }
     debugLog(`✗ ${response.status} ${method} ${path}`);
+    if (protocolMismatch) throw new BorgProtocolMismatchError();
     if (droneSession !== undefined && response.status === 410 && code === DRONE_EVICTED_CODE) {
       if (localSessionCredentialRef !== undefined) markSeatRejected(localSessionCredentialRef);
       throw new DroneEvictedError();
     }
+    if (response.status === 410 && code === CUBE_DELETED_CODE) {
+      if (localSessionCredentialRef !== undefined) markSeatRejected(localSessionCredentialRef);
+      throw new CubeDeletedError();
+    }
     throw new BorgServerHttpError(
       response.status,
       `Borg server request failed (HTTP ${response.status})`,
@@ -1011,7 +1041,7 @@ export async function regen(
   opts: {
     since?: string;
     /** Advisory self-report from the running agent; never model-routing config. */
-    reportedModel?: string;
+    reportedModel?: string | null;
     /** Positively identified running Agent CLI; null means explicitly unknown. */
     agentKind?: AgentKind | null;
     /** Current cwd-derived identity; refreshed each regen to avoid stale routing data. */
@@ -1047,7 +1077,7 @@ export async function regen(
   ) {
     const patch = buildRuntimeMetadataPatch({
       agentKind: opts.agentKind ?? null,
-      reportedModel: opts.reportedModel,
+      reportedModel: opts.reportedModel ?? null,
       workingRepo: opts.workingRepo,
     });
     try {
@@ -1316,9 +1346,30 @@ export async function patchTaxonomyClass(
  * Delete a cube. Cascade-deletes all roles, drones, and log entries.
  * Requires a live cube-manage grant on the selected local client.
  */
-export async function deleteCube(cubeId: string): Promise<void> {
-  void cubeId;
-  localUnsupported('cube deletion');
+export async function deleteCube(cubeId: string, confirmCubeId: string): Promise<void> {
+  if (confirmCubeId !== cubeId) {
+    throw new CubeDeletionConfirmationError(cubeId, confirmCubeId);
+  }
+  assertUuidShape(cubeId, 'cube_id');
+  const active = await getActiveCube();
+  if (!active?.serverTrustIdentity) throw new Error('Selected Borg server authority state is missing or unreadable');
+  const cubeName = cubeId === active.cubeId ? active.name : cubeId;
+  const result = await localManageRequest(
+    active,
+    `/api/cubes/${cubeId}`,
+    'DELETE',
+    {
+      operation: `delete cube ${manageCopyValue(cubeName)}`,
+      cubeName,
+      noMutation: 'The cube was not deleted.',
+    },
+    {},
+    decodeDeleteCubeResponse,
+  );
+  if (!result) throw new Error('Local Borg server returned an empty cube deletion response');
+  if (result.cube_id !== cubeId) {
+    throw new Error('Local Borg server returned a deletion response for an unexpected cube');
+  }
 }
 
 /**

package/src/runtime-metadata.ts

@@ -53,13 +53,14 @@ export function buildRuntimeMetadataReport(input: {
 
 export function buildRuntimeMetadataPatch(input: {
   agentKind: AgentKind | null;
-  reportedModel?: string;
+  reportedModel?: string | null;
   workingRepo?: WorkingRepo;
 }): DroneRuntimeMetadataPatch {
   const patch: DroneRuntimeMetadataPatch = { agent_kind: input.agentKind };
   if (input.reportedModel !== undefined) {
-    const model = safeReportedModel(input.reportedModel);
-    if (model !== null) patch.reported_model = model;
+    patch.reported_model = input.reportedModel === null
+      ? null
+      : validateReportedModel(input.reportedModel);
   }
   const repository = reportableRepository(input.workingRepo);
   if (repository) Object.assign(patch, repository);

package/src/server-errors.ts

@@ -2,6 +2,7 @@ export type BorgServerErrorCode =
   | 'NOT_ENROLLED'
   | 'CREDENTIAL_REJECTED'
   | 'INVITATION_REJECTED'
+  | 'LOCAL_CREDENTIAL_EXISTS'
   | 'CREATE_CUBE_DENIED'
   | 'ATTACH_CONFLICT'
   | 'SESSION_REJECTED'
@@ -35,6 +36,16 @@ export class BorgServerHttpError extends Error {
   }
 }
 
+export class BorgProtocolMismatchError extends Error {
+  constructor() {
+    super(
+      'This client and the selected Borg server use different protocol versions. ' +
+      'Update `borgmcp-server` and `borgmcp` to matching releases, server first and then client.',
+    );
+    this.name = 'BorgProtocolMismatchError';
+  }
+}
+
 export class LocalManageRequiredError extends Error {
   constructor(
     public readonly operation: string,
@@ -106,6 +117,20 @@ export class CubeCreationConfirmationError extends Error {
   }
 }
 
+export class CubeDeletionConfirmationError extends Error {
+  constructor(
+    public readonly cubeId: string,
+    public readonly confirmCubeId: string | undefined,
+  ) {
+    const supplied = confirmCubeId === undefined ? '(missing)' : `"${confirmCubeId}"`;
+    super(
+      `Cube deletion is irreversible. The confirmation cube ID ${supplied} must exactly match ` +
+      `the requested cube ID "${cubeId}". No cube was deleted.`,
+    );
+    this.name = 'CubeDeletionConfirmationError';
+  }
+}
+
 export type RepositoryAssociationFailure =
   | 'repository-already-associated'
   | 'cube-already-associated'