assertion-cli 0.1.0__py3-none-any.whl

api.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+import os
+from typing import Any, TypeVar
+
+import httpx
+import typer
+from dotenv import find_dotenv, load_dotenv
+from pydantic import BaseModel, ValidationError
+
+from models import (
+    CheckpointResponse,
+    DecisionResponse,
+    ErrorResponse,
+    InitResponse,
+    StatusResponse,
+    VerifyResponse,
+)
+
+T = TypeVar("T", bound=BaseModel)
+
+DEFAULT_BASE_URL = "http://localhost:8000"
+DEFAULT_CHECKPOINT_TIMEOUT_SECONDS = 300.0
+API_TOKEN_ENV = "ASSERTION_API_TOKEN"
+
+# Walk up from cwd looking for a .env so the user can drop their token in the
+# repo root once and forget it. override=False means a real shell `export`
+# still wins over the file — useful for CI.
+_dotenv_path = find_dotenv(usecwd=True)
+if _dotenv_path:
+    load_dotenv(_dotenv_path, override=False)
+
+
+def _base_url() -> str:
+    return os.environ.get("ASSERTION_BASE_URL", DEFAULT_BASE_URL)
+
+
+def _auth_headers() -> dict[str, str]:
+    token = (os.environ.get(API_TOKEN_ENV) or "").strip()
+    if not token:
+        typer.echo(
+            f"Missing {API_TOKEN_ENV}. Generate a token at Settings → Authentication "
+            "in the dashboard, then save it in a .env at your repo root:\n\n"
+            f"  echo '{API_TOKEN_ENV}=alk_...' >> .env\n\n"
+            "(Or export it in your shell.)",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+    return {"Authorization": f"Bearer {token}"}
+
+
+def _parse_response(response: httpx.Response, model: type[T]) -> T:
+    try:
+        return model.model_validate_json(response.text)
+    except ValidationError as exc:
+        raise ValueError(f"Invalid API response: {exc}") from exc
+
+
+def _summarize_error(response: httpx.Response) -> str:
+    try:
+        return ErrorResponse.model_validate_json(response.text).error
+    except ValidationError:
+        body = response.text.strip()
+        return body[:200] if body else "<empty response body>"
+
+
+class AssertionClient:
+    def __init__(self) -> None:
+        self.base_url = _base_url()
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        model: type[T],
+        *,
+        timeout: float = 30.0,
+        **kwargs: Any,
+    ) -> T:
+        url = f"{self.base_url}{path}"
+        headers = {**_auth_headers(), **kwargs.pop("headers", {})}
+        try:
+            response = httpx.request(
+                method, url, timeout=timeout, headers=headers, **kwargs
+            )
+            response.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            summary = _summarize_error(exc.response)
+            typer.echo(
+                f"Request failed with status {exc.response.status_code}: {summary}",
+                err=True,
+            )
+            raise typer.Exit(code=1) from exc
+        except httpx.ReadTimeout as exc:
+            typer.echo(f"Request to {url} timed out after {timeout:.0f}s.", err=True)
+            raise typer.Exit(code=1) from exc
+        except httpx.HTTPError as exc:
+            typer.echo(f"Failed to connect to Assertion API at {url}: {exc}", err=True)
+            raise typer.Exit(code=1) from exc
+
+        try:
+            return _parse_response(response, model)
+        except ValueError as exc:
+            typer.echo(str(exc), err=True)
+            raise typer.Exit(code=1) from exc
+
+    def init(self) -> InitResponse:
+        return self._request("POST", "/api/v0/agent/init", InitResponse, timeout=10.0)
+
+    def _request_no_content(
+        self,
+        method: str,
+        path: str,
+        *,
+        timeout: float = 30.0,
+        **kwargs: Any,
+    ) -> DecisionResponse:
+        url = f"{self.base_url}{path}"
+        headers = {**_auth_headers(), **kwargs.pop("headers", {})}
+        try:
+            response = httpx.request(
+                method, url, timeout=timeout, headers=headers, **kwargs
+            )
+            response.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            summary = _summarize_error(exc.response)
+            typer.echo(
+                f"Request failed with status {exc.response.status_code}: {summary}",
+                err=True,
+            )
+            raise typer.Exit(code=1) from exc
+        except httpx.HTTPError as exc:
+            typer.echo(f"Failed to connect to Assertion API at {url}: {exc}", err=True)
+            raise typer.Exit(code=1) from exc
+
+        return DecisionResponse()
+
+    def stacks(self) -> list:
+        """Fetch available stacks (read-only, no session created)."""
+        from models import VerificationStack
+        from pydantic import TypeAdapter
+
+        url = f"{self.base_url}/api/v0/agent/stacks"
+        try:
+            response = httpx.get(url, timeout=10.0, headers=_auth_headers())
+            response.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            summary = _summarize_error(exc.response)
+            typer.echo(
+                f"Request failed with status {exc.response.status_code}: {summary}",
+                err=True,
+            )
+            raise typer.Exit(code=1) from exc
+        except httpx.HTTPError as exc:
+            typer.echo(f"Failed to connect to Assertion API at {url}: {exc}", err=True)
+            raise typer.Exit(code=1) from exc
+
+        try:
+            adapter = TypeAdapter(list[VerificationStack])
+            return adapter.validate_json(response.text)
+        except Exception as exc:
+            typer.echo(f"Invalid API response: {exc}", err=True)
+            raise typer.Exit(code=1) from exc
+
+    def verify(
+        self,
+        *,
+        stack_id: str,
+        session_id: str,
+        bundle_bytes: bytes,
+    ) -> VerifyResponse:
+        path = f"/api/v0/agent/verify/{stack_id}/{session_id}"
+        return self._request(
+            "POST",
+            path,
+            VerifyResponse,
+            files={"bundle": ("assertion_bundle.zip", bundle_bytes, "application/zip")},
+        )
+
+    def checkpoint(
+        self,
+        *,
+        stack_id: str,
+        session_id: str,
+        bundle_bytes: bytes,
+    ) -> CheckpointResponse:
+        path = f"/api/v0/agent/checkpoint/{stack_id}/{session_id}"
+        return self._request(
+            "POST",
+            path,
+            CheckpointResponse,
+            timeout=DEFAULT_CHECKPOINT_TIMEOUT_SECONDS,
+            files={"bundle": ("assertion_bundle.zip", bundle_bytes, "application/zip")},
+        )
+
+    def decision(self, *, checkpoint_id: str, decision: str) -> DecisionResponse:
+        return self._request_no_content(
+            "POST",
+            f"/api/v0/agent/decision/{checkpoint_id}",
+            json={"decision": decision},
+            timeout=10.0,
+        )
+
+    def status(self, *, session_id: str) -> StatusResponse:
+        return self._request(
+            "POST",
+            "/api/v0/agent/status",
+            StatusResponse,
+            json={"session_id": session_id},
+            timeout=10.0,
+        )

