config, mcp, gui: specs from sources, spec-blind suites, and the bugs they found

ledger-config: parse gets a sourced spec. A fiscal year starts on the
first of a month (IRS Pub. 538); tax_classification is read by whole
words (Treas. Reg. 301.7701-3, Schedule C instructions; "business corp"
no longer reads as an S corp, "corporation or S corporation" is refused);
duplicate or blank members and shared capital accounts are refused; a
negative or non-grammatical receipt threshold is refused; codes trimmed.
tests/spec_config.rs (65 spec-blind tests, 14 properties), fuzz target
fuzz_config_parse (weekly). Mutation: 55 of 55 viable caught (from 25/38).

The receipt policy moves to ledger-config, with one loader
(effective_receipt_policy) and one decimal grammar, so the server and
the viewer enforce and show the same rule (the viewer had its own: only
expense-like debits, a silent $25 default, and no config.json).

ledger-mcp: a module spec (MCP 2025-06-18 tools, JSON-RPC 2.0, the
operating contract). Amounts in are exactly -?digits[.digits]; a number
that is one account's code and another's id (vendors, classes alike) is
refused, not guessed; the threshold is validated at startup. Fixed:
add_line with a bad class journaled the line before refusing;
profit_and_loss_by_class ignored `class`; aging buckets said "0". A wire
in front of rmcp answers malformed JSON with -32700 and invalid requests
with -32600 and their id (rmcp dropped the first, omitted the id).
tests/spec_mcp.rs (26 spec-blind tests: every tool's result against its
own outputSchema, a random-call state machine checking the journal is
untouched by every refusal, amount grammar, previews, the receipt policy).

