antemortem 0.2.0__tar.gz

antemortem-0.2.0/.gitignore

@@ -0,0 +1,75 @@
+# ── Local prototype workspace (design notes, scratch, not for distribution) ──
+.design/
+.gstack/
+drafts/
+scratch/
+*.draft.md
+
+# ── Python ──
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+# ── Build / dist ──
+build/
+develop-eggs/
+dist/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# ── Virtual environments ──
+.venv/
+venv/
+env/
+ENV/
+
+# ── Packaging / tooling ──
+.uv/
+pip-log.txt
+pip-delete-this-directory.txt
+
+# ── Testing ──
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+.tox/
+.nox/
+coverage.xml
+*.cover
+.cache
+
+# ── Type checking ──
+.mypy_cache/
+.pyre/
+.pytype/
+.ruff_cache/
+
+# ── IDE ──
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# ── OS ──
+.DS_Store
+Thumbs.db
+
+# ── Secrets / local config ──
+.env
+.env.local
+.env.*.local
+*.pem

antemortem-0.2.0/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.2.0] - 2026-04-21
+
+Initial public release of the Antemortem CLI.
+
+### Added
+
+- `antemortem init <name>` — scaffold a new antemortem document from the basic template, or `--enhanced` for the enhanced template (calibration dimensions, fine-grained classification, skeptic pass, decision-first output).
+- `antemortem run <doc>` — run LLM-assisted classification on an antemortem document using Claude Opus 4.7. Reads the spec, traps, and referenced files; returns REAL / GHOST / NEW labels with `file:line` citations; writes a JSON audit artifact.
+- `antemortem lint <doc>` — validate an antemortem document's structured schema and verify all `file:line` citations exist in the current repository. Exit 0 on pass, 1 on fail. Suitable for CI.
+- Embedded templates (basic + enhanced) vendored from [hibou04-ops/Antemortem](https://github.com/hibou04-ops/Antemortem) v0.1.1 under MIT.
+- Pydantic v2 schemas for classifications, new traps, and spec mutations — shared end-to-end across `run` and `lint`.
+- Prompt caching on the system prompt for Claude API calls, targeting the Opus 4.7 4096-token minimum to ensure cache hits.
+
+### Scope boundary — not in v0.2
+
+- Multi-model support (GPT, Gemini, etc.) — intentional, Claude Opus 4.7 only.
+- GitHub Action / CI integration templates — follow in v0.3.
+- HTML report rendering — follow in v0.3.
+- Web dashboard / viewer — out of scope.
+- Database-backed history — out of scope; files only.
+
+### Rationale
+
+Antemortem as a discipline was released as methodology-only in [Antemortem v0.1 / v0.1.1](https://github.com/hibou04-ops/Antemortem). The CLI operationalizes the protocol: scaffold, run, lint — three commands, one week to a disciplined antemortem doc. v0.2 ships the CLI; the methodology repo stays the source of truth for the protocol itself.
+
+[Unreleased]: https://github.com/hibou04-ops/antemortem-cli/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/hibou04-ops/antemortem-cli/releases/tag/v0.2.0

antemortem-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hibou04-ops
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

antemortem-0.2.0/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: antemortem
+Version: 0.2.0
+Summary: CLI for the Antemortem pre-implementation reconnaissance discipline — scaffold, run, and lint antemortem documents with Claude.
+Project-URL: Homepage, https://github.com/hibou04-ops/antemortem-cli
+Project-URL: Repository, https://github.com/hibou04-ops/antemortem-cli
+Project-URL: Methodology, https://github.com/hibou04-ops/Antemortem
+Project-URL: Issues, https://github.com/hibou04-ops/antemortem-cli/issues
+Author: hibou04-ops
+License: MIT License
+        
+        Copyright (c) 2026 hibou04-ops
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: antemortem,anthropic,claude,code-review,pre-mortem,reconnaissance,risk-classification
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.11
+Requires-Dist: anthropic>=0.40.0
+Requires-Dist: pydantic>=2.6.0
+Requires-Dist: python-frontmatter>=1.1.0
+Requires-Dist: typer>=0.12.0
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# antemortem-cli
+
+![License: MIT](https://img.shields.io/badge/license-MIT-yellow.svg)
+![Python](https://img.shields.io/badge/python-3.11%2B-blue.svg)
+![Version](https://img.shields.io/badge/version-0.2.0-blue)
+![Status](https://img.shields.io/badge/status-alpha-orange)
+
+*CLI for the [Antemortem](https://github.com/hibou04-ops/Antemortem) pre-implementation reconnaissance discipline.*
+
+An antemortem is what you do before you build. You put the planned change under stress *on paper*, use an LLM to read the existing code thoroughly, enumerate traps, classify each as REAL / GHOST / NEW with primary-source `file:line` citations, and revise your risk and your spec before writing a single line. This CLI automates the scaffolding, the classification pass, and the schema lint — so the discipline is a single command, not a workflow you have to remember.
+
+The methodology lives at [hibou04-ops/Antemortem](https://github.com/hibou04-ops/Antemortem). This repo is the tooling that runs it.
+
+## Install
+
+```bash
+pip install antemortem
+```
+
+Requires Python 3.11+ and an `ANTHROPIC_API_KEY` environment variable for `run`.
+
+## Three commands
+
+### `antemortem init` — scaffold a document
+
+```bash
+antemortem init my-feature
+# → Created antemortem/my-feature.md (basic template)
+
+antemortem init my-migration --enhanced
+# → Created antemortem/my-migration.md (enhanced template)
+```
+
+Copies the official Antemortem template with YAML frontmatter (`name`, `date`, `scope`, `reversibility`, `status: draft`). Output path: `./antemortem/<name>.md`.
+
+### `antemortem run` — LLM-assisted classification
+
+```bash
+antemortem run antemortem/my-feature.md --repo ../target-repo
+# Reading 6 files from ../target-repo ...
+# Calling claude-opus-4-7 (cached system prompt, 4.2k input / 1.1k output) ...
+# Classified 7 traps: 3 GHOST, 3 REAL, 1 NEW
+# Citations written with file:line references.
+# Updated: antemortem/my-feature.md
+# Artifact: antemortem/my-feature.json
+```
+
+Reads the doc, extracts spec + traps + `files_to_read`, loads files from `--repo`, calls Claude Opus 4.7 with prompt caching on the frozen system prompt (~90% cost reduction on repeated runs), writes classifications back with `file:line` citations. Also emits a JSON artifact for `lint` and downstream tooling.
+
+### `antemortem lint` — validate the schema and citations
+
+```bash
+antemortem lint antemortem/my-feature.md
+# PASS — 7/7 traps classified, 7/7 citations present, 7/7 citations verify file:line.
+
+antemortem lint antemortem/broken.md
+# FAIL:
+#   - trap#3: classification missing
+#   - trap#5: citation format invalid ("see walk_forward.py" → expected "path:line")
+#   - trap#6: cited file antemortem/ghost.py does not exist in --repo
+# exit 1
+```
+
+Validates structured schema (all sections present, classifications complete) and verifies every `file:line` exists on disk. Exit 0 on pass, 1 on fail. Use in CI to block PRs with missing or fabricated citations.
+
+## Model and cost
+
+Uses Claude Opus 4.7 via the Anthropic SDK. Typical cost per `run`:
+
+| Scenario | Cost |
+|---|---|
+| First run (writes system prompt to cache) | ~$0.18 |
+| Cached run (system prompt + files reused within 5 min) | ~$0.11 |
+| 100 iterations during development | $11–18 |
+
+Cache miss indicators are surfaced in the CLI output so silent invalidators (e.g. non-deterministic prompt state) fail loud, not silent.
+
+## Why a CLI (and not just "ask Claude to review my plan")
+
+The discipline is two guardrails:
+
+1. **Enumerate traps before the LLM sees them.** Prevents anchoring on the model's framing. The CLI surfaces this as a required section in the scaffolded document.
+2. **Require `file:line` citations.** Prevents accepting the model's vibes. The CLI enforces this as a Pydantic schema field, and `lint` verifies the citations exist on disk (no hallucinated line numbers).
+
+Without these guardrails, you have traded one form of hand-waving for another.
+
+## Project status
+
+v0.2.0 is the **initial release**. Alpha — API and output formats may change in v0.2.x as prompts iterate on real repos. Semver applies after v1.0.
+
+Full changelog: [CHANGELOG.md](CHANGELOG.md).
+
+## Relation to other projects
+
+- [`Antemortem`](https://github.com/hibou04-ops/Antemortem) — the methodology, templates, and case studies. This CLI implements the `docs/methodology.md` protocol.
+- [`omega-lock`](https://github.com/hibou04-ops/omega-lock) — first shipped case study of the discipline (audit submodule built with a 15-minute antemortem recon). Cited in Antemortem v0.1's case studies.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Citing
+
+```
+Antemortem CLI v0.2 — tooling for the Antemortem pre-implementation reconnaissance discipline.
+https://github.com/hibou04-ops/antemortem-cli, 2026.
+```

antemortem-0.2.0/README.md

@@ -0,0 +1,107 @@
+# antemortem-cli
+
+![License: MIT](https://img.shields.io/badge/license-MIT-yellow.svg)
+![Python](https://img.shields.io/badge/python-3.11%2B-blue.svg)
+![Version](https://img.shields.io/badge/version-0.2.0-blue)
+![Status](https://img.shields.io/badge/status-alpha-orange)
+
+*CLI for the [Antemortem](https://github.com/hibou04-ops/Antemortem) pre-implementation reconnaissance discipline.*
+
+An antemortem is what you do before you build. You put the planned change under stress *on paper*, use an LLM to read the existing code thoroughly, enumerate traps, classify each as REAL / GHOST / NEW with primary-source `file:line` citations, and revise your risk and your spec before writing a single line. This CLI automates the scaffolding, the classification pass, and the schema lint — so the discipline is a single command, not a workflow you have to remember.
+
+The methodology lives at [hibou04-ops/Antemortem](https://github.com/hibou04-ops/Antemortem). This repo is the tooling that runs it.
+
+## Install
+
+```bash
+pip install antemortem
+```
+
+Requires Python 3.11+ and an `ANTHROPIC_API_KEY` environment variable for `run`.
+
+## Three commands
+
+### `antemortem init` — scaffold a document
+
+```bash
+antemortem init my-feature
+# → Created antemortem/my-feature.md (basic template)
+
+antemortem init my-migration --enhanced
+# → Created antemortem/my-migration.md (enhanced template)
+```
+
+Copies the official Antemortem template with YAML frontmatter (`name`, `date`, `scope`, `reversibility`, `status: draft`). Output path: `./antemortem/<name>.md`.
+
+### `antemortem run` — LLM-assisted classification
+
+```bash
+antemortem run antemortem/my-feature.md --repo ../target-repo
+# Reading 6 files from ../target-repo ...
+# Calling claude-opus-4-7 (cached system prompt, 4.2k input / 1.1k output) ...
+# Classified 7 traps: 3 GHOST, 3 REAL, 1 NEW
+# Citations written with file:line references.
+# Updated: antemortem/my-feature.md
+# Artifact: antemortem/my-feature.json
+```
+
+Reads the doc, extracts spec + traps + `files_to_read`, loads files from `--repo`, calls Claude Opus 4.7 with prompt caching on the frozen system prompt (~90% cost reduction on repeated runs), writes classifications back with `file:line` citations. Also emits a JSON artifact for `lint` and downstream tooling.
+
+### `antemortem lint` — validate the schema and citations
+
+```bash
+antemortem lint antemortem/my-feature.md
+# PASS — 7/7 traps classified, 7/7 citations present, 7/7 citations verify file:line.
+
+antemortem lint antemortem/broken.md
+# FAIL:
+#   - trap#3: classification missing
+#   - trap#5: citation format invalid ("see walk_forward.py" → expected "path:line")
+#   - trap#6: cited file antemortem/ghost.py does not exist in --repo
+# exit 1
+```
+
+Validates structured schema (all sections present, classifications complete) and verifies every `file:line` exists on disk. Exit 0 on pass, 1 on fail. Use in CI to block PRs with missing or fabricated citations.
+
+## Model and cost
+
+Uses Claude Opus 4.7 via the Anthropic SDK. Typical cost per `run`:
+
+| Scenario | Cost |
+|---|---|
+| First run (writes system prompt to cache) | ~$0.18 |
+| Cached run (system prompt + files reused within 5 min) | ~$0.11 |
+| 100 iterations during development | $11–18 |
+
+Cache miss indicators are surfaced in the CLI output so silent invalidators (e.g. non-deterministic prompt state) fail loud, not silent.
+
+## Why a CLI (and not just "ask Claude to review my plan")
+
+The discipline is two guardrails:
+
+1. **Enumerate traps before the LLM sees them.** Prevents anchoring on the model's framing. The CLI surfaces this as a required section in the scaffolded document.
+2. **Require `file:line` citations.** Prevents accepting the model's vibes. The CLI enforces this as a Pydantic schema field, and `lint` verifies the citations exist on disk (no hallucinated line numbers).
+
+Without these guardrails, you have traded one form of hand-waving for another.
+
+## Project status
+
+v0.2.0 is the **initial release**. Alpha — API and output formats may change in v0.2.x as prompts iterate on real repos. Semver applies after v1.0.
+
+Full changelog: [CHANGELOG.md](CHANGELOG.md).
+
+## Relation to other projects
+
+- [`Antemortem`](https://github.com/hibou04-ops/Antemortem) — the methodology, templates, and case studies. This CLI implements the `docs/methodology.md` protocol.
+- [`omega-lock`](https://github.com/hibou04-ops/omega-lock) — first shipped case study of the discipline (audit submodule built with a 15-minute antemortem recon). Cited in Antemortem v0.1's case studies.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Citing
+
+```
+Antemortem CLI v0.2 — tooling for the Antemortem pre-implementation reconnaissance discipline.
+https://github.com/hibou04-ops/antemortem-cli, 2026.
+```

antemortem-0.2.0/pyproject.toml

@@ -0,0 +1,80 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "antemortem"
+version = "0.2.0"
+description = "CLI for the Antemortem pre-implementation reconnaissance discipline — scaffold, run, and lint antemortem documents with Claude."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { file = "LICENSE" }
+authors = [
+    { name = "hibou04-ops" },
+]
+keywords = [
+    "antemortem",
+    "reconnaissance",
+    "pre-mortem",
+    "risk-classification",
+    "claude",
+    "anthropic",
+    "code-review",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Quality Assurance",
+]
+dependencies = [
+    "typer>=0.12.0",
+    "pydantic>=2.6.0",
+    "anthropic>=0.40.0",
+    "python-frontmatter>=1.1.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/hibou04-ops/antemortem-cli"
+Repository = "https://github.com/hibou04-ops/antemortem-cli"
+Methodology = "https://github.com/hibou04-ops/Antemortem"
+Issues = "https://github.com/hibou04-ops/antemortem-cli/issues"
+
+[project.scripts]
+antemortem = "antemortem.cli:app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/antemortem"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "src/antemortem",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "pyproject.toml",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+addopts = "-ra -q"
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "N", "UP", "B", "C4", "SIM"]
+ignore = ["E501"]

antemortem-0.2.0/src/antemortem/__init__.py

@@ -0,0 +1,6 @@
+"""Antemortem CLI — tooling for the Antemortem pre-implementation reconnaissance discipline.
+
+See https://github.com/hibou04-ops/Antemortem for the methodology.
+"""
+
+__version__ = "0.2.0"

antemortem-0.2.0/src/antemortem/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for `python -m antemortem`."""
+
+from antemortem.cli import app
+
+if __name__ == "__main__":
+    app()

antemortem-0.2.0/src/antemortem/api.py

@@ -0,0 +1,159 @@
+"""Anthropic Claude API wrapper for the classification step.
+
+The ``run_classification`` function is the single boundary between the CLI
+and the Anthropic SDK. Everything else in the package is framework-free and
+testable without the network. Tests mock the ``client`` argument.
+
+Caching strategy:
+- The system prompt is rendered with ``cache_control={"type": "ephemeral"}``
+  on a top-level system text block. On Opus 4.7 this requires the prompt to
+  exceed the 4096-token cacheable-prefix minimum; we size ``SYSTEM_PROMPT``
+  accordingly and verify via ``usage.cache_read_input_tokens`` on each call.
+- The user payload carries no caching control — it's volatile (different
+  traps each run). A second breakpoint on the files block is a v0.2.1
+  optimization when we add iterative-run UX.
+
+Model and sampling:
+- ``claude-opus-4-7`` is the only supported model in v0.2 (matches Antemortem
+  discipline + enforces a known behavioral contract for the prompt).
+- No ``temperature`` / ``top_p`` / ``top_k`` — removed on Opus 4.7.
+- ``thinking={"type": "adaptive"}`` — off by default on 4.7; explicitly
+  enabled because classification benefits from multi-file chain tracing.
+- ``output_config={"effort": "high"}`` — minimum recommended for
+  intelligence-sensitive work per Anthropic's migration guide.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Protocol
+
+from antemortem.prompts import SYSTEM_PROMPT
+from antemortem.schema import AntemortemOutput
+
+MODEL = "claude-opus-4-7"
+DEFAULT_MAX_TOKENS = 16000
+
+
+class _MessagesNamespace(Protocol):
+    """Duck-typed interface for the subset of ``anthropic.messages`` we use.
+
+    Accepting a Protocol rather than the concrete class keeps the hot path
+    testable without importing ``anthropic`` in unit tests.
+    """
+
+    def parse(self, **kwargs: Any) -> Any: ...  # noqa: D401
+
+
+class _AnthropicLike(Protocol):
+    """Minimal interface we need from an Anthropic client instance."""
+
+    messages: _MessagesNamespace
+
+
+def _build_user_content(
+    spec: str,
+    traps_table_md: str,
+    files: list[tuple[str, str]],
+) -> str:
+    """Render the user-turn payload as the prompt expects."""
+    file_blocks: list[str] = []
+    for path, content in sorted(files, key=lambda item: item[0]):
+        # Normalize path separators so cache keys don't drift on Windows.
+        normalized = path.replace("\\", "/")
+        file_blocks.append(f'<file path="{normalized}">\n{content}\n</file>')
+    files_section = "\n".join(file_blocks)
+    return (
+        f"<files>\n{files_section}\n</files>\n\n"
+        f"<spec>\n{spec.strip()}\n</spec>\n\n"
+        f"<traps>\n{traps_table_md.strip()}\n</traps>"
+    )
+
+
+def _usage_to_dict(usage: Any) -> dict[str, int]:
+    """Extract token counts from the SDK's usage object into a plain dict."""
+    return {
+        "input_tokens": getattr(usage, "input_tokens", 0) or 0,
+        "output_tokens": getattr(usage, "output_tokens", 0) or 0,
+        "cache_creation_input_tokens": getattr(usage, "cache_creation_input_tokens", 0) or 0,
+        "cache_read_input_tokens": getattr(usage, "cache_read_input_tokens", 0) or 0,
+    }
+
+
+def run_classification(
+    client: _AnthropicLike,
+    spec: str,
+    traps_table_md: str,
+    files: list[tuple[str, str]],
+    *,
+    max_tokens: int = DEFAULT_MAX_TOKENS,
+) -> tuple[AntemortemOutput, dict[str, int]]:
+    """Call Claude Opus 4.7 to classify traps against provided files.
+
+    Parameters
+    ----------
+    client:
+        An ``anthropic.Anthropic`` instance (or duck-typed equivalent for
+        tests).
+    spec:
+        Text of the change description from the antemortem document.
+    traps_table_md:
+        The pre-recon Traps table as a markdown string (raw, including
+        header row).
+    files:
+        List of ``(path, content)`` pairs. Sorted internally so cache
+        behavior is deterministic regardless of caller ordering.
+    max_tokens:
+        Upper bound on output tokens. Defaults to 16000 — the ~8k-output
+        typical classification response has ample headroom.
+
+    Returns
+    -------
+    A tuple ``(output, usage)``:
+
+    - ``output``: a validated ``AntemortemOutput`` instance.
+    - ``usage``: ``{"input_tokens", "output_tokens", "cache_creation_input_tokens", "cache_read_input_tokens"}``.
+    """
+    user_content = _build_user_content(spec, traps_table_md, files)
+
+    response = client.messages.parse(
+        model=MODEL,
+        max_tokens=max_tokens,
+        thinking={"type": "adaptive"},
+        output_config={"effort": "high"},
+        system=[
+            {
+                "type": "text",
+                "text": SYSTEM_PROMPT,
+                "cache_control": {"type": "ephemeral"},
+            }
+        ],
+        messages=[{"role": "user", "content": user_content}],
+        output_format=AntemortemOutput,
+    )
+
+    stop_reason = getattr(response, "stop_reason", None)
+    if stop_reason == "refusal":
+        text = ""
+        for block in getattr(response, "content", []) or []:
+            if getattr(block, "type", None) == "text":
+                text = getattr(block, "text", "")
+                break
+        raise RuntimeError(
+            "Claude refused the classification request. This usually means the "
+            "spec or traps contain content flagged by safety filters. "
+            f"Response text: {text!r}"
+        )
+
+    parsed: AntemortemOutput | None = getattr(response, "parsed_output", None)
+    if parsed is None:
+        raise RuntimeError(
+            "SDK returned no parsed_output. This indicates a schema mismatch or "
+            "a malformed response. Raw stop_reason: "
+            f"{stop_reason!r}"
+        )
+    if not isinstance(parsed, AntemortemOutput):
+        # Some SDK versions may pass through a dict — coerce defensively.
+        parsed = AntemortemOutput.model_validate(parsed)
+
+    usage = _usage_to_dict(getattr(response, "usage", None))
+    return parsed, usage