luv-cli 0.3.0__tar.gz → 0.4.0__tar.gz

{luv_cli-0.3.0 → luv_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: luv-cli
-Version: 0.3.0
+Version: 0.4.0
 Summary: Launch Claude Code or Codex agents on GitHub repos with isolated workspaces and optional Docker dev environments
 Project-URL: Homepage, https://github.com/exospherehost/luv
 Project-URL: Repository, https://github.com/exospherehost/luv
@@ -63,7 +63,7 @@ luv other-org/my-repo "fix the bug"
 # Reopen workspace #42
 luv my-repo 42
 
-# Open any GitHub PR by URL
+# Clone any GitHub PR by URL into a fresh workspace
 luv -l https://github.com/org/repo/pull/123
 
 # Open a shell instead of Claude
@@ -97,6 +97,22 @@ The machine name is what keeps two computers apart. Each one works out the next
 
 With a remote host configured, steps 1–4 happen on that machine inside a tmux session instead — see [Remote sessions](#remote-sessions).
 
+### Opening an existing PR
+
+`luv -l <PR URL>` gives you the PR as it is *right now*: a full clone into a
+workspace of its own, checked out on the PR's head branch. It never reuses a
+folder that happens to be sitting there — a URL you paste is a request to look
+at that PR, not at whatever was checked out in `myrepo-mbp-123` last week. Run
+it twice on the same PR and you get `myrepo-mbp-123` and `myrepo-mbp-123_2`,
+which are independent workspaces you can run side by side. When the PR comes
+from a fork, the base repo is added as `upstream` and fetched too, so the branch
+you need to diff or rebase against is there.
+
+`-r` is the exception: resuming means picking up a conversation, and a
+conversation lives in the folder it was held in, so `luv -l <URL> -r` reopens the
+newest workspace for that PR instead of cloning another. `luv <repo> -pr <N>`
+also keeps reusing its workspace — it names a workspace, where a URL names a PR.
+
 ## Commands
 
 | Command | Description |
@@ -115,8 +131,8 @@ With a remote host configured, steps 1–4 happen on that machine inside a tmux
 | `luv --codex [org/]<repo> [prompt...]` | Create a workspace and launch Codex in YOLO mode |
 | `luv [org/]<repo> -b <branch> [prompt...]` | Create a workspace based off `<branch>` instead of the default |
 | `luv [org/]<repo> <number> [prompt]` | Reopen an existing workspace |
-| `luv -l <PR URL> [prompt]` | Open any GitHub PR by URL |
-| `luv [org/]<repo> -pr <number> [prompt]` | Open a PR by repo + number |
+| `luv -l <PR URL> [prompt]` | Clone any GitHub PR by URL into a fresh workspace |
+| `luv [org/]<repo> -pr <number> [prompt]` | Open a PR by repo + number, reusing its workspace |
 | `luv --clean` | Delete workspaces where the branch is fully pushed/merged |
 | `luv --clean -f` | Force delete all workspaces |
 | `luv --clean --safe -f` | Force delete only workspaces older than 24h |
@@ -270,9 +286,10 @@ registry as soon as its tmux session exits, but the clone it was working in
 stays on the remote disk. Those orphans are invisible to `luv ls` and are
 usually what is actually filling up the box.
 
-Only folders ending in `-{N}` are ever eligible — `{repo}-{machine}-{N}` and
-pre-slug `{repo}-{N}` alike. Anything else in the workspace root is left alone,
-and a target that doesn't resolve to one is an error rather than an `rm -rf`.
+Only folders ending in `-{N}` are ever eligible — `{repo}-{machine}-{N}`, a
+`luv -l` copy `{repo}-{machine}-{N}_2`, and pre-slug `{repo}-{N}` alike.
+Anything else in the workspace root is left alone, and a target that doesn't
+resolve to one is an error rather than an `rm -rf`.
 
 ## Configuration
 

{luv_cli-0.3.0 → luv_cli-0.4.0}/README.md

@@ -40,7 +40,7 @@ luv other-org/my-repo "fix the bug"
 # Reopen workspace #42
 luv my-repo 42
 
-# Open any GitHub PR by URL
+# Clone any GitHub PR by URL into a fresh workspace
 luv -l https://github.com/org/repo/pull/123
 
 # Open a shell instead of Claude
@@ -74,6 +74,22 @@ The machine name is what keeps two computers apart. Each one works out the next
 
 With a remote host configured, steps 1–4 happen on that machine inside a tmux session instead — see [Remote sessions](#remote-sessions).
 
+### Opening an existing PR
+
+`luv -l <PR URL>` gives you the PR as it is *right now*: a full clone into a
+workspace of its own, checked out on the PR's head branch. It never reuses a
+folder that happens to be sitting there — a URL you paste is a request to look
+at that PR, not at whatever was checked out in `myrepo-mbp-123` last week. Run
+it twice on the same PR and you get `myrepo-mbp-123` and `myrepo-mbp-123_2`,
+which are independent workspaces you can run side by side. When the PR comes
+from a fork, the base repo is added as `upstream` and fetched too, so the branch
+you need to diff or rebase against is there.
+
+`-r` is the exception: resuming means picking up a conversation, and a
+conversation lives in the folder it was held in, so `luv -l <URL> -r` reopens the
+newest workspace for that PR instead of cloning another. `luv <repo> -pr <N>`
+also keeps reusing its workspace — it names a workspace, where a URL names a PR.
+
 ## Commands
 
 | Command | Description |
@@ -92,8 +108,8 @@ With a remote host configured, steps 1–4 happen on that machine inside a tmux
 | `luv --codex [org/]<repo> [prompt...]` | Create a workspace and launch Codex in YOLO mode |
 | `luv [org/]<repo> -b <branch> [prompt...]` | Create a workspace based off `<branch>` instead of the default |
 | `luv [org/]<repo> <number> [prompt]` | Reopen an existing workspace |
-| `luv -l <PR URL> [prompt]` | Open any GitHub PR by URL |
-| `luv [org/]<repo> -pr <number> [prompt]` | Open a PR by repo + number |
+| `luv -l <PR URL> [prompt]` | Clone any GitHub PR by URL into a fresh workspace |
+| `luv [org/]<repo> -pr <number> [prompt]` | Open a PR by repo + number, reusing its workspace |
 | `luv --clean` | Delete workspaces where the branch is fully pushed/merged |
 | `luv --clean -f` | Force delete all workspaces |
 | `luv --clean --safe -f` | Force delete only workspaces older than 24h |
@@ -247,9 +263,10 @@ registry as soon as its tmux session exits, but the clone it was working in
 stays on the remote disk. Those orphans are invisible to `luv ls` and are
 usually what is actually filling up the box.
 
-Only folders ending in `-{N}` are ever eligible — `{repo}-{machine}-{N}` and
-pre-slug `{repo}-{N}` alike. Anything else in the workspace root is left alone,
-and a target that doesn't resolve to one is an error rather than an `rm -rf`.
+Only folders ending in `-{N}` are ever eligible — `{repo}-{machine}-{N}`, a
+`luv -l` copy `{repo}-{machine}-{N}_2`, and pre-slug `{repo}-{N}` alike.
+Anything else in the workspace root is left alone, and a target that doesn't
+resolve to one is an error rather than an `rm -rf`.
 
 ## Configuration
 

{luv_cli-0.3.0 → luv_cli-0.4.0}/docs/remote-sessions.md

@@ -345,19 +345,27 @@ a laptop and a box would routinely pick the same one and push the same branch.
 Folders and branches created before slugs existed keep working — luv looks for
 its own name first, then any other machine's, then the plain `{repo}-{number}`.
 
+`luv -l <PR URL>` clones into a folder of its own every time, so a second run on
+the same PR gets `{repo}-{machine}-{number}_2`, a third `_3`. The suffix is part
+of the number's segment, so those folders are still workspace `{number}`
+everywhere it matters — `luv ls`, `luv rm`, `--clean`, handover. Where a number
+has several copies, the newest wins: that is the one you just made.
+
 Sessions are named after the workspace folder: `~/prs/myrepo-box-42` becomes
 `luv-myrepo-box-42`. tmux forbids `.` and `:` in session names, so a repo like
 `foo.js` becomes `luv-foo_js-box-42`.
 
-When the workspace is already known — reopening by number, `-pr`, or `-l` — the
-laptop pins the session name down before dispatching, so `tmux new-session -A`
-doubles as "attach if it's already running". It can't compute that name, though,
-since the slug belongs to the machine holding the folder: it takes it from the
-session registry, or asks the host directly, and falls back to the
+When the workspace is already known — reopening by number, `-pr`, or `-l -r` —
+the laptop pins the session name down before dispatching, so `tmux new-session
+-A` doubles as "attach if it's already running". It can't compute that name,
+though, since the slug belongs to the machine holding the folder: it takes it
+from the session registry, or asks the host directly, and falls back to the
 `luv-pending-<id>` rename-on-arrival path if the host doesn't answer.
 
-When it isn't known — a brand new workspace, or bare `-n`/`-r` — the laptop uses
-a placeholder `luv-pending-<id>` and the remote renames it once the clone lands.
+When it isn't known — a brand new workspace, plain `luv -l` (whose folder the
+remote only picks once it sees what is already there), or bare `-n`/`-r` — the
+laptop uses a placeholder `luv-pending-<id>` and the remote renames it once the
+clone lands.
 If the target name is already taken by another live session, luv keeps the
 session under `luv-myrepo-box-42-2` and warns rather than failing.
 

{luv_cli-0.3.0 → luv_cli-0.4.0}/docs/sessions.md

@@ -63,7 +63,7 @@ the session (which luv does as soon as the clone lands) breaks nothing.
 | `pr_number`, `pr_url` | The session's pull request; `null` until one exists |
 | `pr_state` | `OPEN`, `CLOSED` or `MERGED` — what `luv rm --merged` selects on |
 | `pr_checked` | Unix time GitHub was last asked about it |
-| `pr_hint` | PR number known at dispatch (`-l` / `-pr` only); absent otherwise |
+| `pr_hint` | PR number known at dispatch (`-l` / `-pr` only); absent otherwise. Set even when the folder isn't yet known, which is always the case for `-l` |
 | `adopted` | Present when this machine found the session rather than starting it |
 
 `attached`, `activity`, and `live` are recomputed on every reconcile and are
@@ -230,10 +230,11 @@ case.
 
 Two things bound the damage:
 
-- Only names ending in `-{N}` are eligible — `{repo}-{machine}-{N}` and pre-slug
-  `{repo}-{N}` alike — checked again immediately before the `rm -rf` rather than
-  only at selection time. A stray directory in the workspace root is never a
-  candidate, and a target that resolves to one is an error, not a deletion.
+- Only names ending in `-{N}` are eligible — `{repo}-{machine}-{N}`, a `luv -l`
+  copy `{repo}-{machine}-{N}_2`, and pre-slug `{repo}-{N}` alike — checked again
+  immediately before the `rm -rf` rather than only at selection time. A stray
+  directory in the workspace root is never a candidate, and a target that
+  resolves to one is an error, not a deletion.
 - A named target is its own confirmation, but `--merged` and `--dead` print what
   they matched and ask, because a selector can sweep up folders on a machine you
   are not looking at. `-f` skips the prompt.

{luv_cli-0.3.0 → luv_cli-0.4.0}/luv/__init__.py

@@ -218,9 +218,28 @@ def machine_slug() -> str:
     return sanitize_slug(socket.gethostname().split(".")[0]) or "local"
 
 
-def workspace_name(repo: str, number: int, slug: str | None = None) -> str:
-    """Folder name for a workspace: '{repo}-{machine}-{number}'."""
-    return f"{repo}-{slug or machine_slug()}-{number}"
+def workspace_name(repo: str, number: int, slug: str | None = None,
+                   copy: int = 1) -> str:
+    """Folder name for a workspace: '{repo}-{machine}-{number}[_{copy}]'.
+
+    The copy suffix exists for `luv -l`, which clones a PR into a folder of its
+    own every time rather than reopening the one already there. '_' is the one
+    separator that survives every name derived from this: tmux forbids '.' and
+    ':' in session names, and Compose project names forbid '.' too.
+    """
+    base = f"{repo}-{slug or machine_slug()}-{number}"
+    return base if copy <= 1 else f"{base}_{copy}"
+
+
+def next_workspace_dir(repo: str, number: int) -> Path:
+    """A workspace path for this number that nothing occupies yet.
+
+    Second and later clones of the same PR land on '..._2', '..._3', and so on.
+    """
+    copy = 1
+    while (PRS_DIR / workspace_name(repo, number, copy=copy)).exists():
+        copy += 1
+    return PRS_DIR / workspace_name(repo, number, copy=copy)
 
 
 def branch_name(number: int, slug: str | None = None) -> str:
@@ -233,9 +252,10 @@ def workspace_re(repo: str) -> re.Pattern:
 
     The repo name is known at every call site, so it can be anchored — which is
     what makes the optional middle group unambiguous. Group 1 is the slug (None
-    for a pre-slug folder), group 2 the number.
+    for a pre-slug folder), group 2 the number, group 3 the copy index (None for
+    the first clone of that number).
     """
-    return re.compile(rf"^{re.escape(repo)}-(?:([a-z0-9]+)-)?(\d+)$")
+    return re.compile(rf"^{re.escape(repo)}-(?:([a-z0-9]+)-)?(\d+)(?:_(\d+))?$")
 
 
 def branch_re(number: int) -> re.Pattern:
@@ -262,34 +282,44 @@ def find_workspace(repo: str, number: int) -> Path | None:
     """Locate an existing workspace folder for {repo}-{number}, or None.
 
     Ours first, then one that arrived here by handover (it keeps the slug of the
-    machine that created it), then a pre-slug folder. Two foreign candidates is
-    genuinely ambiguous — the number alone cannot say which was meant.
+    machine that created it), then a pre-slug folder. Where `luv -l` has cloned
+    the same PR more than once, the newest copy wins — that is the one you just
+    made. Two foreign *machines* is still genuinely ambiguous: the number alone
+    cannot say which was meant.
     """
-    mine = PRS_DIR / workspace_name(repo, number)
-    if mine.is_dir():
-        return mine
     if not PRS_DIR.exists():
         return None
 
     pattern = workspace_re(repo)
-    foreign, legacy = [], None
+    mine = machine_slug()
+    ours: list[tuple[int, Path]] = []
+    foreign: dict[str, list[tuple[int, Path]]] = {}
+    legacy = None
     for entry in sorted(PRS_DIR.iterdir()):
         if not entry.is_dir():
             continue
         m = pattern.match(entry.name)
         if not m or int(m.group(2)) != number:
             continue
-        if m.group(1) is None:
+        slug, copy = m.group(1), int(m.group(3) or 1)
+        if slug is None:
             legacy = entry
+        elif slug == mine:
+            ours.append((copy, entry))
         else:
-            foreign.append(entry)
+            foreign.setdefault(slug, []).append((copy, entry))
+
+    def newest(copies: list[tuple[int, Path]]) -> Path:
+        return max(copies, key=lambda c: c[0])[1]
 
+    if ours:
+        return newest(ours)
     if len(foreign) > 1:
-        names = ", ".join(e.name for e in foreign)
+        names = ", ".join(sorted(e.name for c in foreign.values() for _, e in c))
         die(f"ambiguous workspace for '{repo}' {number}: {names}\n"
             f"       open one by name with 'luv {repo} -n' or remove the stale folder")
     if foreign:
-        return foreign[0]
+        return newest(next(iter(foreign.values())))
     return legacy
 
 
@@ -335,13 +365,17 @@ def folder_number(name: str | None) -> int | None:
     the orphan scan, `--clean` — are looking at a directory listing and have no
     repo to anchor on. Where the repo *is* known, workspace_number reads the
     slug too and should be preferred.
+
+    A '_{copy}' suffix is part of the number's segment, so it is stripped here
+    too: '{repo}-{slug}-41_2' is still workspace 41.
     """
     if not name:
         return None
     parts = name.rsplit("-", 1)
