Fixed assets carry federal tax basis beside book value; tests sweep stale temp dirs

- core: TaxBasisRule (cost IRC 1012, carryover IRC 723, personal-use conversion Treas. Reg. 1.168(i)-4(b)), TaxBasis with the contributor's adjusted basis, Asset::tax_basis and ::built_in_gain (IRC 704(c)); the register gains tax rule, contributor basis, tax basis, built-in gain, total tax basis, missing count (rules.md B-25; sources vendored in docs/spec/sources/irs-partnership-basis.md)
- store: asset.tax_basis_set journaled, replayed, projected (schema v10)
- mcp: books.set_asset_tax_basis; register_asset takes tax_basis_rule and contributor_basis, checked before anything registers (found by the spec-blind suite); list_assets and the register export (json, csv) carry tax basis; instructions say to record it for every asset
- import: the register's XLSX and PDF gain the federal tax basis table with citations
- viewer: tax basis on the Assets page, the asset page (a Tax basis card), the report, the journal, and Needs attention for assets without one
- just: check and the mutation recipes sweep this user's test book dirs older than an hour (killed runs had left 23 GB in RAM-backed /tmp)
- docs: the parties, attachments, TIN vault, completeness engine, and updates designs (docs/parties-and-attachments.md)
- tests: spec-blind tax basis suites in core, store, MCP; register PDF/XLSX and viewer tests

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

crates/ledger-import/tests/asset_register.rs

@@ -4,8 +4,10 @@
 //! INVARIANT it checks.
 
 use chrono::NaiveDate;
-use ledger_core::{AssetRegister, AssetRegisterRow};
-use ledger_import::asset_register::{layout, typeset_asset_register};
+use ledger_core::{AssetRegister, AssetRegisterRow, TaxBasisRule};
+use ledger_import::asset_register::{
+    layout, missing_line, notes, rule_cited, rule_label, typeset_asset_register,
+};
 use ledger_import::report::ReportMeta;
 use ledger_import::{PdfError, asset_register_pdf};
 use rust_decimal::Decimal;
@@ -41,14 +43,43 @@ fn row(id: u64, tag: &str, desc: &str, cost: i64, acc: i64) -> AssetRegisterRow
         accumulated: cents(acc),
         book_value: cents(cost - acc),
         disposed: None,
+        tax_rule: None,
+        contributor_basis: None,
+        tax_basis: None,
+        built_in_gain: None,
     }
 }
 
