evo-cli 0.18.0__tar.gz → 0.19.0__tar.gz

{evo_cli-0.18.0 → evo_cli-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.18.0
+Version: 0.19.0
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli
@@ -159,6 +159,21 @@ else has the flat file open.
 
 #### Harness Repositories
 
+Clone every repository a harness manifest declares but this machine does not have yet:
+
+```bash
+evo harness clone
+evo harness clone --dry-run                     # show what lands where, change nothing
+evo harness clone --repo backend --depth 1
+evo harness clone --all                         # include repos marked present: false
+```
+
+Each repo lands on its declared `path`, falling back to `<workspace>/<name>`, so a fresh machine
+ends up with the layout the manifest, the contract seams and the exec-plans already assume. A repo
+already on disk is left alone; if its `origin` is not the remote the manifest names, the summary
+says so instead of touching it. When the manifest names a `branch`, the clone moves onto it, and a
+branch nobody has pushed yet is reported rather than treated as a failure.
+
 Fast-forward every available repository declared in a harness manifest:
 
 ```bash
@@ -299,6 +314,7 @@ evo harness plans      # progress across every exec-plan
 evo harness show <plan>
 evo harness check <plan> [--fetch]      # what the plan claims vs what git says
 evo harness graph <plan>:steps          # the same DAG as an adjacency list
+evo harness clone      # clone every declared repo into its declared path
 evo harness pull       # fast-forward every repo
 ```
 

{evo_cli-0.18.0 → evo_cli-0.19.0}/README.md

@@ -131,6 +131,21 @@ else has the flat file open.
 
 #### Harness Repositories
 
+Clone every repository a harness manifest declares but this machine does not have yet:
+
+```bash
+evo harness clone
+evo harness clone --dry-run                     # show what lands where, change nothing
+evo harness clone --repo backend --depth 1
+evo harness clone --all                         # include repos marked present: false
+```
+
+Each repo lands on its declared `path`, falling back to `<workspace>/<name>`, so a fresh machine
+ends up with the layout the manifest, the contract seams and the exec-plans already assume. A repo
+already on disk is left alone; if its `origin` is not the remote the manifest names, the summary
+says so instead of touching it. When the manifest names a `branch`, the clone moves onto it, and a
+branch nobody has pushed yet is reported rather than treated as a failure.
+
 Fast-forward every available repository declared in a harness manifest:
 
 ```bash
@@ -271,6 +286,7 @@ evo harness plans      # progress across every exec-plan
 evo harness show <plan>
 evo harness check <plan> [--fetch]      # what the plan claims vs what git says
 evo harness graph <plan>:steps          # the same DAG as an adjacency list
+evo harness clone      # clone every declared repo into its declared path
 evo harness pull       # fast-forward every repo
 ```
 

evo_cli-0.19.0/evo_cli/VERSION

@@ -0,0 +1 @@
+0.19.0

{evo_cli-0.18.0 → evo_cli-0.19.0}/evo_cli/commands/harness/__init__.py

@@ -1,6 +1,7 @@
 import rich_click as click
 
 from evo_cli.commands.harness.check import check
+from evo_cli.commands.harness.clone import clone
 from evo_cli.commands.harness.edit import debt, question, repo, step
 from evo_cli.commands.harness.pull import pull
 from evo_cli.commands.harness.serve import serve
@@ -21,9 +22,10 @@ def harness_group():
     evo harness graph <plan>       print a DAG as an adjacency list
     evo harness check <plan>       check what the plan claims against real git
     evo harness step <plan> 3 done mark a step
+    evo harness clone              clone every declared repo into its declared path
     evo harness pull               fast-forward every repo
     """
 
 
-for command in (serve, repos, seams, plans, show, graph, check, step, debt, question, repo, pull):
+for command in (serve, repos, seams, plans, show, graph, check, step, debt, question, repo, clone, pull):
     harness_group.add_command(command)

{evo_cli-0.18.0 → evo_cli-0.19.0}/evo_cli/commands/harness/_paths.py

@@ -62,6 +62,10 @@ def load_repos(manifest_path):
             {
                 "name": name,
                 "path": path,
+                # Where the manifest says the repo belongs, whether or not it is there yet.
+                # `path` falls back to the workspace when the declared path is missing, so a
+                # command that creates the checkout has to read this one instead.
+                "declared_path": declared or fallback.resolve(),
                 "present": bool(present) and path.is_dir(),
                 "declared_present": bool(present),
                 "role": str(entry.get("role") or ""),

{evo_cli-0.18.0 → evo_cli-0.19.0}/evo_cli/commands/harness/_render.py

@@ -85,6 +85,16 @@ def print_graph(title: str, graph: dict) -> None:
         print_warnings(graph["warnings"])
 
 
+def print_summary(results: list) -> None:
+    """One `name  status` line per repo, coloured by the verb the status starts with."""
+    click.echo()
+    click.secho("Summary", bold=True)
+    width = max((len(name) for name, _ in results), default=0)
+    for name, status in results:
+        color = "red" if status.startswith("failed") else "yellow" if status.startswith("skipped") else "green"
+        click.secho(f"  {name:<{width}}  {status}", fg=color)
+
+
 def fail_if(condition: bool) -> None:
     if condition:
         raise click.exceptions.Exit(1)

evo_cli-0.19.0/evo_cli/commands/harness/clone.py

@@ -0,0 +1,123 @@
+import re
+import shutil
+
+import rich_click as click
+
+from evo_cli.commands.harness._paths import find_manifest, git, harness_option, load_repos
+from evo_cli.commands.harness._render import print_summary
+
+SCHEME_RE = re.compile(r"^\w+://")
+USER_RE = re.compile(r"^[^@/]+@")
+
+
+def normalize_remote(url):
+    """Reduce a remote URL to host + path so the ssh and https forms of one repo compare equal."""
+    text = str(url).strip().rstrip("/")
+    if text.endswith(".git"):
+        text = text[: -len(".git")]
+    text = USER_RE.sub("", SCHEME_RE.sub("", text))
+    return text.replace(":", "/", 1).lower()
+
+
+def detail_of(result, fallback):
+    lines = ((result.stderr or "") + (result.stdout or "")).strip().splitlines()
+    return lines[-1] if lines else fallback
+
+
+def already_cloned(entry, target):
+    """A checkout is already there. Say so, and say if it came from a different remote."""
+    declared = entry["origin"]
+    actual = git(target, "remote", "get-url", "origin").stdout.strip()
+    if declared and actual and normalize_remote(declared) != normalize_remote(actual):
+        return f"skipped (already cloned, but origin is {actual})"
+    return "skipped (already cloned)"
+
+
+def checkout_declared_branch(entry, target):
+    """Move onto the branch the manifest names. A branch that is not on origin is not an error.
+
+    Cloning with `--branch` would fail the whole clone for a branch that has not been pushed yet,
+    which is a normal state for a plan in progress. Clone the default branch, then try to move.
+    """
+    branch = entry["branch"]
+    if not branch or branch.upper() == "TBD":
+        return ""
+    current = git(target, "rev-parse", "--abbrev-ref", "HEAD").stdout.strip()
+    if current == branch:
+        return ""
+    if git(target, "checkout", branch, timeout=120).returncode != 0:
+        return f" (branch {branch!r} is not on origin, left on {current or 'HEAD'})"
+    return f" (on {branch})"
+
+
+@click.command("clone", help="Clone the repositories a harness declares into their declared paths.")
+@harness_option
+@click.option("--repo", "repos", multiple=True, help="Clone only this repo name. Repeat for multiple repos.")
+@click.option("--all", "include_absent", is_flag=True, help="Also clone repos the manifest marks present: false.")
+@click.option("--depth", type=int, help="Shallow clone with this many commits of history.")
+@click.option("--dry-run", is_flag=True, help="Show what would be cloned, and where.")
+def clone(harness_path, repos, include_absent, depth, dry_run):
+    """Clone every repository the harness manifest declares but this machine does not have.
+
+    Each repo lands on its declared `path`, falling back to `<workspace>/<name>`, so a fresh
+    machine ends up with the layout the manifest, the contract seams and the exec-plans already
+    assume. Repos already on disk are left alone.
+    """
+    if shutil.which("git") is None:
+        raise click.ClickException("git is not installed or is not on PATH")
+
+    manifest_path = find_manifest(harness_path)
+    manifest, entries = load_repos(manifest_path)
+    available = {entry["name"] for entry in entries}
+    unknown = sorted(set(repos) - available)
+    if unknown:
+        raise click.ClickException(f"Unknown repo name(s): {', '.join(unknown)}")
+    selected = [entry for entry in entries if not repos or entry["name"] in repos]
+
+    click.echo(f"Harness: {manifest.get('name') or manifest_path.parent.name}")
+    click.echo(f"Manifest: {manifest_path}")
+    results = []
+    failures = 0
+
+    for entry in selected:
+        name = entry["name"]
+        target = entry["declared_path"]
+
+        # `present: false` means the manifest knows about the repo and deliberately does not want
+        # it here. Naming it with --repo, or asking for --all, overrides that.
+        if not entry["declared_present"] and not include_absent and not repos:
+            results.append((name, "skipped (present: false)"))
+            continue
+        if (target / ".git").is_dir():
+            results.append((name, already_cloned(entry, target)))
+            continue
+        if entry["path"] != target and (entry["path"] / ".git").is_dir():
+            results.append((name, f"skipped (already cloned at {entry['path']}, manifest says {target})"))
+            continue
+        if target.exists() and (not target.is_dir() or any(target.iterdir())):
+            results.append((name, f"failed (path is taken and is not an empty directory: {target})"))
+            failures += 1
+            continue
+        if not entry["origin"]:
+            results.append((name, "failed (no origin declared in the manifest)"))
+            failures += 1
+            continue
+        if dry_run:
+            results.append((name, f"would clone {entry['origin']} into {target}"))
+            continue
+
+        target.parent.mkdir(parents=True, exist_ok=True)
+        args = ["clone"]
+        if depth:
+            args += ["--depth", str(depth)]
+        args += [entry["origin"], str(target)]
+        result = git(target.parent, *args, timeout=900)
+        if result.returncode != 0:
+            results.append((name, f"failed ({detail_of(result, 'git clone failed')})"))
+            failures += 1
+            continue
+        results.append((name, f"cloned into {target}{checkout_declared_branch(entry, target)}"))
+
+    print_summary(results)
+    if failures:
+        raise click.exceptions.Exit(1)

{evo_cli-0.18.0 → evo_cli-0.19.0}/evo_cli/commands/harness/pull.py

@@ -3,6 +3,7 @@ import shutil
 import rich_click as click
 
 from evo_cli.commands.harness._paths import find_manifest, git, harness_option, load_repos
+from evo_cli.commands.harness._render import print_summary
 
 
 @click.command("pull", help="Fast-forward all available repositories in a harness.")
@@ -34,7 +35,7 @@ def pull(harness_path, repos, prune, dry_run):
             results.append((name, "skipped (present: false)"))
             continue
         if not path.is_dir():
-            results.append((name, f"failed (missing: {path})"))
+            results.append((name, f"failed (missing: {path} - run `evo harness clone`)"))
             incomplete += 1
             continue
 
@@ -64,11 +65,6 @@ def pull(harness_path, repos, prune, dry_run):
         head = git(path, "log", "-1", "--oneline")
         results.append((name, head.stdout.strip() or "updated"))
 
-    click.echo()
-    click.secho("Summary", bold=True)
-    width = max((len(name) for name, _ in results), default=0)
-    for name, status in results:
-        color = "red" if status.startswith("failed") else "yellow" if status.startswith("skipped") else "green"
-        click.secho(f"  {name:<{width}}  {status}", fg=color)
+    print_summary(results)
     if incomplete:
         raise click.exceptions.Exit(1)

{evo_cli-0.18.0 → evo_cli-0.19.0}/evo_cli/commands/harness/views.py

@@ -71,6 +71,10 @@ def repos(harness_path, with_git):
         grid.add_row(f"[bold]{entry['name']}[/]", entry["role"] or "-", branch, state, one_line(entry["note"], width))
     console.print(grid)
 
+    missing = [entry["name"] for entry in info["repos"] if not entry["present"]]
+    if missing:
+        console.print(f"\n[red]{len(missing)} repo(s) missing[/] - run [accent]evo harness clone[/] to fetch them")
+
     if info["proposals_pending"]:
         console.print(f"\n[yellow]{len(info['proposals_pending'])} pending proposal(s)[/] in proposals/_pending")
 

{evo_cli-0.18.0 → evo_cli-0.19.0}/evo_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.18.0
+Version: 0.19.0
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli
@@ -159,6 +159,21 @@ else has the flat file open.
 
 #### Harness Repositories
 
+Clone every repository a harness manifest declares but this machine does not have yet:
+
+```bash
+evo harness clone
+evo harness clone --dry-run                     # show what lands where, change nothing
+evo harness clone --repo backend --depth 1
+evo harness clone --all                         # include repos marked present: false
+```
+
+Each repo lands on its declared `path`, falling back to `<workspace>/<name>`, so a fresh machine
+ends up with the layout the manifest, the contract seams and the exec-plans already assume. A repo
+already on disk is left alone; if its `origin` is not the remote the manifest names, the summary
+says so instead of touching it. When the manifest names a `branch`, the clone moves onto it, and a
+branch nobody has pushed yet is reported rather than treated as a failure.
+
 Fast-forward every available repository declared in a harness manifest:
 
 ```bash
@@ -299,6 +314,7 @@ evo harness plans      # progress across every exec-plan
 evo harness show <plan>
 evo harness check <plan> [--fetch]      # what the plan claims vs what git says
 evo harness graph <plan>:steps          # the same DAG as an adjacency list
+evo harness clone      # clone every declared repo into its declared path
 evo harness pull       # fast-forward every repo
 ```
 

{evo_cli-0.18.0 → evo_cli-0.19.0}/evo_cli.egg-info/SOURCES.txt

@@ -50,6 +50,7 @@ evo_cli/commands/harness/_paths.py
 evo_cli/commands/harness/_render.py
 evo_cli/commands/harness/_server.py
 evo_cli/commands/harness/check.py
+evo_cli/commands/harness/clone.py
 evo_cli/commands/harness/edit.py
 evo_cli/commands/harness/pull.py
 evo_cli/commands/harness/serve.py
@@ -103,6 +104,7 @@ tests/test_download.py
 tests/test_fix_claude.py
 tests/test_gh.py
 tests/test_harness.py
+tests/test_harness_clone.py
 tests/test_harness_dag.py
 tests/test_mcp.py
 tests/test_opencode.py

evo_cli-0.19.0/tests/test_harness_clone.py

@@ -0,0 +1,270 @@
+import importlib
+import subprocess
+
+from click.testing import CliRunner
+
+from evo_cli.cli import cli
+
+# harness/__init__ binds the command object to the name `clone`, shadowing the submodule,
+# so the module has to be fetched by path rather than imported by name.
+clone_command = importlib.import_module("evo_cli.commands.harness.clone")
+
+
+def _result(returncode=0, stdout="", stderr=""):
+    return subprocess.CompletedProcess([], returncode, stdout, stderr)
+
+
+def _write_harness(root, workspace, extra=""):
+    """alpha declares a path outside <workspace>/<name>; beta relies on the fallback."""
+    root.mkdir()
+    (root / "harness.yaml").write_text(
+        f"name: test-cluster\nworkspace: {workspace.as_posix()}\nrepos:\n"
+        f"- name: alpha\n  path: {(workspace / 'nested' / 'alpha').as_posix()}\n"
+        "  origin: https://github.com/acme/alpha.git\n"
+        "- name: beta\n  origin: git@github.com:acme/beta.git\n" + extra,
+        encoding="utf-8",
+    )
+
+
+def _checkout(path, origin="https://github.com/acme/alpha.git"):
+    (path / ".git").mkdir(parents=True)
+    return origin
+
+
+def test_clone_command_is_registered():
+    assert "clone" in cli.commands["harness"].commands
+
+
+def test_clone_dry_run_targets_the_declared_path_not_the_workspace_fallback(tmp_path, monkeypatch):
+    workspace = tmp_path / "repos"
+    workspace.mkdir()
+    root = tmp_path / "cluster"
+    _write_harness(root, workspace)
+    calls = []
+    monkeypatch.setattr(clone_command, "git", lambda path, *args, **kwargs: calls.append((path, args)) or _result())
+
+    result = CliRunner().invoke(cli, ["harness", "clone", "--harness", str(root), "--dry-run"])
+
+    assert result.exit_code == 0
+    assert f"would clone https://github.com/acme/alpha.git into {(workspace / 'nested' / 'alpha').resolve()}" in (
+        result.output
+    )
+    assert f"would clone git@github.com:acme/beta.git into {(workspace / 'beta').resolve()}" in result.output
+    assert calls == []
+
+
+def test_clone_runs_git_clone_from_the_parent_directory(tmp_path, monkeypatch):
+    workspace = tmp_path / "repos"
+    workspace.mkdir()
+    root = tmp_path / "cluster"
+    _write_harness(root, workspace)
+    calls = []
+
+    def fake_git(path, *args, **kwargs):
+        calls.append((path, args))
+        return _result()
+
+    monkeypatch.setattr(clone_command, "git", fake_git)
+    result = CliRunner().invoke(cli, ["harness", "clone", "--harness", str(root), "--repo", "beta", "--depth", "1"])
+
+    target = (workspace / "beta").resolve()
+    assert result.exit_code == 0
+    assert calls == [(target.parent, ("clone", "--depth", "1", "git@github.com:acme/beta.git", str(target)))]
+    assert f"cloned into {target}" in result.output
+
+
+def test_clone_creates_the_parent_of_a_nested_declared_path(tmp_path, monkeypatch):
+    workspace = tmp_path / "repos"
+    workspace.mkdir()
+    root = tmp_path / "cluster"
+    _write_harness(root, workspace)
+    monkeypatch.setattr(clone_command, "git", lambda path, *args, **kwargs: _result())
+
+    result = CliRunner().invoke(cli, ["harness", "clone", "--harness", str(root), "--repo", "alpha"])
+
+    assert result.exit_code == 0
+    assert (workspace / "nested").is_dir()
+
+
+def test_clone_leaves_an_existing_checkout_alone(tmp_path, monkeypatch):
+    workspace = tmp_path / "repos"
+    workspace.mkdir()
+    root = tmp_path / "cluster"
+    _write_harness(root, workspace)
+    _checkout(workspace / "nested" / "alpha")
+    # The ssh form of the same remote must not read as a different repository.
+    monkeypatch.setattr(
+        clone_command, "git", lambda path, *args, **kwargs: _result(stdout="git@github.com:acme/alpha.git\n")
+    )
+
+    result = CliRunner().invoke(cli, ["harness", "clone", "--harness", str(root), "--repo", "alpha"])
+
+    assert result.exit_code == 0
+    assert "alpha  skipped (already cloned)" in result.output
+
+
+def test_clone_reports_a_checkout_whose_origin_is_a_different_repo(tmp_path, monkeypatch):
+    workspace = tmp_path / "repos"
+    workspace.mkdir()
+    root = tmp_path / "cluster"
+    _write_harness(root, workspace)
+    _checkout(workspace / "nested" / "alpha")
+    monkeypatch.setattr(
+        clone_command, "git", lambda path, *args, **kwargs: _result(stdout="https://github.com/other/fork.git\n")
+    )
+
+    result = CliRunner().invoke(cli, ["harness", "clone", "--harness", str(root), "--repo", "alpha"])
+
+    assert result.exit_code == 0
+    assert "skipped (already cloned, but origin is https://github.com/other/fork.git)" in result.output
+
+
+def test_clone_reports_a_checkout_sitting_somewhere_other_than_the_declared_path(tmp_path, monkeypatch):
+    workspace = tmp_path / "repos"
+    workspace.mkdir()
+    root = tmp_path / "cluster"
+    _write_harness(root, workspace)
+    _checkout(workspace / "alpha")
+    monkeypatch.setattr(clone_command, "git", lambda path, *args, **kwargs: _result())
+
+    result = CliRunner().invoke(cli, ["harness", "clone", "--harness", str(root), "--repo", "alpha"])
+
+    assert result.exit_code == 0
+    assert f"already cloned at {(workspace / 'alpha').resolve()}" in result.output
+    assert f"manifest says {(workspace / 'nested' / 'alpha').resolve()}" in result.output
+
+
+def test_clone_refuses_to_write_into_an_occupied_path(tmp_path, monkeypatch):
+    workspace = tmp_path / "repos"
+    workspace.mkdir()
+    (workspace / "beta").mkdir()
+    (workspace / "beta" / "notes.txt").write_text("mine", encoding="utf-8")
+    root = tmp_path / "cluster"
+    _write_harness(root, workspace)
+    monkeypatch.setattr(clone_command, "git", lambda path, *args, **kwargs: _result())
+
+    result = CliRunner().invoke(cli, ["harness", "clone", "--harness", str(root), "--repo", "beta"])
+
+    assert result.exit_code == 1
+    assert "failed (path is taken and is not an empty directory" in result.output
+
+
+def test_clone_reports_the_git_failure_and_exits_nonzero(tmp_path, monkeypatch):
+    workspace = tmp_path / "repos"
+    workspace.mkdir()
+    root = tmp_path / "cluster"
+    _write_harness(root, workspace)
+    monkeypatch.setattr(
+        clone_command,
+        "git",
+        lambda path, *args, **kwargs: _result(returncode=128, stderr="fatal: repository not found\n"),
+    )
+
+    result = CliRunner().invoke(cli, ["harness", "clone", "--harness", str(root), "--repo", "beta"])
+
+    assert result.exit_code == 1
+    assert "failed (fatal: repository not found)" in result.output
+
+
+def test_clone_skips_present_false_unless_asked(tmp_path, monkeypatch):
+    workspace = tmp_path / "repos"
+    workspace.mkdir()
+    root = tmp_path / "cluster"
+    _write_harness(root, workspace, extra="- name: gamma\n  present: false\n  origin: https://x.test/gamma.git\n")
+    monkeypatch.setattr(clone_command, "git", lambda path, *args, **kwargs: _result())
+
+    skipped = CliRunner().invoke(cli, ["harness", "clone", "--harness", str(root), "--dry-run"])
+    forced = CliRunner().invoke(cli, ["harness", "clone", "--harness", str(root), "--dry-run", "--all"])
+    named = CliRunner().invoke(cli, ["harness", "clone", "--harness", str(root), "--dry-run", "--repo", "gamma"])
+
+    assert "gamma  skipped (present: false)" in skipped.output
+    assert f"would clone https://x.test/gamma.git into {(workspace / 'gamma').resolve()}" in forced.output
+    assert f"would clone https://x.test/gamma.git into {(workspace / 'gamma').resolve()}" in named.output
+
+
+def test_clone_fails_a_repo_with_no_origin(tmp_path, monkeypatch):
+    workspace = tmp_path / "repos"
+    workspace.mkdir()
+    root = tmp_path / "cluster"
+    root.mkdir()
+    (root / "harness.yaml").write_text(
+        f"name: test-cluster\nworkspace: {workspace.as_posix()}\nrepos:\n- name: alpha\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(clone_command, "git", lambda path, *args, **kwargs: _result())
+
+    result = CliRunner().invoke(cli, ["harness", "clone", "--harness", str(root)])
+
+    assert result.exit_code == 1
+    assert "failed (no origin declared in the manifest)" in result.output
+
+
+def test_clone_moves_onto_the_declared_branch_when_it_exists(tmp_path, monkeypatch):
+    workspace = tmp_path / "repos"
+    workspace.mkdir()
+    root = tmp_path / "cluster"
+    root.mkdir()
+    (root / "harness.yaml").write_text(
+        f"name: test-cluster\nworkspace: {workspace.as_posix()}\nrepos:\n"
+        "- name: beta\n  origin: git@github.com:acme/beta.git\n  branch: feat/new-intent-flow\n",
+        encoding="utf-8",
+    )
+    calls = []
+
+    def fake_git(path, *args, **kwargs):
+        calls.append(args)
+        if args[0] == "rev-parse":
+            return _result(stdout="main\n")
+        return _result()
+
+    monkeypatch.setattr(clone_command, "git", fake_git)
+    result = CliRunner().invoke(cli, ["harness", "clone", "--harness", str(root)])
+
+    assert result.exit_code == 0
+    assert ("checkout", "feat/new-intent-flow") in calls
+    assert "(on feat/new-intent-flow)" in result.output
+
+
+def test_clone_keeps_a_clone_whose_declared_branch_is_not_pushed_yet(tmp_path, monkeypatch):
+    workspace = tmp_path / "repos"
+    workspace.mkdir()
+    root = tmp_path / "cluster"
+    root.mkdir()
+    (root / "harness.yaml").write_text(
+        f"name: test-cluster\nworkspace: {workspace.as_posix()}\nrepos:\n"
+        "- name: beta\n  origin: git@github.com:acme/beta.git\n  branch: feat/unpushed\n",
+        encoding="utf-8",
+    )
+
+    def fake_git(path, *args, **kwargs):
+        if args[0] == "rev-parse":
+            return _result(stdout="main\n")
+        if args[0] == "checkout":
+            return _result(returncode=1, stderr="error: pathspec did not match\n")
+        return _result()
+
+    monkeypatch.setattr(clone_command, "git", fake_git)
+    result = CliRunner().invoke(cli, ["harness", "clone", "--harness", str(root)])
+
+    assert result.exit_code == 0
+    assert "cloned into" in result.output
+    assert "branch 'feat/unpushed' is not on origin, left on main" in result.output
+
+
+def test_clone_rejects_unknown_repo(tmp_path):
+    workspace = tmp_path / "repos"
+    workspace.mkdir()
+    root = tmp_path / "cluster"
+    _write_harness(root, workspace)
+
+    result = CliRunner().invoke(cli, ["harness", "clone", "--harness", str(root), "--repo", "nope"])
+
+    assert result.exit_code == 1
+    assert "Unknown repo name(s): nope" in result.output
+
+
+def test_normalize_remote_matches_ssh_and_https_forms():
+    assert clone_command.normalize_remote("git@github.com:acme/repo.git") == "github.com/acme/repo"
+    assert clone_command.normalize_remote("https://github.com/acme/repo.git") == "github.com/acme/repo"
+    assert clone_command.normalize_remote("ssh://git@github.com/acme/repo/") == "github.com/acme/repo"
+    assert clone_command.normalize_remote("https://github.com/acme/other") != "github.com/acme/repo"

evo_cli-0.18.0/evo_cli/VERSION

@@ -1 +0,0 @@
-0.18.0