swaitsandClaude Fable 5.1
4774bd9abd
After P5 merged first: a close leads to the audit and the period's attestation, an audit run to its workpaper and the claims behind it, the attest tools to the attestations and the CPA package; a refusal for want of a standing audit is the guard audit_required with books.audit as its remedy; the audit prompt runs the audit tools. policy.cpa_package_requires_audit, unset, refuses once the books hold an audit run and warns before, so a book that has not begun the programme is not stopped from its first handoff by a rule it has not met; set to refuse, it holds from the start. bookspec states B-45 (convention) in its checker. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01HS8WZziDnyxunC23MUxrLp
420 lines
16 KiB
Rust
420 lines
16 KiB
Rust
//! Audits and attestations over the wire (plan P8; rules.md B-45, D-9):
|
|
//! a deterministic run and workpaper, claims weighed against the bar when
|
|
//! asked, the CPA package that waits for a counted audit, and books that
|
|
//! have not declared `audits`.
|
|
//!
|
|
//! Expected behavior comes from `docs/mcp-interface.md` ("Tools — audit
|
|
//! and attestations") and rules.md B-45. Every call goes through a real
|
|
//! books server as an agent reaches it (`common.rs`).
|
|
|
|
mod common;
|
|
|
|
use common::{Books, answer_of};
|
|
use serde_json::{Value, json};
|
|
|
|
/// Cash at 1000, the default 25.00 receipt threshold.
|
|
const SETTINGS: &str = "[company]\nname = \"Audit Co\"\nfiscal_year_start = \"01-01\"\n\
|
|
[books]\ncash_accounts = [\"1000\"]\n";
|
|
|
|
fn chart(w: &mut common::Wire) {
|
|
for (code, name, ty) in [
|
|
("1000", "Cash", "asset"),
|
|
("3000", "Capital", "equity"),
|
|
("4000", "Sales", "revenue"),
|
|
("6000", "Supplies", "expense"),
|
|
] {
|
|
answer_of(&w.call(
|
|
"books.add_account",
|
|
json!({"code": code, "name": name, "account_type": ty}),
|
|
))
|
|
.unwrap();
|
|
}
|
|
}
|
|
|
|
/// A posted entry of `amount` supplies paid from cash on `date`.
|
|
fn post(w: &mut common::Wire, date: &str, what: &str, amount: &str) -> u64 {
|
|
let r = answer_of(&w.call(
|
|
"books.draft_entry",
|
|
json!({"date": date, "description": what, "no_party_reason": "test"}),
|
|
))
|
|
.unwrap();
|
|
let id = r["entry_id"].as_u64().unwrap();
|
|
for (account, side) in [("6000", "debit"), ("1000", "credit")] {
|
|
answer_of(&w.call(
|
|
"books.add_line",
|
|
json!({"entry_id": id, "account": account, "side": side, "amount": amount}),
|
|
))
|
|
.unwrap();
|
|
}
|
|
id
|
|
}
|
|
|
|
fn receipt(w: &mut common::Wire, entry: u64, text: &str) -> u64 {
|
|
let upload = w.upload(text.as_bytes(), "receipt.txt", "text/plain", "receipt");
|
|
answer_of(&w.call(
|
|
"books.attach_receipt",
|
|
json!({"entry_id": entry, "upload_id": upload}),
|
|
))
|
|
.unwrap()["attachment_id"]
|
|
.as_u64()
|
|
.unwrap()
|
|
}
|
|
|
|
fn confirm_post(w: &mut common::Wire, id: u64) {
|
|
let r = answer_of(&w.call(
|
|
"books.post_entry",
|
|
json!({"entry_id": id, "confirmed": true}),
|
|
))
|
|
.unwrap();
|
|
assert_eq!(r["status"], "posted", "{r}");
|
|
}
|
|
|
|
/// Capital in, a 40.00 purchase with its receipt, and a 60.00 one with
|
|
/// none. Returns (receipted entry, its receipt, the bare entry).
|
|
fn setup(tag: &str) -> (Books, common::Wire, u64, u64, u64) {
|
|
let books = Books::with(tag, "USD", Some(SETTINGS));
|
|
let mut w = books.session("p8");
|
|
chart(&mut w);
|
|
let cap = answer_of(&w.call(
|
|
"books.draft_entry",
|
|
json!({"date": "2026-03-01", "description": "Capital", "no_party_reason": "test"}),
|
|
))
|
|
.unwrap()["entry_id"]
|
|
.as_u64()
|
|
.unwrap();
|
|
for (account, side) in [("1000", "debit"), ("3000", "credit")] {
|
|
answer_of(&w.call(
|
|
"books.add_line",
|
|
json!({"entry_id": cap, "account": account, "side": side, "amount": "1000.00"}),
|
|
))
|
|
.unwrap();
|
|
}
|
|
receipt(&mut w, cap, "Opening deposit 1000.00 2026-03-01");
|
|
confirm_post(&mut w, cap);
|
|
let paper = post(&mut w, "2026-03-05", "Printer paper", "40.00");
|
|
let rid = receipt(&mut w, paper, "Printer paper 40.00 2026-03-05");
|
|
confirm_post(&mut w, paper);
|
|
// The 60.00 purchase is posted while the books' receipt threshold was
|
|
// higher, as it could have been before the rule was tightened.
|
|
set_threshold(&mut w, "1000.00");
|
|
let bare = post(&mut w, "2026-03-07", "Toner", "60.00");
|
|
confirm_post(&mut w, bare);
|
|
set_threshold(&mut w, "25.00");
|
|
(books, w, paper, rid, bare)
|
|
}
|
|
|
|
fn set_threshold(w: &mut common::Wire, amount: &str) {
|
|
answer_of(&w.call(
|
|
"books.set_setting",
|
|
json!({"decided_by": "Avery Quill",
|
|
"changes": [{"key": "policy.evidence.threshold", "value": amount}]}),
|
|
))
|
|
.unwrap();
|
|
}
|
|
|
|
fn audit(w: &mut common::Wire, scope: &str, through: &str) -> Value {
|
|
answer_of(&w.call(
|
|
"books.audit",
|
|
json!({"scope": scope, "through": through, "confirmed": true}),
|
|
))
|
|
.unwrap_or_else(|e| panic!("books.audit: {e}"))
|
|
}
|
|
|
|
fn codes(out: &Value) -> Vec<String> {
|
|
out["findings"]
|
|
.as_array()
|
|
.unwrap()
|
|
.iter()
|
|
.map(|f| f["code"].as_str().unwrap().to_string())
|
|
.collect()
|
|
}
|
|
|
|
/// The same books, day and scope give the same run, findings and
|
|
/// workpaper; asking again files and journals nothing; an entry makes it a
|
|
/// new audit.
|
|
#[test]
|
|
fn audit_is_deterministic() {
|
|
let (books, mut w, _, _, bare) = setup("p8-deterministic");
|
|
let preview = answer_of(&w.call(
|
|
"books.audit",
|
|
json!({"scope": "full", "through": "2026-03-31"}),
|
|
))
|
|
.unwrap();
|
|
assert_eq!(preview["status"], "preview");
|
|
assert!(preview["run"].is_null());
|
|
assert!(
|
|
preview["checks"]
|
|
.as_array()
|
|
.unwrap()
|
|
.iter()
|
|
.any(|c| c["code"] == "evidence_missing")
|
|
);
|
|
let first = audit(&mut w, "full", "2026-03-31");
|
|
assert_eq!(first["status"], "audited", "{first}");
|
|
assert!(
|
|
codes(&first).contains(&"evidence_missing".to_string()),
|
|
"the bare 60.00 entry has no receipt: {first}"
|
|
);
|
|
let run = first["run"].clone();
|
|
assert_eq!(run["at_current_head"], true);
|
|
let journal = books.journal();
|
|
let again = audit(&mut w, "full", "2026-03-31");
|
|
assert_eq!(again["status"], "already_run");
|
|
assert_eq!(again["run"]["id"], run["id"]);
|
|
assert_eq!(again["run"]["findings_sha256"], run["findings_sha256"]);
|
|
assert_eq!(again["findings"], first["findings"]);
|
|
assert_eq!(books.journal(), journal, "asking again journals nothing");
|
|
// The workpaper is the same twice, JSON and PDF.
|
|
let id = run["id"].clone();
|
|
let one = answer_of(&w.call("books.workpaper", json!({"id": id}))).unwrap();
|
|
let two = answer_of(&w.call("books.workpaper", json!({"id": id}))).unwrap();
|
|
assert_eq!(one["workpaper"], two["workpaper"]);
|
|
assert_eq!(one["pdf"]["sha256"], two["pdf"]["sha256"]);
|
|
assert_eq!(one["workpaper"]["findings_sha256"], run["findings_sha256"]);
|
|
let pdf = w.fetch(&one["pdf"]);
|
|
assert!(pdf.starts_with(b"%PDF"));
|
|
// The audit fixes nothing and moves no figure; an entry makes it stale.
|
|
let tb = answer_of(&w.call("books.trial_balance", json!({"as_of": "2026-03-31"}))).unwrap();
|
|
assert_eq!(tb["balanced"], true);
|
|
let extra = post(&mut w, "2026-03-09", "Stamps", "10.00");
|
|
confirm_post(&mut w, extra);
|
|
let third = audit(&mut w, "full", "2026-03-31");
|
|
assert_eq!(third["status"], "audited");
|
|
assert_ne!(third["run"]["id"], run["id"]);
|
|
let _ = bare;
|
|
}
|
|
|
|
/// A reading that differs from the entry never counts; one that agrees
|
|
/// counts only at the bar, and the bar is read when asked.
|
|
#[test]
|
|
fn attestations_count_against_the_bar_when_asked() {
|
|
let (_books, mut w, paper, rid, _) = setup("p8-bar");
|
|
let good = answer_of(&w.call(
|
|
"books.attest_receipt",
|
|
json!({"attachment_id": rid, "entry_id": paper, "amount": "40.00", "date": "2026-03-05",
|
|
"method": {"model": "opus", "reasoning_effort": "high"}}),
|
|
))
|
|
.unwrap();
|
|
assert_eq!(good["attestation"]["counted"], true, "{good}");
|
|
assert_eq!(good["attestation"]["by"], "test");
|
|
let wrong = answer_of(&w.call(
|
|
"books.attest_receipt",
|
|
json!({"attachment_id": rid, "entry_id": paper, "amount": "41.00", "date": "2026-03-05",
|
|
"method": {"reasoning_effort": "max", "adversarial": true, "verifier_agents": 5}}),
|
|
))
|
|
.unwrap();
|
|
assert_eq!(wrong["attestation"]["disagrees"], true);
|
|
assert_eq!(wrong["attestation"]["counted"], false);
|
|
assert!(
|
|
wrong["why_not_counted"]
|
|
.as_str()
|
|
.unwrap()
|
|
.contains("differs")
|
|
);
|
|
let low = answer_of(&w.call(
|
|
"books.review_entry",
|
|
json!({"entry_id": paper, "method": {"reasoning_effort": "medium"}}),
|
|
))
|
|
.unwrap();
|
|
assert_eq!(low["attestation"]["counted"], false);
|
|
assert!(low["why_not_counted"].as_str().unwrap().contains("high"));
|
|
let none = answer_of(&w.call("books.review_entry", json!({"entry_id": paper}))).unwrap();
|
|
assert_eq!(none["attestation"]["counted"], false, "no claim, no count");
|
|
let listed = answer_of(&w.call("books.attestations", json!({}))).unwrap();
|
|
assert_eq!(listed["attestations"].as_array().unwrap().len(), 4);
|
|
assert_eq!(listed["counted"], 1);
|
|
assert_eq!(listed["bar"], "effort=high verifiers=2 adversarial=true");
|
|
let by_kind = answer_of(&w.call("books.attestations", json!({"kind": "entry"}))).unwrap();
|
|
assert_eq!(by_kind["attestations"].as_array().unwrap().len(), 2);
|
|
// The bar is read when asked: lowered, the medium review counts.
|
|
answer_of(&w.call(
|
|
"books.set_setting",
|
|
json!({"decided_by": "Avery Quill",
|
|
"changes": [{"key": "policy.attestation_bar", "value": "effort=medium"}]}),
|
|
))
|
|
.unwrap();
|
|
let after = answer_of(&w.call("books.attestations", json!({"kind": "entry"}))).unwrap();
|
|
assert_eq!(after["bar"], "effort=medium verifiers=2 adversarial=true");
|
|
assert_eq!(after["attestations"][0]["counted"], true);
|
|
assert_eq!(after["attestations"][1]["counted"], false);
|
|
// Refused: bad method words, an unposted entry.
|
|
let bad = w.call(
|
|
"books.review_entry",
|
|
json!({"entry_id": paper, "method": {"reasoning_effort": "wild"}}),
|
|
);
|
|
assert!(answer_of(&bad).unwrap_err().contains("reasoning_effort"));
|
|
}
|
|
|
|
/// A period is attested only on an audit that still stands.
|
|
#[test]
|
|
fn a_period_is_attested_on_a_standing_audit() {
|
|
let (_books, mut w, paper, _, _) = setup("p8-period");
|
|
answer_of(&w.call(
|
|
"books.create_period",
|
|
json!({"name": "2026-03", "start": "2026-03-01", "end": "2026-03-31"}),
|
|
))
|
|
.unwrap();
|
|
let method = json!({"reasoning_effort": "high"});
|
|
let none = w.call(
|
|
"books.attest_period",
|
|
json!({"period": "2026-03", "method": method}),
|
|
);
|
|
assert!(answer_of(&none).unwrap_err().contains("books.audit"));
|
|
let run = audit(&mut w, "month", "2026-03-31");
|
|
let ok = answer_of(&w.call(
|
|
"books.attest_period",
|
|
json!({"period": "2026-03", "method": method}),
|
|
))
|
|
.unwrap();
|
|
assert_eq!(ok["attestation"]["audit_run_id"], run["run"]["id"]);
|
|
assert_eq!(
|
|
ok["attestation"]["counted"], true,
|
|
"a month needs the effort only"
|
|
);
|
|
// A change since the audit: refused until it is run again.
|
|
let extra = post(&mut w, "2026-03-20", "Stamps", "5.00");
|
|
confirm_post(&mut w, extra);
|
|
let stale = w.call(
|
|
"books.attest_period",
|
|
json!({"period": "2026-03", "method": method}),
|
|
);
|
|
assert!(answer_of(&stale).unwrap_err().contains("books.audit"));
|
|
let listing = answer_of(&w.call("books.workpaper", json!({"id": run["run"]["id"]}))).unwrap();
|
|
assert_eq!(listing["run"]["at_current_head"], false);
|
|
let _ = paper;
|
|
}
|
|
|
|
/// D-9: the CPA package waits for a counted audit for the handoff; a
|
|
/// reason overrides it and is journaled as a decision; the bar is the
|
|
/// whole bar for a year.
|
|
#[test]
|
|
fn cpa_package_refuses_without_a_counted_audit_unless_a_reason_is_given() {
|
|
let (_books, mut w, paper, rid, bare) = setup("p8-cpa");
|
|
// Unset, the package warns until the books hold an audit run; the
|
|
// owner who wants it refused from the start says so.
|
|
answer_of(&w.call(
|
|
"books.set_setting",
|
|
json!({"decided_by": "Avery Quill",
|
|
"changes": [{"key": "policy.cpa_package_requires_audit", "value": "refuse"}]}),
|
|
))
|
|
.unwrap();
|
|
let export = |w: &mut common::Wire, extra: Value| {
|
|
let mut args = json!({"as_of": "2026-03-31", "cash_accounts": ["1000"],
|
|
"include_receipts": false, "include_tins": false});
|
|
for (k, v) in extra.as_object().unwrap() {
|
|
args[k] = v.clone();
|
|
}
|
|
w.call("books.export_cpa_package", args)
|
|
};
|
|
let refused = export(&mut w, json!({}));
|
|
let err: Value = serde_json::from_str(&answer_of(&refused).unwrap_err()).unwrap();
|
|
assert_eq!(err["code"], "audit_required", "{err}");
|
|
assert_eq!(err["remedy_tool"], "books.audit");
|
|
// A reason lets it go, and is a decision in the journal.
|
|
let before = answer_of(&w.call("books.decisions", json!({}))).unwrap();
|
|
answer_of(&export(
|
|
&mut w,
|
|
json!({"without_audit_reason": " the CPA asked for it early "}),
|
|
))
|
|
.unwrap();
|
|
let after = answer_of(&w.call("books.decisions", json!({}))).unwrap();
|
|
assert_eq!(
|
|
after["decisions"].as_array().unwrap().len(),
|
|
before["decisions"].as_array().unwrap().len() + 1
|
|
);
|
|
assert!(after.to_string().contains("without a counted audit"));
|
|
// An audit alone does not open it; nor one attested below the bar.
|
|
answer_of(&w.call(
|
|
"books.create_period",
|
|
json!({"name": "2026-03", "start": "2026-03-01", "end": "2026-03-31"}),
|
|
))
|
|
.unwrap();
|
|
audit(&mut w, "cpa_handoff", "2026-03-31");
|
|
assert!(answer_of(&export(&mut w, json!({}))).is_err());
|
|
answer_of(&w.call(
|
|
"books.attest_period",
|
|
json!({"period": "2026-03", "method": {"reasoning_effort": "high"}}),
|
|
))
|
|
.unwrap();
|
|
assert!(
|
|
answer_of(&export(&mut w, json!({}))).is_err(),
|
|
"a year-level audit needs the adversarial check and the verifiers"
|
|
);
|
|
answer_of(&w.call(
|
|
"books.attest_period",
|
|
json!({"period": "2026-03", "method": {"reasoning_effort": "high",
|
|
"adversarial": true, "verifier_agents": 2}}),
|
|
))
|
|
.unwrap();
|
|
let made = answer_of(&export(&mut w, json!({}))).unwrap();
|
|
assert!(made["file"]["sha256"].is_string(), "{made}");
|
|
// A change since: the audit no longer stands, and the package waits again.
|
|
let extra = post(&mut w, "2026-03-20", "Stamps", "5.00");
|
|
confirm_post(&mut w, extra);
|
|
assert!(answer_of(&export(&mut w, json!({}))).is_err());
|
|
// Under warn the package is made and says so.
|
|
answer_of(&w.call(
|
|
"books.set_setting",
|
|
json!({"decided_by": "Avery Quill",
|
|
"changes": [{"key": "policy.cpa_package_requires_audit", "value": "warn"}]}),
|
|
))
|
|
.unwrap();
|
|
let warned = answer_of(&export(&mut w, json!({}))).unwrap();
|
|
assert!(
|
|
warned["warnings"]
|
|
.to_string()
|
|
.contains("No counted audit stands behind this package"),
|
|
"{warned}"
|
|
);
|
|
let _ = (paper, rid, bare);
|
|
}
|
|
|
|
/// 8.0.6: books the version before P8 wrote (the fixture `p8_before`)
|
|
/// open with no upgrade; the audit's preview works, its run and every
|
|
/// attestation are refused with format_upgrade_pending, nothing is
|
|
/// journaled, and the CPA package is not held up by an audit it cannot ask
|
|
/// for.
|
|
#[test]
|
|
fn audits_wait_for_the_upgrade() {
|
|
let src = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
|
|
.join("../ledger-store/tests/fixtures/old-books/p8_before");
|
|
let only = tempfile::tempdir().unwrap();
|
|
std::fs::copy(src.join("journal.jsonl"), only.path().join("journal.jsonl")).unwrap();
|
|
common::copy_private(&src.join("blobs"), &only.path().join("blobs"));
|
|
let books = Books::placed("p8-waits", only.path());
|
|
let mut w = books.session("p8");
|
|
let preview = answer_of(&w.call(
|
|
"books.audit",
|
|
json!({"scope": "full", "through": "2026-02-28"}),
|
|
))
|
|
.unwrap();
|
|
assert_eq!(preview["status"], "preview");
|
|
let journal = books.journal();
|
|
for (tool, args) in [
|
|
(
|
|
"books.audit",
|
|
json!({"scope": "full", "through": "2026-02-28", "confirmed": true}),
|
|
),
|
|
(
|
|
"books.review_entry",
|
|
json!({"entry_id": 1, "method": {"reasoning_effort": "high"}}),
|
|
),
|
|
(
|
|
"books.attest_receipt",
|
|
json!({"attachment_id": 1, "entry_id": 1, "amount": "1000.00",
|
|
"date": "2026-01-01"}),
|
|
),
|
|
] {
|
|
let e = answer_of(&w.call(tool, args)).unwrap_err();
|
|
assert!(e.starts_with("format_upgrade_pending"), "{tool}: {e}");
|
|
}
|
|
assert_eq!(books.journal(), journal, "a refusal journals nothing");
|
|
// The package is held up only by what it always was: an open draft.
|
|
let args = json!({"as_of": "2026-01-31", "cash_accounts": ["1000"],
|
|
"include_receipts": false, "include_tins": false});
|
|
let made = answer_of(&w.call("books.export_cpa_package", args)).unwrap();
|
|
assert!(made["file"]["sha256"].is_string(), "{made}");
|
|
let listed = answer_of(&w.call("books.attestations", json!({}))).unwrap();
|
|
assert!(listed["attestations"].as_array().unwrap().is_empty());
|
|
}
|