assertion-cli 0.1.0__tar.gz → 0.2.0__tar.gz

{assertion_cli-0.1.0 → assertion_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertion-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: CLI for the Assertion API
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
@@ -26,14 +26,15 @@ Run locally from the workspace:
 uv run --package assertion-cli asrt --help
 ```
 
-Install from Git as a `uv` tool:
+Install as a `uv` tool from PyPI:
 
 ```bash
-uv tool install git+ssh://git@github.com/prooflayer-ai/backend.git#subdirectory=cli
+uv tool install assertion-cli              # latest
+uv tool install --reinstall assertion-cli  # upgrade in place
 ```
 
 The CLI package declares all of its direct runtime dependencies. At the moment
-that set is `httpx`, `pydantic`, and `typer`.
+that set is `httpx`, `pydantic`, `python-dotenv`, and `typer`.
 
 After installation:
 
@@ -42,7 +43,19 @@ 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
+asrt verify                            # submit final verification (non-blocking)
+asrt verify-status                     # one-shot poll; loop with your own sleep until terminal
 ```
 
-This expects the installer to already have GitHub SSH access to `prooflayer-ai/backend`.
+## Publishing a new version
+
+```bash
+# 1. Bump the version in cli/pyproject.toml.
+# 2. Build the sdist + wheel.
+uv build --package assertion-cli
+# 3. Upload (requires UV_PUBLISH_TOKEN, or `--token` on the command).
+uv publish dist/*
+# 4. Tag the release so consumers can correlate to git:
+git tag cli-v$(grep '^version = ' pyproject.toml | head -1 | cut -d'"' -f2)
+git push origin --tags
+```

assertion_cli-0.2.0/README.md

@@ -0,0 +1,47 @@
+# Assertion CLI
+
+CLI for the Assertion API.
+
+## Usage
+
+The CLI currently targets a local backend at `http://localhost:8000`.
+
+Run locally from the workspace:
+
+```bash
+uv run --package assertion-cli asrt --help
+```
+
+Install as a `uv` tool from PyPI:
+
+```bash
+uv tool install assertion-cli              # latest
+uv tool install --reinstall assertion-cli  # upgrade in place
+```
+
+The CLI package declares all of its direct runtime dependencies. At the moment
+that set is `httpx`, `pydantic`, `python-dotenv`, and `typer`.
+
+After installation:
+
+```bash
+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-status                     # one-shot poll; loop with your own sleep until terminal
+```
+
+## Publishing a new version
+
+```bash
+# 1. Bump the version in cli/pyproject.toml.
+# 2. Build the sdist + wheel.
+uv build --package assertion-cli
+# 3. Upload (requires UV_PUBLISH_TOKEN, or `--token` on the command).
+uv publish dist/*
+# 4. Tag the release so consumers can correlate to git:
+git tag cli-v$(grep '^version = ' pyproject.toml | head -1 | cut -d'"' -f2)
+git push origin --tags
+```

{assertion_cli-0.1.0 → assertion_cli-0.2.0}/assertion_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertion-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: CLI for the Assertion API
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
@@ -26,14 +26,15 @@ Run locally from the workspace:
 uv run --package assertion-cli asrt --help
 ```
 
-Install from Git as a `uv` tool:
+Install as a `uv` tool from PyPI:
 
 ```bash
-uv tool install git+ssh://git@github.com/prooflayer-ai/backend.git#subdirectory=cli
+uv tool install assertion-cli              # latest
+uv tool install --reinstall assertion-cli  # upgrade in place
 ```
 
 The CLI package declares all of its direct runtime dependencies. At the moment
-that set is `httpx`, `pydantic`, and `typer`.
+that set is `httpx`, `pydantic`, `python-dotenv`, and `typer`.
 
 After installation:
 
@@ -42,7 +43,19 @@ 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
+asrt verify                            # submit final verification (non-blocking)
+asrt verify-status                     # one-shot poll; loop with your own sleep until terminal
 ```
 
-This expects the installer to already have GitHub SSH access to `prooflayer-ai/backend`.
+## Publishing a new version
+
+```bash
+# 1. Bump the version in cli/pyproject.toml.
+# 2. Build the sdist + wheel.
+uv build --package assertion-cli
+# 3. Upload (requires UV_PUBLISH_TOKEN, or `--token` on the command).
+uv publish dist/*
+# 4. Tag the release so consumers can correlate to git:
+git tag cli-v$(grep '^version = ' pyproject.toml | head -1 | cut -d'"' -f2)
+git push origin --tags
+```

{assertion_cli-0.1.0 → assertion_cli-0.2.0}/git.py

@@ -37,7 +37,23 @@ def find_git_root(start_path: Path) -> Path:
     return Path(completed.stdout.strip())
 
 
-def require_head_pushed(repo_root: Path) -> None:
+def get_diff_base_sha(repo_root: Path) -> str:
+    """Return the SHA the verifier should diff against — i.e. the most recent
+    commit reachable from BOTH local HEAD and some `refs/remotes/*` ref.
+
+    The verifier clones from GitHub and runs `git checkout <head_sha>` (see
+    backend/repo_analysis/clone.py). That checkout fails for any commit that
+    only exists locally — which is exactly what Codex Cloud produces when its
+    agent autocommits before `asrt checkpoint`. By picking the latest commit
+    that's on origin AND reachable from HEAD, the checkout always succeeds;
+    any local-only commits on top of that base flow through as part of the
+    diff (see `get_uncommitted_diff`), so the verifier still sees the full
+    state the agent built.
+
+    When HEAD itself is on a remote-tracking ref (no local commits),
+    `git merge-base HEAD <ref>` returns HEAD, so this collapses to the old
+    behavior with no diff growth.
+    """
     try:
         remote_refs = run_git_command(
             repo_root, ["for-each-ref", "--format=%(refname:short)", "refs/remotes"]
@@ -50,26 +66,42 @@ def require_head_pushed(repo_root: Path) -> None:
     ]
     if not refs:
         exit_with_error(
-            "Current HEAD commit is not present on any remote-tracking branch."
+            "No remote-tracking branches found. The verifier needs a commit "
+            "on origin to apply the diff onto — push at least one branch "
+            "(and `git fetch`) before running this command."
         )
 
+    candidate_shas: list[str] = []
     for ref in refs:
         completed = subprocess.run(
-            ["git", "merge-base", "--is-ancestor", "HEAD", ref],
+            ["git", "merge-base", "HEAD", ref],
             cwd=repo_root,
             capture_output=True,
             text=True,
             check=False,
         )
         if completed.returncode == 0:
-            return
-        if completed.returncode != 1:
-            message = (
-                completed.stderr.strip() or completed.stdout.strip() or "git failed"
-            )
-            exit_with_error(f"Failed to verify remote commit state: {message}")
+            sha = completed.stdout.strip()
+            if sha:
+                candidate_shas.append(sha)
+
+    if not candidate_shas:
+        exit_with_error(
+            "HEAD has no commits in common with any remote-tracking branch. "
+            "Push the branch (or its parent commits) to origin and retry."
+        )
 
-    exit_with_error("Current HEAD commit is not present on any remote-tracking branch.")
+    best_sha = candidate_shas[0]
+    best_ts = -1
+    for sha in candidate_shas:
+        try:
+            ts = int(run_git_command(repo_root, ["log", "-1", "--format=%ct", sha]))
+        except (RuntimeError, ValueError):
+            continue
+        if ts > best_ts:
+            best_ts = ts
+            best_sha = sha
+    return best_sha
 
 
 def get_head_sha(repo_root: Path) -> str:
@@ -148,9 +180,9 @@ def _build_untracked_diff(repo_root: Path, rel_path: str) -> str:
 # Paths the assertion-cli owns end-to-end. Excluded from the diff bundle so
 # reviewers don't flag our own bootstrap files as "unrelated changes" — they're
 # generated/refreshed by `asrt init` and `asrt checkpoint` and have nothing to
-# do with the customer's feature work. CLAUDE.md / AGENTS.md are intentionally
-# NOT in this list: those are customer-owned files we only patch a marked
-# block into, so the customer's other edits to them should still flow through.
+# do with the user's feature work. CLAUDE.md / AGENTS.md are intentionally
+# NOT in this list: those are user-owned files we only patch a marked
+# block into, so the user's other edits to them should still flow through.
 _ASSERTION_EXCLUDED_PATHSPECS = [
     ":(exclude).assertion",
     ":(exclude).claude/skills/assertion-cli",
@@ -158,13 +190,18 @@ _ASSERTION_EXCLUDED_PATHSPECS = [
 ]
 
 
-def get_uncommitted_diff(repo_root: Path) -> str:
+def get_uncommitted_diff(repo_root: Path, base_sha: str) -> str:
+    """Build a unified diff from `base_sha` to the current working tree.
+
+    `git diff <base_sha>` compares the working tree directly to the base
+    commit, which subsumes both committed-since-base and unstaged tweaks in
+    one shot — so a single call covers all tracked changes regardless of
+    whether the agent committed locally. Untracked files are still added
+    separately as new-file diffs.
+    """
     try:
         tracked = run_git_command(
-            repo_root, ["diff", "--", *_ASSERTION_EXCLUDED_PATHSPECS]
-        )
-        staged = run_git_command(
-            repo_root, ["diff", "--cached", "--", *_ASSERTION_EXCLUDED_PATHSPECS]
+            repo_root, ["diff", base_sha, "--", *_ASSERTION_EXCLUDED_PATHSPECS]
         )
 
         untracked_output = run_git_command(
@@ -183,7 +220,7 @@ def get_uncommitted_diff(repo_root: Path) -> str:
             if rel_path
         ]
 
-        parts = [p for p in [tracked, staged, "\n".join(untracked_diffs)] if p]
+        parts = [p for p in [tracked, "\n".join(untracked_diffs)] if p]
         return "\n".join(parts)
     except RuntimeError as exc:
         exit_with_error(f"Failed to collect git diff: {exc}")

{assertion_cli-0.1.0 → assertion_cli-0.2.0}/main.py

@@ -2,8 +2,6 @@ import base64
 import importlib.resources
 import json
 import re
-import sys
-import time
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -14,12 +12,12 @@ from bundle import build_bundle
 from git import (
     exit_with_error,
     find_git_root,
+    get_diff_base_sha,
     get_head_branch,
-    get_head_sha,
     get_uncommitted_diff,
 )
 from link import load_link, save_link
-from models import CheckpointResponse, SessionContext, SessionStatus, render_stack_list
+from models import CheckpointResponse, SessionStatus, render_stack_list
 from session import (
     ASSERTION_DIR_NAME,
     METADATA_FILE_NAME,
@@ -33,8 +31,6 @@ from session import (
 
 app = typer.Typer(help="Assertion CLI")
 
-STATUS_POLL_INTERVAL_SECONDS = 2.0
-
 
 def render_checkpoint_response(resp: CheckpointResponse) -> str:
     lines = [
@@ -131,7 +127,7 @@ def _refresh_skill_files(repo_root: Path) -> None:
     """Write/refresh the assertion-owned skill files for each coding agent.
 
     Safe to call on every checkpoint — these files are entirely ours; updating
-    them to match the installed CLI version cannot clobber customer content.
+    them to match the installed CLI version cannot clobber user content.
 
     `.claude/skills/`  — Claude Code
     `.agents/skills/`  — Codex + Cursor (Cursor also accepts .cursor/skills/)
@@ -176,10 +172,10 @@ def _ensure_gitignore_excludes_assertion(repo_root: Path) -> None:
 
 
 def _apply_activation_blocks(repo_root: Path) -> None:
-    """Insert/update the marked activation block in customer-owned CLAUDE.md / AGENTS.md.
+    """Insert/update the marked activation block in user-owned CLAUDE.md / AGENTS.md.
 
     Only called by `asrt init`. We deliberately do NOT call this on every checkpoint —
-    these files may be tracked in the customer's git, and silently dirtying them on
+    these files may be tracked in the user's git, and silently dirtying them on
     every checkpoint is hostile. The block is a stable pointer to the skill file, so
     re-running on every CLI upgrade isn't necessary.
     """
@@ -188,16 +184,6 @@ def _apply_activation_blocks(repo_root: Path) -> None:
     _apply_marked_block(repo_root / "AGENTS.md", activation_body, repo_root)
 
 
-def _clear_session_state(ctx: SessionContext) -> None:
-    """Remove per-session files so the next prompt/checkpoint starts cleanly.
-
-    Leaves the `.assertion/` directory itself (and `link`, `screenshots/`) in
-    place so the customer can still retrieve the just-completed session's URL.
-    """
-    for path in (ctx.prompts_path, ctx.checkpoint_path, ctx.metadata_path):
-        path.unlink(missing_ok=True)
-
-
 @app.command("init")
 def init() -> None:
     """One-time bootstrap: install the assertion-cli skill files into this repo.
@@ -215,16 +201,16 @@ def init() -> None:
     _ensure_gitignore_excludes_assertion(repo_root)
     typer.echo("")
     typer.echo("The coding agent will now follow the Assertion workflow:")
-    typer.echo('  - asrt prompt "<msg>" on every customer turn')
+    typer.echo('  - asrt prompt "<msg>" on every user turn')
     typer.echo("  - asrt checkpoint at trajectory-feedback moments")
     typer.echo("  - asrt verify at completion, then PR")
 
 
 @app.command("prompt")
 def prompt_cmd(
-    text: str = typer.Argument(..., help="Customer prompt text to record."),
+    text: str = typer.Argument(..., help="User prompt text to record."),
 ) -> None:
-    """Append a customer prompt to the session prompt history."""
+    """Append a user prompt to the session prompt history."""
     normalized = text.strip()
     if not normalized:
         exit_with_error("Prompt text must not be empty.")
@@ -275,7 +261,7 @@ def checkpoint(
 
     # Refresh the assertion-owned skill files so the agent always loads the
     # version that ships with the installed CLI. We deliberately do NOT touch
-    # CLAUDE.md / AGENTS.md here — those are customer-owned and only updated
+    # CLAUDE.md / AGENTS.md here — those are user-owned and only updated
     # by `asrt init`.
     _refresh_skill_files(repo_root)
 
@@ -301,11 +287,15 @@ def checkpoint(
     assert stack_id is not None
 
     append_checkpoint_entry(ctx.checkpoint_path, message)
-    head_sha = get_head_sha(ctx.repo_root)
+    # `head_sha` here is the diff base — the latest commit on origin that's
+    # also reachable from local HEAD. Backend uses it as the checkout target
+    # before applying the diff; sending the actual local HEAD would break
+    # when the agent has uncommitted-to-origin commits (e.g. Codex Cloud).
+    base_sha = get_diff_base_sha(ctx.repo_root)
     head_branch = get_head_branch(ctx.repo_root)
-    diff_text = get_uncommitted_diff(ctx.repo_root)
+    diff_text = get_uncommitted_diff(ctx.repo_root, base_sha)
     metadata = update_metadata_head(
-        ctx.metadata_path, metadata, head_sha, head_branch=head_branch
+        ctx.metadata_path, metadata, base_sha, head_branch=head_branch
     )
 
     bundle_bytes = build_bundle(
@@ -329,28 +319,67 @@ def checkpoint(
         raise typer.Exit(code=1)
 
 
+VERIFY_SESSION_FILE_NAME = "verify_session_id"
+
+
+def _save_verify_session_id(assertion_dir: Path, session_id: str) -> None:
+    (assertion_dir / VERIFY_SESSION_FILE_NAME).write_text(
+        session_id + "\n", encoding="utf-8"
+    )
+
+
+def _load_verify_session_id(assertion_dir: Path) -> str:
+    path = assertion_dir / VERIFY_SESSION_FILE_NAME
+    if not path.exists():
+        exit_with_error(
+            "No verification in flight. Run `asrt verify` before `asrt verify-status`."
+        )
+    content = path.read_text(encoding="utf-8").strip()
+    if not content:
+        exit_with_error(
+            f"{path.name} is empty. Re-run `asrt verify` to start a new verification."
+        )
+    return content
+
+
+def _write_screenshots(
+    assertion_dir: Path, session_id: str, screenshots: list[str]
+) -> Path:
+    screenshot_dir = assertion_dir / "screenshots" / session_id
+    screenshot_dir.mkdir(parents=True, exist_ok=True)
+    for idx, uri in enumerate(screenshots):
+        _, b64data = uri.split(",", 1)
+        ext = "jpeg" if "jpeg" in uri.split(",")[0] else "png"
+        (screenshot_dir / f"screenshot_{idx:03d}.{ext}").write_bytes(
+            base64.b64decode(b64data)
+        )
+    return screenshot_dir
+
+
 @app.command("verify")
 def verify(
     json_output: bool = typer.Option(
         False,
         "--json",
-        help="Print the terminal verification status as a single JSON line.",
-    ),
-    no_wait: bool = typer.Option(
-        False,
-        "--no-wait",
-        help="Submit and return immediately without polling. Useful for harnesses.",
+        help="Print the verification submission as a single JSON line.",
     ),
 ) -> None:
-    """Submit final verification and wait for the result."""
+    """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
-    head_sha = get_head_sha(ctx.repo_root)
+    # See checkpoint() for why we send the diff base rather than local HEAD.
+    base_sha = get_diff_base_sha(ctx.repo_root)
     head_branch = get_head_branch(ctx.repo_root)
-    diff_text = get_uncommitted_diff(ctx.repo_root)
+    diff_text = get_uncommitted_diff(ctx.repo_root, base_sha)
     metadata = update_metadata_head(
-        ctx.metadata_path, metadata, head_sha, head_branch=head_branch
+        ctx.metadata_path, metadata, base_sha, head_branch=head_branch
     )
 
     bundle_bytes = build_bundle(
@@ -370,99 +399,90 @@ def verify(
     session_id = resp.session_id
     session_url = resp.url
     save_link(ctx.assertion_dir, session_url)
+    _save_verify_session_id(ctx.assertion_dir, session_id)
 
-    if no_wait:
-        if json_output:
-            typer.echo(
-                json.dumps(
-                    {
-                        "session_id": session_id,
-                        "url": session_url,
-                        "status": "submitted",
-                    }
-                )
+    if json_output:
+        typer.echo(
+            json.dumps(
+                {
+                    "session_id": session_id,
+                    "url": session_url,
+                    "status": "submitted",
+                }
             )
-        else:
-            typer.echo(f"Verification submitted ({session_id}). URL: {session_url}")
-        return
+        )
+    else:
+        typer.echo(f"Verification submitted ({session_id}). URL: {session_url}")
+        typer.echo("Poll `asrt verify-status` to check progress.")
 
-    if not json_output:
-        typer.echo(f"Verification submitted ({session_id}). Waiting for result...")
 
-    poll_count = 0
-    while True:
-        payload = client.status(session_id=session_id)
+@app.command("verify-status")
+def verify_status(
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Print the verification status as a single JSON line.",
+    ),
+) -> None:
+    """One-shot poll of the in-flight verification.
 
-        if payload.status in {SessionStatus.CREATED, SessionStatus.RUNNING}:
-            poll_count += 1
-            if not json_output:
-                sys.stderr.write(".")
-                sys.stderr.flush()
-            time.sleep(STATUS_POLL_INTERVAL_SECONDS)
-            continue
+    Reads the session id saved by `asrt verify` and prints the current status.
+    Exits 0 for `created` / `running` / `succeeded`, and 1 for `failed` so a
+    polling shell loop can branch on `$?`. When the run reaches a terminal
+    state, screenshots are written to `.assertion/screenshots/<session_id>/`
+    and the link file is refreshed.
+    """
+    ctx, metadata = load_existing_session(Path.cwd())
+    _ = metadata  # touched only to validate session existence
+    session_id = _load_verify_session_id(ctx.assertion_dir)
 
-        if poll_count > 0 and not json_output:
-            sys.stderr.write("\n")
-            sys.stderr.flush()
+    client = AssertionClient()
+    payload = client.status(session_id=session_id)
 
-        if payload.url:
-            session_url = payload.url
+    session_url: str | None = payload.url
+    if session_url:
         save_link(ctx.assertion_dir, session_url)
+    else:
+        # Fallback to the link we saved at submission time.
+        try:
+            session_url = load_link(ctx.assertion_dir)
+        except SystemExit:
+            session_url = None
 
-        if payload.screenshots:
-            screenshot_dir = Path(".assertion") / "screenshots" / session_id
-            screenshot_dir.mkdir(parents=True, exist_ok=True)
-            for idx, uri in enumerate(payload.screenshots):
-                _, b64data = uri.split(",", 1)
-                ext = "jpeg" if "jpeg" in uri.split(",")[0] else "png"
-                path = screenshot_dir / f"screenshot_{idx:03d}.{ext}"
-                path.write_bytes(base64.b64decode(b64data))
-
-        if json_output:
-            typer.echo(
-                json.dumps(
-                    {
-                        "session_id": session_id,
-                        "url": session_url,
-                        "status": str(payload.status),
-                        "message": payload.message,
-                        "summary": payload.summary,
-                        "screenshot_count": len(payload.screenshots),
-                    }
-                )
-            )
-            if payload.status == SessionStatus.FAILED:
-                raise typer.Exit(code=1)
-            return
+    terminal = payload.status in {SessionStatus.SUCCEEDED, SessionStatus.FAILED}
+    screenshot_count = len(payload.screenshots)
+    if terminal and payload.screenshots:
+        _write_screenshots(ctx.assertion_dir, session_id, payload.screenshots)
 
-        if payload.message is None:
-            typer.echo(
-                "Invalid API response: terminal status must include a message.",
-                err=True,
+    if json_output:
+        typer.echo(
+            json.dumps(
+                {
+                    "session_id": session_id,
+                    "url": session_url,
+                    "status": str(payload.status),
+                    "message": payload.message,
+                    "summary": payload.summary,
+                    "screenshot_count": screenshot_count,
+                }
             )
-            raise typer.Exit(code=1)
-
-        typer.echo(payload.message)
+        )
+    else:
+        typer.echo(f"status: {payload.status}")
+        if payload.message:
+            typer.echo(payload.message)
         if payload.summary:
             typer.echo(f"\nSummary:\n{payload.summary}")
-        if payload.screenshots:
+        if terminal and payload.screenshots:
             typer.echo(
-                f"\nScreenshots ({len(payload.screenshots)}) saved to "
+                f"\nScreenshots ({screenshot_count}) saved to "
                 f".assertion/screenshots/{session_id}/"
             )
-        typer.echo(f"\nSession: {session_url}")
-        if payload.status == SessionStatus.FAILED:
-            raise typer.Exit(code=1)
-
-        # On a clean verify in an interactive shell, offer to clear session
-        # state so the next `asrt prompt` / `asrt checkpoint` starts fresh.
-        if sys.stdin.isatty() and typer.confirm(
-            "\nStart a new session? This clears .assertion/ (prompts, metadata, checkpoint).",
-            default=False,
-        ):
-            _clear_session_state(ctx)
-            typer.echo("Cleared. Next `asrt prompt` starts a new session.")
-        return
+        if session_url:
+            typer.echo(f"\nSession: {session_url}")
+
+    if payload.status == SessionStatus.FAILED:
+        raise typer.Exit(code=1)
 
 
 @app.command("get-link")

{assertion_cli-0.1.0 → assertion_cli-0.2.0}/pyproject.toml

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

{assertion_cli-0.1.0 → assertion_cli-0.2.0}/session.py

@@ -6,8 +6,8 @@ from api import AssertionClient
 from git import (
     exit_with_error,
     find_git_root,
+    get_diff_base_sha,
     get_origin_github_repo,
-    require_head_pushed,
 )
 from models import MetadataPayload, SessionContext, render_stack_list
 
@@ -19,7 +19,9 @@ METADATA_FILE_NAME = "metadata.json"
 
 def _require_repo_ready(start_path: Path) -> Path:
     repo_root = find_git_root(start_path)
-    require_head_pushed(repo_root)
+    # Fail fast here if no remote-reachable base exists. Result is discarded
+    # — callers re-compute at diff time, which is cheap.
+    get_diff_base_sha(repo_root)
     return repo_root
 
 
@@ -77,7 +79,7 @@ def _require_prompts_file(ctx: SessionContext) -> None:
     ):
         exit_with_error(
             f"ERROR: {ASSERTION_DIR_NAME}/{PROMPTS_FILE_NAME} is missing or empty.\n"
-            'Record at least one customer prompt with `asrt prompt "<message>"` before running checkpoint.'
+            'Record at least one user prompt with `asrt prompt "<message>"` before running checkpoint.'
         )
 
 

{assertion_cli-0.1.0 → assertion_cli-0.2.0}/templates/ACTIVATION.md

@@ -1,13 +1,13 @@
 # Assertion verification
 
-This repo uses the Assertion CLI (`asrt`) to track customer intent and verify your work. The full workflow lives in the `assertion-cli` skill:
+This repo uses the Assertion CLI (`asrt`) to track user intent and verify your work. The full workflow lives in the `assertion-cli` skill:
 
 - **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:
 
-1. **Every customer message:** call `asrt prompt "<exact text of the message>"` before doing any other work for that turn. This is the verifier's source of truth for what the customer asked for and how their direction evolves. Apply to every customer turn, not just the first.
+1. **Every user message:** call `asrt prompt "<exact text of the message>"` before doing any other work for that turn. This is the verifier's source of truth for what the user asked for and how their direction evolves. Apply to every user turn, not just the first.
 2. **Checkpoint at trajectory-feedback moments**, not on every small change. Use `asrt checkpoint "<summary>"` — the CLI auto-resolves the stack from this repo's GitHub origin on the first call and auto-continues the session on subsequent calls. A whole feature build is a handful of checkpoints, not one per file.
 3. **Verify at completion** with `asrt verify`. If feedback requires changes, iterate and re-verify — do **not** drop back into the checkpoint loop. Once verify is clean, open a PR with `gh pr create` and include the session URL (from `asrt get-link`) in the body.
 

{assertion_cli-0.1.0 → assertion_cli-0.2.0}/templates/SKILL.md

@@ -1,11 +1,11 @@
 ---
 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 customer message with `asrt prompt`, checkpoint at trajectory-feedback moments (not on every change), and verify only at completion before opening a PR. 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 every user message with `asrt prompt`, checkpoint at trajectory-feedback moments (not on every change), and verify only at completion before opening a PR. Applies to any coding agent reading this skill.
 ---
 
 # Assertion CLI
 
-You are operating in a repo that uses the Assertion CLI (`asrt`) to track customer 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. 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.
 
@@ -14,7 +14,7 @@ This skill is operational, not advisory. Treat each rule as a hard requirement u
 Before any `asrt` call:
 
 - You are inside a git repository.
-- `HEAD` is present on at least one remote-tracking branch (the CLI enforces this for checkpoint/verify; `asrt prompt` does not require it).
+- The repo has at least one remote-tracking ref that shares history with `HEAD` (the CLI uses the latest such commit as the diff base for checkpoint/verify; local-only commits on top flow through as part of the diff). `asrt prompt` does not require this.
 
 No `asrt init` is needed — the CLI creates `.assertion/` on first use. Treat `.assertion/metadata.json` and `.assertion/prompts` 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.
 
@@ -22,21 +22,21 @@ No `asrt init` is needed — the CLI creates `.assertion/` on first use. Treat `
 
 ---
 
-## Rule 1 — Log every customer message, immediately
+## Rule 1 — Log every user message, immediately
 
-**The first thing you do when a new customer message arrives — before reading any file, planning, or editing anything — is run:**
+**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 customer's message>"
+asrt prompt "<exact text of the user's message>"
 ```
 
-This applies to **every customer 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").
+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 customer 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.
+**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.
 
 **Edge cases:**
 - Multi-line / multi-paragraph messages: pass the full text as one quoted argument. Use shell-quoting that preserves newlines (e.g., `$'first line\nsecond line'` in bash, or a heredoc piped via `xargs`).
-- Empty / whitespace-only customer turns: skip — `asrt prompt` rejects them.
+- Empty / whitespace-only user turns: skip — `asrt prompt` rejects them.
 - You misrecorded a prompt: there is no undo. Append a correction as a normal prompt, e.g. `asrt prompt "Correction: previous message should have been '...'"`.
 
 ---
@@ -49,7 +49,7 @@ This applies to **every customer turn**, not just the first. It applies even whe
 - A meaningful slice of the feature is complete (e.g., the data model, the API layer, the UI scaffold).
 - You made a non-trivial design choice and want it sanity-checked before building further on it.
 - You hit ambiguity and want input on which of two reasonable paths to take.
-- The customer's evolving direction (visible in the prompt log) could legitimately change what comes next.
+- The user's evolving direction (visible in the prompt log) could legitimately change what comes next.
 
 **Do NOT checkpoint when:**
 - You finished a single file edit.
@@ -68,7 +68,7 @@ You don't need a flag to distinguish "first" from "subsequent" — the CLI does
 - No session exists yet → start a new one. The CLI picks the stack by matching the repo's GitHub `owner/name` (from `git remote get-url origin`) against the stacks attached to this repo.
 - A session already exists → continue it.
 
-If no stack is attached to this repo on the very first checkpoint, the command fails with a clear message telling the customer to attach one in the Assertion web app. If multiple stacks are attached, it tells you to pass `--stack <id>` to disambiguate.
+If no stack is attached to this repo on the very first checkpoint, the command fails with a clear message telling the user to attach one in the Assertion web app. If multiple stacks are attached, it tells you to pass `--stack <id>` to disambiguate.
 
 Flags exist for explicit intent, but you normally don't need them:
 - `--continue` — fail fast if no session exists (otherwise behaves identically to no flag when a session does exist).
@@ -87,9 +87,9 @@ Use checkpoint messages to summarize substantive progress and decisions since th
 Stack selection is **enforced by the CLI**, not by you. When you run `asrt checkpoint "..."` (no `--stack` flag), the CLI:
 
 1. Runs `git remote get-url origin` and normalizes to `owner/name`
-2. Calls the backend, fetches every stack in the customer's workspace, and matches by the stack's `repo` field
+2. Calls the backend, fetches every stack in the user's workspace, and matches by the stack's `repo` field
 3. Picks the single match → starts the session against it
-4. If zero or multiple match, exits non-zero with a clear, customer-facing error
+4. If zero or multiple match, exits non-zero with a clear, user-facing error
 
 You don't need to do the matching yourself or pass `--stack`. Just call `asrt checkpoint "..."`.
 
@@ -99,20 +99,20 @@ This is the most common failure. The CLI distinguishes three cases — your resp
 
 | CLI error starts with | Meaning |
 |---|---|
-| `No verification stacks exist in this workspace yet.` | Customer has never set up any stacks. |
+| `No verification stacks exist in this workspace yet.` | User has never set up any stacks. |
 | `No verification stack is attached to this repo (...)` | Stacks exist but none are bound to this repo. |
 | `Multiple stacks are attached to ...` | Two or more stacks match; CLI asks for `--stack <id>`. |
 
-**For the first two:** the customer has to take an action in the Assertion web app. Your response:
+**For the first two:** the user has to take an action in the Assertion web app. Your response:
 
-1. Tell the customer the error verbatim. The CLI already wrote the right message.
-2. **Keep the work moving on your side.** You can continue editing files and implementing what the customer asked for. Verification is the gate before opening a PR — not a gate on writing code.
-3. Keep calling `asrt prompt "..."` on every new customer turn. The prompt log accumulates in `.assertion/prompts` and is *not* lost when checkpoint fails — once the customer attaches a stack, the next successful `asrt checkpoint "..."` ships every prompt logged so far in its bundle.
-4. When the customer says they've attached a stack (or asks you to retry), call `asrt checkpoint "<what you built so far>"` again. The CLI will resolve the stack this time and start the session with the full prompt history already in the bundle.
+1. Tell the user the error verbatim. The CLI already wrote the right message.
+2. **Keep the work moving on your side.** You can continue editing files and implementing what the user asked for. Verification is the gate before opening a PR — not a gate on writing code.
+3. Keep calling `asrt prompt "..."` on every new user turn. The prompt log accumulates in `.assertion/prompts` and is *not* lost when checkpoint fails — once the user attaches a stack, the next successful `asrt checkpoint "..."` ships every prompt logged so far in its bundle.
+4. When the user says they've attached a stack (or asks you to retry), call `asrt checkpoint "<what you built so far>"` again. The CLI will resolve the stack this time and start the session with the full prompt history already in the bundle.
 
-**Do not** try to work around the missing stack by guessing a stack ID, hardcoding one from another repo, or picking the wrong one with `--stack`. Repo-binding is the customer's signal that the stack is configured for this codebase; bypassing it creates a verification session in the wrong context.
+**Do not** try to work around the missing stack by guessing a stack ID, hardcoding one from another repo, or picking the wrong one with `--stack`. Repo-binding is the user's signal that the stack is configured for this codebase; bypassing it creates a verification session in the wrong context.
 
-**For the third case (multiple matches):** the CLI's error lists the candidates. Pick the one whose name/description best fits the primary deliverable (code review, security, docs, perf) and pass `asrt checkpoint --stack <id> "..."`. State your choice briefly so the customer can correct you.
+**For the third case (multiple matches):** the CLI's error lists the candidates. Pick the one whose name/description best fits the primary deliverable (code review, security, docs, perf) and pass `asrt checkpoint --stack <id> "..."`. State your choice briefly so the user can correct you.
 
 ### Optional: confirm before you start
 
@@ -125,35 +125,51 @@ If you want to know which stack the CLI *would* pick before running checkpoint (
 `asrt verify` is the terminal validation gate. Call it when **all three** are true:
 
 1. The feature is implemented.
-2. The customer has signalled no further edits or redirections.
+2. The user has signalled no further edits or redirections.
 3. All in-flight checkpoint feedback has been addressed.
 
 Do not call `verify` mid-task. It is not a substitute for checkpoints; it is the gate after them.
 
-`verify` blocks until verification completes. It prints the final result, may print a summary, may save screenshots under `.assertion/screenshots/<verification_id>/`, prints a session URL, and saves the URL to `.assertion/link`. This may take several minutes — do not interrupt it.
+`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.
+
+```
+asrt verify                                # submit; prints session id + URL, exits 0
+# … then poll until terminal:
+while :; do
+  out=$(asrt verify-status --json)
+  st=$(printf '%s' "$out" | jq -r .status)
+  case "$st" in
+    succeeded|failed) printf '%s\n' "$out"; break ;;
+    *) sleep 10 ;;
+  esac
+done
+```
+
+`asrt verify-status` is a one-shot poll. It prints the current status, refreshes `.assertion/link`, and on terminal status writes screenshots under `.assertion/screenshots/<verification_id>/`. Exit code is `0` for `created` / `running` / `succeeded` and `1` for `failed`, so a polling loop can also branch on `$?`.
 
 `asrt get-link` prints the last session URL (e.g., for inclusion in PR descriptions).
 
-**After verify returns, branch on the outcome:**
+**After status reports terminal, branch on the outcome:**
 
 | Outcome | What you do next |
 |---|---|
-| **Clean** (succeeded, no required changes) | Open a PR with `gh pr create`. Include the session URL (printed by verify; also `asrt get-link`) in the PR body so reviewers can see the verification record. |
-| **Feedback or failed** (changes required) | Treat the feedback as authoritative. Apply the changes it calls for, then re-run `asrt verify`. Repeat until clean. **Do not drop back into the checkpoint loop** — verify is the gate, not a checkpoint. |
-| **Customer sends a new message during iteration** | Log it with `asrt prompt` first (Rule 1 still applies). Address the new direction. Re-verify before opening the PR. |
+| **Clean** (succeeded, no required changes) | Open a PR with `gh pr create`. Include the session URL (printed by verify/status; also `asrt get-link`) in the PR body so reviewers can see the verification record. |
+| **Feedback or failed** (changes required) | Treat the feedback as authoritative. Apply the changes it calls for, then re-run `asrt verify` and poll `asrt verify-status` again. Repeat until clean. **Do not drop back into the checkpoint loop** — verify is the gate, not a checkpoint. |
+| **User sends a new message during iteration** | Log it with `asrt prompt` first (Rule 1 still applies). Address the new direction. Re-verify before opening the PR. |
 
-**Do not open a PR without a clean `asrt verify`.** Do not end a session with a failed/dirty verify unless the verification service itself is unavailable.
+**Do not open a PR without a clean `asrt verify` / `asrt verify-status`.** Do not end a session with a failed/dirty verify unless the verification service itself is unavailable.
 
 ---
 
 ## Quick reference
 
 ```
-asrt prompt "<message>"             # every customer turn, before anything else
+asrt prompt "<message>"             # every user turn, before anything else
 asrt stacks                         # optional: list stacks attached to this repo
 asrt checkpoint "..."               # at trajectory moments — auto-starts or continues
 asrt decision --yes|--no <ckpt-id>  # optional, on failed checkpoints only
-asrt verify                         # at feature completion; the gate before PR
+asrt verify                         # submit verification (non-blocking)
+asrt verify-status                  # one-shot poll; loop with your own sleep
 asrt get-link                       # retrieve the last session URL
 ```
 
@@ -172,6 +188,6 @@ 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. Use `asrt verify --json --no-wait` to submit and exit, then poll `asrt get-link` / the session URL externally to detach the harness from the polling loop. Without `--no-wait`, `verify --json` still polls but emits a single JSON line on termination.
+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.
 
 Do not mix `--json` output with human-rendered output in the same run. Pick one mode and stick with it.

{assertion_cli-0.1.0 → assertion_cli-0.2.0}/tests/test_git.py

@@ -4,7 +4,13 @@ from pathlib import Path
 import pytest
 from click.exceptions import Exit as ClickExit
 
-from git import find_git_root, get_head_sha, get_uncommitted_diff, run_git_command
+from git import (
+    find_git_root,
+    get_diff_base_sha,
+    get_head_sha,
+    get_uncommitted_diff,
+    run_git_command,
+)
 
 
 # --- run_git_command ---
@@ -87,7 +93,7 @@ def _init_repo_with_commit(tmp_path: Path) -> None:
 
 def test_get_uncommitted_diff_clean(tmp_path: Path) -> None:
     _init_repo_with_commit(tmp_path)
-    diff = get_uncommitted_diff(tmp_path)
+    diff = get_uncommitted_diff(tmp_path, "HEAD")
     assert diff == ""
 
 
@@ -107,7 +113,7 @@ def test_get_uncommitted_diff_tracked_changes(tmp_path: Path) -> None:
         env={**GIT_ENV, "HOME": str(tmp_path)},
     )
     f.write_text("modified\n")
-    diff = get_uncommitted_diff(tmp_path)
+    diff = get_uncommitted_diff(tmp_path, "HEAD")
     assert "hello.txt" in diff
     assert "-original" in diff
     assert "+modified" in diff
@@ -120,7 +126,7 @@ def test_get_uncommitted_diff_staged_changes(tmp_path: Path) -> None:
     subprocess.run(
         ["git", "add", "staged.txt"], cwd=tmp_path, capture_output=True, check=True
     )
-    diff = get_uncommitted_diff(tmp_path)
+    diff = get_uncommitted_diff(tmp_path, "HEAD")
     assert "staged.txt" in diff
     assert "+staged content" in diff
 
@@ -129,7 +135,7 @@ def test_get_uncommitted_diff_untracked_files(tmp_path: Path) -> None:
     _init_repo_with_commit(tmp_path)
     f = tmp_path / "new_file.py"
     f.write_text("print('hello')\n")
-    diff = get_uncommitted_diff(tmp_path)
+    diff = get_uncommitted_diff(tmp_path, "HEAD")
     assert "new_file.py" in diff
     assert "new file mode" in diff
     assert "+print('hello')" in diff
@@ -160,18 +166,18 @@ def test_get_uncommitted_diff_combines_all_sources(tmp_path: Path) -> None:
     # Untracked file
     (tmp_path / "untracked.txt").write_text("surprise\n")
 
-    diff = get_uncommitted_diff(tmp_path)
+    diff = get_uncommitted_diff(tmp_path, "HEAD")
     assert "tracked.txt" in diff
     assert "staged.txt" in diff
     assert "untracked.txt" in diff
 
 
 def test_get_uncommitted_diff_includes_untracked_file(tmp_path: Path) -> None:
-    subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
+    _init_repo_with_commit(tmp_path)
     new_file = tmp_path / "notes.txt"
     new_file.write_text("hello\nworld\n", encoding="utf-8")
 
-    diff = get_uncommitted_diff(tmp_path)
+    diff = get_uncommitted_diff(tmp_path, "HEAD")
 
     assert "diff --git a/notes.txt b/notes.txt" in diff
     assert "new file mode" in diff
@@ -181,10 +187,117 @@ def test_get_uncommitted_diff_includes_untracked_file(tmp_path: Path) -> None:
 
 
 def test_get_uncommitted_diff_includes_empty_untracked_file(tmp_path: Path) -> None:
-    subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
+    _init_repo_with_commit(tmp_path)
     (tmp_path / "empty.txt").write_text("", encoding="utf-8")
 
-    diff = get_uncommitted_diff(tmp_path)
+    diff = get_uncommitted_diff(tmp_path, "HEAD")
 
     assert "diff --git a/empty.txt b/empty.txt" in diff
     assert "new file mode" in diff
+
+
+# --- get_diff_base_sha + local-commit handling ---
+
+
+def _set_up_repo_with_fake_remote(tmp_path: Path) -> tuple[Path, Path]:
+    """Build a local repo with a `refs/remotes/origin/*` ref pointing at HEAD.
+
+    Returns (repo_path, bare_remote_path). We push to a real bare remote so the
+    `refs/remotes/origin/main` entry exists naturally — `get_diff_base_sha`
+    reads it via `git for-each-ref refs/remotes`.
+    """
+    bare = tmp_path / "remote.git"
+    repo = tmp_path / "repo"
+    subprocess.run(
+        ["git", "init", "--bare", str(bare)], capture_output=True, check=True
+    )
+    subprocess.run(
+        ["git", "init", "-b", "main", str(repo)], capture_output=True, check=True
+    )
+    env = {**GIT_ENV, "HOME": str(repo)}
+    subprocess.run(
+        ["git", "commit", "--allow-empty", "-m", "init"],
+        cwd=repo,
+        capture_output=True,
+        check=True,
+        env=env,
+    )
+    subprocess.run(
+        ["git", "remote", "add", "origin", str(bare)],
+        cwd=repo,
+        capture_output=True,
+        check=True,
+    )
+    subprocess.run(
+        ["git", "push", "-u", "origin", "main"],
+        cwd=repo,
+        capture_output=True,
+        check=True,
+        env=env,
+    )
+    return repo, bare
+
+
+def test_get_diff_base_sha_returns_head_when_no_local_commits(tmp_path: Path) -> None:
+    repo, _ = _set_up_repo_with_fake_remote(tmp_path)
+    head = run_git_command(repo, ["rev-parse", "HEAD"])
+    assert get_diff_base_sha(repo) == head
+
+
+def test_get_diff_base_sha_returns_pushed_parent_when_local_commit_present(
+    tmp_path: Path,
+) -> None:
+    """The bug fix: when the agent commits locally without pushing, the base
+    must remain the latest pushed commit — not the local-only HEAD."""
+    repo, _ = _set_up_repo_with_fake_remote(tmp_path)
+    pushed_head = run_git_command(repo, ["rev-parse", "HEAD"])
+
+    # Local commit on top of the pushed tip (not pushed back to origin).
+    (repo / "local.txt").write_text("local change\n")
+    env = {**GIT_ENV, "HOME": str(repo)}
+    subprocess.run(
+        ["git", "add", "local.txt"], cwd=repo, capture_output=True, check=True
+    )
+    subprocess.run(
+        ["git", "commit", "-m", "local-only"],
+        cwd=repo,
+        capture_output=True,
+        check=True,
+        env=env,
+    )
+    new_head = run_git_command(repo, ["rev-parse", "HEAD"])
+    assert new_head != pushed_head
+
+    assert get_diff_base_sha(repo) == pushed_head
+
+
+def test_get_diff_base_sha_exits_when_no_remote_refs(tmp_path: Path) -> None:
+    _init_repo_with_commit(tmp_path)
+    with pytest.raises(ClickExit):
+        get_diff_base_sha(tmp_path)
+
+
+def test_get_uncommitted_diff_includes_local_only_commit_against_base(
+    tmp_path: Path,
+) -> None:
+    """A local-only commit on top of the pushed base must show up in the diff
+    sent to the verifier — otherwise the verifier would never see it."""
+    repo, _ = _set_up_repo_with_fake_remote(tmp_path)
+    base_sha = run_git_command(repo, ["rev-parse", "HEAD"])
+
+    (repo / "local.txt").write_text("local change\n")
+    env = {**GIT_ENV, "HOME": str(repo)}
+    subprocess.run(
+        ["git", "add", "local.txt"], cwd=repo, capture_output=True, check=True
+    )
+    subprocess.run(
+        ["git", "commit", "-m", "local-only"],
+        cwd=repo,
+        capture_output=True,
+        check=True,
+        env=env,
+    )
+
+    diff = get_uncommitted_diff(repo, base_sha)
+    assert "local.txt" in diff
+    assert "+local change" in diff

{assertion_cli-0.1.0 → assertion_cli-0.2.0}/tests/test_init.py

@@ -114,17 +114,17 @@ def test_init_requires_git_repo(tmp_path: Path, monkeypatch) -> None:
 def test_refresh_skill_files_does_not_touch_activation_files(tmp_path: Path) -> None:
     """`asrt checkpoint` must refresh skill files without dirtying CLAUDE.md / AGENTS.md.
 
-    Customer-authored CLAUDE.md may be tracked in git; silently editing it on every
+    User-authored CLAUDE.md may be tracked in git; silently editing it on every
     checkpoint is hostile. Only `asrt init` is allowed to touch activation blocks.
     """
-    customer_claude = "# My CLAUDE.md\n\nCustom rules.\n"
-    customer_agents = "# Project guidelines\n"
-    (tmp_path / "CLAUDE.md").write_text(customer_claude)
-    (tmp_path / "AGENTS.md").write_text(customer_agents)
+    user_claude = "# My CLAUDE.md\n\nCustom rules.\n"
+    user_agents = "# Project guidelines\n"
+    (tmp_path / "CLAUDE.md").write_text(user_claude)
+    (tmp_path / "AGENTS.md").write_text(user_agents)
 
     main._refresh_skill_files(tmp_path)
 
-    assert (tmp_path / "CLAUDE.md").read_text() == customer_claude
-    assert (tmp_path / "AGENTS.md").read_text() == customer_agents
+    assert (tmp_path / "CLAUDE.md").read_text() == user_claude
+    assert (tmp_path / "AGENTS.md").read_text() == user_agents
     assert (tmp_path / ".claude" / "skills" / "assertion-cli" / "SKILL.md").exists()
     assert (tmp_path / ".agents" / "skills" / "assertion-cli" / "SKILL.md").exists()

{assertion_cli-0.1.0 → assertion_cli-0.2.0}/tests/test_stack_resolve.py

@@ -97,7 +97,7 @@ def test_resolve_errors_when_workspace_has_no_stacks(tmp_path: Path, capsys) ->
         with pytest.raises(typer.Exit):
             resolve_stack_id_for_repo(tmp_path)
     captured = capsys.readouterr()
-    # Distinct message — points the customer at "create a stack", not "attach one"
+    # Distinct message — points the user at "create a stack", not "attach one"
     assert "No verification stacks exist in this workspace" in captured.err
 
 

assertion_cli-0.1.0/README.md

@@ -1,34 +0,0 @@
-# Assertion CLI
-
-CLI for the Assertion API.
-
-## Usage
-
-The CLI currently targets a local backend at `http://localhost:8000`.
-
-Run locally from the workspace:
-
-```bash
-uv run --package assertion-cli asrt --help
-```
-
-Install from Git as a `uv` tool:
-
-```bash
-uv tool install git+ssh://git@github.com/prooflayer-ai/backend.git#subdirectory=cli
-```
-
-The CLI package declares all of its direct runtime dependencies. At the moment
-that set is `httpx`, `pydantic`, and `typer`.
-
-After installation:
-
-```bash
-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
-```
-
-This expects the installer to already have GitHub SSH access to `prooflayer-ai/backend`.