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

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

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

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

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

{assertion_cli-0.5.8 → assertion_cli-0.5.9}/bundle.py

@@ -6,6 +6,7 @@ from models import MetadataPayload
 
 ASSERTION_DIR_NAME = ".assertion"
 DIFF_ARCHIVE_PATH = "git.diff"
+UNCOMMITTED_DIFF_ARCHIVE_PATH = "uncommitted.diff"
 METADATA_ARCHIVE_PATH = f"{ASSERTION_DIR_NAME}/metadata.json"
 PROMPTS_ARCHIVE_PATH = f"{ASSERTION_DIR_NAME}/prompts"
 CHECKPOINT_ARCHIVE_PATH = f"{ASSERTION_DIR_NAME}/checkpoint"
@@ -30,6 +31,7 @@ def build_bundle(
     *,
     metadata: MetadataPayload,
     diff_text: str,
+    uncommitted_diff_text: str,
     prompts_text: str,
     checkpoint_text: str,
 ) -> bytes:
@@ -39,4 +41,5 @@ def build_bundle(
         zf.writestr(PROMPTS_ARCHIVE_PATH, prompts_text)
         zf.writestr(CHECKPOINT_ARCHIVE_PATH, checkpoint_text)
         zf.writestr(DIFF_ARCHIVE_PATH, diff_text)
+        zf.writestr(UNCOMMITTED_DIFF_ARCHIVE_PATH, uncommitted_diff_text)
     return buf.getvalue()

assertion_cli-0.5.9/git.py

@@ -0,0 +1,199 @@
+import subprocess
+from pathlib import Path
+from typing import NoReturn, Sequence
+
+import typer
+
+
+def exit_with_error(message: str) -> NoReturn:
+    typer.echo(message, err=True)
+    raise typer.Exit(code=1)
+
+
+def run_git_command(
+    repo_root: Path, args: Sequence[str], *, preserve_stdout: bool = False
+) -> str:
+    completed = subprocess.run(
+        ["git", *args],
+        cwd=repo_root,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if completed.returncode != 0:
+        message = completed.stderr.strip() or completed.stdout.strip() or "git failed"
+        raise RuntimeError(message)
+    return completed.stdout if preserve_stdout else completed.stdout.strip()
+
+
+def find_git_root(start_path: Path) -> Path:
+    completed = subprocess.run(
+        ["git", "rev-parse", "--show-toplevel"],
+        cwd=start_path,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if completed.returncode != 0:
+        exit_with_error("Current directory is not inside a git repository.")
+    return Path(completed.stdout.strip())
+
+
+def get_head_sha(repo_root: Path) -> str:
+    try:
+        return run_git_command(repo_root, ["rev-parse", "HEAD"])
+    except RuntimeError as exc:
+        exit_with_error(f"Failed to get HEAD SHA: {exc}")
+
+
+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).
+    """
+    try:
+        return run_git_command(
+            repo_root, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"]
+        )
+    except RuntimeError:
+        pass
+
+    head_branch = get_head_branch(repo_root)
+    if head_branch is not None:
+        fallback = f"origin/{head_branch}"
+        try:
+            run_git_command(repo_root, ["rev-parse", "--verify", fallback])
+        except RuntimeError:
+            pass
+        else:
+            return fallback
+
+    return None
+
+
+def get_merge_base(repo_root: Path, upstream: str) -> str:
+    """Return the merge-base of ``HEAD`` and *upstream*."""
+    try:
+        return run_git_command(repo_root, ["merge-base", "HEAD", upstream])
+    except RuntimeError as exc:
+        exit_with_error(
+            f"Failed to compute merge-base between HEAD and {upstream}: {exc}"
+        )
+
+
+def get_head_branch(repo_root: Path) -> str | None:
+    """Return the current branch name, or None if HEAD is detached."""
+    try:
+        name = run_git_command(repo_root, ["rev-parse", "--abbrev-ref", "HEAD"])
+    except RuntimeError:
+        return None
+    return name if name and name != "HEAD" else None
+
+
+def _build_untracked_diff(repo_root: Path, rel_path: str) -> str:
+    completed = subprocess.run(
+        [
+            "git",
+            "diff",
+            "--no-index",
+            "--src-prefix=a/",
+            "--dst-prefix=b/",
+            "--",
+            "/dev/null",
+            rel_path,
+        ],
+        cwd=repo_root,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if completed.returncode not in (0, 1):
+        message = completed.stderr.strip() or completed.stdout.strip() or "git failed"
+        raise RuntimeError(message)
+    return completed.stdout
+
+
+# Paths the assertion-cli owns end-to-end. Excluded from the diff bundle so
+# reviewers don't flag our own bootstrap files as "unrelated changes" — they're
+# generated by `asrt install` and have nothing to do with the user's feature
+# work. CLAUDE.md / AGENTS.md are intentionally NOT in this list: `asrt install`
+# writes a small pointer block into them once at onboarding (meant to be
+# committed before work starts, so it never shows in a work-session diff), but
+# the rest of those files is the user's own and must flow through to reviewers.
+_ASSERTION_EXCLUDED_PATHSPECS = [
+    ":(exclude).assertion",
+    ":(exclude).claude/skills/assertion-cli",
+    ":(exclude).agents/skills/assertion-cli",
+]
+
+
+def _build_tracked_diff(repo_root: Path, base: str) -> str:
+    """``git diff <base>`` for tracked files, excluding assertion-owned paths."""
+    return run_git_command(
+        repo_root,
+        ["diff", base, "--", *_ASSERTION_EXCLUDED_PATHSPECS],
+        preserve_stdout=True,
+    )
+
+
+def _build_untracked_diffs(repo_root: Path) -> list[str]:
+    """Diff of every untracked (but non-ignored) file as a new-file diff."""
+    output = run_git_command(
+        repo_root,
+        [
+            "ls-files",
+            "--others",
+            "--exclude-standard",
+            "--",
+            *_ASSERTION_EXCLUDED_PATHSPECS,
+        ],
+    )
+    return [
+        _build_untracked_diff(repo_root, rel_path)
+        for rel_path in output.splitlines()
+        if rel_path
+    ]
+
+
+def _join_diffs(parts: list[str]) -> str:
+    parts = [_ensure_trailing_newline(p) for p in parts if p]
+    return "".join(parts)
+
+
+def get_uncommitted_diff(repo_root: Path) -> str:
+    """Build a diff of **only uncommitted** changes (staged + unstaged +
+    untracked).
+
+    ``git diff HEAD`` compares the working tree directly to ``HEAD``, so
+    local commits are excluded — only changes the agent hasn't committed yet
+    appear.
+    """
+    try:
+        tracked = _build_tracked_diff(repo_root, "HEAD")
+        untracked = _build_untracked_diffs(repo_root)
+        return _join_diffs([tracked, *untracked])
+    except RuntimeError as exc:
+        exit_with_error(f"Failed to collect uncommitted diff: {exc}")
+
+
+def get_full_diff(repo_root: Path, base_sha: str) -> str:
+    """Build a unified diff from ``base_sha`` to the current working tree.
+
+    ``git diff <base_sha>`` captures everything since the base commit —
+    local commits, staged changes, unstaged changes, and untracked files.
+    This is the diff the backend uses to reconstruct the full working state
+    (for terminal/browser sandboxes).
+    """
+    try:
+        tracked = _build_tracked_diff(repo_root, base_sha)
+        untracked = _build_untracked_diffs(repo_root)
+        return _join_diffs([tracked, *untracked])
+    except RuntimeError as exc:
+        exit_with_error(f"Failed to collect full diff: {exc}")
+
+
+def _ensure_trailing_newline(value: str) -> str:
+    return value if value.endswith("\n") else value + "\n"

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

@@ -14,9 +14,11 @@ from bundle import build_bundle
 from git import (
     exit_with_error,
     find_git_root,
+    get_full_diff,
     get_head_branch,
-    get_head_sha,
+    get_merge_base,
     get_uncommitted_diff,
+    get_upstream_ref,
 )
 from link import load_link, save_link
 from models import CheckpointResponse, SessionStatus, render_stack_list
@@ -260,13 +262,32 @@ session_app = typer.Typer(help="Manage Assertion work sessions.")
 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).
+    """
+    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.",
+        )
+    return get_merge_base(repo_root, upstream)
+
+
 @session_app.command("start")
 def session_start() -> None:
-    """Record the current HEAD SHA as the diff base for this repo's work session.
+    """Record the merge-base with the upstream tracking branch as the diff base.
 
-    The base is what the backend `git checkout`s against before applying the
-    diff — capturing it once here means later commands don't need to rediscover
-    it (which previously broke in sandboxes with no remote-tracking refs).
+    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.
 
     `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` /
@@ -276,7 +297,7 @@ def session_start() -> None:
     repo_root = find_git_root(Path.cwd())
     _ensure_gitignore_limits_assertion_state(repo_root)
 
-    base_sha = get_head_sha(repo_root)
+    base_sha = _resolve_diff_base(repo_root)
     assertion_dir = repo_root / ASSERTION_DIR_NAME
     assertion_dir.mkdir(exist_ok=True)
     base_sha_path = assertion_dir / BASE_SHA_FILE_NAME
@@ -294,9 +315,9 @@ def session_start() -> None:
 
 @app.command("new")
 def new() -> None:
-    """Reset local Assertion run state and record current HEAD as the diff base."""
+    """Reset local Assertion run state and record the merge-base as the diff base."""
     repo_root = find_git_root(Path.cwd())
-    base_sha = get_head_sha(repo_root)
+    base_sha = _resolve_diff_base(repo_root)
     assertion_dir = repo_root / ASSERTION_DIR_NAME
     assertion_dir.mkdir(exist_ok=True)
 
@@ -401,13 +422,10 @@ def checkpoint(
     assert stack_id is not None
 
     append_checkpoint_entry(ctx.checkpoint_path, message)
-    # Base SHA is whatever `asrt session start` recorded for this repo. Backend
-    # uses it as the checkout target before applying the diff. Pinning it at
-    # session-start time (instead of rediscovering per command) means sandboxes
-    # without remote-tracking refs — e.g. Codex Cloud — still work.
     base_sha = read_init_base_sha(ctx.assertion_dir)
     head_branch = get_head_branch(ctx.repo_root)
-    diff_text = get_uncommitted_diff(ctx.repo_root, base_sha)
+    diff_text = get_full_diff(ctx.repo_root, base_sha)
+    uncommitted_diff_text = get_uncommitted_diff(ctx.repo_root)
     metadata = update_metadata_anchor(
         ctx.metadata_path, metadata, base_sha, head_branch=head_branch
     )
@@ -415,6 +433,7 @@ def checkpoint(
     bundle_bytes = build_bundle(
         metadata=metadata,
         diff_text=diff_text,
+        uncommitted_diff_text=uncommitted_diff_text,
         prompts_text=ctx.prompts_path.read_text(encoding="utf-8"),
         checkpoint_text=message,
     )
@@ -505,11 +524,10 @@ def verify(
     ctx, metadata = load_existing_session(Path.cwd())
     stack_id = metadata.stack_id
     assert stack_id is not None
-    # See checkpoint() for why the base is the SHA `asrt session start`
-    # recorded, not local HEAD.
     base_sha = read_init_base_sha(ctx.assertion_dir)
     head_branch = get_head_branch(ctx.repo_root)
-    diff_text = get_uncommitted_diff(ctx.repo_root, base_sha)
+    diff_text = get_full_diff(ctx.repo_root, base_sha)
+    uncommitted_diff_text = get_uncommitted_diff(ctx.repo_root)
     metadata = update_metadata_anchor(
         ctx.metadata_path, metadata, base_sha, head_branch=head_branch
     )
@@ -517,6 +535,7 @@ def verify(
     bundle_bytes = build_bundle(
         metadata=metadata,
         diff_text=diff_text,
+        uncommitted_diff_text=uncommitted_diff_text,
         prompts_text=ctx.prompts_path.read_text(encoding="utf-8"),
         checkpoint_text=ctx.checkpoint_path.read_text(encoding="utf-8"),
     )

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

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

{assertion_cli-0.5.8 → assertion_cli-0.5.9}/session.py

@@ -19,15 +19,16 @@ BASE_SHA_FILE_NAME = "base_sha"
 def read_init_base_sha(assertion_dir: Path) -> str:
     """Return the diff base SHA recorded by `asrt session start`.
 
-    Exits with a clear error if `asrt session start` hasn't been run or the file
-    is empty. The base SHA is the commit the backend `git checkout`s against
-    before applying the diff, so every checkpoint/verify must have it.
+    The base SHA is the merge-base with the upstream tracking branch — always
+    fetchable from the remote. Every checkpoint/verify reads this value; it
+    never changes within a session.
     """
     path = assertion_dir / BASE_SHA_FILE_NAME
     if not path.exists():
         exit_with_error(
             "No diff base recorded for this repo. Run `asrt session start` "
-            "first — it captures the HEAD SHA that checkpoint/verify diff against."
+            "first — it captures the merge-base SHA that checkpoint/verify "
+            "diff against."
         )
     content = path.read_text(encoding="utf-8").strip()
     if not content:

{assertion_cli-0.5.8 → assertion_cli-0.5.9}/tests/test_bundle.py

@@ -15,6 +15,7 @@ def test_build_bundle_writes_session_metadata() -> None:
     bundle_bytes = build_bundle(
         metadata=metadata,
         diff_text="diff --git a/file b/file",
+        uncommitted_diff_text="diff --git a/file b/file",
         prompts_text='{"ts": "2026-05-28T14:32:01Z", "text": "Do the thing"}\n',
         checkpoint_text="Checkpoint text",
     )
@@ -31,3 +32,10 @@ def test_build_bundle_writes_session_metadata() -> None:
 
         prompts_raw = zf.read(".assertion/prompts").decode("utf-8")
         assert '"text": "Do the thing"' in prompts_raw
+
+        # Both diffs are included in the bundle.
+        git_diff = zf.read("git.diff").decode("utf-8")
+        assert "diff --git a/file b/file" in git_diff
+
+        uncommitted_diff = zf.read("uncommitted.diff").decode("utf-8")
+        assert "diff --git a/file b/file" in uncommitted_diff

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

@@ -6,8 +6,12 @@ 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,
+    get_upstream_ref,
     run_git_command,
 )
 
@@ -16,7 +20,6 @@ from git import (
 
 
 def test_run_git_command_success(tmp_path: Path) -> None:
-    # init a real git repo
     subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
     result = run_git_command(tmp_path, ["rev-parse", "--git-dir"])
     assert result == ".git"
@@ -66,6 +69,142 @@ def test_get_head_sha(tmp_path: Path) -> None:
     assert len(sha) == 40
 
 
+# --- get_upstream_ref ---
+
+
+def test_get_upstream_ref_no_remote(tmp_path: Path) -> None:
+    """A bare repo with no remote returns None."""
+    subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
+    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",
+        },
+    )
+    ref = get_upstream_ref(tmp_path)
+    assert ref is None
+
+
+def test_get_upstream_ref_picks_configured_upstream(tmp_path: Path) -> None:
+    """When @{upstream} is configured it should be returned."""
+    subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
+    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",
+        },
+    )
+    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", "branch", "-u", "origin/main"],
+        cwd=tmp_path, capture_output=True, check=True,
+    )
+    ref = get_upstream_ref(tmp_path)
+    assert ref == "origin/main"
+
+
+def test_get_upstream_ref_fallback_origin_branch(tmp_path: Path) -> None:
+    """When @{upstream} is not configured but origin/<branch> exists, use it."""
+    subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
+    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",
+        },
+    )
+    subprocess.run(
+        ["git", "remote", "add", "origin", "http://example.com/repo.git"],
+        cwd=tmp_path, capture_output=True, check=True,
+    )
+    branch = subprocess.run(
+        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+        cwd=tmp_path, capture_output=True, text=True, check=True,
+    ).stdout.strip()
+    subprocess.run(
+        ["git", "update-ref", f"refs/remotes/origin/{branch}", "HEAD"],
+        cwd=tmp_path, capture_output=True, check=True,
+    )
+    ref = get_upstream_ref(tmp_path)
+    assert ref == f"origin/{branch}"
+
+
+def test_get_upstream_ref_detached_head(tmp_path: Path) -> None:
+    """Detached HEAD returns None when origin/<branch> is also unset."""
+    subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
+    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",
+        },
+    )
+    ref = get_upstream_ref(tmp_path)
+    assert ref is None
+
+
+# --- get_merge_base ---
+
+
+def test_get_merge_base_returns_head_when_at_upstream(tmp_path: Path) -> None:
+    """When HEAD is at the merge-base with its upstream, they should match."""
+    subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
+    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",
+        },
+    )
+    head = get_head_sha(tmp_path)
+    merge_base = get_merge_base(tmp_path, head)
+    assert merge_base == head
+
+
 # --- get_uncommitted_diff ---
 
 
