@tickernelz/wardmote-plugin-daytona 2026.1108.2 → 2026.1111.0

package/dist/file-sync.test.js

@@ -55,13 +55,13 @@ describe("daytona file-sync inbound scratch cleanup", () => {
         }
     });
     it("removes the reserved scratch tar when a directory extraction fails", async () => {
-        const rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-daytona-scratch-"));
+        const rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "wardmote-daytona-scratch-"));
         cleanupDirs.push(rootDir);
         const sourceDir = path.join(rootDir, "referenced-project");
         await fs.mkdir(sourceDir, { recursive: true });
         await fs.writeFile(path.join(sourceDir, "README.md"), "referenced project\n", "utf8");
         const remoteDir = "/workspace";
-        const targetPath = "/workspace/.paperclip-runtime/test-adapter/project-abc";
+        const targetPath = "/workspace/.wardmote-runtime/test-adapter/project-abc";
         const uploadedDestinations = [];
         const commands = [];
         // Fail the extract round trip (the only command that runs `tar -xf`).
@@ -82,11 +82,9 @@ describe("daytona file-sync inbound scratch cleanup", () => {
             remoteDir,
             timeoutSeconds: 30,
         })).rejects.toThrow(/syncIn extract/);
-        // The runtime uploaded exactly one reserved scratch tar under the workspace
-        // root. Its name carries the reserved `.paperclip-upload-` prefix.
         expect(uploadedDestinations).toHaveLength(1);
         const scratchTar = uploadedDestinations[0];
-        expect(scratchTar).toContain(".paperclip-upload-");
+        expect(scratchTar).toContain(".wardmote-upload-");
         expect(scratchTar.startsWith(`${remoteDir}/`)).toBe(true);
         // The failure path swept the scratch tar: a standalone `rm -f` of the exact
         // scratch path ran after the failed extract. The extract command itself also
@@ -98,13 +96,13 @@ describe("daytona file-sync inbound scratch cleanup", () => {
         expect(cleanupCommands.length).toBeGreaterThan(0);
     });
     it("does not sweep scratch on the happy path (extract removes it)", async () => {
-        const rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-daytona-scratch-"));
+        const rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "wardmote-daytona-scratch-"));
         cleanupDirs.push(rootDir);
         const sourceDir = path.join(rootDir, "referenced-project");
         await fs.mkdir(sourceDir, { recursive: true });
         await fs.writeFile(path.join(sourceDir, "README.md"), "referenced project\n", "utf8");
         const remoteDir = "/workspace";
-        const targetPath = "/workspace/.paperclip-runtime/test-adapter/project-abc";
+        const targetPath = "/workspace/.wardmote-runtime/test-adapter/project-abc";
         const uploadedDestinations = [];
         const commands = [];
         // No failure: every command succeeds, so the extract's own `rm -f` clears the
