The audit log with missing entries

import java.util.*;
import java.util.function.*;
import java.util.stream.*;

/**
 * Solution: the audit log with missing entries.
 *
 * Two defects, both of them laziness showing through.
 *
 *   Defect 1 — the audit lived in peek. Intermediate operations only run if
 *   the terminal operation needs their output, and since Java 9 count() can
 *   determine the size straight from the source when no operation could have
 *   changed it. The pipeline never executed, so the audit never ran. This is
 *   documented behaviour, which is why the job worked on 8 and stopped on the
 *   upgrade without a single line of the job changing.
 *
 *   The tell is the second check: adding an unrelated filter made the audit
 *   start working again, because now count() cannot know the size in advance.
 *   Behaviour that depends on an unrelated edit elsewhere in the pipeline is
 *   the signal that the effect was never guaranteed.
 *
 *   The fix is not a different intermediate operation. An audit IS the work,
 *   so it belongs in a terminal operation. peek is for debugging.
 *
 *   Defect 2 — one stream, two terminal operations. A stream is consumed by
 *   its terminal operation and throws on any second use. Where the source can
 *   be traversed again, hold a Supplier<Stream<T>> and take a fresh stream
 *   each time; that also documents that several passes are intended.
 */
public class Solution {

    record Order(String id, double amount) { }

    static class Audit {
        private final List<String> recorded = new ArrayList<>();

        void record(Order order) {
            recorded.add(order.id());
        }

        int size() {
            return recorded.size();
        }
    }

    static List<Order> orders() {
        return List.of(
            new Order("A-1", 120.00),
            new Order("A-2", 80.50),
            new Order("A-3", 12.25),
            new Order("A-4", 640.00),
            new Order("A-5", 5.75));
    }

    /** FIX 1: forEach is terminal, so the audit always runs. */
    static long countAudited(List<Order> orders, Audit audit, boolean withFilter) {
        Supplier<Stream<Order>> source = withFilter
            ? () -> orders.stream().filter(o -> o.amount() >= 0)
            : orders::stream;

        source.get().forEach(audit::record);
        return source.get().count();
    }

    /** FIX 2: a fresh stream per traversal, from a supplier. */
    static String summarise(List<Order> orders) {
        Supplier<Stream<Order>> source = orders::stream;
        long n = source.get().count();
        double total = source.get().mapToDouble(Order::amount).sum();
        return n + " orders totalling " + total;
    }

    public static void main(String[] args) {
        boolean ok = true;
        List<Order> orders = orders();

        System.out.println("── the nightly count ──");
        Audit plain = new Audit();
        long counted = countAudited(orders, plain, false);
        System.out.println("  counted        : " + counted);
        System.out.println("  audit entries  : " + plain.size() + " of " + orders.size());

        ok &= check("every order reached the audit log", plain.size() == orders.size());

        System.out.println();
        System.out.println("── the same job with an unrelated filter added ──");
        Audit filtered = new Audit();
        long counted2 = countAudited(orders, filtered, true);
        System.out.println("  counted        : " + counted2);
        System.out.println("  audit entries  : " + filtered.size() + " of " + orders.size());

        ok &= check("adding a filter does not change what the audit sees",
            plain.size() == filtered.size());

        System.out.println();
        System.out.println("── the summary line ──");
        String summary;
        try {
            summary = summarise(orders);
            System.out.println("  " + summary);
        } catch (IllegalStateException e) {
            summary = null;
            System.out.println("  " + e.getMessage());
        }

        ok &= check("the summary was produced", summary != null);

        System.out.println();
        System.out.println(ok ? "PASS" : "FAIL");
    }

    static boolean check(String what, boolean passed) {
        System.out.println((passed ? "  ok    " : "  FAIL  ") + what);
        return passed;
    }
}