assertion_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: assertion-cli
+Version: 0.1.0
+Summary: CLI for the Assertion API
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: typer>=0.24.1
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Requires-Dist: respx>=0.22; extra == "test"
+
+# 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`.

assertion_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+api.py,sha256=6RuyOoZrsBTY_51XA60iHwkYJ6nqME0CrmDgGaEbWzk,6901
+bundle.py,sha256=e1-a0_hcKG0Xitjq0ac5u7ox3soAiodVbKIf4pRmI4w,828
+git.py,sha256=qcPiQ01DO7joEqzmSIwRkiUekPTF52nwbRATAk5Qqj0,5977
+link.py,sha256=bfH0MhkeTFGbOSJbSvuuw3ilGX3akyvjvCw25AP_fz8,643
+main.py,sha256=Eof43tayPYuSwMiGGKZNPPcIaG_4FHmxdKS3gwakOSg,17308
+models.py,sha256=PQ0q_kUUzRVme325TXB_8eQaNl4LPSuxY8CVy9HK2ls,1678
+session.py,sha256=FfdQqVNhWLBefcdmbuz8xN5KIT4belIeYNX1VTTn1mw,7002
+assertion_cli_templates/ACTIVATION.md,sha256=njAti5gFu3yn91D5dmO8vfiRJ2M337bHXybrxPNWlMk,1439
+assertion_cli_templates/SKILL.md,sha256=Qi8lHaQni0KrjD8O4Bpg43ScXi5rG0b7URe0oDVimfY,12103
+assertion_cli_templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+assertion_cli-0.1.0.dist-info/METADATA,sha256=JWcTQeySngOLykBPQZvhgu08v-ihgGkYX2Zo9LXm1ew,1195
+assertion_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+assertion_cli-0.1.0.dist-info/entry_points.txt,sha256=LgwuPLZEIk-4sD7ghGVRQOhm3PG8sPVozMRxrihwMgU,34
+assertion_cli-0.1.0.dist-info/top_level.txt,sha256=xbZYH9xQOa99z-Vbkc2Xp6h8oUR97DVlyczy8H4ZuFc,64
+assertion_cli-0.1.0.dist-info/RECORD,,

assertion_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

assertion_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+asrt = main:app

assertion_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,8 @@
+api
+assertion_cli_templates
+bundle
+git
+link
+main
+models
+session

assertion_cli_templates/ACTIVATION.md

@@ -0,0 +1,14 @@
+# 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:
+
+- **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.
+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.
+
+Do not open a PR without a clean `asrt verify`.

assertion_cli_templates/SKILL.md

