@mycadet/cli 0.12.6-dev.202610082233.54244ee → 0.12.7

package/src/__tests__/recover.test.ts

@@ -1,3 +1,4 @@
+import { resolveLockfilePaths } from "@mycadet/local-mode";
 import {
   afterAll,
   afterEach,
@@ -14,9 +15,11 @@ import {
   mkdirSync,
   mkdtempSync,
   rmSync,
+  readFileSync,
   writeFileSync,
 } from "node:fs";
-import { tmpdir } from "node:os";
+import { homedir, tmpdir } from "node:os";
+import * as osModule from "node:os";
 import { basename, join } from "node:path";
 
 import type { AssistantEntry } from "../lib/assistant-config.js";
@@ -35,7 +38,9 @@ const realExec = stepRunnerModule.exec;
 
 // Prevent real daemon / gateway / CES from starting
 const startLocalDaemonMock = mock(async () => {});
-const startGatewayMock = mock(async () => {});
+const startGatewayMock = mock<typeof localModule.startGateway>(
+  async () => "http://127.0.0.1:7831",
+);
 const startCesMock = mock(async () => {});
 
 // Capture exec calls without running real tar
@@ -73,12 +78,14 @@ function makeEntry(assistantId: string, instanceDir: string): AssistantEntry {
     assistantId,
     runtimeUrl: "http://127.0.0.1:7831",
     cloud: "local",
+    guardianBootstrapSecret: "existing-bootstrap",
     resources: {
       instanceDir,
       daemonPort: 7801,
       gatewayPort: 7831,
       qdrantPort: 6334,
       cesPort: 7790,
+      signingKey: "ab".repeat(32),
     },
   };
 }
@@ -106,18 +113,21 @@ function writeArchiveFixtures(
   return { archivePath, metadataPath, extractedPath };
 }
 
