assertion-cli 0.5.9__tar.gz → 0.5.11__tar.gz

{assertion_cli-0.5.9 → assertion_cli-0.5.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertion-cli
-Version: 0.5.9
+Version: 0.5.11
 Summary: CLI for the Assertion API
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown

{assertion_cli-0.5.9 → assertion_cli-0.5.11}/assertion_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertion-cli
-Version: 0.5.9
+Version: 0.5.11
 Summary: CLI for the Assertion API
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown

{assertion_cli-0.5.9 → assertion_cli-0.5.11}/git.py

@@ -49,11 +49,14 @@ def get_head_sha(repo_root: Path) -> str:
 def get_upstream_ref(repo_root: Path) -> str | None:
     """Return the upstream tracking ref (e.g. ``origin/main``).
 
-    Tries HEAD's configured upstream first (``HEAD@{upstream}``). When the
-    branch has no upstream but the branch name itself resolves on the default
-    remote, falls back to ``origin/<branch>``. Returns ``None`` when neither
-    is available (detached HEAD, no remote, branch not pushed).
+    Tries HEAD's configured upstream first, then falls through increasingly
+    general heuristics to find a remote ref to compute a merge-base against:
+    same-named remote branch, closest remote ancestor (via
+    ``git branch -r --merged HEAD`` + ``git merge-base``), then well-known
+    default branch names. Returns ``None`` when none are available.
     """
+
+    # 1. Configured upstream (git branch -u).
     try:
         return run_git_command(
             repo_root, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"]
@@ -61,6 +64,7 @@ def get_upstream_ref(repo_root: Path) -> str | None:
     except RuntimeError:
         pass
 
+    # 2. Same branch name on remote (has been pushed at least once).
     head_branch = get_head_branch(repo_root)
     if head_branch is not None:
         fallback = f"origin/{head_branch}"
@@ -71,6 +75,50 @@ def get_upstream_ref(repo_root: Path) -> str | None:
         else:
             return fallback
 
+    # 3. Closest remote ancestor — handles branches based on other pushed
+    #    branches (e.g. my-feature on my-feature-base). Uses --merged HEAD
+    #    so only remote branches in HEAD's ancestry are considered; a branch
+    #    whose tip moved forward after we branched off is correctly excluded.
+    try:
+        merged = run_git_command(
+            repo_root,
+            [
+                "branch", "-r", "--merged", "HEAD",
+                "--format=%(refname:short)",
+            ],
+        )
+        ancestors = [r for r in merged.splitlines() if r]
+        if ancestors:
+            return run_git_command(
+                repo_root, ["merge-base", "HEAD", *ancestors]
+            )
+    except RuntimeError:
+        pass
+
+    # 4. Remote's default branch (symbolic ref, usually origin/main).
+    try:
+        run_git_command(repo_root, ["rev-parse", "--verify", "origin/HEAD"])
+    except RuntimeError:
+        pass
+    else:
+        return "origin/HEAD"
+
+    # 5. Conventional default branch name.
+    try:
+        run_git_command(repo_root, ["rev-parse", "--verify", "origin/main"])
+    except RuntimeError:
+        pass
+    else:
+        return "origin/main"
+
+    # 6. Legacy default branch name.
+    try:
+        run_git_command(repo_root, ["rev-parse", "--verify", "origin/master"])
+    except RuntimeError:
+        pass
+    else:
+        return "origin/master"
+
     return None
 
 

{assertion_cli-0.5.9 → assertion_cli-0.5.11}/main.py

@@ -16,9 +16,11 @@ from git import (
     find_git_root,
     get_full_diff,
     get_head_branch,
+    get_head_sha,
     get_merge_base,
     get_uncommitted_diff,
     get_upstream_ref,
+    run_git_command,
 )
 from link import load_link, save_link
 from models import CheckpointResponse, SessionStatus, render_stack_list
@@ -265,18 +267,27 @@ app.add_typer(session_app, name="session")
 def _resolve_diff_base(repo_root: Path) -> str:
     """Compute the merge-base with the upstream tracking branch.
 
-    Errors out when no upstream can be resolved (detached HEAD, no tracking
-    branch, branch not pushed to remote).
+    Fetches from origin first so the merge-base SHA is guaranteed to exist
+    on the remote when the backend checks it out — stale remote tracking
+    refs (from a force-pushed or rebased branch) would otherwise produce a
+    merge-base that's no longer reachable from any remote ref.
+
+    Falls back to HEAD when no upstream can be resolved (e.g. Codex cloud
+    sandboxes with no remote tracking refs) — the branch was cloned from the
+    remote so HEAD exists on the remote at session start time.
     """
+    try:
+        run_git_command(repo_root, ["fetch", "--no-tags", "origin"])
+    except RuntimeError:
+        pass  # non-fatal: offline or unavailable; proceed with stale refs
+
     upstream = get_upstream_ref(repo_root)
     if upstream is None:
-        exit_with_error(
-            "Cannot determine the diff base: no upstream tracking branch found.\n"
-            "Make sure you are on a branch that has been pushed to a remote "
-            "with a tracking branch configured, e.g.:\n"
-            "  git push -u origin <branch>\n"
-            "Or use an existing branch that tracks an upstream.",
+        typer.echo(
+            "Warning: no upstream tracking branch found, falling back to HEAD.",
+            err=True,
         )
+        return get_head_sha(repo_root)
     return get_merge_base(repo_root, upstream)
 
 
@@ -285,9 +296,10 @@ def session_start() -> None:
     """Record the merge-base with the upstream tracking branch as the diff base.
 
     Unlike the old HEAD-based approach, the merge-base always exists on the
-    remote so the backend can check it out. Branches without a remote tracking
-    ref (detached HEAD, no upstream, not pushed) are rejected with a clear
-    message — run ``asrt session start`` from a branch with an upstream.
+    remote so the backend can check it out. When no upstream tracking branch
+    can be resolved (e.g. Codex cloud sandboxes), falls back to HEAD — the
+    branch was cloned from the remote so HEAD exists on the remote at session
+    start time.
 
     `session start` does not write skill files — that is `asrt install`, the
     one-time onboarding step. It also never touches user content in `CLAUDE.md` /

{assertion_cli-0.5.9 → assertion_cli-0.5.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "assertion-cli"
-version = "0.5.9"
+version = "0.5.11"
 description = "CLI for the Assertion API"
 readme = "README.md"
 requires-python = ">=3.13"

{assertion_cli-0.5.9 → assertion_cli-0.5.11}/templates/SKILL.md

@@ -15,7 +15,7 @@ Before any `asrt` call:
 
 - You are inside a git repository.
 - `asrt install` has been run once in this repo. It installs the skill files you are reading right now (plus the `AGENTS.md` / `CLAUDE.md` pointer and `.gitignore` rules). This is an onboarding step, not a per-run one.
-- `asrt session start` has been run for this work session. It records the current HEAD as the diff base that every checkpoint/verify diffs against. If `asrt checkpoint` or `asrt verify` errors with "No diff base recorded", run `asrt session start` and retry.
+- `asrt session start` has been run for this work session. It records the merge-base with the upstream tracking branch (falling back to HEAD when no upstream is available) as the diff base that every checkpoint/verify diffs against. If `asrt checkpoint` or `asrt verify` errors with "No diff base recorded", run `asrt session start` and retry.
 
 **First command sequence for a new work session:**
 

{assertion_cli-0.5.9 → assertion_cli-0.5.11}/tests/test_git.py

@@ -7,7 +7,6 @@ from click.exceptions import Exit as ClickExit
 from git import (
     find_git_root,
     get_full_diff,
-    get_head_branch,
     get_head_sha,
     get_merge_base,
     get_uncommitted_diff,
@@ -180,6 +179,187 @@ def test_get_upstream_ref_detached_head(tmp_path: Path) -> None:
     assert ref is None
 
 
+def test_get_upstream_ref_fallback_to_origin_head(tmp_path: Path) -> None:
+    """HEAD on an orphan commit (no shared history with remote refs)
+    returns origin/HEAD."""
+    subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
+    _make_commit(tmp_path)
+    subprocess.run(
+        ["git", "remote", "add", "origin", "http://example.com/repo.git"],
+        cwd=tmp_path, capture_output=True, check=True,
+    )
+    subprocess.run(
+        ["git", "symbolic-ref", "refs/remotes/origin/HEAD", "refs/remotes/origin/somebranch"],
+        cwd=tmp_path, capture_output=True, check=True,
+    )
+    subprocess.run(
+        ["git", "update-ref", "refs/remotes/origin/somebranch", "HEAD"],
+        cwd=tmp_path, capture_output=True, check=True,
+    )
+    # Create an orphan commit so HEAD has no shared history with the
+    # remote refs — this makes step 3 (--merged HEAD) produce nothing.
+    subprocess.run(
+        ["git", "checkout", "--orphan", "orphan-branch"],
+        cwd=tmp_path, capture_output=True, check=True,
+    )
+    (tmp_path / "orphan.txt").write_text("orphan\n")
+    subprocess.run(
+        ["git", "add", "orphan.txt"], cwd=tmp_path, capture_output=True, check=True
+    )
+    subprocess.run(
+        ["git", "commit", "-m", "orphan"],
+        cwd=tmp_path, capture_output=True, check=True,
+        env={**GIT_ENV, "HOME": str(tmp_path)},
+    )
+    ref = get_upstream_ref(tmp_path)
+    assert ref == "origin/HEAD"
+
+
+def test_get_upstream_ref_fallback_to_origin_main(tmp_path: Path) -> None:
+    """HEAD on an orphan commit, no origin/HEAD, but origin/main exists."""
+    subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
+    _make_commit(tmp_path)
+    subprocess.run(
+        ["git", "remote", "add", "origin", "http://example.com/repo.git"],
+        cwd=tmp_path, capture_output=True, check=True,
+    )
+    subprocess.run(
+        ["git", "update-ref", "refs/remotes/origin/main", "HEAD"],
+        cwd=tmp_path, capture_output=True, check=True,
+    )
+    subprocess.run(
+        ["git", "checkout", "--orphan", "orphan-branch"],
+        cwd=tmp_path, capture_output=True, check=True,
+    )
+    (tmp_path / "orphan.txt").write_text("orphan\n")
+    subprocess.run(
+        ["git", "add", "orphan.txt"], cwd=tmp_path, capture_output=True, check=True
+    )
+    subprocess.run(
+        ["git", "commit", "-m", "orphan"],
+        cwd=tmp_path, capture_output=True, check=True,
+        env={**GIT_ENV, "HOME": str(tmp_path)},
+    )
+    ref = get_upstream_ref(tmp_path)
+    assert ref == "origin/main"
+
+
+def test_get_upstream_ref_fallback_to_origin_master(tmp_path: Path) -> None:
+    """HEAD on an orphan commit, no origin/HEAD/main, origin/master exists."""
+    subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
+    _make_commit(tmp_path)
+    subprocess.run(
+        ["git", "remote", "add", "origin", "http://example.com/repo.git"],
+        cwd=tmp_path, capture_output=True, check=True,
+    )
+    subprocess.run(
+        ["git", "update-ref", "refs/remotes/origin/master", "HEAD"],
+        cwd=tmp_path, capture_output=True, check=True,
+    )
+    subprocess.run(
+        ["git", "checkout", "--orphan", "orphan-branch"],
+        cwd=tmp_path, capture_output=True, check=True,
+    )
+    (tmp_path / "orphan.txt").write_text("orphan\n")
+    subprocess.run(
+        ["git", "add", "orphan.txt"], cwd=tmp_path, capture_output=True, check=True
+    )
+    subprocess.run(
+        ["git", "commit", "-m", "orphan"],
+        cwd=tmp_path, capture_output=True, check=True,
+        env={**GIT_ENV, "HOME": str(tmp_path)},
+    )
+    ref = get_upstream_ref(tmp_path)
+    assert ref == "origin/master"
+
+
+def test_get_upstream_ref_fallback_to_merged_ancestors(tmp_path: Path) -> None:
+    """Branch based on a pushed feature branch finds the closest remote
+    ancestor via --merged HEAD + merge-base."""
+    _init_repo_with_commit(tmp_path)
+    base_sha = run_git_command(tmp_path, ["rev-parse", "HEAD"])
+    subprocess.run(
+        ["git", "remote", "add", "origin", "http://example.com/repo.git"],
+        cwd=tmp_path, capture_output=True, check=True,
+    )
+
+    # Simulate origin/main at the initial commit.
+    subprocess.run(
+        ["git", "update-ref", "refs/remotes/origin/main", base_sha],
+        cwd=tmp_path, capture_output=True, check=True,
+    )
+
+    # Simulate a pushed feature branch (origin/my-feature-base) with a
+    # commit on top of main.
+    (tmp_path / "base.txt").write_text("base\n")
+    subprocess.run(
+        ["git", "add", "base.txt"], cwd=tmp_path, capture_output=True, check=True
+    )
+    subprocess.run(
+        ["git", "commit", "-m", "base work"],
+        cwd=tmp_path, capture_output=True, check=True,
+        env={**GIT_ENV, "HOME": str(tmp_path)},
+    )
+    feature_base_sha = run_git_command(tmp_path, ["rev-parse", "HEAD"])
+    subprocess.run(
+        ["git", "update-ref", "refs/remotes/origin/my-feature-base", feature_base_sha],
+        cwd=tmp_path, capture_output=True, check=True,
+    )
+
+    # Create a new local branch on top of my-feature-base (simulates a
+    # branch-off that hasn't been pushed). Use a branch name that doesn't
+    # collide with any remote ref so step 2 is skipped.
+    subprocess.run(
+        ["git", "checkout", "-b", "my-feature"],
+        cwd=tmp_path, capture_output=True, check=True,
+    )
+    (tmp_path / "new.txt").write_text("new\n")
+    subprocess.run(
+        ["git", "add", "new.txt"], cwd=tmp_path, capture_output=True, check=True
+    )
+    subprocess.run(
+        ["git", "commit", "-m", "new work"],
+        cwd=tmp_path, capture_output=True, check=True,
+        env={**GIT_ENV, "HOME": str(tmp_path)},
+    )
+
+    ref = get_upstream_ref(tmp_path)
+    assert ref is not None
+    # ref was returned by `git merge-base HEAD ...`, it should be the
+    # SHA of the feature base, not a named ref.
+    assert ref == feature_base_sha
+
+
+def test_get_upstream_ref_no_fallback(tmp_path: Path) -> None:
+    """No upstream, no origin/HEAD, no known default branches returns None."""
+    subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
+    _make_commit(tmp_path)
+    subprocess.run(
+        ["git", "remote", "add", "origin", "http://example.com/repo.git"],
+        cwd=tmp_path, capture_output=True, check=True,
+    )
+    ref = get_upstream_ref(tmp_path)
+    assert ref is None
+
+
+def _make_commit(tmp_path: Path) -> None:
+    """Helper: make an initial commit in a bare init."""
+    subprocess.run(
+        ["git", "commit", "--allow-empty", "-m", "init"],
+        cwd=tmp_path,
+        capture_output=True,
+        check=True,
+        env={
+            "GIT_AUTHOR_NAME": "T",
+            "GIT_AUTHOR_EMAIL": "t@t",
+            "GIT_COMMITTER_NAME": "T",
+            "GIT_COMMITTER_EMAIL": "t@t",
+            "HOME": str(tmp_path),
+            "PATH": "/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin",
+        },
+    )
+
+
 # --- get_merge_base ---
 
 

{assertion_cli-0.5.9 → assertion_cli-0.5.11}/tests/test_new.py

@@ -125,15 +125,18 @@ def test_new_leaves_next_checkpoint_requiring_stack(
     assert not (assertion_dir / "metadata.json").exists()
 
 
-def test_new_requires_upstream_tracking_branch(
+def test_new_falls_back_to_head_when_no_upstream(
     tmp_path: Path,
     monkeypatch,
 ) -> None:
+    """When no upstream tracking branch exists, fall back to HEAD instead of erroring."""
     _run_git(tmp_path, "init")
     _run_git(tmp_path, "commit", "--allow-empty", "-m", "init")
+    head_sha = _run_git(tmp_path, "rev-parse", "HEAD")
     monkeypatch.chdir(tmp_path)
 
     result = runner.invoke(main.app, ["new"])
 
-    assert result.exit_code == 1
-    assert "no upstream tracking branch" in result.stderr
+    assert result.exit_code == 0
+    assert "falling back to HEAD" in result.stderr
+    assert (tmp_path / ".assertion" / "base_sha").read_text().strip() == head_sha

{assertion_cli-0.5.9 → assertion_cli-0.5.11}/tests/test_session_start.py

@@ -197,23 +197,27 @@ def test_session_start_requires_git_repo(tmp_path: Path, monkeypatch) -> None:
     assert "git repository" in result.stderr
 
 
-def test_session_start_requires_upstream_tracking_branch(
+def test_session_start_falls_back_to_head_when_no_upstream(
     tmp_path: Path, monkeypatch
 ) -> None:
+    """When no upstream tracking branch exists, fall back to HEAD instead of erroring.
+
+    Codex cloud sandboxes may not have upstream tracking configured, but the
+    branch was cloned from the remote so HEAD exists on the remote.
+    """
     _run_git(tmp_path, "init")
     _run_git(tmp_path, "commit", "--allow-empty", "-m", "init")
+    head_sha = _run_git(tmp_path, "rev-parse", "HEAD")
     monkeypatch.chdir(tmp_path)
 
     result = runner.invoke(main.app, ["session", "start"])
 
-    assert result.exit_code == 1
-    assert "no upstream tracking branch" in result.stderr
-    assert not (tmp_path / ".assertion" / "base_sha").exists()
+    assert result.exit_code == 0
+    assert "falling back to HEAD" in result.stderr
+    assert (tmp_path / ".assertion" / "base_sha").read_text().strip() == head_sha
 
 
-def test_session_start_records_merge_base_as_base(
-    tmp_path: Path, monkeypatch
-) -> None:
+def test_session_start_records_merge_base_as_base(tmp_path: Path, monkeypatch) -> None:
     """`asrt session start` pins the diff base to the branch merge-base.
 
     Every subsequent checkpoint/verify diffs against this SHA, so backend can