@@ -129,7 +127,7 @@ describe("daytona file-sync inbound scratch cleanup", () => {
         expect(standaloneRemoves).toHaveLength(0);
     });
     it("writes an inbound file mapping to a sandbox path outside the workspace root", async () => {
-        const hostDir = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-daytona-outside-root-"));
+        const hostDir = await fs.mkdtemp(path.join(os.tmpdir(), "wardmote-daytona-outside-root-"));
         cleanupDirs.push(hostDir);
         const sourcePath = path.join(hostDir, "source.txt");
         await fs.writeFile(sourcePath, "payload");
@@ -138,7 +136,7 @@ describe("daytona file-sync inbound scratch cleanup", () => {
         // authority over its own filesystem, so the provider no longer confines
         // the target to the remote dir.
         const remoteDir = "/workspace";
-        const targetPath = "/etc/paperclip-outside-root.txt";
+        const targetPath = "/etc/wardmote-outside-root.txt";
         const uploadedDestinations = [];
         const commands = [];
         const sandbox = createMockSandbox({ uploadedDestinations, commands });
@@ -171,7 +169,7 @@ function sha256OfFile(filePath) {
 }
 async function writeCompressibleFile(filePath, sizeBytes) {
     // Low-entropy repeated content compresses well past the 10% saving bar.
-    const chunk = Buffer.from("paperclip-zstd-transport-compression-fixture-".repeat(64));
+    const chunk = Buffer.from("wardmote-zstd-transport-compression-fixture-".repeat(64));
     const parts = [];
     for (let written = 0; written < sizeBytes; written += chunk.length)
         parts.push(chunk);
@@ -194,7 +192,7 @@ function createRecordingSandbox(input) {
             executeCommand: async (command) => {
                 input.commands.push({ command });
                 if (command.includes("mkdir -p")) {
-                    return { exitCode: 0, result: input.probeReportsZstd ? "PAPERCLIP_ZSTD_AVAILABLE\n" : "" };
+                    return { exitCode: 0, result: input.probeReportsZstd ? "WARDMOTE_ZSTD_AVAILABLE\n" : "" };
                 }
                 return { exitCode: 0, result: "" };
             },
@@ -250,7 +248,7 @@ const gnuTar = ["gtar", "tar"].map((candidate) => {
     return resolved && spawnSync(resolved, ["--version"], { encoding: "utf8" }).stdout?.includes("GNU tar") ? resolved : null;
 }).find(Boolean);
 it.skipIf(!gnuTar)("extracts interleaved read-only skill directories with GNU tar and preserves their modes", async () => {
-    const root = await fs.mkdtemp("/tmp/paperclip-daytona-readonly-");
+    const root = await fs.mkdtemp("/tmp/wardmote-daytona-readonly-");
     const source = path.join(root, "source");
     const remoteDir = path.join(root, "remote");
     const target = path.join(remoteDir, "skill");
@@ -298,7 +296,7 @@ it.skipIf(!gnuTar)("extracts interleaved read-only skill directories with GNU ta
         await expect(performSyncIn({ sandbox: sandbox, remoteDir, timeoutSeconds: 30,
             operations: [{ operationId: "corrupt-skill-resume", files: [{ sourcePath: source, targetPath: target, kind: "directory", mode: 0o555 }] }] })).rejects.toThrow("syncIn extract");
         expect(await fs.readFile(qa, "utf8")).toBe("XX instructions");
-        expect((await fs.readdir(remoteDir)).filter((name) => name.startsWith(".paperclip-upload"))).toEqual([]);
+        expect((await fs.readdir(remoteDir)).filter((name) => name.startsWith(".wardmote-upload"))).toEqual([]);
     }
     finally {
         for (const base of [source, target]) {
@@ -309,7 +307,7 @@ it.skipIf(!gnuTar)("extracts interleaved read-only skill directories with GNU ta
     }
 }, 30_000);
 it.skipIf(!gnuTar)("uploads gzip directory archives and preserves content, executable modes, and symlinks", async () => {
-    const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-daytona-gzip-dir-"));
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), "wardmote-daytona-gzip-dir-"));
     const source = path.join(root, "source");
     const remoteDir = path.join(root, "remote");
     const target = path.join(remoteDir, "target");
@@ -351,7 +349,7 @@ it.skipIf(!gnuTar)("uploads gzip directory archives and preserves content, execu
     }
 }, 30_000);
 it.skipIf(!gnuTar)("uploads and extracts a gzip empty directory archive", async () => {
-    const root = await fs.mkdtemp(path.join(os.tmpdir(), "paperclip-daytona-gzip-empty-"));
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), "wardmote-daytona-gzip-empty-"));
     const source = path.join(root, "source");
     const remoteDir = path.join(root, "remote");
     const target = path.join(remoteDir, "target");
@@ -405,8 +403,8 @@ describe("daytona file-sync inbound zstd transport compression", () => {
     };
     describeWithZstd("compressed path (real promotion script, real zstd)", () => {
         it("compresses on the host and decompresses in-sandbox to a byte-identical file", async () => {
-            const remoteDir = await mkTempDir("paperclip-daytona-zstd-remote-");
-            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const remoteDir = await mkTempDir("wardmote-daytona-zstd-remote-");
+            const hostDir = await mkTempDir("wardmote-daytona-zstd-host-");
             const sourcePath = path.join(hostDir, "workspace-upload.tar");
             await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
             const targetPath = path.posix.join(remoteDir, "workspace-upload.tar");
@@ -424,11 +422,11 @@ describe("daytona file-sync inbound zstd transport compression", () => {
             expect(await sha256OfFile(targetPath)).toBe(await sha256OfFile(sourcePath));
             // Cleanup on success: no reserved scratch (raw or `.zst`) remains.
             const remaining = await fs.readdir(remoteDir);
-            expect(remaining.filter((name) => name.includes(".paperclip-upload"))).toHaveLength(0);
+            expect(remaining.filter((name) => name.includes(".wardmote-upload"))).toHaveLength(0);
         });
         it("removes the private compressed host temp directory after a successful sync", async () => {
-            const remoteDir = await mkTempDir("paperclip-daytona-zstd-remote-");
-            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const remoteDir = await mkTempDir("wardmote-daytona-zstd-remote-");
+            const hostDir = await mkTempDir("wardmote-daytona-zstd-host-");
             const sourcePath = path.join(hostDir, "workspace-upload.tar");
             await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
             const targetPath = path.posix.join(remoteDir, "target.bin");
@@ -448,14 +446,14 @@ describe("daytona file-sync inbound zstd transport compression", () => {
                     files: [{ sourcePath, targetPath, kind: "file" }],
                 }];
             await performSyncIn({ sandbox: sandbox, operations, remoteDir, timeoutSeconds: 30 });
-            expect(capturedHostTempDir).toContain("paperclip-daytona-zstd-");
+            expect(capturedHostTempDir).toContain("wardmote-daytona-zstd-");
             // The private host temp directory (not just the file inside it) is gone
             // after a successful sync.
             await expect(fs.stat(capturedHostTempDir)).rejects.toThrow();
         });
         it("reports the sync as successful when the post-promotion `.zst` cleanup fails, and warns with a leftover count but no path", async () => {
-            const remoteDir = await mkTempDir("paperclip-daytona-zstd-remote-");
-            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const remoteDir = await mkTempDir("wardmote-daytona-zstd-remote-");
+            const hostDir = await mkTempDir("wardmote-daytona-zstd-host-");
             const sourcePath = path.join(hostDir, "workspace-upload.tar");
             await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
             const targetPath = path.posix.join(remoteDir, "target.bin");
@@ -464,7 +462,7 @@ describe("daytona file-sync inbound zstd transport compression", () => {
             // separate `rm -f` fail, the same way a persistent cleanup error would.
             // The other commands (`mv`, `zstd`, `chmod`) still resolve to the real
             // binaries later on PATH.
-            const fakeBinDir = await mkTempDir("paperclip-daytona-zstd-fakebin-");
+            const fakeBinDir = await mkTempDir("wardmote-daytona-zstd-fakebin-");
             const fakeRmPath = path.join(fakeBinDir, "rm");
             await fs.writeFile(fakeRmPath, "#!/bin/sh\nexit 1\n");
             await fs.chmod(fakeRmPath, 0o755);
@@ -501,8 +499,8 @@ describe("daytona file-sync inbound zstd transport compression", () => {
             }
         });
         it("recovers a transient post-promotion `.zst` cleanup failure with the bounded sweep, without warning", async () => {
-            const remoteDir = await mkTempDir("paperclip-daytona-zstd-remote-");
-            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const remoteDir = await mkTempDir("wardmote-daytona-zstd-remote-");
+            const hostDir = await mkTempDir("wardmote-daytona-zstd-host-");
             const sourcePath = path.join(hostDir, "workspace-upload.tar");
             await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
             const targetPath = path.posix.join(remoteDir, "target.bin");
@@ -510,7 +508,7 @@ describe("daytona file-sync inbound zstd transport compression", () => {
             // own inline `.zst` cleanup. It defers to the real `rm` for every later
             // call. This simulates a transient cleanup failure: the bounded sweep's
             // own, separate `rm -f` is the second call, and it succeeds.
-            const fakeBinDir = await mkTempDir("paperclip-daytona-zstd-fakebin-");
+            const fakeBinDir = await mkTempDir("wardmote-daytona-zstd-fakebin-");
             const counterFile = path.join(fakeBinDir, "rm-call-count");
             const fakeRmPath = path.join(fakeBinDir, "rm");
             await fs.writeFile(fakeRmPath, [
@@ -549,8 +547,8 @@ describe("daytona file-sync inbound zstd transport compression", () => {
             }
         });
         it("never promotes a partial file when decompression fails, and sweeps all reserved scratch", async () => {
-            const remoteDir = await mkTempDir("paperclip-daytona-zstd-remote-");
-            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const remoteDir = await mkTempDir("wardmote-daytona-zstd-remote-");
+            const hostDir = await mkTempDir("wardmote-daytona-zstd-host-");
             const sourcePath = path.join(hostDir, "workspace-upload.tar");
             await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
             const targetPath = path.posix.join(remoteDir, "target.bin");
@@ -576,11 +574,11 @@ describe("daytona file-sync inbound zstd transport compression", () => {
             await expect(performSyncIn({ sandbox: sandbox, operations, remoteDir, timeoutSeconds: 30 })).rejects.toThrow(/syncIn rename/);
             await expect(fs.stat(targetPath)).rejects.toThrow(); // never promoted
             const remaining = await fs.readdir(remoteDir);
-            expect(remaining.filter((name) => name.includes(".paperclip-upload"))).toHaveLength(0); // scratch swept
+            expect(remaining.filter((name) => name.includes(".wardmote-upload"))).toHaveLength(0); // scratch swept
         });
         it("applies mapping.mode via chmod before promotion, when set", async () => {
-            const remoteDir = await mkTempDir("paperclip-daytona-zstd-remote-");
-            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const remoteDir = await mkTempDir("wardmote-daytona-zstd-remote-");
+            const hostDir = await mkTempDir("wardmote-daytona-zstd-host-");
             const sourceNoMode = path.join(hostDir, "no-mode.tar");
             const sourceWithMode = path.join(hostDir, "with-mode.tar");
             await writeCompressibleFile(sourceNoMode, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
@@ -620,9 +618,9 @@ describe("daytona file-sync inbound zstd transport compression", () => {
             expect((await fs.stat(targetWithMode)).mode & 0o777).toBe(0o640);
         });
         it("runs two concurrent compressed sync operations without cross-talk", async () => {
-            const remoteDirA = await mkTempDir("paperclip-daytona-zstd-remote-a-");
-            const remoteDirB = await mkTempDir("paperclip-daytona-zstd-remote-b-");
-            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const remoteDirA = await mkTempDir("wardmote-daytona-zstd-remote-a-");
+            const remoteDirB = await mkTempDir("wardmote-daytona-zstd-remote-b-");
+            const hostDir = await mkTempDir("wardmote-daytona-zstd-host-");
             const sourceA = path.join(hostDir, "a.tar");
             const sourceB = path.join(hostDir, "b.tar");
             await writeCompressibleFile(sourceA, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 2048);
@@ -669,8 +667,8 @@ describe("daytona file-sync inbound zstd transport compression", () => {
             let targetPath = "";
             let remoteDir = "";
             try {
-                remoteDir = await mkTempDir("paperclip-daytona-zstd-remote-");
-                const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+                remoteDir = await mkTempDir("wardmote-daytona-zstd-remote-");
+                const hostDir = await mkTempDir("wardmote-daytona-zstd-host-");
                 const sourcePath = path.join(hostDir, "workspace-upload.tar");
                 await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
                 targetPath = path.posix.join(remoteDir, "target.bin");
@@ -690,18 +688,18 @@ describe("daytona file-sync inbound zstd transport compression", () => {
                 Object.assign(allAttrs, span.attributes);
             const compressionKeys = Object.keys(allAttrs).filter((key) => key.includes(".transfer.compression.") || key.includes(".transfer.decompress."));
             expect(new Set(compressionKeys)).toEqual(new Set([
-                "paperclip.sandbox.startup.transfer.compression.codec",
-                "paperclip.sandbox.startup.transfer.compression.wall_ms",
-                "paperclip.sandbox.startup.transfer.compression.bytes_in",
-                "paperclip.sandbox.startup.transfer.compression.bytes_out",
-                "paperclip.sandbox.startup.transfer.decompress.wall_ms",
+                "wardmote.sandbox.startup.transfer.compression.codec",
+                "wardmote.sandbox.startup.transfer.compression.wall_ms",
+                "wardmote.sandbox.startup.transfer.compression.bytes_in",
+                "wardmote.sandbox.startup.transfer.compression.bytes_out",
+                "wardmote.sandbox.startup.transfer.decompress.wall_ms",
             ]));
-            expect(allAttrs["paperclip.sandbox.startup.transfer.compression.codec"]).toBe("zstd");
+            expect(allAttrs["wardmote.sandbox.startup.transfer.compression.codec"]).toBe("zstd");
             for (const key of [
-                "paperclip.sandbox.startup.transfer.compression.wall_ms",
-                "paperclip.sandbox.startup.transfer.compression.bytes_in",
-                "paperclip.sandbox.startup.transfer.compression.bytes_out",
-                "paperclip.sandbox.startup.transfer.decompress.wall_ms",
+                "wardmote.sandbox.startup.transfer.compression.wall_ms",
+                "wardmote.sandbox.startup.transfer.compression.bytes_in",
+                "wardmote.sandbox.startup.transfer.compression.bytes_out",
+                "wardmote.sandbox.startup.transfer.decompress.wall_ms",
             ]) {
                 expect(Number.isFinite(allAttrs[key])).toBe(true);
             }
@@ -709,7 +707,7 @@ describe("daytona file-sync inbound zstd transport compression", () => {
     });
     describe("raw-path fallback conditions (no real sandbox exec needed)", () => {
         it("falls back to the raw path when the sandbox reports no zstd binary", async () => {
-            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const hostDir = await mkTempDir("wardmote-daytona-zstd-host-");
             const sourcePath = path.join(hostDir, "big.tar");
             await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
             const uploadedSources = [];
@@ -729,7 +727,7 @@ describe("daytona file-sync inbound zstd transport compression", () => {
             expect(uploadedDestinations.some((dest) => dest.endsWith(".zst"))).toBe(false);
         });
         it("falls back to the raw path when the source is below ZSTD_MIN_SOURCE_BYTES", async () => {
-            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const hostDir = await mkTempDir("wardmote-daytona-zstd-host-");
             const sourcePath = path.join(hostDir, "small.tar");
             await fs.writeFile(sourcePath, "well below the 8 MiB compression floor\n");
             const uploadedSources = [];
@@ -749,7 +747,7 @@ describe("daytona file-sync inbound zstd transport compression", () => {
             expect(uploadedDestinations.some((dest) => dest.endsWith(".zst"))).toBe(false);
         });
         it("falls back to the raw path when the saving ratio is below ZSTD_MIN_SAVING_RATIO", async () => {
-            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const hostDir = await mkTempDir("wardmote-daytona-zstd-host-");
             const sourcePath = path.join(hostDir, "incompressible.tar");
             await writeIncompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
             const uploadedSources = [];
@@ -775,7 +773,7 @@ describe("daytona file-sync inbound zstd transport compression", () => {
             const original = zlib.createZstdCompress;
             Object.defineProperty(zlib, "createZstdCompress", { value: undefined, configurable: true, writable: true });
             try {
-                const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+                const hostDir = await mkTempDir("wardmote-daytona-zstd-host-");
                 const sourcePath = path.join(hostDir, "big.tar");
                 await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
                 const uploadedSources = [];
@@ -811,7 +809,7 @@ describe("daytona file-sync inbound zstd transport compression", () => {
                 writable: true,
             });
             try {
-                const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+                const hostDir = await mkTempDir("wardmote-daytona-zstd-host-");
                 const sourcePath = path.join(hostDir, "big.tar");
                 await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
                 const uploadedSources = [];
@@ -826,11 +824,11 @@ describe("daytona file-sync inbound zstd transport compression", () => {
                         operationId: "op-1",
                         files: [{ sourcePath, targetPath: "/workspace/target.bin", kind: "file" }],
                     }];
-                const before = (await fs.readdir(os.tmpdir())).filter((name) => name.startsWith("paperclip-daytona-zstd-"));
+                const before = (await fs.readdir(os.tmpdir())).filter((name) => name.startsWith("wardmote-daytona-zstd-"));
                 await performSyncIn({ sandbox: sandbox, operations, remoteDir: "/workspace", timeoutSeconds: 30 });
                 expect(uploadedSources).toEqual([sourcePath]);
                 expect(uploadedDestinations.some((dest) => dest.endsWith(".zst"))).toBe(false);
-                const after = (await fs.readdir(os.tmpdir())).filter((name) => name.startsWith("paperclip-daytona-zstd-"));
+                const after = (await fs.readdir(os.tmpdir())).filter((name) => name.startsWith("wardmote-daytona-zstd-"));
                 expect(after).toEqual(before); // no leftover host temp file
             }
             finally {
@@ -846,7 +844,7 @@ describe("daytona file-sync inbound zstd transport compression", () => {
                 return realStat(targetPath, ...rest);
             });
             try {
-                const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+                const hostDir = await mkTempDir("wardmote-daytona-zstd-host-");
                 const sourcePath = path.join(hostDir, "big.tar");
                 await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
                 const uploadedSources = [];
@@ -861,12 +859,12 @@ describe("daytona file-sync inbound zstd transport compression", () => {
                         operationId: "op-1",
                         files: [{ sourcePath, targetPath: "/workspace/target.bin", kind: "file" }],
                     }];
-                const before = (await fs.readdir(os.tmpdir())).filter((name) => name.startsWith("paperclip-daytona-zstd-"));
+                const before = (await fs.readdir(os.tmpdir())).filter((name) => name.startsWith("wardmote-daytona-zstd-"));
                 await performSyncIn({ sandbox: sandbox, operations, remoteDir: "/workspace", timeoutSeconds: 30 });
                 // The post-compression stat failed, so the candidate falls back to the raw path.
                 expect(uploadedSources).toEqual([sourcePath]);
                 expect(uploadedDestinations.some((dest) => dest.endsWith(".zst"))).toBe(false);
-                const after = (await fs.readdir(os.tmpdir())).filter((name) => name.startsWith("paperclip-daytona-zstd-"));
+                const after = (await fs.readdir(os.tmpdir())).filter((name) => name.startsWith("wardmote-daytona-zstd-"));
                 expect(after).toEqual(before); // the stat failure did not leak the private host temp directory
             }
             finally {
@@ -874,7 +872,7 @@ describe("daytona file-sync inbound zstd transport compression", () => {
             }
         });
         it("removes the host compressed temp file and sweeps sandbox scratch when the upload itself is rejected (cancellation)", async () => {
-            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const hostDir = await mkTempDir("wardmote-daytona-zstd-host-");
             const sourcePath = path.join(hostDir, "big.tar");
             await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
             const commands = [];
@@ -882,7 +880,7 @@ describe("daytona file-sync inbound zstd transport compression", () => {
                 process: {
                     executeCommand: async (command) => {
                         commands.push({ command });
-                        return { exitCode: 0, result: command.includes("mkdir -p") ? "PAPERCLIP_ZSTD_AVAILABLE\n" : "" };
+                        return { exitCode: 0, result: command.includes("mkdir -p") ? "WARDMOTE_ZSTD_AVAILABLE\n" : "" };
                     },
                 },
                 fs: {
@@ -892,19 +890,19 @@ describe("daytona file-sync inbound zstd transport compression", () => {
                     setFilePermissions: async () => undefined,
                 },
             };
-            const before = (await fs.readdir(os.tmpdir())).filter((name) => name.startsWith("paperclip-daytona-zstd-"));
+            const before = (await fs.readdir(os.tmpdir())).filter((name) => name.startsWith("wardmote-daytona-zstd-"));
             const operations = [{
                     operationId: "op-1",
                     files: [{ sourcePath, targetPath: "/workspace/target.bin", kind: "file" }],
                 }];
             await expect(performSyncIn({ sandbox: sandbox, operations, remoteDir: "/workspace", timeoutSeconds: 30 })).rejects.toThrow(/simulated cancellation/);
-            const after = (await fs.readdir(os.tmpdir())).filter((name) => name.startsWith("paperclip-daytona-zstd-"));
+            const after = (await fs.readdir(os.tmpdir())).filter((name) => name.startsWith("wardmote-daytona-zstd-"));
             expect(after).toEqual(before); // no leftover host temp file
             const rmCommands = commands.filter((entry) => entry.command.includes("rm -f"));
             expect(rmCommands.length).toBeGreaterThan(0); // both reserved scratch names swept
         });
         it("stages the compressed artifact in a private 0700 directory with a 0600 file, and removes the directory when the upload fails", async () => {
-            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const hostDir = await mkTempDir("wardmote-daytona-zstd-host-");
             const sourcePath = path.join(hostDir, "big.tar");
             await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
             let capturedDir = "";
@@ -914,7 +912,7 @@ describe("daytona file-sync inbound zstd transport compression", () => {
                 process: {
                     executeCommand: async (command) => ({
                         exitCode: 0,
-                        result: command.includes("mkdir -p") ? "PAPERCLIP_ZSTD_AVAILABLE\n" : "",
+                        result: command.includes("mkdir -p") ? "WARDMOTE_ZSTD_AVAILABLE\n" : "",
                     }),
                 },
                 fs: {
@@ -943,7 +941,7 @@ describe("daytona file-sync inbound zstd transport compression", () => {
             await expect(fs.stat(capturedDir)).rejects.toThrow();
         });
         it("passes the caller's timeoutSeconds unchanged through every round trip on the compressed path", async () => {
-            const hostDir = await mkTempDir("paperclip-daytona-zstd-host-");
+            const hostDir = await mkTempDir("wardmote-daytona-zstd-host-");
             const sourcePath = path.join(hostDir, "big.tar");
             await writeCompressibleFile(sourcePath, ZSTD_MIN_SOURCE_BYTES_FOR_TEST + 1024);
             const seenTimeouts = [];
@@ -951,7 +949,7 @@ describe("daytona file-sync inbound zstd transport compression", () => {
                 process: {
                     executeCommand: async (command, _cwd, _env, timeoutSeconds) => {
                         seenTimeouts.push(timeoutSeconds);
-                        return { exitCode: 0, result: command.includes("mkdir -p") ? "PAPERCLIP_ZSTD_AVAILABLE\n" : "" };
+                        return { exitCode: 0, result: command.includes("mkdir -p") ? "WARDMOTE_ZSTD_AVAILABLE\n" : "" };
                     },
                 },
                 fs: {
@@ -977,7 +975,7 @@ describe.skipIf(!gnuTar)("automatic unsafe workspace export recovery", () => {
         await Promise.all(cleanupDirs.splice(0).map((root) => fs.rm(root, { recursive: true, force: true })));
     });
     it.each(["/usr/bin/pnpm", "../../outside.txt", "ambiguous", "ambiguous-target"])("preserves files and safe links when a link is unsafe: %s", async (target) => {
-        const root = await fs.mkdtemp("/tmp/paperclip-export-recovery-");
+        const root = await fs.mkdtemp("/tmp/wardmote-export-recovery-");
         cleanupDirs.push(root);
         const remoteDir = path.join(root, "remote");
         const output = path.join(root, "output");
@@ -1018,10 +1016,10 @@ describe.skipIf(!gnuTar)("automatic unsafe workspace export recovery", () => {
         await expect(fs.stat(path.join(output, "cache", "ignored.txt"))).rejects.toMatchObject({ code: "ENOENT" });
         expect(await fs.readFile(path.join(root, "outside.txt"), "utf8")).toBe("private bytes");
         expect((await fs.lstat(path.join(remoteDir, "nested", linkName))).isSymbolicLink()).toBe(true);
-        expect((await fs.readdir(remoteDir)).filter((name) => name.startsWith(".paperclip-upload"))).toEqual([]);
+        expect((await fs.readdir(remoteDir)).filter((name) => name.startsWith(".wardmote-upload"))).toEqual([]);
     });
     it("finishes an export containing only unsafe links with an empty directory", async () => {
-        const root = await fs.mkdtemp("/tmp/paperclip-export-empty-");
+        const root = await fs.mkdtemp("/tmp/wardmote-export-empty-");
         cleanupDirs.push(root);
         const remoteDir = path.join(root, "remote");
         const output = path.join(root, "output");