+let homeSpy: ReturnType<typeof spyOn>;
 let consoleLogSpy: ReturnType<typeof spyOn>;
 let consoleErrorSpy: ReturnType<typeof spyOn>;
 let exitSpy: ReturnType<typeof spyOn>;
 
 beforeEach(() => {
+  homeSpy = spyOn(osModule, "homedir").mockReturnValue(join(testDir, "home"));
+  mkdirSync(homedir(), { recursive: true });
   // Route lockfile and retired archives to the temp directory
   process.env.CADET_LOCKFILE_DIR = testDir;
   process.env.XDG_DATA_HOME = testDir;
   // Write an empty lockfile so saveAssistantEntry has a dir to write to
   mkdirSync(testDir, { recursive: true });
   writeFileSync(
-    join(testDir, ".cadet.lock.json"),
+    resolveLockfilePaths(process.env)[0]!,
     JSON.stringify({ assistants: [] }) + "\n",
   );
 
@@ -134,6 +144,7 @@ beforeEach(() => {
 });
 
 afterEach(() => {
+  homeSpy.mockRestore();
   process.argv = [...originalArgv];
   process.env.CADET_LOCKFILE_DIR = originalLockfileDir;
   process.env.XDG_DATA_HOME = originalXdgData;
@@ -176,6 +187,83 @@ describe("recover --help", () => {
 });
 
 describe("recover error cases", () => {
+  for (const failure of ["missing", "conflict"] as const) {
+    test(`recovery ${failure} leaves destination and registry untouched and permits retry`, async () => {
+      const name = `retry-${failure}`;
+      const instanceDir = join(testDir, "cadet", "assistants", name);
+      const entry = makeEntry(name, instanceDir);
+      delete entry.resources!.signingKey;
+      const { archivePath, metadataPath, extractedPath } = writeArchiveFixtures(
+        name,
+        entry,
+      );
+      if (failure === "conflict") {
+        for (const [dir, hex] of [
+          ["gateway-security", "ab"],
+          ["workspace/deprecated", "cd"],
+        ]) {
+          mkdirSync(join(extractedPath, dir!), { recursive: true });
+          writeFileSync(
+            join(extractedPath, dir!, "actor-token-signing-key"),
+            Buffer.from(hex!.repeat(32), "hex"),
+          );
+        }
+      }
+      const registry = resolveLockfilePaths(process.env)[0]!;
+      const before = readFileSync(registry, "utf8");
+      process.argv = ["bun", "cadet", "recover", name];
+      await expect(recover()).rejects.toThrow(`signing key ${failure}`);
+      expect(existsSync(instanceDir)).toBe(false);
+      expect(readFileSync(registry, "utf8")).toBe(before);
+      expect(existsSync(archivePath)).toBe(true);
+      expect(existsSync(metadataPath)).toBe(true);
+      expect(startLocalDaemonMock).not.toHaveBeenCalled();
+      expect(startGatewayMock).not.toHaveBeenCalled();
+      // Restore the authoritative identity in the archive metadata and retry.
+      entry.resources!.signingKey = "ab".repeat(32);
+      writeFileSync(metadataPath, JSON.stringify(entry));
+      await recover();
+      expect(existsSync(instanceDir)).toBe(true);
+      expect(existsSync(archivePath)).toBe(false);
+      expect(startGatewayMock).toHaveBeenCalledTimes(1);
+      rmSync(instanceDir, { recursive: true, force: true });
+    });
+  }
+
+  test("recovers an archived legacy identity from staging", async () => {
+    const name = "legacy-staged";
+    const entry = makeEntry(name, join(testDir, "cadet", "assistants", name));
+    delete entry.resources!.signingKey;
+    const { extractedPath } = writeArchiveFixtures(name, entry);
+    const dir = join(extractedPath, "workspace", "deprecated");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "actor-token-signing-key"),
+      Buffer.from("cd".repeat(32), "hex"),
+    );
+    process.argv = ["bun", "cadet", "recover", name];
+    await recover();
+    expect(startGatewayMock).toHaveBeenCalledWith(
+      false,
+      expect.objectContaining({ signingKey: "cd".repeat(32) }),
+      { signingKey: "cd".repeat(32), bootstrapSecret: "existing-bootstrap" },
+    );
+    rmSync(entry.resources!.instanceDir, { recursive: true, force: true });
+  });
+
+  test("missing identity preserves the archive and starts no processes", async () => {
+    const name = "missing-key";
+    const entry = makeEntry(name, join(testDir, "cadet", "assistants", name));
+    delete entry.resources!.signingKey;
+    const { archivePath, metadataPath } = writeArchiveFixtures(name, entry);
+    process.argv = ["bun", "cadet", "recover", name];
+    await expect(recover()).rejects.toThrow("signing key missing");
+    expect(existsSync(archivePath)).toBe(true);
+    expect(existsSync(metadataPath)).toBe(true);
+    expect(startLocalDaemonMock).not.toHaveBeenCalled();
+    expect(startGatewayMock).not.toHaveBeenCalled();
+  });
+
   test("exits 1 when no name is given", async () => {
     process.argv = ["bun", "cadet", "recover"];
     await expect(recover()).rejects.toThrow("process.exit(1)");
@@ -253,6 +341,11 @@ describe("recover extraction path — named instance (instanceDir !== homedir())
     // Daemon and gateway were started
     expect(startLocalDaemonMock).toHaveBeenCalledTimes(1);
     expect(startGatewayMock).toHaveBeenCalledTimes(1);
+    expect(startGatewayMock.mock.calls[0]).toEqual([
+      false,
+      expect.objectContaining({ signingKey: "ab".repeat(32) }),
+      { signingKey: "ab".repeat(32), bootstrapSecret: "existing-bootstrap" },
+    ]);
   });
 
   test("creates parent directories of instanceDir when they do not exist", async () => {

package/src/__tests__/retire.test.ts

@@ -111,13 +111,13 @@ function makeEntry(
 function writeLockfile(entries: AssistantEntry[]): void {
   mkdirSync(testDir, { recursive: true });
   writeFileSync(
-    join(testDir, ".cadet.lock.json"),
+    join(testDir, "lockfile.json"),
     JSON.stringify({ assistants: entries }, null, 2) + "\n",
   );
 }
 
 function readLockfile(): string {
-  return readFileSync(join(testDir, ".cadet.lock.json"), "utf-8");
+  return readFileSync(join(testDir, "lockfile.json"), "utf-8");
 }
 
 function setTerminalMode(isTTY: boolean): void {
@@ -168,7 +168,9 @@ describe("cadet retire", () => {
   beforeEach(() => {
     process.env.CADET_LOCKFILE_DIR = testDir;
     delete process.env.CADET_PLATFORM_TOKEN;
-    rmSync(join(testDir, ".cadet.lock.json"), { force: true });
+    for (const name of ["lockfile.json", ".cadet.lock.json", ".cadet.lockfile.json"]) {
+      rmSync(join(testDir, name), { force: true });
+    }
     process.argv = ["bun", "cadet", "retire"];
     process.exit = ((code?: number) => {
       throw new Error(`process.exit:${code}`);

package/src/__tests__/signing-key-continuity.test.ts

@@ -0,0 +1,261 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { createHmac } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+
+import {
+  getLockfileData,
+  resolveExistingLocalSigningKey,
+  upsertRendererLockfileAssistant,
+} from "@mycadet/local-mode";
+
+// wake, upgrade and recover resolve the existing signing identity through
+// @mycadet/local-mode before touching any process. These tests exercise that
+// contract the way the CLI consumes it: host lockfile entries, legacy on-disk
+// key files, and a renderer save in between.
+describe("local signing identity continuity", () => {
+  let instanceDir: string;
+  const key = "ab".repeat(32);
+  const other = "cd".repeat(32);
+  const legacyPaths = () => [
+    join(instanceDir, "gateway-security", "actor-token-signing-key"),
+    join(instanceDir, "workspace", "deprecated", "actor-token-signing-key"),
+  ];
+  function put(file: string, hex: string) {
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, Buffer.from(hex, "hex"), { mode: 0o600 });
+  }
+  beforeEach(() => {
+    instanceDir = mkdtempSync(join(tmpdir(), "signing-continuity-"));
+  });
+  afterEach(() => {
+    rmSync(instanceDir, { recursive: true, force: true });
+  });
+
+  describe("resolveExistingLocalSigningKey", () => {
+    test("loads the persisted key without creating disk copies", () => {
+      expect(
+        resolveExistingLocalSigningKey({
+          instanceDir,
+          signingKey: key.toUpperCase(),
+        }),
+      ).toBe(key);
+      for (const file of legacyPaths()) {
+        expect(existsSync(file)).toBe(false);
+      }
+    });
+    for (const index of [0, 1]) {
+      test(`recovers legacy source ${index} without rewriting it`, () => {
+        put(legacyPaths()[index]!, key);
+        expect(resolveExistingLocalSigningKey({ instanceDir })).toBe(key);
+        expect(readFileSync(legacyPaths()[index]!)).toEqual(
+          Buffer.from(key, "hex"),
+        );
+      });
+    }
+    test("matching legacy sources converge", () => {
+      for (const file of legacyPaths()) {
+        put(file, key);
+      }
+      expect(
+        resolveExistingLocalSigningKey({ instanceDir, signingKey: key }),
+      ).toBe(key);
+    });
+    test("missing state refuses to create an identity", () => {
+      expect(() => resolveExistingLocalSigningKey({ instanceDir })).toThrow(
+        "signing key missing",
+      );
+    });
+    test("malformed persisted state cannot fall back to a different source", () => {
+      put(legacyPaths()[1]!, key);
+      for (const invalid of ["", "short", null, 123, "z".repeat(64)]) {
+        expect(() =>
+          resolveExistingLocalSigningKey({ instanceDir, signingKey: invalid }),
+        ).toThrow("signing key invalid");
+      }
+    });
+    test("the host key remains authoritative over stale legacy copies after repair", () => {
+      put(legacyPaths()[1]!, other);
+      expect(
+        resolveExistingLocalSigningKey({ instanceDir, signingKey: key }),
+      ).toBe(key);
+      expect(readFileSync(legacyPaths()[1]!)).toEqual(
+        Buffer.from(other, "hex"),
+      );
+    });
+    test("conflicting legacy copies refuse even without a persisted key", () => {
+      put(legacyPaths()[0]!, key);
+      put(legacyPaths()[1]!, other);
+      expect(() => resolveExistingLocalSigningKey({ instanceDir })).toThrow(
+        "signing key conflict",
+      );
+    });
+    test("malformed or unreadable legacy storage is not absence", () => {
+      put(legacyPaths()[0]!, "ab");
+      expect(() => resolveExistingLocalSigningKey({ instanceDir })).toThrow(
+        "signing key invalid",
+      );
+      rmSync(legacyPaths()[0]!);
+      mkdirSync(legacyPaths()[0]!);
+      expect(() => resolveExistingLocalSigningKey({ instanceDir })).toThrow(
+        /signing key (invalid|unreadable)/,
+      );
+    });
+    test("a foreign instance cannot supply a key", () => {
+      put(legacyPaths()[1]!, key);
+      expect(() =>
+        resolveExistingLocalSigningKey({
+          instanceDir: join(instanceDir, "other"),
+        }),
+      ).toThrow("signing key missing");
+    });
+  });
+
+  describe("renderer saves preserve host identity", () => {
+    const lockfilePath = () => join(instanceDir, "lockfile.json");
+    function writeOnDisk(value: unknown): void {
+      writeFileSync(lockfilePath(), JSON.stringify(value, null, 2));
+    }
+    function readOnDisk(): Record<string, unknown> {
+      return JSON.parse(readFileSync(lockfilePath(), "utf-8")) as Record<
+        string,
+        unknown
+      >;
+    }
+
+    test("a renderer read/select/save preserves host resources and credentials", () => {
+      const entry = {
+        assistantId: "local-1",
+        cloud: "local",
+        name: "Example Assistant",
+        runtimeUrl: "http://127.0.0.1:7830",
+        guardianBootstrapSecret: "bootstrap-secret",
+        resources: {
+          instanceDir: "/example/instance",
+          gatewayPort: 7830,
+          daemonPort: 7831,
+          signingKey: key,
+          cesPort: 7832,
+          futureHostField: "keep",
+        },
+      };
+      writeOnDisk({ assistants: [entry], activeAssistant: null });
+      const read = getLockfileData([lockfilePath()]);
+      expect(read.ok).toBe(true);
+      if (!read.ok) {
+        throw new Error("fixture read failed");
+      }
+      const view = read.data.assistants[0]!;
+      expect(view.resources).not.toHaveProperty("signingKey");
+      const result = upsertRendererLockfileAssistant(
+        [lockfilePath()],
+        { ...view },
+        "local-1",
+      );
+      expect(result.ok).toBe(true);
+      expect(readOnDisk()).toEqual({
+        assistants: [entry],
+        activeAssistant: "local-1",
+      });
+    });
+
+    test("stale or forged renderer resources cannot replace host state", () => {
+      const entry = {
+        assistantId: "local-1",
+        cloud: "local",
+        guardianBootstrapSecret: "keep",
+        resources: {
+          instanceDir: "/example/current",
+          signingKey: key,
+          gatewayPort: 7830,
+          daemonPort: 7831,
+        },
+      };
+      writeOnDisk({ assistants: [entry], activeAssistant: null });
+      const result = upsertRendererLockfileAssistant(
+        [lockfilePath()],
+        {
+          assistantId: "local-1",
+          name: "Updated",
+          guardianBootstrapSecret: "replace",
+          resources: {
+            instanceDir: "/example/stale",
+            signingKey: other,
+          },
+        },
+        undefined,
+      );
+      expect(result.ok).toBe(true);
+      expect(readOnDisk().assistants).toEqual([{ ...entry, name: "Updated" }]);
+    });
+
+    test("a renderer save refuses an unreadable registry without replacing it", () => {
+      writeFileSync(lockfilePath(), "{ invalid");
+      expect(
+        upsertRendererLockfileAssistant(
+          [lockfilePath()],
+          { assistantId: "local-1" },
+          "local-1",
+        ),
+      ).toMatchObject({ ok: false, status: 409 });
+      expect(readFileSync(lockfilePath(), "utf-8")).toBe("{ invalid");
+    });
+  });
+
+  describe("across desktop saves and wake cycles", () => {
+    test("read/select/save and repeated key loads preserve a retained credential", () => {
+      const registry = join(instanceDir, "registry.json");
+      const payload = "synthetic-retained-credential";
+      const signature = createHmac("sha256", Buffer.from(key, "hex"))
+        .update(payload)
+        .digest("hex");
+      writeFileSync(
+        registry,
+        JSON.stringify({
+          assistants: [
+            {
+              assistantId: "example",
+              cloud: "local",
+              resources: {
+                instanceDir,
+                gatewayPort: 7830,
+                daemonPort: 7831,
+                signingKey: key,
+              },
+            },
+          ],
+        }),
+      );
+      for (let cycle = 0; cycle < 3; cycle++) {
+        const view = getLockfileData([registry]);
+        if (!view.ok) {
+          throw new Error("fixture read failed");
+        }
+        expect(
+          upsertRendererLockfileAssistant(
+            [registry],
+            { ...view.data.assistants[0]! },
+            "example",
+          ).ok,
+        ).toBe(true);
+        const stored = JSON.parse(readFileSync(registry, "utf8"));
+        const restored = resolveExistingLocalSigningKey(
+          stored.assistants[0].resources,
+        );
+        expect(
+          createHmac("sha256", Buffer.from(restored, "hex"))
+            .update(payload)
+            .digest("hex"),
+        ).toBe(signature);
+      }
+    });
+  });
+});

package/src/__tests__/sleep.test.ts

@@ -18,10 +18,12 @@ const assistantRootDir = testDir;
 process.env.CADET_LOCKFILE_DIR = testDir;
 
 const stopProcessByPidFileMock = mock(async () => true);
-const isProcessAliveMock = mock((): { alive: boolean; pid: number | null } => ({
-  alive: false,
-  pid: null,
-}));
+const isProcessAliveMock = mock(
+  (_pidFile?: string): { alive: boolean; pid: number | null } => ({
+    alive: false,
+    pid: null,
+  }),
+);
 
 const realProcess = { ...(await import("../lib/process.js")) };
 
@@ -95,7 +97,7 @@ import {
 // assistant without needing to mock the entire assistant-config module.
 function writeLockfile(extraEntryFields: Record<string, unknown> = {}): void {
   writeFileSync(
-    join(testDir, ".cadet.lock.json"),
+    join(testDir, "lockfile.json"),
     JSON.stringify(
       {
         assistants: [
@@ -161,7 +163,7 @@ describe("sleep command", () => {
     // Reset per-test state: drop the lockfile and any lease file left behind.
     // assistantRootDir IS testDir now (state is flattened into the instance
     // dir), so wipe files rather than the directory itself.
-    rmSync(join(testDir, ".cadet.lock.json"), { force: true });
+    rmSync(join(testDir, "lockfile.json"), { force: true });
     rmSync(join(assistantRootDir, "active-call-leases.json"), { force: true });
     writeLockfile();
   });
@@ -366,4 +368,185 @@ describe("sleep command", () => {
       expect(stopProcessByPidFileMock).not.toHaveBeenCalled();
     });
   });
+
+  describe("--all", () => {
+    function writeMultiAssistantLockfile(): void {
+      writeFileSync(
+        join(testDir, "lockfile.json"),
+        JSON.stringify(
+          {
+            assistants: [
+              {
+                assistantId: "sleep-all-1",
+                runtimeUrl: `http://127.0.0.1:${DEFAULT_DAEMON_PORT}`,
+                cloud: "local",
+                resources: {
+                  instanceDir: join(testDir, "instance-1"),
+                  daemonPort: DEFAULT_DAEMON_PORT,
+                  gatewayPort: DEFAULT_GATEWAY_PORT,
+                  qdrantPort: DEFAULT_QDRANT_PORT,
+                },
+              },
+              {
+                assistantId: "sleep-all-2",
+                runtimeUrl: `http://127.0.0.1:${DEFAULT_DAEMON_PORT}`,
+                cloud: "local",
+                resources: {
+                  instanceDir: join(testDir, "instance-2"),
+                  daemonPort: DEFAULT_DAEMON_PORT,
+                  gatewayPort: DEFAULT_GATEWAY_PORT,
+                  qdrantPort: DEFAULT_QDRANT_PORT,
+                },
+              },
+            ],
+            activeAssistant: "sleep-all-1",
+          },
+          null,
+          2,
+        ),
+      );
+    }
+
+    test("stops every assistant in the lockfile", async () => {
+      writeMultiAssistantLockfile();
+      process.argv = ["bun", "cadet", "sleep", "--all"];
+
+      const consoleLog = spyOn(console, "log").mockImplementation(() => {});
+      try {
+        await sleep();
+      } finally {
+        consoleLog.mockRestore();
+      }
+
+      expect(stopProcessByPidFileMock).toHaveBeenCalledTimes(6); // assistant+gateway+CES × 2
+    });
+
+    test("skips assistants whose lifecycle is managed elsewhere", async () => {
+      writeMultiAssistantLockfile();
+      // Rewrite the lockfile with the second entry paired.
+      writeFileSync(
+        join(testDir, "lockfile.json"),
+        JSON.stringify({
+          assistants: [
+            {
+              assistantId: "sleep-all-1",
+              runtimeUrl: `http://127.0.0.1:${DEFAULT_DAEMON_PORT}`,
+              cloud: "local",
+              resources: {
+                instanceDir: join(testDir, "instance-1"),
+                daemonPort: DEFAULT_DAEMON_PORT,
+                gatewayPort: DEFAULT_GATEWAY_PORT,
+                qdrantPort: DEFAULT_QDRANT_PORT,
+              },
+            },
+            {
+              assistantId: "paired-one",
+              runtimeUrl: "http://127.0.0.1:1",
+              cloud: "paired",
+            },
+          ],
+          activeAssistant: "sleep-all-1",
+        }),
+      );
+      process.argv = ["bun", "cadet", "sleep", "--all"];
+
+      const consoleLog = spyOn(console, "log").mockImplementation(() => {});
+      try {
+        await sleep();
+      } finally {
+        consoleLog.mockRestore();
+      }
+
+      expect(stopProcessByPidFileMock).toHaveBeenCalledTimes(3); // assistant+gateway+CES, one local entry
+    });
+
+    test("continues past a failing assistant and exits 1", async () => {
+      writeMultiAssistantLockfile();
+      // instance-1 hits an active-call lease refusal; instance-2 is fine.
+      isProcessAliveMock.mockImplementation((pidFile?: string) => ({
+        alive: pidFile?.includes("instance-1") ?? false,
+        pid: pidFile?.includes("instance-1") ? 12345 : null,
+      }));
+      mkdirSync(join(testDir, "instance-1"), { recursive: true });
+      writeFileSync(
+        join(testDir, "instance-1", "active-call-leases.json"),
+        JSON.stringify({
+          version: 1,
+          leases: [
+            {
+              callSessionId: "call-all-1",
+              providerCallSid: null,
+              updatedAt: Date.now(),
+            },
+          ],
+        }),
+      );
+      process.argv = ["bun", "cadet", "sleep", "--all"];
+
+      const consoleError = spyOn(console, "error").mockImplementation(() => {});
+      const exitMock = mock((code?: number) => {
+        throw new Error(`process.exit:${code}`);
+      });
+      const originalExit = process.exit;
+      process.exit = exitMock as unknown as typeof process.exit;
+
+      try {
+        await expect(sleep()).rejects.toThrow("process.exit:1");
+        expect(
+          consoleError.mock.calls.some(([line]) =>
+            String(line).includes("failed to stop 'sleep-all-1'"),
+          ),
+        ).toBe(true);
+      } finally {
+        process.exit = originalExit;
+        consoleError.mockRestore();
+      }
+
+      // The healthy assistant was still stopped.
+      expect(stopProcessByPidFileMock).toHaveBeenCalledTimes(3); // assistant+gateway+CES of instance-2
+    });
+
+    test("exits 1 when there is nothing to stop", async () => {
+      rmSync(join(testDir, "lockfile.json"), { force: true });
+      process.argv = ["bun", "cadet", "sleep", "--all"];
+
+      const consoleError = spyOn(console, "error").mockImplementation(() => {});
+      const exitMock = mock((code?: number) => {
+        throw new Error(`process.exit:${code}`);
+      });
+      const originalExit = process.exit;
+      process.exit = exitMock as unknown as typeof process.exit;
+
+      try {
+        await expect(sleep()).rejects.toThrow("process.exit:1");
+        expect(consoleError).toHaveBeenCalledWith(
+          expect.stringContaining("no assistants found"),
+        );
+      } finally {
+        process.exit = originalExit;
+        consoleError.mockRestore();
+      }
+    });
+
+    test("refuses --all combined with a name", async () => {
+      process.argv = ["bun", "cadet", "sleep", "sleep-test", "--all"];
+
+      const consoleError = spyOn(console, "error").mockImplementation(() => {});
+      const exitMock = mock((code?: number) => {
+        throw new Error(`process.exit:${code}`);
+      });
+      const originalExit = process.exit;
+      process.exit = exitMock as unknown as typeof process.exit;
+
+      try {
+        await expect(sleep()).rejects.toThrow("process.exit:1");
+        expect(consoleError).toHaveBeenCalledWith(
+          expect.stringContaining("--all cannot be combined"),
+        );
+      } finally {
+        process.exit = originalExit;
+        consoleError.mockRestore();
+      }
+    });
+  });
 });

package/src/__tests__/tailscale-tunnel.test.ts

@@ -92,7 +92,7 @@ function makeDeps(opts: {
 function useTempLockfile(assistantId: string, ingressUrl?: string): string {
   const lockfileDir = makeWorkspace();
   process.env.CADET_LOCKFILE_DIR = lockfileDir;
-  const lockfilePath = join(lockfileDir, ".cadet.lock.json");
+  const lockfilePath = join(lockfileDir, "lockfile.json");
   writeFileSync(
     lockfilePath,
     JSON.stringify({