py-gzkit 0.18.1__tar.gz

py_gzkit-0.18.1/.agents/skills/airlineops-parity-scan/SKILL.md

@@ -0,0 +1,138 @@
+---
+name: airlineops-parity-scan
+description: Run a repeatable governance parity scan between ../airlineops (canon) and gzkit (extraction).
+category: cross-repository
+lifecycle_state: active
+owner: gzkit-governance
+last_reviewed: 2026-02-18
+---
+
+# SKILL.md
+
+## AirlineOps Parity Scan
+
+Run a repeatable governance parity scan between `../airlineops` (canon) and gzkit (extraction).
+
+## Trigger
+
+- Weekly parity check cadence.
+- Before promoting any pool ADR into active implementation.
+- Any time a canonical GovZero skill/doc changes in AirlineOps.
+
+## Behavior
+
+Produce a dated parity report with explicit gaps, severity, and required ADR/OBPI follow-up.
+Parity is operational, not textual. The scan MUST evaluate behavior/procedure sources across multiple surfaces.
+
+Operational identity rule:
+
+`GovZero = AirlineOps - (AirlineOps product capabilities)`
+
+Treat every AirlineOps process habit/structure/rule as GovZero parity scope unless it is purely product capability behavior.
+
+GovZero mining rule:
+
+- Treat `AGENTS.md`, governance docs, and control-surface directories (`.github/`, `.claude/`, `.codex/`, `.gzkit/`) as first-class GovZero extraction sources.
+- Mine process habits from all of them; do not restrict extraction to one docs subtree.
+
+## Prerequisites
+
+- `../airlineops` exists and is readable.
+- gzkit repo is initialized with `docs/` and `docs/design/`.
+- Use canonical references in `docs/design/lodestar/govzero-doctrine.md`.
+
+## Steps
+
+1. Confirm both repos are present:
+   `test -d ../airlineops && test -d .`
+2. Resolve canonical root deterministically:
+   - explicit override (if provided)
+   - sibling path `../airlineops`
+   - absolute fallback `/Users/jeff/Documents/Code/airlineops`
+   Fail closed if none resolve.
+   Record canonical-root evidence in the parity report.
+3. Read canonical source declarations:
+   `docs/design/lodestar/govzero-doctrine.md`, `docs/design/lodestar/README.md`, `AGENTS.md`.
+4. Build a behavior/procedure source matrix from canonical and extraction surfaces:
+   - Canonical behavior sources (AirlineOps):
+     - `.github/skills/gz-*`
+     - `.github/instructions/*.instructions.md`
+     - `.claude/**`
+     - `.codex/**`
+     - `.gzkit/**`
+     - `AGENTS.md`, `CLAUDE.md`
+     - `docs/governance/GovZero/**/*.md`
+     - operator runbook/proof docs where rituals are declared
+   - gzkit extraction surfaces:
+     - `.github/skills/*`
+     - `.claude/**`
+     - `.codex/**` (if present)
+     - `.gzkit/**`
+     - `AGENTS.md`, `CLAUDE.md`
+     - `docs/governance/GovZero/**/*.md`
+     - `docs/user/commands/*`, `docs/user/concepts/*`, `docs/user/runbook.md`
+     - runtime control surfaces (`src/gzkit/cli.py`, ledger events, validation commands)
+5. Produce a GovZero mining inventory:
+   - list each mined norm/habit
+   - cite source file/path
+   - map to extracted gzkit surface (or mark missing/divergent)
+   - classify confidence and remediation target
+6. Apply parity intake rubric to each candidate import:
+   - Use `docs/governance/parity-intake-rubric.md`
+   - Classify each item as `Import Now`, `Import with Compatibility`, `Defer (Tracked)`, or `Exclude`
+   - Record rationale and runtime/proof backing for the classification
+7. Compare both artifact parity and procedure parity:
+   - artifact parity: presence/path/content
+   - procedure parity: orientation, tool use, post-accounting, validation, verification, presentation, human authority boundaries
+8. Classify each matrix item as:
+   - `Parity`
+   - `Partial`
+   - `Missing`
+   - `Divergent`
+9. Execute and record runnable ritual checks from gzkit surfaces:
+   - `uv run gz cli audit`
+   - `uv run gz check-config-paths`
+   - `uv run gz adr audit-check ADR-<target>`
+   - `uv run mkdocs build --strict`
+10. Write a dated report:
+   `docs/proposals/REPORT-airlineops-parity-YYYY-MM-DD.md`
+   Use `docs/proposals/REPORT-TEMPLATE-airlineops-parity.md`.
+   Also produce mining inventory report:
+   `docs/proposals/REPORT-airlineops-govzero-mining-YYYY-MM-DD.md`
+   Use `docs/proposals/REPORT-TEMPLATE-airlineops-govzero-mining.md`.
+11. For every `Missing`, `Divergent`, or high-impact `Partial` finding:
+   - Propose target SemVer minor
+   - Identify parent ADR and OBPI linkage
+   - Add an explicit next action
+12. Summarize risk:
+   - What blocks 1.0 readiness
+   - What can wait
+   - What must be done next cycle
+13. Enforce action closure for this scan cycle:
+   - For each `Import Now` finding, execute at least one concrete tranche in the
+     same cycle (code/docs/settings change) and record file-level evidence.
+   - If execution cannot happen in-cycle, open a trackable defect (`gh issue create --label defect`)
+     and link it in the report.
+   - A scan with findings but no execution artifact or defect artifact is `INCOMPLETE`.
+
+## Examples
+
+### Example 1
+
+**Input**: "Run the weekly AirlineOps parity scan."
+
+**Output**: `docs/proposals/REPORT-airlineops-parity-2026-02-07.md` with matrix, severity, and action list.
+
+## Constraints
+
+- Do not modify anything in `../airlineops`.
+- Do not claim parity without path-level evidence.
+- Do not claim procedure parity without executable ritual evidence from gzkit runtime/docs surfaces.
+- Do not use patch versions for new feature sequencing.
+- Keep findings actionable: each gap must map to ADR/OBPI follow-up.
+- Do not close a scan cycle with only passive tracking; require execution or a filed defect.
+
+## Related Skills
+
+- gz-adr-create
+- gz-adr-audit

