assertion-cli 0.5.14__tar.gz → 0.5.16__tar.gz

{assertion_cli-0.5.14 → assertion_cli-0.5.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertion-cli
-Version: 0.5.14
+Version: 0.5.16
 Summary: CLI for the Assertion API
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
@@ -42,12 +42,12 @@ After installation:
 asrt install                           # one-time onboarding: write skill files, AGENTS.md/CLAUDE.md pointer, .gitignore
 asrt login                             # authenticate this repo (generate a token at Settings → Authentication)
 asrt session start                     # per work session: record the diff base (current HEAD)
-asrt new                               # reset local run state for a fresh session
 asrt stacks
 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.14 → assertion_cli-0.5.16}/README.md

@@ -29,12 +29,12 @@ After installation:
 asrt install                           # one-time onboarding: write skill files, AGENTS.md/CLAUDE.md pointer, .gitignore
 asrt login                             # authenticate this repo (generate a token at Settings → Authentication)
 asrt session start                     # per work session: record the diff base (current HEAD)
-asrt new                               # reset local run state for a fresh session
 asrt stacks
 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.14 → assertion_cli-0.5.16}/assertion_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertion-cli
-Version: 0.5.14
+Version: 0.5.16
 Summary: CLI for the Assertion API
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
@@ -42,12 +42,12 @@ After installation:
 asrt install                           # one-time onboarding: write skill files, AGENTS.md/CLAUDE.md pointer, .gitignore
 asrt login                             # authenticate this repo (generate a token at Settings → Authentication)
 asrt session start                     # per work session: record the diff base (current HEAD)
