@forgezero/agent 0.1.62 → 0.1.64

package/dist/fz.js

@@ -4811,8 +4811,8 @@ async function spawnWith(command, env, report = () => {}, options = {}) {
 
 // src/cli/index.ts
 init_dist();
-import { existsSync as existsSync11, lstatSync as lstatSync9, mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync12 } from "fs";
-import { basename as basename3, dirname as dirname12, isAbsolute as isAbsolute5, resolve as resolve9 } from "path";
+import { existsSync as existsSync12, lstatSync as lstatSync10, mkdirSync as mkdirSync13, readFileSync as readFileSync15, writeFileSync as writeFileSync13 } from "fs";
+import { basename as basename3, dirname as dirname14, isAbsolute as isAbsolute7, join as join12, resolve as resolve11 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { hostname } from "os";
 
@@ -4829,7 +4829,7 @@ var UPDATE_RETRY_BASE_MS = 5 * 60000;
 var UPDATE_RETRY_MAX_MS = 24 * 60 * 60000;
 
 // src/version.ts
-var VERSION2 = "0.1.62";
+var VERSION2 = "0.1.64";
 
 // src/software.ts
 var PINNED_BUN_VERSION = "1.3.14";
@@ -4845,7 +4845,8 @@ var SOFTWARE_CATALOG = [
   { id: "cloudflared", version: "2026.7.3", status: "active", os: "ubuntu", osVersion: "26.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" },
   { id: "cloudflare-warp", version: "2026.6.822.0-min", status: "active", os: "ubuntu", osVersion: "26.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" },
   { id: "ufw", version: "ubuntu-26.04", status: "active", os: "ubuntu", osVersion: "26.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" },
-  { id: "openssh-client", version: "ubuntu-26.04", status: "active", os: "ubuntu", osVersion: "26.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" }
+  { id: "openssh-client", version: "ubuntu-26.04", status: "active", os: "ubuntu", osVersion: "26.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" },
+  { id: "git", version: "ubuntu-26.04", status: "active", os: "ubuntu", osVersion: "26.04", architecture: "x64", evidence: "reviewed-strategy-and-tests" }
 ];
 var DOCKER_DAEMON_CONFIG = `${JSON.stringify({
   "data-root": "/var/lib/docker",
@@ -4866,7 +4867,7 @@ function validateSoftwareRequirements(value, _options = {}) {
     if (Object.keys(row).some((key) => key !== "id" && key !== "version")) {
       throw new Error("software requirement contains an unknown field");
     }
-    if (!["bun", "docker", "nginx", "arangodb", "cloudflared", "cloudflare-warp", "ufw", "openssh-client"].includes(String(row.id)) || typeof row.version !== "string" || !/^[A-Za-z0-9][A-Za-z0-9.-]{0,31}$/.test(row.version)) {
+    if (!["bun", "docker", "nginx", "arangodb", "cloudflared", "cloudflare-warp", "ufw", "openssh-client", "git"].includes(String(row.id)) || typeof row.version !== "string" || !/^[A-Za-z0-9][A-Za-z0-9.-]{0,31}$/.test(row.version)) {
       throw new Error("software requirement coordinate is invalid");
     }
     const requirement = { id: row.id, version: row.version };
@@ -5427,7 +5428,11 @@ function agentEgressUnit(options) {
   const user = options.user ?? "forgezero";
   if (!/^[a-z_][a-z0-9_-]{0,30}$/.test(user))
     throw new Error("invalid Agent service user");
-  const deploymentEnabled = Boolean(options.repository || options.pullDeployments);
+  const bootstrapBundleEnabled = Boolean(options.bootstrapBundlePath && options.bootstrapBundleManifestPath);
+  if (Boolean(options.bootstrapBundlePath) !== Boolean(options.bootstrapBundleManifestPath) || bootstrapBundleEnabled && ![options.bootstrapBundlePath, options.bootstrapBundleManifestPath].every((path) => path.startsWith("/") && !/[\r\n\0:]/.test(path))) {
+    throw new Error("bootstrap bundle and manifest must be supplied together as absolute paths");
+  }
+  const deploymentEnabled = Boolean(options.repository || bootstrapBundleEnabled || options.pullDeployments);
   const runnerLoopbackPorts = normalizeEgressTcpPorts(options.runnerLoopbackPorts ?? []);
   const runnerPublicTcpPorts = normalizeEgressTcpPorts(options.runnerPublicTcpPorts ?? DEFAULT_RUNNER_PUBLIC_TCP_PORTS);
   if (deploymentEnabled && runnerPublicTcpPorts.length < 1) {
@@ -5833,17 +5838,16 @@ function agentUnit(options) {
   if (Boolean(options.pullMigrations) !== Boolean(options.lifecycleProfilePath)) {
     throw new Error("migration pull and lifecycle profile must be supplied together");
   }
-  const bootstrapEnabled = Boolean(options.pullBootstrap && options.bootstrapSshCredentialPath && options.bootstrapSshPublicKeyPath && options.bootstrapTargetTelemetryEndpoint);
-  if ([
-    options.pullBootstrap,
-    options.bootstrapSshCredentialPath,
-    options.bootstrapSshPublicKeyPath,
-    options.bootstrapTargetTelemetryEndpoint
-  ].some(Boolean) && !bootstrapEnabled) {
-    throw new Error("bootstrap pull, SSH credential, public key and target telemetry endpoint must be supplied together");
+  const bootstrapIdentityEnabled = Boolean(options.bootstrapSshCredentialPath && options.bootstrapSshPublicKeyPath);
+  if (Boolean(options.bootstrapSshCredentialPath) !== Boolean(options.bootstrapSshPublicKeyPath)) {
+    throw new Error("bootstrap SSH credential and public key paths must be supplied together");
+  }
+  const bootstrapEnabled = Boolean(options.pullBootstrap);
+  if (bootstrapEnabled && (!bootstrapIdentityEnabled || !options.bootstrapTargetTelemetryEndpoint) || !bootstrapEnabled && options.bootstrapTargetTelemetryEndpoint) {
+    throw new Error("bootstrap pull, SSH identity and target telemetry endpoint must be supplied together");
   }
   const lifecycleHelperSocketPath = lifecycleEnabled ? systemdPath(options.lifecycleHelperSocketPath ?? LIFECYCLE_HELPER_SOCKET, "lifecycle helper socket") : undefined;
-  const bootstrapSshCredentialPath = bootstrapEnabled ? systemdPath(options.bootstrapSshCredentialPath, "bootstrap SSH credential") : undefined;
+  const bootstrapSshCredentialPath = bootstrapIdentityEnabled ? systemdPath(options.bootstrapSshCredentialPath, "bootstrap SSH credential") : undefined;
   const warpValues = [
     options.warpOrganization,
     options.warpClientIdCredentialPath,
@@ -5897,6 +5901,8 @@ function agentUnit(options) {
     options.gitPublicKeyPath ? `FZ_GIT_PUBLIC_KEY_FILE=${options.gitPublicKeyPath}` : null,
     options.repository ? `FZ_DEPLOY_REPO=${options.repository}` : null,
     options.branch ? `FZ_DEPLOY_BRANCH=${options.branch}` : null,
+    options.bootstrapBundlePath ? `FZ_BOOTSTRAP_BUNDLE=${options.bootstrapBundlePath}` : null,
+    options.bootstrapBundleManifestPath ? `FZ_BOOTSTRAP_BUNDLE_MANIFEST=${options.bootstrapBundleManifestPath}` : null,
     options.profile ? `FZ_DEPLOY_PROFILE=${options.profile}` : null,
     options.repository && options.branch ? `FZ_DEPLOY_KEY=${options.project ?? "platform"}:${options.environment ?? "production"}` : null,
     deploymentEnabled ? `FZ_DEPLOY_ROOT=${deployRoot}` : null,
@@ -6080,15 +6086,13 @@ function planProvision(options) {
   if (Boolean(options.pullMigrations) !== Boolean(options.lifecycleProfilePath)) {
     throw new Error("migration pull and lifecycle profile must be supplied together");
   }
-  const bootstrapEnabled = Boolean(options.pullBootstrap && options.bootstrapSshCredentialPath && options.bootstrapSshPublicKeyPath && options.bootstrapTargetTelemetryEndpoint);
-  if ([
-    options.pullBootstrap,
-    options.bootstrapSshCredentialPath,
-    options.bootstrapSshPublicKeyPath,
-    options.bootstrapSshSourcePath,
-    options.bootstrapTargetTelemetryEndpoint
-  ].some(Boolean) && !bootstrapEnabled) {
-    throw new Error("bootstrap pull, SSH credential, public key and target telemetry endpoint must be supplied together");
+  const bootstrapIdentityEnabled = Boolean(options.bootstrapSshCredentialPath && options.bootstrapSshPublicKeyPath);
+  if (Boolean(options.bootstrapSshCredentialPath) !== Boolean(options.bootstrapSshPublicKeyPath) || options.bootstrapSshSourcePath && !bootstrapIdentityEnabled) {
+    throw new Error("bootstrap SSH credential and public key paths must be supplied together");
+  }
+  const bootstrapEnabled = Boolean(options.pullBootstrap);
+  if (bootstrapEnabled && (!bootstrapIdentityEnabled || !options.bootstrapTargetTelemetryEndpoint) || !bootstrapEnabled && options.bootstrapTargetTelemetryEndpoint) {
+    throw new Error("bootstrap pull, SSH identity and target telemetry endpoint must be supplied together");
   }
   const warpValues = [
     options.warpOrganization,
@@ -6098,13 +6102,13 @@ function planProvision(options) {
   const warpEnabled = warpValues.every(Boolean);
   if (warpValues.some(Boolean) && !warpEnabled)
     throw new Error("WARP configuration must be supplied together");
-  const enrolmentEnabled = Boolean(options.enrolTokenCredentialPath && options.enrolStatePath);
-  if (Boolean(options.enrolTokenCredentialPath) !== Boolean(options.enrolStatePath) || options.enrolTokenSourcePath && !enrolmentEnabled) {
-    throw new Error("direct enrolment credential and state paths must be supplied together");
+  const enrolmentEnabled = Boolean(options.enrolTokenCredentialPath);
+  if (options.enrolTokenCredentialPath && !options.enrolStatePath || options.enrolTokenSourcePath && (!options.enrolTokenCredentialPath || !options.enrolStatePath)) {
+    throw new Error("direct enrolment credential requires its durable state path");
   }
   const enrolTokenSourcePath = options.enrolTokenSourcePath ? systemdPath(options.enrolTokenSourcePath, "enrolment source") : undefined;
   const enrolTokenCredentialPath = enrolmentEnabled ? systemdPath(options.enrolTokenCredentialPath, "enrolment credential") : undefined;
-  const enrolStatePath = enrolmentEnabled ? systemdPath(options.enrolStatePath, "enrolment state") : undefined;
+  const enrolStatePath = options.enrolStatePath ? systemdPath(options.enrolStatePath, "enrolment state") : undefined;
   const enrolStateDir = enrolStatePath?.replace(/\/[^/]+$/, "");
   const sourceBinPath = options.sourceBinPath ? systemdPath(options.sourceBinPath, "agent source binary") : undefined;
   const binPath = options.binPath ? systemdPath(options.binPath, "agent binary") : undefined;
@@ -6116,8 +6120,8 @@ function planProvision(options) {
   const gitPublicKeyDir = gitPublicKeyPath?.replace(/\/[^/]+$/, "");
   const lifecycleProfilePath = lifecycleEnabled ? systemdPath(options.lifecycleProfilePath, "lifecycle profile") : undefined;
   const lifecycleHelperSocketPath = lifecycleEnabled ? systemdPath(options.lifecycleHelperSocketPath ?? LIFECYCLE_HELPER_SOCKET, "lifecycle helper socket") : undefined;
-  const bootstrapSshCredentialPath = bootstrapEnabled ? systemdPath(options.bootstrapSshCredentialPath, "bootstrap SSH credential") : undefined;
-  const bootstrapSshPublicKeyPath = bootstrapEnabled ? systemdPath(options.bootstrapSshPublicKeyPath, "bootstrap SSH public key") : undefined;
+  const bootstrapSshCredentialPath = bootstrapIdentityEnabled ? systemdPath(options.bootstrapSshCredentialPath, "bootstrap SSH credential") : undefined;
+  const bootstrapSshPublicKeyPath = bootstrapIdentityEnabled ? systemdPath(options.bootstrapSshPublicKeyPath, "bootstrap SSH public key") : undefined;
   const bootstrapSshSourcePath = options.bootstrapSshSourcePath ? systemdPath(options.bootstrapSshSourcePath, "bootstrap SSH private-key source") : undefined;
   const bootstrapSshPublicKeyDir = bootstrapSshPublicKeyPath?.replace(/\/[^/]+$/, "");
   const warpClientIdCredentialPath = warpEnabled ? systemdPath(options.warpClientIdCredentialPath, "WARP client-id credential") : undefined;
@@ -6217,7 +6221,7 @@ function planProvision(options) {
         step("Git deploy identity directory", { kind: "directories", directories: [{ path: gitPublicKeyDir, mode: 493, owner: "root", group: "root" }] }),
         step("unique encrypted Git deploy identity", { kind: "ensure-git-identity", credential: gitCredentialPath, publicKey: gitPublicKeyPath })
       ] : [],
-      ...bootstrapEnabled ? [
+      ...bootstrapIdentityEnabled ? [
         step("bootstrap SSH public identity directory", { kind: "directories", directories: [
           { path: bootstrapSshPublicKeyDir, mode: 493, owner: "root", group: "root" }
         ] }),
@@ -6253,6 +6257,10 @@ function planProvision(options) {
         { argv: ["/usr/bin/rm", "-f", "/etc/systemd/system/forgezero-deploy-runner.socket"] },
         { argv: ["/usr/bin/systemctl", "daemon-reload"] }
       ] })] : [],
+      ...enrolStatePath && !enrolmentEnabled ? [step("retire consumed enrolment unit", { kind: "commands", commands: [
+        { argv: ["/usr/bin/systemctl", "disable", "--now", "forgezero-agent-enrol.service"], acceptedExitCodes: [0, 1, 5] },
+        { argv: ["/usr/bin/rm", "-f", ENROLMENT_UNIT_PATH] }
+      ] })] : [],
       step("enable and converge services", { kind: "commands", commands: [
         { argv: ["/usr/bin/systemctl", "enable", ...enabledUnits] },
         { argv: ["/usr/bin/systemctl", "reset-failed", "forgezero-agent.service"], acceptedExitCodes: [0, 1] },
@@ -11555,18 +11563,18 @@ function removeSession(api, realm, path = defaultSessionPath()) {
 }
 
 // src/bootstrap.ts
-import { createHash as createHash3, createHmac as createHmac2, randomBytes as randomBytes6 } from "crypto";
+import { createHash as createHash4, createHmac as createHmac2, randomBytes as randomBytes7 } from "crypto";
 import {
-  chmodSync as chmodSync3,
-  existsSync as existsSync8,
-  lstatSync as lstatSync4,
-  mkdirSync as mkdirSync8,
-  readFileSync as readFileSync8,
-  renameSync as renameSync7,
-  rmSync as rmSync5,
-  writeFileSync as writeFileSync8
+  chmodSync as chmodSync4,
+  existsSync as existsSync9,
+  lstatSync as lstatSync5,
+  mkdirSync as mkdirSync9,
+  readFileSync as readFileSync9,
+  renameSync as renameSync8,
+  rmSync as rmSync6,
+  writeFileSync as writeFileSync9
 } from "fs";
-import { dirname as dirname8 } from "path";
+import { dirname as dirname9 } from "path";
 import { fileURLToPath } from "url";
 
 // src/platform-bootstrap-runtime.ts
@@ -11654,8 +11662,6 @@ function validatePlatformSharedEnvironment(input) {
     databaseUser: input.databaseUser,
     sharedDirectory: input.sharedDirectory,
     seedSyncEpoch: input.seedSyncEpoch,
-    repository: input.repository,
-    branch: input.branch,
     deployProfile: input.deployProfile
   }))
     safeAtom(name, value);
@@ -11738,8 +11744,6 @@ function renderPlatformSharedEnvironment(input) {
     FZ_AGENT_OTLP_ENDPOINT: value.agentOtlpEndpoint,
     FZ_CUSTODIAN_EMAIL: value.custodianEmail ?? "",
     FZ_PROFILE: value.deployProfile,
-    FZ_REPO: value.repository,
-    FZ_BRANCH: value.branch,
     FZ_EMAIL_PROVIDER: value.email?.provider ?? "",
     FZ_SMTP_HOST: value.email?.provider === "smtp" ? value.email.host : "",
     FZ_SMTP_PORT: value.email?.provider === "smtp" ? String(value.email.port) : "",
@@ -13158,6 +13162,164 @@ async function ensureForgeZeroOtelCollector(host, exportEndpoint) {
 
 // src/bootstrap.ts
 init_dist();
+
+// src/bootstrap-bundle.ts
+import { createHash as createHash3, randomBytes as randomBytes6 } from "crypto";
+import {
+  chmodSync as chmodSync3,
+  createReadStream,
+  existsSync as existsSync8,
+  lstatSync as lstatSync4,
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync8,
+  renameSync as renameSync7,
+  rmSync as rmSync5,
+  writeFileSync as writeFileSync8
+} from "fs";
+import { dirname as dirname8, isAbsolute as isAbsolute2, resolve as resolve6 } from "path";
+var BOOTSTRAP_BUNDLE_FORMAT = 1;
+var BOOTSTRAP_BUNDLE_KIND = "forgezero-api-git-bundle";
+var MAX_BOOTSTRAP_BUNDLE_BYTES = 512 * 1024 * 1024;
+var run = async (argv2) => {
+  const child = Bun.spawn([...argv2], { stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+    child.exited
+  ]);
+  return { exitCode, output: `${stdout}${stderr}`.slice(0, 65536) };
+};
+var checked2 = async (exec, argv2, label) => {
+  const result = await exec(argv2);
+  if (result.exitCode !== 0)
+    throw new Error(`${label} failed${result.output.trim() ? `: ${result.output.trim()}` : ""}`);
+  return result.output.trim();
+};
+async function sha256File(path) {
+  const hash = createHash3("sha256");
+  await new Promise((resolveDone, reject) => {
+    const stream = createReadStream(path);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", resolveDone);
+  });
+  return hash.digest("hex");
+}
+var branchName = (value) => {
+  if (typeof value !== "string" || !/^[A-Za-z0-9](?:[A-Za-z0-9._/-]{0,126}[A-Za-z0-9])?$/.test(value) || value.includes("..") || value.includes("//") || value.startsWith("-")) {
+    throw new Error("bootstrap bundle branch is malformed");
+  }
+  return value;
+};
+function parseBootstrapBundleManifest(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("bootstrap bundle manifest must be an object");
+  const source = value;
+  const allowed = ["format", "kind", "branch", "revision", "sha256", "bytes", "createdAt"];
+  const unknown = Object.keys(source).filter((key) => !allowed.includes(key));
+  if (unknown.length)
+    throw new Error(`bootstrap bundle manifest contains unknown field ${unknown[0]}`);
+  if (source.format !== BOOTSTRAP_BUNDLE_FORMAT || source.kind !== BOOTSTRAP_BUNDLE_KIND) {
+    throw new Error("bootstrap bundle manifest format is unsupported");
+  }
+  branchName(source.branch);
+  if (typeof source.revision !== "string" || !/^[a-f0-9]{40}$/.test(source.revision)) {
+    throw new Error("bootstrap bundle revision must be an exact lowercase Git commit");
+  }
+  if (typeof source.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(source.sha256)) {
+    throw new Error("bootstrap bundle digest is malformed");
+  }
+  if (!Number.isSafeInteger(source.bytes) || Number(source.bytes) < 1 || Number(source.bytes) > MAX_BOOTSTRAP_BUNDLE_BYTES) {
+    throw new Error("bootstrap bundle size is outside the supported boundary");
+  }
+  if (typeof source.createdAt !== "string" || Number.isNaN(Date.parse(source.createdAt))) {
+    throw new Error("bootstrap bundle creation time is malformed");
+  }
+  return source;
+}
+function ownerRegularFile(path, maximum, label) {
+  if (!isAbsolute2(path) || resolve6(path) !== path || /[\r\n\0]/.test(path)) {
+    throw new Error(`${label} path must be canonical and absolute`);
+  }
+  const value = lstatSync4(path);
+  const uid = process.getuid?.() ?? value.uid;
+  if (!value.isFile() || value.isSymbolicLink() || value.uid !== uid || value.nlink !== 1 || (value.mode & 63) !== 0 || value.size < 1 || value.size > maximum) {
+    throw new Error(`${label} must be an owner-only regular file with one link and at most ${maximum} bytes`);
+  }
+}
+async function readBootstrapBundle(bundlePath, manifestPath = `${bundlePath}.json`) {
+  ownerRegularFile(bundlePath, MAX_BOOTSTRAP_BUNDLE_BYTES, "bootstrap bundle");
+  ownerRegularFile(manifestPath, 16 * 1024, "bootstrap bundle manifest");
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync8(manifestPath, "utf8"));
+  } catch {
+    throw new Error("bootstrap bundle manifest is not valid JSON");
+  }
+  const manifest = parseBootstrapBundleManifest(parsed);
+  const size = lstatSync4(bundlePath).size;
+  if (size !== manifest.bytes || await sha256File(bundlePath) !== manifest.sha256) {
+    throw new Error("bootstrap bundle bytes do not match their manifest");
+  }
+  return { bundlePath, manifestPath, manifest };
+}
+async function buildBootstrapBundle(input, exec = run) {
+  const repositoryRoot = resolve6(input.repositoryRoot);
+  const outputPath = resolve6(input.outputPath);
+  const manifestPath = `${outputPath}.json`;
+  const branch = branchName(input.branch);
+  if (!isAbsolute2(input.outputPath) || outputPath !== input.outputPath) {
+    throw new Error("bootstrap bundle output must be a canonical absolute path");
+  }
+  if (existsSync8(outputPath) || existsSync8(manifestPath)) {
+    throw new Error("bootstrap bundle output already exists");
+  }
+  const root = lstatSync4(repositoryRoot);
+  if (!root.isDirectory() || root.isSymbolicLink())
+    throw new Error("bootstrap bundle source must be a real directory");
+  mkdirSync8(dirname8(outputPath), { recursive: true, mode: 448 });
+  const parent = lstatSync4(dirname8(outputPath));
+  const uid = process.getuid?.() ?? parent.uid;
+  if (!parent.isDirectory() || parent.isSymbolicLink() || parent.uid !== uid || (parent.mode & 63) !== 0) {
+    throw new Error("bootstrap bundle output directory must be caller-owned and owner-only");
+  }
+  const dirty = await checked2(exec, ["git", "-C", repositoryRoot, "status", "--porcelain=v1", "--untracked-files=no"], "Git worktree check");
+  if (dirty)
+    throw new Error("bootstrap bundle source has tracked changes; commit the reviewed API release first");
+  const revision = (await checked2(exec, ["git", "-C", repositoryRoot, "rev-parse", "--verify", `refs/heads/${branch}^{commit}`], "Git branch resolution")).toLowerCase();
+  if (!/^[a-f0-9]{40}$/.test(revision))
+    throw new Error("bootstrap bundle branch did not resolve to one exact commit");
+  const temporary = `${outputPath}.next.${process.pid}.${randomBytes6(6).toString("hex")}`;
+  try {
+    await checked2(exec, ["git", "-C", repositoryRoot, "bundle", "create", temporary, `refs/heads/${branch}`], "Git bundle creation");
+    chmodSync3(temporary, 384);
+    const file = lstatSync4(temporary);
+    if (!file.isFile() || file.isSymbolicLink() || file.size < 1 || file.size > MAX_BOOTSTRAP_BUNDLE_BYTES) {
+      throw new Error("created bootstrap bundle is outside the supported boundary");
+    }
+    await checked2(exec, ["git", "bundle", "verify", temporary], "Git bundle verification");
+    const manifest = {
+      format: BOOTSTRAP_BUNDLE_FORMAT,
+      kind: BOOTSTRAP_BUNDLE_KIND,
+      branch,
+      revision,
+      sha256: await sha256File(temporary),
+      bytes: file.size,
+      createdAt: new Date().toISOString()
+    };
+    const manifestTemporary = `${manifestPath}.next.${process.pid}.${randomBytes6(6).toString("hex")}`;
+    writeFileSync8(manifestTemporary, `${JSON.stringify(manifest, null, 2)}
+`, { mode: 384, flag: "wx" });
+    renameSync7(temporary, outputPath);
+    renameSync7(manifestTemporary, manifestPath);
+    return { bundlePath: outputPath, manifestPath, manifest };
+  } catch (cause) {
+    rmSync5(temporary, { force: true });
+    throw cause;
+  }
+}
+
+// src/bootstrap.ts
 var PLATFORM_BOOTSTRAP_PROFILES = [
   "platform-db-api",
   "platform-api"
@@ -13257,7 +13419,7 @@ var SEED_CREDENTIAL = `${CREDS}/seed-sync-root.cred`;
 var BACKUP_RECOVERY_CREDENTIAL = `${CREDS}/backup-recovery-root.cred`;
 var BOOTSTRAP_SSH_CREDENTIAL = `${CREDS}/bootstrap-ssh-key.cred`;
 var BOOTSTRAP_SSH_PUBLIC_KEY = "/etc/forgezero/bootstrap/runner.pub";
-var GIT_PUBLIC_KEY = "/etc/forgezero/git/deploy.pub";
+var BOOTSTRAP_RELEASE_EVIDENCE = "/var/lib/forgezero/bootstrap-release.json";
 var DB_MODE_EVIDENCE = "/var/lib/forgezero-cluster/server-mode.json";
 var LIFECYCLE_PROFILE = "/etc/forgezero/lifecycle.json";
 var CONTROL_SOCKET = "/run/forgezero/control.sock";
@@ -13330,6 +13492,9 @@ function validateBootstrapConfig(value) {
     throw new Error("Cloudflare Mesh/WARP requires a node-specific Cloudflare handoff");
   }
   if (value.kind === "enrolled-compute") {
+    if (value.gitDeployKey !== undefined && typeof value.gitDeployKey !== "boolean") {
+      throw new Error("gitDeployKey must be boolean");
+    }
     if (!/^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/.test(value.realm))
       throw new Error("tenant realm is malformed");
     if (!/^https:\/\//.test(value.apiUrl) && !/^http:\/\/(?:127\.0\.0\.1|localhost)(?::\d+)?$/.test(value.apiUrl)) {
@@ -13355,6 +13520,9 @@ function validateBootstrapConfig(value) {
     throw new Error("unsupported platform software profile");
   if (!["production", "development"].includes(value.environment))
     throw new Error("platform environment must be production or development");
+  if (!value.bootstrapBundle || ![value.bootstrapBundle.bundleFile, value.bootstrapBundle.manifestFile].every((path) => typeof path === "string" && path.startsWith("/") && !/[\r\n\0:]/.test(path))) {
+    throw new Error("platform bootstrap requires absolute bundle and manifest paths");
+  }
   let api;
   try {
     api = new URL(value.apiUrl);
@@ -13387,7 +13555,7 @@ function validateBootstrapConfig(value) {
   if (runtime.otlpCollectorUnit !== FORGEZERO_OTEL_COLLECTOR_UNIT) {
     throw new Error(`platform bootstrap requires ${FORGEZERO_OTEL_COLLECTOR_UNIT}`);
   }
-  if (runtime.softwareProfile !== value.profile || runtime.databaseRole !== value.database.role || runtime.nodeHostname !== value.nodeHostname || runtime.apiOrigin !== api.origin || runtime.repository !== value.repository || runtime.branch !== value.branch || runtime.databaseCoordinators.join(",") !== write.join(",")) {
+  if (runtime.softwareProfile !== value.profile || runtime.databaseRole !== value.database.role || runtime.nodeHostname !== value.nodeHostname || runtime.apiOrigin !== api.origin || runtime.databaseCoordinators.join(",") !== write.join(",")) {
     throw new Error("platform runtime coordinates disagree with immutable bootstrap coordinates");
   }
   if (runtime.deployProfile !== value.environment)
@@ -13417,6 +13585,7 @@ function planBootstrap(input, initialized = false) {
   ] : [
     ...config.firewall.enabled ? [{ id: "ufw", version: "ubuntu-26.04" }] : [],
     { id: "bun", version: "1.3.14" },
+    { id: "git", version: "ubuntu-26.04" },
     { id: "nginx", version: "ubuntu-26.04" },
     ...platformBootstrapRunner(config) ? [{ id: "openssh-client", version: "ubuntu-26.04" }] : [],
     ...config.profile === "platform-api" ? [] : [{ id: "arangodb", version: "3.11.14" }],
@@ -13445,7 +13614,7 @@ function planBootstrap(input, initialized = false) {
     ]
   };
 }
-var checked2 = async (host, argv2, label, options) => {
+var checked3 = async (host, argv2, label, options) => {
   const result = await host.exec(argv2, options);
   if (result.exitCode !== 0)
     throw new Error(`${label} failed: ${result.output.trim()}`);
@@ -13626,6 +13795,37 @@ async function seal(host, name, destination2, value) {
   if (result.exitCode !== 0)
     throw new Error(`could not seal ${name}: ${result.output.trim()}`);
 }
+async function verifyBootstrapBundleOnHost(host, config, verifyGit = false) {
+  const manifestMetadata = host.inspect?.(config.bootstrapBundle.manifestFile);
+  const bundleMetadata = host.inspect?.(config.bootstrapBundle.bundleFile);
+  if (manifestMetadata && (!manifestMetadata.regular || manifestMetadata.symbolic || manifestMetadata.uid !== 0 || manifestMetadata.links !== 1 || (manifestMetadata.mode & 63) !== 0 || manifestMetadata.size > 16 * 1024)) {
+    throw new Error("bootstrap bundle manifest must be a root-owned owner-only regular file");
+  }
+  if (bundleMetadata && (!bundleMetadata.regular || bundleMetadata.symbolic || bundleMetadata.uid !== 0 || bundleMetadata.links !== 1 || (bundleMetadata.mode & 63) !== 0 || bundleMetadata.size < 1 || bundleMetadata.size > 512 * 1024 * 1024)) {
+    throw new Error("bootstrap bundle must be a root-owned owner-only regular file within 512 MiB");
+  }
+  if (!host.exists(config.bootstrapBundle.bundleFile) || !host.exists(config.bootstrapBundle.manifestFile)) {
+    throw new Error("attended bootstrap bundle and manifest are required for release generation one");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(host.read(config.bootstrapBundle.manifestFile));
+  } catch {
+    throw new Error("bootstrap bundle manifest is not valid JSON");
+  }
+  const manifest = parseBootstrapBundleManifest(parsed);
+  const expectedBranch = config.environment === "production" ? "main" : "dev";
+  if (manifest.branch !== expectedBranch || bundleMetadata && bundleMetadata.size !== manifest.bytes) {
+    throw new Error("bootstrap bundle manifest disagrees with the selected platform environment");
+  }
+  const digest = (await checked3(host, ["/usr/bin/sha256sum", config.bootstrapBundle.bundleFile], "bootstrap bundle digest")).trim().split(/\s+/)[0];
+  if (digest !== manifest.sha256)
+    throw new Error("bootstrap bundle digest does not match its manifest");
+  if (verifyGit) {
+    await checked3(host, ["/usr/bin/git", "bundle", "verify", config.bootstrapBundle.bundleFile], "bootstrap Git bundle verification");
+  }
+  return manifest;
+}
 function bootstrapIdentity(config) {
   if (config.kind === "enrolled-compute")
     return {
@@ -13652,8 +13852,7 @@ function bootstrapIdentity(config) {
     computeReference: config.computeReference,
     nodeHostname: config.nodeHostname,
     apiUrl: config.apiUrl,
-    repository: config.repository,
-    branch: config.branch,
+    bootstrapBundle: config.bootstrapBundle,
     deployRoot: config.deployRoot ?? "/opt/forgezero",
     telemetryEndpoint: config.telemetryEndpoint,
     database: {
@@ -13683,7 +13882,7 @@ function bootstrapIdentity(config) {
   };
 }
 function bootstrapIdentityDigest(config) {
-  return createHash3("sha256").update(JSON.stringify(bootstrapIdentity(config))).digest("hex");
+  return createHash4("sha256").update(JSON.stringify(bootstrapIdentity(config))).digest("hex");
 }
 function parseStoredState(raw) {
   let value;
@@ -13733,34 +13932,6 @@ function bindBootstrapIntent(host, config) {
   }
   return identityDigest;
 }
-async function preparePlatformBootstrap(input, host = localBootstrapHost()) {
-  const config = validateBootstrapConfig(structuredClone(input));
-  if (config.kind !== "platform")
-    throw new Error("platform preparation requires a platform bootstrap config");
-  if (host.uid() !== 0)
-    throw new Error("fz bootstrap platform prepare --apply must run as root");
-  if (host.exists(STATE_PATH)) {
-    const installed = parseStoredState(host.read(STATE_PATH));
-    if (installed.kind !== "platform" || installed.identityDigest !== bootstrapIdentityDigest(config)) {
-      throw new Error("platform preparation coordinates do not match the installed host identity");
-    }
-  }
-  const identityDigest = bindBootstrapIntent(host, config);
-  await host.installAgent(config);
-  if (!host.exists(GIT_PUBLIC_KEY))
-    throw new Error("Agent installation did not produce its public Git deploy key");
-  const gitPublicKey = host.read(GIT_PUBLIC_KEY).trim();
-  if (!/^ssh-(?:ed25519|rsa) [A-Za-z0-9+/]+={0,3}(?: [^\r\n]+)?$/.test(gitPublicKey)) {
-    throw new Error("Agent public Git deploy key is malformed");
-  }
-  return {
-    kind: "platform",
-    prepared: true,
-    identityDigest,
-    gitPublicKey,
-    next: "register this read-only deploy key, then run --apply concurrently on all three genesis Agency members"
-  };
-}
 function stateFor(config, cloudflare, previousCloudflareTunnelId) {
   return `${JSON.stringify({
     format: 2,
@@ -13914,6 +14085,7 @@ async function applyBootstrap(input, host = localBootstrapHost(), secrets, depen
   let installed;
   if (host.exists(STATE_PATH))
     installed = parseStoredState(host.read(STATE_PATH));
+  const bootstrapManifest = config.kind === "platform" && !host.exists(BOOTSTRAP_RELEASE_EVIDENCE) ? await verifyBootstrapBundleOnHost(host, config) : undefined;
   let cloudflare;
   if (config.cloudflareHandoff) {
     if (host.exists(config.cloudflareHandoff.handoffFile)) {
@@ -13971,14 +14143,14 @@ async function applyBootstrap(input, host = localBootstrapHost(), secrets, depen
   const platformPrivate = config.kind === "platform" ? (() => {
     if (!secrets)
       throw new Error("platform apply requires attended credentials on stdin");
-    const checked3 = validatePlatformBootstrapSecrets(config, secrets);
+    const checked4 = validatePlatformBootstrapSecrets(config, secrets);
     return {
-      root: checked3.clusterBootstrapCode,
-      email: checked3.emailSecret,
-      enrolmentToken: checked3.enrolmentToken,
-      backup: checked3.backupS3Secret,
-      cloudflareTunnelToken: checked3.cloudflareTunnelToken,
-      cloudflareApiToken: checked3.cloudflareApiToken
+      root: checked4.clusterBootstrapCode,
+      email: checked4.emailSecret,
+      enrolmentToken: checked4.enrolmentToken,
+      backup: checked4.backupS3Secret,
+      cloudflareTunnelToken: checked4.cloudflareTunnelToken,
+      cloudflareApiToken: checked4.cloudflareApiToken
     };
   })() : undefined;
   const enrolledPrivate = config.kind === "enrolled-compute" ? validateEnrolledComputeBootstrapSecrets(config, secrets) : undefined;
@@ -14017,24 +14189,35 @@ async function applyBootstrap(input, host = localBootstrapHost(), secrets, depen
   if (connectorCapabilities?.meshConnectorToken && !host.exists(WARP_CONNECTOR_CREDENTIAL)) {
     await seal(host, "CF_WARP_CONNECTOR_TOKEN", WARP_CONNECTOR_CREDENTIAL, connectorCapabilities.meshConnectorToken);
   }
-  await host.installAgent(config);
+  if (alreadyEnrolled) {
+    await host.installAgent(config, "bound");
+  } else if (config.kind === "platform") {
+    if (bootstrapManifest)
+      await host.installAgent(config, "bootstrap");
+  } else {
+    await host.installAgent(config, "enrol");
+    await host.installAgent(config, "bound");
+  }
   if (config.kind === "platform" && config.firewall.enabled) {
     await host.ensureSoftware(plan.software.filter(({ id: id2 }) => id2 === "ufw"));
   } else
     await host.ensureSoftware(plan.software);
   if (config.kind === "platform" && config.firewall.enabled) {
-    await checked2(host, ["ufw", "--force", "default", "deny", "incoming"], "firewall inbound policy");
-    await checked2(host, ["ufw", "--force", "default", "allow", "outgoing"], "firewall outbound policy");
-    await checked2(host, ["ufw", "allow", `${config.firewall.sshPort}/tcp`], "firewall SSH rule");
+    await checked3(host, ["ufw", "--force", "default", "deny", "incoming"], "firewall inbound policy");
+    await checked3(host, ["ufw", "--force", "default", "allow", "outgoing"], "firewall outbound policy");
+    await checked3(host, ["ufw", "allow", `${config.firewall.sshPort}/tcp`], "firewall SSH rule");
     for (const cidr of config.firewall.privateCidrs) {
       if (config.database.role !== "none")
-        await checked2(host, ["ufw", "allow", "from", cidr, "to", "any", "port", "8528:8539", "proto", "tcp"], "database firewall rule");
+        await checked3(host, ["ufw", "allow", "from", cidr, "to", "any", "port", "8528:8539", "proto", "tcp"], "database firewall rule");
       for (const port of [config.runtime.bluePort, config.runtime.greenPort])
-        await checked2(host, ["ufw", "allow", "from", cidr, "to", "any", "port", String(port), "proto", "tcp"], "seed-mesh firewall rule");
+        await checked3(host, ["ufw", "allow", "from", cidr, "to", "any", "port", String(port), "proto", "tcp"], "seed-mesh firewall rule");
     }
-    await checked2(host, ["ufw", "--force", "enable"], "firewall activation");
+    await checked3(host, ["ufw", "--force", "enable"], "firewall activation");
     await host.ensureSoftware(plan.software.filter(({ id: id2 }) => id2 !== "ufw"));
   }
+  if (config.kind === "platform" && bootstrapManifest) {
+    await verifyBootstrapBundleOnHost(host, config, true);
+  }
   if (config.kind === "platform") {
     const root = platformPrivate.root;
     if (!host.exists(JWT_CREDENTIAL)) {
@@ -14089,8 +14272,8 @@ async function applyBootstrap(input, host = localBootstrapHost(), secrets, depen
       keepReleases: runtime.keepReleases,
       drainDeadlineMs: runtime.environment.drainDeadlineMs
     });
-    await checked2(host, ["useradd", "--system", "--no-create-home", "--shell", "/usr/sbin/nologin", runtime.serviceUser], "API service account").catch(async () => {
-      await checked2(host, ["id", runtime.serviceUser], "existing API service account");
+    await checked3(host, ["useradd", "--system", "--no-create-home", "--shell", "/usr/sbin/nologin", runtime.serviceUser], "API service account").catch(async () => {
+      await checked3(host, ["id", runtime.serviceUser], "existing API service account");
     });
     host.mkdir(runtime.environment.sharedDirectory, 488);
     host.mkdir(runtime.slotsDirectory, 493);
@@ -14099,7 +14282,7 @@ async function applyBootstrap(input, host = localBootstrapHost(), secrets, depen
       host.write("/etc/forgezero/capacity.env", `FZ_CONCURRENCY_LIMIT=${runtime.environment.concurrencyLimit}
 `, 420);
     }
-    await checked2(host, ["chown", `root:${runtime.serviceUser}`, runtime.environment.sharedDirectory, envPath], "runtime ownership");
+    await checked3(host, ["chown", `root:${runtime.serviceUser}`, runtime.environment.sharedDirectory, envPath], "runtime ownership");
     host.write("/etc/systemd/system/forgezero@.service", units.template, 420);
     host.write("/etc/systemd/system/forgezero@blue.service.d/port.conf", units.dropIns.blue, 420);
     host.write("/etc/systemd/system/forgezero@green.service.d/port.conf", units.dropIns.green, 420);
@@ -14108,30 +14291,30 @@ async function applyBootstrap(input, host = localBootstrapHost(), secrets, depen
     host.write("/etc/forgezero/deploy.env", activation.environment, 420);
     host.write("/etc/forgezero/deploy-activation.json", activation.helper, 384);
     host.write("/etc/sudoers.d/forgezero-runner", activation.sudoers, 288);
-    await checked2(host, ["visudo", "-cf", "/etc/sudoers.d/forgezero-runner"], "activation sudo policy");
+    await checked3(host, ["visudo", "-cf", "/etc/sudoers.d/forgezero-runner"], "activation sudo policy");
     const telemetry = planLocalOtlpProof(runtime.environment.otlpEndpoint, runtime.environment.otlpCollectorUnit);
-    await checked2(host, telemetry.unitCheck.argv, "OTLP collector supervision");
-    const otlpStatus = (await checked2(host, [telemetry.receiverCheck.command, ...telemetry.receiverCheck.argv], "OTLP receiver")).trim();
+    await checked3(host, telemetry.unitCheck.argv, "OTLP collector supervision");
+    const otlpStatus = (await checked3(host, [telemetry.receiverCheck.command, ...telemetry.receiverCheck.argv], "OTLP receiver")).trim();
     if (!/^2\d\d$/.test(otlpStatus))
       throw new Error(`OTLP receiver returned HTTP ${otlpStatus || "unknown"}`);
-    await checked2(host, ["nginx", "-t"], "nginx configuration");
-    await checked2(host, ["systemctl", "daemon-reload"], "systemd reload");
-    await checked2(host, ["systemctl", "enable", "--now", "nginx.service"], "nginx supervision");
+    await checked3(host, ["nginx", "-t"], "nginx configuration");
+    await checked3(host, ["systemctl", "daemon-reload"], "systemd reload");
+    await checked3(host, ["systemctl", "enable", "--now", "nginx.service"], "nginx supervision");
     if (config.database.role === "master") {
       const invite = `${runtime.environment.sharedDirectory}/platform-invite.token`;
       if (!host.exists(invite)) {
-        host.write(invite, `plt_${randomBytes6(24).toString("hex")}
+        host.write(invite, `plt_${randomBytes7(24).toString("hex")}
 `, 384);
-        await checked2(host, ["chown", `${runtime.serviceUser}:${runtime.serviceUser}`, invite], "platform invite ownership");
+        await checked3(host, ["chown", `${runtime.serviceUser}:${runtime.serviceUser}`, invite], "platform invite ownership");
       }
     }
     if (config.database.role !== "none") {
       host.mkdir("/var/lib/forgezero-cluster", 448);
-      await checked2(host, ["chown", "arangodb:arangodb", "/var/lib/forgezero-cluster"], "database state ownership");
+      await checked3(host, ["chown", "arangodb:arangodb", "/var/lib/forgezero-cluster"], "database state ownership");
       host.write("/etc/systemd/system/forgezero-db.service", databaseUnit(config), 420);
       host.write("/etc/systemd/system/forgezero-db-verify.service", databaseVerifyUnit(config), 420);
-      await checked2(host, ["systemctl", "daemon-reload"], "database unit reload");
-      await checked2(host, ["systemctl", "enable", "--now", "forgezero-db.service", "forgezero-db-verify.service"], "database supervision");
+      await checked3(host, ["systemctl", "daemon-reload"], "database unit reload");
+      await checked3(host, ["systemctl", "enable", "--now", "forgezero-db.service", "forgezero-db-verify.service"], "database supervision");
       const evidence = {
         expectedMode: "default",
         role: "COORDINATOR",
@@ -14142,15 +14325,42 @@ async function applyBootstrap(input, host = localBootstrapHost(), secrets, depen
       host.write(DB_MODE_EVIDENCE, `${JSON.stringify(evidence, null, 2)}
 `, 384);
     }
-    await checked2(host, [
-      "runuser",
-      "-u",
-      "forgezero-agent",
-      "--",
-      "/usr/local/bin/fz-agent",
-      "deploy",
-      ...config.database.role === "master" ? ["--release-executor"] : []
-    ], "initial Agent deployment");
+    if (bootstrapManifest) {
+      await checked3(host, [
+        "runuser",
+        "-u",
+        "forgezero-agent",
+        "--",
+        "/usr/local/bin/fz-agent",
+        "deploy",
+        `--revision=${bootstrapManifest.revision}`,
+        ...config.database.role === "master" ? ["--release-executor"] : []
+      ], "initial Agent deployment");
+      host.write(BOOTSTRAP_RELEASE_EVIDENCE, `${JSON.stringify({
+        format: 1,
+        kind: "forgezero-bootstrap-release",
+        revision: bootstrapManifest.revision,
+        sha256: bootstrapManifest.sha256,
+        branch: bootstrapManifest.branch,
+        deployedAt: new Date().toISOString()
+      }, null, 2)}
+`, 384);
+      host.remove(config.bootstrapBundle.bundleFile);
+      host.remove(config.bootstrapBundle.manifestFile);
+    }
+    if (!alreadyEnrolled) {
+      await checked3(host, [
+        "curl",
+        "--fail",
+        "--silent",
+        "--show-error",
+        "--max-time",
+        "10",
+        `http://127.0.0.1:3000${runtime.healthPath}`
+      ], "release-one API health");
+      await host.installAgent(config, "enrol");
+      await host.installAgent(config, "bound");
+    }
   }
   if (config.cloudflareHandoff) {
     if (!host.exists(TUNNEL_CREDENTIAL) && connectorCapabilities) {
@@ -14159,8 +14369,8 @@ async function applyBootstrap(input, host = localBootstrapHost(), secrets, depen
     if (!host.exists(TUNNEL_CREDENTIAL))
       throw new Error("sealed cloudflared connector credential is missing");
     host.write("/etc/systemd/system/cloudflared.service", tunnelUnit(), 420);
-    await checked2(host, ["systemctl", "daemon-reload"], "cloudflared unit reload");
-    await checked2(host, ["systemctl", "enable", "--now", "cloudflared.service"], "cloudflared connector supervision");
+    await checked3(host, ["systemctl", "daemon-reload"], "cloudflared unit reload");
+    await checked3(host, ["systemctl", "enable", "--now", "cloudflared.service"], "cloudflared connector supervision");
     const tunnelId = cloudflare?.tunnelId ?? installed?.cloudflareTunnelId ?? (config.kind === "platform" ? config.runtime.environment.cloudflare?.tunnelId : undefined);
     if (!tunnelId)
       throw new Error("Cloudflare tunnel identity is missing after handoff validation");
@@ -14170,8 +14380,8 @@ async function applyBootstrap(input, host = localBootstrapHost(), secrets, depen
     if (!host.exists(WARP_CONNECTOR_CREDENTIAL))
       throw new Error("sealed Cloudflare Mesh connector credential is missing");
     host.write("/etc/systemd/system/forgezero-mesh-config.service", meshConnectorUnit(), 420);
-    await checked2(host, ["systemctl", "daemon-reload"], "Cloudflare Mesh unit reload");
-    await checked2(host, ["systemctl", "enable", "--now", "warp-svc.service", "forgezero-mesh-config.service"], "Cloudflare Mesh connector supervision");
+    await checked3(host, ["systemctl", "daemon-reload"], "Cloudflare Mesh unit reload");
+    await checked3(host, ["systemctl", "enable", "--now", "warp-svc.service", "forgezero-mesh-config.service"], "Cloudflare Mesh connector supervision");
   }
   host.write(STATE_PATH, stateFor(config, cloudflare, installed?.cloudflareTunnelId), 384);
   const status = await bootstrapStatus(host);
@@ -14216,8 +14426,7 @@ function strictBootstrapDocument(value) {
     "computeReference",
     "nodeHostname",
     "apiUrl",
-    "repository",
-    "branch",
+    "bootstrapBundle",
     "deployRoot",
     "telemetryEndpoint",
     "database",
@@ -14230,9 +14439,11 @@ function strictBootstrapDocument(value) {
     "realm",
     "software",
     "deploymentCredentials",
+    "gitDeployKey",
     "bootstrapRunner"
   ], "bootstrap config");
   if (root.kind === "platform") {
+    exactKeys2(root.bootstrapBundle, ["bundleFile", "manifestFile"], "bootstrap bundle config");
     exactKeys2(root.firewall, ["enabled", "sshPort", "privateCidrs"], "firewall config");
     if (root.cloudflareHandoff !== undefined)
       exactKeys2(root.cloudflareHandoff, ["handoffFile", "nodeName"], "Cloudflare handoff");
@@ -14274,8 +14485,6 @@ function strictBootstrapDocument(value) {
       "agentOtlpEndpoint",
       "custodianEmail",
       "email",
-      "repository",
-      "branch",
       "deployProfile",
       "otlpFlushIntervalMs",
       "otlpTraceSampleRatio",
@@ -14313,11 +14522,70 @@ function strictBootstrapDocument(value) {
   return value;
 }
 function readBootstrapConfig(path) {
-  const metadata = lstatSync4(path);
+  const metadata = lstatSync5(path);
   if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.uid !== (process.getuid?.() ?? metadata.uid) || metadata.nlink !== 1 || (metadata.mode & 63) !== 0 || metadata.size > 64 * 1024) {
     throw new Error("bootstrap config must be an owner-only regular file with one link and at most 64 KiB");
   }
-  return validateBootstrapConfig(strictBootstrapDocument(JSON.parse(readFileSync8(path, "utf8"))));
+  return validateBootstrapConfig(strictBootstrapDocument(JSON.parse(readFileSync9(path, "utf8"))));
+}
+function planBootstrapAgentInstall(config, phase, context) {
+  const { capabilities, hasBinding, hasEnrolCredential, initialBundle } = context;
+  if (phase === "bootstrap") {
+    if (config.kind !== "platform" || hasBinding || !initialBundle) {
+      throw new Error("release-one Agent install requires an unbound platform host and verified bootstrap bundle");
+    }
+  } else if (phase === "enrol") {
+    if (hasBinding || !hasEnrolCredential) {
+      throw new Error("Agent enrolment requires one unbound host and its sealed one-use credential");
+    }
+  } else if (!hasBinding) {
+    throw new Error("bound Agent convergence requires durable enrolment state");
+  }
+  const bound = phase === "bound";
+  const enrolling = phase === "enrol";
+  const authenticated = enrolling || bound;
+  const bootstrapRunner = platformBootstrapRunner(config) || config.kind === "enrolled-compute" && Boolean(config.bootstrapRunner);
+  const options = {
+    capabilities,
+    socketPath: DEFAULT_SOCKET,
+    seedPath: "/var/lib/forgezero/node.seed",
+    controlSocketPath: CONTROL_SOCKET,
+    repository: phase === "bootstrap" ? initialBundle.path : bound && config.kind === "enrolled-compute" ? config.repository : undefined,
+    branch: phase === "bootstrap" ? initialBundle.manifest.branch : bound && config.kind === "enrolled-compute" ? config.branch : undefined,
+    bootstrapBundlePath: phase === "bootstrap" ? initialBundle.path : undefined,
+    bootstrapBundleManifestPath: phase === "bootstrap" ? initialBundle.manifestPath : undefined,
+    profile: config.profile,
+    deployRoot: config.deployRoot ?? "/opt/forgezero",
+    deploymentCredentials: config.deploymentCredentials,
+    publicApiUrl: config.apiUrl,
+    gitCredentialPath: authenticated && config.kind === "enrolled-compute" && config.gitDeployKey ? "/etc/forgezero/creds/git-deploy-key.cred" : undefined,
+    gitPublicKeyPath: authenticated && config.kind === "enrolled-compute" && config.gitDeployKey ? "/etc/forgezero/git/deploy.pub" : undefined,
+    generateGitIdentity: authenticated && config.kind === "enrolled-compute" && config.gitDeployKey === true,
+    pullDeployments: bound,
+    pullMigrations: bound && config.kind === "platform",
+    pullBootstrap: bound && bootstrapRunner,
+    bootstrapSshCredentialPath: authenticated && bootstrapRunner ? BOOTSTRAP_SSH_CREDENTIAL : undefined,
+    bootstrapSshSourcePath: enrolling && config.kind === "enrolled-compute" ? config.bootstrapRunner?.sshPrivateKeyFile : undefined,
+    bootstrapSshPublicKeyPath: authenticated && bootstrapRunner ? BOOTSTRAP_SSH_PUBLIC_KEY : undefined,
+    bootstrapTargetTelemetryEndpoint: bound && bootstrapRunner ? platformBootstrapRunner(config) ? config.telemetryEndpoint : config.kind === "enrolled-compute" ? config.bootstrapRunner?.targetTelemetryEndpoint : undefined : undefined,
+    lifecycleProfilePath: bound && config.kind === "platform" ? LIFECYCLE_PROFILE : undefined,
+    enforceEgress: true,
+    nodeHostname: config.nodeHostname,
+    telemetryEndpoint: config.telemetryEndpoint,
+    binPath: "/usr/local/lib/forgezero/agent/fz-agent",
+    sourceBinPath: PACKAGED_AGENT_BIN,
+    ...enrolling ? {
+      enrolTokenCredentialPath: ENROL_CREDENTIAL,
+      enrolStatePath: "/var/lib/forgezero/enrolment.json"
+    } : bound ? { enrolStatePath: "/var/lib/forgezero/enrolment.json" } : {},
+    ...authenticated ? {
+      apiUrl: config.apiUrl,
+      project: config.kind === "enrolled-compute" ? config.realm : "platform",
+      environment: config.kind === "enrolled-compute" ? undefined : config.environment,
+      nodeLabel: config.kind === "enrolled-compute" ? config.nodeHostname : config.computeReference
+    } : {}
+  };
+  return planInstall(options);
 }
 function localBootstrapHost() {
   const execute = async (argv2, options = {}) => {
@@ -14335,19 +14603,19 @@ function localBootstrapHost() {
   };
   return {
     uid: () => process.getuid?.() ?? -1,
-    exists: existsSync8,
-    read: (path) => readFileSync8(path, "utf8"),
+    exists: existsSync9,
+    read: (path) => readFileSync9(path, "utf8"),
     write(path, content, mode) {
-      mkdirSync8(dirname8(path), { recursive: true, mode: 493 });
+      mkdirSync9(dirname9(path), { recursive: true, mode: 493 });
       const temporary = `${path}.next.${process.pid}`;
-      writeFileSync8(temporary, content, { mode });
-      chmodSync3(temporary, mode);
-      renameSync7(temporary, path);
+      writeFileSync9(temporary, content, { mode });
+      chmodSync4(temporary, mode);
+      renameSync8(temporary, path);
     },
-    mkdir: (path, mode) => mkdirSync8(path, { recursive: true, mode }),
-    remove: (path) => rmSync5(path, { force: true }),
+    mkdir: (path, mode) => mkdirSync9(path, { recursive: true, mode }),
+    remove: (path) => rmSync6(path, { force: true }),
     inspect(path) {
-      const value = lstatSync4(path);
+      const value = lstatSync5(path);
       return { regular: value.isFile(), symbolic: value.isSymbolicLink(), uid: value.uid, mode: value.mode, links: value.nlink, size: value.size };
     },
     exec: execute,
@@ -14366,10 +14634,15 @@ function localBootstrapHost() {
         throw new Error(`Agent software requirements failed: ${result.output.trim()}`);
       return result;
     },
-    async installAgent(config) {
+    async installAgent(config, phase) {
       const capabilities = await readCapabilities(localRunner);
-      const deployRoot = config.deployRoot ?? "/opt/forgezero";
-      const hasBinding = config.kind === "enrolled-compute" || existsSync8(ENROL_CREDENTIAL) || existsSync8("/var/lib/forgezero/enrolment.json");
+      const hasBinding = existsSync9("/var/lib/forgezero/enrolment.json");
+      const hasEnrolCredential = existsSync9(ENROL_CREDENTIAL);
+      const initialBundle = config.kind === "platform" && !existsSync9(BOOTSTRAP_RELEASE_EVIDENCE) ? {
+        path: config.bootstrapBundle.bundleFile,
+        manifestPath: config.bootstrapBundle.manifestFile,
+        manifest: parseBootstrapBundleManifest(JSON.parse(readFileSync9(config.bootstrapBundle.manifestFile, "utf8")))
+      } : undefined;
       if (config.kind === "platform") {
         const lifecycle = config.database.role === "none" ? {
           apiUnits: ["forgezero@blue.service", "forgezero@green.service"],
@@ -14381,49 +14654,19 @@ function localBootstrapHost() {
           databaseHealthUrl: `http://${config.database.address}:8529/_api/version`,
           databasePorts: [8529]
         };
-        mkdirSync8(dirname8(LIFECYCLE_PROFILE), { recursive: true, mode: 493 });
-        writeFileSync8(LIFECYCLE_PROFILE, `${JSON.stringify(lifecycle, null, 2)}
+        mkdirSync9(dirname9(LIFECYCLE_PROFILE), { recursive: true, mode: 493 });
+        writeFileSync9(LIFECYCLE_PROFILE, `${JSON.stringify(lifecycle, null, 2)}
 `, { mode: 256 });
       }
-      const plan = planInstall({
+      const plan = planBootstrapAgentInstall(config, phase, {
         capabilities,
-        socketPath: DEFAULT_SOCKET,
-        seedPath: "/var/lib/forgezero/node.seed",
-        controlSocketPath: "/run/forgezero/control.sock",
-        repository: config.repository,
-        branch: config.branch,
-        profile: config.kind === "platform" ? config.profile : config.profile,
-        deployRoot,
-        deploymentCredentials: config.deploymentCredentials,
-        publicApiUrl: config.apiUrl,
-        gitCredentialPath: "/etc/forgezero/creds/git-deploy-key.cred",
-        gitPublicKeyPath: "/etc/forgezero/git/deploy.pub",
-        generateGitIdentity: true,
-        pullDeployments: hasBinding,
-        pullMigrations: config.kind === "platform" && hasBinding,
-        pullBootstrap: platformBootstrapRunner(config) || config.kind === "enrolled-compute" && Boolean(config.bootstrapRunner),
-        bootstrapSshCredentialPath: platformBootstrapRunner(config) || config.kind === "enrolled-compute" && config.bootstrapRunner ? BOOTSTRAP_SSH_CREDENTIAL : undefined,
-        bootstrapSshSourcePath: config.kind === "enrolled-compute" ? config.bootstrapRunner?.sshPrivateKeyFile : undefined,
-        bootstrapSshPublicKeyPath: platformBootstrapRunner(config) || config.kind === "enrolled-compute" && config.bootstrapRunner ? BOOTSTRAP_SSH_PUBLIC_KEY : undefined,
-        bootstrapTargetTelemetryEndpoint: platformBootstrapRunner(config) ? config.telemetryEndpoint : config.kind === "enrolled-compute" ? config.bootstrapRunner?.targetTelemetryEndpoint : undefined,
-        lifecycleProfilePath: config.kind === "platform" ? LIFECYCLE_PROFILE : undefined,
-        enforceEgress: true,
-        nodeHostname: config.nodeHostname,
-        telemetryEndpoint: config.telemetryEndpoint,
-        binPath: "/usr/local/lib/forgezero/agent/fz-agent",
-        sourceBinPath: PACKAGED_AGENT_BIN,
-        ...hasBinding ? {
-          enrolTokenCredentialPath: ENROL_CREDENTIAL,
-          enrolStatePath: "/var/lib/forgezero/enrolment.json",
-          apiUrl: config.apiUrl,
-          project: config.kind === "enrolled-compute" ? config.realm : "platform",
-          environment: config.kind === "enrolled-compute" ? undefined : config.environment,
-          nodeLabel: config.kind === "enrolled-compute" ? config.nodeHostname : config.computeReference
-        } : {}
+        hasBinding,
+        hasEnrolCredential,
+        initialBundle
       });
       for (const unit of [{ path: plan.unitPath, unit: plan.unit }, ...plan.auxiliaryUnits]) {
-        mkdirSync8(dirname8(unit.path), { recursive: true, mode: 493 });
-        writeFileSync8(unit.path, unit.unit, { mode: 420 });
+        mkdirSync9(dirname9(unit.path), { recursive: true, mode: 493 });
+        writeFileSync9(unit.path, unit.unit, { mode: 420 });
       }
       await applyPlan(plan, localRunner);
       return plan;
@@ -14432,8 +14675,8 @@ function localBootstrapHost() {
 }
 
 // src/cli/cloudflare-bootstrap.ts
-import { constants as constants2, closeSync, fstatSync, openSync, readFileSync as readFileSync9 } from "fs";
-import { dirname as dirname9, resolve as resolve6 } from "path";
+import { constants as constants2, closeSync, fstatSync, openSync, readFileSync as readFileSync10 } from "fs";
+import { dirname as dirname10, resolve as resolve7 } from "path";
 async function discoverCloudflareBootstrapCommandResources(input, dependencies = {}) {
   return (dependencies.discover ?? discoverCloudflareBootstrapResources)({
     zoneName: input.zoneName,
@@ -14464,7 +14707,7 @@ function createCloudflareBootstrapCommandConfig(input) {
   };
 }
 function readOwnerConfig(path) {
-  const absolute2 = resolve6(path);
+  const absolute2 = resolve7(path);
   let descriptor;
   try {
     descriptor = openSync(absolute2, constants2.O_RDONLY | constants2.O_NOFOLLOW);
@@ -14473,7 +14716,7 @@ function readOwnerConfig(path) {
     if (!metadata.isFile() || metadata.nlink !== 1 || metadata.size < 2 || metadata.size > 131072 || uid !== undefined && metadata.uid !== uid || (metadata.mode & 63) !== 0) {
       throw new Error(`${absolute2} must be one operator-owned 0600 regular file`);
     }
-    return JSON.parse(readFileSync9(descriptor, "utf8"));
+    return JSON.parse(readFileSync10(descriptor, "utf8"));
   } catch (cause) {
     if (cause instanceof SyntaxError)
       throw new Error(`${absolute2} is not valid Cloudflare bootstrap JSON`);
@@ -14487,7 +14730,7 @@ function readOwnerConfig(path) {
 }
 function readCloudflareBootstrapCommandConfig(path, mode) {
   const input = record2(readOwnerConfig(path), "Cloudflare bootstrap config");
-  const baseDirectory = dirname9(resolve6(path));
+  const baseDirectory = dirname10(resolve7(path));
   exactKeys3(input, ["format", "kind", "checkpointPath", "coordinates"], "Cloudflare bootstrap config");
   if (input.format !== 1 || input.kind !== "forgezero-cloudflare-bootstrap-request") {
     throw new Error("Cloudflare bootstrap config format/kind is invalid");
@@ -14527,7 +14770,7 @@ function readCloudflareBootstrapCommandConfig(path, mode) {
   return {
     mode,
     coordinates,
-    checkpointPath: resolve6(baseDirectory, input.checkpointPath)
+    checkpointPath: resolve7(baseDirectory, input.checkpointPath)
   };
 }
 async function runCloudflareBootstrapCommand(configPath, apply, tokens, dependencies = {}) {
@@ -14540,14 +14783,14 @@ async function runCloudflareBootstrapCommand(configPath, apply, tokens, dependen
   return evidence;
 }
 async function runCloudflareBootstrapVerificationCommand(checkpointPath, dependencies = {}) {
-  const evidence = await (dependencies.verify ?? verifyCloudflareBootstrapAcceptance)(resolve6(checkpointPath));
+  const evidence = await (dependencies.verify ?? verifyCloudflareBootstrapAcceptance)(resolve7(checkpointPath));
   (dependencies.write ?? ((text3) => process.stdout.write(text3)))(`${JSON.stringify(evidence, null, 2)}
 `);
   return evidence;
 }
 function readCloudflareBootstrapFinalizeConfig(path) {
   const input = record2(readOwnerConfig(path), "Cloudflare bootstrap finalize config");
-  const baseDirectory = dirname9(resolve6(path));
+  const baseDirectory = dirname10(resolve7(path));
   exactKeys3(input, ["format", "kind", "checkpointPath", "acceptancePath"], "Cloudflare bootstrap finalize config");
   if (input.format !== 1 || input.kind !== "forgezero-cloudflare-bootstrap-finalize") {
     throw new Error("Cloudflare bootstrap finalize config format/kind is invalid");
@@ -14558,8 +14801,8 @@ function readCloudflareBootstrapFinalizeConfig(path) {
     }
   }
   return {
-    checkpointPath: resolve6(baseDirectory, input.checkpointPath),
-    acceptancePath: resolve6(baseDirectory, input.acceptancePath)
+    checkpointPath: resolve7(baseDirectory, input.checkpointPath),
+    acceptancePath: resolve7(baseDirectory, input.acceptancePath)
   };
 }
 async function runCloudflareBootstrapFinalizeCommand(configPath, dependencies = {}) {
@@ -14571,31 +14814,31 @@ async function runCloudflareBootstrapFinalizeCommand(configPath, dependencies =
 }
 
 // src/metal-bootstrap.ts
-import { createHash as createHash4, randomBytes as randomBytes7 } from "crypto";
+import { createHash as createHash5, randomBytes as randomBytes8 } from "crypto";
 import {
-  chmodSync as chmodSync4,
+  chmodSync as chmodSync5,
   chownSync,
   copyFileSync as copyFileSync2,
-  existsSync as existsSync9,
-  lstatSync as lstatSync5,
-  mkdirSync as mkdirSync10,
-  readFileSync as readFileSync10,
+  existsSync as existsSync10,
+  lstatSync as lstatSync6,
+  mkdirSync as mkdirSync11,
+  readFileSync as readFileSync11,
   realpathSync as realpathSync4,
-  renameSync as renameSync8,
+  renameSync as renameSync9,
   statSync,
   symlinkSync as symlinkSync2,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync10
+  writeFileSync as writeFileSync11
 } from "fs";
-import { dirname as dirname11, isAbsolute as isAbsolute3, join as join9, resolve as resolve7 } from "path";
+import { dirname as dirname12, isAbsolute as isAbsolute4, join as join9, resolve as resolve8 } from "path";
 import { isIP as isIP5 } from "net";
 
 // src/metal-isolation.ts
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
 import { join as join8 } from "path";
 
 // src/metal-provision.ts
-import { dirname as dirname10, isAbsolute as isAbsolute2, join as join7 } from "path";
+import { dirname as dirname11, isAbsolute as isAbsolute3, join as join7 } from "path";
 import { isIP as isIP4 } from "net";
 
 // src/ubuntu.ts
@@ -14644,7 +14887,7 @@ function validateMetalProfile(profile) {
   if (!Number.isInteger(profile.addressStart) || !Number.isInteger(profile.addressEnd) || profile.addressStart < 2 || profile.addressEnd > 254 || profile.addressStart > profile.addressEnd)
     throw new MetalProvisionError("invalid guest address range");
   for (const path of [profile.stateDir, profile.seedDir, profile.unitDir]) {
-    if (!isAbsolute2(path))
+    if (!isAbsolute3(path))
       throw new MetalProvisionError("metal paths must be absolute");
   }
   new URL(profile.apiUrl);
@@ -14752,14 +14995,14 @@ var defaultExec = async (argv2) => {
   ]);
   return { exitCode, stdout, stderr };
 };
-var checked3 = async (exec, argv2) => {
+var checked4 = async (exec, argv2) => {
   const result = await exec(argv2);
   if (result.exitCode !== 0)
     throw new Error(`${argv2[0]} failed: ${(result.stderr || result.stdout).trim()}`);
   return result;
 };
 var requireGuestsInSlice = async (exec) => {
-  const active = await checked3(exec, [
+  const active = await checked4(exec, [
     "systemctl",
     "list-units",
     "--type=service",
@@ -14773,7 +15016,7 @@ var requireGuestsInSlice = async (exec) => {
     const service = line.trim().split(/\s+/)[0];
     if (!service)
       continue;
-    const cgroup = await checked3(exec, ["systemctl", "show", "-p", "ControlGroup", "--value", service]);
+    const cgroup = await checked4(exec, ["systemctl", "show", "-p", "ControlGroup", "--value", service]);
     if (!cgroup.stdout.trim().includes("/forgezero-guests.slice/")) {
       throw new Error(`${service} must be drained and restarted into forgezero-guests.slice`);
     }
@@ -14783,23 +15026,23 @@ async function applyMetalIsolation(profile, exec = defaultExec) {
   validateMetalProfile(profile);
   await requireGuestsInSlice(exec);
   const unitDir = profile.unitDir;
-  mkdirSync9(unitDir, { recursive: true });
-  writeFileSync9(join8(unitDir, "forgezero-guests.slice"), metalGuestSliceUnit(profile), { mode: 420 });
+  mkdirSync10(unitDir, { recursive: true });
+  writeFileSync10(join8(unitDir, "forgezero-guests.slice"), metalGuestSliceUnit(profile), { mode: 420 });
   for (const unit of ["system.slice", "user.slice"]) {
     const directory = join8(unitDir, `${unit}.d`);
-    mkdirSync9(directory, { recursive: true });
-    writeFileSync9(join8(directory, "50-forgezero-housekeeping.conf"), metalHousekeepingDropIn(profile, "slice"), { mode: 420 });
+    mkdirSync10(directory, { recursive: true });
+    writeFileSync10(join8(directory, "50-forgezero-housekeeping.conf"), metalHousekeepingDropIn(profile, "slice"), { mode: 420 });
   }
   const initDirectory = join8(unitDir, "init.scope.d");
-  mkdirSync9(initDirectory, { recursive: true });
-  writeFileSync9(join8(initDirectory, "50-forgezero-housekeeping.conf"), metalHousekeepingDropIn(profile, "scope"), { mode: 420 });
-  await checked3(exec, ["systemctl", "daemon-reload"]);
+  mkdirSync10(initDirectory, { recursive: true });
+  writeFileSync10(join8(initDirectory, "50-forgezero-housekeeping.conf"), metalHousekeepingDropIn(profile, "scope"), { mode: 420 });
+  await checked4(exec, ["systemctl", "daemon-reload"]);
   await requireGuestsInSlice(exec);
   const properties = [`AllowedCPUs=${profile.housekeepingCpus}`];
   if (profile.housekeepingMemoryNodes)
     properties.push(`AllowedMemoryNodes=${profile.housekeepingMemoryNodes}`);
   for (const unit of ["system.slice", "user.slice", "init.scope"]) {
-    await checked3(exec, ["systemctl", "set-property", "--runtime", unit, ...properties]);
+    await checked4(exec, ["systemctl", "set-property", "--runtime", unit, ...properties]);
   }
 }
 
@@ -14911,7 +15154,7 @@ function validateMetalBootstrapConfig(config) {
     throw new MetalBootstrapError("metal bootstrap uses fixed state, seed, and systemd unit directories");
   }
   const image = config.profile.images[Object.keys(config.profile.images)[0]];
-  if (!image.path.startsWith("/var/lib/forgezero/images/") || resolve7(image.path) !== image.path || /[\0\r\n]/.test(image.path)) {
+  if (!image.path.startsWith("/var/lib/forgezero/images/") || resolve8(image.path) !== image.path || /[\0\r\n]/.test(image.path)) {
     throw new MetalBootstrapError("the pinned guest image must use the fixed image directory");
   }
   if (config.profile.bunVersion !== SUPPORTED_BUN_VERSION || config.profile.bunReleaseSha256 !== SUPPORTED_BUN_RELEASE_SHA256 || config.profile.agentVersion !== VERSION2) {
@@ -14946,10 +15189,10 @@ function validateMetalBootstrapConfig(config) {
   return config;
 }
 function validateOwnerOnlyPath(path, requireRootOwner) {
-  if (!isAbsolute3(path) || resolve7(path) !== path || path.includes("/../")) {
+  if (!isAbsolute4(path) || resolve8(path) !== path || path.includes("/../")) {
     throw new MetalBootstrapError("private bootstrap paths must be canonical absolute paths");
   }
-  const metadata = lstatSync5(path);
+  const metadata = lstatSync6(path);
   if (!metadata.isFile() || metadata.isSymbolicLink() || realpathSync4(path) !== path) {
     throw new MetalBootstrapError("private bootstrap path must be a regular non-symlink file");
   }
@@ -14967,7 +15210,7 @@ function readMetalBootstrapConfig(path) {
     throw new MetalBootstrapError("metal bootstrap config size is invalid");
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync10(path, "utf8"));
+    parsed = JSON.parse(readFileSync11(path, "utf8"));
   } catch {
     throw new MetalBootstrapError("metal bootstrap config is not valid JSON");
   }
@@ -15000,15 +15243,15 @@ function planMetalBootstrap(config) {
   };
 }
 var atomicWrite2 = (path, body, mode) => {
-  mkdirSync10(dirname11(path), { recursive: true, mode: 493 });
+  mkdirSync11(dirname12(path), { recursive: true, mode: 493 });
   const temporary = `${path}.next-${process.pid}`;
-  writeFileSync10(temporary, body, { mode, flag: "wx" });
-  chmodSync4(temporary, mode);
+  writeFileSync11(temporary, body, { mode, flag: "wx" });
+  chmodSync5(temporary, mode);
   chownSync(temporary, 0, 0);
-  renameSync8(temporary, path);
+  renameSync9(temporary, path);
 };
 var validateAgentSourcePath = (source) => {
-  if (!isAbsolute3(source) || !lstatSync5(source).isFile() || lstatSync5(source).isSymbolicLink()) {
+  if (!isAbsolute4(source) || !lstatSync6(source).isFile() || lstatSync6(source).isSymbolicLink()) {
     throw new MetalBootstrapError("published Agent source path must be an absolute regular non-symlink file");
   }
 };
@@ -15172,11 +15415,11 @@ WantedBy=multi-user.target
 var installAgentBinary = (source, version) => {
   validateAgentSourcePath(source);
   const release = `/opt/forgezero/agent/versions/${version}/dist`;
-  mkdirSync10(release, { recursive: true, mode: 493 });
+  mkdirSync11(release, { recursive: true, mode: 493 });
   copyFileSync2(source, join9(release, "fz-agent.js"));
-  chmodSync4(join9(release, "fz-agent.js"), 493);
+  chmodSync5(join9(release, "fz-agent.js"), 493);
   chownSync(join9(release, "fz-agent.js"), 0, 0);
-  mkdirSync10("/opt/forgezero/agent", { recursive: true, mode: 493 });
+  mkdirSync11("/opt/forgezero/agent", { recursive: true, mode: 493 });
   for (const [link, target] of [
     ["/opt/forgezero/agent/current.next", `versions/${version}`],
     [AGENT_PATH, "/opt/forgezero/agent/current/dist/fz-agent.js"]
@@ -15186,7 +15429,7 @@ var installAgentBinary = (source, version) => {
     } catch {}
     symlinkSync2(target, link);
     if (link.endsWith("current.next"))
-      renameSync8(link, "/opt/forgezero/agent/current");
+      renameSync9(link, "/opt/forgezero/agent/current");
   }
 };
 var preflight = async (config, exec) => {
@@ -15208,10 +15451,10 @@ var preflight = async (config, exec) => {
   ]);
   await runChecked(exec, ["/usr/sbin/vgs", config.profile.volumeGroup]);
   await runChecked(exec, ["/usr/sbin/ip", "link", "show", config.profile.bridge]);
-  if (!existsSync9("/dev/kvm"))
+  if (!existsSync10("/dev/kvm"))
     throw new MetalBootstrapError("/dev/kvm is required");
   if (config.profile.confidential) {
-    if (!existsSync9("/dev/sev"))
+    if (!existsSync10("/dev/sev"))
       throw new MetalBootstrapError("/dev/sev is required by the confidential profile");
     await runChecked(exec, ["/usr/bin/qemu-system-x86_64", "-object", "sev-snp-guest,help"]);
   }
@@ -15223,16 +15466,16 @@ var assertSupportedMetalHost = () => {
   if (process.platform !== "linux" || process.arch !== "x64") {
     throw new MetalBootstrapError("metal bootstrap supports only Ubuntu 26.04 x86_64 hosts");
   }
-  const release = readFileSync10("/etc/os-release", "utf8");
+  const release = readFileSync11("/etc/os-release", "utf8");
   if (!/^ID=ubuntu$/m.test(release) || !/^VERSION_ID="?26\.04"?$/m.test(release)) {
     throw new MetalBootstrapError("metal bootstrap supports only Ubuntu 26.04 x86_64 hosts");
   }
 };
 var ensurePinnedGuestImage = async (config, exec) => {
   const image = config.profile.images[SUPPORTED_GUEST_IMAGE.key];
-  if (existsSync9(image.path))
+  if (existsSync10(image.path))
     return;
-  mkdirSync10(dirname11(image.path), { recursive: true, mode: 493 });
+  mkdirSync11(dirname12(image.path), { recursive: true, mode: 493 });
   const temporary = `${image.path}.next-${process.pid}`;
   try {
     await runChecked(exec, [
@@ -15249,9 +15492,9 @@ var ensurePinnedGuestImage = async (config, exec) => {
     const digest = (await runChecked(exec, ["/usr/bin/sha256sum", temporary])).stdout.split(/\s+/)[0];
     if (digest !== image.sha256)
       throw new MetalBootstrapError("downloaded guest image digest mismatch");
-    chmodSync4(temporary, 292);
+    chmodSync5(temporary, 292);
     chownSync(temporary, 0, 0);
-    renameSync8(temporary, image.path);
+    renameSync9(temporary, image.path);
   } catch (cause) {
     try {
       unlinkSync2(temporary);
@@ -15264,11 +15507,11 @@ async function applyMetalBootstrap(config, options) {
   if ((options.getuid ?? process.getuid)?.() !== 0)
     throw new MetalBootstrapError("fz bootstrap metal --apply must run as root");
   assertSupportedMetalHost();
-  if (existsSync9(STATE_PATH2) && !options.repair)
+  if (existsSync10(STATE_PATH2) && !options.repair)
     throw new MetalBootstrapError("metal host is already initialized; use explicit repair");
   if (config.agentSeedFile)
     validateOwnerOnlyPath(config.agentSeedFile, true);
-  if (config.agentSeedFile && existsSync9(SEED_CREDENTIAL_PATH)) {
+  if (config.agentSeedFile && existsSync10(SEED_CREDENTIAL_PATH)) {
     throw new MetalBootstrapError("repair refuses replacement seed material while the sealed metal identity exists");
   }
   validateAgentSourcePath(options.agentSourcePath);
@@ -15295,9 +15538,9 @@ async function applyMetalBootstrap(config, options) {
   await preflight(config, exec);
   await ensureAccount(exec);
   installAgentBinary(options.agentSourcePath, config.profile.agentVersion);
-  mkdirSync10("/etc/forgezero/creds", { recursive: true, mode: 448 });
-  mkdirSync10(config.profile.stateDir, { recursive: true, mode: 448 });
-  mkdirSync10(config.profile.seedDir, { recursive: true, mode: 448 });
+  mkdirSync11("/etc/forgezero/creds", { recursive: true, mode: 448 });
+  mkdirSync11(config.profile.stateDir, { recursive: true, mode: 448 });
+  mkdirSync11(config.profile.seedDir, { recursive: true, mode: 448 });
   const persistedProfile = {
     ...config.profile,
     metalHostname: config.metalHostname,
@@ -15306,13 +15549,13 @@ async function applyMetalBootstrap(config, options) {
   };
   atomicWrite2(PROFILE_PATH, `${JSON.stringify(persistedProfile, null, 2)}
 `, 384);
-  if (!existsSync9(SEED_CREDENTIAL_PATH)) {
-    const seed = config.agentSeedFile ? readFileSync10(config.agentSeedFile, "utf8").trim() : randomBytes7(32).toString("base64url");
+  if (!existsSync10(SEED_CREDENTIAL_PATH)) {
+    const seed = config.agentSeedFile ? readFileSync11(config.agentSeedFile, "utf8").trim() : randomBytes8(32).toString("base64url");
     if (seed.length < 32 || /[\0\r\n]/.test(seed))
       throw new MetalBootstrapError("metal Agent seed is invalid");
     await runChecked(exec, ["/usr/bin/systemd-creds", "encrypt", "--name=metal-agent-seed", "-", SEED_CREDENTIAL_PATH], `${seed}
 `);
-    chmodSync4(SEED_CREDENTIAL_PATH, 256);
+    chmodSync5(SEED_CREDENTIAL_PATH, 256);
     chownSync(SEED_CREDENTIAL_PATH, 0, 0);
     if (config.agentSeedFile)
       unlinkSync2(config.agentSeedFile);
@@ -15361,7 +15604,7 @@ async function applyMetalBootstrap(config, options) {
     initializedAt: new Date().toISOString(),
     role: "metal",
     metalHostname: config.metalHostname,
-    profileSha256: createHash4("sha256").update(JSON.stringify(config.profile)).digest("hex")
+    profileSha256: createHash5("sha256").update(JSON.stringify(config.profile)).digest("hex")
   };
   atomicWrite2(STATE_PATH2, `${JSON.stringify(state, null, 2)}
 `, 384);
@@ -15369,7 +15612,7 @@ async function applyMetalBootstrap(config, options) {
 }
 var socketReady = (path) => {
   try {
-    return lstatSync5(path).isSocket();
+    return lstatSync6(path).isSocket();
   } catch {
     return false;
   }
@@ -15378,17 +15621,17 @@ async function metalBootstrapStatus(exec = defaultExec2) {
   const problems = [];
   let profileValid = false, imageVerified = false, metalHostname, profileSha256;
   let profileMode = null;
-  if (existsSync9(PROFILE_PATH)) {
+  if (existsSync10(PROFILE_PATH)) {
     try {
       const metadata = statSync(PROFILE_PATH);
       profileMode = metadata.mode & 511;
       if (profileMode !== 384 || metadata.uid !== 0)
         problems.push("metal profile is not root-owned mode 0600");
-      const persisted = JSON.parse(readFileSync10(PROFILE_PATH, "utf8"));
+      const persisted = JSON.parse(readFileSync11(PROFILE_PATH, "utf8"));
       const { metalHostname: profileHostname, hostTelemetryEndpoint, hostTelemetryUnit, ...profile } = persisted;
       validateMetalProfile(profile);
       profileValid = true;
-      profileSha256 = createHash4("sha256").update(JSON.stringify(profile)).digest("hex");
+      profileSha256 = createHash5("sha256").update(JSON.stringify(profile)).digest("hex");
       if (!/^[A-Za-z0-9][A-Za-z0-9.-]{1,252}$/.test(profileHostname) || hostTelemetryEndpoint !== "http://127.0.0.1:4318") {
         problems.push("persisted metal host coordinates are invalid");
       }
@@ -15417,7 +15660,7 @@ async function metalBootstrapStatus(exec = defaultExec2) {
         problems.push("local OTLP metrics receiver did not accept a proof request");
       }
       const image = profile.images[Object.keys(profile.images)[0]];
-      if (existsSync9(image.path)) {
+      if (existsSync10(image.path)) {
         const digest = (await exec(["/usr/bin/sha256sum", image.path])).stdout.split(/\s+/)[0];
         imageVerified = digest === image.sha256;
       }
@@ -15428,9 +15671,9 @@ async function metalBootstrapStatus(exec = defaultExec2) {
     }
   } else
     problems.push("metal profile is missing");
-  if (existsSync9(STATE_PATH2)) {
+  if (existsSync10(STATE_PATH2)) {
     try {
-      const state = JSON.parse(readFileSync10(STATE_PATH2, "utf8"));
+      const state = JSON.parse(readFileSync11(STATE_PATH2, "utf8"));
       metalHostname = state.metalHostname;
       if (state.role !== "metal" || !metalHostname || state.profileSha256 !== profileSha256) {
         problems.push("metal initialized state does not bind the current profile");
@@ -15446,7 +15689,7 @@ async function metalBootstrapStatus(exec = defaultExec2) {
     "forgezero-metal-agent-egress.service",
     "forgezero-metal-agent.service"
   ]) {
-    if (!existsSync9(join9(UNIT_DIRECTORY, unit)))
+    if (!existsSync10(join9(UNIT_DIRECTORY, unit)))
       units[unit] = "missing";
     else
       units[unit] = (await exec(["/usr/bin/systemctl", "is-active", "--quiet", unit])).exitCode === 0 ? "active" : "inactive";
@@ -15460,7 +15703,7 @@ async function metalBootstrapStatus(exec = defaultExec2) {
   if (!updateSocketReady)
     problems.push("Agent update helper socket is not ready");
   return {
-    initialized: existsSync9(STATE_PATH2),
+    initialized: existsSync10(STATE_PATH2),
     profileValid,
     profileMode,
     imageVerified,
@@ -15473,11 +15716,11 @@ async function metalBootstrapStatus(exec = defaultExec2) {
 }
 
 // src/operator-bootstrap.ts
-import { createHash as createHash5, randomBytes as randomBytes8 } from "crypto";
-import { lstatSync as lstatSync6, mkdtempSync, readFileSync as readFileSync11, rmSync as rmSync6, writeFileSync as writeFileSync11 } from "fs";
+import { createHash as createHash6, randomBytes as randomBytes9 } from "crypto";
+import { chmodSync as chmodSync6, lstatSync as lstatSync7, mkdirSync as mkdirSync12, mkdtempSync, readFileSync as readFileSync12, rmSync as rmSync7, writeFileSync as writeFileSync12 } from "fs";
 import { isIP as isIP6 } from "net";
 import { tmpdir } from "os";
-import { basename as basename2, join as join10 } from "path";
+import { basename as basename2, dirname as dirname13, isAbsolute as isAbsolute5, join as join10, resolve as resolve9 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/platform-genesis.ts
@@ -15612,25 +15855,44 @@ var exactKeys5 = (value, keys, label) => {
     throw new Error(`${label} contains unknown fields: ${unknown.join(", ")}`);
   return record3;
 };
+var canonicalOutputPath = (path, label) => {
+  if (!isAbsolute5(path) || resolve9(path) !== path || /[\r\n\0]/.test(path)) {
+    throw new Error(`${label} must be a canonical absolute path`);
+  }
+  return path;
+};
+var writeOwnerJson2 = (path, value, label) => {
+  canonicalOutputPath(path, label);
+  mkdirSync12(dirname13(path), { recursive: true, mode: 448 });
+  const parent = lstatSync7(dirname13(path));
+  const uid = process.getuid?.() ?? parent.uid;
+  if (!parent.isDirectory() || parent.isSymbolicLink() || parent.uid !== uid || (parent.mode & 63) !== 0) {
+    throw new Error(`${label} parent must be an owner-only directory`);
+  }
+  writeFileSync12(path, `${JSON.stringify(value, null, 2)}
+`, { mode: 384, flag: "wx" });
+  chmodSync6(path, 384);
+  return path;
+};
 var ownerFile = (path, limit, label) => {
   if (!path.startsWith("/") || /[\r\n]/.test(path))
     throw new Error(`${label} path must be absolute`);
-  const metadata = lstatSync6(path);
+  const metadata = lstatSync7(path);
   const uid = process.getuid?.() ?? metadata.uid;
   if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.uid !== uid || metadata.nlink !== 1 || (metadata.mode & 63) !== 0 || metadata.size < 1 || metadata.size > limit) {
     throw new Error(`${label} must be an owner-only regular file with one link and at most ${limit} bytes`);
   }
-  return readFileSync11(path);
+  return readFileSync12(path);
 };
 var publicIdentity = (path) => {
   if (!path.startsWith("/") || /[\r\n]/.test(path))
     throw new Error("SSH public-key path must be absolute");
-  const metadata = lstatSync6(path);
+  const metadata = lstatSync7(path);
   const uid = process.getuid?.() ?? metadata.uid;
   if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.uid !== uid || metadata.nlink !== 1 || metadata.size > 16384) {
     throw new Error("SSH public key must be a caller-owned regular file with one link");
   }
-  const value = readFileSync11(path, "utf8").trim();
+  const value = readFileSync12(path, "utf8").trim();
   if (!/^ssh-(?:ed25519|rsa) [A-Za-z0-9+/]+={0,3}(?: [^\r\n]+)?$/.test(value)) {
     throw new Error("SSH public key is malformed");
   }
@@ -15639,7 +15901,7 @@ var publicIdentity = (path) => {
 var socketPath = (path) => {
   if (!path.startsWith("/") || /[\r\n]/.test(path))
     throw new Error("SSH agent socket path must be absolute");
-  const metadata = lstatSync6(path);
+  const metadata = lstatSync7(path);
   const uid = process.getuid?.() ?? metadata.uid;
   if (!metadata.isSocket() || metadata.isSymbolicLink() || metadata.uid !== uid) {
     throw new Error("SSH agent socket must be a caller-owned Unix socket");
@@ -15653,7 +15915,7 @@ var fingerprint = (key) => {
   if (!bytes.length || bytes.toString("base64").replace(/=+$/, "") !== encoded.replace(/=+$/, "")) {
     throw new Error("SSH host key is malformed");
   }
-  return `SHA256:${createHash5("sha256").update(bytes).digest("base64").replace(/=+$/, "")}`;
+  return `SHA256:${createHash6("sha256").update(bytes).digest("base64").replace(/=+$/, "")}`;
 };
 var validateHop = (value, label) => {
   const hop = exactKeys5(value, ["address", "port", "user", "hostKey", "hostKeySha256"], label);
@@ -15670,8 +15932,10 @@ var validateHop = (value, label) => {
   }
   return hop;
 };
-function readOperatorPlatformBootstrapRequest(path) {
-  const value = JSON.parse(new TextDecoder().decode(ownerFile(path, REQUEST_LIMIT, "operator bootstrap request")));
+function createOperatorSshHop(input) {
+  return validateHop({ ...input, hostKeySha256: fingerprint(input.hostKey) }, "operator SSH hop");
+}
+var validatePlatformRequestValue = (value) => {
   const root = exactKeys5(value, ["kind", "target", "platformConfigFile"], "operator bootstrap request");
   if (root.kind !== "platform-remote")
     throw new Error("operator bootstrap kind must be platform-remote");
@@ -15690,6 +15954,7 @@ function readOperatorPlatformBootstrapRequest(path) {
   socketPath(targetValue.agentSocket);
   if (typeof root.platformConfigFile !== "string")
     throw new Error("platformConfigFile must be an absolute path");
+  canonicalOutputPath(root.platformConfigFile, "platformConfigFile");
   const config = readBootstrapConfig(root.platformConfigFile);
   if (config.kind !== "platform")
     throw new Error("operator bootstrap requires a platform config");
@@ -15703,9 +15968,39 @@ function readOperatorPlatformBootstrapRequest(path) {
       ...targetValue.jump === undefined ? {} : { jump: validateHop(targetValue.jump, "operator bootstrap jump") }
     }
   };
-}
-function readOperatorMetalBootstrapRequest(path) {
-  const value = JSON.parse(new TextDecoder().decode(ownerFile(path, REQUEST_LIMIT, "operator metal request")));
+};
+function readOperatorPlatformBootstrapRequest(path) {
+  const value = JSON.parse(new TextDecoder().decode(ownerFile(path, REQUEST_LIMIT, "operator bootstrap request")));
+  return validatePlatformRequestValue(value);
+}
+function writeOperatorPlatformBootstrapRequest(path, request) {
+  validatePlatformRequestValue(request);
+  return writeOwnerJson2(path, request, "operator bootstrap request");
+}
+function readOperatorPlatformBootstrapFleetRequest(path) {
+  const value = JSON.parse(new TextDecoder().decode(ownerFile(path, REQUEST_LIMIT, "operator fleet request")));
+  const root = exactKeys5(value, ["kind", "requests"], "operator fleet request");
+  if (root.kind !== "platform-fleet-remote")
+    throw new Error("operator fleet kind must be platform-fleet-remote");
+  if (!Array.isArray(root.requests) || root.requests.length !== 3 || root.requests.some((entry) => typeof entry !== "string")) {
+    throw new Error("operator fleet requires exactly three request files");
+  }
+  const requests = root.requests.map((entry) => canonicalOutputPath(entry, "operator fleet request file"));
+  if (new Set(requests).size !== 3)
+    throw new Error("operator fleet request files must be unique");
+  for (const request of requests)
+    readOperatorPlatformBootstrapRequest(request);
+  return { kind: "platform-fleet-remote", requests };
+}
+function writeOperatorPlatformBootstrapFleetRequest(path, requestFiles) {
+  const request = { kind: "platform-fleet-remote", requests: requestFiles };
+  if (new Set(requestFiles).size !== 3)
+    throw new Error("operator fleet request files must be unique");
+  for (const file of requestFiles)
+    readOperatorPlatformBootstrapRequest(file);
+  return writeOwnerJson2(path, request, "operator fleet request");
+}
+var validateMetalRequestValue = (value) => {
   const root = exactKeys5(value, ["kind", "target", "metalConfigFile", "genesis"], "operator metal request");
   if (root.kind !== "metal-remote")
     throw new Error("operator metal bootstrap kind must be metal-remote");
@@ -15724,6 +16019,7 @@ function readOperatorMetalBootstrapRequest(path) {
   socketPath(targetValue.agentSocket);
   if (typeof root.metalConfigFile !== "string")
     throw new Error("metalConfigFile must be an absolute path");
+  canonicalOutputPath(root.metalConfigFile, "metalConfigFile");
   readMetalBootstrapConfig(root.metalConfigFile);
   const genesis = exactKeys5(root.genesis, ["environment", "sshPublicKeyFiles"], "operator metal genesis");
   if (typeof genesis.environment !== "string" || !PLATFORM_GENESIS_ENVIRONMENTS.includes(genesis.environment)) {
@@ -15747,6 +16043,14 @@ function readOperatorMetalBootstrapRequest(path) {
       sshPublicKeyFiles: genesis.sshPublicKeyFiles
     }
   };
+};
+function readOperatorMetalBootstrapRequest(path) {
+  const value = JSON.parse(new TextDecoder().decode(ownerFile(path, REQUEST_LIMIT, "operator metal request")));
+  return validateMetalRequestValue(value);
+}
+function writeOperatorMetalBootstrapRequest(path, request) {
+  validateMetalRequestValue(request);
+  return writeOwnerJson2(path, request, "operator metal request");
 }
 function planOperatorMetalBootstrap(request, mode) {
   const config = readMetalBootstrapConfig(request.metalConfigFile);
@@ -15798,13 +16102,95 @@ function planOperatorPlatformBootstrap(request, mode) {
     steps: mode === "status" ? ["verify pinned SSH transport", "run typed fz bootstrap status"] : [
       "verify pinned SSH transport and caller-approved SSH agent",
       "copy pinned Bun and packaged fz artifacts to a private staging directory",
+      "verify and copy the one immutable API Git bundle plus its manifest",
       "stage the rewritten owner-only platform config and its named credential handoffs",
-      `run typed fz bootstrap platform${mode === "prepare" ? " prepare" : ""} --apply`,
+      "run typed fz bootstrap platform --apply from the local bundle",
       "remove transient local and remote staging data"
     ],
     secretInputs: mode === "apply" ? [...attendedSecretNames(config), ...secretSources(config).map(([name]) => name)] : []
   };
 }
+var fleetConfigIdentity = (config) => {
+  const normalized = structuredClone(config);
+  delete normalized.computeReference;
+  delete normalized.nodeHostname;
+  delete normalized.cloudflareHandoff;
+  delete normalized.database.role;
+  delete normalized.database.address;
+  delete normalized.database.master;
+  const environment = normalized.runtime.environment;
+  delete environment.databaseRole;
+  delete environment.databaseAddress;
+  delete environment.databaseMaster;
+  delete environment.nodeHostname;
+  delete environment.seedSyncPeers;
+  delete environment.custodianEmail;
+  return JSON.stringify(normalized);
+};
+function validatedPlatformFleet(fleet) {
+  const requests = fleet.requests.map(readOperatorPlatformBootstrapRequest);
+  const configs = requests.map((request) => {
+    const config = readBootstrapConfig(request.platformConfigFile);
+    if (config.kind !== "platform")
+      throw new Error("operator fleet requires platform configs");
+    return config;
+  });
+  const environment = configs[0].environment;
+  const expected = PLATFORM_GENESIS_FLEETS[environment];
+  if (!expected || expected.length !== 3)
+    throw new Error("operator fleet environment is invalid");
+  const identity = fleetConfigIdentity(configs[0]);
+  const operatorIdentity = `${requests[0].target.identityPublicKeyFile}\x00${requests[0].target.agentSocket}`;
+  const jumpIdentity = JSON.stringify(requests[0].target.jump ?? null);
+  const coordinators = expected.map((guest) => `http://${guest.address}:8529`);
+  const nodeHostnames = new Set;
+  for (let index = 0;index < 3; index += 1) {
+    const config = configs[index];
+    const request = requests[index];
+    const guest = expected[index];
+    const role = index === 0 ? "master" : "joiner";
+    if (config.environment !== environment || fleetConfigIdentity(config) !== identity) {
+      throw new Error("operator fleet platform configs do not share one immutable identity");
+    }
+    if (config.computeReference !== guest.name || config.database.address !== guest.address || config.database.role !== role || config.database.agency !== "member" || (role === "master" ? config.database.master !== undefined : config.database.master !== expected[0].address) || config.database.coordinators.join(",") !== coordinators.join(",") || config.enrolment.source !== "genesis-derived" || config.cloudflareHandoff?.nodeName !== guest.name) {
+      throw new Error(`operator fleet ${guest.name} does not match the exact genesis topology`);
+    }
+    if (request.target.address !== guest.address || request.target.port !== 22 || request.target.user !== "forgezero") {
+      throw new Error(`operator fleet ${guest.name} SSH target must be forgezero@${guest.address}:22`);
+    }
+    if (`${request.target.identityPublicKeyFile}\x00${request.target.agentSocket}` !== operatorIdentity) {
+      throw new Error("operator fleet must use one caller-approved SSH identity and agent socket");
+    }
+    if (JSON.stringify(request.target.jump ?? null) !== jumpIdentity) {
+      throw new Error("operator fleet must use one pinned Metal jump or no jump on every node");
+    }
+    if (nodeHostnames.has(config.nodeHostname))
+      throw new Error("operator fleet node hostnames must be unique");
+    nodeHostnames.add(config.nodeHostname);
+  }
+  return { requests, configs, environment };
+}
+function planOperatorPlatformFleetBootstrap(fleet, mode) {
+  const { requests, configs, environment } = validatedPlatformFleet(fleet);
+  const secretInputs = mode === "apply" ? attendedSecretNames(configs[0]) : [];
+  for (const config of configs.slice(1)) {
+    if (JSON.stringify(attendedSecretNames(config)) !== JSON.stringify(secretInputs)) {
+      throw new Error("operator fleet configs do not share one attended secret schema");
+    }
+  }
+  return {
+    kind: "platform-fleet-remote",
+    mode,
+    mutation: mode !== "status",
+    environment,
+    nodes: requests.map((request, index) => ({
+      computeReference: configs[index].computeReference,
+      address: request.target.address,
+      ...request.target.jump ? { via: request.target.jump.address } : {}
+    })),
+    secretInputs
+  };
+}
 var defaultExec3 = async (argv2, options = {}) => {
   const child = Bun.spawn([...argv2], {
     stdin: options.stdin === undefined ? "ignore" : "pipe",
@@ -15828,7 +16214,7 @@ var defaultExec3 = async (argv2, options = {}) => {
   ]);
   return { exitCode, output: options.secret ? "" : `${stdout}${stderr}`.slice(0, 65536) };
 };
-var checked4 = async (exec, argv2, label, options) => {
+var checked5 = async (exec, argv2, label, options) => {
   const result = await exec(argv2, options);
   if (result.exitCode !== 0)
     throw new Error(`${label} failed${result.output ? `: ${result.output.trim()}` : ""}`);
@@ -15841,7 +16227,7 @@ function writeKnownHosts(request, directory) {
   if (request.target.jump)
     lines.push(`${hostLabel(request.target.jump.address, request.target.jump.port)} ${request.target.jump.hostKey}`);
   const path = join10(directory, "known_hosts");
-  writeFileSync11(path, `${lines.join(`
+  writeFileSync12(path, `${lines.join(`
 `)}
 `, { mode: 384, flag: "wx" });
   return path;
@@ -15882,7 +16268,7 @@ var safeRemoteArg = (value) => {
 };
 var remote = async (exec, request, knownHosts, argv2, label, secret = false, stdin) => {
   argv2.forEach(safeRemoteArg);
-  return checked4(exec, ["ssh", ...sshOptions(request, knownHosts), destination2(request.target), "--", ...argv2], label, { secret, stdin });
+  return checked5(exec, ["ssh", ...sshOptions(request, knownHosts), destination2(request.target), "--", ...argv2], label, { secret, stdin });
 };
 var remoteRegularFileExists = async (exec, request, knownHosts, path) => {
   safeRemoteArg(path);
@@ -15903,36 +16289,45 @@ var remoteRegularFileExists = async (exec, request, knownHosts, path) => {
 };
 var copy = async (exec, request, knownHosts, local, remotePath, secret = false) => {
   safeRemoteArg(remotePath);
-  await checked4(exec, [
+  await checked5(exec, [
     "scp",
     ...sshOptions(request, knownHosts, true),
     local,
     `${destination2(request.target)}:${remotePath}`
   ], "secure copy", { secret });
 };
-function stageConfig(config, directory) {
+async function stageConfig(config, directory) {
   const rewritten = structuredClone(config);
   const staged = [];
   for (const [name, source] of secretSources(config)) {
     const bytes = ownerFile(source, SECRET_LIMIT, name);
     const local = join10(directory, name);
-    writeFileSync11(local, bytes, { mode: 384, flag: "wx" });
+    writeFileSync12(local, bytes, { mode: 384, flag: "wx" });
     staged.push(name);
     const remotePath = `${REMOTE_STAGE}/${name}`;
     if (name === "cloudflare-handoff")
       rewritten.cloudflareHandoff.handoffFile = remotePath;
   }
+  const bundle = await readBootstrapBundle(config.bootstrapBundle.bundleFile, config.bootstrapBundle.manifestFile);
+  const bundleFiles = [
+    { source: bundle.bundlePath, name: "bootstrap-api.bundle" },
+    { source: bundle.manifestPath, name: "bootstrap-api.bundle.json" }
+  ];
+  rewritten.bootstrapBundle = {
+    bundleFile: `${REMOTE_STAGE}/bootstrap-api.bundle`,
+    manifestFile: `${REMOTE_STAGE}/bootstrap-api.bundle.json`
+  };
   const path = join10(directory, "platform-config.json");
-  writeFileSync11(path, `${JSON.stringify(rewritten, null, 2)}
+  writeFileSync12(path, `${JSON.stringify(rewritten, null, 2)}
 `, { mode: 384, flag: "wx" });
-  return { path, files: staged };
+  return { path, files: staged, bundleFiles };
 }
 function stageMetalConfig(config, directory) {
   const rewritten = structuredClone(config);
   const files = [];
   if (config.agentSeedFile) {
     const name = "metal-agent-seed";
-    writeFileSync11(join10(directory, name), ownerFile(config.agentSeedFile, SECRET_LIMIT, name), {
+    writeFileSync12(join10(directory, name), ownerFile(config.agentSeedFile, SECRET_LIMIT, name), {
       mode: 384,
       flag: "wx"
     });
@@ -15940,7 +16335,7 @@ function stageMetalConfig(config, directory) {
     files.push(name);
   }
   const path = join10(directory, "metal-config.json");
-  writeFileSync11(path, `${JSON.stringify(rewritten, null, 2)}
+  writeFileSync12(path, `${JSON.stringify(rewritten, null, 2)}
 `, { mode: 384, flag: "wx" });
   return { path, files };
 }
@@ -15949,10 +16344,10 @@ async function verifiedBunArchive(directory, fetcher) {
   if (!response.ok)
     throw new Error("pinned Bun download failed");
   const bytes = new Uint8Array(await response.arrayBuffer());
-  if (createHash5("sha256").update(bytes).digest("hex") !== BUN_RELEASE_SHA256)
+  if (createHash6("sha256").update(bytes).digest("hex") !== BUN_RELEASE_SHA256)
     throw new Error("pinned Bun checksum mismatch");
   const path = join10(directory, "bun.zip");
-  writeFileSync11(path, bytes, { mode: 384, flag: "wx" });
+  writeFileSync12(path, bytes, { mode: 384, flag: "wx" });
   return path;
 }
 async function installPackagedAgent(request, knownHosts, exec, directory, remoteTemp, options) {
@@ -15962,7 +16357,7 @@ async function installPackagedAgent(request, knownHosts, exec, directory, remote
     [options.fzGitSshPath ?? fileURLToPath2(new URL("./fz-git-ssh.js", import.meta.url)), "fz-git-ssh.js"]
   ];
   for (const [artifact] of artifacts) {
-    if (!readFileSync11(artifact).length)
+    if (!readFileSync12(artifact).length)
       throw new Error(`packaged artifact is empty: ${basename2(artifact)}`);
   }
   await remote(exec, request, knownHosts, ["/usr/bin/mkdir", "-m", "0700", remoteTemp], "remote staging");
@@ -16003,7 +16398,7 @@ async function applyOperatorPlatformBootstrap(request, mode, options = {}) {
   socketPath(request.target.agentSocket);
   const exec = options.exec ?? defaultExec3;
   const directory = mkdtempSync(join10(tmpdir(), "forgezero-operator-bootstrap-"));
-  const remoteTemp = `/tmp/forgezero-operator-${randomBytes8(12).toString("hex")}`;
+  const remoteTemp = `/tmp/forgezero-operator-${randomBytes9(12).toString("hex")}`;
   let knownHosts = "";
   try {
     knownHosts = writeKnownHosts(request, directory);
@@ -16015,18 +16410,16 @@ async function applyOperatorPlatformBootstrap(request, mode, options = {}) {
     if (config.kind !== "platform")
       throw new Error("operator bootstrap requires a platform config");
     const secrets = mode === "apply" ? validatePlatformBootstrapSecrets(config, options.secrets) : undefined;
-    const staged = stageConfig(config, directory);
+    const staged = await stageConfig(config, directory);
     await installPackagedAgent(request, knownHosts, exec, directory, remoteTemp, options);
     await copy(exec, request, knownHosts, staged.path, `${remoteTemp}/platform-config.json`, true);
     for (const name of staged.files)
       await copy(exec, request, knownHosts, join10(directory, name), `${remoteTemp}/${name}`, true);
-    for (const name of ["platform-config.json", ...staged.files])
+    for (const bundle of staged.bundleFiles)
+      await copy(exec, request, knownHosts, bundle.source, `${remoteTemp}/${bundle.name}`, true);
+    for (const name of ["platform-config.json", ...staged.files, ...staged.bundleFiles.map(({ name: name2 }) => name2)])
       await remote(exec, request, knownHosts, ["/usr/bin/sudo", "-n", "/usr/bin/install", "-m", "0600", `${remoteTemp}/${name}`, `${REMOTE_STAGE}/${name}`], "remote bootstrap handoff", true);
-    const command = ["/usr/bin/sudo", "-n", "/usr/local/bin/fz", "bootstrap", "platform"];
-    if (mode === "prepare")
-      command.push("prepare");
-    else
-      command.push("credentials-stdin");
+    const command = ["/usr/bin/sudo", "-n", "/usr/local/bin/fz", "bootstrap", "platform", "credentials-stdin"];
     command.push("--bootstrap-config", `${REMOTE_STAGE}/platform-config.json`, "--apply");
     const output = await remote(exec, request, knownHosts, command, "remote typed bootstrap", mode === "apply", secrets ? `${JSON.stringify(secrets)}
 ` : undefined);
@@ -16037,16 +16430,40 @@ async function applyOperatorPlatformBootstrap(request, mode, options = {}) {
         return;
       });
     }
-    rmSync6(directory, { recursive: true, force: true });
+    rmSync7(directory, { recursive: true, force: true });
   }
 }
+async function applyOperatorPlatformFleetBootstrap(fleet, mode, options = {}) {
+  const plan = planOperatorPlatformFleetBootstrap(fleet, mode);
+  const { requests, configs } = validatedPlatformFleet(fleet);
+  const secrets = mode === "apply" ? validatePlatformBootstrapSecrets(configs[0], options.secrets) : undefined;
+  if (secrets) {
+    for (const config of configs.slice(1))
+      validatePlatformBootstrapSecrets(config, secrets);
+  }
+  const settled = await Promise.allSettled(requests.map((request) => applyOperatorPlatformBootstrap(request, mode, { ...options, secrets })));
+  const outcomes = settled.map((result, index) => {
+    const config = configs[index];
+    const address = requests[index].target.address;
+    if (result.status === "fulfilled")
+      return {
+        computeReference: config.computeReference,
+        address,
+        ok: true,
+        output: result.value.output.slice(0, 65536)
+      };
+    const message = result.reason instanceof Error ? result.reason.message : String(result.reason);
+    return { computeReference: config.computeReference, address, ok: false, error: message.slice(0, 4096) };
+  });
+  return { plan, ok: outcomes.every(({ ok }) => ok), outcomes };
+}
 async function applyOperatorMetalBootstrap(request, mode, options = {}) {
   const plan = planOperatorMetalBootstrap(request, mode);
   publicIdentity(request.target.identityPublicKeyFile);
   socketPath(request.target.agentSocket);
   const exec = options.exec ?? defaultExec3;
   const directory = mkdtempSync(join10(tmpdir(), "forgezero-operator-metal-"));
-  const remoteTemp = `/tmp/forgezero-operator-${randomBytes8(12).toString("hex")}`;
+  const remoteTemp = `/tmp/forgezero-operator-${randomBytes9(12).toString("hex")}`;
   let knownHosts = "";
   try {
     knownHosts = writeKnownHosts(request, directory);
@@ -16090,7 +16507,7 @@ async function applyOperatorMetalBootstrap(request, mode, options = {}) {
         return;
       });
     }
-    rmSync6(directory, { recursive: true, force: true });
+    rmSync7(directory, { recursive: true, force: true });
   }
 }
 
@@ -16103,9 +16520,6 @@ function platformGenesisBootstrapConfigs(template, nodes) {
   if (nodes.some((node) => !node.nodeHostname || !node.cloudflareHandoffFile)) {
     throw new Error("every platform genesis node requires its public hostname and node-specific Cloudflare handoff");
   }
-  if (template.branch !== (environment === "production" ? "main" : "dev")) {
-    throw new Error("platform genesis branch must match the selected environment");
-  }
   const coordinators = fleet.map((guest) => `http://${guest.address}:8529`);
   return fleet.map((guest, index) => {
     const node = nodes[index];
@@ -16144,7 +16558,7 @@ function platformGenesisBootstrapConfigs(template, nodes) {
 }
 
 // src/host-maintenance.ts
-import { lstatSync as lstatSync7, readFileSync as readFileSync12 } from "fs";
+import { lstatSync as lstatSync8, readFileSync as readFileSync13 } from "fs";
 var ROOT = "/opt/forgezero";
 var SLOT_FILE = `${ROOT}/.forge-slot`;
 var SHARED_ENV = `${ROOT}/shared/.env`;
@@ -16152,9 +16566,9 @@ var JWT = "/etc/forgezero/creds/arangodb-jwt.cred";
 var FZ = "/usr/local/bin/fz";
 var localRuntime = () => ({
   uid: () => process.getuid?.() ?? -1,
-  read: (path) => readFileSync12(path, "utf8"),
+  read: (path) => readFileSync13(path, "utf8"),
   inspect(path) {
-    const value = lstatSync7(path);
+    const value = lstatSync8(path);
     return {
       regular: value.isFile(),
       symbolic: value.isSymbolicLink(),
@@ -16275,8 +16689,8 @@ async function applyHostMaintenance(request, runtime = localRuntime()) {
 }
 
 // src/cli/maintenance.ts
-import { existsSync as existsSync10, lstatSync as lstatSync8, readFileSync as readFileSync13, realpathSync as realpathSync5 } from "fs";
-import { isAbsolute as isAbsolute4, join as join11, relative as relative2, resolve as resolve8 } from "path";
+import { existsSync as existsSync11, lstatSync as lstatSync9, readFileSync as readFileSync14, realpathSync as realpathSync5 } from "fs";
+import { isAbsolute as isAbsolute6, join as join11, relative as relative2, resolve as resolve10 } from "path";
 var API_OPERATION_ENTRYPOINTS = {
   "dev-reset": ["src", "server", "maintenance", "dev-reset.ts"],
   "db-backup": ["src", "server", "maintenance", "snapshot-backup.ts"],
@@ -16346,12 +16760,12 @@ function unsupportedRepositoryCliOption(argv2) {
 }
 function manifestName(root) {
   const manifestPath = join11(root, "package.json");
-  if (!existsSync10(manifestPath)) {
+  if (!existsSync11(manifestPath)) {
     throw new Error(`No package.json exists at repository root ${root}.`);
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync13(manifestPath, "utf8"));
+    parsed = JSON.parse(readFileSync14(manifestPath, "utf8"));
   } catch (cause) {
     throw new Error(`Cannot read ${manifestPath}: ${cause instanceof Error ? cause.message : String(cause)}`);
   }
@@ -16362,21 +16776,21 @@ function manifestName(root) {
 }
 function checkedEntrypoint(root, parts) {
   const candidate = join11(root, ...parts);
-  if (!existsSync10(candidate) || !lstatSync8(candidate).isFile()) {
+  if (!existsSync11(candidate) || !lstatSync9(candidate).isFile()) {
     throw new Error(`The reviewed operation entrypoint is missing: ${candidate}`);
   }
-  if (lstatSync8(candidate).isSymbolicLink()) {
+  if (lstatSync9(candidate).isSymbolicLink()) {
     throw new Error(`The reviewed operation entrypoint must not be a symbolic link: ${candidate}`);
   }
   const actual = realpathSync5(candidate);
   const within = relative2(root, actual);
-  if (within.startsWith("..") || isAbsolute4(within)) {
+  if (within.startsWith("..") || isAbsolute6(within)) {
     throw new Error(`The reviewed operation entrypoint escapes repository root ${root}.`);
   }
   return actual;
 }
 function resolveRepositoryOperation(operation, requestedRoot) {
-  const root = realpathSync5(resolve8(requestedRoot));
+  const root = realpathSync5(resolve10(requestedRoot));
   const name = manifestName(root);
   if (operation in API_OPERATION_ENTRYPOINTS) {
     const parts = API_OPERATION_ENTRYPOINTS[operation];
@@ -16677,7 +17091,7 @@ async function api(options, path, init) {
   return { status: response.status, body };
 }
 function sleep(ms) {
-  return new Promise((resolve10) => setTimeout(resolve10, ms));
+  return new Promise((resolve12) => setTimeout(resolve12, ms));
 }
 function browserCommand(url) {
   if (process.platform === "darwin")
@@ -16762,7 +17176,7 @@ function requireSession() {
 function readOwnerOnlySecret(path, label) {
   let metadata;
   try {
-    metadata = lstatSync9(path);
+    metadata = lstatSync10(path);
   } catch {
     throw new Error(`The ${label} file ${path} is unreadable.`);
   }
@@ -16776,7 +17190,7 @@ function readOwnerOnlySecret(path, label) {
   if (uid !== undefined && uid !== 0 && metadata.uid !== uid) {
     throw new Error(`The ${label} file ${path} is not owned by the current user.`);
   }
-  const value = readFileSync14(path, "utf8").trim();
+  const value = readFileSync15(path, "utf8").trim();
   if (!value)
     throw new Error(`The ${label} file ${path} is empty.`);
   return value;
@@ -16957,7 +17371,7 @@ async function cmdApi(options, args) {
     let body = undefined;
     if (options.data !== undefined && options.dataFile)
       throw new Error("Use only one of --data or --data-file.");
-    const encoded = options.data === "-" ? await Bun.stdin.text() : options.dataFile ? readFileSync14(options.dataFile, "utf8") : options.data;
+    const encoded = options.data === "-" ? await Bun.stdin.text() : options.dataFile ? readFileSync15(options.dataFile, "utf8") : options.data;
     if (encoded !== undefined)
       body = JSON.parse(encoded);
     const result = await api(options, `${url.pathname}${url.search}`, { method, body });
@@ -17051,7 +17465,7 @@ async function cmdAgent(options, args) {
     seedCredentialPath: process.env.FZ_SEED_CREDENTIAL_PATH,
     gitCredentialPath,
     gitPublicKeyPath,
-    generateGitIdentity: true,
+    generateGitIdentity: process.env.FZ_GENERATE_GIT_DEPLOY_KEY === "true",
     controlSocketPath: process.env.FZ_CONTROL_SOCKET,
     repository: process.env.FZ_DEPLOY_REPO,
     branch: process.env.FZ_DEPLOY_BRANCH,
@@ -17108,19 +17522,19 @@ async function cmdAgent(options, args) {
     return 0;
   }
   try {
-    writeFileSync12(plan.unitPath, plan.unit, { mode: 420 });
+    writeFileSync13(plan.unitPath, plan.unit, { mode: 420 });
     out.ok(`Wrote ${plan.unitPath}`);
     for (const auxiliary of plan.auxiliaryUnits) {
-      mkdirSync11(dirname12(auxiliary.path), { recursive: true, mode: 493 });
-      writeFileSync12(auxiliary.path, auxiliary.unit, { mode: 420 });
+      mkdirSync13(dirname14(auxiliary.path), { recursive: true, mode: 493 });
+      writeFileSync13(auxiliary.path, auxiliary.unit, { mode: 420 });
       out.ok(`Wrote ${auxiliary.path}`);
     }
     if (options.enrol) {
-      if (!existsSync11(enrolStatePath) && !existsSync11(enrolTokenCredentialPath)) {
+      if (!existsSync12(enrolStatePath) && !existsSync12(enrolTokenCredentialPath)) {
         const token = await bootstrapSecret("ForgeZero one-time enrolment token");
         if (!/^fze_[A-Za-z0-9_-]{40,100}$/.test(token))
           throw new Error("A valid fze_ enrolment token was not provided.");
-        mkdirSync11(dirname12(enrolTokenCredentialPath), { recursive: true, mode: 448 });
+        mkdirSync13(dirname14(enrolTokenCredentialPath), { recursive: true, mode: 448 });
         const sealing = Bun.spawn(["systemd-creds", "encrypt", "--name=enrol-token", "-", enrolTokenCredentialPath], { stdin: "pipe", stdout: "ignore", stderr: "pipe" });
         if (sealing.stdin && typeof sealing.stdin !== "number") {
           sealing.stdin.write(`${token}
@@ -17136,11 +17550,13 @@ async function cmdAgent(options, args) {
     for (const step3 of transcript)
       out.ok(step3.label);
     out.ok("Agent service and socket verified");
-    out.line();
-    out.line("  Add this machine-specific PUBLIC key as a read-only deploy key:");
-    out.line();
-    out.line(`  ${readFileSync14(gitPublicKeyPath, "utf8").trim()}`);
-    out.line();
+    if (existsSync12(gitPublicKeyPath)) {
+      out.line();
+      out.line("  Compatibility SSH deploy public key:");
+      out.line();
+      out.line(`  ${readFileSync15(gitPublicKeyPath, "utf8").trim()}`);
+      out.line();
+    }
     return 0;
   } catch (cause) {
     out.fail(`Could not write ${plan.unitPath}: ${cause.message}`);
@@ -17244,10 +17660,10 @@ function interactiveMetalBootstrap() {
   });
 }
 function writeBootstrapConfig(path, config) {
-  if (!isAbsolute5(path) || resolve9(path) !== path)
+  if (!isAbsolute7(path) || resolve11(path) !== path)
     throw new Error("--output must be a canonical absolute path");
-  mkdirSync11(dirname12(path), { recursive: true, mode: 448 });
-  writeFileSync12(path, `${JSON.stringify(config, null, 2)}
+  mkdirSync13(dirname14(path), { recursive: true, mode: 448 });
+  writeFileSync13(path, `${JSON.stringify(config, null, 2)}
 `, { mode: 384, flag: "wx" });
   return path;
 }
@@ -17308,17 +17724,48 @@ async function interactiveCloudflareBootstrap() {
   });
 }
 function genesisOutputDirectory(path) {
-  if (!isAbsolute5(path) || resolve9(path) !== path)
+  if (!isAbsolute7(path) || resolve11(path) !== path)
     throw new Error("--output must be a canonical absolute directory");
-  if (!existsSync11(path))
-    mkdirSync11(path, { recursive: true, mode: 448 });
-  const metadata = lstatSync9(path);
+  if (!existsSync12(path))
+    mkdirSync13(path, { recursive: true, mode: 448 });
+  const metadata = lstatSync10(path);
   const uid = process.getuid?.();
   if (!metadata.isDirectory() || metadata.isSymbolicLink() || (metadata.mode & 63) !== 0 || uid !== undefined && uid !== 0 && metadata.uid !== uid) {
     throw new Error("platform genesis output must be an owner-only directory owned by the current user");
   }
   return path;
 }
+function interactiveOperatorHop(label, defaults) {
+  return createOperatorSshHop({
+    address: bootstrapAnswer(`${label} explicit SSH IP`, defaults.address),
+    port: bootstrapNumber(`${label} SSH port`, "22"),
+    user: bootstrapAnswer(`${label} SSH user`, defaults.user),
+    hostKey: bootstrapAnswer(`${label} trusted ssh-ed25519 host public key`)
+  });
+}
+function operatorIdentityCoordinates() {
+  return {
+    identityPublicKeyFile: bootstrapAnswer("Operator SSH public-key file (private key remains in Bitwarden SSH agent)"),
+    agentSocket: bootstrapAnswer("Bitwarden SSH agent socket", process.env.SSH_AUTH_SOCK)
+  };
+}
+function writeMetalOperatorFiles(directory) {
+  const output = genesisOutputDirectory(directory);
+  const config = interactiveMetalBootstrap();
+  const metalConfig = writeBootstrapConfig(join12(output, "metal.json"), config);
+  const identity = operatorIdentityCoordinates();
+  const target = interactiveOperatorHop("Metal", { user: "root" });
+  const remoteRequest = writeOperatorMetalBootstrapRequest(join12(output, "metal-remote.json"), {
+    kind: "metal-remote",
+    metalConfigFile: metalConfig,
+    target: { ...target, ...identity },
+    genesis: {
+      environment: bootstrapAnswer("Genesis environment (production/development)", "development"),
+      sshPublicKeyFiles: [identity.identityPublicKeyFile]
+    }
+  });
+  return { metalConfig, remoteRequest };
+}
 function writePlatformGenesisFleet(directory) {
   const output = genesisOutputDirectory(directory);
   const template = interactiveBootstrap("platform", true);
@@ -17335,7 +17782,20 @@ function writePlatformGenesisFleet(directory) {
     writeBootstrapConfig(path, config);
     return path;
   });
-  return { configs };
+  const identity = operatorIdentityCoordinates();
+  const useJump = bootstrapAnswer("Reach genesis computes through the Metal SSH jump? (yes/no)", "yes") === "yes";
+  const jump = useJump ? interactiveOperatorHop("Metal jump", { user: "root" }) : undefined;
+  const requests = configs.map((platformConfigFile, index) => {
+    const guest = fleet[index];
+    const target = interactiveOperatorHop(`${guest.name} compute`, { address: guest.address, user: "forgezero" });
+    return writeOperatorPlatformBootstrapRequest(join12(output, `${guest.name}-remote.json`), {
+      kind: "platform-remote",
+      platformConfigFile,
+      target: { ...target, ...identity, ...jump ? { jump } : {} }
+    });
+  });
+  const fleetRequest = writeOperatorPlatformBootstrapFleetRequest(join12(output, "platform-fleet-remote.json"), requests);
+  return { configs, requests, fleetRequest };
 }
 function interactiveBootstrap(kind, genesis = false) {
   if (!process.stdin.isTTY)
@@ -17356,8 +17816,8 @@ function interactiveBootstrap(kind, genesis = false) {
   const nodeHostname = bootstrapAnswer(genesis ? `${computeReference} public node hostname` : "Public node hostname");
   const apiUrl = bootstrapAnswer("Platform API URL");
   const appOrigin = bootstrapAnswer("Public App origin");
-  const repository = bootstrapAnswer("API Git repository");
-  const branch = bootstrapAnswer("Deployment branch", environment === "production" ? "main" : "dev");
+  const bundleFile = bootstrapAnswer("Bootstrap API Git bundle (absolute path)");
+  const manifestFile = bootstrapAnswer("Bootstrap bundle manifest (absolute path)", `${bundleFile}.json`);
   const telemetryEndpoint = bootstrapAnswer("Public HTTPS Agent OTLP endpoint");
   const collectorUnit = FORGEZERO_OTEL_COLLECTOR_UNIT;
   const replicationFactor = Number(bootstrapAnswer("Database replication factor", "3"));
@@ -17386,8 +17846,7 @@ function interactiveBootstrap(kind, genesis = false) {
     computeReference,
     nodeHostname,
     apiUrl,
-    repository,
-    branch,
+    bootstrapBundle: { bundleFile, manifestFile },
     telemetryEndpoint,
     database: {
       role,
@@ -17431,8 +17890,6 @@ function interactiveBootstrap(kind, genesis = false) {
         ...backupEndpoint && backupRegion && backupBucket && backupAccessKeyId ? {
           backup: { endpoint: backupEndpoint, region: backupRegion, bucket: backupBucket, accessKeyId: backupAccessKeyId }
         } : {},
-        repository,
-        branch,
         deployProfile: environment
       },
       serviceUser: "forgezero-api",
@@ -17460,7 +17917,7 @@ async function cmdBootstrap(options, args) {
     if (operation === "config") {
       const kind = args[1];
       if (kind !== "metal" && kind !== "platform" && kind !== "cloudflare" || args[2] !== undefined || !options.outputPath) {
-        throw new Error("Usage: fz bootstrap config metal|cloudflare --output <absolute-file> | fz bootstrap config platform --output <absolute-owner-only-directory>");
+        throw new Error("Usage: fz bootstrap config cloudflare --output <absolute-file> | fz bootstrap config metal|platform --output <absolute-owner-only-directory>");
       }
       if (kind === "platform") {
         out.line(JSON.stringify({ kind, ...writePlatformGenesisFleet(options.outputPath), mode: "0600" }, null, 2));
@@ -17472,14 +17929,36 @@ async function cmdBootstrap(options, args) {
         out.line(JSON.stringify({ kind, path, mode: "0600" }, null, 2));
         return 0;
       }
-      const config2 = interactiveMetalBootstrap();
-      out.line(JSON.stringify({ kind, path: writeBootstrapConfig(options.outputPath, config2), mode: "0600" }, null, 2));
+      out.line(JSON.stringify({ kind, ...writeMetalOperatorFiles(options.outputPath), mode: "0600" }, null, 2));
       return 0;
     }
+    if (operation === "platform" && args[1] === "fleet") {
+      const mode = args[2];
+      if (!mode || !["apply", "status"].includes(mode) || args[3] !== undefined) {
+        throw new Error("Usage: fz bootstrap platform fleet <apply|status> --bootstrap-config <owner-only-platform-fleet-remote.json> [--apply]");
+      }
+      if (!options.bootstrapConfigPath)
+        throw new Error("remote platform fleet bootstrap requires --bootstrap-config");
+      const fleet = readOperatorPlatformBootstrapFleetRequest(options.bootstrapConfigPath);
+      const plan2 = planOperatorPlatformFleetBootstrap(fleet, mode);
+      if (!options.apply) {
+        out.line(JSON.stringify(plan2, null, 2));
+        out.step("Review all three pinned targets and shared secret names, then repeat with --apply.");
+        return 0;
+      }
+      const first = readOperatorPlatformBootstrapRequest(fleet.requests[0]);
+      const firstConfig = readBootstrapConfig(first.platformConfigFile);
+      if (firstConfig.kind !== "platform")
+        throw new Error("remote platform fleet requires platform configs");
+      const secrets2 = mode === "apply" ? await promptPlatformBootstrapSecrets(firstConfig) : undefined;
+      const result2 = await applyOperatorPlatformFleetBootstrap(fleet, mode, { secrets: secrets2 });
+      out.line(JSON.stringify(result2, null, 2));
+      return result2.ok ? 0 : 1;
+    }
     if (operation === "platform" && args[1] === "remote") {
       const mode = args[2];
-      if (!mode || !["prepare", "apply", "status"].includes(mode) || args[3] !== undefined) {
-        throw new Error("Usage: fz bootstrap platform remote <prepare|apply|status> --bootstrap-config <owner-only-request.json> [--apply]");
+      if (!mode || !["apply", "status"].includes(mode) || args[3] !== undefined) {
+        throw new Error("Usage: fz bootstrap platform remote <apply|status> --bootstrap-config <owner-only-request.json> [--apply]");
       }
       if (!options.bootstrapConfigPath)
         throw new Error("remote platform bootstrap requires --bootstrap-config");
@@ -17497,6 +17976,18 @@ async function cmdBootstrap(options, args) {
       out.line(JSON.stringify(await applyOperatorPlatformBootstrap(request, mode, { secrets: secrets2 }), null, 2));
       return 0;
     }
+    if (operation === "platform" && args[1] === "bundle") {
+      if (args[2] !== undefined || !options.outputPath) {
+        throw new Error("Usage: fz bootstrap platform bundle --root <clean-api-checkout> --branch <main|dev> --output <absolute.bundle>");
+      }
+      const result2 = await buildBootstrapBundle({
+        repositoryRoot: options.projectRoot,
+        outputPath: options.outputPath,
+        branch: options.branch
+      });
+      out.line(JSON.stringify(result2, null, 2));
+      return 0;
+    }
     if (operation === "metal" && args[1] === "remote") {
       const mode = args[2];
       if (!mode || !["apply", "genesis", "rehearsal", "rehearsal-cleanup", "status"].includes(mode) || args[3] !== undefined) {
@@ -17553,31 +18044,12 @@ async function cmdBootstrap(options, args) {
       await runCloudflareBootstrapCommand(options.bootstrapConfigPath, options.apply, tokens);
       return 0;
     }
-    if (operation === "platform" && args[1] === "prepare") {
-      if (args[2] !== undefined)
-        throw new Error("platform prepare accepts no positional arguments");
-      const config2 = options.bootstrapConfigPath ? readBootstrapConfig(options.bootstrapConfigPath) : interactiveBootstrap("platform");
-      if (config2.kind !== "platform")
-        throw new Error("platform prepare requires a platform bootstrap config");
-      if (!options.apply) {
-        out.line(JSON.stringify({
-          kind: "platform",
-          mode: "prepare",
-          mutation: false,
-          steps: ["bind immutable host intent", "install common Agent", "print machine public deploy key"]
-        }, null, 2));
-        out.step("Review the plan, then repeat with --apply as root. No database or API starts in prepare.");
-        return 0;
-      }
-      out.line(JSON.stringify(await preparePlatformBootstrap(config2), null, 2));
-      return 0;
-    }
     const credentialStdin = operation === "platform" && args[1] === "credentials-stdin";
     if (credentialStdin && args[2] !== undefined)
       throw new Error("platform credential stdin accepts no additional positional arguments");
     const installedBootstrapKind = () => resolveInstalledBootstrapKind({
-      metal: existsSync11(METAL_BOOTSTRAP_STATE_PATH),
-      compute: existsSync11(BOOTSTRAP_STATE_PATH)
+      metal: existsSync12(METAL_BOOTSTRAP_STATE_PATH),
+      compute: existsSync12(BOOTSTRAP_STATE_PATH)
     });
     if (operation === "status") {
       if (installedBootstrapKind() === "metal") {
@@ -17618,7 +18090,7 @@ async function cmdBootstrap(options, args) {
       return 0;
     }
     if (!["platform", "repair"].includes(operation)) {
-      throw new Error("Usage: fz bootstrap config <metal|platform|cloudflare>|platform [prepare|remote <prepare|apply|status>|cloudflare [verify|finalize]]|metal [remote <apply|genesis|rehearsal|rehearsal-cleanup|status>]|status|repair [--bootstrap-config <path>] [--apply]");
+      throw new Error("Usage: fz bootstrap config <metal|platform|cloudflare>|platform [bundle|fleet <apply|status>|remote <apply|status>|cloudflare [verify|finalize]]|metal [remote <apply|genesis|rehearsal|rehearsal-cleanup|status>]|status|repair [--bootstrap-config <path>] [--apply]");
     }
     const config = options.bootstrapConfigPath ? readBootstrapConfig(options.bootstrapConfigPath) : operation === "repair" ? (() => {
       throw new Error("repair requires --bootstrap-config so immutable coordinates are revalidated");
@@ -17715,7 +18187,7 @@ async function cmdUnlock(options) {
     if (options.key || options.userExplicit) {
       throw new Error("SSH/user unlock coordinates are not accepted. SSH keys cannot open a WebAuthn-PRF custody envelope; use --phrase-file or --phrase-stdin.");
     }
-    const phraseText = options.phraseFile ? readOwnerOnlySecret(options.phraseFile, "recovery phrase") : options.phraseStdin ? readFileSync14(0, "utf8").trim() : "";
+    const phraseText = options.phraseFile ? readOwnerOnlySecret(options.phraseFile, "recovery phrase") : options.phraseStdin ? readFileSync15(0, "utf8").trim() : "";
     const phrase = phraseText ? phraseText.split(/\s+/) : [];
     if (phrase.length !== 24) {
       throw new Error(`Recovery phrase must contain exactly 24 words; received ${phrase.length}. Use --phrase-file or --phrase-stdin.`);
@@ -17931,7 +18403,7 @@ function projectFromCheckout(options) {
   try {
     return loadConfig({
       cwd: options.projectRoot,
-      readFile: (path) => existsSync11(path) ? readFileSync14(path, "utf8") : undefined
+      readFile: (path) => existsSync12(path) ? readFileSync15(path, "utf8") : undefined
     }).config.project;
   } catch (cause) {
     throw new Error(`No --project was given and the checkout has no usable .fz/config.json: ${cause instanceof Error ? cause.message : String(cause)}`);
@@ -17964,10 +18436,10 @@ async function waitForRuns(options, pipelineKey, keys) {
   while (Date.now() < deadline) {
     const payload = await deploymentRequest(options, `/runs?pipelineKey=${encodeURIComponent(pipelineKey)}`);
     const runs = payload.runs ?? [];
-    const selected = runs.filter((run) => run._key && keys.includes(run._key));
-    if (selected.length === keys.length && selected.every((run) => terminal.has(run.outcome ?? ""))) {
-      out.line(JSON.stringify({ ok: selected.every((run) => run.outcome === "deployed"), runs: selected }, null, 2));
-      return selected.every((run) => run.outcome === "deployed");
+    const selected = runs.filter((run2) => run2._key && keys.includes(run2._key));
+    if (selected.length === keys.length && selected.every((run2) => terminal.has(run2.outcome ?? ""))) {
+      out.line(JSON.stringify({ ok: selected.every((run2) => run2.outcome === "deployed"), runs: selected }, null, 2));
+      return selected.every((run2) => run2.outcome === "deployed");
     }
     await sleep(2000);
   }
@@ -17994,7 +18466,7 @@ async function cmdDeploy(options, args) {
           out.ok(`Initialized legacy .fz/deploy.json (${created.summary.digest}).`);
         return 0;
       }
-      initializeTypeScriptDeployment(options.projectRoot, { name: options.projectName ?? basename3(resolve9(options.projectRoot)), force: options.force });
+      initializeTypeScriptDeployment(options.projectRoot, { name: options.projectName ?? basename3(resolve11(options.projectRoot)), force: options.force });
       const compiled = await compileDeploymentProject(options.projectRoot);
       if (options.json)
         out.line(JSON.stringify({ source: compiled.source, output: compiled.output, digest: compiled.digest }, null, 2));
@@ -18019,7 +18491,7 @@ async function cmdDeploy(options, args) {
       return problems.length === 0 ? 0 : 1;
     }
     if (operation === "check" || operation === "sync") {
-      if (existsSync11(resolve9(options.projectRoot, DEPLOY_SOURCE_FILE))) {
+      if (existsSync12(resolve11(options.projectRoot, DEPLOY_SOURCE_FILE))) {
         const expected = await compileDeploymentProject(options.projectRoot, { write: false });
         const actual = inspectCompiledDeployment(options.projectRoot);
         const current = canonicalJson(expected.plan) === canonicalJson(actual.plan);
@@ -18095,7 +18567,7 @@ async function cmdDeploy(options, args) {
         branch: options.branch,
         cloneUrl: required(options.cloneUrl, "--clone-url"),
         sourceAuth,
-        ...options.knownHostsFile ? { knownHosts: readFileSync14(options.knownHostsFile, "utf8") } : {},
+        ...options.knownHostsFile ? { knownHosts: readFileSync15(options.knownHostsFile, "utf8") } : {},
         projectKey
       } });
       const pipelineKey2 = String(created.pipelineKey);
@@ -18135,7 +18607,7 @@ async function cmdDeploy(options, args) {
         out.line(JSON.stringify(released, null, 2));
         return 0;
       }
-      const keys = (released.runs ?? []).flatMap((run) => run._key ? [run._key] : []);
+      const keys = (released.runs ?? []).flatMap((run2) => run2._key ? [run2._key] : []);
       if (keys.length === 0)
         throw new Error("The API accepted the release but returned no deployment runs.");
       return await waitForRuns(options, pipelineKey, keys) ? 0 : 1;
@@ -18191,15 +18663,18 @@ function usage() {
     fz agent install        Install the node agent as a systemd service, so
                             applications on this box read secrets through a
                             local socket instead of holding an API key
-	 fz bootstrap platform prepare
-	                         Generate the machine deploy key before private Git deployment
-	 fz bootstrap platform remote <prepare|apply|status>
+	 fz bootstrap platform bundle
+	                         Build one clean exact-revision API Git bundle for genesis
+	 fz bootstrap platform remote <apply|status>
 	                         Run typed bootstrap from the operator laptop through
-	                         a pinned host and caller-approved SSH agent
+	                         a pinned host; apply copies and verifies that bundle
+	 fz bootstrap platform fleet <apply|status>
+	                         Validate the exact three-node genesis identity, prompt
+	                         shared secrets once and run all pinned nodes concurrently
 	 fz bootstrap platform   Install/repair a typed elastic platform compute
 	 fz bootstrap config <metal|platform|cloudflare>
-	                         Write a validated owner-only metal/Cloudflare file or
-	                         strict three-node platform genesis directory; never apply locally
+	                         Write validated owner-only metal config+remote request,
+	                         Cloudflare file, or complete three-node platform request set
 	 fz bootstrap platform cloudflare
 	                         Plan/apply attended Tunnel and DNS reconciliation
 	                         using hidden management and KV/Worker runtime token prompts