@@ -92,13 +231,12 @@ def _init_repo_with_commit(tmp_path: Path) -> None:
 
 def test_get_uncommitted_diff_clean(tmp_path: Path) -> None:
     _init_repo_with_commit(tmp_path)
-    diff = get_uncommitted_diff(tmp_path, "HEAD")
+    diff = get_uncommitted_diff(tmp_path)
     assert diff == ""
 
 
 def test_get_uncommitted_diff_tracked_changes(tmp_path: Path) -> None:
     _init_repo_with_commit(tmp_path)
-    # Create and commit a file, then modify it
     f = tmp_path / "hello.txt"
     f.write_text("original\n")
     subprocess.run(
@@ -112,7 +250,7 @@ def test_get_uncommitted_diff_tracked_changes(tmp_path: Path) -> None:
         env={**GIT_ENV, "HOME": str(tmp_path)},
     )
     f.write_text("modified\n")
-    diff = get_uncommitted_diff(tmp_path, "HEAD")
+    diff = get_uncommitted_diff(tmp_path)
     assert "hello.txt" in diff
     assert "-original" in diff
     assert "+modified" in diff
@@ -125,7 +263,7 @@ def test_get_uncommitted_diff_staged_changes(tmp_path: Path) -> None:
     subprocess.run(
         ["git", "add", "staged.txt"], cwd=tmp_path, capture_output=True, check=True
     )