-asrt new                               # reset local run state for a fresh session
 asrt stacks
 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.14 → assertion_cli-0.5.16}/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.14 → assertion_cli-0.5.16}/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.14 → assertion_cli-0.5.16}/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(
@@ -469,7 +480,8 @@ def session_start(
 
     typer.echo("")
     typer.echo("The coding agent will now follow the Assertion workflow:")
-    typer.echo('  - asrt prompt "<msg>" on every user turn')
+    typer.echo('  - in non-Plan mode, asrt prompt "<msg>" for each user turn')
+    typer.echo('  - when starting from a finalized plan, log it with asrt prompt')
     typer.echo("  - asrt checkpoint at trajectory-feedback moments")
     typer.echo("  - asrt verify at completion, then PR")
 
@@ -602,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():
@@ -647,6 +667,82 @@ def _write_screenshots(
     return screenshot_dir
 
 
+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)
+    diff_text = get_full_diff(ctx.repo_root, clone_anchor)
+    review_diff_text = get_full_diff(ctx.repo_root, verify_base)
+    metadata = update_metadata_anchor(
+        ctx.metadata_path,
+        metadata,
+        verify_base,
+        clone_sha=clone_anchor,
+        head_branch=head_branch,
+    )
+    bundle_bytes = build_bundle(
+        metadata=metadata,
+        diff_text=diff_text,
+        review_diff_text=review_diff_text,
+        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 _try_reuse_successful_verify(
+    assertion_dir: Path,
+    *,
+    review_diff_hash: str,
+    json_output: bool,
+) -> bool:
+    """Reuse the prior verification when the review diff is unchanged.
+
+    Returns True when a prior succeeded verification is reused (no new submission).
+    """
+    stored_hash = read_review_diff_hash(assertion_dir)
+    if stored_hash != review_diff_hash:
+        return False
+
+    last_status = read_verify_last_status(assertion_dir)
+    if last_status != SessionStatus.SUCCEEDED.value:
+        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": SessionStatus.SUCCEEDED.value,
+                    "reused": True,
+                }
+            )
+        )
+    else:
+        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."
+        )
+    return True
+
+
 @app.command("verify")
 def verify(
     json_output: bool = typer.Option(
@@ -654,6 +750,11 @@ def verify(
         "--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.
 
@@ -661,30 +762,24 @@ def verify(
     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 *succeeded*
+    verification, the CLI reuses that result instead of submitting again.
+    Pass ``--force`` to always submit.
     """
     ctx, metadata = load_existing_session(Path.cwd())
     stack_id = metadata.stack_id
     assert stack_id is not None
-    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)
-    diff_text = get_full_diff(ctx.repo_root, clone_anchor)
-    review_diff_text = get_full_diff(ctx.repo_root, verify_base)
-    metadata = update_metadata_anchor(
-        ctx.metadata_path,
-        metadata,
-        verify_base,
-        clone_sha=clone_anchor,
-        head_branch=head_branch,
+    bundle_bytes, review_diff_text, review_diff_hash = _build_verify_bundle(
+        ctx, metadata
     )
 
-    bundle_bytes = build_bundle(
-        metadata=metadata,
-        diff_text=diff_text,
-        review_diff_text=review_diff_text,
-        prompts_text=ctx.prompts_path.read_text(encoding="utf-8"),
-        checkpoint_text=ctx.checkpoint_path.read_text(encoding="utf-8"),
-    )
+    if not force and _try_reuse_successful_verify(
+        ctx.assertion_dir,
+        review_diff_hash=review_diff_hash,
+        json_output=json_output,
+    ):
+        return
 
     client = AssertionClient()
     resp = client.verify(
@@ -697,6 +792,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(
@@ -705,6 +802,7 @@ def verify(
                     "session_id": session_id,
                     "url": session_url,
                     "status": "submitted",
+                    "reused": False,
                 }
             )
         )
@@ -747,6 +845,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.14 → assertion_cli-0.5.16}/pyproject.toml

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

{assertion_cli-0.5.14 → assertion_cli-0.5.16}/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.14 → assertion_cli-0.5.16}/templates/AGENTS.md

@@ -5,9 +5,9 @@ This repo uses the Assertion CLI (`asrt`) to track user intent and verify your w
 - **Claude Code** — [`.claude/skills/assertion-cli/SKILL.md`](.claude/skills/assertion-cli/SKILL.md)
 - **Codex / Cursor** — [`.agents/skills/assertion-cli/SKILL.md`](.agents/skills/assertion-cli/SKILL.md)
 
-Both files are byte-identical — read whichever your agent loads (or either one directly). In brief, follow these three rules for every conversation:
+Both files are byte-identical — read whichever your agent loads (or either one directly). In brief, follow these three rules in non-Plan mode:
 
-1. **Every user message:** call `asrt prompt "<exact text of the message>"` before doing any other work for that turn. Apply to every user turn, not just the first.
+1. **Prompts:** do not call `asrt prompt` during Plan Mode. When implementation begins from a finalized plan, record that plan with `asrt prompt "<finalized plan text>"`; after that, call `asrt prompt "<exact text of the message>"` for each non-Plan user turn before doing other work.
 2. **Checkpoint at trajectory-feedback moments** with `asrt checkpoint` — a handful across a feature build, not one per file.
 3. **Verify, then PR with the session marker.** At completion, run `asrt verify` and poll `asrt verify-status` until clean. Then open the PR and embed the hidden session marker — `$(asrt get-link)`, an HTML comment — in its body.
 

{assertion_cli-0.5.14 → assertion_cli-0.5.16}/templates/SKILL.md

@@ -1,14 +1,20 @@
 ---
 name: assertion-cli
-description: Use this skill in non-Plan mode whenever working in a repo that uses the Assertion CLI (`asrt`). It enforces the three-rule workflow — log every user message with `asrt prompt`, checkpoint at trajectory-feedback moments (not on every change), and verify only at completion before opening a PR whose body embeds the hidden Assertion session marker. Applies to any coding agent reading this skill.
+description: Use this skill in non-Plan mode whenever working in a repo that uses the Assertion CLI (`asrt`). It enforces the three-rule workflow — log non-Plan user messages and finalized implementation plans with `asrt prompt`, checkpoint at trajectory-feedback moments (not on every change), and verify only at completion before opening a PR whose body embeds the hidden Assertion session marker. Applies to any coding agent reading this skill.
 ---
 
 # Assertion CLI
 
-You are operating in a repo that uses the Assertion CLI (`asrt`) to track user intent and verify your work. Follow the three rules below without exception. They apply regardless of which coding agent harness you are running under (Claude Code, Codex, Cursor, etc.).
+You are operating in a repo that uses the Assertion CLI (`asrt`) to track user intent and verify your work. Follow the three rules below without exception in non-Plan mode. They apply regardless of which coding agent harness you are running under (Claude Code, Codex, Cursor, etc.).
 
 This skill is operational, not advisory. Treat each rule as a hard requirement unless the underlying service is unavailable.
 
+## Plan Mode boundary
+
+When the harness is in Plan Mode, do not run `asrt prompt`, `asrt checkpoint`, `asrt verify`, or PR commands. Plan Mode is for producing a plan, not for mutating Assertion session state.
+
+When the harness leaves Plan Mode and begins implementation from a finalized plan, first record that plan with `asrt prompt "<finalized plan text>"`. Then proceed with the non-Plan workflow below, including logging any later user messages as they arrive.
+
 ## Preflight (one-time per session)
 
 Before any `asrt` call:
@@ -21,7 +27,8 @@ Before any `asrt` call:
 **First command sequence for a new work session:**
 
 1. Run `asrt session start` to start fresh. This clears previous in-flight Assertion state (metadata, prompts log, link, verification status, screenshots) and records the current verification base.
-2. Immediately log the active user prompt with `asrt prompt`.
+2. If starting from a finalized Plan Mode plan, immediately log that plan with `asrt prompt`.
+3. Otherwise, immediately log the active non-Plan user prompt with `asrt prompt`.
 
 Treat `.assertion/metadata.json`, `.assertion/prompts`, and `.assertion/verify_base_sha` as internal state owned by the CLI. Do not create, edit, or delete those files manually — use `asrt prompt` to append to the prompts log and `asrt session start` to reset for a fresh session.
 
@@ -29,17 +36,23 @@ Treat `.assertion/metadata.json`, `.assertion/prompts`, and `.assertion/verify_b
 
 ---
 
-## Rule 1 — Log every user message, immediately
+## Rule 1 — Log non-Plan user messages and finalized plans, immediately
 
-**The first thing you do when a new user message arrives — before reading any file, planning, or editing anything — is run:**
+**In non-Plan mode, the first thing you do when a new user message arrives — before reading any file, planning, or editing anything — is run:**
 
 ```
 asrt prompt "<exact text of the user's message>"
 ```
 
-Exception: on the first user turn of a new work session, perform the Preflight fresh-session check first by running `asrt session start`, then immediately run `asrt prompt` for the active user message so the new/current session records the user's intent.
+Plan Mode exception: if the harness is currently in Plan Mode, do not call `asrt prompt` for each planning turn. When implementation begins from the finalized plan, record the plan itself as the first prompt:
+
+```
+asrt prompt "<finalized plan text>"
+```
+
+Fresh-session exception: on the first non-Plan user turn of a new work session, perform the Preflight fresh-session check first by running `asrt session start`, then immediately run `asrt prompt` for the active user message or finalized plan so the new/current session records the user's intent.
 
-This applies to **every user turn**, not just the first. It applies even when the message is a one-word direction change ("nope"), a clarification ("use Postgres, not SQLite"), or a follow-up after verify ("also add dark mode").
+Outside Plan Mode, this applies to **every user turn**, not just the first. It applies even when the message is a one-word direction change ("nope"), a clarification ("use Postgres, not SQLite"), or a follow-up after verify ("also add dark mode").
 
 **Why:** The prompts log is the verifier's source of truth for what the user asked for and how their direction evolved. It is shipped with every checkpoint and the final verify, and persisted in the verification database. A missed turn causes the verifier to flag legitimate work as off-spec because it cannot see the intent change that authorized the work.
 
@@ -131,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 **succeeded** verification, `asrt verify` reuses that session instead of submitting again. 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:
@@ -207,13 +222,14 @@ A missing marker is a **blocking error**, not a warning: do not consider the PR
 ## Quick reference
 
 ```
-asrt prompt "<message>"                       # every user turn, before anything else
+asrt prompt "<message>"                       # non-Plan user turn or finalized plan, before work
 asrt session start [--from <ref>]             # start fresh; optional explicit verification base
 asrt stacks                                   # list every stack — read once before first checkpoint
 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)
 ```
@@ -231,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.14 → assertion_cli-0.5.16}/tests/test_install.py

@@ -47,6 +47,9 @@ def test_install_writes_agent_doc_pointers(tmp_path: Path, monkeypatch) -> None:
         assert main._AGENT_BLOCK_END in text
         assert "assertion-cli" in text
         assert "asrt prompt" in text
+        assert "do not call `asrt prompt` during Plan Mode" in text
+        assert "finalized plan" in text
+        assert "**Every user message:**" not in text
 
 
 def test_install_preserves_existing_agent_doc_content(
@@ -132,6 +135,12 @@ def test_install_records_skill_cleanup_guidance(tmp_path: Path, monkeypatch) ->
     skill = (tmp_path / ".agents" / "skills" / "assertion-cli" / "SKILL.md").read_text()
     assert "First command sequence for a new work session" in skill
     assert "`asrt session start`" in skill
+    assert "## Plan Mode boundary" in skill
+    assert (
+        "do not run `asrt prompt`, `asrt checkpoint`, `asrt verify`, or PR commands"
+        in skill
+    )
+    assert 'asrt prompt "<finalized plan text>"' in skill
     assert "`asrt new`" not in skill
 
 

{assertion_cli-0.5.14 → assertion_cli-0.5.16}/tests/test_session_start.py

@@ -66,6 +66,26 @@ def test_session_start_does_not_write_skill_or_agent_files(
     assert not (tmp_path / "AGENTS.md").exists()
 
 
+def test_session_start_prints_non_plan_prompt_workflow(
+    tmp_path: Path, monkeypatch
+) -> None:
+    _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    result = runner.invoke(main.app, ["session", "start"])
+    assert result.exit_code == 0, result.stderr
+
+    assert (
+        'in non-Plan mode, asrt prompt "<msg>" for each user turn'
+        in result.stdout
+    )
+    assert (
+        "when starting from a finalized plan, log it with asrt prompt"
+        in result.stdout
+    )
+    assert 'asrt prompt "<msg>" on every user turn' not in result.stdout
+
+
 def test_session_start_resets_assertion_state_but_keeps_seed_trackable(
     tmp_path: Path, monkeypatch
 ) -> None:
@@ -246,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.16/tests/test_verify.py

@@ -0,0 +1,332 @@
+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 (
+    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"
+    )
+
+
+@patch("main.AssertionClient")
+@patch("main._build_verify_bundle")
+@patch("main.load_existing_session")
+def test_verify_reuses_unchanged_successful_diff(
+    mock_load_session,
+    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"
+    )
+
+    from session import SessionContext
+
+    ctx = SessionContext(
+        repo_root=tmp_path,
+        assertion_dir=assertion_dir,
+        prompts_path=assertion_dir / "prompts",
+        checkpoint_path=assertion_dir / "checkpoint",
+        metadata_path=assertion_dir / "metadata.json",
+    )
+    metadata = MetadataPayload(session_id="sess-1", stack_id="stack-1")
+    mock_load_session.return_value = (ctx, metadata)
+    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()
+
+
+@patch("main.AssertionClient")
+@patch("main._build_verify_bundle")
+@patch("main.load_existing_session")
+def test_verify_submits_when_diff_changed(
+    mock_load_session,
+    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)
+
+    from session import SessionContext
+
+    ctx = SessionContext(
+        repo_root=tmp_path,
+        assertion_dir=assertion_dir,
+        prompts_path=assertion_dir / "prompts",
+        checkpoint_path=assertion_dir / "checkpoint",
+        metadata_path=assertion_dir / "metadata.json",
+    )
+    metadata = MetadataPayload(session_id="sess-1", stack_id="stack-1")
+    mock_load_session.return_value = (ctx, metadata)
+    new_diff = "new diff\n"
+    mock_build_bundle.return_value = (
+        b"bundle",
+        new_diff,
+        compute_review_diff_hash(new_diff),
+    )
+    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) == compute_review_diff_hash(new_diff)
+    assert read_verify_last_status(assertion_dir) == SessionStatus.RUNNING.value
+
+
+@patch("main.AssertionClient")
+@patch("main._build_verify_bundle")
+@patch("main.load_existing_session")
+def test_verify_does_not_reuse_after_failure(
+    mock_load_session,
+    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)
+
+    from session import SessionContext
+
+    ctx = SessionContext(
+        repo_root=tmp_path,
+        assertion_dir=assertion_dir,
+        prompts_path=assertion_dir / "prompts",
+        checkpoint_path=assertion_dir / "checkpoint",
+        metadata_path=assertion_dir / "metadata.json",
+    )
+    metadata = MetadataPayload(session_id="sess-1", stack_id="stack-1")
+    mock_load_session.return_value = (ctx, metadata)
+    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.load_existing_session")
+def test_verify_force_bypasses_reuse(
+    mock_load_session,
+    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"
+    )
+
+    from session import SessionContext
+
+    ctx = SessionContext(
+        repo_root=tmp_path,
+        assertion_dir=assertion_dir,
+        prompts_path=assertion_dir / "prompts",
+        checkpoint_path=assertion_dir / "checkpoint",
+        metadata_path=assertion_dir / "metadata.json",
+    )
+    metadata = MetadataPayload(session_id="sess-1", stack_id="stack-1")
+    mock_load_session.return_value = (ctx, metadata)
+    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)
+
+    from session import SessionContext
+
+    ctx = SessionContext(
+        repo_root=tmp_path,
+        assertion_dir=assertion_dir,
+        prompts_path=assertion_dir / "prompts",
+        checkpoint_path=assertion_dir / "checkpoint",
+        metadata_path=assertion_dir / "metadata.json",
+    )
+    metadata = MetadataPayload(session_id="sess-1", stack_id="stack-1")
+    mock_load_session.return_value = (ctx, 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.load_existing_session")
+def test_verify_reuse_json_output(
+    mock_load_session,
+    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"
+    )
+
+    from session import SessionContext
+
+    ctx = SessionContext(
+        repo_root=tmp_path,
+        assertion_dir=assertion_dir,
+        prompts_path=assertion_dir / "prompts",
+        checkpoint_path=assertion_dir / "checkpoint",
+        metadata_path=assertion_dir / "metadata.json",
+    )
+    metadata = MetadataPayload(session_id="sess-1", stack_id="stack-1")
+    mock_load_session.return_value = (ctx, metadata)
+    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()
+
+
+@patch("main.AssertionClient")
+@patch("main._build_verify_bundle")
+@patch("main.load_existing_session")
+def test_verify_missing_session_id_falls_through_to_submit(
+    mock_load_session,
+    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)
+
+    from session import SessionContext
+
+    ctx = SessionContext(
+        repo_root=tmp_path,
+        assertion_dir=assertion_dir,
+        prompts_path=assertion_dir / "prompts",
+        checkpoint_path=assertion_dir / "checkpoint",
+        metadata_path=assertion_dir / "metadata.json",
+    )
+    metadata = MetadataPayload(session_id="sess-1", stack_id="stack-1")
+    mock_load_session.return_value = (ctx, metadata)
+    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.16/tests/test_verify_integration.py

@@ -0,0 +1,232 @@
+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_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")