assertion-cli 0.5.15__tar.gz → 0.5.17__tar.gz

{assertion_cli-0.5.15 → assertion_cli-0.5.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertion-cli
-Version: 0.5.15
+Version: 0.5.17
 Summary: CLI for the Assertion API
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
@@ -47,6 +47,7 @@ asrt checkpoint --stack <stack-id> "Implemented X\nUpdated Y"
 asrt checkpoint --continue "Implemented Y"
 asrt decision --yes <checkpoint-id>   # optional, only after a failed checkpoint
 asrt verify                            # submit final verification (non-blocking)
+asrt verify --force                    # submit even when review diff is unchanged
 asrt verify-status                     # one-shot poll; loop with your own sleep until terminal
 ```
 

{assertion_cli-0.5.15 → assertion_cli-0.5.17}/README.md

@@ -34,6 +34,7 @@ asrt checkpoint --stack <stack-id> "Implemented X\nUpdated Y"
 asrt checkpoint --continue "Implemented Y"
 asrt decision --yes <checkpoint-id>   # optional, only after a failed checkpoint
 asrt verify                            # submit final verification (non-blocking)
+asrt verify --force                    # submit even when review diff is unchanged
 asrt verify-status                     # one-shot poll; loop with your own sleep until terminal
 ```
 

{assertion_cli-0.5.15 → assertion_cli-0.5.17}/assertion_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertion-cli
-Version: 0.5.15
+Version: 0.5.17
 Summary: CLI for the Assertion API
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
@@ -47,6 +47,7 @@ asrt checkpoint --stack <stack-id> "Implemented X\nUpdated Y"
 asrt checkpoint --continue "Implemented Y"
 asrt decision --yes <checkpoint-id>   # optional, only after a failed checkpoint
 asrt verify                            # submit final verification (non-blocking)
+asrt verify --force                    # submit even when review diff is unchanged
 asrt verify-status                     # one-shot poll; loop with your own sleep until terminal
 ```
 

{assertion_cli-0.5.15 → assertion_cli-0.5.17}/assertion_cli.egg-info/SOURCES.txt

@@ -28,4 +28,6 @@ tests/test_link.py
 tests/test_main.py
 tests/test_prompt.py
 tests/test_session.py
-tests/test_session_start.py
+tests/test_session_start.py
+tests/test_verify.py
+tests/test_verify_integration.py

{assertion_cli-0.5.15 → assertion_cli-0.5.17}/git.py

@@ -180,6 +180,60 @@ def get_upstream_ref(repo_root: Path) -> str | None:
     return None
 
 
+def get_closest_merged_remote_ref(repo_root: Path) -> str | None:
+    """Return the newest remote-tracking ref that is an ancestor of ``HEAD``.
+
+    Used when ``get_upstream_ref`` falls through to a raw merge-base SHA so
+    session-start output can still name the branch the user branched from.
+    """
+    try:
+        merged = run_git_command(
+            repo_root,
+            [
+                "branch",
+                "-r",
+                "--merged",
+                "HEAD",
+                "--format=%(refname:short)",
+            ],
+        )
+    except RuntimeError:
+        return None
+
+    ancestors = [r for r in merged.splitlines() if r]
+    if not ancestors:
+        return None
+
+    newest_ref: str | None = None
+    newest_ts = -1
+    for ref in ancestors:
+        try:
+            ts = int(run_git_command(repo_root, ["log", "-1", "--format=%ct", ref]))
+        except (RuntimeError, ValueError):
+            continue
+        if ts > newest_ts:
+            newest_ts = ts
+            newest_ref = ref
+
+    return newest_ref
+
+
+def format_verify_scope_label(repo_root: Path, upstream: str) -> str:
+    """Human-readable label for the upstream used to compute the verify base."""
+    if upstream.startswith("origin/") or upstream == "origin/HEAD":
+        return f"merge-base with {upstream}"
+
+    # Step 3 of ``get_upstream_ref`` returns a raw SHA; name the parent branch.
+    closest = get_closest_merged_remote_ref(repo_root)
+    if closest is not None:
+        return f"merge-base with {closest}"
+
+    if len(upstream) >= 12 and all(c in "0123456789abcdef" for c in upstream.lower()):
+        return f"merge-base at {upstream[:12]}"
+
+    return f"merge-base with {upstream}"
+
+
 def get_merge_base(repo_root: Path, upstream: str) -> str:
     """Return the merge-base of ``HEAD`` and *upstream*."""
     try:

{assertion_cli-0.5.15 → assertion_cli-0.5.17}/main.py

@@ -17,6 +17,7 @@ from git import (
     exit_with_error,
     find_git_root,
     find_git_root_or_none,
+    format_verify_scope_label,
     get_full_diff,
     get_head_branch,
     get_head_sha,
@@ -25,17 +26,23 @@ from git import (
     is_ancestor,
     run_git_command,
 )
-from link import load_link, save_link
+from link import LINK_FILE_NAME, load_link, save_link
 from models import CheckpointResponse, SessionStatus, render_stack_list
 from session import (
     ASSERTION_DIR_NAME,
     METADATA_FILE_NAME,
     PROMPTS_FILE_NAME,
     VERIFY_BASE_SHA_FILE_NAME,
+    _read_optional_text_file,
     append_checkpoint_entry,
+    compute_review_diff_hash,
     continue_session,
     load_existing_session,
     read_init_verify_base_sha,
+    read_review_diff_hash,
+    read_verify_last_status,
+    save_review_diff_hash,
+    save_verify_last_status,
     start_new_session,
     update_metadata_anchor,
 )
@@ -360,8 +367,10 @@ session_app = typer.Typer(help="Manage Assertion work sessions.")
 app.add_typer(session_app, name="session")
 
 
-def _resolve_verify_base(repo_root: Path, from_ref: str | None) -> str:
-    """Resolve the verification base SHA.
+def _resolve_verify_scope(
+    repo_root: Path, from_ref: str | None
+) -> tuple[str, str]:
+    """Resolve the verification base SHA and a human-readable scope label.
 
     If *from_ref* is provided, resolve it and validate that it is an ancestor
     of HEAD. Otherwise compute the merge-base with the upstream tracking branch,
@@ -374,7 +383,7 @@ def _resolve_verify_base(repo_root: Path, from_ref: str | None) -> str:
             exit_with_error(f"Invalid --from ref '{from_ref}': {exc}")
         if not is_ancestor(repo_root, sha, "HEAD"):
             exit_with_error(f"--from ref {sha[:12]} is not an ancestor of HEAD.")
-        return sha
+        return sha, f"explicit ref {from_ref}"
 
     try:
         run_git_command(repo_root, ["fetch", "--no-tags", "origin"])
@@ -387,13 +396,14 @@ def _resolve_verify_base(repo_root: Path, from_ref: str | None) -> str:
             "Warning: no upstream tracking branch found, falling back to HEAD.",
             err=True,
         )
-        return get_head_sha(repo_root)
+        return get_head_sha(repo_root), "HEAD (no upstream found)"
     try:
-        return run_git_command(repo_root, ["merge-base", "HEAD", upstream])
+        sha = 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}"
         )
+    return sha, format_verify_scope_label(repo_root, upstream)
 
 
 def _resolve_clone_anchor(repo_root: Path, verify_base: str) -> str:
@@ -452,7 +462,7 @@ def session_start(
     repo_root = find_git_root(Path.cwd())
     _ensure_gitignore_limits_assertion_state(repo_root)
 
-    verify_base = _resolve_verify_base(repo_root, from_ref)
+    verify_base, scope_label = _resolve_verify_scope(repo_root, from_ref)
     assertion_dir = repo_root / ASSERTION_DIR_NAME
     assertion_dir.mkdir(exist_ok=True)
     removed = _reset_assertion_dir(assertion_dir)
@@ -460,7 +470,8 @@ def session_start(
     verify_base_path = assertion_dir / VERIFY_BASE_SHA_FILE_NAME
     verify_base_path.write_text(verify_base + "\n", encoding="utf-8")
     typer.echo(
-        f"Recorded verification base {verify_base[:12]} → {verify_base_path.relative_to(repo_root)}"
+        f"Recorded verification base {verify_base[:12]} ({scope_label}) "
+        f"→ {verify_base_path.relative_to(repo_root)}"
     )
     if removed:
         typer.echo(
@@ -603,6 +614,14 @@ def _save_verify_session_id(assertion_dir: Path, session_id: str) -> None:
     )
 
 
+def _read_optional_verify_session_id(assertion_dir: Path) -> str | None:
+    path = assertion_dir / VERIFY_SESSION_FILE_NAME
+    if not path.exists():
+        return None
+    content = path.read_text(encoding="utf-8").strip()
+    return content or None
+
+
 def _load_verify_session_id(assertion_dir: Path) -> str:
     path = assertion_dir / VERIFY_SESSION_FILE_NAME
     if not path.exists():
@@ -648,24 +667,11 @@ def _write_screenshots(
     return screenshot_dir
 
 
-@app.command("verify")
-def verify(
-    json_output: bool = typer.Option(
-        False,
-        "--json",
-        help="Print the verification submission as a single JSON line.",
-    ),
-) -> None:
-    """Submit final verification. Returns immediately without polling.
-
-    Verification can take several minutes on the backend; blocking the agent's
-    shell long enough to trip a Bash-tool timeout was a real failure mode. So
-    this command only submits — poll `asrt verify-status` (one-shot) on whatever
-    interval your harness prefers to learn the outcome.
-    """
-    ctx, metadata = load_existing_session(Path.cwd())
-    stack_id = metadata.stack_id
-    assert stack_id is not None
+def _build_verify_bundle(
+    ctx,
+    metadata,
+) -> tuple[bytes, str, str]:
+    """Return (bundle_bytes, review_diff_text, review_diff_hash)."""
     verify_base = read_init_verify_base_sha(ctx.assertion_dir)
     clone_anchor = _resolve_clone_anchor(ctx.repo_root, verify_base)
     head_branch = get_head_branch(ctx.repo_root)
@@ -678,7 +684,6 @@ def verify(
         clone_sha=clone_anchor,
         head_branch=head_branch,
     )
-
     bundle_bytes = build_bundle(
         metadata=metadata,
         diff_text=diff_text,
@@ -686,6 +691,117 @@ def verify(
         prompts_text=ctx.prompts_path.read_text(encoding="utf-8"),
         checkpoint_text=ctx.checkpoint_path.read_text(encoding="utf-8"),
     )
+    return bundle_bytes, review_diff_text, compute_review_diff_hash(review_diff_text)
+
+
+def _compute_review_diff_fingerprint(ctx) -> tuple[str, str]:
+    """Return (review_diff_text, review_diff_hash) without bundle side effects."""
+    verify_base = read_init_verify_base_sha(ctx.assertion_dir)
+    review_diff_text = get_full_diff(ctx.repo_root, verify_base)
+    return review_diff_text, compute_review_diff_hash(review_diff_text)
+
+
+def _try_reuse_verify(
+    assertion_dir: Path,
+    *,
+    review_diff_hash: str,
+    json_output: bool,
+) -> bool:
+    """Reuse a prior verification when the review diff is unchanged.
+
+    Returns True when an existing session is reused (no new submission). Covers
+    both terminal ``succeeded`` runs and in-flight ``created``/``running`` runs
+    so a repeated ``asrt verify`` does not submit twice for the same diff.
+    """
+    stored_hash = read_review_diff_hash(assertion_dir)
+    if stored_hash != review_diff_hash:
+        return False
+
+    last_status = read_verify_last_status(assertion_dir)
+    reusable_statuses = {
+        SessionStatus.SUCCEEDED.value,
+        SessionStatus.CREATED.value,
+        SessionStatus.RUNNING.value,
+    }
+    if last_status not in reusable_statuses:
+        return False
+
+    session_id = _read_optional_verify_session_id(assertion_dir)
+    if session_id is None:
+        return False
+
+    session_url = _read_optional_text_file(assertion_dir / LINK_FILE_NAME)
+    if session_url is None:
+        return False
+
+    if json_output:
+        typer.echo(
+            json.dumps(
+                {
+                    "session_id": session_id,
+                    "url": session_url,
+                    "status": last_status,
+                    "reused": True,
+                }
+            )
+        )
+    elif last_status == SessionStatus.SUCCEEDED.value:
+        typer.echo(
+            "Review diff unchanged since the last successful verification — "
+            f"reusing session {session_id}."
+        )
+        typer.echo(f"URL: {session_url}")
+        typer.echo(
+            "Embed `asrt get-link` in the PR body if the branch name may differ."
+        )
+    else:
+        typer.echo(
+            "Review diff unchanged since the last verification submission — "
+            f"session {session_id} is still {last_status}."
+        )
+        typer.echo(f"URL: {session_url}")
+        typer.echo("Poll `asrt verify-status` instead of submitting again.")
+    return True
+
+
+@app.command("verify")
+def verify(
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Print the verification submission as a single JSON line.",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        help="Submit a new verification even when the review diff is unchanged.",
+    ),
+) -> None:
+    """Submit final verification. Returns immediately without polling.
+
+    Verification can take several minutes on the backend; blocking the agent's
+    shell long enough to trip a Bash-tool timeout was a real failure mode. So
+    this command only submits — poll `asrt verify-status` (one-shot) on whatever
+    interval your harness prefers to learn the outcome.
+
+    When the review-scope diff is unchanged since the last verification
+    submission, the CLI reuses that session instead of submitting again —
+    including while a prior run is still ``running``. Pass ``--force`` to always
+    submit.
+    """
+    ctx, metadata = load_existing_session(Path.cwd())
+    stack_id = metadata.stack_id
+    assert stack_id is not None
+    _, review_diff_hash = _compute_review_diff_fingerprint(ctx)
+
+    if not force and _try_reuse_verify(
+        ctx.assertion_dir,
+        review_diff_hash=review_diff_hash,
+        json_output=json_output,
+    ):
+        return
+
+    bundle_bytes, _, review_diff_hash = _build_verify_bundle(ctx, metadata)
 
     client = AssertionClient()
     resp = client.verify(
@@ -698,6 +814,8 @@ def verify(
     session_url = resp.url
     save_link(ctx.assertion_dir, session_url)
     _save_verify_session_id(ctx.assertion_dir, session_id)
+    save_review_diff_hash(ctx.assertion_dir, review_diff_hash)
+    save_verify_last_status(ctx.assertion_dir, SessionStatus.RUNNING.value)
 
     if json_output:
         typer.echo(
@@ -706,6 +824,7 @@ def verify(
                     "session_id": session_id,
                     "url": session_url,
                     "status": "submitted",
+                    "reused": False,
                 }
             )
         )
@@ -748,6 +867,8 @@ def verify_status(
             session_url = None
 
     terminal = payload.status in {SessionStatus.SUCCEEDED, SessionStatus.FAILED}
+    if terminal:
+        save_verify_last_status(ctx.assertion_dir, str(payload.status))
     screenshot_count = len(payload.screenshots)
     screenshots_saved = False
     if terminal and payload.screenshots:

{assertion_cli-0.5.15 → assertion_cli-0.5.17}/pyproject.toml

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

{assertion_cli-0.5.15 → assertion_cli-0.5.17}/session.py

@@ -1,3 +1,4 @@
+import hashlib
 from pathlib import Path
 
 from pydantic import ValidationError
@@ -14,6 +15,40 @@ PROMPTS_FILE_NAME = "prompts"
 CHECKPOINT_FILE_NAME = "checkpoint"
 METADATA_FILE_NAME = "metadata.json"
 VERIFY_BASE_SHA_FILE_NAME = "verify_base_sha"
+REVIEW_DIFF_HASH_FILE_NAME = "review_diff_hash"
+VERIFY_LAST_STATUS_FILE_NAME = "verify_last_status"
+
+
+def compute_review_diff_hash(review_diff_text: str) -> str:
+    """Stable hash of the review-scope diff (verify base → working tree)."""
+    return hashlib.sha256(review_diff_text.encode("utf-8")).hexdigest()
+
+
+def _read_optional_text_file(path: Path) -> str | None:
+    if not path.exists():
+        return None
+    content = path.read_text(encoding="utf-8").strip()
+    return content or None
+
+
+def read_review_diff_hash(assertion_dir: Path) -> str | None:
+    return _read_optional_text_file(assertion_dir / REVIEW_DIFF_HASH_FILE_NAME)
+
+
+def save_review_diff_hash(assertion_dir: Path, digest: str) -> None:
+    (assertion_dir / REVIEW_DIFF_HASH_FILE_NAME).write_text(
+        digest + "\n", encoding="utf-8"
+    )
+
+
+def read_verify_last_status(assertion_dir: Path) -> str | None:
+    return _read_optional_text_file(assertion_dir / VERIFY_LAST_STATUS_FILE_NAME)
+
+
+def save_verify_last_status(assertion_dir: Path, status: str) -> None:
+    (assertion_dir / VERIFY_LAST_STATUS_FILE_NAME).write_text(
+        status + "\n", encoding="utf-8"
+    )
 
 
 def read_init_verify_base_sha(assertion_dir: Path) -> str:

{assertion_cli-0.5.15 → assertion_cli-0.5.17}/templates/SKILL.md

@@ -144,6 +144,8 @@ Do not call `verify` mid-task. It is not a substitute for checkpoints; it is the
 
 `verify` is **non-blocking**: it submits the verification and returns immediately with the session id and URL. The verification itself can take several minutes — you poll `asrt verify-status` on your own cadence to learn the outcome. This avoids tripping any shell-timeout in the harness.
 
+When the review diff is unchanged since the last verification submission, `asrt verify` reuses that session instead of submitting again — including while a prior run is still `running` (poll `asrt verify-status` instead). After a **succeeded** run, reuse skips a redundant submission. Use `asrt verify --force` to submit anyway. After a new git branch, run `asrt session start` only when the verification base should change — check the scope line it prints, or pass `--from <ref>` if the default is wrong.
+
 ```
 asrt verify                                # submit; prints session id + URL, exits 0
 # … then poll until terminal:
@@ -227,6 +229,7 @@ asrt checkpoint --stack <id> "..."            # first checkpoint of a session
 asrt checkpoint "..."                         # subsequent checkpoints — auto-continues
 asrt decision --yes|--no <ckpt-id>            # optional, on failed checkpoints only
 asrt verify                                   # submit verification (non-blocking)
+asrt verify --force                           # submit even when review diff unchanged
 asrt verify-status                            # one-shot poll; loop with your own sleep
 asrt get-link                                 # hidden PR marker — embed in the PR body (required)
 ```
@@ -244,7 +247,7 @@ When running under a non-interactive harness (CI, benchmark runner, scripts):
    - Apply changes targeted at the cited failure.
    - Re-run `asrt checkpoint "<what you changed>" --json` (auto-continues the existing session).
    - Bound retries: stop after 3 attempts on the same failure mode, or when the same `reasoning` is returned twice in a row.
-4. `asrt verify --json` submits and exits with a one-line JSON `{"session_id", "url", "status": "submitted"}`. Poll `asrt verify-status --json` on your own cadence — terminal output is `{"session_id", "url", "status", "message", "summary", "screenshot_count"}` with exit `1` on `failed`, `0` otherwise. Choose the poll interval to fit your harness timeouts; do not block a single shell call on verify.
+4. `asrt verify --json` submits and exits with a one-line JSON `{"session_id", "url", "status": "submitted"|"succeeded", "reused": bool}`. When `"reused": true`, the review diff matched the last succeeded verification and no new backend run was started. Poll `asrt verify-status --json` on your own cadence — terminal output is `{"session_id", "url", "status", "message", "summary", "screenshot_count"}` with exit `1` on `failed`, `0` otherwise. Choose the poll interval to fit your harness timeouts; do not block a single shell call on verify.
 5. If the harness opens a PR, embed the hidden session marker (`asrt get-link`) in the PR body — same requirement as interactive mode. The bot matches the PR to the session by branch name first, then by this marker.
 
 Do not mix `--json` output with human-rendered output in the same run. Pick one mode and stick with it.

{assertion_cli-0.5.15 → assertion_cli-0.5.17}/tests/test_session_start.py

@@ -266,6 +266,7 @@ def test_session_start_records_merge_base_as_verify_base(tmp_path: Path, monkeyp
     assert base_sha_path.exists()
     assert base_sha_path.read_text().strip() == merge_base
     assert merge_base != head_sha
+    assert f"merge-base with {upstream}" in result.stdout
 
 
 def test_session_start_errors_when_repo_has_no_commits(

assertion_cli-0.5.17/tests/test_verify.py

@@ -0,0 +1,334 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from unittest.mock import patch
+
+from typer.testing import CliRunner
+
+import main
+from models import MetadataPayload, SessionStatus, StatusResponse, VerifyResponse
+from session import (
+    SessionContext,
+    compute_review_diff_hash,
+    read_review_diff_hash,
+    read_verify_last_status,
+    save_review_diff_hash,
+    save_verify_last_status,
+)
+
+
+runner = CliRunner()
+
+
+def _write_session(assertion_dir: Path) -> None:
+    assertion_dir.mkdir(parents=True, exist_ok=True)
+    (assertion_dir / "verify_base_sha").write_text("a" * 40 + "\n")
+    (assertion_dir / "prompts").write_text(
+        json.dumps({"ts": "2026-01-01T00:00:00Z", "text": "build it"}) + "\n"
+    )
+    (assertion_dir / "checkpoint").write_text("done\n")
+    (assertion_dir / "metadata.json").write_text(
+        MetadataPayload(session_id="sess-1", stack_id="stack-1").model_dump_json()
+        + "\n"
+    )
+
+
+def _session_ctx(assertion_dir: Path, repo_root: Path) -> SessionContext:
+    return SessionContext(
+        repo_root=repo_root,
+        assertion_dir=assertion_dir,
+        prompts_path=assertion_dir / "prompts",
+        checkpoint_path=assertion_dir / "checkpoint",
+        metadata_path=assertion_dir / "metadata.json",
+    )
+
+
+@patch("main.AssertionClient")
+@patch("main._build_verify_bundle")
+@patch("main._compute_review_diff_fingerprint")
+@patch("main.load_existing_session")
+def test_verify_reuses_unchanged_successful_diff(
+    mock_load_session,
+    mock_fingerprint,
+    mock_build_bundle,
+    MockClient,
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    assertion_dir = tmp_path / ".assertion"
+    _write_session(assertion_dir)
+    review_diff = "diff unchanged\n"
+    digest = compute_review_diff_hash(review_diff)
+    save_review_diff_hash(assertion_dir, digest)
+    save_verify_last_status(assertion_dir, SessionStatus.SUCCEEDED.value)
+    (assertion_dir / "verify_session_id").write_text("sess-1\n")
+    (assertion_dir / "link").write_text(
+        "https://app.tryassertion.com/sessions/sess-1\n"
+    )
+
+    metadata = MetadataPayload(session_id="sess-1", stack_id="stack-1")
+    mock_load_session.return_value = (_session_ctx(assertion_dir, tmp_path), metadata)
+    mock_fingerprint.return_value = (review_diff, digest)
+    mock_build_bundle.return_value = (b"bundle", review_diff, digest)
+
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(main.app, ["verify"])
+
+    assert result.exit_code == 0
+    assert "reusing session sess-1" in result.stdout
+    MockClient.return_value.verify.assert_not_called()
+    mock_build_bundle.assert_not_called()
+
+
+@patch("main.AssertionClient")
+@patch("main._build_verify_bundle")
+@patch("main._compute_review_diff_fingerprint")
+@patch("main.load_existing_session")
+def test_verify_reuses_in_flight_running_diff(
+    mock_load_session,
+    mock_fingerprint,
+    mock_build_bundle,
+    MockClient,
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    assertion_dir = tmp_path / ".assertion"
+    _write_session(assertion_dir)
+    review_diff = "diff unchanged\n"
+    digest = compute_review_diff_hash(review_diff)
+    save_review_diff_hash(assertion_dir, digest)
+    save_verify_last_status(assertion_dir, SessionStatus.RUNNING.value)
+    (assertion_dir / "verify_session_id").write_text("sess-1\n")
+    (assertion_dir / "link").write_text(
+        "https://app.tryassertion.com/sessions/sess-1\n"
+    )
+
+    metadata = MetadataPayload(session_id="sess-1", stack_id="stack-1")
+    mock_load_session.return_value = (_session_ctx(assertion_dir, tmp_path), metadata)
+    mock_fingerprint.return_value = (review_diff, digest)
+
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(main.app, ["verify"])
+
+    assert result.exit_code == 0
+    assert "session sess-1 is still running" in result.stdout
+    assert "Poll `asrt verify-status`" in result.stdout
+    MockClient.return_value.verify.assert_not_called()
+    mock_build_bundle.assert_not_called()
+
+
+@patch("main.AssertionClient")
+@patch("main._build_verify_bundle")
+@patch("main._compute_review_diff_fingerprint")
+@patch("main.load_existing_session")
+def test_verify_submits_when_diff_changed(
+    mock_load_session,
+    mock_fingerprint,
+    mock_build_bundle,
+    MockClient,
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    assertion_dir = tmp_path / ".assertion"
+    _write_session(assertion_dir)
+    old_digest = compute_review_diff_hash("old diff\n")
+    save_review_diff_hash(assertion_dir, old_digest)
+    save_verify_last_status(assertion_dir, SessionStatus.SUCCEEDED.value)
+
+    metadata = MetadataPayload(session_id="sess-1", stack_id="stack-1")
+    mock_load_session.return_value = (_session_ctx(assertion_dir, tmp_path), metadata)
+    new_diff = "new diff\n"
+    new_digest = compute_review_diff_hash(new_diff)
+    mock_fingerprint.return_value = (new_diff, new_digest)
+    mock_build_bundle.return_value = (b"bundle", new_diff, new_digest)
+    MockClient.return_value.verify.return_value = VerifyResponse(
+        session_id="sess-1",
+        url="https://app.tryassertion.com/sessions/sess-1",
+    )
+
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(main.app, ["verify"])
+
+    assert result.exit_code == 0
+    assert "Verification submitted" in result.stdout
+    MockClient.return_value.verify.assert_called_once()
+    assert read_review_diff_hash(assertion_dir) == new_digest
+    assert read_verify_last_status(assertion_dir) == SessionStatus.RUNNING.value
+
+
+@patch("main.AssertionClient")
+@patch("main._build_verify_bundle")
+@patch("main._compute_review_diff_fingerprint")
+@patch("main.load_existing_session")
+def test_verify_does_not_reuse_after_failure(
+    mock_load_session,
+    mock_fingerprint,
+    mock_build_bundle,
+    MockClient,
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    assertion_dir = tmp_path / ".assertion"
+    _write_session(assertion_dir)
+    review_diff = "same diff\n"
+    digest = compute_review_diff_hash(review_diff)
+    save_review_diff_hash(assertion_dir, digest)
+    save_verify_last_status(assertion_dir, SessionStatus.FAILED.value)
+
+    metadata = MetadataPayload(session_id="sess-1", stack_id="stack-1")
+    mock_load_session.return_value = (_session_ctx(assertion_dir, tmp_path), metadata)
+    mock_fingerprint.return_value = (review_diff, digest)
+    mock_build_bundle.return_value = (b"bundle", review_diff, digest)
+    MockClient.return_value.verify.return_value = VerifyResponse(
+        session_id="sess-1",
+        url="https://app.tryassertion.com/sessions/sess-1",
+    )
+
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(main.app, ["verify"])
+
+    assert result.exit_code == 0
+    MockClient.return_value.verify.assert_called_once()
+
+
+@patch("main.AssertionClient")
+@patch("main._build_verify_bundle")
+@patch("main._compute_review_diff_fingerprint")
+@patch("main.load_existing_session")
+def test_verify_force_bypasses_reuse(
+    mock_load_session,
+    mock_fingerprint,
+    mock_build_bundle,
+    MockClient,
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    assertion_dir = tmp_path / ".assertion"
+    _write_session(assertion_dir)
+    review_diff = "same diff\n"
+    digest = compute_review_diff_hash(review_diff)
+    save_review_diff_hash(assertion_dir, digest)
+    save_verify_last_status(assertion_dir, SessionStatus.SUCCEEDED.value)
+    (assertion_dir / "verify_session_id").write_text("sess-1\n")
+    (assertion_dir / "link").write_text(
+        "https://app.tryassertion.com/sessions/sess-1\n"
+    )
+
+    metadata = MetadataPayload(session_id="sess-1", stack_id="stack-1")
+    mock_load_session.return_value = (_session_ctx(assertion_dir, tmp_path), metadata)
+    mock_fingerprint.return_value = (review_diff, digest)
+    mock_build_bundle.return_value = (b"bundle", review_diff, digest)
+    MockClient.return_value.verify.return_value = VerifyResponse(
+        session_id="sess-1",
+        url="https://app.tryassertion.com/sessions/sess-1",
+    )
+
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(main.app, ["verify", "--force"])
+
+    assert result.exit_code == 0
+    MockClient.return_value.verify.assert_called_once()
+
+
+@patch("main.AssertionClient")
+@patch("main._load_verify_session_id")
+@patch("main.load_existing_session")
+def test_verify_status_persists_terminal_status(
+    mock_load_session,
+    mock_load_session_id,
+    MockClient,
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    assertion_dir = tmp_path / ".assertion"
+    _write_session(assertion_dir)
+
+    metadata = MetadataPayload(session_id="sess-1", stack_id="stack-1")
+    mock_load_session.return_value = (_session_ctx(assertion_dir, tmp_path), metadata)
+    mock_load_session_id.return_value = "sess-1"
+    MockClient.return_value.status.return_value = StatusResponse(
+        status=SessionStatus.SUCCEEDED,
+        message="ok",
+        url="https://app.tryassertion.com/sessions/sess-1",
+    )
+
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(main.app, ["verify-status"])
+
+    assert result.exit_code == 0
+    assert read_verify_last_status(assertion_dir) == SessionStatus.SUCCEEDED.value
+
+
+@patch("main.AssertionClient")
+@patch("main._build_verify_bundle")
+@patch("main._compute_review_diff_fingerprint")
+@patch("main.load_existing_session")
+def test_verify_reuse_json_output(
+    mock_load_session,
+    mock_fingerprint,
+    mock_build_bundle,
+    MockClient,
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    assertion_dir = tmp_path / ".assertion"
+    _write_session(assertion_dir)
+    review_diff = "diff unchanged\n"
+    digest = compute_review_diff_hash(review_diff)
+    save_review_diff_hash(assertion_dir, digest)
+    save_verify_last_status(assertion_dir, SessionStatus.SUCCEEDED.value)
+    (assertion_dir / "verify_session_id").write_text("sess-1\n")
+    (assertion_dir / "link").write_text(
+        "https://app.tryassertion.com/sessions/sess-1\n"
+    )
+
+    metadata = MetadataPayload(session_id="sess-1", stack_id="stack-1")
+    mock_load_session.return_value = (_session_ctx(assertion_dir, tmp_path), metadata)
+    mock_fingerprint.return_value = (review_diff, digest)
+    mock_build_bundle.return_value = (b"bundle", review_diff, digest)
+
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(main.app, ["verify", "--json"])
+
+    assert result.exit_code == 0
+    payload = json.loads(result.stdout)
+    assert payload["reused"] is True
+    assert payload["status"] == "succeeded"
+    MockClient.return_value.verify.assert_not_called()
+    mock_build_bundle.assert_not_called()
+
+
+@patch("main.AssertionClient")
+@patch("main._build_verify_bundle")
+@patch("main._compute_review_diff_fingerprint")
+@patch("main.load_existing_session")
+def test_verify_missing_session_id_falls_through_to_submit(
+    mock_load_session,
+    mock_fingerprint,
+    mock_build_bundle,
+    MockClient,
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    assertion_dir = tmp_path / ".assertion"
+    _write_session(assertion_dir)
+    review_diff = "same diff\n"
+    digest = compute_review_diff_hash(review_diff)
+    save_review_diff_hash(assertion_dir, digest)
+    save_verify_last_status(assertion_dir, SessionStatus.SUCCEEDED.value)
+
+    metadata = MetadataPayload(session_id="sess-1", stack_id="stack-1")
+    mock_load_session.return_value = (_session_ctx(assertion_dir, tmp_path), metadata)
+    mock_fingerprint.return_value = (review_diff, digest)
+    mock_build_bundle.return_value = (b"bundle", review_diff, digest)
+    MockClient.return_value.verify.return_value = VerifyResponse(
+        session_id="sess-1",
+        url="https://app.tryassertion.com/sessions/sess-1",
+    )
+
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(main.app, ["verify"])
+
+    assert result.exit_code == 0
+    MockClient.return_value.verify.assert_called_once()

assertion_cli-0.5.17/tests/test_verify_integration.py

@@ -0,0 +1,277 @@
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+from typer.testing import CliRunner
+
+import main
+from git import format_verify_scope_label, get_closest_merged_remote_ref
+from models import MetadataPayload, SessionStatus, VerifyResponse
+from session import (
+    REVIEW_DIFF_HASH_FILE_NAME,
+    VERIFY_LAST_STATUS_FILE_NAME,
+    compute_review_diff_hash,
+    read_review_diff_hash,
+    read_verify_last_status,
+)
+
+
+runner = CliRunner()
+
+_GIT_ENV = {
+    "GIT_AUTHOR_NAME": "T",
+    "GIT_AUTHOR_EMAIL": "t@t",
+    "GIT_COMMITTER_NAME": "T",
+    "GIT_COMMITTER_EMAIL": "t@t",
+    "PATH": "/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin",
+}
+
+
+def _run_git(repo: Path, *args: str) -> str:
+    result = subprocess.run(
+        ["git", *args],
+        cwd=repo,
+        capture_output=True,
+        check=True,
+        env={**_GIT_ENV, "HOME": str(repo)},
+        text=True,
+    )
+    return result.stdout.strip()
+
+
+def _setup_branching_repo(repo: Path) -> str:
+    _run_git(repo, "init")
+    _run_git(repo, "remote", "add", "origin", "http://example.com/repo.git")
+    _run_git(repo, "commit", "--allow-empty", "-m", "main")
+    main_sha = _run_git(repo, "rev-parse", "HEAD")
+    _run_git(repo, "update-ref", "refs/remotes/origin/main", main_sha)
+
+    _run_git(repo, "checkout", "-b", "feature-base")
+    _run_git(repo, "commit", "--allow-empty", "-m", "base work")
+    feature_base_sha = _run_git(repo, "rev-parse", "HEAD")
+    _run_git(repo, "update-ref", "refs/remotes/origin/feature-base", feature_base_sha)
+
+    _run_git(repo, "checkout", "-b", "feature-follow-up")
+    _run_git(repo, "commit", "--allow-empty", "-m", "follow-up")
+    return feature_base_sha
+
+
+def _write_assertion_session(repo: Path) -> None:
+    assertion = repo / ".assertion"
+    assertion.mkdir()
+    base = _run_git(repo, "merge-base", "HEAD", "origin/feature-base")
+    (assertion / "verify_base_sha").write_text(base + "\n")
+    (assertion / "prompts").write_text(
+        json.dumps({"ts": "2026-01-01T00:00:00Z", "text": "do work"}) + "\n"
+    )
+    (assertion / "checkpoint").write_text("ready\n")
+    (assertion / "metadata.json").write_text(
+        MetadataPayload(session_id="sess-int", stack_id="stack-1").model_dump_json()
+        + "\n"
+    )
+
+
+def test_format_verify_scope_label_names_parent_branch(tmp_path: Path) -> None:
+    feature_base_sha = _setup_branching_repo(tmp_path)
+    upstream = _run_git(
+        tmp_path, "merge-base", "HEAD", "origin/main", "origin/feature-base"
+    )
+    assert upstream == feature_base_sha
+    assert get_closest_merged_remote_ref(tmp_path) == "origin/feature-base"
+    assert format_verify_scope_label(tmp_path, upstream) == (
+        "merge-base with origin/feature-base"
+    )
+
+
+def test_format_verify_scope_label_keeps_named_upstream(tmp_path: Path) -> None:
+    assert (
+        format_verify_scope_label(tmp_path, "origin/main")
+        == "merge-base with origin/main"
+    )
+
+
+@patch("main.AssertionClient")
+def test_build_verify_bundle_uses_recorded_base(MockClient, tmp_path: Path) -> None:
+    feature_base_sha = _setup_branching_repo(tmp_path)
+    _write_assertion_session(tmp_path)
+
+    from session import SessionContext, _load_metadata
+
+    ctx = SessionContext(
+        repo_root=tmp_path,
+        assertion_dir=tmp_path / ".assertion",
+        prompts_path=tmp_path / ".assertion" / "prompts",
+        checkpoint_path=tmp_path / ".assertion" / "checkpoint",
+        metadata_path=tmp_path / ".assertion" / "metadata.json",
+    )
+    metadata = _load_metadata(ctx.metadata_path)
+    assert metadata is not None
+
+    bundle_bytes, review_diff, digest = main._build_verify_bundle(ctx, metadata)
+    assert digest == compute_review_diff_hash(review_diff)
+    assert feature_base_sha in review_diff or review_diff == ""
+    assert bundle_bytes.startswith(b"PK")
+
+
+@patch("main.AssertionClient")
+def test_verify_end_to_end_git_flow_submits_bundle(MockClient, tmp_path: Path, monkeypatch) -> None:
+    _setup_branching_repo(tmp_path)
+    _write_assertion_session(tmp_path)
+    MockClient.return_value.verify.return_value = VerifyResponse(
+        session_id="sess-int",
+        url="https://app.tryassertion.com/sessions/sess-int",
+    )
+    monkeypatch.chdir(tmp_path)
+
+    result = runner.invoke(main.app, ["verify"])
+    assert result.exit_code == 0, result.stdout + result.stderr
+    assert "Verification submitted" in result.stdout
+    MockClient.return_value.verify.assert_called_once()
+    args, kwargs = MockClient.return_value.verify.call_args
+    assert kwargs["bundle_bytes"].startswith(b"PK")
+    assert read_review_diff_hash(tmp_path / ".assertion") is not None
+    assert read_verify_last_status(tmp_path / ".assertion") == SessionStatus.RUNNING.value
+
+
+@patch("main.AssertionClient")
+def test_verify_double_submit_avoids_second_api_call(
+    MockClient, tmp_path: Path, monkeypatch
+) -> None:
+    """Repeated verify with unchanged diff must not submit twice while in-flight."""
+    _setup_branching_repo(tmp_path)
+    _write_assertion_session(tmp_path)
+    MockClient.return_value.verify.return_value = VerifyResponse(
+        session_id="sess-int",
+        url="https://app.tryassertion.com/sessions/sess-int",
+    )
+    monkeypatch.chdir(tmp_path)
+
+    first = runner.invoke(main.app, ["verify"])
+    assert first.exit_code == 0, first.stdout + first.stderr
+    assert "Verification submitted" in first.stdout
+
+    second = runner.invoke(main.app, ["verify"])
+    assert second.exit_code == 0, second.stdout + second.stderr
+    assert "Poll `asrt verify-status`" in second.stdout
+    assert MockClient.return_value.verify.call_count == 1
+
+
+@patch("main.AssertionClient")
+def test_verify_review_diff_hash_stable_across_invocations(
+    MockClient, tmp_path: Path, monkeypatch
+) -> None:
+    _setup_branching_repo(tmp_path)
+    _write_assertion_session(tmp_path)
+    MockClient.return_value.verify.return_value = VerifyResponse(
+        session_id="sess-int",
+        url="https://app.tryassertion.com/sessions/sess-int",
+    )
+    monkeypatch.chdir(tmp_path)
+
+    runner.invoke(main.app, ["verify"])
+    hash_after_first = read_review_diff_hash(tmp_path / ".assertion")
+
+    runner.invoke(main.app, ["verify"])
+    hash_after_second = read_review_diff_hash(tmp_path / ".assertion")
+
+    assert hash_after_first is not None
+    assert hash_after_first == hash_after_second
+
+
+@patch("main.AssertionClient")
+def test_verify_reuse_after_status_succeeded(MockClient, tmp_path: Path, monkeypatch) -> None:
+    _setup_branching_repo(tmp_path)
+    _write_assertion_session(tmp_path)
+    MockClient.return_value.verify.return_value = VerifyResponse(
+        session_id="sess-int",
+        url="https://app.tryassertion.com/sessions/sess-int",
+    )
+    monkeypatch.chdir(tmp_path)
+
+    first = runner.invoke(main.app, ["verify"])
+    assert first.exit_code == 0
+    (tmp_path / ".assertion" / VERIFY_LAST_STATUS_FILE_NAME).write_text("succeeded\n")
+
+    second = runner.invoke(main.app, ["verify"])
+    assert second.exit_code == 0
+    assert "reusing session" in second.stdout
+    assert MockClient.return_value.verify.call_count == 1
+
+
+@patch("main.AssertionClient")
+def test_verify_status_running_does_not_erase_succeeded(
+    MockClient, tmp_path: Path, monkeypatch
+) -> None:
+    _setup_branching_repo(tmp_path)
+    _write_assertion_session(tmp_path)
+    assertion = tmp_path / ".assertion"
+    (assertion / "verify_session_id").write_text("sess-int\n")
+    (assertion / "link").write_text("https://app.tryassertion.com/sessions/sess-int\n")
+    (assertion / VERIFY_LAST_STATUS_FILE_NAME).write_text("succeeded\n")
+    (assertion / REVIEW_DIFF_HASH_FILE_NAME).write_text("deadbeef\n")
+
+    from models import StatusResponse
+
+    MockClient.return_value.status.return_value = StatusResponse(
+        status=SessionStatus.RUNNING,
+        message="still going",
+        url="https://app.tryassertion.com/sessions/sess-int",
+    )
+    monkeypatch.chdir(tmp_path)
+
+    result = runner.invoke(main.app, ["verify-status"])
+    assert result.exit_code == 0
+    assert read_verify_last_status(assertion) == "succeeded"
+
+
+def test_session_start_clears_verify_reuse_state(tmp_path: Path, monkeypatch) -> None:
+    _setup_branching_repo(tmp_path)
+    assertion = tmp_path / ".assertion"
+    assertion.mkdir()
+    (assertion / REVIEW_DIFF_HASH_FILE_NAME).write_text("hash\n")
+    (assertion / VERIFY_LAST_STATUS_FILE_NAME).write_text("succeeded\n")
+    (assertion / "old_state").write_text("x\n")
+    monkeypatch.chdir(tmp_path)
+
+    result = runner.invoke(main.app, ["session", "start"])
+    assert result.exit_code == 0
+    assert not (assertion / REVIEW_DIFF_HASH_FILE_NAME).exists()
+    assert not (assertion / VERIFY_LAST_STATUS_FILE_NAME).exists()
+    assert not (assertion / "old_state").exists()
+
+
+@patch("main.AssertionClient")
+@patch("session._require_repo_ready")
+@patch("session._require_prompts_file")
+def test_checkpoint_still_builds_bundle_after_verify_refactor(
+    mock_require_prompts,
+    mock_require_repo_ready,
+    MockClient,
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    """Checkpoint path must remain independent of verify bundle helper."""
+    _setup_branching_repo(tmp_path)
+    _write_assertion_session(tmp_path)
+    mock_require_repo_ready.return_value = tmp_path
+    from models import CheckpointResponse, ReviewDetail
+
+    MockClient.return_value.checkpoint.return_value = CheckpointResponse(
+        checkpoint_id="cp-1",
+        outcome="succeeded",
+        reasoning="ok",
+        reviews=[ReviewDetail(model="m", approved=True, feedback="ok")],
+        created_at="2026-01-01T00:00:00+00:00",
+        updated_at="2026-01-01T00:00:00+00:00",
+    )
+    monkeypatch.chdir(tmp_path)
+
+    result = runner.invoke(main.app, ["checkpoint", "still works"])
+    assert result.exit_code == 0, result.stdout + result.stderr
+    MockClient.return_value.checkpoint.assert_called_once()
+    args, kwargs = MockClient.return_value.checkpoint.call_args
+    assert kwargs["bundle_bytes"].startswith(b"PK")