py_gzkit-0.18.1/.agents/skills/format/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: format
+description: Auto-format code with Ruff.
+category: code-quality
+lifecycle_state: active
+owner: gzkit-governance
+last_reviewed: 2026-02-18
+model: haiku
+---
+
+# SKILL.md
+
+## Format
+
+Auto-format code with Ruff.
+
+## Trigger
+
+Before committing changes.
+
+## Behavior
+
+Run `gz format` to fix formatting issues.
+
+## Prerequisites
+
+None
+
+## Steps
+
+1. Step 1
+2. Step 2
+3. Step 3
+
+## Examples
+
+### Example 1
+
+**Input**: Example input
+
+**Output**: Example output
+
+## Constraints
+
+- Constraint 1
+- Constraint 2
+
+## Related Skills
+
+- Skill 1
+- Skill 2

py_gzkit-0.18.1/.agents/skills/git-sync/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: git-sync
+description: Run the guarded repository sync ritual with lint/test gates.
+category: agent-operations
+lifecycle_state: active
+owner: gzkit-governance
+last_reviewed: 2026-02-21
+---
+
+# SKILL.md
+
+## Git Sync
+
+Run the guarded repository sync ritual with lint/test gates.
+
+## Trigger
+
+- User asks to "git sync" or "push with guards"
+- End-of-task reconciliation before handoff
+- Branch drift recovery after remote updates
+
+## Behavior
+
+Use the `gz git-sync` command flow (dry-run first, then apply as requested).
+
+## Prerequisites
+
+- Repository is initialized with `gz init`
+- Current directory is a git worktree
+
+## Steps
+
+1. Preview planned actions:
+   `uv run gz git-sync`
+2. Execute git-only sync when requested:
+   `uv run gz git-sync --apply`
+3. Execute full ritual with quality gates:
+   `uv run gz git-sync --apply --lint --test`
+
+## Examples
+
+### Example 1
+
+**Input**: "git sync"
+
+**Output**: Runs `uv run gz git-sync --apply --lint --test` (or dry-run first if safety confirmation is needed).
+
+## Constraints
+
+- Never use force push in this routine.
+- Resolve blockers (divergence, lint/test failures) before retrying.
+- Use `uv run` invocation style for project commands.
+
+## Related Skills
+
+- `lint`
+- `test`
+- `format`

py_gzkit-0.18.1/.agents/skills/gz-adr-audit/SKILL.md