-    diff = get_uncommitted_diff(tmp_path, "HEAD")
+    diff = get_uncommitted_diff(tmp_path)
     assert "staged.txt" in diff
     assert "+staged content" in diff
 
@@ -134,7 +272,7 @@ def test_get_uncommitted_diff_untracked_files(tmp_path: Path) -> None:
     _init_repo_with_commit(tmp_path)
     f = tmp_path / "new_file.py"
     f.write_text("print('hello')\n")
-    diff = get_uncommitted_diff(tmp_path, "HEAD")
+    diff = get_uncommitted_diff(tmp_path)
     assert "new_file.py" in diff
     assert "new file mode" in diff
     assert "+print('hello')" in diff
@@ -142,7 +280,6 @@ def test_get_uncommitted_diff_untracked_files(tmp_path: Path) -> None:
 
 def test_get_uncommitted_diff_combines_all_sources(tmp_path: Path) -> None:
     _init_repo_with_commit(tmp_path)
-    # Tracked modification
     tracked = tmp_path / "tracked.txt"
     tracked.write_text("v1\n")
     subprocess.run(
@@ -156,16 +293,14 @@ def test_get_uncommitted_diff_combines_all_sources(tmp_path: Path) -> None:
         env={**GIT_ENV, "HOME": str(tmp_path)},
     )
     tracked.write_text("v2\n")