ledger-gui: money, accounting, and dollars never round (they rounded to
cents, banker's style); export file names avoid Windows device names,
trailing dots and spaces, empty names, and 255-byte overflow; specs on
attention, history, fuzzy search, and axis ticks.

ledger-core: the lifetime profit_and_loss is renamed unclosed_earnings
(docs/testing.md #3).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GWVo7x3UHw5kwCUaWxiejX

crates/ledger-core/src/classes.rs

@@ -180,7 +180,7 @@ mod tests {
         assert_eq!((z.revenue, z.expenses), (Decimal::ZERO, Decimal::ZERO));
         // None counts every line: identical to the account-based P&L.
         let all = crate::reports::profit_and_loss_filtered(&ledger, None).unwrap();
-        let plain = crate::reports::profit_and_loss(&ledger).unwrap();
+        let plain = crate::reports::unclosed_earnings(&ledger).unwrap();
         assert_eq!((all.revenue, all.expenses), (plain.revenue, plain.expenses));
         assert_eq!((all.revenue, all.expenses), (d(170_000), d(55_000)));
     }
@@ -205,7 +205,7 @@ mod tests {
         assert_eq!(rows[1].profit_and_loss.net_income(), d(40_000));
         assert_eq!(rows[2].profit_and_loss.net_income(), d(15_000));
         // The rows partition the ledger: they sum to the total P&L.
-        let total = crate::reports::profit_and_loss(&ledger).unwrap();
+        let total = crate::reports::unclosed_earnings(&ledger).unwrap();
         let rev: Decimal = rows.iter().map(|r| r.profit_and_loss.revenue).sum();
         let exp: Decimal = rows.iter().map(|r| r.profit_and_loss.expenses).sum();
         assert_eq!((rev, exp), (total.revenue, total.expenses));

crates/ledger-core/src/lib.rs

@@ -12,7 +12,7 @@
 //! * All mutations go through [`Ledger`] commands (`create_entry`, `add_line`,
 //!   `post_entry`, `reverse_entry`). Posted entries are immutable; corrections
 //!   are reversing entries.
-//! * Reports ([`trial_balance`](reports::trial_balance), [`balance_sheet`](reports::balance_sheet), [`profit_and_loss`](reports::profit_and_loss)) are
+//! * Reports ([`trial_balance`](reports::trial_balance), [`balance_sheet`](reports::balance_sheet), [`unclosed_earnings`](reports::unclosed_earnings)) are
 //!   pure functions of a ledger, which is what makes the semantic oracle
 //!   (`docs/oracle.md`) possible.
 

crates/ledger-core/src/reports.rs

@@ -126,8 +126,9 @@ fn trial_balance_where(ledger: &Ledger, include: &dyn Fn(&JournalEntry) -> bool)
     }
 }
 
-/// Profit and loss: revenue and expenses for the life of the ledger. For a
-/// date range, with a line per account, use [`profit_and_loss_for_period`].
+/// Revenue and expense totals: from [`unclosed_earnings`], what the books
+/// hold now (closed periods already moved to equity); for a date range,
+/// with a line per account, use [`profit_and_loss_for_period`].
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct ProfitAndLoss {
     /// Total revenue (credit-normal balances, reported positive).
@@ -143,15 +144,19 @@ impl ProfitAndLoss {
     }
 }
 
-/// Build the profit and loss statement from all posted entries.
-pub fn profit_and_loss(ledger: &Ledger) -> Result<ProfitAndLoss, LedgerError> {
+/// Earnings not yet closed: revenue and expenses over every posted entry,
+/// closing entries included, so a closed period's income (already moved
+/// to equity) nets out. This is the balance sheet's current-earnings line,
+/// not a profit and loss for any period (docs/testing.md #3; OpenStax,
+/// Principles of Financial Accounting 5.1).
+pub fn unclosed_earnings(ledger: &Ledger) -> Result<ProfitAndLoss, LedgerError> {
     profit_and_loss_filtered(ledger, None)
 }
 
 /// Build the profit and loss statement, optionally filtered to one class.
 ///
 /// With `None` every line counts and the result is identical to
-/// [`profit_and_loss`]. With `Some(class)` only lines tagged with that
+/// [`unclosed_earnings`]. With `Some(class)` only lines tagged with that
 /// class count. Unlike the account-at-a-time accumulation this works line
 /// by line, because classes live on lines: each line contributes its signed
 /// amount (positive on the account's normal side) to its account type's
@@ -181,7 +186,7 @@ pub struct ClassProfitAndLoss {
 /// sorted by class name; the unclassified row comes last.
 ///
 /// The rows partition the ledger: summing every row's revenue and expenses
-/// reproduces [`profit_and_loss`].
+/// reproduces [`unclosed_earnings`].
 ///
 /// ```text
 /// GOAL: a profit and loss per class (department, location, job), plus the
@@ -313,7 +318,7 @@ pub fn balance_sheet(ledger: &Ledger) -> Result<BalanceSheet, LedgerError> {
             AccountType::Revenue | AccountType::Expense => {}
         }
     }
-    let current_earnings = profit_and_loss(ledger)?.net_income();
+    let current_earnings = unclosed_earnings(ledger)?.net_income();
     equity += current_earnings;
     Ok(BalanceSheet {
         assets,
@@ -1031,7 +1036,7 @@ pub fn members_equity(
 /// ```
 pub fn snapshot(ledger: &Ledger) -> Result<serde_json::Value, LedgerError> {
     let tb = trial_balance(ledger);
-    let pl = profit_and_loss(ledger)?;
+    let pl = unclosed_earnings(ledger)?;
     let bs = balance_sheet(ledger)?;
     Ok(serde_json::json!({
         "trial_balance": {

crates/ledger-core/tests/invariants.rs

@@ -10,7 +10,7 @@
 //! semantic oracle (see `docs/oracle.md`).
 
 use chrono::NaiveDate;
-use ledger_core::reports::{balance_sheet, profit_and_loss, snapshot, trial_balance};
+use ledger_core::reports::{balance_sheet, snapshot, trial_balance, unclosed_earnings};
 use ledger_core::{
     AccountId, AccountType, ChartOfAccounts, Currency, EntryStatus, JournalEntry, Ledger,
     LedgerError, Money, Side,
@@ -565,7 +565,7 @@ fn accounting_equation_holds() {
 #[test]
 fn profit_and_loss_is_correct() {
     let c = fixture_company();
-    let pl = profit_and_loss(&c.ledger).unwrap();
+    let pl = unclosed_earnings(&c.ledger).unwrap();
     assert_eq!(pl.revenue, Decimal::from(4_000));
     assert_eq!(pl.expenses, Decimal::from(800));
     assert_eq!(pl.net_income(), Decimal::from(3_200));

crates/ledger-core/tests/properties.rs

@@ -10,8 +10,8 @@ use ledger_core::{
     AccountType, Currency, Ledger, Money, NewAsset, Side, accumulated_depreciation, book_value,
     depreciation_schedule,
     reports::{
-        balance_sheet, balance_sheet_as_of, profit_and_loss, profit_and_loss_for_period,
-        trial_balance,
+        balance_sheet, balance_sheet_as_of, profit_and_loss_for_period, trial_balance,
+        unclosed_earnings,
     },
 };
 use proptest::prelude::*;
@@ -157,7 +157,7 @@ proptest! {
         let (r2, e2) = rest.map_or((Decimal::ZERO, Decimal::ZERO), |p| (p.total_revenue, p.total_expenses));
         prop_assert_eq!(first.total_revenue + r2, whole.total_revenue);
         prop_assert_eq!(first.total_expenses + e2, whole.total_expenses);
-        let all = profit_and_loss(&ledger).unwrap();
+        let all = unclosed_earnings(&ledger).unwrap();
         prop_assert_eq!((whole.total_revenue, whole.total_expenses), (all.revenue, all.expenses));
     }
 

crates/ledger-core/tests/spec_reports.rs

@@ -11,7 +11,7 @@
 use std::collections::{BTreeMap, BTreeSet};
 
 use chrono::{Days, NaiveDate};
-use ledger_core::reports::{profit_and_loss, profit_and_loss_by_class, snapshot, trial_balance};
+use ledger_core::reports::{profit_and_loss_by_class, snapshot, trial_balance, unclosed_earnings};
 use ledger_core::{
     AccountId, AccountType, BalanceSheetStatement, CashFlowParams, CashFlowStatement, ClassId,
     CloseTo, Currency, EntryId, GeneralLedger, Ledger, MemberCapital, MemberClose,
@@ -651,7 +651,7 @@ fn pnl_by_class_rows_sorted_by_name_unclassified_last() {
             (None, c(0), c(3000)),
         ]
     );
-    let whole = profit_and_loss(&co.l).unwrap();
+    let whole = unclosed_earnings(&co.l).unwrap();
     assert_eq!(whole.revenue, c(15000));
     assert_eq!(whole.expenses, c(5000));
 }
@@ -2134,7 +2134,7 @@ proptest! {
     fn prop_pnl_by_class_rows_sum_to_whole(gens in arb_books()) {
         let b = build_ordered(&gens, 1, &(0..N).collect::<Vec<_>>(), true);
         let rows = profit_and_loss_by_class(&b.l).unwrap();
-        let whole = profit_and_loss(&b.l).unwrap();
+        let whole = unclosed_earnings(&b.l).unwrap();
         prop_assert_eq!(rows.iter().map(|r| r.profit_and_loss.revenue).sum::<Decimal>(), whole.revenue);
         prop_assert_eq!(rows.iter().map(|r| r.profit_and_loss.expenses).sum::<Decimal>(), whole.expenses);
         let (wr, we) = model_pnl(&model(&gens, early(), d(2030, 1, 1), None));
@@ -2171,7 +2171,7 @@ proptest! {
         let mut b = build_ordered(&gens, 1, &(0..N).collect::<Vec<_>>(), true);
         close_through(&mut b, Some(month), &re_close());
         let rows = profit_and_loss_by_class(&b.l).unwrap();
-        let whole = profit_and_loss(&b.l).unwrap();
+        let whole = unclosed_earnings(&b.l).unwrap();
         prop_assert_eq!(rows.iter().map(|r| r.profit_and_loss.revenue).sum::<Decimal>(), whole.revenue);
         prop_assert_eq!(rows.iter().map(|r| r.profit_and_loss.expenses).sum::<Decimal>(), whole.expenses);
     }

crates/ledger-core/tests/statements.rs

@@ -15,7 +15,7 @@
 
 use chrono::NaiveDate;
 use ledger_core::reports::{
-    balance_sheet, balance_sheet_as_of, profit_and_loss, profit_and_loss_for_period,
+    balance_sheet, balance_sheet_as_of, profit_and_loss_for_period, unclosed_earnings,
 };
 use ledger_core::{
     AccountId, AccountType, CashFlowParams, ClassId, Currency, Ledger, LedgerError, MemberCapital,
@@ -127,7 +127,7 @@ fn profit_and_loss_is_scoped_to_the_period() {
         (dec(3_500), dec(920))
     );
     // ... which is the life-of-ledger P&L, because nothing is outside it.
-    let all = profit_and_loss(&b.ledger).unwrap();
+    let all = unclosed_earnings(&b.ledger).unwrap();
     assert_eq!((all.revenue, all.expenses), (dec(3_500), dec(920)));
 
     // One class: only the tagged software line.