@vibedeckx/linux-x64 0.3.6 → 0.3.7

package/dist/bin.js

@@ -128797,8 +128797,8 @@ var require_snapshot_utils = __commonJS({
         match: new Set(matchHeaders.map((header) => caseSensitive ? header : header.toLowerCase()))
       };
     }
-    var crypto5 = runtimeFeatures.has("crypto") ? __require("node:crypto") : null;
-    var hashId = crypto5?.hash ? (value) => crypto5.hash("sha256", value, "base64url") : (value) => Buffer.from(value).toString("base64url");
+    var crypto6 = runtimeFeatures.has("crypto") ? __require("node:crypto") : null;
+    var hashId = crypto6?.hash ? (value) => crypto6.hash("sha256", value, "base64url") : (value) => Buffer.from(value).toString("base64url");
     function isUndiciHeaders(headers) {
       return Array.isArray(headers) && (headers.length & 1) === 0;
     }
@@ -134600,10 +134600,10 @@ var require_subresource_integrity = __commonJS({
     var assert2 = __require("node:assert");
     var { runtimeFeatures } = require_runtime_features();
     var validSRIHashAlgorithmTokenSet = /* @__PURE__ */ new Map([["sha256", 0], ["sha384", 1], ["sha512", 2]]);
-    var crypto5;
+    var crypto6;
     if (runtimeFeatures.has("crypto")) {
-      crypto5 = __require("node:crypto");
-      const cryptoHashes = crypto5.getHashes();
+      crypto6 = __require("node:crypto");
+      const cryptoHashes = crypto6.getHashes();
       if (cryptoHashes.length === 0) {
         validSRIHashAlgorithmTokenSet.clear();
       }
@@ -134693,7 +134693,7 @@ var require_subresource_integrity = __commonJS({
       return result;
     }
     var applyAlgorithmToBytes = (algorithm, bytes) => {
-      return crypto5.hash(algorithm, bytes, "base64");
+      return crypto6.hash(algorithm, bytes, "base64");
     };
     function caseSensitiveMatch(actualValue, expectedValue) {
       let actualValueLength = actualValue.length;
@@ -137614,7 +137614,7 @@ var require_connection = __commonJS({
     var { WebsocketFrameSend } = require_frame();
     var assert2 = __require("node:assert");
     var { runtimeFeatures } = require_runtime_features();
-    var crypto5 = runtimeFeatures.has("crypto") ? __require("node:crypto") : null;
+    var crypto6 = runtimeFeatures.has("crypto") ? __require("node:crypto") : null;
     var warningEmitted = false;
     function establishWebSocketConnection(url2, protocols, client, handler, options) {
       const requestURL = url2;
@@ -137634,7 +137634,7 @@ var require_connection = __commonJS({
         const headersList = getHeadersList(new Headers4(options.headers));
         request.headersList = headersList;
       }
-      const keyValue = crypto5.randomBytes(16).toString("base64");
+      const keyValue = crypto6.randomBytes(16).toString("base64");
       request.headersList.append("sec-websocket-key", keyValue, true);
       request.headersList.append("sec-websocket-version", "13", true);
       for (const protocol of protocols) {
@@ -137674,7 +137674,7 @@ var require_connection = __commonJS({
             return;
           }
           const secWSAccept = response.headersList.get("Sec-WebSocket-Accept");
-          const digest = crypto5.hash("sha1", keyValue + uid, "base64");
+          const digest = crypto6.hash("sha1", keyValue + uid, "base64");
           if (secWSAccept !== digest) {
             failWebsocketConnection(handler, 1002, "Incorrect hash received in Sec-WebSocket-Accept header.");
             return;
@@ -184842,7 +184842,7 @@ var SqliteDialect = class {
 // src/storage/sqlite.ts
 import { mkdir } from "fs/promises";
 import path4 from "path";
-import crypto4 from "crypto";
+import crypto5 from "crypto";
 
 // src/storage/dialect.ts
 var fromDbBool = (v2) => v2 === 1 || v2 === true;
@@ -202550,6 +202550,164 @@ var createProjectChatRepos = (kdb) => ({
   }
 });
 
+// src/storage/repositories/workspace-registry.ts
+import crypto4 from "crypto";
+var mapWorkspace = (row) => ({
+  id: row.id,
+  project_id: row.project_id,
+  branch: row.branch,
+  status: row.status,
+  error: row.error,
+  created_at: row.created_at,
+  updated_at: row.updated_at
+});
+var mapCheckout = (row) => ({
+  id: row.id,
+  workspace_id: row.workspace_id,
+  target_id: row.target_id,
+  worktree_path: row.worktree_path,
+  expected_branch: row.expected_branch,
+  status: row.status,
+  error: row.error,
+  created_at: row.created_at,
+  updated_at: row.updated_at
+});
+async function recomputeWorkspace(db, workspaceId, h) {
+  const rows = await db.selectFrom("workspace_checkouts").select(["status", "error"]).where("workspace_id", "=", workspaceId).execute();
+  if (rows.length === 0) return;
+  const statuses = new Set(rows.map((row) => row.status));
+  const status = statuses.has("ready") ? "ready" : statuses.has("creating") ? "creating" : statuses.has("deleting") ? "deleting" : "error";
+  const error48 = status === "error" ? rows.map((row) => row.error).find((value) => Boolean(value)) ?? "Checkout failed" : null;
+  await db.updateTable("workspaces").set({ status, error: error48, updated_at: h.nowMs() }).where("id", "=", workspaceId).execute();
+}
+async function upsertCheckout(trx, h, opts) {
+  const now3 = h.nowMs();
+  let workspaceRow = await trx.selectFrom("workspaces").selectAll().where("project_id", "=", opts.projectId).where("branch", "=", opts.branch).executeTakeFirst();
+  if (!workspaceRow) {
+    const workspaceId = crypto4.randomUUID();
+    await trx.insertInto("workspaces").values({
+      id: workspaceId,
+      project_id: opts.projectId,
+      branch: opts.branch,
+      status: opts.status,
+      error: null,
+      created_at: now3,
+      updated_at: now3
+    }).execute();
+    workspaceRow = await trx.selectFrom("workspaces").selectAll().where("id", "=", workspaceId).executeTakeFirstOrThrow();
+  }
+  const checkoutId = crypto4.randomUUID();
+  await trx.insertInto("workspace_checkouts").values({
+    id: checkoutId,
+    workspace_id: workspaceRow.id,
+    target_id: opts.targetId,
+    worktree_path: opts.worktreePath,
+    expected_branch: opts.expectedBranch,
+    status: opts.status,
+    error: null,
+    created_at: now3,
+    updated_at: now3
+  }).onConflict((oc) => oc.columns(["workspace_id", "target_id"]).doUpdateSet({
+    worktree_path: opts.worktreePath,
+    expected_branch: opts.expectedBranch,
+    status: opts.status,
+    error: null,
+    updated_at: now3
+  })).execute();
+  await recomputeWorkspace(trx, workspaceRow.id, h);
+  const [workspace, checkout] = await Promise.all([
+    trx.selectFrom("workspaces").selectAll().where("id", "=", workspaceRow.id).executeTakeFirstOrThrow(),
+    trx.selectFrom("workspace_checkouts").selectAll().where("workspace_id", "=", workspaceRow.id).where("target_id", "=", opts.targetId).executeTakeFirstOrThrow()
+  ]);
+  return { workspace: mapWorkspace(workspace), checkout: mapCheckout(checkout) };
+}
+var createWorkspaceRegistryRepo = (kdb, h) => ({
+  workspaceRegistry: {
+    beginCheckout: (opts) => kdb.transaction().execute((trx) => upsertCheckout(trx, h, { ...opts, status: "creating" })),
+    registerReadyCheckout: (opts) => kdb.transaction().execute((trx) => upsertCheckout(trx, h, { ...opts, status: "ready" })),
+    setCheckoutStatus: async (workspaceId, targetId, status, error48 = null) => {
+      await kdb.transaction().execute(async (trx) => {
+        await trx.updateTable("workspace_checkouts").set({ status, error: error48, updated_at: h.nowMs() }).where("workspace_id", "=", workspaceId).where("target_id", "=", targetId).execute();
+        await recomputeWorkspace(trx, workspaceId, h);
+      });
+    },
+    setCheckoutStatusIfCurrent: async (workspaceId, targetId, expected, status, error48 = null) => kdb.transaction().execute(async (trx) => {
+      const result = await trx.updateTable("workspace_checkouts").set({ status, error: error48, updated_at: h.nowMs() }).where("workspace_id", "=", workspaceId).where("target_id", "=", targetId).where("status", "=", expected.status).where("updated_at", "=", expected.updatedAt).executeTakeFirst();
+      const changed = result.numUpdatedRows > 0n;
+      if (changed) await recomputeWorkspace(trx, workspaceId, h);
+      return changed;
+    }),
+    listByProject: async (projectId, targetId) => {
+      let query = kdb.selectFrom("workspaces as workspace").innerJoin("workspace_checkouts as checkout", "checkout.workspace_id", "workspace.id").selectAll("workspace").select([
+        "checkout.id as checkout_id",
+        "checkout.workspace_id as checkout_workspace_id",
+        "checkout.target_id as checkout_target_id",
+        "checkout.worktree_path as checkout_worktree_path",
+        "checkout.expected_branch as checkout_expected_branch",
+        "checkout.status as checkout_status",
+        "checkout.error as checkout_error",
+        "checkout.created_at as checkout_created_at",
+        "checkout.updated_at as checkout_updated_at"
+      ]).where("workspace.project_id", "=", projectId);
+      if (targetId) query = query.where("checkout.target_id", "=", targetId);
+      const rows = await query.orderBy("workspace.created_at", "asc").execute();
+      return rows.map((row) => ({
+        workspace: mapWorkspace(row),
+        checkout: {
+          id: row.checkout_id,
+          workspace_id: row.checkout_workspace_id,
+          target_id: row.checkout_target_id,
+          worktree_path: row.checkout_worktree_path,
+          expected_branch: row.checkout_expected_branch,
+          status: row.checkout_status,
+          error: row.checkout_error,
+          created_at: row.checkout_created_at,
+          updated_at: row.checkout_updated_at
+        }
+      }));
+    },
+    getByProjectBranch: async (projectId, branch, targetId) => {
+      const rows = await kdb.selectFrom("workspaces as workspace").innerJoin("workspace_checkouts as checkout", "checkout.workspace_id", "workspace.id").selectAll("workspace").select([
+        "checkout.id as checkout_id",
+        "checkout.workspace_id as checkout_workspace_id",
+        "checkout.target_id as checkout_target_id",
+        "checkout.worktree_path as checkout_worktree_path",
+        "checkout.expected_branch as checkout_expected_branch",
+        "checkout.status as checkout_status",
+        "checkout.error as checkout_error",
+        "checkout.created_at as checkout_created_at",
+        "checkout.updated_at as checkout_updated_at"
+      ]).where("workspace.project_id", "=", projectId).where("workspace.branch", "=", branch).where("checkout.target_id", "=", targetId).executeTakeFirst();
+      if (!rows) return void 0;
+      return {
+        workspace: mapWorkspace(rows),
+        checkout: {
+          id: rows.checkout_id,
+          workspace_id: rows.checkout_workspace_id,
+          target_id: rows.checkout_target_id,
+          worktree_path: rows.checkout_worktree_path,
+          expected_branch: rows.checkout_expected_branch,
+          status: rows.checkout_status,
+          error: rows.checkout_error,
+          created_at: rows.checkout_created_at,
+          updated_at: rows.checkout_updated_at
+        }
+      };
+    },
+    removeCheckout: async (workspaceId, targetId) => {
+      await kdb.transaction().execute(async (trx) => {
+        await trx.deleteFrom("workspace_checkouts").where("workspace_id", "=", workspaceId).where("target_id", "=", targetId).execute();
+        const remaining = await trx.selectFrom("workspace_checkouts").select("id").where("workspace_id", "=", workspaceId).limit(1).executeTakeFirst();
+        if (!remaining) {
+          await trx.deleteFrom("workspaces").where("id", "=", workspaceId).execute();
+        } else {
+          await recomputeWorkspace(trx, workspaceId, h);
+        }
+      });
+    }
+  }
+});
+
 // src/storage/sqlite.ts
 var createDatabase = (dbPath) => {
   const db = new Database(dbPath);
@@ -202569,6 +202727,37 @@ var createDatabase = (dbPath) => {
       created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     );
 
+    CREATE TABLE IF NOT EXISTS workspaces (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      branch TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL CHECK (status IN ('creating', 'ready', 'deleting', 'error')),
+      error TEXT,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),
+      updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),
+      UNIQUE(project_id, branch),
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS workspace_checkouts (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      target_id TEXT NOT NULL,
+      worktree_path TEXT NOT NULL,
+      expected_branch TEXT NOT NULL,
+      status TEXT NOT NULL CHECK (status IN ('creating', 'ready', 'deleting', 'error')),
+      error TEXT,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),
+      updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),
+      UNIQUE(workspace_id, target_id),
+      FOREIGN KEY (workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_workspaces_project_status
+      ON workspaces(project_id, status, branch);
+    CREATE INDEX IF NOT EXISTS idx_workspace_checkouts_workspace_status
+      ON workspace_checkouts(workspace_id, status, target_id);
+
     CREATE TABLE IF NOT EXISTS project_chat_threads (
       id TEXT PRIMARY KEY,
       project_id TEXT NOT NULL,
@@ -202873,6 +203062,34 @@ var createDatabase = (dbPath) => {
 
     CREATE INDEX IF NOT EXISTS idx_cross_remote_audit_target ON cross_remote_audit(target_remote_id, seq);
   `);
+  const workspaceCheckoutsTable = db.prepare(
+    "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'workspace_checkouts'"
+  ).get();
+  if (/UNIQUE\s*\(\s*target_id\s*,\s*worktree_path\s*\)/i.test(workspaceCheckoutsTable?.sql ?? "")) {
+    db.transaction(() => db.exec(`
+      ALTER TABLE workspace_checkouts RENAME TO workspace_checkouts_global_path_unique;
+      CREATE TABLE workspace_checkouts (
+        id TEXT PRIMARY KEY,
+        workspace_id TEXT NOT NULL,
+        target_id TEXT NOT NULL,
+        worktree_path TEXT NOT NULL,
+        expected_branch TEXT NOT NULL,
+        status TEXT NOT NULL CHECK (status IN ('creating', 'ready', 'deleting', 'error')),
+        error TEXT,
+        created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),
+        updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),
+        UNIQUE(workspace_id, target_id),
+        FOREIGN KEY (workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE
+      );
+      INSERT INTO workspace_checkouts
+        (id, workspace_id, target_id, worktree_path, expected_branch, status, error, created_at, updated_at)
+      SELECT id, workspace_id, target_id, worktree_path, expected_branch, status, error, created_at, updated_at
+        FROM workspace_checkouts_global_path_unique;
+      DROP TABLE workspace_checkouts_global_path_unique;
+      CREATE INDEX idx_workspace_checkouts_workspace_status
+        ON workspace_checkouts(workspace_id, status, target_id);
+    `))();
+  }
   const instructionDeliveryCols = db.prepare("PRAGMA table_info(agent_instruction_deliveries)").all();
   if (!instructionDeliveryCols.some((c) => c.name === "owner_token")) {
     db.exec("ALTER TABLE agent_instruction_deliveries ADD COLUMN owner_token TEXT");
@@ -203209,7 +203426,7 @@ var createDatabase = (dbPath) => {
         } catch {
           name25 = row.remote_url;
         }
-        const id = crypto4.randomUUID();
+        const id = crypto5.randomUUID();
         db.prepare(
           `INSERT INTO remote_servers (id, name, url, api_key, created_at, updated_at) VALUES (?, ?, ?, ?, datetime('now'), datetime('now'))`
         ).run(id, name25, row.remote_url, row.remote_api_key);
@@ -203227,7 +203444,7 @@ var createDatabase = (dbPath) => {
       if (!existingLink && proj.remote_path) {
         db.prepare(
           `INSERT INTO project_remotes (id, project_id, remote_server_id, remote_path, sort_order, sync_up_config, sync_down_config) VALUES (?, ?, ?, ?, 0, ?, ?)`
-        ).run(crypto4.randomUUID(), proj.id, server.id, proj.remote_path, proj.sync_up_config, proj.sync_down_config);
+        ).run(crypto5.randomUUID(), proj.id, server.id, proj.remote_path, proj.sync_up_config, proj.sync_down_config);
       }
       if (proj.agent_mode === "remote") {
         db.prepare(`UPDATE projects SET agent_mode = ? WHERE id = ?`).run(server.id, proj.id);
@@ -203896,6 +204113,7 @@ var createSqliteStorage = async (dbPath) => {
   const h = sqliteHelpers;
   return {
     ...createCoreRepos(kdb, h),
+    ...createWorkspaceRegistryRepo(kdb, h),
     ...createRemoteServerRepos(kdb, h),
     ...createExecutorRepos(kdb, h),
     ...createScheduledRepos(kdb, h),
@@ -206163,16 +206381,88 @@ function resolveWorktreePath(projectPath, branch) {
 function getWorktreeBaseForProject(projectPath) {
   return path6.join(WORKTREE_BASE_DIR, getProjectIdentifier(projectPath));
 }
-function getWorktreeBranches(projectPath) {
-  const entries = parseGitWorktreeList(projectPath);
-  const worktrees = [{ branch: null }];
+function conventionalWorktreePath(projectPath, branch) {
+  return path6.join(getWorktreeBaseForProject(projectPath), branch.replace(/\//g, "-"));
+}
+function reconcileWorktreeBranches(projectPath, entries, sessionBranches = [], registry2 = []) {
+  const registryByPath = /* @__PURE__ */ new Map();
+  for (const anchor of registry2) registryByPath.set(path6.resolve(anchor.worktreePath), anchor);
+  const stableBranchByPath = /* @__PURE__ */ new Map();
+  for (const branch of sessionBranches) {
+    if (!branch) continue;
+    stableBranchByPath.set(path6.resolve(conventionalWorktreePath(projectPath, branch)), branch);
+  }
+  const rootEntry = entries[0];
+  const rootAnchor = rootEntry ? registryByPath.get(path6.resolve(rootEntry.path)) : void 0;
+  const worktrees = [rootAnchor && rootEntry?.branch !== rootAnchor.expectedBranch ? { branch: null, currentBranch: rootEntry?.branch ?? null } : { branch: null }];
   for (let i = 1; i < entries.length; i++) {
-    if (entries[i].branch) {
-      worktrees.push({ branch: entries[i].branch });
+    const entry = entries[i];
+    const anchor = registryByPath.get(path6.resolve(entry.path));
+    const stableBranch = anchor?.branch || stableBranchByPath.get(path6.resolve(entry.path));
+    if (stableBranch) {
+      const expectedBranch = anchor?.expectedBranch ?? stableBranch;
+      worktrees.push(entry.branch === expectedBranch ? { branch: stableBranch } : { branch: stableBranch, currentBranch: entry.branch });
+    } else if (entry.branch) {
+      worktrees.push({ branch: entry.branch });
     }
   }
   return worktrees;
 }
+async function getRegisteredWorktreeBranches(storage, projectId, projectPath) {
+  const entries = parseGitWorktreeList(projectPath);
+  const sessions = await storage.agentSessions.getByProjectId(projectId);
+  const sessionBranches = sessions.map((session) => session.branch);
+  const sessionBranchByPath = /* @__PURE__ */ new Map();
+  for (const branch of sessionBranches) {
+    if (branch) sessionBranchByPath.set(path6.resolve(conventionalWorktreePath(projectPath, branch)), branch);
+  }
+  let registered = await storage.workspaceRegistry.listByProject(projectId, "local");
+  const livePaths = new Set(entries.map((entry) => path6.resolve(entry.path)));
+  for (const row of registered) {
+    if (livePaths.has(path6.resolve(row.checkout.worktree_path))) continue;
+    if (row.checkout.status === "deleting") {
+      await storage.workspaceRegistry.removeCheckout(row.workspace.id, "local");
+    } else if (row.checkout.status !== "error" || row.checkout.error !== "Worktree is missing") {
+      await storage.workspaceRegistry.setCheckoutStatusIfCurrent(
+        row.workspace.id,
+        "local",
+        { status: row.checkout.status, updatedAt: row.checkout.updated_at },
+        "error",
+        "Worktree is missing"
+      );
+    }
+  }
+  registered = await storage.workspaceRegistry.listByProject(projectId, "local");
+  const registeredPaths = new Set(registered.map((row) => path6.resolve(row.checkout.worktree_path)));
+  for (let index = 0; index < entries.length; index++) {
+    const entry = entries[index];
+    const resolvedPath = path6.resolve(entry.path);
+    const existing = registered.find((row) => path6.resolve(row.checkout.worktree_path) === resolvedPath);
+    if (existing) {
+      if (existing.checkout.status === "creating" || existing.checkout.status === "error") {
+        await storage.workspaceRegistry.setCheckoutStatus(existing.workspace.id, "local", "ready");
+      }
+      continue;
+    }
+    if (registeredPaths.has(resolvedPath) || entry.branch === null) continue;
+    const stableBranch = index === 0 ? "" : sessionBranchByPath.get(resolvedPath) ?? entry.branch;
+    await storage.workspaceRegistry.registerReadyCheckout({
+      projectId,
+      branch: stableBranch,
+      targetId: "local",
+      worktreePath: entry.path,
+      expectedBranch: index === 0 ? entry.branch : stableBranch
+    });
+    registeredPaths.add(resolvedPath);
+  }
+  registered = await storage.workspaceRegistry.listByProject(projectId, "local");
+  const anchors = registered.map((row) => ({
+    branch: row.workspace.branch,
+    worktreePath: row.checkout.worktree_path,
+    expectedBranch: row.checkout.expected_branch
+  }));
+  return reconcileWorktreeBranches(projectPath, entries, sessionBranches, anchors);
+}
 
 // ../../node_modules/.pnpm/@ai-sdk+provider@3.0.8/node_modules/@ai-sdk/provider/dist/index.mjs
 var marker = "vercel.ai.error";
@@ -239804,6 +240094,23 @@ var process_routes_default = (0, import_fastify_plugin9.default)(routes8, { name
 // src/routes/worktree-routes.ts
 var import_fastify_plugin10 = __toESM(require_plugin2(), 1);
 import { mkdir as mkdir3 } from "fs/promises";
+
+// src/utils/path-project.ts
+async function ensurePathProjectId(fastify2, projectPath) {
+  const pseudoProjectId = `path:${projectPath}`;
+  if (await fastify2.storage.projects.getById(pseudoProjectId)) return pseudoProjectId;
+  const existingByPath = await fastify2.storage.projects.getByPath(projectPath);
+  if (existingByPath) return existingByPath.id;
+  const name25 = projectPath.split("/").filter(Boolean).pop() || projectPath;
+  try {
+    await fastify2.storage.projects.create({ id: pseudoProjectId, name: name25, path: projectPath });
+  } catch (err) {
+    if (!(err instanceof Error && err.message.includes("UNIQUE constraint failed"))) throw err;
+  }
+  return pseudoProjectId;
+}
+
+// src/routes/worktree-routes.ts
 async function getAllRemoteConfigs(fastify2, project) {
   const remotes = await fastify2.storage.projectRemotes.getByProject(project.id);
   return remotes.map((r) => ({
@@ -239815,6 +240122,12 @@ async function getRemoteConfig(fastify2, project) {
   const all = await getAllRemoteConfigs(fastify2, project);
   return all.length > 0 ? all[0] : null;
 }
+async function ensurePathProject(fastify2, projectPath) {
+  const projectId = await ensurePathProjectId(fastify2, projectPath);
+  const project = await fastify2.storage.projects.getById(projectId);
+  if (!project) throw new Error(`Path project '${projectId}' was not persisted`);
+  return project;
+}
 var routes9 = async (fastify2) => {
   fastify2.get("/api/path/branches", async (req, reply) => {
     const projectPath = req.query.path;
@@ -239842,7 +240155,8 @@ var routes9 = async (fastify2) => {
     }
     try {
       pruneWorktrees(projectPath);
-      const worktrees = getWorktreeBranches(projectPath);
+      const project = await ensurePathProject(fastify2, projectPath);
+      const worktrees = await getRegisteredWorktreeBranches(fastify2.storage, project.id, projectPath);
       return reply.code(200).send({ worktrees });
     } catch (error48) {
       const errorMessage = error48 instanceof Error ? error48.message : "Unknown error";
@@ -239864,6 +240178,7 @@ var routes9 = async (fastify2) => {
       return reply.code(400).send({ error: "Invalid base branch name format" });
     }
     console.log(`[worktree] ${requestId} Creating: branch=${trimmedBranch}, base=${startPoint}, path=${projectPath}`);
+    let pendingWorkspaceId = null;
     try {
       const { execFileSync: execFileSync7 } = await import("child_process");
       try {
@@ -239876,6 +240191,15 @@ var routes9 = async (fastify2) => {
       } catch {
       }
       const worktreeAbsolutePath = resolveWorktreePath(projectPath, trimmedBranch);
+      const project = await ensurePathProject(fastify2, projectPath);
+      const pending = await fastify2.storage.workspaceRegistry.beginCheckout({
+        projectId: project.id,
+        branch: trimmedBranch,
+        targetId: "local",
+        worktreePath: worktreeAbsolutePath,
+        expectedBranch: trimmedBranch
+      });
+      pendingWorkspaceId = pending.workspace.id;
       await mkdir3(getWorktreeBaseForProject(projectPath), { recursive: true });
       execFileSync7("git", ["worktree", "add", "-b", trimmedBranch, worktreeAbsolutePath, startPoint], {
         cwd: projectPath,
@@ -239883,12 +240207,16 @@ var routes9 = async (fastify2) => {
         stdio: ["pipe", "pipe", "pipe"]
       });
       invalidateWorktreeListCache(projectPath);
+      await fastify2.storage.workspaceRegistry.setCheckoutStatus(pending.workspace.id, "local", "ready");
       console.log(`[worktree] ${requestId} Created: branch=${trimmedBranch}`);
       return reply.code(201).send({
         worktree: { branch: trimmedBranch }
       });
     } catch (error48) {
       const errorMessage = error48 instanceof Error ? error48.message : "Unknown error";
+      if (pendingWorkspaceId) {
+        await fastify2.storage.workspaceRegistry.setCheckoutStatus(pendingWorkspaceId, "local", "error", errorMessage).catch((registryError) => console.error("[worktree] Failed to record checkout error:", registryError));
+      }
       const stderr = error48?.stderr || "";
       console.error(`[worktree] ${requestId} Failed: ${errorMessage}${stderr ? `, stderr: ${stderr}` : ""}`);
       return reply.code(500).send({ error: `Failed to create worktree: ${errorMessage}` });
@@ -239902,6 +240230,12 @@ var routes9 = async (fastify2) => {
     if (!/^[a-zA-Z0-9]/.test(branch) || /[^a-zA-Z0-9/_-]/.test(branch)) {
       return reply.code(400).send({ error: "Invalid branch name format" });
     }
+    const pathProject = await fastify2.storage.projects.getByPath(projectPath);
+    const registered = pathProject ? await fastify2.storage.workspaceRegistry.getByProjectBranch(pathProject.id, branch, "local") : void 0;
+    if (registered) {
+      await fastify2.storage.workspaceRegistry.setCheckoutStatus(registered.workspace.id, "local", "deleting");
+    }
+    let worktreeRemoved = false;
     try {
       const { execSync: execSync2, execFileSync: execFileSync7 } = await import("child_process");
       const worktreeAbsPath = resolveWorktreePath(projectPath, branch);
@@ -239912,6 +240246,9 @@ var routes9 = async (fastify2) => {
           stdio: ["pipe", "pipe", "pipe"]
         });
         if (statusOutput.trim() !== "") {
+          if (registered) {
+            await fastify2.storage.workspaceRegistry.setCheckoutStatus(registered.workspace.id, "local", "ready");
+          }
           return reply.code(409).send({
             error: "Worktree has uncommitted changes"
           });
@@ -239930,6 +240267,7 @@ var routes9 = async (fastify2) => {
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       });
+      worktreeRemoved = true;
       invalidateWorktreeListCache(projectPath);
       if (branchToDelete) {
         try {
@@ -239941,9 +240279,15 @@ var routes9 = async (fastify2) => {
         } catch {
         }
       }
+      if (registered) {
+        await fastify2.storage.workspaceRegistry.removeCheckout(registered.workspace.id, "local");
+      }
       return reply.code(200).send({ success: true });
     } catch (error48) {
       const errorMessage = error48 instanceof Error ? error48.message : "Unknown error";
+      if (registered && !worktreeRemoved) {
+        await fastify2.storage.workspaceRegistry.setCheckoutStatus(registered.workspace.id, "local", "error", errorMessage).catch((registryError) => console.error("[worktree] Failed to record delete error:", registryError));
+      }
       return reply.code(500).send({ error: `Failed to delete worktree: ${errorMessage}` });
     }
   });
@@ -239983,7 +240327,7 @@ var routes9 = async (fastify2) => {
     }
     try {
       pruneWorktrees(project.path);
-      const worktrees = getWorktreeBranches(project.path);
+      const worktrees = await getRegisteredWorktreeBranches(fastify2.storage, project.id, project.path);
       return reply.code(200).send({ worktrees });
     } catch (error48) {
       const errorMessage = error48 instanceof Error ? error48.message : "Unknown error";
@@ -240055,13 +240399,44 @@ var routes9 = async (fastify2) => {
     const remoteConfigs = await getAllRemoteConfigs(fastify2, project);
     const hasRemote = remoteConfigs.length > 0;
     const deleteOnRemote = async (rc) => {
-      return proxyToRemoteAuto(
-        rc.serverId,
-        "DELETE",
-        `/api/path/worktrees`,
-        { path: rc.remotePath, branch },
-        { reverseConnectManager: fastify2.reverseConnectManager }
-      );
+      const registered = await fastify2.storage.workspaceRegistry.getByProjectBranch(project.id, branch, rc.serverId);
+      const restorePreviousStatus = async () => {
+        if (!registered) return;
+        const current = await fastify2.storage.workspaceRegistry.getByProjectBranch(project.id, branch, rc.serverId);
+        if (!current || current.checkout.status !== "deleting") return;
+        await fastify2.storage.workspaceRegistry.setCheckoutStatusIfCurrent(
+          registered.workspace.id,
+          rc.serverId,
+          { status: "deleting", updatedAt: current.checkout.updated_at },
+          registered.checkout.status,
+          registered.checkout.error
+        );
+      };
+      if (registered) {
+        await fastify2.storage.workspaceRegistry.setCheckoutStatus(registered.workspace.id, rc.serverId, "deleting");
+      }
+      try {
+        const result = await proxyToRemoteAuto(
+          rc.serverId,
+          "DELETE",
+          `/api/path/worktrees`,
+          { path: rc.remotePath, branch },
+          { reverseConnectManager: fastify2.reverseConnectManager }
+        );
+        if (registered) {
+          if (result.ok) {
+            await fastify2.storage.workspaceRegistry.removeCheckout(registered.workspace.id, rc.serverId);
+          } else {
+            await restorePreviousStatus();
+          }
+        }
+        return result;
+      } catch (error48) {
+        if (registered) {
+          await restorePreviousStatus().catch((registryError) => console.error("[worktree] Failed to restore remote checkout status:", registryError));
+        }
+        throw error48;
+      }
     };
     if (!hasLocal && hasRemote) {
       if (remoteConfigs.length === 1) {
@@ -240098,40 +240473,58 @@ var routes9 = async (fastify2) => {
     const deleteLocal = async () => {
       const { execSync: execSync2, execFileSync: execFileSync7 } = await import("child_process");
       const worktreeAbsPath = resolveWorktreePath(project.path, branch);
-      try {
-        const statusOutput = execSync2("git status --porcelain", {
-          cwd: worktreeAbsPath,
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        if (statusOutput.trim() !== "") {
-          throw new Error("Worktree has uncommitted changes. Please commit or discard changes before deleting.");
-        }
-      } catch (err) {
-        if (err instanceof Error && err.message.includes("uncommitted changes")) throw err;
+      const registered = await fastify2.storage.workspaceRegistry.getByProjectBranch(project.id, branch, "local");
+      if (registered) {
+        await fastify2.storage.workspaceRegistry.setCheckoutStatus(registered.workspace.id, "local", "deleting");
       }
-      let branchToDelete = null;
+      let worktreeRemoved = false;
       try {
-        const entries = parseGitWorktreeList(project.path);
-        const match2 = entries.find((e) => e.path === worktreeAbsPath);
-        if (match2) branchToDelete = match2.branch;
-      } catch {
-      }
-      execFileSync7("git", ["worktree", "remove", worktreeAbsPath], {
-        cwd: project.path,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      invalidateWorktreeListCache(project.path);
-      if (branchToDelete) {
         try {
-          execFileSync7("git", ["branch", "-d", branchToDelete], {
-            cwd: project.path,
+          const statusOutput = execSync2("git status --porcelain", {
+            cwd: worktreeAbsPath,
             encoding: "utf-8",
             stdio: ["pipe", "pipe", "pipe"]
           });
+          if (statusOutput.trim() !== "") {
+            throw new Error("Worktree has uncommitted changes. Please commit or discard changes before deleting.");
+          }
+        } catch (err) {
+          if (err instanceof Error && err.message.includes("uncommitted changes")) throw err;
+        }
+        let branchToDelete = null;
+        try {
+          const entries = parseGitWorktreeList(project.path);
+          const match2 = entries.find((e) => e.path === worktreeAbsPath);
+          if (match2) branchToDelete = match2.branch;
         } catch {
         }
+        execFileSync7("git", ["worktree", "remove", worktreeAbsPath], {
+          cwd: project.path,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        worktreeRemoved = true;
+        invalidateWorktreeListCache(project.path);
+        if (branchToDelete) {
+          try {
+            execFileSync7("git", ["branch", "-d", branchToDelete], {
+              cwd: project.path,
+              encoding: "utf-8",
+              stdio: ["pipe", "pipe", "pipe"]
+            });
+          } catch {
+          }
+        }
+        if (registered) {
+          await fastify2.storage.workspaceRegistry.removeCheckout(registered.workspace.id, "local");
+        }
+      } catch (error48) {
+        if (registered && !worktreeRemoved) {
+          const message = error48 instanceof Error ? error48.message : "Local deletion failed";
+          const status = message.includes("uncommitted changes") ? "ready" : "error";
+          await fastify2.storage.workspaceRegistry.setCheckoutStatus(registered.workspace.id, "local", status, status === "error" ? message : null).catch((registryError) => console.error("[worktree] Failed to record local delete error:", registryError));
+        }
+        throw error48;
       }
     };
     if (!hasRemote) {
@@ -240218,13 +240611,47 @@ var routes9 = async (fastify2) => {
       return reply.code(400).send({ error: "Project has no remote configuration" });
     }
     const createOnRemote = async (rc) => {
-      return proxyToRemoteAuto(
-        rc.serverId,
-        "POST",
-        `/api/path/worktrees`,
-        { path: rc.remotePath, branchName: trimmedBranch, baseBranch: remoteStartPoint },
-        { reverseConnectManager: fastify2.reverseConnectManager }
-      );
+      const previous = await fastify2.storage.workspaceRegistry.getByProjectBranch(project.id, trimmedBranch, rc.serverId);
+      const preserveReady = previous?.checkout.status === "ready";
+      const pending = preserveReady && previous ? previous : await fastify2.storage.workspaceRegistry.beginCheckout({
+        projectId: project.id,
+        branch: trimmedBranch,
+        targetId: rc.serverId,
+        worktreePath: conventionalWorktreePath(rc.remotePath, trimmedBranch),
+        expectedBranch: trimmedBranch
+      });
+      try {
+        const result = await proxyToRemoteAuto(
+          rc.serverId,
+          "POST",
+          `/api/path/worktrees`,
+          { path: rc.remotePath, branchName: trimmedBranch, baseBranch: remoteStartPoint },
+          { reverseConnectManager: fastify2.reverseConnectManager }
+        );
+        if (result.ok) {
+          await fastify2.storage.workspaceRegistry.setCheckoutStatus(pending.workspace.id, rc.serverId, "ready");
+        } else if (preserveReady) {
+          await fastify2.storage.workspaceRegistry.setCheckoutStatus(pending.workspace.id, rc.serverId, "ready");
+        } else {
+          const detail = result.data;
+          await fastify2.storage.workspaceRegistry.setCheckoutStatus(
+            pending.workspace.id,
+            rc.serverId,
+            "error",
+            detail.error ?? result.errorCode ?? "Remote creation failed"
+          );
+        }
+        return result;
+      } catch (error48) {
+        const message = error48 instanceof Error ? error48.message : "Remote creation failed";
+        await fastify2.storage.workspaceRegistry.setCheckoutStatus(
+          pending.workspace.id,
+          rc.serverId,
+          preserveReady ? "ready" : "error",
+          preserveReady ? null : message
+        ).catch((registryError) => console.error("[worktree] Failed to record remote checkout error:", registryError));
+        throw error48;
+      }
     };
     if (targets.length === 1 && targets[0] === "remote") {
       if (remoteConfigs.length === 1) {
@@ -240275,14 +240702,28 @@ var routes9 = async (fastify2) => {
         if (err instanceof Error && err.message.includes("already exists")) throw err;
       }
       const worktreeAbsolutePath = resolveWorktreePath(project.path, trimmedBranch);
-      await mkdir3(getWorktreeBaseForProject(project.path), { recursive: true });
-      execFileSync7("git", ["worktree", "add", "-b", trimmedBranch, worktreeAbsolutePath, localStartPoint], {
-        cwd: project.path,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
+      const pending = await fastify2.storage.workspaceRegistry.beginCheckout({
+        projectId: project.id,
+        branch: trimmedBranch,
+        targetId: "local",
+        worktreePath: worktreeAbsolutePath,
+        expectedBranch: trimmedBranch
       });
-      invalidateWorktreeListCache(project.path);
-      return { branch: trimmedBranch };
+      try {
+        await mkdir3(getWorktreeBaseForProject(project.path), { recursive: true });
+        execFileSync7("git", ["worktree", "add", "-b", trimmedBranch, worktreeAbsolutePath, localStartPoint], {
+          cwd: project.path,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        invalidateWorktreeListCache(project.path);
+        await fastify2.storage.workspaceRegistry.setCheckoutStatus(pending.workspace.id, "local", "ready");
+        return { branch: trimmedBranch };
+      } catch (error48) {
+        const message = error48 instanceof Error ? error48.message : "Local creation failed";
+        await fastify2.storage.workspaceRegistry.setCheckoutStatus(pending.workspace.id, "local", "error", message).catch((registryError) => console.error("[worktree] Failed to record local checkout error:", registryError));
+        throw error48;
+      }
     };
     if (targets.length === 1 && targets[0] === "local") {
       try {
@@ -246516,23 +246957,6 @@ var event_routes_default = (0, import_fastify_plugin27.default)(routes26, { name
 // src/routes/terminal-routes.ts
 var import_fastify_plugin28 = __toESM(require_plugin2(), 1);
 import path13 from "path";
-
-// src/utils/path-project.ts
-async function ensurePathProjectId(fastify2, projectPath) {
-  const pseudoProjectId = `path:${projectPath}`;
-  if (await fastify2.storage.projects.getById(pseudoProjectId)) return pseudoProjectId;
-  const existingByPath = await fastify2.storage.projects.getByPath(projectPath);
-  if (existingByPath) return existingByPath.id;
-  const name25 = projectPath.split("/").filter(Boolean).pop() || projectPath;
-  try {
-    await fastify2.storage.projects.create({ id: pseudoProjectId, name: name25, path: projectPath });
-  } catch (err) {
-    if (!(err instanceof Error && err.message.includes("UNIQUE constraint failed"))) throw err;
-  }
-  return pseudoProjectId;
-}
-
-// src/routes/terminal-routes.ts
 async function getRemoteConfig5(fastify2, project, remoteServerId) {
   const remotes = await fastify2.storage.projectRemotes.getByProject(project.id);
   const target = remoteServerId ? remotes.find((r) => r.remote_server_id === remoteServerId) : remotes[0];
@@ -248145,8 +248569,8 @@ var parseDbTimestamp5 = (ts) => {
 };
 async function buildSearchCatalog(deps, projectId, projectPath) {
   pruneWorktrees(projectPath);
-  const workspaces = getWorktreeBranches(projectPath);
   const sessions = await deps.storage.agentSessions.getByProjectId(projectId);
+  const workspaces = await getRegisteredWorktreeBranches(deps.storage, projectId, projectPath);
   const counts = new Map(
     (await deps.storage.agentSessions.countEntries()).map((r) => [r.session_id, r.cnt])
   );

package/package.json

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