borgmcp 2.9.0 → 2.10.0

package/dist/unknown-subcommand.d.ts

@@ -11,7 +11,7 @@
  * (`--cli`, `--remote`, agent passthrough, …) still fall through to launch.
  */
 /** The subcommands the claude.ts router dispatches on (lines 107-176). */
-export declare const KNOWN_SUBCOMMANDS: readonly ["setup", "update", "assimilate", "reset-local-seat", "spawn", "sync", "cleanup", "launch-all", "server"];
+export declare const KNOWN_SUBCOMMANDS: readonly ["setup", "update", "assimilate", "reset-local-seat", "recover-enrollment", "spawn", "sync", "cleanup", "launch-all", "server"];
 /**
  * Returns the offending command string when argv[2] is an unknown non-flag
  * positional (caller should error + exit 1), or null when it's bare `borg`,

package/dist/unknown-subcommand.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unknown-subcommand.d.ts","sourceRoot":"","sources":["../src/unknown-subcommand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,0EAA0E;AAC1E,eAAO,MAAM,iBAAiB,oHAUpB,CAAC;AAEX;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAK1E"}
+{"version":3,"file":"unknown-subcommand.d.ts","sourceRoot":"","sources":["../src/unknown-subcommand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,0EAA0E;AAC1E,eAAO,MAAM,iBAAiB,0IAWpB,CAAC;AAEX;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAK1E"}

package/dist/unknown-subcommand.js

@@ -16,6 +16,7 @@ export const KNOWN_SUBCOMMANDS = [
     'update',
     'assimilate',
     'reset-local-seat',
+    'recover-enrollment',
     'spawn',
     'sync',
     'cleanup',

package/dist/unknown-subcommand.js.map

@@ -1 +1 @@
-{"version":3,"file":"unknown-subcommand.js","sourceRoot":"","sources":["../src/unknown-subcommand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,0EAA0E;AAC1E,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,OAAO;IACP,QAAQ;IACR,YAAY;IACZ,kBAAkB;IAClB,OAAO;IACP,MAAM;IACN,SAAS;IACT,YAAY;IACZ,QAAQ;CACA,CAAC;AAEX;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAyB;IACzD,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC,CAAC,cAAc;IACpD,IAAI,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC,CAAC,8BAA8B;IACtE,IAAK,iBAAuC,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAC1E,OAAO,KAAK,CAAC,CAAC,wCAAwC;AACxD,CAAC"}
+{"version":3,"file":"unknown-subcommand.js","sourceRoot":"","sources":["../src/unknown-subcommand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,0EAA0E;AAC1E,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,OAAO;IACP,QAAQ;IACR,YAAY;IACZ,kBAAkB;IAClB,oBAAoB;IACpB,OAAO;IACP,MAAM;IACN,SAAS;IACT,YAAY;IACZ,QAAQ;CACA,CAAC;AAEX;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAyB;IACzD,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC,CAAC,cAAc;IACpD,IAAI,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC,CAAC,8BAA8B;IACtE,IAAK,iBAAuC,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAC1E,OAAO,KAAK,CAAC,CAAC,wCAAwC;AACxD,CAAC"}

package/docs/EXTRACTION_PROVENANCE.md

@@ -22,7 +22,7 @@ The extraction copied the monorepo's `client/src/` production boundary and top-l
   recovery, `2.0.2`, `2.0.3`, `2.0.4`, `2.0.5`, and `2.0.6` successors were
   published and registry-verified. The immutable `2.0.7` workflow failed before
   package creation or npm publication. The `2.0.8`, `2.0.9`, `2.0.10`, `2.0.11`,
-  `2.1.0`, and `2.1.1` successors were published, and `2.2.0` was subsequently published, and `2.3.0` was subsequently published, and `2.4.0` was subsequently published, and `2.4.1` was subsequently published, and `2.5.0` was subsequently published, and `2.6.0` was subsequently published, and `2.6.1` was subsequently published, and `2.7.0` was subsequently published, and `2.7.1` was subsequently published, and `2.7.2` was subsequently published, and `2.7.3` was subsequently published, and `2.8.0` was subsequently published, so the next candidate identity is `2.9.0`. Extraction and
+  `2.1.0`, and `2.1.1` successors were published, and `2.2.0` was subsequently published, and `2.3.0` was subsequently published, and `2.4.0` was subsequently published, and `2.4.1` was subsequently published, and `2.5.0` was subsequently published, and `2.6.0` was subsequently published, and `2.6.1` was subsequently published, and `2.7.0` was subsequently published, and `2.7.1` was subsequently published, and `2.7.2` was subsequently published, and `2.7.3` was subsequently published, and `2.8.0` was subsequently published, and `2.9.0` was subsequently published, so the next candidate identity is `2.10.0`. Extraction and
   versioning do not authorize publication.
 
 ## Review Holds
@@ -38,11 +38,15 @@ artifact reaches no hosted authority.
 Local enrollment now uses the reviewed client-generated credential/retry
 contract, with a pre-request `PENDING` record in the local 0600-permission seat
 store, exact-tuple ambiguous retry, and verified activation. The contract now
-resolves to the audited registry `borgmcp-shared@0.7.1` with integrity
-`sha512-d4GE7ezGyoFN0uwA62gvRPUMfMdJ1kxhTunqU8dW3Qhy1n2SlNXZWr1Nthm6Goo0bAgvax8KEywyReodA6FyQA==`.
-The matching `borgmcp-server@0.8.0` release is published with integrity
-`sha512-OSnBBcdZOM88Dokr7WICcTmF19c+Nr0TOl7NXy8DSUeCpBttiKKx+KuFvGbaXAWikFkm0UUBUca5cLZAOWw4Xw==`
-and pins the same `borgmcp-shared@0.7.1` contract. Client `borgmcp@2.8.0` is published. The immutable `v2.0.7`
+resolves to the audited registry `borgmcp-shared@0.8.0` with integrity
+`sha512-0p/ZC03Y6G4N6bfBjMD5b+WcQXcLalhU/3QqGjSWYCFKa3q2/183O53w6Tu6y8h2DkhTw5prnamsOozmVpXZew==`.
+The coupled `borgmcp-server@0.9.0` release was published on 2026-08-02 for the
+client `borgmcp@2.10.0` line. Its annotated tag object
+`7021a2e1f551aa0c1716c9e3f29f7b8bc4b0ccb0` peels to protected-main commit
+`734051375d77013f8fd5b396af12feb53d5af96d`; the same-run artifact integrity is
+`sha512-lOxIPg3WcjSBte46iTM7SAFVN6Y0b2oizOKAJ9Q1EijBdOlmsh/cQlpUIaa8F2UJPaTDFsXy3M64gpGs6XgKzA==`
+in the `borgmcp-server-0.9.0-release` registry decision. Both releases pin the
+audited `borgmcp-shared@0.8.0` dependency above. Client `borgmcp@2.9.0` is published. The immutable `v2.0.7`
 attempt failed before publication and remains preserved. Publication of the next
-candidate remains gated by reviewed `v2.9.0` source, a fresh annotated tag, and
+candidate remains gated by reviewed `v2.10.0` source, a fresh annotated tag, and
 the exact-artifact and protected-publication gates.

package/docs/LOCAL_SERVER.md

@@ -140,6 +140,14 @@ create distinct bounded cubes. An ordinary enrolled client is denied before a
 create request is sent. Cloud-only capabilities fail explicitly rather than
 being redirected.
 
+## Agent Launch State
+
+Borg tools are inactive unless the agent session was launched with `borg`.
+For Claude Code and Codex, `BORG_DISABLE_LAUNCH_REMINDER` is a presence-based
+local opt-out for launch orientation messaging; setting it does not activate
+Borg tools or change server authorization. OpenCode has no launch-reminder
+surface.
+
 ## Updating Borg
 
 For an npm-global installation, use the whole-product command:
@@ -227,9 +235,10 @@ The default discovery endpoint is `https://127.0.0.1:7091`. Explicit `--host` va
 
 ## Release status
 
-This self-hosted path pins published `borgmcp-shared@0.7.1` and requires the
-matching published `borgmcp-server@0.8.0` for protocol v7 repository resolve,
-association, and cube deletion. The server owner-enrollment, repository resolve/association,
+This client candidate pins published `borgmcp-shared@0.8.0` and requires the
+matching coupled client/server release for protocol v7 repository resolve,
+association, and cube deletion. The already-published server 0.8.0 retains its
+immutable older shared dependency pin and is not that coupled artifact. The server owner-enrollment, repository resolve/association,
 cube-create, attach, restart, log, and SSE implementation must also pass the full
 process-level local dogfood gate. Until that gate opens the self-hosted path remains preview-only, and the client
 publish is deferred accordingly.

package/docs/RELEASING.md

@@ -178,8 +178,13 @@ Never move, replace, reuse, or rerun that tag or workflow. The annotated `v2.8.0
 `ad40e93ee9b1ff2801119c1c763ad526974ae2a6`. Workflow run `30639790368`, attempt 1,
 successfully published that exact source as `borgmcp@2.8.0`; the same-run artifact report records integrity
 `sha512-hKNyWwVg/8WJ/qcqaNjZVylMw2UzgFEhE7sAJmWy/BjNU4lEa6ox8N7SdbEt8hhKsySMxt+YTFbNFitRtf9u3g==`.
+Never move, replace, reuse, or rerun that tag or workflow. The annotated `v2.9.0` tag object
+`26df119da33e914f857f820e68df6e887afed949` peels to protected-main commit
+`895f12065c09ec5c0a35f770f26ec89f36f2feaa`. Workflow run `30695501563`, attempt 1,
+successfully published that exact source as `borgmcp@2.9.0`; the same-run artifact report records integrity
+`sha512-e10KK//zAP6xRDtUjCrLqzVyeX5zd/39JD4LksBhNVL0ZIGthu5ZLahPMrcCjGl6lZQHNTCo8Tez5c1jmThgGQ==`.
 Never move, replace, reuse, or rerun that tag or workflow. The next candidate
-uses the unused `v2.9.0` identity from a fresh reviewed protected-main commit
+uses the unused `v2.10.0` identity from a fresh reviewed protected-main commit
 and requires the complete release gate again.
 
 ## Release Prerequisites
@@ -191,12 +196,13 @@ Before creating the release tag, independently verify all of these conditions:
 - the extraction review confirms no private backend secrets, deployment
   configuration, customer data, local state, or duplicated shared contracts
   entered the public package;
-- the exact audited registry dependency `borgmcp-shared@0.7.1` remains locked to
+- the exact audited registry dependency `borgmcp-shared@0.8.0` remains locked to
   its canonical tarball and integrity
-  `sha512-d4GE7ezGyoFN0uwA62gvRPUMfMdJ1kxhTunqU8dW3Qhy1n2SlNXZWr1Nthm6Goo0bAgvax8KEywyReodA6FyQA==`;
-- the client and matching published `borgmcp-server@0.8.0`, integrity
-  `sha512-OSnBBcdZOM88Dokr7WICcTmF19c+Nr0TOl7NXy8DSUeCpBttiKKx+KuFvGbaXAWikFkm0UUBUca5cLZAOWw4Xw==`, which pins
-  `borgmcp-shared@0.7.1`, pass the complete local dogfood gate;
+  `sha512-0p/ZC03Y6G4N6bfBjMD5b+WcQXcLalhU/3QqGjSWYCFKa3q2/183O53w6Tu6y8h2DkhTw5prnamsOozmVpXZew==`;
+- the coupled client/server release is published only after the server artifact
+  is rebuilt against `borgmcp-shared@0.8.0` and both pass the complete local
+  dogfood gate; the already-published server 0.8.0 remains immutable at its
+  older immutable shared dependency pin;
 - the selected stable client version is unused and the exact release commit is
   on protected `main`;
 - the repository and protected npm environment settings pass an operator audit;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "borgmcp",
-  "version": "2.9.0",
+  "version": "2.10.0",
   "description": "Coordinate AI coding agents in shared cubes. Works with Claude Code, Codex, and OpenCode.",
   "type": "module",
   "main": "./dist/index.js",
@@ -71,7 +71,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.4",
-    "borgmcp-shared": "0.7.1",
+    "borgmcp-shared": "0.8.0",
     "chalk": "^5.3.0",
     "prompts": "^2.4.2",
     "which": "^4.0.0"

package/src/assimilate-cmd.ts

@@ -56,6 +56,17 @@ import {
   RepositoryAssociationOutcomeUnknownError,
   RepositoryAssociationResolutionError,
 } from './server-errors.js';
+import {
+  decodeAndVerifyInvitationArtifact,
+  InvitationArtifactCompatibilityError,
+  InvitationArtifactEndpointMismatchError,
+  InvitationArtifactFormatError,
+  InvitationArtifactLegacyError,
+  InvitationArtifactRecoveryError,
+  InvitationArtifactStorageError,
+  InvitationArtifactTransportError,
+  InvitationArtifactTrustError,
+} from './invitation-artifact.js';
 import type { SeatStatus } from './seat-probe.js';
 import type { ServerSessionOperation } from './config.js';
 import type { ExpectedBinding, FinalizeServerSeatOutcome, PersistedLocalSeat } from './cubes.js';
@@ -67,6 +78,7 @@ import type {
   AssociateRepositoryCubeResponse,
   CreateCubeRepository,
   CubeTemplate,
+  InvitationArtifact,
 } from 'borgmcp-shared/protocol';
 import {
   initializeRepositoryCube,
@@ -277,7 +289,11 @@ export interface AssimilateDeps {
   detectLocalServer: () => Promise<string | null>;
   connectServer: (
     apiUrl: string,
-    enrollment?: { invitation: string; confirmReplacement?: () => Promise<boolean> },
+    enrollment?: {
+      invitation: string;
+      artifact?: import('borgmcp-shared/protocol').InvitationArtifact;
+      confirmReplacement?: () => Promise<boolean>;
+    },
   ) => Promise<{
     token: string;
     trustIdentity: string;
@@ -291,6 +307,17 @@ export interface AssimilateDeps {
     trustIdentity: string;
     serverCapabilities?: readonly string[];
   } | null>;
+  /** Read-only pending-artifact peek used to validate an explicit host before
+   * the normal resume path performs trust/credential work. */
+  peekPendingServerEnrollment?: () => Promise<{ origin: string; invitation: string } | null>;
+  resumePendingServerEnrollment?: (
+    onPending?: () => void,
+  ) => Promise<{
+    token: string;
+    apiUrl?: string;
+    trustIdentity: string;
+    serverCapabilities?: readonly string[];
+  } | null>;
 
   resolveRepositoryCube: (
     apiUrl: string,
@@ -382,6 +409,11 @@ async function selectAssimilationAuthority(
 
   // Only a local self-hosted server authority exists. Non-TTY and --yes must
   // NOT infer an authority — fail closed with actionable guidance.
+  if (flags.enroll && deps.isTTY()) {
+    // The v2 enrollment artifact is itself the authority selector. Use the
+    // local origin only as a placeholder until the hidden artifact is decoded.
+    return { kind: 'server', apiUrl: DEFAULT_LOCAL_SERVER_ORIGIN };
+  }
   if (!deps.isTTY() || flags.yes) {
     if (deps.defaultAuthority) return deps.defaultAuthority;
     const command = mode === 'cube-init'
@@ -521,6 +553,38 @@ function reportServerFailure(
     );
     return 1;
   }
+  if (error instanceof InvitationArtifactCompatibilityError) {
+    deps.stderr(`${error.message}\n`);
+    return 1;
+  }
+  if (error instanceof InvitationArtifactLegacyError) {
+    deps.stderr(`${error.message}\n`);
+    return 1;
+  }
+  if (error instanceof InvitationArtifactFormatError) {
+    deps.stderr(`${error.message}\n`);
+    return 1;
+  }
+  if (error instanceof InvitationArtifactEndpointMismatchError) {
+    deps.stderr(`${error.message}\n`);
+    return 1;
+  }
+  if (error instanceof InvitationArtifactTransportError) {
+    deps.stderr(`${error.message}\n`);
+    return 1;
+  }
+  if (error instanceof InvitationArtifactStorageError) {
+    deps.stderr(`${error.message}\n`);
+    return 1;
+  }
+  if (error instanceof InvitationArtifactRecoveryError) {
+    deps.stderr(`${error.message}\n`);
+    return 1;
+  }
+  if (error instanceof InvitationArtifactTrustError) {
+    deps.stderr(`${error.message}\n`);
+    return 1;
+  }
   if (/HTTP 40[13]|auth(?:entication|orization)|credential.*(?:invalid|rejected)/i.test(message)) {
     deps.stderr(
       `The saved enrollment for ${apiUrl} was rejected. Re-run ` +
@@ -662,7 +726,117 @@ export async function runAssimilate(
     return 1;
   }
 
-  if (args.flags.server === undefined && deps.defaultAuthority === undefined) {
+  const artifactOnlyEnrollment = args.flags.enroll === true &&
+    args.flags.server === undefined && deps.defaultAuthority === undefined && deps.isTTY();
+  let preResumeAttempted = false;
+  let preResumedEnrollment: {
+    token: string;
+    trustIdentity: string;
+    serverCapabilities?: readonly string[];
+  } | null = null;
+
+  let prefetchedInvitation: string | undefined;
+  let prefetchedArtifact: InvitationArtifact | undefined;
+
+  // An explicit --host plus a new invitation must be rejected on the pure
+  // input path. Decode and compare the operator-presented artifact before any
+  // pending-enrollment lookup: the lookup enumerates the credential backend,
+  // so it must not precede this contradiction check. A matching artifact may
+  // then take the published pending-resume path until client#267 lands.
+  if (args.flags.enroll && args.flags.server !== undefined && deps.isTTY()) {
+    let preResumeOrigin: string;
+    try {
+      preResumeOrigin = normalizeServerEndpoint(args.flags.server);
+    } catch (error) {
+      deps.stderr(`${error instanceof Error ? error.message : String(error)}\n`);
+      return 1;
+    }
+
+    prefetchedInvitation = await deps.promptSecret('Enrollment invitation (single-use; hidden input):');
+    if (!prefetchedInvitation) {
+      deps.stderr('No enrollment invitation was entered. Ask the server operator for one, then retry.\n');
+      return 1;
+    }
+    try {
+      prefetchedArtifact = decodeAndVerifyInvitationArtifact(prefetchedInvitation);
+      if (prefetchedArtifact.endpoint !== preResumeOrigin) {
+        throw new InvitationArtifactEndpointMismatchError(
+          preResumeOrigin,
+          prefetchedArtifact.endpoint,
+        );
+      }
+    } catch (error) {
+      deps.stderr(`${error instanceof Error ? error.message : 'The enrollment invitation is invalid.'}\n`);
+      prefetchedInvitation = undefined;
+      prefetchedArtifact = undefined;
+      return 1;
+    }
+
+    let pendingForHost = false;
+    if (deps.peekPendingServerEnrollment !== undefined) {
+      let pending: { origin: string; invitation: string } | null = null;
+      try {
+        pending = await deps.peekPendingServerEnrollment();
+      } catch {
+        pending = null;
+      }
+      if (pending?.origin === preResumeOrigin) {
+        try {
+          const pendingArtifact = decodeAndVerifyInvitationArtifact(pending.invitation);
+          if (pendingArtifact.endpoint !== preResumeOrigin) {
+            throw new InvitationArtifactEndpointMismatchError(
+              preResumeOrigin,
+              pendingArtifact.endpoint,
+            );
+          }
+          pendingForHost = true;
+        } catch (error) {
+          deps.stderr(`${error instanceof Error ? error.message : 'The enrollment invitation is invalid.'}\n`);
+          return 1;
+        }
+      }
+    }
+
+    if (pendingForHost) {
+      try {
+        preResumeAttempted = true;
+        preResumedEnrollment = await deps.resumeServerEnrollment(preResumeOrigin, () => {
+          deps.stderr(
+            `Resuming the pending enrollment for \`${preResumeOrigin}\`; ` +
+            'do not enter another invitation unless the server certificate was reissued; ' +
+            'if it was, request a current invitation and rerun this command.\n',
+          );
+        });
+      } catch {
+        preResumeAttempted = false;
+      }
+    }
+  }
+  if (artifactOnlyEnrollment ||
+      preResumeAttempted && preResumedEnrollment === null) {
+    if (artifactOnlyEnrollment && deps.resumePendingServerEnrollment) {
+      preResumedEnrollment = await deps.resumePendingServerEnrollment(() => {
+        deps.stderr('Resuming the pending enrollment; no new invitation is required.\n');
+      });
+    }
+    if (artifactOnlyEnrollment && preResumedEnrollment) {
+      // The exact pending tuple was already redeemed or is being resumed.
+    } else {
+      prefetchedInvitation = await deps.promptSecret('Enrollment invitation (single-use; hidden input):');
+      if (!prefetchedInvitation) {
+        deps.stderr('No enrollment invitation was entered. Ask the server operator for one, then retry.\n');
+        return 1;
+      }
+      try {
+        prefetchedArtifact = decodeAndVerifyInvitationArtifact(prefetchedInvitation);
+      } catch (error) {
+        deps.stderr(`${error instanceof Error ? error.message : 'The enrollment invitation is invalid.'}\n`);
+        prefetchedInvitation = undefined;
+        return 1;
+      }
+    }
+  }
+  if (!artifactOnlyEnrollment && args.flags.server === undefined && deps.defaultAuthority === undefined) {
     const connectCommand = mode === 'cube-init'
       ? 'borg server cube init --host <host>'
       : 'borg assimilate --host <host>';
@@ -699,8 +873,9 @@ export async function runAssimilate(
   }
 
   // ----- Step 1: Select and authenticate the local server -----
-  const authority = await selectAssimilationAuthority(args.flags, deps, mode);
-  if (!authority) return 1;
+  const selectedAuthority = await selectAssimilationAuthority(args.flags, deps, mode);
+  if (!selectedAuthority) return 1;
+  let authority: AssimilationAuthority = selectedAuthority;
   if (localSeatReadError !== undefined) {
     return reportServerFailure(deps, authority.apiUrl, localSeatReadError, false, mode);
   }
@@ -723,33 +898,48 @@ export async function runAssimilate(
           );
           return 1;
         }
-        const resumed = await deps.resumeServerEnrollment(authority.apiUrl, () => {
-          deps.stderr(
-            `Resuming the pending enrollment for \`${authority.apiUrl}\`; ` +
-              'do not enter another invitation.\n',
-          );
-        });
+        let resumed = preResumedEnrollment;
+        if (!resumed && prefetchedArtifact === undefined && !preResumeAttempted && !artifactOnlyEnrollment) {
+          resumed = await deps.resumeServerEnrollment(authority.apiUrl, () => {
+            deps.stderr(
+              `Resuming the pending enrollment for \`${authority.apiUrl}\`; ` +
+              'do not enter another invitation unless the server certificate was reissued; ' +
+              'if it was, request a current invitation and rerun this command.\n',
+            );
+          });
+        }
         if (resumed) {
+          if ('apiUrl' in resumed && typeof resumed.apiUrl === 'string') {
+            authority = { kind: 'server', apiUrl: resumed.apiUrl };
+          }
           serverAuth = resumed;
         } else {
-          let invitation = await deps.promptSecret(
-            `Enrollment invitation for \`${authority.apiUrl}\` (single-use; hidden input):`,
+          let invitation = prefetchedInvitation ?? await deps.promptSecret(
+            artifactOnlyEnrollment
+              ? 'Enrollment invitation (single-use; hidden input):'
+              : `Enrollment invitation for \`${authority.apiUrl}\` (single-use; hidden input):`,
           );
           if (!invitation) {
-            deps.stderr(
-              `No enrollment invitation was entered for ${authority.apiUrl}. ` +
-                `Ask the server operator for one, then rerun ${localAssimilateCommand(authority.apiUrl, true, mode)}.\n`,
-            );
+            deps.stderr(artifactOnlyEnrollment
+              ? 'No enrollment invitation was entered. Ask the server operator for one, then rerun `borg assimilate --enroll`.\n'
+              : `No enrollment invitation was entered for ${authority.apiUrl}. ` +
+                `Ask the server operator for one, then rerun ${localAssimilateCommand(authority.apiUrl, true, mode)}.\n`);
             return 1;
           }
-           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]: ',
-               )),
-             });
+          try {
+            const artifact = prefetchedArtifact ?? decodeAndVerifyInvitationArtifact(invitation);
+            if (args.flags.server !== undefined && authority.apiUrl !== artifact.endpoint) {
+              throw new InvitationArtifactEndpointMismatchError(authority.apiUrl, artifact.endpoint);
+            }
+            authority = { kind: 'server', apiUrl: artifact.endpoint };
+            serverAuth = await deps.connectServer(authority.apiUrl, {
+              invitation,
+              artifact,
+              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
@@ -777,6 +967,11 @@ export async function runAssimilate(
         serverTrustIdentity: serverAuth.trustIdentity,
         serverCapabilities: serverAuth.serverCapabilities ?? [],
       };
+      if (args.flags.enroll) {
+        deps.stderr(
+          `This machine (${deps.getHostname()}) is enrolled with Borg server \`${authority.apiUrl}\`.\n`,
+        );
+      }
     } catch (error) {
       return reportServerFailure(deps, authority.apiUrl, error, args.flags.enroll === true, mode);
     }

package/src/assimilate-deps.ts

@@ -34,6 +34,7 @@ import {
   connectLocalBorgServer,
   createLocalBorgServerCube,
   enrollLocalBorgServer,
+  enrollLocalBorgServerArtifact,
   probeLocalBorgServer,
   resolveLocalBorgServerRepositoryCube,
   resumeLocalBorgServerEnrollment,
@@ -62,6 +63,7 @@ import {
   setCodexWakeTarget,
 } from './cubes.js';
 import { addProjectSessionStartHook } from './config-utils.js';
+import { findPendingServerEnrollment } from './config.js';
 import { setTerminalTitle as setTitle } from './terminal-title.js';
 import { defaultCliChoiceDeps, resolveCliChoice } from './cli-platform.js';
 import { prepareCodexRemoteLaunch, defaultCodexRemoteDeps } from './codex-remote.js';
@@ -240,6 +242,15 @@ export function buildDefaultAssimilateDeps(
         : null,
     connectServer: async (apiUrl, enrollment) => {
       if (enrollment) {
+        if (enrollment.artifact) {
+          return enrollLocalBorgServerArtifact(enrollment.artifact, {
+            invitation: enrollment.invitation,
+            ...(enrollment.confirmReplacement === undefined
+              ? {}
+              : { confirmReplacement: enrollment.confirmReplacement }),
+            clientName: osHostname(),
+          });
+        }
         return enrollLocalBorgServer(apiUrl, enrollment.invitation, {
           ...(enrollment.confirmReplacement === undefined
             ? {}
@@ -253,6 +264,21 @@ export function buildDefaultAssimilateDeps(
       resumeLocalBorgServerEnrollment(apiUrl, {
         ...(onPending === undefined ? {} : { onPending }),
       }),
+    peekPendingServerEnrollment: async () => {
+      const pending = await findPendingServerEnrollment();
+      return pending === null
+        ? null
+        : { origin: pending.origin, invitation: pending.invitation };
+    },
+    resumePendingServerEnrollment: async (onPending) =>
+      (async () => {
+        const pending = await findPendingServerEnrollment();
+        if (!pending) return null;
+        const result = await resumeLocalBorgServerEnrollment(pending.origin, {
+          ...(onPending === undefined ? {} : { onPending }),
+        });
+        return result ? { ...result, apiUrl: pending.origin } : null;
+      })(),
 
     resolveRepositoryCube: async (apiUrl, token, input, serverTrustIdentity) => {
       if (serverTrustIdentity === undefined) {

package/src/assimilate-welcome.ts

@@ -33,6 +33,7 @@ export function renderAssimilationWelcome(
     ``,
     `In the launched agent, run \`borg_whoami\` and \`borg_roster\` to verify the seat`,
     `and begin coordinating.`,
+    `Launch future sessions in this repository with \`borg\`.`,
     ...teammateLines,
     ``,
   ].join('\n');

package/src/claude.ts

@@ -43,6 +43,7 @@ import {
 } from './reset-local-seat-cmd.js';
 import { parseLaunchAllArgs } from './parse-launch-all-args.js';
 import { unknownSubcommand } from './unknown-subcommand.js';
+import { parseRecoverEnrollmentArgs, runRecoverEnrollment } from './recover-enrollment-cmd.js';
 import { runLaunchAll } from './launch-all-cmd.js';
 import { buildDefaultLaunchAllDeps } from './launch-all-deps.js';
 import { discoverDroneCandidates } from './launch-all-discovery.js';
@@ -173,6 +174,27 @@ async function main() {
     const code = await runResetLocalSeat(parsed.flags, buildDefaultResetLocalSeatDeps());
     process.exit(code);
   }
+  if (process.argv[2] === 'recover-enrollment') {
+    const parsed = parseRecoverEnrollmentArgs(process.argv.slice(3));
+    if (!parsed.ok) {
+      if (parsed.error === 'help') {
+        process.stdout.write(clientSubcommandHelpText('recover-enrollment', [], getPackageVersion()) ?? '');
+        process.exit(0);
+      }
+      process.stderr.write(chalk.red(`${consolePrefix()}◼ borg recover-enrollment: ${parsed.error}\n`));
+      process.exit(1);
+    }
+    const prompt = async (message: string): Promise<string> => {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      try { return await rl.question(message); } finally { rl.close(); }
+    };
+    const code = await runRecoverEnrollment(parsed.flags, {
+      prompt,
+      stderr: (line) => process.stderr.write(line),
+      stdout: (line) => process.stdout.write(line),
+    });
+    process.exit(code);
+  }
   if (process.argv[2] === 'spawn') {
     // Deprecated; the stub prints a redirect message and exits 2.
     const code = await runSpawn();

package/src/cli-help.ts

@@ -64,6 +64,7 @@ export function clientSubcommandHelpText(
     case 'setup': return setupHelpText(version);
     case 'assimilate': return assimilateHelpText(version);
     case 'reset-local-seat': return resetLocalSeatHelpText(version);
+    case 'recover-enrollment': return recoverEnrollmentHelpText(version);
     case 'sync': return syncHelpText(version);
     case 'cleanup': return cleanupHelpText(version);
     case 'launch-all': return launchAllHelpText(version);
@@ -101,6 +102,7 @@ export function topLevelHelpText(version: string): string {
     `  borg assimilate --worktree <name>   Spawn a worktree drone (in ~/.borg/worktrees/<repo>/<name>)\n` +
     `  borg server cube init    Initialize this repository's cube without creating a drone\n` +
     `  borg reset-local-seat    Clear ONLY this worktree's saved local seat (offline; after a rejection)\n` +
+    `  borg recover-enrollment  Clear ONLY one failed server enrollment transaction\n` +
     `  borg sync [--prune]      Sync this worktree's branch to origin/main\n` +
     `  borg cleanup [--prune]   Report (or --prune) worktrees orphaned by evicted drones\n` +
     `  borg launch-all [cube]   Launch all drone worktrees of a cube (default: active cube)\n` +
@@ -113,6 +115,17 @@ export function topLevelHelpText(version: string): string {
   );
 }
 
+export function recoverEnrollmentHelpText(version: string): string {
+  return (
+    `borg recover-enrollment (borgmcp ${version}) — clear one failed server enrollment\n\n` +
+    `Usage:\n` +
+    `  borg recover-enrollment [--host <host>] [--yes]\n` +
+    `  borg recover-enrollment --help\n\n` +
+    `This operation clears only the failed enrollment transaction for one server.\n` +
+    `It does not touch other server enrollments or accounts. It never requires manual file editing.\n`
+  );
+}
+
 /** Help for the whole-product, npm-owned update journey. */
 export function updateHelpText(version: string): string {
   return (
@@ -143,6 +156,7 @@ export function serverHelpText(): string {
     `  status   Report verified runtime evidence.\n` +
     `  update   Verify and activate a local server artifact.\n` +
     `  invite   Create a single-use invitation in an interactive terminal.\n` +
+    `  cert-reissue  Widen the server certificate to cover another address without replacing the CA.\n` +
     `  dashboard   View the running local server dashboard.\n` +
     `  cube init   Initialize this Git repository's cube; does not create a drone.\n\n` +
     `Run borg server <command> --help for server command options.\n`