@mycadet/cli 0.12.9-dev.202610142154.883240 → 0.12.9-dev.202610151822.dbac7cb

package/node_modules/@mycadet/assistant-api/node_modules/@mycadet/service-contracts/src/__tests__/ingress.test.ts

@@ -28,10 +28,10 @@ describe("tunnelHostForCloudHost", () => {
 
   test("maps env-prefixed platform hosts to their env tunnel", () => {
     expect(tunnelHostForCloudHost("staging-cloud.mycadet.ai")).toBe(
-      "tunnel-staging.mycadet.ai",
+      "staging-tunnel.mycadet.ai",
     );
     expect(tunnelHostForCloudHost("dev-cloud.mycadet.ai")).toBe(
-      "tunnel-dev.mycadet.ai",
+      "dev-tunnel.mycadet.ai",
     );
   });
 

package/node_modules/@mycadet/assistant-api/node_modules/@mycadet/service-contracts/src/ingress.ts

@@ -1,7 +1,7 @@
 /**
  * Map a Cadet Cloud host onto its environment's tunnel host, following the
  * deployment naming convention (`cloud.mycadet.ai` → `tunnel.mycadet.ai`,
- * `{env}-cloud.mycadet.ai` → `tunnel-{env}.mycadet.ai`). Returns null for
+ * `{env}-cloud.mycadet.ai` → `{env}-tunnel.mycadet.ai`). Returns null for
  * hosts outside that convention (localhost, custom domains). Shared by the
  * gateway speech relay and the web live-voice client so the two ends of the
  * cloud-speech transport can't drift.
@@ -11,7 +11,7 @@ export function tunnelHostForCloudHost(host: string): string | null {
     return "tunnel.mycadet.ai";
   }
   const match = /^([a-z0-9-]+)-cloud\.mycadet\.ai$/.exec(host);
-  return match ? `tunnel-${match[1]}.mycadet.ai` : null;
+  return match ? `${match[1]}-tunnel.mycadet.ai` : null;
 }
 
 export function normalizePublicBaseUrl(value: unknown): string | undefined {

package/node_modules/@mycadet/local-mode/node_modules/@mycadet/service-contracts/src/__tests__/ingress.test.ts

@@ -28,10 +28,10 @@ describe("tunnelHostForCloudHost", () => {
 
   test("maps env-prefixed platform hosts to their env tunnel", () => {
     expect(tunnelHostForCloudHost("staging-cloud.mycadet.ai")).toBe(
-      "tunnel-staging.mycadet.ai",
+      "staging-tunnel.mycadet.ai",
     );
     expect(tunnelHostForCloudHost("dev-cloud.mycadet.ai")).toBe(
-      "tunnel-dev.mycadet.ai",
+      "dev-tunnel.mycadet.ai",
     );
   });
 

package/node_modules/@mycadet/local-mode/node_modules/@mycadet/service-contracts/src/ingress.ts

@@ -1,7 +1,7 @@
 /**
  * Map a Cadet Cloud host onto its environment's tunnel host, following the
  * deployment naming convention (`cloud.mycadet.ai` → `tunnel.mycadet.ai`,
- * `{env}-cloud.mycadet.ai` → `tunnel-{env}.mycadet.ai`). Returns null for
+ * `{env}-cloud.mycadet.ai` → `{env}-tunnel.mycadet.ai`). Returns null for
  * hosts outside that convention (localhost, custom domains). Shared by the
  * gateway speech relay and the web live-voice client so the two ends of the
  * cloud-speech transport can't drift.
@@ -11,7 +11,7 @@ export function tunnelHostForCloudHost(host: string): string | null {
     return "tunnel.mycadet.ai";
   }
   const match = /^([a-z0-9-]+)-cloud\.mycadet\.ai$/.exec(host);
-  return match ? `tunnel-${match[1]}.mycadet.ai` : null;
+  return match ? `${match[1]}-tunnel.mycadet.ai` : null;
 }
 
 export function normalizePublicBaseUrl(value: unknown): string | undefined {

package/node_modules/@mycadet/service-contracts/src/__tests__/ingress.test.ts

@@ -28,10 +28,10 @@ describe("tunnelHostForCloudHost", () => {
 
   test("maps env-prefixed platform hosts to their env tunnel", () => {
     expect(tunnelHostForCloudHost("staging-cloud.mycadet.ai")).toBe(
-      "tunnel-staging.mycadet.ai",
+      "staging-tunnel.mycadet.ai",
     );
     expect(tunnelHostForCloudHost("dev-cloud.mycadet.ai")).toBe(
-      "tunnel-dev.mycadet.ai",
+      "dev-tunnel.mycadet.ai",
     );
   });
 

package/node_modules/@mycadet/service-contracts/src/ingress.ts

@@ -1,7 +1,7 @@
 /**
  * Map a Cadet Cloud host onto its environment's tunnel host, following the
  * deployment naming convention (`cloud.mycadet.ai` → `tunnel.mycadet.ai`,
- * `{env}-cloud.mycadet.ai` → `tunnel-{env}.mycadet.ai`). Returns null for
+ * `{env}-cloud.mycadet.ai` → `{env}-tunnel.mycadet.ai`). Returns null for
  * hosts outside that convention (localhost, custom domains). Shared by the
  * gateway speech relay and the web live-voice client so the two ends of the
  * cloud-speech transport can't drift.
@@ -11,7 +11,7 @@ export function tunnelHostForCloudHost(host: string): string | null {
     return "tunnel.mycadet.ai";
   }
   const match = /^([a-z0-9-]+)-cloud\.mycadet\.ai$/.exec(host);
-  return match ? `tunnel-${match[1]}.mycadet.ai` : null;
+  return match ? `${match[1]}-tunnel.mycadet.ai` : null;
 }
 
 export function normalizePublicBaseUrl(value: unknown): string | undefined {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mycadet/cli",
-  "version": "0.12.9-dev.202610142154.0883240",
+  "version": "0.12.9-dev.202610151822.dbac7cb",
   "description": "CLI tools for mycadet",
   "type": "module",
   "exports": {

package/src/__tests__/assistant-client-cloud-auth.test.ts

@@ -1,5 +1,5 @@
 /**
- * Tests for AssistantClient's cloud-managed (`cloud: "cadet"`) auth path.
+ * Tests for AssistantClient's cloud-managed (`cloud: "cloud"`) auth path.
  * These entries have no guardian token on disk, so the client must authenticate
  * with the stored platform credential instead of sending an anonymous request
  * (which the cloud answers with a bare 403).
@@ -38,7 +38,7 @@ function seedCloud(token?: string): void {
     assistantId: ASSISTANT_ID,
     name: "Credence",
     runtimeUrl: PLATFORM_URL,
-    cloud: "cadet",
+    cloud: "cloud",
   });
   if (token) {
     saveCloudToken(token);

package/src/__tests__/backup.test.ts

@@ -79,7 +79,7 @@ for (const topology of ["local", "docker"] as const) {
 test("cloud backup calls the cloud backup API with session authentication", async () => {
   const entry: config.AssistantEntry = {
     assistantId: "cloud-test",
-    cloud: "cadet",
+    cloud: "cloud",
     runtimeUrl: "https://cloud.mycadet.ai",
   };
   lookup.mockReturnValue(entry);

package/src/__tests__/debug.test.ts

@@ -18,7 +18,6 @@ process.env.CADET_LOCKFILE_DIR = testDir;
 
 import * as assistantConfig from "../lib/assistant-config.js";
 import * as guardianToken from "../lib/guardian-token.js";
-import * as localRuntimeClient from "../lib/local-runtime-client.js";
 import * as cloudClient from "../lib/cloud-client.js";
 import { withPreconnect } from "./helpers/http.js";
 import { makeGuardianTokenData } from "./helpers/guardian-token.js";
@@ -29,26 +28,9 @@ const resolveTargetMock = spyOn(
 ).mockImplementation(() => {
   throw new Error("process.exit:1");
 });
-const readCloudTokenMock = spyOn(
-  cloudClient,
-  "readCloudToken",
-).mockReturnValue("platform-token");
-const exportMock = spyOn(
-  localRuntimeClient,
-  "localRuntimeExportToGcs",
-).mockResolvedValue({ jobId: "job-1" });
-const identityMock = spyOn(
-  localRuntimeClient,
-  "localRuntimeIdentity",
-).mockResolvedValue({ version: "0.12.3" });
-const pollMock = spyOn(
-  localRuntimeClient,
-  "localRuntimePollJobStatus",
-).mockResolvedValue({
-  jobId: "job-1",
-  type: "export",
-  status: "complete",
-});
+const readCloudTokenMock = spyOn(cloudClient, "readCloudToken").mockReturnValue(
+  "platform-token",
+);
 const loadGuardianTokenSpy = spyOn(
   guardianToken,
   "loadGuardianToken",
@@ -109,13 +91,9 @@ beforeEach(() => {
   );
   resolveTargetMock.mockReset();
   resolveTargetMock.mockReturnValue(LOCAL_ENTRY);
-  identityMock.mockReset();
-  identityMock.mockResolvedValue({ version: "0.12.3" });
   leaseGuardianTokenSpy.mockClear();
   readCloudTokenMock.mockReset();
   readCloudTokenMock.mockReturnValue("platform-token");
-  exportMock.mockClear();
-  pollMock.mockClear();
 });
 
 afterEach(() => {
@@ -125,40 +103,29 @@ afterEach(() => {
 
 afterAll(() => {
   resolveTargetMock.mockRestore();
-  identityMock.mockRestore();
   leaseGuardianTokenSpy.mockRestore();
   readCloudTokenMock.mockRestore();
-  exportMock.mockRestore();
-  pollMock.mockRestore();
   loadGuardianTokenSpy.mockRestore();
   rmSync(testDir, { recursive: true, force: true });
 });
 
 describe("cadet debug", () => {
-  test("mints the URL on the cloud, exports with the debug profile, and waits", async () => {
+  test("requests sanitized logs and uploads them without runtime export jobs", async () => {
     await debug();
-
-    expect(fetchCalls).toHaveLength(1);
-    expect(fetchCalls[0].url).toBe(
+    expect(fetchCalls.map((call) => call.url)).toEqual([
       "https://cloud.mycadet.ai/v1/assistants/11111111-2222-3333-4444-555555555555/debug-bundle-upload-url/",
+      "http://127.0.0.1:7821/v1/logs/export",
+      "https://storage.googleapis.com/b/signed",
+    ]);
+    expect(fetchCalls[1].init?.method).toBe("POST");
+    expect(new Headers(fetchCalls[1].init?.headers).get("Authorization")).toBe(
+      "Bearer local-token",
     );
-    expect(fetchCalls[0].init?.method).toBe("POST");
-    expect(
-      new Headers(fetchCalls[0].init?.headers).get("Cadet-Organization-Id"),
-    ).toBe("org-1");
-
-    expect(exportMock).toHaveBeenCalledTimes(1);
-    const [entry, token, params] = exportMock.mock.calls[0];
-    expect(entry).toBe(LOCAL_ENTRY);
-    expect(token).toBe("local-token");
-    expect(params).toEqual({
-      uploadUrl: "https://storage.googleapis.com/b/signed",
-      description: "debug bundle for Cadet staff",
-      profile: "debug",
-    });
-    expect(pollMock).toHaveBeenCalled();
-    // The daemon was checked for the debug profile before the cloud call.
-    expect(identityMock).toHaveBeenCalledTimes(1);
+    expect(fetchCalls[2].init?.method).toBe("PUT");
+    expect(new Headers(fetchCalls[2].init?.headers).has("Authorization")).toBe(
+      false,
+    );
+    expect(fetchCalls[2].init?.body).toBeInstanceOf(Blob);
   });
 
   test("passes an unquoted multi-word display name through to the shared resolver", async () => {
@@ -167,46 +134,6 @@ describe("cadet debug", () => {
     expect(resolveTargetMock).toHaveBeenCalledWith("Support Bot");
   });
 
-  test("refuses a daemon older than the debug profile before any URL is minted", async () => {
-    // Such a daemon strips `profile` and would upload the owner's
-    // credentials to the staff bucket.
-    identityMock.mockResolvedValue({ version: "0.12.2" });
-    const errors: string[] = [];
-    const errorSpy = spyOn(console, "error").mockImplementation((msg) => {
-      errors.push(String(msg));
-    });
-    try {
-      await expect(debug()).rejects.toThrow("process.exit:1");
-    } finally {
-      errorSpy.mockRestore();
-    }
-    expect(errors.join("\n")).toContain("0.12.3");
-    expect(fetchCalls).toHaveLength(0);
-    expect(exportMock).not.toHaveBeenCalled();
-  });
-
-  test("re-leases the guardian token when the daemon answers 401 mid-poll", async () => {
-    pollMock.mockReset();
-    let polls = 0;
-    pollMock.mockImplementation(async (_entry, token) => {
-      polls += 1;
-      if (polls === 1) {
-        throw new Error("Local job status check failed: 401 Unauthorized");
-      }
-      expect(token).toBe("leased-token");
-      return {
-        jobId: "job-1",
-        type: "export",
-        status: "complete",
-      };
-    });
-
-    await debug();
-
-    expect(leaseGuardianTokenSpy).toHaveBeenCalledTimes(1);
-    expect(polls).toBe(2);
-  });
-
   test("explains what to turn on when the cloud refuses", async () => {
     uploadUrlStatus = 403;
     const errors: string[] = [];
@@ -219,13 +146,12 @@ describe("cadet debug", () => {
       errorSpy.mockRestore();
     }
     expect(errors.join("\n")).toContain("Allow Staff Access");
-    expect(exportMock).not.toHaveBeenCalled();
   });
 
   test("refuses a Cadet-hosted assistant, which needs no bundle", async () => {
     resolveTargetMock.mockReturnValue({
       ...LOCAL_ENTRY,
-      cloud: "cadet",
+      cloud: "cloud",
     });
     const errorSpy = spyOn(console, "error").mockImplementation(() => {});
     try {

package/src/__tests__/host-teleport-docker.test.ts

@@ -0,0 +1,371 @@
+import { afterEach, beforeEach, expect, spyOn, test } from "bun:test";
+import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import * as tar from "tar";
+import {
+  restoreHostTeleportTarget,
+  TeleportRecoveryError,
+} from "../lib/host-teleport.js";
+import { dockerResourceNames } from "../lib/docker.js";
+import { DOCKER_STATEFUL_SET_SPEC } from "../lib/statefulset.js";
+import { packRoot, STATE_ROOTS } from "../lib/root-backup.js";
+import type { AssistantEntry } from "../lib/assistant-config.js";
+import { mockCommands } from "./commands-mock.js";
+
+const entry: AssistantEntry = {
+  assistantId: "destination",
+  cloud: "docker",
+  runtimeUrl: "http://localhost:7830",
+  containerInfo: {
+    assistantImage: "image-assistant",
+    gatewayImage: "image-gateway",
+    cesImage: "image-ces",
+    assistantPort: 7821,
+  },
+};
+const names = dockerResourceNames(entry.assistantId);
+const containers = {
+  assistant: names.assistantContainer,
+  gateway: names.gatewayContainer,
+  "credential-executor": names.cesContainer,
+};
+const services: Array<keyof typeof containers> = ["assistant", "gateway", "credential-executor"];
+const rootContainer = {
+  workspace: names.assistantContainer,
+  "gateway-security": names.gatewayContainer,
+  "ces-security": names.cesContainer,
+  "ces-data": names.cesContainer,
+};
+let directory: string, archive: string, recovery: string;
+let commands: ReturnType<typeof mockCommands>;
+let log: ReturnType<typeof spyOn>;
+let failReadiness: boolean, failEveryWrite: boolean, writes: number;
+let states: Map<string, ReturnType<typeof inspection>>;
+function inspection(service: keyof typeof containers) {
+  const spec = DOCKER_STATEFUL_SET_SPEC.containers.find(
+    (item) => item.internalName === service,
+  )!;
+  return {
+    Id: `${service}-id`,
+    Image: `image-${service}`,
+    State: { Status: "exited", Running: false },
+    Config: {
+      User: "1001:1001",
+      Env: [
+        "ACTOR_TOKEN_SIGNING_KEY=" + "07".repeat(32),
+        "CES_SERVICE_TOKEN=internal-test-token",
+        "RUNTIME_HTTP_PORT=7821",
+        "GATEWAY_PORT=7830",
+        "GUARDIAN_BOOTSTRAP_SECRET=bootstrap-test-secret",
+      ],
+    },
+    HostConfig: {
+      NetworkMode:
+        service === "assistant" ? names.network : "container:assistant-id",
+    },
+    Mounts: spec.volumeMounts.map((mount) => ({
+      Type: "volume",
+      Name: DOCKER_STATEFUL_SET_SPEC.volumeClaimTemplates
+        .find((volume) => volume.name === mount.volumeName)!
+        .dockerVolume(entry.assistantId),
+      Source: "/remote/volume",
+      Destination: mount.mountPath,
+      RW: !mount.readOnly,
+    })),
+  };
+}
+const previousDataHome = process.env.XDG_DATA_HOME;
+beforeEach(async () => {
+  directory = await mkdtemp(join(tmpdir(), "teleport-docker-"));
+  process.env.XDG_DATA_HOME = directory;
+  archive = join(directory, "source.tar.gz");
+  recovery = join(directory, "recovery.tar.gz");
+  for (const flavor of ["source", "original", "volumes"]) {
+    for (const root of STATE_ROOTS) {
+      await mkdir(join(directory, flavor, root), { recursive: true });
+      await writeFile(
+        join(directory, flavor, root, "value"),
+        flavor === "volumes" ? "original" : flavor,
+        { mode: 0o600 },
+      );
+    }
+    await writeFile(
+      join(directory, flavor, "gateway-security", "actor-token-signing-key"),
+      Buffer.alloc(32, flavor === "source" ? 9 : 7),
+    );
+    await writeFile(
+      join(directory, flavor, "ces-security", "keys.enc"),
+      flavor === "source" ? "source ciphertext" : "original ciphertext",
+      { mode: 0o600 },
+    );
+  }
+  await packRoot(join(directory, "source"), archive);
+  await packRoot(join(directory, "original"), recovery);
+  states = new Map(
+    services.map((service) => [
+      containers[service],
+      inspection(service),
+    ]),
+  );
+  failReadiness = false;
+  failEveryWrite = false;
+  writes = 0;
+  log = spyOn(console, "log").mockImplementation(() => {});
+  commands = mockCommands();
+  commands.on(
+    "docker",
+    (args) => args[0] === "inspect",
+    ({ args }) => {
+      const state = states.get(args.at(-1)!);
+      if (!state) {
+        return { code: 1, stderr: "No such container" };
+      }
+      if (args.includes("--format")) {
+        return {
+          stdout:
+            args[2] === "{{.State.Status}}"
+              ? state.State.Status
+              : String(state.State.Running),
+        };
+      }
+      return { stdout: JSON.stringify([state]) };
+    },
+  );
+  commands.on(
+    "docker",
+    (args) => args[0] === "rm",
+    ({ args }) => {
+      const state = states.get(args[1]!);
+      if (!state) {
+        return { code: 1, stderr: "No such container" };
+      }
+      expect(state.State.Running).toBe(false);
+      states.delete(args[1]!);
+      return {};
+    },
+  );
+  commands.on(
+    "docker",
+    (args) => args[0] === "create",
+    ({ args }) => {
+      const container = args[args.indexOf("--name") + 1]!;
+      const service = services.find((service) => containers[service] === container)!;
+      const state = inspection(service);
+      state.Config.Env = args.flatMap((value, index) =>
+        value === "-e" ? [args[index + 1]!] : [],
+      );
+      states.set(container, state);
+      return {};
+    },
+  );
+  commands.on(
+    "docker",
+    (args) => args[0] === "start",
+    ({ args }) => {
+      const state = states.get(args[1]!)!;
+      state.State.Running = true;
+      state.State.Status = "running";
+      return {};
+    },
+  );
+  commands.on(
+    "docker",
+    (args) => args[0] === "kill",
+    ({ args }) => {
+      expect(args[1]).toBe("--signal=SIGTERM");
+      const state = states.get(args.at(-1)!)!;
+      state.State.Running = false;
+      state.State.Status = "exited";
+      return {};
+    },
+  );
+  commands.on(
+    "docker",
+    (args) => args[0] === "cp",
+    async ({ args }) => {
+      const root = STATE_ROOTS.find((root) => args[1]!.includes(`:/${root}/`))!;
+      expect(
+        states.get(rootContainer[root])!.State
+          .Running,
+      ).toBe(false);
+      await cp(join(directory, "volumes", root), args[2]!, { recursive: true });
+      return {};
+    },
+  );
+  commands.on(
+    "docker",
+    (args) => args[0] === "run" && args.includes("-i"),
+    async ({ args, input }) => {
+      const mount = args[args.indexOf("--mount") + 1]!;
+      const root = STATE_ROOTS.find(
+        (root) =>
+          states
+            .get(rootContainer[root])!
+            .Mounts.find((item) => item.Destination === `/${root}`)?.Name ===
+          mount.split("src=")[1]!.split(",")[0]!,
+      )!;
+      expect([...states.values()].every((state) => !state.State.Running)).toBe(
+        true,
+      );
+      expect(args).toContain("--network=none");
+      expect(args).toContain("--user=0");
+      expect(args).toContain("1001:1001");
+      expect(args[args.indexOf("-ec") + 1]).toContain('chown -R "$1" /restore');
+      writes++;
+      if (failEveryWrite) {
+        return { code: 1, stderr: "injected volume write failure" };
+      }
+      const rootDir = join(directory, "volumes", root);
+      await rm(rootDir, { recursive: true });
+      await mkdir(rootDir);
+      await pipeline(
+        Readable.from([input]),
+        tar.x({ cwd: rootDir, preserveOwner: false }),
+      );
+      return {};
+    },
+  );
+  commands.on(
+    "docker",
+    (args) => args[0] === "exec",
+    () =>
+      failReadiness
+        ? { code: 2, stdout: "migration_failed", stderr: "migration_failed" }
+        : { stdout: "ready" },
+  );
+});
+afterEach(async () => {
+  if (previousDataHome === undefined) {
+    delete process.env.XDG_DATA_HOME;
+  } else {
+    process.env.XDG_DATA_HOME = previousDataHome;
+  }
+  commands.restore();
+  log.mockRestore();
+  await rm(directory, { recursive: true, force: true });
+});
+
+test("recreates immutable identity overrides and imports all roots before first start", async () => {
+  await restoreHostTeleportTarget(entry, archive, recovery);
+  for (const root of STATE_ROOTS) {
+    expect(
+      await readFile(join(directory, "volumes", root, "value"), "utf8"),
+    ).toBe("source");
+  }
+  expect(
+    await readFile(
+      join(directory, "volumes", "ces-security", "keys.enc"),
+      "utf8",
+    ),
+  ).toBe("source ciphertext");
+  expect(
+    await readFile(
+      join(directory, "volumes", "gateway-security", "actor-token-signing-key"),
+    ),
+  ).toEqual(Buffer.alloc(32, 9));
+  expect(
+    [...states.values()].every(
+      (state) =>
+        !state.Config.Env.some((value) =>
+          value.startsWith("ACTOR_TOKEN_SIGNING_KEY="),
+        ),
+    ),
+  ).toBe(true);
+  const firstStart = commands.calls.findIndex(
+    (request) => request.args[0] === "start",
+  );
+  const installs = commands.calls
+    .map((request, index) => ({ request, index }))
+    .filter(
+      ({ request }) => request.args[0] === "run" && request.args.includes("-i"),
+    );
+  expect(installs).toHaveLength(4);
+  expect(installs.every(({ index }) => index < firstStart)).toBe(true);
+});
+test("readiness failure restores original ciphertext, gateway identity, and stopped containers", async () => {
+  failReadiness = true;
+  await expect(
+    restoreHostTeleportTarget(entry, archive, recovery),
+  ).rejects.toThrow("did not become ready");
+  for (const root of STATE_ROOTS) {
+    expect(
+      await readFile(join(directory, "volumes", root, "value"), "utf8"),
+    ).toBe("original");
+  }
+  expect(
+    await readFile(
+      join(directory, "volumes", "ces-security", "keys.enc"),
+      "utf8",
+    ),
+  ).toBe("original ciphertext");
+  expect([...states.values()].every((state) => !state.State.Running)).toBe(
+    true,
+  );
+  expect(states.get(names.gatewayContainer)!.Config.Env).toContain(
+    "ACTOR_TOKEN_SIGNING_KEY=" + "07".repeat(32),
+  );
+});
+test("unrecoverable writes leave services stopped and report the retained recovery tar", async () => {
+  failEveryWrite = true;
+  await expect(
+    restoreHostTeleportTarget(entry, archive, recovery),
+  ).rejects.toBeInstanceOf(TeleportRecoveryError);
+  expect([...states.values()].every((state) => !state.State.Running)).toBe(
+    true,
+  );
+  expect(writes).toBeGreaterThan(1);
+});
+test("customized persistent mounts are rejected before container removal or volume writes", async () => {
+  states.get(names.cesContainer)!.Mounts[0]!.Name = "custom-security";
+  await expect(
+    restoreHostTeleportTarget(entry, archive, recovery),
+  ).rejects.toThrow("customized Docker mounts");
+  expect(commands.calls.some((request) => request.args[0] === "rm")).toBe(
+    false,
+  );
+  expect(writes).toBe(0);
+});
+test("legacy vbundle is rejected before touching destination containers", async () => {
+  await expect(
+    restoreHostTeleportTarget(
+      entry,
+      join(directory, "legacy.vbundle"),
+      recovery,
+    ),
+  ).rejects.toThrow("vellum-to-cadet");
+  expect(commands.calls).toHaveLength(0);
+});
+
+test("reads the remote Docker runtime version through in-container health instead of host ports", async () => {
+  const { readHostRuntimeVersion } = await import("../lib/host-teleport.js");
+  commands.on(
+    "docker",
+    (args) => args[0] === "exec" && args.at(-1)?.endsWith("/healthz") === true,
+    ({ args }) => {
+      expect(args[1]).toBe(names.gatewayContainer);
+      expect(args.at(-1)).toBe("http://127.0.0.1:7830/healthz");
+      return { stdout: JSON.stringify({ version: "0.12.9" }) };
+    },
+  );
+  expect(await readHostRuntimeVersion(entry)).toBe("0.12.9");
+});
+
+test("sleeping remote Docker runtime uses its recorded image tag for the version guard", async () => {
+  const { readHostRuntimeVersion } = await import("../lib/host-teleport.js");
+  commands.on("docker", (args) => args[0] === "exec", {
+    code: 1,
+    stderr: "container is stopped",
+  });
+  expect(
+    await readHostRuntimeVersion({
+      ...entry,
+      containerInfo: {
+        ...entry.containerInfo!,
+        gatewayImage: "mycadet/gateway:0.12.8",
+      },
+    }),
+  ).toBe("0.12.8");
+});