-    # Staged new file
     staged = tmp_path / "staged.txt"
     staged.write_text("new\n")
     subprocess.run(
         ["git", "add", "staged.txt"], cwd=tmp_path, capture_output=True, check=True
     )
-    # Untracked file
     (tmp_path / "untracked.txt").write_text("surprise\n")
 
-    diff = get_uncommitted_diff(tmp_path, "HEAD")
+    diff = get_uncommitted_diff(tmp_path)
     assert "tracked.txt" in diff
     assert "staged.txt" in diff
     assert "untracked.txt" in diff
@@ -176,7 +311,7 @@ def test_get_uncommitted_diff_includes_untracked_file(tmp_path: Path) -> None:
     new_file = tmp_path / "notes.txt"
     new_file.write_text("hello\nworld\n", encoding="utf-8")
 
-    diff = get_uncommitted_diff(tmp_path, "HEAD")
+    diff = get_uncommitted_diff(tmp_path)
 
     assert "diff --git a/notes.txt b/notes.txt" in diff
     assert "new file mode" in diff
@@ -189,22 +324,16 @@ def test_get_uncommitted_diff_includes_empty_untracked_file(tmp_path: Path) -> N
     _init_repo_with_commit(tmp_path)
     (tmp_path / "empty.txt").write_text("", encoding="utf-8")
 
