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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertion-cli
-Version: 0.5.7
+Version: 0.5.8
 Summary: CLI for the Assertion API
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
@@ -39,6 +39,8 @@ that set is `httpx`, `pydantic`, `python-dotenv`, and `typer`.
 After installation:
 
 ```bash
+asrt install                           # one-time onboarding: write skill files, AGENTS.md/CLAUDE.md pointer, .gitignore
+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"

{assertion_cli-0.5.7 → assertion_cli-0.5.8}/README.md

@@ -25,6 +25,8 @@ that set is `httpx`, `pydantic`, `python-dotenv`, and `typer`.
 After installation:
 
 ```bash
+asrt install                           # one-time onboarding: write skill files, AGENTS.md/CLAUDE.md pointer, .gitignore
+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"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assertion-cli
-Version: 0.5.7
+Version: 0.5.8
 Summary: CLI for the Assertion API
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
@@ -39,6 +39,8 @@ that set is `httpx`, `pydantic`, `python-dotenv`, and `typer`.
 After installation:
 
 ```bash
+asrt install                           # one-time onboarding: write skill files, AGENTS.md/CLAUDE.md pointer, .gitignore
+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"

{assertion_cli-0.5.7 → assertion_cli-0.5.8}/assertion_cli.egg-info/SOURCES.txt

@@ -13,15 +13,17 @@ assertion_cli.egg-info/dependency_links.txt
 assertion_cli.egg-info/entry_points.txt
 assertion_cli.egg-info/requires.txt
 assertion_cli.egg-info/top_level.txt
+templates/AGENTS.md
 templates/SKILL.md
 templates/__init__.py
 tests/test_api.py
 tests/test_bundle.py
 tests/test_decision.py
 tests/test_git.py
-tests/test_init.py
+tests/test_install.py
 tests/test_link.py
 tests/test_main.py
 tests/test_new.py
 tests/test_prompt.py
-tests/test_session.py
+tests/test_session.py
+tests/test_session_start.py

{assertion_cli-0.5.7 → assertion_cli-0.5.8}/git.py

@@ -10,7 +10,9 @@ def exit_with_error(message: str) -> NoReturn:
     raise typer.Exit(code=1)
 
 
-def run_git_command(repo_root: Path, args: Sequence[str]) -> str:
+def run_git_command(
+    repo_root: Path, args: Sequence[str], *, preserve_stdout: bool = False
+) -> str:
     completed = subprocess.run(
         ["git", *args],
         cwd=repo_root,
@@ -21,7 +23,7 @@ def run_git_command(repo_root: Path, args: Sequence[str]) -> str:
     if completed.returncode != 0:
         message = completed.stderr.strip() or completed.stdout.strip() or "git failed"
         raise RuntimeError(message)
-    return completed.stdout.strip()
+    return completed.stdout if preserve_stdout else completed.stdout.strip()
 
 
 def find_git_root(start_path: Path) -> Path:
@@ -73,15 +75,16 @@ def _build_untracked_diff(repo_root: Path, rel_path: str) -> str:
     if completed.returncode not in (0, 1):
         message = completed.stderr.strip() or completed.stdout.strip() or "git failed"
         raise RuntimeError(message)
-    return completed.stdout.strip()
+    return completed.stdout
 
 
 # Paths the assertion-cli owns end-to-end. Excluded from the diff bundle so
 # reviewers don't flag our own bootstrap files as "unrelated changes" — they're
-# generated/refreshed by `asrt init` and `asrt checkpoint` and have nothing to
-# do with the user's feature work. CLAUDE.md / AGENTS.md are intentionally
-# NOT in this list: the CLI never writes them, so any edits there are the
-# user's own and should flow through to reviewers.
+# generated by `asrt install` and have nothing to do with the user's feature
+# work. CLAUDE.md / AGENTS.md are intentionally NOT in this list: `asrt install`
+# writes a small pointer block into them once at onboarding (meant to be
+# committed before work starts, so it never shows in a work-session diff), but
+# the rest of those files is the user's own and must flow through to reviewers.
 _ASSERTION_EXCLUDED_PATHSPECS = [
     ":(exclude).assertion",
     ":(exclude).claude/skills/assertion-cli",
@@ -100,7 +103,9 @@ def get_uncommitted_diff(repo_root: Path, base_sha: str) -> str:
     """
     try:
         tracked = run_git_command(
-            repo_root, ["diff", base_sha, "--", *_ASSERTION_EXCLUDED_PATHSPECS]
+            repo_root,
+            ["diff", base_sha, "--", *_ASSERTION_EXCLUDED_PATHSPECS],
+            preserve_stdout=True,
         )
 
         untracked_output = run_git_command(
@@ -119,8 +124,15 @@ def get_uncommitted_diff(repo_root: Path, base_sha: str) -> str:
             if rel_path
         ]
 
-        parts = [p for p in [tracked, "\n".join(untracked_diffs)] if p]
-        diff = "\n".join(parts)
-        return diff + "\n" if diff else diff
+        parts = [
+            _ensure_trailing_newline(p)
+            for p in [tracked, *untracked_diffs]
+            if p
+        ]
+        return "".join(parts)
     except RuntimeError as exc:
         exit_with_error(f"Failed to collect git diff: {exc}")
+
+
+def _ensure_trailing_newline(value: str) -> str:
+    return value if value.endswith("\n") else value + "\n"

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

@@ -121,10 +121,11 @@ def _write_full_file(path: Path, content: str, repo_root: Path) -> None:
 
 
 def _refresh_skill_files(repo_root: Path) -> None:
-    """Write/refresh the assertion-owned skill files for each coding agent.
+    """Overwrite the assertion-owned skill files with the bundled template.
 
-    Safe to call on every checkpoint — these files are entirely ours; updating
-    them to match the installed CLI version cannot clobber user content.
+    Called only from `asrt install` (the one-time onboarding step), never on a
+    regular agent run — these files are entirely ours, so writing them to match
+    the installed CLI version cannot clobber user content.
 
     `.claude/skills/`  — Claude Code
     `.agents/skills/`  — Codex + Cursor (Cursor also accepts .cursor/skills/)
@@ -142,6 +143,55 @@ def _refresh_skill_files(repo_root: Path) -> None:
     )
 
 
+# Top-level agent instruction files. Unlike the skill files (which live in
+# agent-owned `*/skills/` dirs), these are user-owned docs that may already hold
+# the user's own content. So we inject an HTML-comment-delimited block rather
+# than overwriting the whole file, and replace just that block on re-install.
+_AGENT_DOC_FILES = ("AGENTS.md", "CLAUDE.md")
+_AGENT_BLOCK_START = "<!-- assertion-cli:start -->"
+_AGENT_BLOCK_END = "<!-- assertion-cli:end -->"
+
+
+def _agent_doc_block() -> str:
+    # No trailing newline: callers add exactly one when assembling the file so
+    # re-installs stay byte-idempotent (a block followed by the original
+    # post-marker text mustn't accumulate blank lines).
+    body = _load_template("AGENTS.md").strip("\n")
+    return f"{_AGENT_BLOCK_START}\n{body}\n{_AGENT_BLOCK_END}"
+
+
+def _upsert_agent_block(path: Path, block: str, repo_root: Path) -> None:
+    """Insert/replace the Assertion block in a user-owned agent doc, idempotently.
+
+    Creates the file from the block if missing; replaces an existing block in
+    place; otherwise appends the block, leaving the user's content untouched.
+    """
+    existing = path.read_text(encoding="utf-8") if path.exists() else ""
+
+    if _AGENT_BLOCK_START in existing and _AGENT_BLOCK_END in existing:
+        pre = existing.split(_AGENT_BLOCK_START, 1)[0]
+        post = existing.split(_AGENT_BLOCK_END, 1)[1]
+        prefix = pre.rstrip("\n") + "\n\n" if pre.strip() else ""
+        new_content = prefix + block + post
+    elif existing.strip():
+        new_content = existing.rstrip("\n") + "\n\n" + block + "\n"
+    else:
+        new_content = block + "\n"
+
+    if existing == new_content:
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(new_content, encoding="utf-8")
+    typer.echo(f"Wrote {path.relative_to(repo_root)}")
+
+
+def _write_agent_docs(repo_root: Path) -> None:
+    """Write the assertion-cli pointer into the top-level agent instruction files."""
+    block = _agent_doc_block()
+    for name in _AGENT_DOC_FILES:
+        _upsert_agent_block(repo_root / name, block, repo_root)
+
+
 _ASSERTION_GITIGNORE_RULES = (".assertion/*", "!.assertion/seed.py")
 
 
@@ -175,30 +225,55 @@ def _ensure_gitignore_limits_assertion_state(repo_root: Path) -> None:
     )
 
 
-@app.command("init")
-def init() -> None:
-    """One-time bootstrap: install the assertion-cli skill files into this repo.
+@app.command("install")
+def install() -> None:
+    """One-time onboarding: scaffold the Assertion skill + agent docs into this repo.
 
-    Writes `.claude/skills/assertion-cli/SKILL.md` and
-    `.agents/skills/assertion-cli/SKILL.md`. Run this once after
-    `uv tool install assertion-cli` so the coding agent (Claude Code, Codex, Cursor)
-    auto-discovers the skill from its skills directory and knows to call `asrt`.
-    `asrt checkpoint` refreshes these skill files on each run so they stay aligned
-    with the installed CLI.
+    Run this once after `uv tool install assertion-cli`. It writes:
 
-    `init` never touches `CLAUDE.md` or `AGENTS.md`. Those are user-owned files;
-    the skill files are auto-discovered without an activation pointer, and editing
-    user-tracked docs would dirty their working tree and leak the assertion
-    bootstrap into the verification diff (which is anchored to the HEAD recorded
-    below).
+      - `.claude/skills/assertion-cli/SKILL.md` and
+        `.agents/skills/assertion-cli/SKILL.md` — the skill the coding agent
+        (Claude Code, Codex, Cursor) auto-discovers so it knows to call `asrt`.
+      - A short assertion-cli pointer block in the top-level `AGENTS.md` and
+        `CLAUDE.md`. These are user-owned, so the block is delimited by HTML
+        comments and re-installs replace just that block — any surrounding
+        content the user wrote is preserved.
+      - `.gitignore` rules that ignore local `.assertion/*` run state while
+        keeping committed seed hooks trackable.
 
-    Also records the current HEAD SHA as the diff base for all future checkpoint/verify
-    calls in this repo. The base is what the backend `git checkout`s against before
-    applying the diff — capturing it once at init means later commands don't need to
-    rediscover it (which previously broke in sandboxes with no remote-tracking refs).
+    This is the onboarding step, not a per-run step: skill files are written
+    here, never on `asrt checkpoint`. After installing, run `asrt session start`
+    to record the diff base for a work session.
     """
     repo_root = find_git_root(Path.cwd())
     _refresh_skill_files(repo_root)
+    _write_agent_docs(repo_root)
+    _ensure_gitignore_limits_assertion_state(repo_root)
+
+    typer.echo("")
+    typer.echo(
+        "Assertion skill installed. To start a work session, run `asrt session start`."
+    )
+
+
+session_app = typer.Typer(help="Manage Assertion work sessions.")
+app.add_typer(session_app, name="session")
+
+
+@session_app.command("start")
+def session_start() -> None:
+    """Record the current HEAD SHA as the diff base for this repo's work session.
+
+    The base is what the backend `git checkout`s against before applying the
+    diff — capturing it once here means later commands don't need to rediscover
+    it (which previously broke in sandboxes with no remote-tracking refs).
+
+    `session start` does not write skill files — that is `asrt install`, the
+    one-time onboarding step. It also never touches user content in `CLAUDE.md` /
+    `AGENTS.md`. It does ensure the `.gitignore` rules exist so the `.assertion`
+    state it writes below stays out of the user's commits.
+    """
+    repo_root = find_git_root(Path.cwd())
     _ensure_gitignore_limits_assertion_state(repo_root)
 
     base_sha = get_head_sha(repo_root)
@@ -296,12 +371,6 @@ def checkpoint(
 
     repo_root = find_git_root(Path.cwd())
 
-    # Refresh the assertion-owned skill files so the agent always loads the
-    # version that ships with the installed CLI. The CLI never writes
-    # CLAUDE.md / AGENTS.md — those are user-owned, and the skill files are
-    # auto-discovered without an activation pointer.
-    _refresh_skill_files(repo_root)
-
     existing_metadata_path = repo_root / ASSERTION_DIR_NAME / METADATA_FILE_NAME
     session_exists = existing_metadata_path.exists()
 
@@ -332,10 +401,10 @@ def checkpoint(
     assert stack_id is not None
 
     append_checkpoint_entry(ctx.checkpoint_path, message)
-    # Base SHA is whatever `asrt init` recorded for this repo. Backend uses
-    # it as the checkout target before applying the diff. Pinning it at init
-    # time (instead of rediscovering per command) means sandboxes without
-    # remote-tracking refs — e.g. Codex Cloud — still work.
+    # Base SHA is whatever `asrt session start` recorded for this repo. Backend
+    # uses it as the checkout target before applying the diff. Pinning it at
+    # session-start time (instead of rediscovering per command) means sandboxes
+    # without remote-tracking refs — e.g. Codex Cloud — still work.
     base_sha = read_init_base_sha(ctx.assertion_dir)
     head_branch = get_head_branch(ctx.repo_root)
     diff_text = get_uncommitted_diff(ctx.repo_root, base_sha)
@@ -436,8 +505,8 @@ def verify(
     ctx, metadata = load_existing_session(Path.cwd())
     stack_id = metadata.stack_id
     assert stack_id is not None
-    # See checkpoint() for why the base is the SHA `asrt init` recorded,
-    # not local HEAD.
+    # See checkpoint() for why the base is the SHA `asrt session start`
+    # recorded, not local HEAD.
     base_sha = read_init_base_sha(ctx.assertion_dir)
     head_branch = get_head_branch(ctx.repo_root)
     diff_text = get_uncommitted_diff(ctx.repo_root, base_sha)

{assertion_cli-0.5.7 → assertion_cli-0.5.8}/models.py

@@ -64,7 +64,7 @@ class ErrorResponse(BaseModel):
 class MetadataPayload(BaseModel):
     """Local on-disk schema for `.assertion/metadata.json`.
 
-    `base_sha` is the diff base (the commit `asrt init` recorded; the commit
+    `base_sha` is the diff base (the commit `asrt session start` recorded; the commit
     the backend checks out before applying the diff). In the bundle sent to
     the backend it is remapped to `head_sha` for wire compatibility — from
     the backend's perspective, after `git checkout <sha>`, that SHA IS its

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

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

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

@@ -17,30 +17,31 @@ BASE_SHA_FILE_NAME = "base_sha"
 
 
 def read_init_base_sha(assertion_dir: Path) -> str:
-    """Return the diff base SHA recorded by `asrt init`.
+    """Return the diff base SHA recorded by `asrt session start`.
 
-    Exits with a clear error if init hasn't been run or the file is empty.
-    The base SHA is the commit the backend `git checkout`s against before
-    applying the diff, so every checkpoint/verify must have it.
+    Exits with a clear error if `asrt session start` hasn't been run or the file
+    is empty. The base SHA is the commit the backend `git checkout`s against
+    before applying the diff, so every checkpoint/verify must have it.
     """
     path = assertion_dir / BASE_SHA_FILE_NAME
     if not path.exists():
         exit_with_error(
-            "No diff base recorded for this repo. Run `asrt init` first — "
-            "it captures the HEAD SHA that checkpoint/verify diff against."
+            "No diff base recorded for this repo. Run `asrt session start` "
+            "first — it captures the HEAD SHA that checkpoint/verify diff against."
         )
     content = path.read_text(encoding="utf-8").strip()
     if not content:
         exit_with_error(
-            f"{path.name} is empty. Re-run `asrt init` to record the diff base."
+            f"{path.name} is empty. Re-run `asrt session start` to record the "
+            "diff base."
         )
     return content
 
 
 def _require_repo_ready(start_path: Path) -> Path:
     repo_root = find_git_root(start_path)
-    # Fail fast if `asrt init` hasn't run — checkpoint/verify need the base
-    # SHA it records before doing any work or making any network calls.
+    # Fail fast if `asrt session start` hasn't run — checkpoint/verify need the
+    # base SHA it records before doing any work or making any network calls.
     read_init_base_sha(repo_root / ASSERTION_DIR_NAME)
     return repo_root
 
@@ -193,8 +194,8 @@ def update_metadata_anchor(
 ) -> MetadataPayload:
     """Refresh the per-session git anchor: diff base + branch name.
 
-    `base_sha` is the diff base (recorded by `asrt init`, same value on every
-    call within a session). `head_branch` is the current local branch — may
+    `base_sha` is the diff base (recorded by `asrt session start`, same value on
+    every call within a session). `head_branch` is the current local branch — may
     legitimately change within a session if the user renames or switches.
     """
     updated = metadata.model_copy(

assertion_cli-0.5.8/templates/AGENTS.md

@@ -0,0 +1,14 @@
+# Assertion verification
+
+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 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.
+2. **Checkpoint at trajectory-feedback moments** with `asrt checkpoint` — a handful across a feature build, not one per file.
+3. **Verify at completion** with `asrt verify`. Once it is clean, open a PR whose body embeds the hidden session marker from `asrt get-link`.
+
+See the skill file for the full rules, edge cases, and the exact PR command.

{assertion_cli-0.5.7 → assertion_cli-0.5.8}/templates/SKILL.md

@@ -14,7 +14,8 @@ This skill is operational, not advisory. Treat each rule as a hard requirement u
 Before any `asrt` call:
 
 - You are inside a git repository.
-- `asrt init` has been run in this repo. It records the current HEAD as the diff base that every checkpoint/verify diffs against, and installs the skill files you are reading right now. If `asrt checkpoint` or `asrt verify` errors with "No diff base recorded", run `asrt init` and retry.
+- `asrt install` has been run once in this repo. It installs the skill files you are reading right now (plus the `AGENTS.md` / `CLAUDE.md` pointer and `.gitignore` rules). This is an onboarding step, not a per-run one.
+- `asrt session start` has been run for this work session. It records the current HEAD as the diff base that every checkpoint/verify diffs against. If `asrt checkpoint` or `asrt verify` errors with "No diff base recorded", run `asrt session start` and retry.
 
 **First command sequence for a new work session:**
 
@@ -118,7 +119,7 @@ When you pass `--stack`, briefly state which stack you chose and why ("Picked st
 | `No session exists yet and no --stack given.` | First checkpoint of a fresh `.assertion/`, but you didn't pick a stack. | Run `asrt stacks`, pick one using the signals above, pass `--stack <id>`. |
 | `This session is already anchored to a stack.` | You passed `--stack` after a session was already created. The CLI locks the stack at session creation. | Drop the `--stack` flag and re-run `asrt checkpoint "<message>"`, or ask the user to run `asrt new` if this should be a fresh session. |
 | `ERROR: Unknown stack '<id>'.` | The `--stack` you passed is not in the workspace. | Re-run `asrt stacks` (the list may have changed) and pass a valid id. |
-| `No diff base recorded for this repo.` | `asrt init` wasn't run. | Run `asrt init` and retry. |
+| `No diff base recorded for this repo.` | `asrt session start` wasn't run. | Run `asrt session start` and retry. |
 | `ERROR: No active session to continue.` | You passed `--continue` but there is no session. | Drop `--continue` and pass `--stack <id>` to start one. |
 
 ---

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

@@ -255,3 +255,57 @@ def test_get_uncommitted_diff_ends_with_newline_when_not_empty(tmp_path: Path) -
     diff2 = get_uncommitted_diff(tmp_path, "HEAD")
     assert diff2 != ""
     assert diff2.endswith("\n"), f"untracked diff should end with newline, got: {diff2[-10:]!r}"
+
+
+def test_get_uncommitted_diff_preserves_trailing_blank_context_lines(
+    tmp_path: Path,
+) -> None:
+    """Blank context lines at EOF are patch content and must not be stripped."""
+    _init_repo_with_commit(tmp_path)
+    source = tmp_path / "crypto.ts"
+    source.write_text(
+        "\n".join(
+            [
+                "const nonce = bytes.slice(0, 12);",
+                "const plaintext = decrypt(oldParams(nonce));",
+                "",
+                "",
+            ]
+        ),
+        encoding="utf-8",
+    )
+    subprocess.run(["git", "add", "crypto.ts"], cwd=tmp_path, check=True)
+    subprocess.run(
+        ["git", "commit", "-m", "add crypto"],
+        cwd=tmp_path,
+        capture_output=True,
+        check=True,
+        env={**GIT_ENV, "HOME": str(tmp_path)},
+    )
+    base_sha = run_git_command(tmp_path, ["rev-parse", "HEAD"])
+
+    source.write_text(
+        "\n".join(
+            [
+                "const nonce = bytes.slice(0, 12);",
+                "const plaintext = decrypt(newParams(nonce));",
+                "",
+                "",
+            ]
+        ),
+        encoding="utf-8",
+    )
+
+    diff = get_uncommitted_diff(tmp_path, base_sha)
+
+    assert diff.endswith(" \n")
+    subprocess.run(["git", "checkout", "--", "crypto.ts"], cwd=tmp_path, check=True)
+    apply_check = subprocess.run(
+        ["git", "apply", "--check", "-"],
+        input=diff,
+        cwd=tmp_path,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert apply_check.returncode == 0, apply_check.stderr

assertion_cli-0.5.8/tests/test_install.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import inspect
+import subprocess
+from pathlib import Path
+
+from typer.testing import CliRunner
+
+import main
+
+
+runner = CliRunner()
+
+
+def _init_repo(tmp_path: Path) -> None:
+    subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
+
+
+def test_install_writes_all_skill_destinations(tmp_path: Path, monkeypatch) -> None:
+    _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    result = runner.invoke(main.app, ["install"])
+    assert result.exit_code == 0, result.stderr
+
+    # Claude Code: skill registry
+    claude_skill = tmp_path / ".claude" / "skills" / "assertion-cli" / "SKILL.md"
+    assert claude_skill.exists()
+    assert "name: assertion-cli" in claude_skill.read_text()
+
+    # Codex + Cursor: shared skill registry, byte-identical
+    agents_skill = tmp_path / ".agents" / "skills" / "assertion-cli" / "SKILL.md"
+    assert agents_skill.exists()
+    assert agents_skill.read_text() == claude_skill.read_text()
+
+
+def test_install_writes_agent_doc_pointers(tmp_path: Path, monkeypatch) -> None:
+    _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    result = runner.invoke(main.app, ["install"])
+    assert result.exit_code == 0, result.stderr
+
+    for name in ("AGENTS.md", "CLAUDE.md"):
+        text = (tmp_path / name).read_text()
+        assert main._AGENT_BLOCK_START in text
+        assert main._AGENT_BLOCK_END in text
+        assert "assertion-cli" in text
+        assert "asrt prompt" in text
+
+
+def test_install_preserves_existing_agent_doc_content(
+    tmp_path: Path, monkeypatch
+) -> None:
+    """install appends its block without clobbering the user's own content."""
+    _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    user_claude = "# My CLAUDE.md\n\nCustom rules.\n"
+    (tmp_path / "CLAUDE.md").write_text(user_claude)
+
+    result = runner.invoke(main.app, ["install"])
+    assert result.exit_code == 0, result.stderr
+
+    text = (tmp_path / "CLAUDE.md").read_text()
+    assert text.startswith(user_claude.rstrip("\n"))
+    assert main._AGENT_BLOCK_START in text
+
+
+def test_install_replaces_stale_block_in_place(tmp_path: Path, monkeypatch) -> None:
+    """Re-installing replaces only the delimited block, not user content."""
+    _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    stale = (
+        "# My doc\n\n"
+        f"{main._AGENT_BLOCK_START}\n"
+        "OLD STALE ASSERTION CONTENT\n"
+        f"{main._AGENT_BLOCK_END}\n\n"
+        "Footer the user wrote.\n"
+    )
+    (tmp_path / "AGENTS.md").write_text(stale)
+
+    result = runner.invoke(main.app, ["install"])
+    assert result.exit_code == 0, result.stderr
+
+    text = (tmp_path / "AGENTS.md").read_text()
+    assert "OLD STALE ASSERTION CONTENT" not in text
+    assert "# My doc" in text
+    assert "Footer the user wrote." in text
+    assert text.count(main._AGENT_BLOCK_START) == 1
+
+
+def test_install_is_idempotent(tmp_path: Path, monkeypatch) -> None:
+    _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    runner.invoke(main.app, ["install"])
+    tracked = [
+        ".claude/skills/assertion-cli/SKILL.md",
+        ".agents/skills/assertion-cli/SKILL.md",
+        "AGENTS.md",
+        "CLAUDE.md",
+    ]
+    snapshots = {p: (tmp_path / p).read_text() for p in tracked}
+
+    runner.invoke(main.app, ["install"])
+    for rel, before in snapshots.items():
+        assert (tmp_path / rel).read_text() == before, rel
+
+
+def test_install_ensures_gitignore(tmp_path: Path, monkeypatch) -> None:
+    _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    result = runner.invoke(main.app, ["install"])
+    assert result.exit_code == 0, result.stderr
+
+    assert (tmp_path / ".gitignore").read_text() == (
+        "# Assertion CLI local state\n.assertion/*\n!.assertion/seed.py\n"
+    )
+
+
+def test_install_records_skill_cleanup_guidance(tmp_path: Path, monkeypatch) -> None:
+    """The installed skill carries the fresh-session cleanup workflow text."""
+    _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    result = runner.invoke(main.app, ["install"])
+    assert result.exit_code == 0, result.stderr
+
+    skill = (tmp_path / ".agents" / "skills" / "assertion-cli" / "SKILL.md").read_text()
+    assert "First command sequence for a new work session" in skill
+    assert (
+        'ask the user: "Do you want to clean up the previous Assertion session '
+        'and start fresh?"'
+    ) in skill
+    assert "Do not run `asrt new` without explicit user consent" in skill
+
+
+def test_install_requires_git_repo(tmp_path: Path, monkeypatch) -> None:
+    monkeypatch.chdir(tmp_path)
+
+    result = runner.invoke(main.app, ["install"])
+    assert result.exit_code == 1
+    assert "git repository" in result.stderr
+
+
+def test_checkpoint_does_not_write_skill_files() -> None:
+    """Skill files are written at install, never on a regular agent run.
+
+    `asrt checkpoint` runs on every trajectory-feedback moment; refreshing the
+    skill files there is exactly the per-run behavior we moved to `asrt install`.
+    """
+    assert "_refresh_skill_files" not in inspect.getsource(main.checkpoint)

assertion_cli-0.5.8/tests/test_session_start.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from typer.testing import CliRunner
+
+import main
+
+
+runner = CliRunner()
+
+
+_GIT_COMMIT_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 _init_repo(tmp_path: Path) -> None:
+    """Init a git repo with an initial commit so `git rev-parse HEAD` works.
+
+    `asrt session start` records HEAD as the diff base, so tests need a
+    resolvable HEAD.
+    """
+    subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
+    subprocess.run(
+        ["git", "commit", "--allow-empty", "-m", "init"],
+        cwd=tmp_path,
+        capture_output=True,
+        check=True,
+        env={**_GIT_COMMIT_ENV, "HOME": str(tmp_path)},
+    )
+
+
+def test_session_start_does_not_write_skill_or_agent_files(
+    tmp_path: Path, monkeypatch
+) -> None:
+    """`asrt session start` is the per-session diff-base step — not scaffolding.
+
+    Skill files and the AGENTS.md / CLAUDE.md pointer are written by
+    `asrt install`, never by `session start` (and never on a regular agent run).
+    """
+    _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    result = runner.invoke(main.app, ["session", "start"])
+    assert result.exit_code == 0, result.stderr
+
+    assert not (tmp_path / ".claude" / "skills" / "assertion-cli" / "SKILL.md").exists()
+    assert not (tmp_path / ".agents" / "skills" / "assertion-cli" / "SKILL.md").exists()
+    assert not (tmp_path / "CLAUDE.md").exists()
+    assert not (tmp_path / "AGENTS.md").exists()
+
+
+def test_session_start_ignores_assertion_state_but_keeps_seed_trackable(
+    tmp_path: Path, monkeypatch
+) -> None:
+    _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    existing_gitignore = "*.pyc\n"
+    (tmp_path / ".gitignore").write_text(existing_gitignore)
+    (tmp_path / ".assertion").mkdir()
+    (tmp_path / ".assertion" / "base_sha").write_text("local state\n")
+    (tmp_path / ".assertion" / "seed.py").write_text(
+        "from assertion_seed import seed\n"
+    )
+
+    result = runner.invoke(main.app, ["session", "start"])
+    assert result.exit_code == 0, result.stderr
+
+    assert (tmp_path / ".gitignore").read_text() == (
+        "*.pyc\n\n# Assertion CLI local state\n.assertion/*\n!.assertion/seed.py\n"
+    )
+
+    ignored_state = subprocess.run(
+        ["git", "check-ignore", ".assertion/base_sha"],
+        cwd=tmp_path,
+        capture_output=True,
+    )
+    trackable_seed = subprocess.run(
+        ["git", "check-ignore", ".assertion/seed.py"],
+        cwd=tmp_path,
+        capture_output=True,
+    )
+    assert ignored_state.returncode == 0
+    assert trackable_seed.returncode == 1
+
+
+def test_session_start_creates_gitignore_for_assertion_state(
+    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 (tmp_path / ".gitignore").read_text() == (
+        "# Assertion CLI local state\n.assertion/*\n!.assertion/seed.py\n"
+    )
+
+
+def test_session_start_preserves_broad_assertion_gitignore_entry(
+    tmp_path: Path, monkeypatch
+) -> None:
+    _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+    (tmp_path / ".gitignore").write_text(".assertion/\n")
+
+    result = runner.invoke(main.app, ["session", "start"])
+    assert result.exit_code == 0, result.stderr
+
+    assert (tmp_path / ".gitignore").read_text() == (
+        ".assertion/\n\n"
+        "# Assertion CLI local state\n"
+        ".assertion/*\n"
+        "!.assertion/seed.py\n"
+    )
+
+
+def test_session_start_adds_only_missing_assertion_gitignore_rules(
+    tmp_path: Path, monkeypatch
+) -> None:
+    _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+    (tmp_path / ".gitignore").write_text("# Assertion CLI local state\n.assertion/*\n")
+
+    result = runner.invoke(main.app, ["session", "start"])
+    assert result.exit_code == 0, result.stderr
+
+    assert (tmp_path / ".gitignore").read_text() == (
+        "# Assertion CLI local state\n.assertion/*\n\n!.assertion/seed.py\n"
+    )
+
+
+def test_session_start_leaves_gitignore_unchanged_when_rules_exist(
+    tmp_path: Path, monkeypatch
+) -> None:
+    _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+    existing_gitignore = (
+        "*.pyc\n\n# Assertion CLI local state\n.assertion/*\n!.assertion/seed.py\n"
+    )
+    (tmp_path / ".gitignore").write_text(existing_gitignore)
+
+    result = runner.invoke(main.app, ["session", "start"])
+    assert result.exit_code == 0, result.stderr
+
+    assert (tmp_path / ".gitignore").read_text() == existing_gitignore
+
+
+def test_session_start_leaves_existing_activation_files_untouched(
+    tmp_path: Path, monkeypatch
+) -> None:
+    """`session start` must not modify user-owned CLAUDE.md / AGENTS.md.
+
+    The base SHA is recorded here, so any edit to user-tracked docs would
+    surface in every checkpoint/verify diff as unrelated bootstrap noise. The
+    assertion-cli pointer block belongs to `asrt install`, committed before work
+    starts.
+    """
+    _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    existing_claude = "# My existing CLAUDE.md\n\nSome custom instructions.\n"
+    existing_agents = "# Project guidelines\n\nLint with ruff.\n"
+    (tmp_path / "CLAUDE.md").write_text(existing_claude)
+    (tmp_path / "AGENTS.md").write_text(existing_agents)
+
+    result = runner.invoke(main.app, ["session", "start"])
+    assert result.exit_code == 0
+
+    assert (tmp_path / "CLAUDE.md").read_text() == existing_claude
+    assert (tmp_path / "AGENTS.md").read_text() == existing_agents
+
+
+def test_session_start_requires_git_repo(tmp_path: Path, monkeypatch) -> None:
+    monkeypatch.chdir(tmp_path)
+
+    result = runner.invoke(main.app, ["session", "start"])
+    assert result.exit_code == 1
+    assert "git repository" in result.stderr
+
+
+def test_session_start_records_head_sha_as_base(tmp_path: Path, monkeypatch) -> None:
+    """`asrt session start` pins the diff base for this repo to current HEAD.
+
+    Every subsequent checkpoint/verify diffs against this SHA, so backend
+    `git checkout` always targets a commit the user/agent has committed at
+    least once locally (and presumably pushed).
+    """
+    _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    result = runner.invoke(main.app, ["session", "start"])
+    assert result.exit_code == 0, result.stderr
+
+    head_sha = subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        cwd=tmp_path,
+        capture_output=True,
+        text=True,
+        check=True,
+    ).stdout.strip()
+
+    base_sha_path = tmp_path / ".assertion" / "base_sha"
+    assert base_sha_path.exists()
+    assert base_sha_path.read_text().strip() == head_sha
+
+
+def test_session_start_errors_when_repo_has_no_commits(
+    tmp_path: Path, monkeypatch
+) -> None:
+    """No HEAD → no base SHA to record → `session start` should fail cleanly."""
+    subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
+    monkeypatch.chdir(tmp_path)
+
+    result = runner.invoke(main.app, ["session", "start"])
+    assert result.exit_code == 1
+    assert not (tmp_path / ".assertion" / "base_sha").exists()

assertion_cli-0.5.7/tests/test_init.py

@@ -1,320 +0,0 @@
-from __future__ import annotations
-
-import subprocess
-from pathlib import Path
-
-from typer.testing import CliRunner
-
-import main
-
-
-runner = CliRunner()
-
-
-_GIT_COMMIT_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 _init_repo(tmp_path: Path) -> None:
-    """Init a git repo with an initial commit so `git rev-parse HEAD` works.
-
-    `asrt init` records HEAD as the diff base, so tests need a resolvable HEAD.
-    """
-    subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
-    subprocess.run(
-        ["git", "commit", "--allow-empty", "-m", "init"],
-        cwd=tmp_path,
-        capture_output=True,
-        check=True,
-        env={**_GIT_COMMIT_ENV, "HOME": str(tmp_path)},
-    )
-
-
-def test_init_writes_all_agent_destinations(tmp_path: Path, monkeypatch) -> None:
-    _init_repo(tmp_path)
-    monkeypatch.chdir(tmp_path)
-
-    result = runner.invoke(main.app, ["init"])
-    assert result.exit_code == 0, result.stderr
-
-    # Claude Code: skill registry
-    claude_skill = tmp_path / ".claude" / "skills" / "assertion-cli" / "SKILL.md"
-    assert claude_skill.exists()
-    assert "name: assertion-cli" in claude_skill.read_text()
-
-    # Codex + Cursor: shared skill registry, byte-identical
-    agents_skill = tmp_path / ".agents" / "skills" / "assertion-cli" / "SKILL.md"
-    assert agents_skill.exists()
-    assert agents_skill.read_text() == claude_skill.read_text()
-
-    # init must never create or touch user-owned CLAUDE.md / AGENTS.md — the
-    # skill files are auto-discovered, and editing user docs would leak the
-    # assertion bootstrap into the verification diff.
-    assert not (tmp_path / "CLAUDE.md").exists()
-    assert not (tmp_path / "AGENTS.md").exists()
-
-
-def test_init_ignores_assertion_state_but_keeps_seed_trackable(
-    tmp_path: Path, monkeypatch
-) -> None:
-    _init_repo(tmp_path)
-    monkeypatch.chdir(tmp_path)
-
-    existing_gitignore = "*.pyc\n"
-    (tmp_path / ".gitignore").write_text(existing_gitignore)
-    (tmp_path / ".assertion").mkdir()
-    (tmp_path / ".assertion" / "base_sha").write_text("local state\n")
-    (tmp_path / ".assertion" / "seed.py").write_text("from assertion_seed import seed\n")
-
-    result = runner.invoke(main.app, ["init"])
-    assert result.exit_code == 0, result.stderr
-
-    assert (tmp_path / ".gitignore").read_text() == (
-        "*.pyc\n\n"
-        "# Assertion CLI local state\n"
-        ".assertion/*\n"
-        "!.assertion/seed.py\n"
-    )
-
-    ignored_state = subprocess.run(
-        ["git", "check-ignore", ".assertion/base_sha"],
-        cwd=tmp_path,
-        capture_output=True,
-    )
-    trackable_seed = subprocess.run(
-        ["git", "check-ignore", ".assertion/seed.py"],
-        cwd=tmp_path,
-        capture_output=True,
-    )
-    assert ignored_state.returncode == 0
-    assert trackable_seed.returncode == 1
-
-
-def test_init_creates_gitignore_for_assertion_state(tmp_path: Path, monkeypatch) -> None:
-    _init_repo(tmp_path)
-    monkeypatch.chdir(tmp_path)
-
-    result = runner.invoke(main.app, ["init"])
-    assert result.exit_code == 0, result.stderr
-
-    assert (tmp_path / ".gitignore").read_text() == (
-        "# Assertion CLI local state\n"
-        ".assertion/*\n"
-        "!.assertion/seed.py\n"
-    )
-
-
-def test_init_preserves_broad_assertion_gitignore_entry_while_adding_missing_rules(
-    tmp_path: Path, monkeypatch
-) -> None:
-    _init_repo(tmp_path)
-    monkeypatch.chdir(tmp_path)
-    (tmp_path / ".gitignore").write_text(".assertion/\n")
-
-    result = runner.invoke(main.app, ["init"])
-    assert result.exit_code == 0, result.stderr
-
-    assert (tmp_path / ".gitignore").read_text() == (
-        ".assertion/\n\n"
-        "# Assertion CLI local state\n"
-        ".assertion/*\n"
-        "!.assertion/seed.py\n"
-    )
-
-
-def test_init_adds_only_missing_assertion_gitignore_rules(
-    tmp_path: Path, monkeypatch
-) -> None:
-    _init_repo(tmp_path)
-    monkeypatch.chdir(tmp_path)
-    (tmp_path / ".gitignore").write_text(
-        "# Assertion CLI local state\n"
-        ".assertion/*\n"
-    )
-
-    result = runner.invoke(main.app, ["init"])
-    assert result.exit_code == 0, result.stderr
-
-    assert (tmp_path / ".gitignore").read_text() == (
-        "# Assertion CLI local state\n"
-        ".assertion/*\n\n"
-        "!.assertion/seed.py\n"
-    )
-
-
-def test_init_leaves_gitignore_unchanged_when_assertion_rules_exist(
-    tmp_path: Path, monkeypatch
-) -> None:
-    _init_repo(tmp_path)
-    monkeypatch.chdir(tmp_path)
-    existing_gitignore = (
-        "*.pyc\n\n"
-        "# Assertion CLI local state\n"
-        ".assertion/*\n"
-        "!.assertion/seed.py\n"
-    )
-    (tmp_path / ".gitignore").write_text(existing_gitignore)
-
-    result = runner.invoke(main.app, ["init"])
-    assert result.exit_code == 0, result.stderr
-
-    assert (tmp_path / ".gitignore").read_text() == existing_gitignore
-
-
-def test_init_skill_prompts_before_new_session_cleanup(
-    tmp_path: Path, monkeypatch
-) -> None:
-    _init_repo(tmp_path)
-    monkeypatch.chdir(tmp_path)
-
-    result = runner.invoke(main.app, ["init"])
-    assert result.exit_code == 0, result.stderr
-
-    skill = (
-        tmp_path / ".agents" / "skills" / "assertion-cli" / "SKILL.md"
-    ).read_text()
-    assert "First command sequence for a new work session" in skill
-    assert (
-        'ask the user: "Do you want to clean up the previous Assertion session '
-        'and start fresh?"'
-    ) in skill
-    assert (
-        "present the question with selectable `Yes` and `No` options"
-    ) in skill
-    assert (
-        "Do not ask the user to type `yes` or `no` unless selectable options "
-        "are unavailable"
-    ) in skill
-    assert (
-        "resolve it before the first `asrt prompt` call, because `asrt new` clears "
-        "the prompts log"
-    ) in skill
-    assert (
-        "If the user answers yes, run `asrt new` before any other `asrt` command"
-    ) in skill
-    assert (
-        "After the reset decision is resolved, immediately log the active user prompt "
-        "with `asrt prompt`"
-    ) in skill
-    assert (
-        "Treat the cleanup confirmation itself as a control response, not user intent "
-        "to record"
-    ) in skill
-    assert (
-        "If the only separate user message during preflight is a plain reset "
-        "confirmation, do not record that confirmation as its own prompt"
-    ) in skill
-    assert "Do not run `asrt new` without explicit user consent" in skill
-    assert "After the PR marker is confirmed" in skill
-    assert "clean up the completed Assertion session" in skill
-
-
-def test_init_is_idempotent(tmp_path: Path, monkeypatch) -> None:
-    _init_repo(tmp_path)
-    monkeypatch.chdir(tmp_path)
-
-    runner.invoke(main.app, ["init"])
-    snapshots = {
-        p: (tmp_path / p).read_text()
-        for p in [
-            ".claude/skills/assertion-cli/SKILL.md",
-            ".agents/skills/assertion-cli/SKILL.md",
-        ]
-    }
-
-    runner.invoke(main.app, ["init"])
-    for rel, before in snapshots.items():
-        assert (tmp_path / rel).read_text() == before, rel
-
-
-def test_init_leaves_existing_activation_files_untouched(
-    tmp_path: Path, monkeypatch
-) -> None:
-    """init must not modify user-owned CLAUDE.md / AGENTS.md, byte for byte.
-
-    Previously init patched a marked activation block into these files. Because
-    the base SHA is recorded at init time, that edit then surfaced in every
-    checkpoint/verify diff as unrelated bootstrap noise. The skill files are
-    auto-discovered, so the activation block is unnecessary.
-    """
-    _init_repo(tmp_path)
-    monkeypatch.chdir(tmp_path)
-
-    existing_claude = "# My existing CLAUDE.md\n\nSome custom instructions.\n"
-    existing_agents = "# Project guidelines\n\nLint with ruff.\n"
-    (tmp_path / "CLAUDE.md").write_text(existing_claude)
-    (tmp_path / "AGENTS.md").write_text(existing_agents)
-
-    result = runner.invoke(main.app, ["init"])
-    assert result.exit_code == 0
-
-    assert (tmp_path / "CLAUDE.md").read_text() == existing_claude
-    assert (tmp_path / "AGENTS.md").read_text() == existing_agents
-
-
-def test_init_requires_git_repo(tmp_path: Path, monkeypatch) -> None:
-    monkeypatch.chdir(tmp_path)
-
-    result = runner.invoke(main.app, ["init"])
-    assert result.exit_code == 1
-    assert "git repository" in result.stderr
-
-
-def test_init_records_head_sha_as_base(tmp_path: Path, monkeypatch) -> None:
-    """`asrt init` pins the diff base for this repo to current HEAD.
-
-    Every subsequent checkpoint/verify diffs against this SHA, so backend
-    `git checkout` always targets a commit the user/agent has committed at
-    least once locally (and presumably pushed).
-    """
-    _init_repo(tmp_path)
-    monkeypatch.chdir(tmp_path)
-
-    result = runner.invoke(main.app, ["init"])
-    assert result.exit_code == 0, result.stderr
-
-    head_sha = subprocess.run(
-        ["git", "rev-parse", "HEAD"],
-        cwd=tmp_path,
-        capture_output=True,
-        text=True,
-        check=True,
-    ).stdout.strip()
-
-    base_sha_path = tmp_path / ".assertion" / "base_sha"
-    assert base_sha_path.exists()
-    assert base_sha_path.read_text().strip() == head_sha
-
-
-def test_init_errors_when_repo_has_no_commits(tmp_path: Path, monkeypatch) -> None:
-    """No HEAD → no base SHA to record → init should fail cleanly."""
-    subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
-    monkeypatch.chdir(tmp_path)
-
-    result = runner.invoke(main.app, ["init"])
-    assert result.exit_code == 1
-    assert not (tmp_path / ".assertion" / "base_sha").exists()
-
-
-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.
-
-    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.
-    """
-    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() == 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()