Cadora · deliverable pack
A run's evidence pack is the checksummed proof a verifier recomputes offline. But the person who signs off on the work usually isn't the verifier — they want the readable story. cadora deliverable turns one archived run into a client-facing delivery report: the persuasive narrative that sits on top of the same tamper-evident evidence, under the same honesty contract, for a different reader.
The run finished green and its evidence pack already exists — report.json, checksums.txt, and a signature — the proof a verifier recomputes. What it doesn't do is read like something you hand a client. Both readers draw from the same archived run; the deliverable is the second surface over the same source of truth.
Same source, same honesty contract, different audience. The deliverable never adds a claim the evidence doesn't already support — it re-reads the pack's structured evidence, it doesn't re-derive anything.
One command reads the archived run and writes deliverable.md — a dependency-free Markdown delivery report. By default it lands beside the run at runs/pr1-verify/ (not inside the evidence pack's report/ — the deliverable is a sibling of the proof, not part of it).
Reads the same archive as cadora report. If the run isn't there you get no such run 'pr1-verify' in runs/ — point --archive-dir at the right directory.
Five sections, always in the same order: Executive summary, What was delivered (a per-node table across the AI-DLC phases), Quality & assurance, Cost (FinOps), and an Evidence appendix that points back at the checksummed pack. Every number is lifted from the archive — nothing is written by hand.
Cadora conducted an AI-DLC pipeline (aidlc-hitl) across 3 nodes on claude. Outcome: ✅ PASS. Total metered cost $0.1873 (1 node(s) priced from the public price table). Gate verdicts — passed: 1. Integrity findings: 0. Human-review decisions: 2.
| Node | Backend | Model | Outcome | Gate | Cost |
|---|---|---|---|---|---|
| requirements | claude | claude-opus-4-8 | ✓ | — | $0.0642 |
| design | claude | claude-opus-4-8 | ✓ | — | $0.0511 |
| construction | claude | claude-sonnet-4-5 | ✓ | passed | $0.0720* |
* = cost estimated from the public price table (backend reported tokens, not dollars).
Total: $0.1873 across 3 nodes, 1 estimated from the price table.
The nodes are the AI-DLC phases — requirements and design (inception), then construction. The table is one row per node; there is no invented per-phase prose, only what the manifest recorded.
The deliverable inherits the evidence pack's honesty contract wholesale. A gate verdict is what the gate returned; a cost is a backend-reported dollar figure or a price-table estimate — and if it's an estimate it carries an *. The report is checksummed, not signed, and it makes no claim about agent honesty beyond what the gates and integrity checks actually verified.
✓ gate verdicts — deterministic, as the gate returned them
✓ integrity findings & human-review decisions — as archived
* per-node cost — backend dollars, or price-table estimate, flagged
· checksummed, not signed — no claim beyond what the gates verified
The * on the construction node's cost isn't decoration — it says that figure came from the public price table (the backend reported tokens, not dollars). Estimates are always marked; nothing is silently rounded into a hard number.
Some stakeholders want a Word document, not Markdown. --docx renders deliverable.docx alongside the Markdown, and --out drops the whole thing into a client-pack directory. The .docx path needs one optional extra — the Markdown core stays dependency-free without it.
The .docx carries the same summary and delivery table as the Markdown — same evidence, a format the client's document folder expects.
The two surfaces don't compete — they're aimed at different desks. Hand the evidence pack to whoever needs to check the work; hand the delivery report to whoever needs to understand and approve it. When a stakeholder wants to go deeper, the appendix points them straight at the pack.
Wants proof, not prose. Recomputes every SHA-256 hash and checks the signature — offline, no live Cadora.
Wants the outcome, the cost, and the assurance in plain language. Reads the narrative; signs off.
The checksummed evidence pack — cadora report / sign / verify — is documented on its own. The deliverable cross-references it (the appendix names it) rather than repeating it.
The frames above reproduce real cadora deliverable output and the exact sections of deliverable.md, rendered as editable HTML rather than raster captures — lift them into Figma or iterate directly. This is Cadora's consulting endgame: the same tamper-evident run, told two ways — a checksummed proof for the verifier, and a readable delivery report for the stakeholder who signs.