@vibe80/vibe80 0.1.1

package/server/src/worktreeManager.js

@@ -0,0 +1,717 @@
+import path from "path";
+import crypto from "crypto";
+import { runAsCommand, runAsCommandOutput } from "./runAs.js";
+import storage from "./storage/index.js";
+import { getSessionRuntime } from "./runtimeStore.js";
+import { createWorktreeClient } from "./clientFactory.js";
+import { createMessageId, toIsoDateTime } from "./helpers.js";
+import { copyClaudeThreadDirectory } from "./services/claudeThreadDirectory.js";
+
+const MAIN_WORKTREE_SENTINEL = "main";
+const MAIN_WORKTREE_PREFIX = "main-";
+
+export const getMainWorktreeStorageId = (sessionId) =>
+  `${MAIN_WORKTREE_PREFIX}${sessionId}`;
+
+const resolveWorktreeStorageId = (session, worktreeId) => {
+  if (!worktreeId) return worktreeId;
+  if (worktreeId === MAIN_WORKTREE_SENTINEL) {
+    return getMainWorktreeStorageId(session.sessionId);
+  }
+  return worktreeId;
+};
+
+const isMainWorktreeStorageId = (session, worktreeId) =>
+  worktreeId === getMainWorktreeStorageId(session.sessionId);
+
+// Palette de couleurs pour distinguer les worktrees
+const WORKTREE_COLORS = [
+  "#3b82f6", // blue
+  "#10b981", // emerald
+  "#f59e0b", // amber
+  "#ef4444", // red
+  "#8b5cf6", // violet
+  "#ec4899", // pink
+  "#06b6d4", // cyan
+  "#84cc16", // lime
+];
+
+let colorIndex = 0;
+const getNextColor = () => {
+  const color = WORKTREE_COLORS[colorIndex % WORKTREE_COLORS.length];
+  colorIndex += 1;
+  return color;
+};
+
+const buildSessionEnv = (session, options = {}) => {
+  const env = { ...(options.env || {}) };
+  if (session?.dir) {
+    env.TMPDIR = path.join(session.dir, "tmp");
+  }
+  return env;
+};
+
+const runSessionCommand = (session, command, args, options = {}) =>
+  runAsCommand(session.workspaceId, command, args, {
+    ...options,
+    env: buildSessionEnv(session, options),
+  });
+
+const runSessionCommandOutput = (session, command, args, options = {}) =>
+  runAsCommandOutput(session.workspaceId, command, args, {
+    ...options,
+    env: buildSessionEnv(session, options),
+  });
+
+const resolveSessionGitDir = (session) =>
+  session?.gitDir || path.join(session.dir, "git");
+
+const ensureSessionGitDir = async (session) => {
+  const gitDir = resolveSessionGitDir(session);
+  await runAsCommand(session.workspaceId, "/bin/mkdir", ["-p", gitDir]);
+  await runAsCommand(session.workspaceId, "/bin/chmod", ["2750", gitDir]);
+  return gitDir;
+};
+
+const applyVibe80WorktreeMetadata = async (session, worktreePath, worktreeId) => {
+  await runSessionCommand(
+    session,
+    "git",
+    ["-C", worktreePath, "config", "--worktree", "vibe80.workspaceId", session.workspaceId]
+  );
+  await runSessionCommand(
+    session,
+    "git",
+    ["-C", worktreePath, "config", "--worktree", "vibe80.sessionId", session.sessionId]
+  );
+  await runSessionCommand(
+    session,
+    "git",
+    ["-C", worktreePath, "config", "--worktree", "vibe80.worktreeId", worktreeId]
+  );
+};
+
+const resolveStartingRef = (startingBranch, remote = "origin") => {
+  if (!startingBranch || typeof startingBranch !== "string") {
+    return null;
+  }
+  const trimmed = startingBranch.trim();
+  if (!trimmed) {
+    return null;
+  }
+  if (trimmed.startsWith("refs/")) {
+    return trimmed;
+  }
+  if (trimmed.startsWith(`${remote}/`)) {
+    return trimmed;
+  }
+  return `${remote}/${trimmed}`;
+};
+
+const normalizeBranchName = (value, remote = "origin") => {
+  if (!value || typeof value !== "string") {
+    return "";
+  }
+  let name = value.trim();
+  if (!name) {
+    return "";
+  }
+  if (name.startsWith("refs/heads/")) {
+    name = name.slice("refs/heads/".length);
+  } else if (name.startsWith(`refs/remotes/${remote}/`)) {
+    name = name.slice(`refs/remotes/${remote}/`.length);
+  } else if (name.startsWith(`${remote}/`)) {
+    name = name.slice(`${remote}/`.length);
+  }
+  return name.trim();
+};
+
+const resolveCurrentBranchName = async (session) => {
+  const output = await runSessionCommandOutput(
+    session,
+    "git",
+    ["rev-parse", "--abbrev-ref", "HEAD"],
+    { cwd: session.repoDir }
+  );
+  return output.trim();
+};
+
+const serializeWorktree = (worktree) => {
+  if (!worktree) return null;
+  const { client, ...persisted } = worktree;
+  return persisted;
+};
+
+const resolveSessionDenyGitCredentialsAccess = (session) =>
+  typeof session?.defaultDenyGitCredentialsAccess === "boolean"
+    ? session.defaultDenyGitCredentialsAccess
+    : true;
+
+const touchSession = async (session) => {
+  const updated = { ...session, lastActivityAt: Date.now() };
+  await storage.saveSession(session.sessionId, updated);
+  return updated;
+};
+
+const loadWorktree = async (worktreeId) => {
+  if (!worktreeId) return null;
+  return storage.getWorktree(worktreeId);
+};
+
+const ensureMainWorktree = async (session) => {
+  const worktreeId = getMainWorktreeStorageId(session.sessionId);
+  const existing = await loadWorktree(worktreeId);
+  if (existing) return existing;
+  const branchName = await resolveCurrentBranchName(session);
+  const worktree = {
+    id: worktreeId,
+    sessionId: session.sessionId,
+    name: branchName || "main",
+    branchName: branchName || "main",
+    threadId: session.threadId || null,
+    path: session.repoDir,
+    provider: session.activeProvider || "codex",
+    model: null,
+    reasoningEffort: null,
+    internetAccess: Boolean(session.defaultInternetAccess),
+    denyGitCredentialsAccess: resolveSessionDenyGitCredentialsAccess(session),
+    startingBranch: branchName || null,
+    workspaceId: session.workspaceId,
+    status: "ready",
+    parentWorktreeId: null,
+    createdAt: new Date().toISOString(),
+    lastActivityAt: new Date().toISOString(),
+    color: getNextColor(),
+  };
+  await storage.saveWorktree(session.sessionId, worktreeId, serializeWorktree(worktree));
+  return worktree;
+};
+
+/**
+ * Génère un nom de worktree à partir du premier message ou un nom par défaut
+ */
+const generateWorktreeName = (text, index) => {
+  if (text) {
+    const cleaned = text
+      .slice(0, 30)
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "");
+    if (cleaned.length > 2) {
+      return cleaned;
+    }
+  }
+  return `branch-${index}`;
+};
+
+/**
+ * Crée un nouveau worktree pour une session
+ */
+export async function createWorktree(session, options) {
+  const {
+    context,
+    provider,
+    sourceWorktree,
+    name,
+    parentWorktreeId,
+    startingBranch,
+    model,
+    reasoningEffort,
+    internetAccess,
+    denyGitCredentialsAccess,
+  } = options;
+  const creationContext = context === "fork" ? "fork" : "new";
+  let resolvedProvider = provider;
+  let resolvedModel = model || null;
+  let resolvedReasoningEffort = reasoningEffort || null;
+  let resolvedSourceWorktreeId = null;
+  let forkSourceThreadId = null;
+  let sourceWorktreeRecord = null;
+
+  if (creationContext === "fork") {
+    sourceWorktreeRecord = await getWorktree(session, sourceWorktree);
+    if (!sourceWorktreeRecord) {
+      throw new Error("Source worktree not found.");
+    }
+    resolvedProvider = sourceWorktreeRecord.provider;
+    resolvedModel = null;
+    resolvedReasoningEffort = null;
+    resolvedSourceWorktreeId = sourceWorktree === "main" ? "main" : sourceWorktreeRecord.id;
+    forkSourceThreadId =
+      sourceWorktreeRecord.threadId ||
+      (resolvedSourceWorktreeId === "main" ? session.threadId || null : null);
+    if (!forkSourceThreadId) {
+      throw new Error("Source worktree has no threadId to fork from.");
+    }
+  }
+
+  if (resolvedProvider !== "codex" && resolvedProvider !== "claude") {
+    throw new Error("Invalid provider for worktree creation.");
+  }
+  const resolvedDenyGitCredentialsAccess =
+    typeof denyGitCredentialsAccess === "boolean"
+      ? denyGitCredentialsAccess
+      : typeof sourceWorktreeRecord?.denyGitCredentialsAccess === "boolean"
+        ? sourceWorktreeRecord.denyGitCredentialsAccess
+      : resolveSessionDenyGitCredentialsAccess(session);
+  const resolvedInternetAccess =
+    typeof internetAccess === "boolean"
+      ? internetAccess
+      : typeof sourceWorktreeRecord?.internetAccess === "boolean"
+        ? sourceWorktreeRecord.internetAccess
+        : true;
+  const shareGitCredentials = !resolvedDenyGitCredentialsAccess;
+
+  const worktreesDir = path.join(session.dir, "worktrees");
+  await runAsCommand(session.workspaceId, "/bin/mkdir", ["-p", worktreesDir]);
+  await runAsCommand(session.workspaceId, "/bin/chmod", ["2750", worktreesDir]);
+
+  const worktreeId = crypto.randomBytes(8).toString("hex");
+  const existingWorktrees = await listStoredWorktrees(session);
+  const worktreeIndex = existingWorktrees.length + 1;
+  const requestedBranchName = normalizeBranchName(name);
+  const worktreePath = path.join(worktreesDir, worktreeId);
+
+  let startCommit = "HEAD";
+  let sourceBranchName = "";
+  if (parentWorktreeId) {
+    const parent = await loadWorktree(parentWorktreeId);
+    if (parent) {
+      startCommit = await runSessionCommandOutput(
+        session,
+        "git",
+        ["rev-parse", "HEAD"],
+        { cwd: parent.path }
+      );
+      startCommit = startCommit.trim();
+      sourceBranchName = parent.branchName || "";
+    }
+  } else if (startingBranch) {
+    startCommit = resolveStartingRef(startingBranch) || startingBranch;
+    sourceBranchName = normalizeBranchName(startingBranch);
+  } else {
+    sourceBranchName = await resolveCurrentBranchName(session);
+  }
+
+  const baseName =
+    requestedBranchName ||
+    sourceBranchName ||
+    generateWorktreeName(null, worktreeIndex);
+  const defaultDisplayName = `wt-${worktreeId.slice(0, 6)}-${baseName}`;
+  const branchName = requestedBranchName
+    ? requestedBranchName
+    : `wt-${worktreeId.slice(0, 6)}-${baseName}`;
+
+  const checkRemoteBranchExists = async (branch) => {
+    const remoteRef = resolveStartingRef(branch);
+    if (!remoteRef) return false;
+    const remoteVerifyRef = remoteRef.startsWith("refs/")
+      ? remoteRef
+      : `refs/remotes/${remoteRef}`;
+    try {
+      await runSessionCommand(session, "git", ["show-ref", "--verify", remoteVerifyRef], {
+        cwd: session.repoDir,
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  const remoteBranchExists = requestedBranchName
+    ? await checkRemoteBranchExists(requestedBranchName)
+    : false;
+
+  if (requestedBranchName) {
+    if (remoteBranchExists) {
+      await runSessionCommand(
+        session,
+        "git",
+        ["branch", branchName, resolveStartingRef(requestedBranchName)],
+        { cwd: session.repoDir }
+      );
+    } else {
+      if (!parentWorktreeId && !startingBranch) {
+        throw new Error("Branche source requise pour creer une nouvelle branche.");
+      }
+      await runSessionCommand(session, "git", ["branch", branchName, startCommit], {
+        cwd: session.repoDir,
+      });
+    }
+  } else {
+    await runSessionCommand(session, "git", ["branch", branchName, startCommit], {
+      cwd: session.repoDir,
+    });
+  }
+
+  await runSessionCommand(
+    session,
+    "git",
+    ["config", `branch.${branchName}.remote`, "origin"],
+    { cwd: session.repoDir }
+  );
+  await runSessionCommand(
+    session,
+    "git",
+    ["config", `branch.${branchName}.merge`, `refs/heads/${branchName}`],
+    { cwd: session.repoDir }
+  );
+
+  await runSessionCommand(
+    session,
+    "git",
+    ["worktree", "add", worktreePath, branchName],
+    { cwd: session.repoDir }
+  );
+  await runAsCommand(session.workspaceId, "/bin/chmod", ["2750", worktreePath]);
+  await applyVibe80WorktreeMetadata(session, worktreePath, worktreeId);
+  if (creationContext === "fork" && resolvedProvider === "claude" && sourceWorktreeRecord?.path) {
+    await copyClaudeThreadDirectory(session.workspaceId, sourceWorktreeRecord.path, worktreePath);
+  }
+
+  if (shareGitCredentials) {
+    await ensureSessionGitDir(session);
+  }
+
+  const worktree = {
+    id: worktreeId,
+    sessionId: session.sessionId,
+    name: name && String(name).trim() ? baseName : defaultDisplayName,
+    branchName,
+    threadId: null,
+    path: worktreePath,
+    provider: resolvedProvider,
+    model: resolvedModel,
+    reasoningEffort: resolvedReasoningEffort,
+    context: creationContext,
+    sourceWorktreeId: resolvedSourceWorktreeId,
+    forkSourceThreadId: creationContext === "fork" ? forkSourceThreadId : null,
+    internetAccess: Boolean(resolvedInternetAccess),
+    denyGitCredentialsAccess: resolvedDenyGitCredentialsAccess,
+    startingBranch: startingBranch || null,
+    workspaceId: session.workspaceId,
+    status: "creating",
+    parentWorktreeId: parentWorktreeId || null,
+    createdAt: new Date().toISOString(),
+    lastActivityAt: new Date().toISOString(),
+    color: getNextColor(),
+  };
+
+  await storage.saveWorktree(session.sessionId, worktreeId, serializeWorktree(worktree));
+  await touchSession(session);
+
+  try {
+    const client = createWorktreeClient(
+      worktree,
+      session.attachmentsDir,
+      session.repoDir,
+      worktree.internetAccess,
+      worktree.threadId,
+      resolveSessionGitDir(session),
+      {
+        threadStartMode: creationContext === "fork" ? "fork" : "new",
+        sourceThreadId: creationContext === "fork" ? forkSourceThreadId : null,
+      }
+    );
+    const runtime = getSessionRuntime(session.sessionId);
+    if (runtime) {
+      runtime.worktreeClients.set(worktreeId, client);
+    }
+    worktree.client = client;
+    worktree.status = "ready";
+  } catch (error) {
+    worktree.status = "error";
+    await storage.saveWorktree(session.sessionId, worktreeId, serializeWorktree(worktree));
+    throw error;
+  }
+
+  return worktree;
+}
+
+/**
+ * Supprime un worktree
+ */
+export async function removeWorktree(session, worktreeId, deleteBranch = true) {
+  const resolvedId = resolveWorktreeStorageId(session, worktreeId);
+  if (isMainWorktreeStorageId(session, resolvedId)) {
+    throw new Error("Main worktree cannot be removed");
+  }
+  const worktree = await loadWorktree(resolvedId);
+  if (!worktree) {
+    throw new Error("Worktree not found");
+  }
+
+  const runtime = getSessionRuntime(session.sessionId);
+  const client = runtime?.worktreeClients?.get(resolvedId);
+  if (client) {
+    try {
+      if (typeof client.stop === "function") {
+        await client.stop();
+      }
+    } catch (error) {
+      console.error("Error stopping worktree client:", error);
+    }
+    runtime.worktreeClients.delete(resolvedId);
+  }
+
+  await runSessionCommand(
+    session,
+    "git",
+    ["worktree", "remove", "--force", worktree.path],
+    { cwd: session.repoDir }
+  );
+
+  if (deleteBranch) {
+    try {
+      await runSessionCommand(session, "git", ["branch", "-D", worktree.branchName], {
+        cwd: session.repoDir,
+      });
+    } catch {
+      console.warn("Could not delete branch:", worktree.branchName);
+    }
+  }
+
+  await storage.deleteWorktree(session.sessionId, resolvedId);
+  await touchSession(session);
+}
+
+export async function getWorktreeDiff(session, worktreeId) {
+  const resolvedId = resolveWorktreeStorageId(session, worktreeId);
+  const worktree = await loadWorktree(resolvedId);
+  if (!worktree) {
+    throw new Error("Worktree not found");
+  }
+  const [status, diff] = await Promise.all([
+    runSessionCommandOutput(session, "git", ["status", "--porcelain"], {
+      cwd: worktree.path,
+    }),
+    runSessionCommandOutput(session, "git", ["diff"], { cwd: worktree.path }),
+  ]);
+  return { status, diff };
+}
+
+export async function getWorktreeCommits(session, worktreeId, limit = 20) {
+  const resolvedId = resolveWorktreeStorageId(session, worktreeId);
+  const worktree = await loadWorktree(resolvedId);
+  if (!worktree) {
+    throw new Error("Worktree not found");
+  }
+
+  const output = await runSessionCommandOutput(
+    session,
+    "git",
+    ["log", `--max-count=${limit}`, "--format=%H|%s|%cI"],
+    { cwd: worktree.path }
+  );
+
+  return output
+    .trim()
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      const [sha, message, date] = line.split("|");
+      return { sha, message, date: toIsoDateTime(date) };
+    });
+}
+
+export async function mergeWorktree(session, sourceWorktreeId, targetWorktreeId) {
+  const source = await loadWorktree(resolveWorktreeStorageId(session, sourceWorktreeId));
+  if (!source) {
+    throw new Error("Source worktree not found");
+  }
+  const target = await loadWorktree(resolveWorktreeStorageId(session, targetWorktreeId));
+  if (!target) {
+    throw new Error("Target worktree not found");
+  }
+
+  try {
+    await runSessionCommand(session, "git", ["merge", source.branchName, "--no-edit"], {
+      cwd: target.path,
+    });
+    return { success: true };
+  } catch (error) {
+    const status = await runSessionCommandOutput(
+      session,
+      "git",
+      ["status", "--porcelain"],
+      { cwd: target.path }
+    );
+    const conflicts = status
+      .split("\n")
+      .filter((line) => line.startsWith("UU") || line.startsWith("AA"))
+      .map((line) => line.slice(3).trim());
+    if (conflicts.length > 0) {
+      return { success: false, conflicts };
+    }
+    throw error;
+  }
+}
+
+export async function abortMerge(session, worktreeId) {
+  const worktree = await loadWorktree(resolveWorktreeStorageId(session, worktreeId));
+  if (!worktree) {
+    throw new Error("Worktree not found");
+  }
+  await runSessionCommand(session, "git", ["merge", "--abort"], { cwd: worktree.path });
+}
+
+export async function cherryPickCommit(session, commitSha, targetWorktreeId) {
+  const target = await loadWorktree(resolveWorktreeStorageId(session, targetWorktreeId));
+  if (!target) {
+    throw new Error("Target worktree not found");
+  }
+  try {
+    await runSessionCommand(session, "git", ["cherry-pick", commitSha], {
+      cwd: target.path,
+    });
+    return { success: true };
+  } catch (error) {
+    const status = await runSessionCommandOutput(
+      session,
+      "git",
+      ["status", "--porcelain"],
+      { cwd: target.path }
+    );
+    const conflicts = status
+      .split("\n")
+      .filter((line) => line.startsWith("UU") || line.startsWith("AA"))
+      .map((line) => line.slice(3).trim());
+    if (conflicts.length > 0) {
+      return { success: false, conflicts };
+    }
+    throw error;
+  }
+}
+
+export async function listStoredWorktrees(session) {
+  const worktrees = await storage.listWorktrees(session.sessionId);
+  return worktrees.filter((wt) => !isMainWorktreeStorageId(session, wt?.id));
+}
+
+export async function listWorktrees(session) {
+  const worktrees = await listStoredWorktrees(session);
+  return worktrees.map((wt) => ({
+    id: wt.id,
+    name: wt.name,
+    branchName: wt.branchName,
+    provider: wt.provider,
+    model: wt.model || null,
+    reasoningEffort: wt.reasoningEffort || null,
+    context: wt.context || "new",
+    sourceWorktreeId: wt.sourceWorktreeId || null,
+    status: wt.status,
+    parentWorktreeId: wt.parentWorktreeId,
+    internetAccess: Boolean(wt.internetAccess),
+    denyGitCredentialsAccess:
+      typeof wt.denyGitCredentialsAccess === "boolean"
+        ? wt.denyGitCredentialsAccess
+        : true,
+    createdAt: toIsoDateTime(wt.createdAt),
+    lastActivityAt: toIsoDateTime(wt.lastActivityAt),
+    color: wt.color,
+  }));
+}
+
+export async function getWorktree(session, worktreeId) {
+  const resolvedId = resolveWorktreeStorageId(session, worktreeId);
+  if (isMainWorktreeStorageId(session, resolvedId)) {
+    const mainWorktree = await ensureMainWorktree(session);
+    return mainWorktree;
+  }
+  const worktree = await loadWorktree(resolvedId);
+  if (!worktree) return null;
+  const runtime = getSessionRuntime(session.sessionId);
+  if (runtime?.worktreeClients?.has(resolvedId)) {
+    worktree.client = runtime.worktreeClients.get(resolvedId);
+  }
+  return worktree;
+}
+
+export async function updateWorktreeStatus(session, worktreeId, status) {
+  const resolvedId = resolveWorktreeStorageId(session, worktreeId);
+  let worktree = await loadWorktree(resolvedId);
+  if (!worktree && isMainWorktreeStorageId(session, resolvedId)) {
+    worktree = await ensureMainWorktree(session);
+  }
+  if (!worktree) return;
+  const updated = {
+    ...worktree,
+    status,
+    lastActivityAt: new Date().toISOString(),
+  };
+  await storage.saveWorktree(session.sessionId, resolvedId, serializeWorktree(updated));
+}
+
+export async function updateWorktreeThreadId(session, worktreeId, threadId) {
+  const resolvedId = resolveWorktreeStorageId(session, worktreeId);
+  const worktree = await loadWorktree(resolvedId);
+  if (!worktree || !threadId) return;
+  const updated = {
+    ...worktree,
+    threadId,
+    lastActivityAt: new Date().toISOString(),
+  };
+  await storage.saveWorktree(session.sessionId, resolvedId, serializeWorktree(updated));
+}
+
+export async function updateWorktreeModel(
+  session,
+  worktreeId,
+  model = null,
+  reasoningEffort = null
+) {
+  const resolvedId = resolveWorktreeStorageId(session, worktreeId);
+  let worktree = await loadWorktree(resolvedId);
+  if (!worktree && isMainWorktreeStorageId(session, resolvedId)) {
+    worktree = await ensureMainWorktree(session);
+  }
+  if (!worktree) return;
+  const updated = {
+    ...worktree,
+    model: model || null,
+    reasoningEffort: reasoningEffort || null,
+    lastActivityAt: new Date().toISOString(),
+  };
+  await storage.saveWorktree(session.sessionId, resolvedId, serializeWorktree(updated));
+}
+
+export async function appendWorktreeMessage(session, worktreeId, message) {
+  const resolvedId = resolveWorktreeStorageId(session, worktreeId);
+  let worktree = await loadWorktree(resolvedId);
+  if (!worktree && isMainWorktreeStorageId(session, resolvedId)) {
+    worktree = await ensureMainWorktree(session);
+  }
+  if (!worktree) return;
+  const messageId = message?.id || createMessageId();
+  const payload = message?.id ? message : { ...message, id: messageId };
+  await storage.appendWorktreeMessage(session.sessionId, resolvedId, payload);
+  const updated = {
+    ...worktree,
+    lastActivityAt: new Date().toISOString(),
+  };
+  await storage.saveWorktree(session.sessionId, resolvedId, serializeWorktree(updated));
+}
+
+export async function clearWorktreeMessages(session, worktreeId) {
+  const resolvedId = resolveWorktreeStorageId(session, worktreeId);
+  let worktree = await loadWorktree(resolvedId);
+  if (!worktree && isMainWorktreeStorageId(session, resolvedId)) {
+    worktree = await ensureMainWorktree(session);
+  }
+  if (!worktree) return;
+  await storage.clearWorktreeMessages(session.sessionId, resolvedId);
+  const updated = {
+    ...worktree,
+    lastActivityAt: new Date().toISOString(),
+  };
+  await storage.saveWorktree(session.sessionId, resolvedId, serializeWorktree(updated));
+}
+
+export async function renameWorktree(session, worktreeId, newName) {
+  const resolvedId = resolveWorktreeStorageId(session, worktreeId);
+  if (isMainWorktreeStorageId(session, resolvedId)) return;
+  const worktree = await loadWorktree(resolvedId);
+  if (!worktree || !newName) return;
+  const updated = { ...worktree, name: newName };
+  await storage.saveWorktree(session.sessionId, resolvedId, serializeWorktree(updated));
+}