-    diff = get_uncommitted_diff(tmp_path, "HEAD")
+    diff = get_uncommitted_diff(tmp_path)
 
     assert "diff --git a/empty.txt b/empty.txt" in diff
     assert "new file mode" in diff
 
 
-# --- local-only commits flow through the diff against a recorded base ---
-
-
-def test_get_uncommitted_diff_includes_local_only_commit_against_base(
-    tmp_path: Path,
-) -> None:
-    """A local-only commit on top of the recorded base must show up in the diff
-    sent to the verifier — otherwise the verifier would never see it."""
+def test_get_uncommitted_diff_excludes_local_commits(tmp_path: Path) -> None:
+    """A local-only commit must NOT show up in the uncommitted diff."""
     _init_repo_with_commit(tmp_path)
-    base_sha = run_git_command(tmp_path, ["rev-parse", "HEAD"])
+    head_at_init = run_git_command(tmp_path, ["rev-parse", "HEAD"])
 
     (tmp_path / "local.txt").write_text("local change\n")
     env = {**GIT_ENV, "HOME": str(tmp_path)}
@@ -219,9 +348,50 @@ def test_get_uncommitted_diff_includes_local_only_commit_against_base(
         env=env,
     )
 
-    diff = get_uncommitted_diff(tmp_path, base_sha)
-    assert "local.txt" in diff
-    assert "+local change" in diff
+    diff = get_uncommitted_diff(tmp_path)
+    assert diff == "", (
+        "Local-only committed changes must not appear in the uncommitted diff"
+    )
+
+    # Verify the full diff against base_sha still includes them.
+    full_diff = get_full_diff(tmp_path, head_at_init)
+    assert "local.txt" in full_diff
+    assert "+local change" in full_diff
+
+
+# --- get_full_diff ---
+
+
+def test_get_full_diff_includes_local_commits(tmp_path: Path) -> None:
+    _init_repo_with_commit(tmp_path)
+    base_sha = run_git_command(tmp_path, ["rev-parse", "HEAD"])
+
+    (tmp_path / "full.txt").write_text("full change\n")
+    env = {**GIT_ENV, "HOME": str(tmp_path)}
+    subprocess.run(
+        ["git", "add", "full.txt"], cwd=tmp_path, capture_output=True, check=True
+    )
+    subprocess.run(
+        ["git", "commit", "-m", "full-only"],
+        cwd=tmp_path,
+        capture_output=True,
+        check=True,
+        env=env,
+    )
+
+    full_diff = get_full_diff(tmp_path, base_sha)
+    assert "full.txt" in full_diff
+    assert "+full change" in full_diff
+
+
+def test_get_full_diff_includes_uncommitted(tmp_path: Path) -> None:
+    _init_repo_with_commit(tmp_path)
+    base_sha = run_git_command(tmp_path, ["rev-parse", "HEAD"])
+
+    (tmp_path / "unstaged.txt").write_text("unstaged\n")
+
+    full_diff = get_full_diff(tmp_path, base_sha)
+    assert "unstaged.txt" in full_diff
 
 
 # --- trailing newline (diff must never be corrupt for git apply) ---