@@ -0,0 +1,177 @@
+---
+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.
+---
+
+# 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.).
+
+This skill is operational, not advisory. Treat each rule as a hard requirement unless the underlying service is unavailable.
+
+## Preflight (one-time per session)
+
+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).
+
+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.
+
+`asrt stacks` is read-only and lists available verification stack IDs. Run it once per session before your first checkpoint so you can pick a stack ID; do not hardcode IDs from memory.
+
+---
+
+## Rule 1 — Log every customer message, immediately
+
+**The first thing you do when a new customer message arrives — before reading any file, planning, or editing anything — is run:**
+
+```
+asrt prompt "<exact text of the customer'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").
+
+**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.
+
+**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.
+- 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 '...'"`.
+
+---
+
+## Rule 2 — Checkpoint at trajectory-feedback moments, not on every change
+
+`asrt checkpoint` is a request for a second opinion from the verifier on your trajectory so far. It is cheap but not free; the right cadence is **a handful of checkpoints across a feature build**, not one per file edit.
+
+**Checkpoint when:**
+- 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.
+
+**Do NOT checkpoint when:**
+- You finished a single file edit.
+- You fixed a typo, renamed a variable, or applied a small refactor inside one feature slice.
+- The next step is mechanical and well-defined.
+- You are stalling because verify is hard — verify is the right command, not more checkpoints.
+
+**Form:**
+
+Every checkpoint:
+```
+asrt checkpoint "<what you built and what you decided>"
+```
+
+You don't need a flag to distinguish "first" from "subsequent" — the CLI does the right thing:
+- 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.
+
+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).
+- `--stack <id>` — force a brand-new session against a specific stack, overwriting any existing one. Only pass this if you deliberately want to abandon the current session.
+
+Use checkpoint messages to summarize substantive progress and decisions since the previous checkpoint — not a changelog of every line touched.
+
+**After each checkpoint response:** read the result. Inspect `checkpoint_id`, the overall approval, and per-model feedback.
+
+- If approved: continue to the next slice.
+- If failed: treat the feedback as authoritative for the next slice of work, address it, then checkpoint again. Do not push toward verify with failing feedback unaddressed.
+- Optionally, after a failed checkpoint, record your sentiment with `asrt decision --yes <checkpoint-id>` (you agree with the feedback) or `asrt decision --no <checkpoint-id>` (you disagree). Do not call `decision` for successful checkpoints.
+
+### Stack selection — handled by the CLI
+
+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
+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
+
+You don't need to do the matching yourself or pass `--stack`. Just call `asrt checkpoint "..."`.
+
+### When `asrt checkpoint` fails because no stack is available
+
+This is the most common failure. The CLI distinguishes three cases — your response is the same shape in all of them:
+
+| CLI error starts with | Meaning |
+|---|---|
+| `No verification stacks exist in this workspace yet.` | Customer 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:
+
+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.
+
+**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.
+
+**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.
+
+### Optional: confirm before you start
+
+If you want to know which stack the CLI *would* pick before running checkpoint (e.g., the work is about to be long and you want to fail-fast on configuration), call `asrt stacks` and look for the line with `[repo: <current-repo-owner/name>]`. You don't have to — `asrt checkpoint` does this internally — but it's available as a read-only check.
+
+---
+
+## Rule 3 — Verify at completion, then iterate or PR
+
+`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.
+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.
+
+`asrt get-link` prints the last session URL (e.g., for inclusion in PR descriptions).
+
+**After verify returns, 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. |
+
+**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.
+
+---
+
+## Quick reference
+
+```
+asrt prompt "<message>"             # every customer 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 get-link                       # retrieve the last session URL
+```
+
+## Environment
+
+- `ASSERTION_BASE_URL` — point the CLI at a non-default backend (default `http://localhost:8000`).
+
+## Non-interactive / harness mode
+
+When running under a non-interactive harness (CI, benchmark runner, scripts):
+
+1. Pass `--json` to `asrt checkpoint` and `asrt verify`. Output is one JSON line per command — parse it; do not regex human text.
+2. Checkpoint response shape: `checkpoint_id`, `outcome` (`succeeded` / `failed`), `reasoning`, `reviews[]`. A non-zero exit code is raised on failed checkpoints, so harnesses can short-circuit on exit status alone.
+3. **Retry-with-feedback loop on a failed checkpoint:**
+   - Read `reasoning` and `reviews[].feedback` from the JSON.
+   - 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.
+
+Do not mix `--json` output with human-rendered output in the same run. Pick one mode and stick with it.

bundle.py

@@ -0,0 +1,26 @@
+import io
+import zipfile
+
+from models import MetadataPayload
+
+ASSERTION_DIR_NAME = ".assertion"
+DIFF_ARCHIVE_PATH = "git.diff"
+METADATA_ARCHIVE_PATH = f"{ASSERTION_DIR_NAME}/metadata.json"
+PROMPTS_ARCHIVE_PATH = f"{ASSERTION_DIR_NAME}/prompts"
+CHECKPOINT_ARCHIVE_PATH = f"{ASSERTION_DIR_NAME}/checkpoint"
+
+
+def build_bundle(
+    *,
+    metadata: MetadataPayload,
+    diff_text: str,
+    prompts_text: str,
+    checkpoint_text: str,
+) -> bytes:
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, mode="w", compression=zipfile.ZIP_DEFLATED) as zf:
+        zf.writestr(METADATA_ARCHIVE_PATH, metadata.model_dump_json(indent=2) + "\n")
+        zf.writestr(PROMPTS_ARCHIVE_PATH, prompts_text)
+        zf.writestr(CHECKPOINT_ARCHIVE_PATH, checkpoint_text)
+        zf.writestr(DIFF_ARCHIVE_PATH, diff_text)
+    return buf.getvalue()