-    if len(parts) != 2 or not parts[1].isdigit():
+    if len(parts) != 2:
         return None
-    return int(parts[1])
+    m = re.match(r"^(\d+)(?:_\d+)?$", parts[1])
+    return int(m.group(1)) if m else None
 
 
 def parse_github_url(url: str) -> tuple[str, str] | None:
@@ -1316,21 +1350,23 @@ def find_latest_clone(repo: str) -> Path | None:
     """Return the highest-numbered local workspace for a repo, or None.
 
     Slugged and pre-slug folders compete on the number alone; a tie between our
-    own slug and one that arrived by handover goes to ours.
+    own slug and one that arrived by handover goes to ours, and a tie between
+    two clones of the same PR goes to the newest copy.
     """
     if not PRS_DIR.exists():
         return None
     pattern = workspace_re(repo)
     mine = machine_slug()
     best: Path | None = None
-    best_key = (-1, -1)
+    best_key = (-1, -1, -1)
     for entry in sorted(PRS_DIR.iterdir()):
         if not entry.is_dir():
             continue
         m = pattern.match(entry.name)
         if not m:
             continue
-        key = (int(m.group(2)), 1 if m.group(1) == mine else 0)
+        key = (int(m.group(2)), 1 if m.group(1) == mine else 0,
+               int(m.group(3) or 1))
         if key > best_key:
             best, best_key = entry, key
     return best
