@vibedeckx/linux-x64 0.3.38 → 0.3.39

package/dist/bin.js

@@ -66967,7 +66967,7 @@ var require_sonic_boom = __commonJS({
       if (!(this instanceof SonicBoom)) {
         return new SonicBoom(opts);
       }
-      let { fd, dest, minLength, maxLength, maxWrite, periodicFlush, sync, append = true, mkdir: mkdir7, retryEAGAIN, fsync, contentMode, mode } = opts || {};
+      let { fd, dest, minLength, maxLength, maxWrite, periodicFlush, sync, append = true, mkdir: mkdir6, retryEAGAIN, fsync, contentMode, mode } = opts || {};
       fd = fd || dest;
       this._len = 0;
       this.fd = -1;
@@ -66992,7 +66992,7 @@ var require_sonic_boom = __commonJS({
       this.append = append || false;
       this.mode = mode;
       this.retryEAGAIN = retryEAGAIN || (() => true);
-      this.mkdir = mkdir7 || false;
+      this.mkdir = mkdir6 || false;
       let fsWriteSync;
       let fsWrite;
       if (contentMode === kContentModeBuffer) {
@@ -100215,7 +100215,7 @@ var require_commonjs6 = __commonJS({
     var node_url_1 = __require("node:url");
     var fs_1 = __require("fs");
     var actualFS = __importStar(__require("node:fs"));
-    var realpathSync = fs_1.realpathSync.native;
+    var realpathSync2 = fs_1.realpathSync.native;
     var promises_1 = __require("node:fs/promises");
     var minipass_1 = require_commonjs5();
     var defaultFS = {
@@ -100223,7 +100223,7 @@ var require_commonjs6 = __commonJS({
       readdir: fs_1.readdir,
       readdirSync: fs_1.readdirSync,
       readlinkSync: fs_1.readlinkSync,
-      realpathSync,
+      realpathSync: realpathSync2,
       promises: {
         lstat: promises_1.lstat,
         readdir: promises_1.readdir,
@@ -115594,7 +115594,7 @@ var require_token_io = __commonJS({
     });
     module.exports = __toCommonJS2(token_io_exports);
     var import_path16 = __toESM3(__require("path"));
-    var import_fs10 = __toESM3(__require("fs"));
+    var import_fs11 = __toESM3(__require("fs"));
     var import_os4 = __toESM3(__require("os"));
     var import_token_error = require_token_error();
     function findRootDir() {
@@ -115602,7 +115602,7 @@ var require_token_io = __commonJS({
         let dir = process.cwd();
         while (dir !== import_path16.default.dirname(dir)) {
           const pkgPath = import_path16.default.join(dir, ".vercel");
-          if (import_fs10.default.existsSync(pkgPath)) {
+          if (import_fs11.default.existsSync(pkgPath)) {
             return dir;
           }
           dir = import_path16.default.dirname(dir);
@@ -128873,7 +128873,7 @@ var require_snapshot_utils = __commonJS({
 var require_snapshot_recorder = __commonJS({
   "../../node_modules/.pnpm/undici@7.22.0/node_modules/undici/lib/mock/snapshot-recorder.js"(exports, module) {
     "use strict";
-    var { writeFile: writeFile2, readFile: readFile2, mkdir: mkdir7 } = __require("node:fs/promises");
+    var { writeFile: writeFile2, readFile: readFile2, mkdir: mkdir6 } = __require("node:fs/promises");
     var { dirname, resolve: resolve3 } = __require("node:path");
     var { setTimeout: setTimeout3, clearTimeout: clearTimeout2 } = __require("node:timers");
     var { InvalidArgumentError: InvalidArgumentError4, UndiciError } = require_errors7();
@@ -129105,7 +129105,7 @@ var require_snapshot_recorder = __commonJS({
           throw new InvalidArgumentError4("Snapshot path is required");
         }
         const resolvedPath = resolve3(path26);
-        await mkdir7(dirname(resolvedPath), { recursive: true });
+        await mkdir6(dirname(resolvedPath), { recursive: true });
         const data = Array.from(this.#snapshots.entries()).map(([hash2, snapshot]) => ({
           hash: hash2,
           snapshot
@@ -208665,6 +208665,7 @@ function parseRows(rows, sessionIdForLog) {
 import path7 from "path";
 import { createHash } from "crypto";
 import { execSync, execFileSync as execFileSync2 } from "child_process";
+import { mkdirSync as mkdirSync2, realpathSync } from "fs";
 var WORKTREE_BASE_DIR = "/var/tmp/vibedeckx/worktrees";
 var WORKTREE_LIST_TTL_MS = 1e4;
 var worktreeListCache = /* @__PURE__ */ new Map();
@@ -208677,35 +208678,41 @@ function isSubpath(basePath33, targetPath) {
   const relative = path7.relative(basePath33, targetPath);
   return relative === "" || !relative.startsWith("..") && !path7.isAbsolute(relative);
 }
+function canonicalPath(target) {
+  try {
+    return realpathSync(target);
+  } catch {
+    return path7.resolve(target);
+  }
+}
 function isTrustedWorktreePath(projectPath, worktreePath) {
-  const normalizedWorktreePath = path7.resolve(worktreePath);
-  if (normalizedWorktreePath === path7.resolve(projectPath)) return true;
-  const managedBase = path7.resolve(getWorktreeBaseForProject(projectPath));
+  const normalizedWorktreePath = canonicalPath(worktreePath);
+  if (normalizedWorktreePath === canonicalPath(projectPath)) return true;
+  const managedBase = canonicalPath(getWorktreeBaseForProject(projectPath));
   return isSubpath(managedBase, normalizedWorktreePath);
 }
-function readWorktreeListFromGit(projectPath) {
+function readWorktreeRecords(projectPath) {
   const output = execSync("git worktree list --porcelain", {
     cwd: projectPath,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
   });
-  const entries = [];
-  const blocks = output.trim().split("\n\n");
-  for (const block of blocks) {
-    const lines = block.split("\n");
+  const records = [];
+  for (const block of output.trim().split("\n\n")) {
     let worktreePath = "";
     let branch = null;
-    let isPrunable = false;
-    for (const line of lines) {
+    let prunable = false;
+    for (const line of block.split("\n")) {
       if (line.startsWith("worktree ")) worktreePath = line.slice(9);
       else if (line.startsWith("branch refs/heads/")) branch = line.slice(18);
-      else if (line === "prunable" || line.startsWith("prunable ")) isPrunable = true;
-    }
-    if (worktreePath && !isPrunable && isTrustedWorktreePath(projectPath, worktreePath)) {
-      entries.push({ path: worktreePath, branch });
+      else if (line === "prunable" || line.startsWith("prunable ")) prunable = true;
     }
+    if (worktreePath) records.push({ path: worktreePath, branch, prunable });
   }
-  return entries;
+  return records;
+}
+function readWorktreeListFromGit(projectPath) {
+  return readWorktreeRecords(projectPath).filter((record2) => !record2.prunable && isTrustedWorktreePath(projectPath, record2.path)).map(({ path: worktreePath, branch }) => ({ path: worktreePath, branch }));
 }
 function parseGitWorktreeList(projectPath) {
   const now3 = Date.now();
@@ -208739,6 +208746,76 @@ function pruneWorktrees(projectPath) {
 function invalidateWorktreeListCache(projectPath) {
   worktreeListCache.delete(projectPath);
 }
+function branchExists(projectPath, branch) {
+  try {
+    execFileSync2("git", ["rev-parse", "--verify", `refs/heads/${branch}`], {
+      cwd: projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function planWorktreeAdd(projectPath, branch, startPoint) {
+  const exists2 = branchExists(projectPath, branch);
+  if (exists2) {
+    pruneWorktrees(projectPath);
+    const existing = parseGitWorktreeList(projectPath).find((e) => e.branch === branch);
+    if (existing) {
+      if (canonicalPath(existing.path) === canonicalPath(projectPath)) {
+        throw Object.assign(
+          new Error(`Branch '${branch}' is checked out in the main workspace`),
+          { statusCode: 409 }
+        );
+      }
+      return { worktreePath: existing.path, adopted: true, addArgs: null };
+    }
+  }
+  const worktreePath = resolveWorktreePath(projectPath, branch);
+  return {
+    worktreePath,
+    adopted: exists2,
+    addArgs: exists2 ? ["worktree", "add", worktreePath, branch] : ["worktree", "add", "-b", branch, worktreePath, startPoint]
+  };
+}
+function liveWorktreeRecord(projectPath, worktreePath) {
+  const target = canonicalPath(worktreePath);
+  const match2 = readWorktreeRecords(projectPath).find((record2) => !record2.prunable && canonicalPath(record2.path) === target);
+  return match2 ? { path: match2.path, branch: match2.branch } : null;
+}
+function worktreeRecordExists(projectPath, worktreePath) {
+  try {
+    return liveWorktreeRecord(projectPath, worktreePath) !== null;
+  } catch {
+    return null;
+  }
+}
+function deleteBranchAfterRemoval(projectPath, branch) {
+  if (!branchExists(projectPath, branch)) return null;
+  try {
+    execFileSync2("git", ["branch", "-d", branch], {
+      cwd: projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return null;
+  } catch (error48) {
+    const stderr = String(error48?.stderr ?? "");
+    return { branch, unmerged: /not fully merged/i.test(stderr) };
+  }
+}
+function applyWorktreeAdd(projectPath, plan) {
+  if (!plan.addArgs) return;
+  mkdirSync2(getWorktreeBaseForProject(projectPath), { recursive: true });
+  execFileSync2("git", plan.addArgs, {
+    cwd: projectPath,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  invalidateWorktreeListCache(projectPath);
+}
 function resolveWorktreePath(projectPath, branch) {
   if (!branch) return projectPath;
   try {
@@ -247391,7 +247468,6 @@ var process_routes_default = (0, import_fastify_plugin8.default)(routes7, { name
 
 // src/routes/worktree-routes.ts
 var import_fastify_plugin9 = __toESM(require_plugin2(), 1);
-import { mkdir as mkdir4 } from "fs/promises";
 
 // src/utils/path-project.ts
 async function ensurePathProjectId(fastify2, projectPath) {
@@ -247413,7 +247489,8 @@ async function getAllRemoteConfigs(fastify2, project) {
   const remotes = await fastify2.storage.projectRemotes.getByProject(project.id);
   return remotes.map((r) => ({
     serverId: r.remote_server_id,
-    remotePath: r.remote_path
+    remotePath: r.remote_path,
+    serverName: r.server_name
   }));
 }
 async function getRemoteConfig(fastify2, project) {
@@ -247436,6 +247513,30 @@ async function ensurePathProject(fastify2, projectPath) {
   if (!project) throw new Error(`Path project '${projectId}' was not persisted`);
   return project;
 }
+function removeWorktreeIfPresent(execFileSync8, projectPath, worktreePath) {
+  try {
+    execFileSync8("git", ["worktree", "remove", worktreePath], {
+      cwd: projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch (error48) {
+    if (worktreeRecordExists(projectPath, worktreePath) !== false) throw error48;
+    pruneWorktrees(projectPath);
+  }
+}
+async function assertPathIsFree(fastify2, opts) {
+  const registered = await fastify2.storage.workspaceRegistry.listByProject(opts.projectId, opts.targetId);
+  const target = canonicalPath(opts.worktreePath);
+  const owner = registered.find((row) => row.workspace.branch !== opts.branch && canonicalPath(row.checkout.worktree_path) === target);
+  if (!owner) return;
+  throw Object.assign(
+    new Error(
+      `That worktree already belongs to workspace '${owner.workspace.branch || "main"}'`
+    ),
+    { statusCode: 409 }
+  );
+}
 async function syncRemoteWorktreeList(fastify2, projectId, remote, data) {
   const worktrees = data?.worktrees;
   if (!Array.isArray(worktrees)) return;
@@ -247535,37 +247636,27 @@ var routes8 = async (fastify2) => {
     console.log(`[worktree] ${requestId} Creating: branch=${trimmedBranch}, base=${startPoint}, path=${projectPath}`);
     let pendingCheckoutId = null;
     try {
-      const { execFileSync: execFileSync8 } = await import("child_process");
-      try {
-        execFileSync8("git", ["rev-parse", "--verify", `refs/heads/${trimmedBranch}`], {
-          cwd: projectPath,
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        return reply.code(409).send({ error: `Branch '${trimmedBranch}' already exists` });
-      } catch {
-      }
-      const worktreeAbsolutePath = resolveWorktreePath(projectPath, trimmedBranch);
+      const plan = planWorktreeAdd(projectPath, trimmedBranch, startPoint);
       const project = await ensurePathProject(fastify2, projectPath);
+      await assertPathIsFree(fastify2, {
+        projectId: project.id,
+        branch: trimmedBranch,
+        targetId: "local",
+        worktreePath: plan.worktreePath
+      });
       const pending = await fastify2.storage.workspaceRegistry.beginCheckout({
         projectId: project.id,
         branch: trimmedBranch,
         targetId: "local",
-        worktreePath: worktreeAbsolutePath,
+        worktreePath: plan.worktreePath,
         expectedBranch: trimmedBranch
       });
       pendingCheckoutId = pending.checkout.id;
-      await mkdir4(getWorktreeBaseForProject(projectPath), { recursive: true });
-      execFileSync8("git", ["worktree", "add", "-b", trimmedBranch, worktreeAbsolutePath, startPoint], {
-        cwd: projectPath,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      invalidateWorktreeListCache(projectPath);
+      applyWorktreeAdd(projectPath, plan);
       await fastify2.storage.workspaceRegistry.setCheckoutStatus(pending.checkout.id, "ready");
-      console.log(`[worktree] ${requestId} Created: branch=${trimmedBranch}`);
+      console.log(`[worktree] ${requestId} ${plan.adopted ? "Adopted" : "Created"}: branch=${trimmedBranch}`);
       return reply.code(201).send({
-        worktree: { branch: trimmedBranch, worktreePath: worktreeAbsolutePath }
+        worktree: { branch: trimmedBranch, worktreePath: plan.worktreePath, adopted: plan.adopted }
       });
     } catch (error48) {
       const errorMessage = error48 instanceof Error ? error48.message : "Unknown error";
@@ -247574,6 +247665,8 @@ var routes8 = async (fastify2) => {
       }
       const stderr = error48?.stderr || "";
       console.error(`[worktree] ${requestId} Failed: ${errorMessage}${stderr ? `, stderr: ${stderr}` : ""}`);
+      const statusCode = error48?.statusCode;
+      if (statusCode) return reply.code(statusCode).send({ error: errorMessage });
       return reply.code(500).send({ error: `Failed to create worktree: ${errorMessage}` });
     }
   });
@@ -247615,34 +247708,19 @@ var routes8 = async (fastify2) => {
         branch,
         worktreePath: worktreeAbsPath
       });
-      let branchToDelete = null;
+      let branchToDelete = branch;
       try {
-        const entries = parseGitWorktreeList(projectPath);
-        const match2 = entries.find((e) => e.path === worktreeAbsPath);
-        if (match2) branchToDelete = match2.branch;
+        branchToDelete = liveWorktreeRecord(projectPath, worktreeAbsPath)?.branch ?? branch;
       } catch {
       }
-      execFileSync8("git", ["worktree", "remove", worktreeAbsPath], {
-        cwd: projectPath,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      });
+      removeWorktreeIfPresent(execFileSync8, projectPath, worktreeAbsPath);
       worktreeRemoved = true;
       invalidateWorktreeListCache(projectPath);
-      if (branchToDelete) {
-        try {
-          execFileSync8("git", ["branch", "-d", branchToDelete], {
-            cwd: projectPath,
-            encoding: "utf-8",
-            stdio: ["pipe", "pipe", "pipe"]
-          });
-        } catch {
-        }
-      }
+      const branchRetained = branchToDelete ? deleteBranchAfterRemoval(projectPath, branchToDelete) : null;
       if (registered) {
         await fastify2.storage.workspaceRegistry.markCheckoutDeleted(registered.checkout.id);
       }
-      return reply.code(200).send({ success: true });
+      return reply.code(200).send({ success: true, branchRetained });
     } catch (error48) {
       const errorMessage = error48 instanceof Error ? error48.message : "Unknown error";
       const busy = error48 instanceof WorktreeBusyError;
@@ -247757,7 +247835,11 @@ var routes8 = async (fastify2) => {
     } else {
       const targetRemote = await fastify2.storage.projectRemotes.getByProjectAndServer(project.id, requestedTarget);
       if (!targetRemote) return reply.code(400).send({ error: "Unknown remote target" });
-      remoteConfig = { serverId: targetRemote.remote_server_id, remotePath: targetRemote.remote_path };
+      remoteConfig = {
+        serverId: targetRemote.remote_server_id,
+        remotePath: targetRemote.remote_path,
+        serverName: targetRemote.server_name
+      };
     }
     if (remoteConfig) {
       const result = await proxyToRemoteAuto(
@@ -247807,7 +247889,11 @@ var routes8 = async (fastify2) => {
     } else {
       const targetRemote = await fastify2.storage.projectRemotes.getByProjectAndServer(project.id, requestedTarget);
       if (!targetRemote) return reply.code(400).send({ error: "Unknown remote target" });
-      remoteConfig = { serverId: targetRemote.remote_server_id, remotePath: targetRemote.remote_path };
+      remoteConfig = {
+        serverId: targetRemote.remote_server_id,
+        remotePath: targetRemote.remote_path,
+        serverName: targetRemote.server_name
+      };
     }
     if (remoteConfig) {
       const result = await proxyToRemoteAuto(
@@ -247951,17 +248037,19 @@ var routes8 = async (fastify2) => {
       await Promise.allSettled(
         remoteConfigs.map(async (rc) => {
           const key2 = rc.serverId;
+          const label = rc.serverName;
           try {
             const result = await deleteOnRemote(rc);
             if (result.ok) {
-              results2[key2] = { success: true };
+              const data = result.data;
+              results2[key2] = { success: true, label, branchRetained: data?.branchRetained };
             } else {
               const data = result.data;
-              results2[key2] = { success: false, error: data.error || "Remote deletion failed" };
+              results2[key2] = { success: false, label, error: data.error || "Remote deletion failed" };
             }
           } catch (error48) {
             const errorMessage = error48 instanceof Error ? error48.message : "Unknown error";
-            results2[key2] = { success: false, error: errorMessage };
+            results2[key2] = { success: false, label, error: errorMessage };
           }
         })
       );
@@ -248000,33 +248088,19 @@ var routes8 = async (fastify2) => {
           branch,
           worktreePath: worktreeAbsPath
         });
-        let branchToDelete = null;
+        let branchToDelete = branch;
         try {
-          const entries = parseGitWorktreeList(project.path);
-          const match2 = entries.find((e) => e.path === worktreeAbsPath);
-          if (match2) branchToDelete = match2.branch;
+          branchToDelete = liveWorktreeRecord(project.path, worktreeAbsPath)?.branch ?? branch;
         } catch {
         }
-        execFileSync8("git", ["worktree", "remove", worktreeAbsPath], {
-          cwd: project.path,
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "pipe"]
-        });
+        removeWorktreeIfPresent(execFileSync8, project.path, worktreeAbsPath);
         worktreeRemoved = true;
         invalidateWorktreeListCache(project.path);
-        if (branchToDelete) {
-          try {
-            execFileSync8("git", ["branch", "-d", branchToDelete], {
-              cwd: project.path,
-              encoding: "utf-8",
-              stdio: ["pipe", "pipe", "pipe"]
-            });
-          } catch {
-          }
-        }
+        const branchRetained = branchToDelete ? deleteBranchAfterRemoval(project.path, branchToDelete) : null;
         if (registered) {
           await fastify2.storage.workspaceRegistry.markCheckoutDeleted(registered.checkout.id);
         }
+        return branchRetained;
       } catch (error48) {
         if (registered && !worktreeRemoved) {
           const message = error48 instanceof Error ? error48.message : "Local deletion failed";
@@ -248038,8 +248112,8 @@ var routes8 = async (fastify2) => {
     };
     if (!hasRemote) {
       try {
-        await deleteLocal();
-        return reply.code(200).send({ success: true });
+        const branchRetained = await deleteLocal();
+        return reply.code(200).send({ success: true, branchRetained });
       } catch (error48) {
         const errorMessage = error48 instanceof Error ? error48.message : "Unknown error";
         if (errorMessage.includes("uncommitted changes") || error48 instanceof WorktreeBusyError) {
@@ -248050,8 +248124,7 @@ var routes8 = async (fastify2) => {
     }
     const results = {};
     try {
-      await deleteLocal();
-      results.local = { success: true };
+      results.local = { success: true, label: "local", branchRetained: await deleteLocal() };
     } catch (error48) {
       const errorMessage = error48 instanceof Error ? error48.message : "Unknown error";
       return reply.code(500).send({ error: `Failed to delete local worktree: ${errorMessage}` });
@@ -248059,17 +248132,19 @@ var routes8 = async (fastify2) => {
     await Promise.allSettled(
       remoteConfigs.map(async (rc) => {
         const key2 = remoteConfigs.length === 1 ? "remote" : rc.serverId;
+        const label = rc.serverName;
         try {
           const remoteResult = await deleteOnRemote(rc);
           if (remoteResult.ok) {
-            results[key2] = { success: true };
+            const remoteData = remoteResult.data;
+            results[key2] = { success: true, label, branchRetained: remoteData?.branchRetained };
           } else {
             const remoteData = remoteResult.data;
-            results[key2] = { success: false, error: remoteData.error || "Remote deletion failed" };
+            results[key2] = { success: false, label, error: remoteData.error || "Remote deletion failed" };
           }
         } catch (error48) {
           const errorMessage = error48 instanceof Error ? error48.message : "Unknown error";
-          results[key2] = { success: false, error: errorMessage };
+          results[key2] = { success: false, label, error: errorMessage };
         }
       })
     );
@@ -248183,20 +248258,21 @@ var routes8 = async (fastify2) => {
       const settled = await Promise.allSettled(
         remoteConfigs.map(async (rc) => {
           const key2 = rc.serverId;
+          const label = rc.serverName;
           console.log(`[worktree] Creating remote worktree: project=${req.params.id}, branch=${trimmedBranch}, serverId=${rc.serverId}`);
           try {
             const result = await createOnRemote(rc);
             if (result.ok) {
               const data = result.data;
-              results2[key2] = { success: true, worktree: data.worktree };
+              results2[key2] = { success: true, label, worktree: data.worktree, adopted: data.worktree?.adopted };
             } else {
               const data = result.data;
               console.error(`[worktree] Remote failed: serverId=${rc.serverId}, requestId=${result.requestId}, error=${JSON.stringify(result.data)}`);
-              results2[key2] = { success: false, error: data.error || "Remote creation failed", errorCode: result.errorCode, requestId: result.requestId };
+              results2[key2] = { success: false, label, error: data.error || "Remote creation failed", errorCode: result.errorCode, requestId: result.requestId };
             }
           } catch (error48) {
             const errorMessage = error48 instanceof Error ? error48.message : "Unknown error";
-            results2[key2] = { success: false, error: errorMessage };
+            results2[key2] = { success: false, label, error: errorMessage };
           }
         })
       );
@@ -248211,35 +248287,24 @@ var routes8 = async (fastify2) => {
       return reply.code(201).send({ worktree: { branch: trimmedBranch }, results: results2 });
     }
     const createLocal = async () => {
-      const { execFileSync: execFileSync8 } = await import("child_process");
-      try {
-        execFileSync8("git", ["rev-parse", "--verify", `refs/heads/${trimmedBranch}`], {
-          cwd: project.path,
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        throw new Error(`Branch '${trimmedBranch}' already exists`);
-      } catch (err) {
-        if (err instanceof Error && err.message.includes("already exists")) throw err;
-      }
-      const worktreeAbsolutePath = resolveWorktreePath(project.path, trimmedBranch);
+      const plan = planWorktreeAdd(project.path, trimmedBranch, localStartPoint);
+      await assertPathIsFree(fastify2, {
+        projectId: project.id,
+        branch: trimmedBranch,
+        targetId: "local",
+        worktreePath: plan.worktreePath
+      });
       const pending = await fastify2.storage.workspaceRegistry.beginCheckout({
         projectId: project.id,
         branch: trimmedBranch,
         targetId: "local",
-        worktreePath: worktreeAbsolutePath,
+        worktreePath: plan.worktreePath,
         expectedBranch: trimmedBranch
       });
       try {
-        await mkdir4(getWorktreeBaseForProject(project.path), { recursive: true });
-        execFileSync8("git", ["worktree", "add", "-b", trimmedBranch, worktreeAbsolutePath, localStartPoint], {
-          cwd: project.path,
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        invalidateWorktreeListCache(project.path);
+        applyWorktreeAdd(project.path, plan);
         await fastify2.storage.workspaceRegistry.setCheckoutStatus(pending.checkout.id, "ready");
-        return { branch: trimmedBranch };
+        return { branch: trimmedBranch, adopted: plan.adopted };
       } catch (error48) {
         const message = error48 instanceof Error ? error48.message : "Local creation failed";
         await fastify2.storage.workspaceRegistry.setCheckoutStatus(pending.checkout.id, "error", message).catch((registryError) => console.error("[worktree] Failed to record local checkout error:", registryError));
@@ -248252,6 +248317,8 @@ var routes8 = async (fastify2) => {
         return reply.code(201).send({ worktree });
       } catch (error48) {
         const errorMessage = error48 instanceof Error ? error48.message : "Unknown error";
+        const statusCode = error48?.statusCode;
+        if (statusCode) return reply.code(statusCode).send({ error: errorMessage });
         if (errorMessage.includes("already exists")) {
           return reply.code(409).send({ error: errorMessage });
         }
@@ -248262,7 +248329,7 @@ var routes8 = async (fastify2) => {
     let localWorktree;
     try {
       localWorktree = await createLocal();
-      results.local = { success: true, worktree: localWorktree };
+      results.local = { success: true, label: "local", worktree: localWorktree, adopted: localWorktree.adopted };
     } catch (error48) {
       const errorMessage = error48 instanceof Error ? error48.message : "Unknown error";
       return reply.code(500).send({ error: `Failed to create local worktree: ${errorMessage}` });
@@ -248270,17 +248337,19 @@ var routes8 = async (fastify2) => {
     await Promise.allSettled(
       remoteConfigs.map(async (rc) => {
         const key2 = remoteConfigs.length === 1 ? "remote" : rc.serverId;
+        const label = rc.serverName;
         console.log(`[worktree] Creating remote worktree: project=${req.params.id}, branch=${trimmedBranch}, serverId=${rc.serverId}`);
         try {
           const remoteResult = await createOnRemote(rc);
           if (remoteResult.ok) {
             const remoteData = remoteResult.data;
-            results[key2] = { success: true, worktree: remoteData.worktree };
+            results[key2] = { success: true, label, worktree: remoteData.worktree, adopted: remoteData.worktree?.adopted };
           } else {
             const remoteData = remoteResult.data;
             console.error(`[worktree] Remote failed: serverId=${rc.serverId}, requestId=${remoteResult.requestId}, errorCode=${remoteResult.errorCode}, status=${remoteResult.status}, duration=${remoteResult.durationMs}ms, error=${JSON.stringify(remoteResult.data)}`);
             results[key2] = {
               success: false,
+              label,
               error: remoteData.error || "Remote creation failed",
               errorCode: remoteResult.errorCode,
               requestId: remoteResult.requestId
@@ -248288,7 +248357,7 @@ var routes8 = async (fastify2) => {
           }
         } catch (error48) {
           const errorMessage = error48 instanceof Error ? error48.message : "Unknown error";
-          results[key2] = { success: false, error: errorMessage };
+          results[key2] = { success: false, label, error: errorMessage };
         }
       })
     );
@@ -249600,7 +249669,7 @@ var file_routes_default = (0, import_fastify_plugin11.default)(routes10, { name:
 var import_fastify_plugin12 = __toESM(require_plugin2(), 1);
 
 // src/utils/paste-file.ts
-import { chmod, mkdir as mkdir5, open as open2 } from "node:fs/promises";
+import { chmod, mkdir as mkdir4, open as open2 } from "node:fs/promises";
 import { constants as fsConstants2 } from "node:fs";
 import path15 from "node:path";
 import { randomUUID as randomUUID15 } from "node:crypto";
@@ -249646,7 +249715,7 @@ var DIR_MODE = 448;
 var FILE_MODE = 384;
 var FILE_FLAGS = fsConstants2.O_WRONLY | fsConstants2.O_CREAT | fsConstants2.O_EXCL | fsConstants2.O_NOFOLLOW;
 async function writePasteToTempFile(content) {
-  await mkdir5(PASTE_DIR, { recursive: true, mode: DIR_MODE });
+  await mkdir4(PASTE_DIR, { recursive: true, mode: DIR_MODE });
   await chmod(PASTE_DIR, DIR_MODE);
   const filePath = path15.join(PASTE_DIR, `${randomUUID15()}.txt`);
   const handle = await open2(filePath, FILE_FLAGS, FILE_MODE);
@@ -249660,7 +249729,7 @@ async function writePasteToTempFile(content) {
 }
 
 // src/utils/attachment-file.ts
-import { chmod as chmod2, mkdir as mkdir6, open as open3 } from "node:fs/promises";
+import { chmod as chmod2, mkdir as mkdir5, open as open3 } from "node:fs/promises";
 import { constants as fsConstants3 } from "node:fs";
 import path16 from "node:path";
 import { randomUUID as randomUUID16 } from "node:crypto";
@@ -249683,10 +249752,10 @@ function sanitizeAttachmentName(raw) {
 }
 async function writeAttachmentToTempFile(rawName, data) {
   const name25 = sanitizeAttachmentName(rawName);
-  await mkdir6(ATTACHMENT_DIR, { recursive: true, mode: DIR_MODE2 });
+  await mkdir5(ATTACHMENT_DIR, { recursive: true, mode: DIR_MODE2 });
   await chmod2(ATTACHMENT_DIR, DIR_MODE2);
   const dir = path16.join(ATTACHMENT_DIR, randomUUID16());
-  await mkdir6(dir, { mode: DIR_MODE2 });
+  await mkdir5(dir, { mode: DIR_MODE2 });
   const filePath = path16.join(dir, name25);
   const handle = await open3(filePath, FILE_FLAGS2, FILE_MODE2);
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibedeckx/linux-x64",
-  "version": "0.3.38",
+  "version": "0.3.39",
   "description": "Vibedeckx platform binaries for Linux x64",
   "os": [
     "linux"