borgmcp 2.9.0 → 2.10.2

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, and `2.10.0` was subsequently published, and the immutable `2.10.1` release attempt failed before artifact creation or publication, so the next candidate identity is `2.10.2`. 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.10.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.2` 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,25 @@ 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 next candidate
-uses the unused `v2.9.0` identity from a fresh reviewed protected-main commit
+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 annotated `v2.10.0` tag object
+`83bd13fe9943c980760db6ecdbcef0d8c413cee0` peels to protected-main commit
+`c5d3d2cbe85644d402dfd82ce108dceca3a913a1`. Workflow run `30764262636`, attempt 1,
+successfully published that exact source as `borgmcp@2.10.0`; the same-run artifact report records integrity
+`sha512-YUVxWevAToQYwu/MDV2r9TrKnaZxpYiEitmLtr7OekfyE0+XZnkyHmL1gSk04JAiYquzv6ZyTRDYMnjQzS5GxA==`.
+Never move, replace, reuse, or rerun that tag or workflow. FAILED-SUPERSEDED release record: The annotated `v2.10.1` tag object
+`afee30802629d0f838b2446efd2241ff01964af2` peels to protected-main commit
+`fcecd75211107994ccd0df0bf4093240f83de9b2`. Workflow run `30766475027`, attempt 1, concluded `failure`
+during verification before artifact creation or publication. Verify job `91545993819` records the release
+artifact build, verification, exercise, and upload steps as skipped; publish job `91546125556` was skipped.
+Registry verification found no published `borgmcp@2.10.1` package, so no published npm artifact or SRI
+exists for that version as of this check.
+Never delete, move, replace, reuse, or rerun that tag, version, or workflow. The next candidate
+uses the unused `v2.10.2` identity from a fresh reviewed protected-main commit
 and requires the complete release gate again.
 
 ## Release Prerequisites
@@ -191,12 +208,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;
@@ -228,6 +246,28 @@ anything. It then deterministically updates only the manifest version, the two
 root lockfile version fields, the extraction ledger, this document's immutable
 release record, and the release-lane current-version/evidence assertions.
 
+When the superseded tag's attempt failed before artifact creation or publication,
+prepare the fresh recovery identity with `--workflow-conclusion failure` and omit
+`--artifact-integrity` entirely. The preparer verifies the annotated tag and exact
+failed workflow attempt, writes a canonical failed-superseded record stating that
+the artifact build, verification, exercise, upload, and publish phases were all
+skipped, and separately re-verifies the last published release as the artifact
+provenance anchor. It also reads the authoritative registry version list before
+writing the time-bounded fact that no published npm artifact or SRI exists for
+the failed version. This recovery-time absence check is required before preparing
+the replacement identity; it is not the prohibited post-publication readback of
+the newly published release. A failed record carrying an SRI, a failed run whose
+artifact or publish phase ran, a failed version present in the registry, or a
+successful record without an SRI is invalid. Failed tags and workflow attempts
+stay immutable and must never be moved, reused, or rerun.
+
+```sh
+npm run release:prepare -- 2.10.2 \
+  --workflow-run-id 30766475027 \
+  --workflow-run-attempt 1 \
+  --workflow-conclusion failure
+```
+
 Release branches use the `release/` prefix and enter protected `main` through a
 pull request. A direct push only updates the staging branch; it does
 not produce a release-identity verdict and grants no review skip, merge

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "borgmcp",
-  "version": "2.9.0",
+  "version": "2.10.2",
   "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'
@@ -429,12 +461,13 @@ async function selectAssimilationAuthority(
 }
 
 function localAssimilateCommand(
-  apiUrl: string,
+  apiUrl: string | undefined,
   enroll = false,
   mode: 'assimilate' | 'cube-init' = 'assimilate',
 ): string {
   const command = mode === 'cube-init' ? 'borg server cube init' : 'borg assimilate';
-  return `\`${command} --host ${apiUrl}${enroll ? ' --enroll' : ''}\``;
+  const host = apiUrl === undefined ? '' : ` --host ${apiUrl}`;
+  return `\`${command}${host}${enroll ? ' --enroll' : ''}\``;
 }
 
 function localAssimilateRoleCommand(apiUrl: string): string {
@@ -521,6 +554,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 +727,126 @@ export async function runAssimilate(
     return 1;
   }
 
-  if (args.flags.server === undefined && deps.defaultAuthority === undefined) {
+  const hostlessEnrollment = args.flags.enroll === true &&
+    args.flags.server === undefined && deps.defaultAuthority === undefined;
+  const artifactOnlyEnrollment = hostlessEnrollment && deps.isTTY();
+  let preResumeAttempted = false;
+  let preResumedEnrollment: {
+    token: string;
+    trustIdentity: string;
+    serverCapabilities?: readonly string[];
+  } | null = null;
+
+  let prefetchedInvitation: string | undefined;
+  let prefetchedArtifact: InvitationArtifact | undefined;
+
+  if (hostlessEnrollment && !deps.isTTY()) {
+    deps.stderr(
+      'Local enrollment requires an interactive operator terminal. ' +
+        `Re-run ${localAssimilateCommand(undefined, true, mode)} from the operator’s terminal.\n`,
+    );
+    return 1;
+  }
+
+  // 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 +883,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 +908,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 +977,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();