@@ -1393,12 +1429,20 @@ def open_existing(org: str, repo: str, number: int, prompt: str | None, nav_mode
         launch(clone_dir, prompt, plan_mode=plan_mode, non_interactive=non_interactive, extra_env=extra_env, model=model, agent=agent)
 
 
-def open_pr(org: str, repo: str, number: int, prompt: str | None, nav_mode: bool = False, resume_mode: bool = False, plan_mode: bool = False, non_interactive: bool = False, extra_env: dict[str, str] | None = None, model: str | None = None, agent: str = "claude") -> None:
-    """Open any GitHub PR by org/repo/number, cloning if needed."""
+def open_pr(org: str, repo: str, number: int, prompt: str | None, nav_mode: bool = False, resume_mode: bool = False, plan_mode: bool = False, non_interactive: bool = False, extra_env: dict[str, str] | None = None, model: str | None = None, agent: str = "claude", fresh: bool = False) -> None:
+    """Open any GitHub PR by org/repo/number, cloning if needed.
+
+    With fresh=True — how `luv -l` calls this — an existing folder for the same
+    number is left alone and the PR is cloned again next to it. A URL you paste
+    is a request to look at that PR as it is *now*, and a folder from last week
+    sits on whatever was checked out then. -r is the exception: resuming means
+    picking up a conversation, and a conversation lives in the folder it was
+    held in.
+    """
     extra_env = extra_env or {}
     clone_dir = find_workspace(repo, number)
 
-    if clone_dir is not None:
+    if clone_dir is not None and (resume_mode or not fresh):
         print(f"luv: opening existing folder {clone_dir.name}")
         ensure_pr_rules(agent)
         if nav_mode:
@@ -1415,9 +1459,15 @@ def open_pr(org: str, repo: str, number: int, prompt: str | None, nav_mode: bool
         die(f"PR {org}/{repo}#{number} not found.\n{r.stderr.strip()}")
     pr_data = json.loads(r.stdout)
     branch = pr_data["head"]["ref"]
-    clone_url = pr_data["head"]["repo"]["clone_url"]
-
-    clone_dir = PRS_DIR / workspace_name(repo, number)
+    # A fork whose repo has since been deleted comes back as head.repo = null.
+    head_repo = pr_data["head"].get("repo") or {}
+    clone_url = head_repo.get("clone_url")
+    if not clone_url:
+        die(f"PR {org}/{repo}#{number} has no head repository — "
+            "the fork it came from was deleted")
+    base_url = (pr_data.get("base", {}).get("repo") or {}).get("clone_url")
+
+    clone_dir = next_workspace_dir(repo, number)
     PRS_DIR.mkdir(parents=True, exist_ok=True)
     print(f"luv: cloning {clone_url} -> {clone_dir} (branch {branch})")
     r = subprocess.run(["git", "clone", clone_url, str(clone_dir)])
@@ -1427,6 +1477,20 @@ def open_pr(org: str, repo: str, number: int, prompt: str | None, nav_mode: bool
     if r.returncode != 0:
         die(f"git checkout {branch} failed (exit {r.returncode})")
 
+    # A clone of the head repo has every branch that repo has — but for a PR
+    # from a fork that is not where the base branch lives, so there would be
+    # nothing to diff or rebase against. Fetch the base repo alongside it.
+    if base_url and base_url != clone_url:
+        print(f"luv: fetching base repo {base_url} as 'upstream'")
+        for cmd in (["git", "remote", "add", "upstream", base_url],
+                    ["git", "fetch", "upstream"]):
+            r = subprocess.run(cmd, cwd=str(clone_dir))
+            if r.returncode != 0:
+                print(f"luv: warning: {' '.join(cmd[:3])} failed "
+                      f"(exit {r.returncode}) — upstream branches unavailable",
+                      file=sys.stderr)
+                break
+
     print(f"luv: ready — {clone_dir.name}, branch {branch}")
     ensure_pr_rules(agent)
     if nav_mode:
@@ -2547,8 +2611,8 @@ Commands:
   luv [org/]<repo> [prompt...]            create a new PR workspace
   luv [org/]<repo> -b <branch> [prompt]   create a workspace based off <branch>
   luv [org/]<repo> <number> [prompt]      reopen an existing work folder by number
-  luv -l <PR URL> [prompt]                open any GitHub PR by URL
-  luv [org/]<repo> -pr <number> [prompt]  open a GitHub PR by repo + number
+  luv -l <PR URL> [prompt]                clone any GitHub PR by URL into a fresh folder
+  luv [org/]<repo> -pr <number> [prompt]  open a GitHub PR by repo + number (reuses its folder)
   luv [org/]<repo> -n                     open shell in latest local clone
   luv [org/]<repo> -r                     resume the selected agent in latest local clone
   luv --clean [-f] [--safe]               delete fully-pushed work folders
@@ -2654,7 +2718,13 @@ Docker:
             m = re.match(r"https://github\.com/([^/]+)/([^/]+)/pull/(\d+)", args[1])
             if m:
                 org_hint, repo_hint = m.group(1), m.group(2)
-                number = pr_hint = int(m.group(3))
+                pr_hint = int(m.group(3))
+                # -l clones into a folder of its own every time, so the name is
+                # only knowable once the remote has picked it — leave it on the
+                # luv-pending path, which renames the session on arrival. -r is
+                # the exception: it reopens the newest folder already there.
+                if resume_mode:
+                    number = pr_hint
         elif repo_hint and "-pr" in args:
             idx = args.index("-pr")
             if idx + 1 < len(args) and args[idx + 1].isdigit():
@@ -2708,7 +2778,7 @@ Docker:
             die(f"cannot parse PR URL: {url}")
         org, repo, number = m.group(1), m.group(2), int(m.group(3))
         prompt = " ".join(args[2:]) or None
-        open_pr(org, repo, number, prompt, nav_mode, resume_mode, plan_mode, non_interactive, extra_env=extra_env, model=model, agent=agent)
+        open_pr(org, repo, number, prompt, nav_mode, resume_mode, plan_mode, non_interactive, extra_env=extra_env, model=model, agent=agent, fresh=True)
         return
 
     raw = args[0].rstrip("/")

{luv_cli-0.3.0 → luv_cli-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "luv-cli"
-version = "0.3.0"
+version = "0.4.0"
 description = "Launch Claude Code or Codex agents on GitHub repos with isolated workspaces and optional Docker dev environments"
 requires-python = ">=3.10"
 license = "MIT"

{luv_cli-0.3.0 → luv_cli-0.4.0}/tests/test_agents.py

@@ -1,5 +1,6 @@
 import contextlib
 import io
+import json
 import re
 import subprocess
 import tempfile
@@ -169,11 +170,29 @@ class RemoteDispatchTests(unittest.TestCase):
 
         self.assertIn("tmux new-session -A -s luv-myrepo-mbp-42", argv[-1])
 
-    def test_pr_url_derives_session_from_url(self):
+    def test_pr_url_gets_a_pending_session(self):
+        # -l clones a fresh folder on the remote, so its name — and with it the
+        # session name — is not knowable here even when the host answers.
         argv = self._dispatch(["-l", "https://github.com/other/thing/pull/7"],
                               where="thing-box-7")
 
+        self.assertIn("luv-pending-", argv[-1])
+        self.assertIn("_LUV_TMUX_PENDING=", argv[-1])
+
+    def test_pr_url_with_resume_pins_the_existing_folder(self):
+        # -r reopens the newest folder that is already there, so it can attach.
+        argv = self._dispatch(["-l", "https://github.com/other/thing/pull/7", "-r"],
+                              where="thing-box-7")
+
         self.assertIn("-s luv-thing-box-7", argv[-1])
+        self.assertNotIn("_LUV_TMUX_PENDING", argv[-1])
+
+    def test_pr_url_still_records_the_pr_number(self):
+        # The PR link in `luv ls` comes from this hint: a -l session's branch is
+        # the PR's head ref, which no folder name spells out.
+        self._dispatch(["-l", "https://github.com/other/thing/pull/7"])
+
+        self.assertEqual([s.get("pr_hint") for s in luv.load_sessions()], [7])
 
     def test_host_flag_selects_per_host_settings(self):
         argv = self._dispatch(["-s", "gpu", "ml", "train"])
@@ -751,6 +770,55 @@ class NamingTests(unittest.TestCase):
         self.assertEqual(luv.workspace_number("myrepo", "myrepo-42"), 42)
         self.assertIsNone(luv.workspace_number("myrepo", "other-mbp-42"))
 
+    def test_repeat_clones_of_a_pr_get_their_own_folder(self):
+        with self._slug("mbp"):
+            self.assertEqual(luv.next_workspace_dir("myrepo", 42).name,
+                             "myrepo-mbp-42")
+            (self.root / "myrepo-mbp-42").mkdir()
+            self.assertEqual(luv.next_workspace_dir("myrepo", 42).name,
+                             "myrepo-mbp-42_2")
+            (self.root / "myrepo-mbp-42_2").mkdir()
+            self.assertEqual(luv.next_workspace_dir("myrepo", 42).name,
+                             "myrepo-mbp-42_3")
+
+    def test_a_copy_is_still_workspace_42(self):
+        self.assertEqual(luv.workspace_number("myrepo", "myrepo-mbp-42_2"), 42)
+        self.assertEqual(luv.folder_number("myrepo-mbp-42_2"), 42)
+        self.assertEqual(luv.folder_number("myrepo-42_11"), 42)
+        self.assertIsNone(luv.folder_number("myrepo-main_2"))
+
+    def test_copy_suffix_survives_every_derived_name(self):
+        # tmux rejects '.' and ':' in session names and Compose rejects '.' in
+        # project names, which is why the separator is '_'.
+        name = luv.workspace_name("myrepo", 42, slug="mbp", copy=2)
+        self.assertEqual(name, "myrepo-mbp-42_2")
+        self.assertEqual(luv.tmux_session_name(name), "luv-myrepo-mbp-42_2")
+        self.assertEqual(luv.docker_project_name(self.root / name),
+                         "luv-myrepo-mbp-42_2")
+
+    def test_find_workspace_opens_the_newest_copy(self):
+        for name in ("myrepo-mbp-42", "myrepo-mbp-42_2", "myrepo-mbp-42_10"):
+            (self.root / name).mkdir()
+        with self._slug("mbp"):
+            self.assertEqual(luv.find_workspace("myrepo", 42).name,
+                             "myrepo-mbp-42_10")
+
+    def test_copies_of_one_machines_folder_are_not_ambiguous(self):
+        # Two copies made *here* are a -l history, not a naming conflict; only
+        # two different machines leave the number genuinely undecidable.
+        for name in ("myrepo-box-42", "myrepo-box-42_2"):
+            (self.root / name).mkdir()
+        with self._slug("mbp"):
+            self.assertEqual(luv.find_workspace("myrepo", 42).name,
+                             "myrepo-box-42_2")
+
+    def test_find_latest_clone_prefers_the_newest_copy(self):
+        for name in ("myrepo-mbp-41", "myrepo-mbp-41_2"):
+            (self.root / name).mkdir()
+        with self._slug("mbp"):
+            self.assertEqual(luv.find_latest_clone("myrepo").name,
+                             "myrepo-mbp-41_2")
+
     def test_find_workspace_prefers_our_own(self):
         for name in ("myrepo-42", "myrepo-box-42", "myrepo-mbp-42"):
             (self.root / name).mkdir()
@@ -796,6 +864,93 @@ class NamingTests(unittest.TestCase):
         self.assertEqual(out.getvalue().split(), ["myrepo-box-42", "myrepo-mbp-77"])
 
 
+class OpenPrTests(unittest.TestCase):
+    """`luv -l` clones the PR again rather than reopening what is lying around."""
+
+    SAME_REPO = json.dumps({
+        "head": {"ref": "feature-branch",
+                 "repo": {"clone_url": "https://github.com/exo/myrepo.git"}},
+        "base": {"repo": {"clone_url": "https://github.com/exo/myrepo.git"}},
+    })
+    FROM_FORK = json.dumps({
+        "head": {"ref": "feature-branch",
+                 "repo": {"clone_url": "https://github.com/someone/myrepo.git"}},
+        "base": {"repo": {"clone_url": "https://github.com/exo/myrepo.git"}},
+    })
+
+    def setUp(self):
+        self.tempdir = tempfile.TemporaryDirectory()
+        self.addCleanup(self.tempdir.cleanup)
+        self.root = Path(self.tempdir.name)
+        self.git = []
+        for p in (patch.object(luv, "PRS_DIR", self.root),
+                  patch.object(luv, "machine_slug", return_value="mbp"),
+                  patch.object(luv, "ensure_pr_rules")):
+            p.start()
+            self.addCleanup(p.stop)
+
+    def _open(self, pr_json=SAME_REPO, **kwargs):
+        """Run open_pr with git stubbed out; returns the launched folder."""
+        with (patch.object(luv, "run", return_value=_completed(pr_json)),
+              patch.object(luv.subprocess, "run",
+                           side_effect=lambda cmd, **kw: self.git.append(cmd)
+                           or _completed()),
+              patch.object(luv, "launch") as launch,
+              patch.object(luv, "navigate") as navigate,
+              patch.object(luv, "resume") as resume,
+              contextlib.redirect_stdout(io.StringIO()),
+              contextlib.redirect_stderr(io.StringIO())):
+            luv.open_pr("exo", "myrepo", 42, None, **kwargs)
+        called = next(m for m in (launch, navigate, resume) if m.called)
+        return called.call_args.args[0]
+
+    def test_a_fresh_clone_lands_next_to_the_old_folder(self):
+        (self.root / "myrepo-mbp-42").mkdir()
+
+        folder = self._open(fresh=True)
+
+        self.assertEqual(folder.name, "myrepo-mbp-42_2")
+        self.assertIn(["git", "checkout", "feature-branch"], self.git)
+
+    def test_without_fresh_the_existing_folder_is_reused(self):
+        # -pr keeps the old behaviour: it names a workspace, not a URL.
+        (self.root / "myrepo-mbp-42").mkdir()
+
+        self.assertEqual(self._open().name, "myrepo-mbp-42")
+        self.assertEqual(self.git, [], "reopening must not clone")
+
+    def test_resume_reopens_rather_than_recloning(self):
+        # A fresh clone has no conversation in it, so there is nothing to resume.
+        (self.root / "myrepo-mbp-42").mkdir()
+
+        self.assertEqual(self._open(fresh=True, resume_mode=True).name,
+                         "myrepo-mbp-42")
+        self.assertEqual(self.git, [])
+
+    def test_a_fork_pr_also_fetches_the_base_repo(self):
+        self._open(self.FROM_FORK, fresh=True)
+
+        self.assertIn(["git", "remote", "add", "upstream",
+                       "https://github.com/exo/myrepo.git"], self.git)
+        self.assertIn(["git", "fetch", "upstream"], self.git)
+
+    def test_a_same_repo_pr_needs_no_second_remote(self):
+        # The clone already carries every branch; a second remote for the same
+        # URL would just duplicate them.
+        self._open(fresh=True)
+
+        self.assertNotIn("upstream", [a for cmd in self.git for a in cmd])
+
+    def test_a_deleted_fork_fails_before_touching_the_disk(self):
+        gone = json.dumps({"head": {"ref": "feature-branch", "repo": None},
+                           "base": {"repo": {"clone_url": "https://x/y.git"}}})
+
+        with self.assertRaises(SystemExit), \
+                contextlib.redirect_stderr(io.StringIO()):
+            self._open(gone, fresh=True)
+        self.assertEqual(self.git, [])
+
+
 class HandoverTests(unittest.TestCase):
     """Moving a workspace between machines."""