Method renameWorkspace

src/node/runtime/SSHRuntime.ts:3097–3168

(
    projectPath: string,
    oldName: string,
    newName: string,
    abortSignal?: AbortSignal
  )

  }

  async renameWorkspace(
    projectPath: string,
    oldName: string,
    newName: string,
    abortSignal?: AbortSignal
  ): Promise<
    { success: true; oldPath: string; newPath: string } | { success: false; error: string }
  > {
    // Check if already aborted
    if (abortSignal?.aborted) {
      return { success: false, error: "Rename operation aborted" };
    }
    const oldPath = this.getWorkspacePath(projectPath, oldName);
    const newPath = path.posix.join(path.posix.dirname(oldPath), newName);

    try {
      const expandedOldPath = expandTildeForSSH(oldPath);
      const expandedNewPath = expandTildeForSSH(newPath);

      // Detect if workspace is a worktree vs legacy full clone.
      const isWorktree = await this.isWorktreeWorkspace(oldPath, abortSignal);

      let moveCommand: string;
      if (isWorktree) {
        // Worktree: use `git worktree move` to keep the workspace registered in whichever
        // shared base repo originally created it, including upgraded legacy SSH layouts.
        const baseRepoPathArg = expandTildeForSSH(
          await this.resolveWorktreeBaseRepoPath(projectPath, oldPath, abortSignal)
        );
        moveCommand = `git -C ${baseRepoPathArg} worktree move ${expandedOldPath} ${expandedNewPath}`;
      } else {
        // Legacy full clone: plain mv.
        moveCommand = `mv ${expandedOldPath} ${expandedNewPath}`;
      }

      const stream = await this.exec(moveCommand, {
        cwd: this.config.srcBaseDir,
        timeout: 30,
        abortSignal,
      });

      await stream.stdin.abort();
      const exitCode = await stream.exitCode;

      if (exitCode !== 0) {
        const stderrReader = stream.stderr.getReader();
        const decoder = new TextDecoder();
        let stderr = "";
        try {
          while (true) {
            const { done, value } = await stderrReader.read();
            if (done) break;
            stderr += decoder.decode(value, { stream: true });
          }
        } finally {
          stderrReader.releaseLock();
        }