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

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

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

{assertion_cli-0.5.16 → 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.16
+Version: 0.5.17
 Summary: CLI for the Assertion API
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown

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

@@ -694,22 +694,36 @@ def _build_verify_bundle(
     return bundle_bytes, review_diff_text, compute_review_diff_hash(review_diff_text)
 
 
-def _try_reuse_successful_verify(
+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 the prior verification when the review diff is unchanged.
+    """Reuse a prior verification when the review diff is unchanged.
 
-    Returns True when a prior succeeded verification is reused (no new submission).
+    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)
-    if last_status != SessionStatus.SUCCEEDED.value:
+    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)
@@ -726,12 +740,12 @@ def _try_reuse_successful_verify(
                 {
                     "session_id": session_id,
                     "url": session_url,
-                    "status": SessionStatus.SUCCEEDED.value,
+                    "status": last_status,
                     "reused": True,
                 }
             )
         )
-    else:
+    elif last_status == SessionStatus.SUCCEEDED.value:
         typer.echo(
             "Review diff unchanged since the last successful verification — "
             f"reusing session {session_id}."
@@ -740,6 +754,13 @@ def _try_reuse_successful_verify(
         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
 
 
@@ -763,24 +784,25 @@ def verify(
     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.
+    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
-    bundle_bytes, review_diff_text, review_diff_hash = _build_verify_bundle(
-        ctx, metadata
-    )
+    _, review_diff_hash = _compute_review_diff_fingerprint(ctx)
 
-    if not force and _try_reuse_successful_verify(
+    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(
         stack_id=stack_id,

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

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

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

@@ -144,7 +144,7 @@ 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.
+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

{assertion_cli-0.5.16 → assertion_cli-0.5.17}/tests/test_verify.py

@@ -9,6 +9,7 @@ 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,
@@ -33,11 +34,23 @@ def _write_session(assertion_dir: Path) -> None:
     )
 
 
+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,
@@ -54,17 +67,9 @@ def test_verify_reuses_unchanged_successful_diff(
         "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_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)
@@ -73,13 +78,53 @@ def test_verify_reuses_unchanged_successful_diff(
     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,
@@ -91,23 +136,12 @@ def test_verify_submits_when_diff_changed(
     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)
+    mock_load_session.return_value = (_session_ctx(assertion_dir, tmp_path), metadata)
     new_diff = "new diff\n"
-    mock_build_bundle.return_value = (
-        b"bundle",
-        new_diff,
-        compute_review_diff_hash(new_diff),
-    )
+    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",
@@ -119,15 +153,17 @@ def test_verify_submits_when_diff_changed(
     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_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,
@@ -140,17 +176,9 @@ def test_verify_does_not_reuse_after_failure(
     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_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",
@@ -166,9 +194,11 @@ def test_verify_does_not_reuse_after_failure(
 
 @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,
@@ -185,17 +215,9 @@ def test_verify_force_bypasses_reuse(
         "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_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",
@@ -222,17 +244,8 @@ def test_verify_status_persists_terminal_status(
     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.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,
@@ -249,9 +262,11 @@ def test_verify_status_persists_terminal_status(
 
 @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,
@@ -268,17 +283,9 @@ def test_verify_reuse_json_output(
         "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_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)
@@ -289,13 +296,16 @@ def test_verify_reuse_json_output(
     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,
@@ -308,17 +318,9 @@ def test_verify_missing_session_id_falls_through_to_submit(
     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_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",

{assertion_cli-0.5.16 → assertion_cli-0.5.17}/tests/test_verify_integration.py

@@ -137,6 +137,51 @@ def test_verify_end_to_end_git_flow_submits_bundle(MockClient, tmp_path: Path, m
     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)