@@ -231,7 +401,6 @@ def test_get_uncommitted_diff_ends_with_newline_when_not_empty(tmp_path: Path) -
     """Diff must end with \\n so git apply on the receiving end never chokes."""
     _init_repo_with_commit(tmp_path)
 
-    # Tracked change
     f = tmp_path / "file.txt"
     f.write_text("content\n")
     subprocess.run(
@@ -246,13 +415,12 @@ def test_get_uncommitted_diff_ends_with_newline_when_not_empty(tmp_path: Path) -
     )
     f.write_text("modified\n")
 
-    diff = get_uncommitted_diff(tmp_path, "HEAD")
+    diff = get_uncommitted_diff(tmp_path)
     assert diff != ""
     assert diff.endswith("\n"), f"tracked diff should end with newline, got: {diff[-10:]!r}"
 
-    # Untracked only
     (tmp_path / "untracked.py").write_text("x = 1\n")
-    diff2 = get_uncommitted_diff(tmp_path, "HEAD")
+    diff2 = get_uncommitted_diff(tmp_path)
     assert diff2 != ""
     assert diff2.endswith("\n"), f"untracked diff should end with newline, got: {diff2[-10:]!r}"
 
@@ -282,7 +450,6 @@ def test_get_uncommitted_diff_preserves_trailing_blank_context_lines(
         check=True,
         env={**GIT_ENV, "HOME": str(tmp_path)},
     )