@@ -0,0 +1,276 @@
+---
+name: gz-adr-audit
+description: Gate-5 audit templates and procedure for ADR verification. GovZero v6 skill.
+category: adr-audit
+compatibility: GovZero v6 framework; provides audit procedure for COMPLETED→VALIDATED ADR transition
+metadata:
+  skill-version: "6.3.0"
+  govzero-framework-version: "v6"
+  govzero-author: "GovZero governance team"
+  govzero-spec-references: "docs/governance/GovZero/charter.md, docs/governance/GovZero/audit-protocol.md"
+  govzero-gates-covered: "Gate 5 (Human Attestation)"
+  govzero_layer: "Layer 2 - Ledger Consumption"
+  trust_model: "Trusts Layer 1 ledger proof; does NOT re-verify evidence"
+gz_command: audit
+invocation: uv run gz audit <adr-id>
+lifecycle_state: active
+owner: gzkit-governance
+last_reviewed: 2026-02-18
+---
+
+# gz-adr-audit
+
+Execute reproducible ADR verification to move from COMPLETED → VALIDATED.
+
+**Two-phase workflow:** See [AGENTS.md](../../../AGENTS.md) § Two-Phase ADR Workflow
+
+---
+
+## Layer 2 Trust Model
+
+This is a **Layer 2** tool — it consumes proof from the ledger rather than re-running verification commands.
+
+**Trust Chain:**
+
+1. **Layer 1 tools** (`gz-obpi-audit`, `gz-adr-verification`) run tests, check coverage, validate evidence
+2. **Layer 1 writes proof** to `logs/obpi-audit.jsonl` with status entries
+3. **This tool reads proof** — if all briefs show PASS/Completed, skip re-verification
+4. **Gate 5 attests** to the presence of proof, not re-execution
+
+**Why trust the ledger?**
+
+- Re-running tests in Layer 2 duplicates Layer 1 work
+- Gate 5's job is to verify *proof exists*, not regenerate proof
+- Human attestation observes artifacts, not re-executes them
+
+**When to force re-verification:**
+
+- If ledger entries are older than 7 days (staleness threshold)
+- If you suspect ledger corruption or tampering
+- If Layer 1 tools have been updated since last audit
+
+In these cases, run `uv run gz audit <adr-id>` first to regenerate ledger proof.
+
+---
+
+## Assets
+
+- `assets/AUDIT_PLAN.template.md` — Plan scaffold (scope, checks, risk focus)
+- `assets/AUDIT.template.md` — Annotation shell (✓/✗/⚠, summary, attestation)
+
+---
+
+## Audit Procedure
+
+**Prerequisite:** ADR is COMPLETED (all briefs done, tests/coverage/docs pass).
+
+### 1. Plan
+
+```bash
+ADR_DIR=docs/design/adr/adr-x.y.x/ADR-x.y.z-slug
+mkdir -p "${ADR_DIR}/audit/proofs"
+```
+
+- Read ADR prose, extract all claims
+- Create `audit/AUDIT_PLAN.md` with checks for each claim
+- Run `uv run gz cli audit` for governance issues
+- Legacy note: `docs/design/audit/**` remains historical only; new audits live under the ADR folder.
+
+### 2. Verify Ledger Completeness
+
+Before running any commands, check ledger proof:
+
+```bash
+uv run gz adr audit-check <adr-id>
+```
+
+**If ledger is complete (all briefs PASS):**
+
+- Skip to Step 3 (Demonstrate Value) — no re-verification needed
+- Trust Layer 1 proof from obpi-audit
+- Record "Ledger proof verified" in audit notes
+
+**If ledger is incomplete or missing:**
+
+- Run: `uv run gz audit <adr-id>`
+- This will audit all briefs and write ledger entries
+- Return to Step 2 after reconciliation
+
+**Force re-verification (optional):**
+
+If you need to regenerate proof (staleness, suspicion, etc.), run the validation commands:
+
+```bash
+uv run -m unittest -q > "${ADR_DIR}/audit/proofs/unittest.txt" 2>&1
+uv run mkdocs build -q > "${ADR_DIR}/audit/proofs/mkdocs.txt" 2>&1
+uv run gz gates --adr <adr-id> > "${ADR_DIR}/audit/proofs/gates.txt" 2>&1
+```
+
+Record ✓/✗/⚠ outcomes for each check.
+
+### 3. Demonstrate Value (MANDATORY)
+
+**An audit that only verifies mechanical checks (tests pass, coverage met) without demonstrating what the ADR delivers is incomplete.**
+
+This step shows the ADR's achieved capabilities through live commands. It answers: "What can the operator do now that they couldn't before?"
+
+**Procedure:**
+
+1. **Summarize the ADR's delivered capabilities** — 3-5 bullet points of what the ADR enables
+2. **Run product surface commands** that exercise each capability:
+   - Use `gz` CLI commands, not ad-hoc scripts
+   - Show actual output (not "tests pass" — show the *feature working*)
+   - For foundation/0.0.x ADRs with no CLI surface: show the tool/library in action via its integration point
+3. **Include a "Feature Demonstration" section in `audit/AUDIT.md`** with:
+   - Each capability named
+   - The command run and representative output
+   - A value summary explaining *why this matters*
+
+**Examples of good demonstrations:**
+
+- Reconciliation ADR → run `uv run gz adr status ADR-<x.y.z>`, show the warnings panel
+- Adapter ADR → run the ingest command, show data flowing through
+- Schema ADR → show validation catching bad input
+
+**Examples of BAD audits (what this step prevents):**
+
+- "121 tests pass, coverage 47%, lint clean" — this is verification, not demonstration
+- Alignment check saying "ALIGNED" without showing the feature running
+- Audit that could apply to *any* ADR because it never mentions this ADR's specific capabilities
+
+**Relationship to closeout ceremony:** If a full closeout ceremony (`/gz-adr-closeout-ceremony`) is being run, its Step 4 (Runbook Walkthrough) satisfies this requirement. If the audit is standalone (no ceremony), this step is mandatory and cannot be skipped.
+
+### 4. Document
+
+Populate `audit/AUDIT.md` with:
+
+- **Feature Demonstration** section (from Step 3 — capabilities, commands, output, value)
+- Execution log (✓/✗/⚠ per check)
+- Evidence index (links to proof files)
+- Summary table (completeness, integrity, alignment)
+
+### 5. Identify Shortfalls
+
+Review for:
+
+- Incomplete implementations (claimed features not shipped)
+- Misalignments (code ≠ docs ≠ tests)
+- Missing value demonstration (feature never shown working)
+- Unexplained anomalies
+
+### 6. Remediate
+
+For each shortfall:
+
+- Severity (blocking/non-blocking)
+- Proposed fix
+- Effort estimate
+
+Implement fixes, re-validate, update `AUDIT.md`.
+
+### 7. Mark VALIDATED
+
+When all shortfalls resolved:
+
+- Sign attestation: human name + date
+- Update ADR: `Status: Validated`
+
+### 8. Emit Validation Receipt
+
+After a successful audit, emit a validation receipt to the ADR ledger for temporal anchoring:
+
+```bash
+# Emit "validated" receipt (after Gate 5 attestation)
+uv run gz adr emit-receipt <adr-id> --event validated \
+  --attestor "human:<name>" \
+  --evidence '{"gate": 5, "tests_passed": true, "coverage_pct": 48.5}'
+
+# Emit "completed" receipt (when marking ADR as Completed, pre-validation)
+uv run gz adr emit-receipt <adr-id> --event completed \
+  --attestor "human:<name>" \
+  --evidence '{"briefs_completed": 6}'
+```
+
+**Rules:**
+
+- **Audit fails → no receipt.** Only emit after all shortfalls are resolved.
+- **Idempotent:** Running twice produces two ledger entries (audit trail preserved).
+- **Git unavailable:** Command warns but returns exit code 0 (doesn't fail the audit).
+
+**Recommended evidence fields:**
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `gate` | int | Gate number (e.g., 5) |
+| `tests_passed` | bool | Whether unit tests passed |
+| `coverage_pct` | float | Coverage percentage |
+| `briefs_completed` | int | Number of briefs completed |
+| `shortfalls_resolved` | int | Number of shortfalls fixed |
+
+---
+
+## Validation Commands
+
+| Type | Command | Layer |
+|------|---------|-------|
+| **Ledger check** | `uv run gz adr audit-check <adr-id>` | L2 |
+| Unit tests | `uv run -m unittest -q` | L1 |
+| Docs build | `uv run mkdocs build -q` | L1 |
+| Governance | `uv run gz cli audit` | L1 |
+| ADR status | `uv run gz adr status <adr-id>` | L1 |
+| Config paths | `uv run gz check-config-paths` | L1 |
+| Heavy gates | `uv run gz gates --adr <adr-id>` | L1 |
+| CLI audit | `uv run gz cli audit` | L1 |
+| OBPI reconcile | `uv run gz audit <adr-id>` | L1+L2 |
+| **Emit receipt** | `uv run gz adr emit-receipt <adr-id> --event validated` | L2 |
+
+**Layer key:** L1 = runs verification, L2 = reads ledger proof
+
+---
+
+## Gate Checklist
+
+**COMPLETED (Phase 1):**
+
+- [ ] All features shipped
+- [ ] Unit tests pass, coverage ≥40%
+- [ ] Docs complete, mkdocs builds clean
+- [ ] Linting/formatting/type checks pass
+
+**VALIDATED (Phase 2):**
+
+- [ ] Audit plan created
+- [ ] All checks executed with proofs
+- [ ] **Value demonstrated** — ADR capabilities shown working with live output
+- [ ] No unresolved ✗ failures
+- [ ] Code matches documentation
+- [ ] Examples are executable
+- [ ] Validation receipt emitted to ledger
+- [ ] Attestation signed
+
+---
+
+## Failure Modes
+
+- **Mechanical-only audit** — tests pass and coverage met but the feature is never demonstrated working. The human cannot assess value from a checklist of green checkmarks alone.
+- Audits drift from template structure
+- No proof artifacts captured
+- Shortfalls not remediated before marking VALIDATED
+- Audit skips Step 3 (Demonstrate Value) and jumps straight to documentation
+
+---
+
+## Relationship to Closeout Ceremony
+
+`gz-adr-audit` and `gz-adr-closeout-ceremony` are **complementary but independent**:
+
+| Concern | gz-adr-audit | gz-adr-closeout-ceremony |
+|---------|-------------|--------------------------|
+| **Focus** | Evidence verification + value demonstration | Human-witnessed runbook walkthrough |
+| **Mode** | Agent-driven with human attestation | Human-driven with agent presenting |
+| **Outputs** | AUDIT.md + proofs/ + ledger entries | Closeout form + attestation record |
+| **Value demo** | Step 3 (agent demonstrates) | Step 4 (human walks through runbook) |
+
+**If both are run:** The closeout ceremony's Step 4 (Runbook Walkthrough) satisfies the audit's Step 3 (Demonstrate Value). No duplication needed.
+
+**If only audit is run:** Step 3 is mandatory. The agent must demonstrate value, not just verify mechanics.

py_gzkit-0.18.1/.agents/skills/gz-adr-audit/assets/AUDIT.template.md

@@ -0,0 +1,92 @@
+# AUDIT TEMPLATE (Gate-5) — Live Annotation
+
+| Field | Value |
+|-------|-------|
+| ADR ID | {{ADR_ID}} |
+| ADR Title | {{ADR_TITLE}} |
+| ADR Dir | {{ADR_DIR}} |
+| Audit Date | {{AUDIT_DATE}} |
+| Auditor(s) | {{AUDITORS}} |
+
+## Feature Demonstration (Step 3 — MANDATORY)
+
+**What does this ADR deliver?** Summarize the capabilities in 3-5 bullets, then demonstrate each.
+
+### Capability 1: (name)
+
+```bash
+$ (command that demonstrates this capability)
+(actual output)
+```
+
+**Why it matters:** (1-2 sentences on the value delivered)
+
+### Capability 2: (name)
+
+```bash
+$ (command)
+(output)
+```
+
+**Why it matters:** (explanation)
+
+### Value Summary
+
+(2-3 sentences: what the operator can do now that they couldn't before)
+
+---
+
+## Execution Log
+
+Annotate each planned check with result symbols:
+
+- ✓ Passed
+- ✗ Failed (include command output snippet + remediation note)
+- ⚠ Warning (non-blocking discrepancy; capture rationale)
+
+| Check | Command / Method | Result | Notes |
+|-------|------------------|--------|-------|
+| (Copy from AUDIT_PLAN) | (exact command run) | __PENDING__ | (results/proof path) |
+| (ADR-specific check 2) | (exact command run) | __PENDING__ | (results/proof path) |
+| (Add rows for all planned checks) | | | |
+
+## Dataset Spot Examples
+
+Paste short console snippets or attach artifact hashes when relevant.
+
+```text
+(Example output from key commands)
+(Or reference: "See {{ADR_DIR}}/audit/proofs/output.txt")
+```
+
+## Summary Table
+
+| Aspect | Status |
+|--------|--------|
+| Implementation Completeness | __PENDING__ |
+| Data Integrity | __PENDING__ |
+| Performance Stability | __PENDING__ |
+| Documentation Alignment | __PENDING__ |
+| Risk Items Resolved | __PENDING__ |
+
+## Evidence Index
+
+List all proof logs saved under `{{ADR_DIR}}/audit/proofs/`.
+
+- {{ADR_DIR}}/audit/proofs/file1.json
+- {{ADR_DIR}}/audit/proofs/file2.txt
+- {{ADR_DIR}}/audit/proofs/chores/
+
+## Recommendations
+
+Document any shortcomings or misimplementations found:
+
+- **Issue 1:** (Description of gap/problem)
+  - **Remedy:** (Recommended fix)
+- **Issue 2:** (If none, state "No blocking issues found")
+
+## Attestation
+
+I/we attest that ADR {{ADR_ID}} is implemented as intended, evidence is reproducible, and no blocking discrepancies remain.
+
+Signed: _<human names & date>_

py_gzkit-0.18.1/.agents/skills/gz-adr-audit/assets/AUDIT_PLAN.template.md

@@ -0,0 +1,64 @@
+# AUDIT PLAN TEMPLATE (Gate-5) — Replace Placeholders
+
+| Field | Value |
+| ----- | ----- |
+| ADR ID | {{ADR_ID}} |
+| ADR Title | {{ADR_TITLE}} |
+| SemVer | {{SEMVER}} |
+| ADR Dir | {{ADR_DIR}} |
+| Audit Date | {{AUDIT_DATE}} |
+| Auditor(s) | {{AUDITORS}} |
+
+## Purpose
+
+Confirm {{ADR_ID}} implementation is complete by validating its claims with reproducible CLI evidence.
+
+**Audit Trigger:** (e.g., post-implementation stability check, pre-release confirmation, Gate-5 validation)
+
+## Scope & Inputs
+
+**Primary contract surfaces:**
+
+List the specific CLI commands, reporter surfaces, or behaviors that this ADR introduces or modifies.
+
+Example (adapt to ADR):
+
+- `uv run -m airlineops reporter <feature> ...`
+- Config sources: `config/settings.json`, `config/calendars.json`
+- Registry/manifest: `data/data_sources.json`
+
+**System health surfaces (use when relevant):**
+
+- `uv run -m airlineops reporter status`
+- `uv run -m airlineops reporter contract horizon`
+- `uv run -m airlineops reporter manifest status`
+- `uv run -m airlineops reporter registrar --format console`
+
+## Planned Checks
+
+| Check | Command / Method | Expected Signal | Status (Planned) |
+|-------|------------------|-----------------|------------------|
+| (ADR-specific check 1) | (command) | (expected outcome) | Pending |
+| (ADR-specific check 2) | (command) | (expected outcome) | Pending |
+| Docs build (if docs changed) | `uv run mkdocs build -q -f mkdocs.yml` | Build clean | Pending |
+| Markdown lint (if docs changed) | `uv run gz md-docs` | Zero violations | Pending |
+| (Add more checks as needed) | | | Pending |
+
+## Risk Focus
+
+Highlight higher-risk seams (e.g., new flags, calendar normalization, receipt immutability).
+
+## Findings Placeholder
+
+Will be captured in `AUDIT.md` — do not populate here beyond structural notes.
+
+## Acceptance Criteria
+
+- All Planned Checks executed; results recorded in `audit/AUDIT.md` with ✓/✗/⚠.
+- Proof logs saved under `{{ADR_DIR}}/audit/proofs/` and referenced in `audit/AUDIT.md` (co-located, committed).
+- ADR present in index/status with correct state; backlinks maintained when applicable.
+- No edits to accepted ADR prose; hygiene via follow-up ADR if required.
+
+## Attestation Placeholder
+
+Human will complete in `AUDIT.md` with final ✓ summary.