+/// Bought: tax basis is cost.
+fn bought(mut r: AssetRegisterRow) -> AssetRegisterRow {
+    r.tax_rule = Some(TaxBasisRule::Cost);
+    r.tax_basis = Some(r.cost);
+    r
+}
+
+/// Contributed under `rule` with the member's basis `basis` (cents); tax
+/// basis and built-in gain as ledger_core::Asset computes them.
+fn contributed(mut r: AssetRegisterRow, rule: TaxBasisRule, basis: i64) -> AssetRegisterRow {
+    let b = cents(basis);
+    r.tax_rule = Some(rule);
+    r.contributor_basis = Some(b);
+    r.tax_basis = Some(match rule {
+        TaxBasisRule::PersonalUseConversion => b.min(r.cost),
+        _ => b,
+    });
+    r.built_in_gain = Some(r.cost - b);
+    r
+}
+
 fn register(rows: Vec<AssetRegisterRow>) -> AssetRegister {
     let held = || rows.iter().filter(|r| r.disposed.is_none());
     let total_cost = held().map(|r| r.cost).sum();
     let total_accumulated = held().map(|r| r.accumulated).sum();
+    let total_tax_basis = held().filter_map(|r| r.tax_basis).sum();
+    let missing_tax_basis = held().filter(|r| r.tax_basis.is_none()).count();
     AssetRegister {
+        total_tax_basis,
+        missing_tax_basis,
         as_of: d(2026, 10, 15),
         total_book_value: total_cost - total_accumulated,
         ledger_cost: total_cost,
@@ -73,9 +104,23 @@ fn sample() -> AssetRegister {
     laptop.serial = Some("FRANBMCP0A1234".into());
     laptop.salvage = cents(10000);
     register(vec![
-        laptop,
-        row(2, "WL-0002", "MacBook Air", 129900, 32475),
-        disposed,
+        bought(laptop),
+        // A member's business laptop: carryover basis, built-in gain.
+        contributed(
+            row(2, "WL-0002", "MacBook Air", 129900, 32475),
+            TaxBasisRule::Carryover,
+            90000,
+        ),
+        bought(disposed),
+        // A member's personal camera: worth less than its basis, so tax
+        // basis is the fair market value and there's a built-in loss.
+        contributed(
+            row(4, "WL-0004", "Sony A7 IV camera", 165000, 0),
+            TaxBasisRule::PersonalUseConversion,
+            191721,
+        ),
+        // No tax basis recorded yet.
+        row(5, "WL-0005", "Standing desk", 80000, 0),
     ])
 }
 
@@ -126,9 +171,9 @@ fn pdf_shows_assets_totals_and_reconciliation() {
         "Active",
         "Disposed 2026-09-30, proceeds 45.00",
         "Total, assets held",
-        "3,799.00", // cost held: 2,500.00 + 1,299.00
+        "6,249.00", // cost held: 2,500.00 + 1,299.00 + 1,650.00 + 800.00
         "852.53",   // accumulated held
-        "2,946.47", // book value held
+        "5,396.47", // book value held
         "Cost per register",
         "Cost per books",
         "Difference (unregistered cost)",
@@ -143,7 +188,93 @@ fn pdf_shows_assets_totals_and_reconciliation() {
     // The disposed asset's cost (400.00) is shown but in no total.
     assert!(t.contains("400.00"));
     let l = layout(&sample());
-    assert_eq!(l.totals, [cents(379900), cents(85253), cents(294647)]);
+    assert_eq!(l.totals, [cents(624900), cents(85253), cents(539647)]);
+}
+
+/// INVARIANTS 7-9: the tax table shows each rule in short words, the
+/// contributor's basis, the tax basis, the built-in gain and loss, the
+/// register's tax basis total, the missing line, and the notes with
+/// their citations.
+#[test]
+fn pdf_shows_tax_basis() {
+    let r = sample();
+    let t = all_text(&r, &meta());
+    for s in [
+        "Federal tax basis",
+        "TAX BASIS RULE",
+        "CONTRIBUTOR'S BASIS",
+        "BUILT-IN GAIN (LOSS)",
+        "Carryover",
+        "Personal-use conversion",
+        "900.00",   // MacBook: contributor's basis = tax basis
+        "399.00",   // its built-in gain
+        "1,917.21", // camera: contributor's basis
+        "1,650.00", // its tax basis: the fair market value
+        "(267.21)", // its built-in loss
+        "Not recorded",
+        "Total tax basis, assets held",
+        "5,050.00", // 2,500.00 + 900.00 + 1,650.00; the desk has none
+        "Tax basis not recorded for 1 asset",
+        "Notes",
+        "Book value is the fair market value at contribution",
+        "IRC §1012(a)",
+        "IRC §723",
+        "Treas. Reg. §1.168(i)-4(b)",
+        "IRC §704(c)(1)(C)",
+    ] {
+        assert!(t.contains(s), "{s:?} missing from {t:?}");
+    }
+    let l = layout(&r);
+    assert_eq!(l.tax_total, r.total_tax_basis);
+    assert_eq!(l.tax_total, cents(505000));
+    assert_eq!(
+        l.missing.as_deref(),
+        Some("Tax basis not recorded for 1 asset")
+    );
+    assert_eq!(l.notes, notes());
+    // Each line carries its row's tax fields unchanged.
+    for (line, row) in l.lines.iter().zip(&r.rows) {
+        assert_eq!(line.tax_rule, row.tax_rule);
+        assert_eq!(line.contributor_basis, row.contributor_basis);
+        assert_eq!(line.tax_basis, row.tax_basis);
+        assert_eq!(line.built_in_gain, row.built_in_gain);
+    }
+}
+
+/// INVARIANT 8: no missing line when every asset held has a tax basis
+/// (a disposed one without doesn't count), and the plural reads right.
+#[test]
+fn missing_line_only_when_missing() {
+    let mut gone = row(1, "WL-0001", "Old monitor", 40000, 0);
+    gone.book_value = Decimal::ZERO;
+    gone.disposed = Some((d(2026, 9, 30), cents(4500)));
+    let r = register(vec![bought(row(2, "WL-0002", "Desk", 50000, 0)), gone]);
+    assert_eq!(r.missing_tax_basis, 0);
+    assert_eq!(layout(&r).missing, None);
+    assert!(!all_text(&r, &meta()).contains("Tax basis not recorded"));
+    assert_eq!(missing_line(0), None);
+    assert_eq!(
+        missing_line(2).as_deref(),
+        Some("Tax basis not recorded for 2 assets")
+    );
+}
+
+/// INVARIANT 7: the rules in words, short and with their citations.
+#[test]
+fn rule_words() {
+    use TaxBasisRule::*;
+    assert_eq!(
+        [Cost, Carryover, PersonalUseConversion].map(rule_label),
+        ["Cost", "Carryover", "Personal-use conversion"]
+    );
+    assert_eq!(
+        [Cost, Carryover, PersonalUseConversion].map(rule_cited),
+        [
+            "Cost",
+            "Carryover (IRC §723)",
+            "Personal-use conversion (Treas. Reg. §1.168(i)-4(b))"
+        ]
+    );
 }
 
 /// INVARIANT 4: an empty register renders a "No fixed assets" line, its