-    base_sha = run_git_command(tmp_path, ["rev-parse", "HEAD"])
 
     source.write_text(
         "\n".join(
@@ -296,7 +463,7 @@ def test_get_uncommitted_diff_preserves_trailing_blank_context_lines(
         encoding="utf-8",
     )
 
-    diff = get_uncommitted_diff(tmp_path, base_sha)
+    diff = get_uncommitted_diff(tmp_path)
 
     assert diff.endswith(" \n")
     subprocess.run(["git", "checkout", "--", "crypto.ts"], cwd=tmp_path, check=True)

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

@@ -34,14 +34,18 @@ def _run_git(repo: Path, *args: str) -> str:
 def _init_repo(tmp_path: Path) -> str:
     _run_git(tmp_path, "init")
     _run_git(tmp_path, "commit", "--allow-empty", "-m", "init")
-    return _run_git(tmp_path, "rev-parse", "HEAD")
+    branch = _run_git(tmp_path, "rev-parse", "--abbrev-ref", "HEAD")
+    _run_git(tmp_path, "remote", "add", "origin", "http://example.com/repo.git")
+    _run_git(tmp_path, "update-ref", f"refs/remotes/origin/{branch}", "HEAD")
+    _run_git(tmp_path, "branch", "-u", f"origin/{branch}")
+    return _run_git(tmp_path, "merge-base", "HEAD", f"origin/{branch}")
 
 
-def test_new_clears_run_state_and_records_current_head(
+def test_new_clears_run_state_and_records_merge_base(
     tmp_path: Path,
     monkeypatch,
 ) -> None:
-    head = _init_repo(tmp_path)
+    merge_base = _init_repo(tmp_path)
     monkeypatch.chdir(tmp_path)
 
     assertion_dir = tmp_path / ".assertion"
@@ -59,7 +63,7 @@ def test_new_clears_run_state_and_records_current_head(
     result = runner.invoke(main.app, ["new"])
 
     assert result.exit_code == 0, result.stderr
-    assert (assertion_dir / "base_sha").read_text() == head + "\n"
+    assert (assertion_dir / "base_sha").read_text() == merge_base + "\n"
     assert not (assertion_dir / "metadata.json").exists()
     assert not (assertion_dir / "prompts").exists()
     assert not (assertion_dir / "checkpoint").exists()
@@ -73,25 +77,25 @@ def test_new_succeeds_when_assertion_dir_missing(
     tmp_path: Path,
     monkeypatch,
 ) -> None:
-    head = _init_repo(tmp_path)
+    merge_base = _init_repo(tmp_path)
     monkeypatch.chdir(tmp_path)
 
     result = runner.invoke(main.app, ["new"])
 
     assert result.exit_code == 0, result.stderr
-    assert (tmp_path / ".assertion" / "base_sha").read_text() == head + "\n"
+    assert (tmp_path / ".assertion" / "base_sha").read_text() == merge_base + "\n"
 
 
-def test_new_updates_base_sha_after_head_changes(
+def test_new_keeps_merge_base_after_local_head_changes(
     tmp_path: Path,
     monkeypatch,
 ) -> None:
-    first_head = _init_repo(tmp_path)
+    merge_base = _init_repo(tmp_path)
     monkeypatch.chdir(tmp_path)
 
     first_result = runner.invoke(main.app, ["new"])
     assert first_result.exit_code == 0, first_result.stderr
-    assert (tmp_path / ".assertion" / "base_sha").read_text() == first_head + "\n"
+    assert (tmp_path / ".assertion" / "base_sha").read_text() == merge_base + "\n"
 
     _run_git(tmp_path, "commit", "--allow-empty", "-m", "second")
     second_head = _run_git(tmp_path, "rev-parse", "HEAD")
@@ -99,8 +103,8 @@ def test_new_updates_base_sha_after_head_changes(
     second_result = runner.invoke(main.app, ["new"])
 
     assert second_result.exit_code == 0, second_result.stderr
-    assert second_head != first_head
-    assert (tmp_path / ".assertion" / "base_sha").read_text() == second_head + "\n"
+    assert second_head != merge_base
+    assert (tmp_path / ".assertion" / "base_sha").read_text() == merge_base + "\n"
 
 
 def test_new_leaves_next_checkpoint_requiring_stack(
@@ -119,3 +123,17 @@ def test_new_leaves_next_checkpoint_requiring_stack(
 
     assert result.exit_code == 0, result.stderr
     assert not (assertion_dir / "metadata.json").exists()
+
+
+def test_new_requires_upstream_tracking_branch(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    _run_git(tmp_path, "init")
+    _run_git(tmp_path, "commit", "--allow-empty", "-m", "init")
+    monkeypatch.chdir(tmp_path)
+
+    result = runner.invoke(main.app, ["new"])
+
+    assert result.exit_code == 1
+    assert "no upstream tracking branch" in result.stderr

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

@@ -20,20 +20,30 @@ _GIT_COMMIT_ENV = {
 }
 
 
-def _init_repo(tmp_path: Path) -> None:
-    """Init a git repo with an initial commit so `git rev-parse HEAD` works.
-
-    `asrt session start` records HEAD as the diff base, so tests need a
-    resolvable HEAD.
-    """
-    subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
-    subprocess.run(
-        ["git", "commit", "--allow-empty", "-m", "init"],
-        cwd=tmp_path,
+def _run_git(repo: Path, *args: str) -> str:
+    result = subprocess.run(
+        ["git", *args],
+        cwd=repo,
         capture_output=True,
         check=True,
-        env={**_GIT_COMMIT_ENV, "HOME": str(tmp_path)},
+        env={**_GIT_COMMIT_ENV, "HOME": str(repo)},
+        text=True,
     )
+    return result.stdout.strip()
+
+
+def _init_repo(tmp_path: Path) -> None:
+    """Init a git repo with an upstream ref so merge-base resolution works.
+
+    `asrt session start` records the merge-base with the upstream branch as the
+    diff base, so tests need a resolvable upstream.
+    """
+    _run_git(tmp_path, "init")
+    _run_git(tmp_path, "commit", "--allow-empty", "-m", "init")
+    branch = _run_git(tmp_path, "rev-parse", "--abbrev-ref", "HEAD")
+    _run_git(tmp_path, "remote", "add", "origin", "http://example.com/repo.git")
+    _run_git(tmp_path, "update-ref", f"refs/remotes/origin/{branch}", "HEAD")
+    _run_git(tmp_path, "branch", "-u", f"origin/{branch}")
 
 
 def test_session_start_does_not_write_skill_or_agent_files(
@@ -187,30 +197,46 @@ def test_session_start_requires_git_repo(tmp_path: Path, monkeypatch) -> None:
     assert "git repository" in result.stderr
 
 
-def test_session_start_records_head_sha_as_base(tmp_path: Path, monkeypatch) -> None:
-    """`asrt session start` pins the diff base for this repo to current HEAD.
+def test_session_start_requires_upstream_tracking_branch(
+    tmp_path: Path, monkeypatch
+) -> None:
+    _run_git(tmp_path, "init")
+    _run_git(tmp_path, "commit", "--allow-empty", "-m", "init")
+    monkeypatch.chdir(tmp_path)
 
-    Every subsequent checkpoint/verify diffs against this SHA, so backend
-    `git checkout` always targets a commit the user/agent has committed at
-    least once locally (and presumably pushed).
+    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()
+
+
+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
+    check out the upstream-visible base before applying the full diff.
     """
     _init_repo(tmp_path)
     monkeypatch.chdir(tmp_path)
+    upstream = _run_git(
+        tmp_path, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"
+    )
+
+    _run_git(tmp_path, "commit", "--allow-empty", "-m", "local-only")
 
     result = runner.invoke(main.app, ["session", "start"])
     assert result.exit_code == 0, result.stderr
 
-    head_sha = subprocess.run(
-        ["git", "rev-parse", "HEAD"],
-        cwd=tmp_path,
-        capture_output=True,
-        text=True,
-        check=True,
-    ).stdout.strip()
+    merge_base = _run_git(tmp_path, "merge-base", "HEAD", upstream)
+    head_sha = _run_git(tmp_path, "rev-parse", "HEAD")
 
     base_sha_path = tmp_path / ".assertion" / "base_sha"
     assert base_sha_path.exists()
-    assert base_sha_path.read_text().strip() == head_sha
+    assert base_sha_path.read_text().strip() == merge_base
+    assert merge_base != head_sha
 
 
 def test_session_start_errors_when_repo_has_no_commits(

assertion_cli-0.5.8/git.py

@@ -1,138 +0,0 @@
-import subprocess
-from pathlib import Path
-from typing import NoReturn, Sequence
-
-import typer
-
-
-def exit_with_error(message: str) -> NoReturn:
-    typer.echo(message, err=True)
-    raise typer.Exit(code=1)
-
-
-def run_git_command(
-    repo_root: Path, args: Sequence[str], *, preserve_stdout: bool = False
-) -> str:
-    completed = subprocess.run(
-        ["git", *args],
-        cwd=repo_root,
-        capture_output=True,
-        text=True,
-        check=False,
-    )
-    if completed.returncode != 0:
-        message = completed.stderr.strip() or completed.stdout.strip() or "git failed"
-        raise RuntimeError(message)
-    return completed.stdout if preserve_stdout else completed.stdout.strip()
-
-
-def find_git_root(start_path: Path) -> Path:
-    completed = subprocess.run(
-        ["git", "rev-parse", "--show-toplevel"],
-        cwd=start_path,
-        capture_output=True,
-        text=True,
-        check=False,
-    )
-    if completed.returncode != 0:
-        exit_with_error("Current directory is not inside a git repository.")
-    return Path(completed.stdout.strip())
-
-
-def get_head_sha(repo_root: Path) -> str:
-    try:
-        return run_git_command(repo_root, ["rev-parse", "HEAD"])
-    except RuntimeError as exc:
-        exit_with_error(f"Failed to get HEAD SHA: {exc}")
-
-
-def get_head_branch(repo_root: Path) -> str | None:
-    """Return the current branch name, or None if HEAD is detached."""
-    try:
-        name = run_git_command(repo_root, ["rev-parse", "--abbrev-ref", "HEAD"])
-    except RuntimeError:
-        return None
-    return name if name and name != "HEAD" else None
-
-
-def _build_untracked_diff(repo_root: Path, rel_path: str) -> str:
-    completed = subprocess.run(
-        [
-            "git",
-            "diff",
-            "--no-index",
-            "--src-prefix=a/",
-            "--dst-prefix=b/",
-            "--",
-            "/dev/null",
-            rel_path,
-        ],
-        cwd=repo_root,
-        capture_output=True,
-        text=True,
-        check=False,
-    )
-    if completed.returncode not in (0, 1):
-        message = completed.stderr.strip() or completed.stdout.strip() or "git failed"
-        raise RuntimeError(message)
-    return completed.stdout
-
-
-# Paths the assertion-cli owns end-to-end. Excluded from the diff bundle so
-# reviewers don't flag our own bootstrap files as "unrelated changes" — they're
-# generated by `asrt install` and have nothing to do with the user's feature
-# work. CLAUDE.md / AGENTS.md are intentionally NOT in this list: `asrt install`
-# writes a small pointer block into them once at onboarding (meant to be
-# committed before work starts, so it never shows in a work-session diff), but
-# the rest of those files is the user's own and must flow through to reviewers.
-_ASSERTION_EXCLUDED_PATHSPECS = [
-    ":(exclude).assertion",
-    ":(exclude).claude/skills/assertion-cli",
-    ":(exclude).agents/skills/assertion-cli",
-]
-
-
-def get_uncommitted_diff(repo_root: Path, base_sha: str) -> str:
-    """Build a unified diff from `base_sha` to the current working tree.
-
-    `git diff <base_sha>` compares the working tree directly to the base
-    commit, which subsumes both committed-since-base and unstaged tweaks in
-    one shot — so a single call covers all tracked changes regardless of
-    whether the agent committed locally. Untracked files are still added
-    separately as new-file diffs.
-    """
-    try:
-        tracked = run_git_command(
-            repo_root,
-            ["diff", base_sha, "--", *_ASSERTION_EXCLUDED_PATHSPECS],
-            preserve_stdout=True,
-        )
-
-        untracked_output = run_git_command(
-            repo_root,
-            [
-                "ls-files",
-                "--others",
-                "--exclude-standard",
-                "--",
-                *_ASSERTION_EXCLUDED_PATHSPECS,
-            ],
-        )
-        untracked_diffs = [
-            _build_untracked_diff(repo_root, rel_path)
-            for rel_path in untracked_output.splitlines()
-            if rel_path
-        ]
-
-        parts = [
-            _ensure_trailing_newline(p)
-            for p in [tracked, *untracked_diffs]
-            if p
-        ]
-        return "".join(parts)
-    except RuntimeError as exc:
-        exit_with_error(f"Failed to collect git diff: {exc}")
-
-
-def _ensure_trailing_newline(value: str) -> str:
-    return value if value.endswith("\n") else value + "\n"