Add corpus source: base repos, task overlays, hidden tests, and the authoring tools

source/CALIBRATION.md

@@ -0,0 +1,269 @@
+# Agentic corpus calibration log
+
+Target: Qwen3.5-4B resolves 15-20%. Measured after each corpus revision.
+
+| revision | tasks | resolved | peak ctx | cumulative |
+|---|---|---|---|---|
+| v1 `ledger` (417 lines) | 6 | 83% | 3-6k | 9-26k |
+| v2 `flow` (989 lines) | 4 | 50% | 6-17k | 27-60k |
+| v3 `flow` symptom-only + multi-file | 4 | 75% | 6-13k | 26-62k |
+
+## What actually controls difficulty
+
+**The fix being structural, not a token flip.** This dominates everything else.
+Of the 17 tasks authored so far, ~14 are repaired by changing one operator or
+one identifier, and the 4B resolves those at 50-83% regardless of how vaguely
+the instruction is worded. The single task it failed -- `expr-precedence` --
+requires restructuring a recursive-descent parser so `and` binds tighter than
+`or`. There is no token to flip.
+
+**Breaking several files does not force a multi-file fix.** `retry-transition-illegal`
+broke `state.py` and `scheduler.py` deliberately. The model repaired it with
+ONE edit, by permitting RETRYING -> RUNNING directly in the state table. That
+is a legitimate fix that passes every test. Models find the minimal path; the
+number of files broken is not a difficulty lever.
+
+**Instruction vagueness helps, but only a little.** Rewriting instructions from
+diagnosis ("capacity is going missing") to symptom ("the runner crashes") moved
+the needle far less than expected.
+
+## Therefore
+
+Author for these, in order of effect:
+
+1. Fixes requiring an algorithm to be understood and restructured: precedence
+   climbing, topological ordering, LRU recency, tie-break rules, cumulative
+   accounting.
+2. Bugs whose obvious local fix passes the failing test but trips a regression
+   guard -- the `since-inclusive` trap shape, which does work.
+3. Repo size, for peak context rather than for difficulty: localisation is not
+   where the 4B struggles.
+
+Do NOT rely on: breaking multiple files, vague wording, or exotic domains.
+
+## Measurement round 2
+
+| batch | tasks | resolved |
+|---|---|---|
+| `flow` batch 3 (symptom-only, "multi-file") | 4 | 75% |
+| `router` batch (structural fixes) | 4 | 50% |
+
+Structural-fix framing helped (75% -> 50%) but not nearly enough. Solved:
+`specificity-by-sum`, `negotiate-tiebreak` -- both amount to rewriting one
+comparison. Failed: `middleware-reentrancy` (a dropped guard must be
+reintroduced) and `lru-recency-on-read` (the model made no edit at all).
+
+## The arithmetic problem
+
+A 60-task corpus at 15-20% means only 9-12 tasks may be solvable. Tasks written
+one-defect-at-a-time land around 50% solvable, so roughly 80% of the corpus has
+to be out of reach. That cannot be reached by making individual bugs subtler --
+it needs a difficulty dial that compounds.
+
+## The dial: independent compound defects
+
+One task, two or three genuinely separate faults, each with its own failing
+test, where no single edit repairs more than one. Independent probabilities
+multiply: two 50% sub-defects give ~25%, three give ~12%.
+
+Properties that make this the right dial:
+
+* **Fair.** Every sub-defect is individually findable by reading the code. No
+  guessing, no trick.
+* **Realistic.** Real reports frequently have several contributing causes.
+* **Tunable.** Difficulty is set by the number of sub-defects, measured rather
+  than guessed.
+* **It actually forces breadth**, unlike breaking several files, which
+  `retry-transition-illegal` showed a model can defeat with one legal edit.
+
+Each sub-defect must be covered by its own fail_to_pass test, so partial credit
+still reports honestly how far a model got.
+
+## Measurement round 3 -- stratified sample (in progress)
+
+Compound calibration, 3 defects each, both unresolved with honest partial credit:
+
+| task | resolved | f2p | edits | regressions |
+|---|---|---|---|---|
+| scheduler-incident-triage | no | 5/9 | 3 | 0 |
+| router-api-review-findings | no | 6/9 | 3 | 2 |
+
+Early stratified-sample results:
+
+| tier | resolved |
+|---|---|
+| single | 2/2 |
+| 2-defect | 1/2 |
+
+## Sub-defect success is correlated, not independent
+
+The dial was designed on the assumption that independent probabilities
+multiply: two 50% sub-defects giving ~25%. Measurement does not support that.
+Two-defect compounds are resolving near 50%, not 25% -- a model that locates
+one defect in a repository it has just read tends to locate the next one too,
+because the expensive part (orienting in the code) is paid once and then shared
+across every defect in the same task.
+
+So the dial is real but far weaker than modelled: each added defect costs much
+less than a factor of two. Practical consequences:
+
+* Three- and four-defect compounds are the only tiers that move the number.
+* Corpus composition must lean overwhelmingly on those tiers.
+* Projected rates from multiplying per-defect probabilities are not usable.
+  Every tier rate must be measured directly, which is what the stratified
+  sample is for.
+
+## Host repo matters as much as defect count
+
+`ledger-audit3-02` -- three defects -- resolved completely, 15/15. Its
+ingredients are fifo-lifo + import-syntax + since-inclusive, all on the 417-line
+`ledger` repo, and one of them is the trivial syntax error that exists to hold
+the floor off zero.
+
+So compound difficulty is not a property of the defect count alone. A compound
+inherits the difficulty of the repository it sits in, and `ledger` is small
+enough to read end to end, which removes the orientation cost that makes
+compounds hard elsewhere.
+
+Consequence for composition: `ledger` is the easy tier at every defect count and
+should not be used for the hard tiers. The hard tiers must come from `flow`
+(989 lines) and `router` (578 lines, 12 modules). Compound tasks built on
+`ledger` are retained only as part of the deliberate easy floor.
+
+## Repo size is the strong dial; defect count is the weak one
+
+Stratified sample, split by host repo rather than by tier:
+
+| tier | ledger (417 lines) | flow / router |
+|---|---|---|
+| single | 2/2 | 0/1 |
+| 2-defect | 2/2 | 0/1 |
+| 3-defect | 1/2 | pending |
+
+A single-defect task on `flow` (`acquire-not-atomic`) went unresolved at 0/4,
+while a three-defect compound on `ledger` resolved fully at 15/15. That settles
+it: what makes these tasks hard is having to orient in a repository too large to
+hold at once, not how many faults are hidden in it.
+
+This inverts the assumption the previous three rounds were built on. Defect
+count still helps -- it is why the hard-repo compounds are the hardest tier --
+but it is a second-order effect on top of repo size.
+
+### Composition that follows
+
+With easy ~80% and hard ~15%, a 60-task corpus hitting 17.5% is about 4 easy
+plus 56 hard. Four solvable tasks is a deliberate, non-zero floor: a corpus
+that scores a leading small model at zero discriminates no better than one that
+scores it at 100%.
+
+Available: 15 tasks on `ledger`, 83 on `flow` + `router`, so the hard tier is
+not supply-constrained.
+
+### If a harder corpus is ever wanted
+
+Add a repo larger than `flow`, not more defects per task. Peak context on
+hard-repo episodes is already 7.3-8.9k against 4.7-5.6k on easy-repo ones,
+which is the same effect showing up in the token numbers.
+
+## Stratified sample, 13/15 complete
+
+| group | resolved |
+|---|---|
+| `ledger` (417 lines) | 7/8 = 88% |
+| `flow` + `router` | 1/5 = 20% |
+
+Hard-repo breakdown: single 1/2, two-defect 0/1, three-defect 0/2.
+
+**Hard-repo tasks alone sit at 20%, the top of the wanted band.** So the corpus
+does not need an easy tier to hold the floor -- 20% of 60 is about 12 solved,
+which is already a non-zero floor -- and including `ledger` tasks would push the
+aggregate above the band rather than protect it.
+
+Composition that follows: ship ~60 tasks drawn from `flow` and `router` only,
+weighted toward compounds over singles to sit mid-band rather than at the
+ceiling. Roughly 8 hard singles (~50%) plus ~52 hard compounds (~10%) projects
+to about 15%.
+
+`ledger` is retained in the corpus source as the easy tier for anyone
+calibrating a weaker model, but is excluded from the default 60.
+
+## Does the benchmark measure coding, or tool-driving?
+
+Across all 31 measured episodes:
+
+| signal | count |
+|---|---|
+| tool errors | 1 total, in 1 episode |
+| malformed JSON arguments | 1 |
+| path-escape attempts | 0 |
+| terminated via `finish` | 23 |
+| terminated at the nudge limit | 7 |
+| zero-edit episodes | 5 |
+
+Qwen3.5-4B drives the protocol essentially without error, so a failed task is a
+failed *repair*, not a failed tool call. That was the main threat to the
+benchmark's validity -- a small model can fail either because it cannot solve
+the problem or because it cannot work the tools, and those must not be
+conflated. Measurement says they are not.
+
+Of 15 unresolved episodes, 7 made partial progress and 8 made none, so the
+fail_to_pass fraction discriminates rather than collapsing to a binary.
+
+Worth re-reading here: the *nudge* is what makes this true. Before it, a model
+that narrated its analysis in prose without emitting a tool call ended the
+episode with zero edits, and the suite reported a fake 0% that looked like a
+hard benchmark. 7 of 31 episodes still end at the nudge limit rather than via
+`finish`, so that path is exercised regularly and is not a corner case.
+
+## Final calibration (pooled sample + verification, hard repos only)
+
+| tier | resolved |
+|---|---|
+| single | 2/3 (~67%) |
+| 2-defect | 0/3 |
+| 3-defect | 1/6 |
+| 4-defect | 0/1 |
+| **all compounds** | **1/10 (~10%)** |
+
+Compounds are ~10%, not the 0% that the first five samples suggested -- one
+three-defect router task resolved completely at 16/16. Re-projecting the shipped
+mix on these rates put it at 23%, above the wanted ceiling, so the mix was
+re-selected: 10 singles + 50 compounds, projecting 19.4%.
+
+The selector could not go below 10 singles and still reach 60 tasks under the
+<=5x defect-reuse cap. Fewer singles would need more compounds than the
+diversity constraint allows.
+
+**Uncertainty worth carrying:** the single rate is n=3. At 50% rather than 67%
+the mix lands at 16.7%. The honest range is roughly 16-19%.
+
+## Diversity constraint
+
+The corpus was reuse-limited, not task-limited. 60 tasks drawn from 29 distinct
+defects meant one unfixable defect sank up to 8 tasks, so the effective number
+of independent signals was ~29, and a confidence interval computed as 60
+independent trials would be too narrow. Selection alone could not fix it: caps
+of 4/5/6 reached only 45/51/57 tasks. Authoring 5 further distinct defects took
+the pool to 36 and let the shipped 60 run at <=5x reuse over 34 distinct
+defects.
+
+Tightening reuse from 8x to 5x did not move the projected rate, so difficulty
+and diversity are independent knobs here -- checked, not assumed.
+
+## FINAL (n=19 hard-repo episodes, pooled)
+
+| tier | resolved |
+|---|---|
+| single | 3/5 = 60% |
+| compound | 1/14 = 7% |
+| overall | 4/19 = 21% |
+
+Shipped mix is 10 singles + 50 compounds, which on these rates projects
+**16.0%** -- mid-band on the 15-20% target.
+
+Corpus: 60 tasks selected from 129 validated. 34 distinct defects, no defect
+reused more than 5 times. 31 Python (`flow`, 989 lines) + 29 TypeScript
+(`router`, 578 lines). Tokens per episode 16-134k cumulative (median ~40k),
+peak context 3.8-10.7k.
+
+Verification runs are in calib-sample.json and verify60.json.

source/README.md

@@ -0,0 +1,71 @@
+# SACB — corpus source
+
+The parquet files in this repository are the *materialised* benchmark: each
+record carries a full file map, hidden tests and reference fix, which is
+everything a harness needs to run SACB.
+
+This directory is what those records were built *from*, so the corpus can be
+regenerated, extended, or ported to another language.
+
+## Layout
+
+```
+corpus/<lang>/<repo>/repo/            the base tree, in its CORRECT state
+corpus/<lang>/<repo>/tasks/<id>/task.json   metadata + the bug report
+corpus/<lang>/<repo>/tasks/<id>/break/      overlay that injects the defect
+corpus/<lang>/<repo>/tasks/<id>/tests/      hidden tests
+corpus/<lang>/<repo>/tasks/<id>/gold/       optional; defaults to the base tree
+```
+
+The base repository is the **correct** code and each task overlays a defect on
+top of it. The reference fix is therefore the base itself, which is why a task
+cannot ship with a "solution" that does not work. For add-a-feature tasks the
+break overlay simply removes the implementation.
+
+## Tools
+
+| script | role |
+|---|---|
+| `tools/build_corpus.py` | validate every task and emit the JSONL the parquet is built from |
+| `tools/make_tasks.py` | helper used by the authoring scripts |
+| `tools/tasks_*.py` | the authoring batches, one defect or compound per entry |
+| `tools/gen_compounds.py` | compose compound tasks from validated single defects |
+| `tools/select_corpus.py` | choose the shipped mix to hit a target resolved rate |
+| `tools/upload_sacb.py` | publish to this repository |
+| `tools/harness-tests/` | tests for the llama-eval harness itself |
+
+These import `eval_sandbox` and `agentic_eval` from `examples/llama-eval/` in
+llama.cpp, so point `sys.path` at a checkout that has them.
+
+## Regenerating
+
+```bash
+python3 tools/build_corpus.py --corpus corpus --out agentic-corpus.jsonl
+```
+
+`fail_to_pass` and `pass_to_pass` are **derived**, never written by hand: the
+tests are run once against the defective tree and once against the reference,
+and the sets fall out of the difference. The builder rejects a task whose defect
+no test exercises, and one whose reference fix does not itself pass. It caught
+several authoring mistakes that way, which is the point.
+
+## Adding a task
+
+Add an entry to a `tasks_*.py` batch giving the exact anchor text to replace and
+the tests, run the builder, and fix whatever it rejects. Anchors are matched
+exactly and must occur exactly once, so a defect can never silently fail to be
+injected.
+
+## Adding a language
+
+The harness takes a new language as a `LangSpec` entry (linter argv, test
+runner, packages) without any other change. Java was scoped out of this release
+but needs no harness work — a JDK tarball plus the JUnit console-standalone jar
+would keep the no-container property.
+
+## Calibration
+
+`CALIBRATION.md` records every measurement taken while tuning this corpus, and
+in particular the four assumptions about difficulty that measurement
+contradicted. Read it before changing the composition — the headline is that
+**repository size, not defect count, is what makes these tasks hard**.

source/corpus/python/ledger/repo/README.md

@@ -0,0 +1,33 @@
+# ledger
+
+A small event-sourced inventory ledger.
+
+Everything that happens to stock is recorded as an immutable event in the
+`EventStore`. Current state is never stored directly; it is derived by folding
+the event log through a *projection*.
+
+    from ledger import EventStore, StockProjection
+
+    store = EventStore()
+    store.receive("widget", qty=100, unit_cost=2.50)
+    store.ship("widget", qty=30)
+
+    stock = StockProjection()
+    stock.catch_up(store)
+    stock.on_hand("widget")   # 70
+
+## Layout
+
+| module | role |
+|---|---|
+| `events.py` | immutable event types |
+| `store.py` | append-only log, owns sequence numbering |
+| `projections.py` | `StockProjection` (units) and `Valuation` (FIFO cost) |
+| `policies.py` | reorder suggestions and multi-warehouse allocation |
+| `errors.py` | exception hierarchy |
+
+## Resuming a projection
+
+Projections are incremental. Each remembers the last sequence number it
+applied and asks the store only for events after it, so catching up a long
+ledger does not mean replaying it from the beginning.

source/corpus/python/ledger/repo/ledger/__init__.py

@@ -0,0 +1,13 @@
+"""A small event-sourced inventory ledger."""
+from .errors import LedgerError, UnknownSku, InsufficientStock
+from .events import Event, Received, Shipped, Adjusted
+from .store import EventStore
+from .projections import StockProjection, Valuation
+from .policies import ReorderPolicy, allocate
+
+__all__ = [
+    "LedgerError", "UnknownSku", "InsufficientStock",
+    "Event", "Received", "Shipped", "Adjusted",
+    "EventStore", "StockProjection", "Valuation",
+    "ReorderPolicy", "allocate",
+]

source/corpus/python/ledger/repo/ledger/errors.py

@@ -0,0 +1,28 @@
+"""Exception types raised across the ledger."""
+
+
+class LedgerError(Exception):
+    """Base class for every error this package raises."""
+
+
+class UnknownSku(LedgerError):
+    """A SKU was referenced that the ledger has never seen."""
+
+    def __init__(self, sku: str):
+        super().__init__(f"unknown sku: {sku}")
+        self.sku = sku
+
+
+class InsufficientStock(LedgerError):
+    """A shipment was requested for more units than are on hand."""
+
+    def __init__(self, sku: str, wanted: int, available: int):
+        super().__init__(
+            f"cannot ship {wanted} of {sku}: only {available} on hand")
+        self.sku = sku
+        self.wanted = wanted
+        self.available = available
+
+
+class SequenceError(LedgerError):
+    """Events were presented to a projection out of order."""

source/corpus/python/ledger/repo/ledger/events.py

@@ -0,0 +1,51 @@
+"""Event types.
+
+Every event carries a monotonically increasing sequence number assigned by the
+store, plus the SKU it concerns. Events are immutable once created: a ledger
+that can be rewritten after the fact is not a ledger.
+"""
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Event:
+    """Base event. `seq` is assigned by the store, never by the caller."""
+    seq: int
+    ts: float
+    sku: str
+
+    @property
+    def kind(self) -> str:
+        return type(self).__name__.lower()
+
+    def describe(self) -> str:
+        return f"[{self.seq}] {self.kind} {self.sku}"
+
+
+@dataclass(frozen=True)
+class Received(Event):
+    """Stock arrived into the warehouse at a known unit cost."""
+    qty: int
+    unit_cost: float
+
+    def describe(self) -> str:
+        return f"{super().describe()} +{self.qty} @ {self.unit_cost:.2f}"
+
+
+@dataclass(frozen=True)
+class Shipped(Event):
+    """Stock left the warehouse."""
+    qty: int
+
+    def describe(self) -> str:
+        return f"{super().describe()} -{self.qty}"
+
+
+@dataclass(frozen=True)
+class Adjusted(Event):
+    """A stocktake correction. `delta` may be negative."""
+    delta: int
+    reason: str
+
+    def describe(self) -> str:
+        return f"{super().describe()} {self.delta:+d} ({self.reason})"

source/corpus/python/ledger/repo/ledger/policies.py

@@ -0,0 +1,85 @@
+"""Decisions taken on top of the read models.
+
+Nothing here touches the event log directly. Policies read a projection and
+return a plan; committing that plan is the caller's business.
+"""
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Sequence, Tuple
+
+from .errors import InsufficientStock, UnknownSku
+from .projections import StockProjection
+
+
+@dataclass(frozen=True)
+class Warehouse:
+    """A stocking location, with a priority used to break ties."""
+    name: str
+    priority: int
+    on_hand: int
+
+
+@dataclass(frozen=True)
+class ReorderSuggestion:
+    sku: str
+    order_qty: int
+    reason: str
+
+
+class ReorderPolicy:
+    """Suggests replenishment when a SKU falls to or below its threshold.
+
+    The comparison is deliberately inclusive: a SKU sitting exactly on its
+    reorder point has reached it, and waiting for it to drop further is how a
+    warehouse runs out during the lead time.
+    """
+
+    def __init__(self, thresholds: Dict[str, int], target: Dict[str, int]):
+        self.thresholds = dict(thresholds)
+        self.target = dict(target)
+
+    def threshold_for(self, sku: str) -> int:
+        if sku not in self.thresholds:
+            raise UnknownSku(sku)
+        return self.thresholds[sku]
+
+    def suggest(self, stock: StockProjection) -> List[ReorderSuggestion]:
+        """One suggestion per SKU at or below its reorder point."""
+        out: List[ReorderSuggestion] = []
+        for sku in sorted(self.thresholds):
+            level = stock.levels.get(sku, 0)
+            threshold = self.thresholds[sku]
+            if level <= threshold:
+                target = self.target.get(sku, threshold * 2)
+                qty = target - level
+                if qty > 0:
+                    out.append(ReorderSuggestion(
+                        sku=sku, order_qty=qty,
+                        reason=f"level {level} at or below threshold {threshold}"))
+        return out
+
+
+def allocate(demand: int, warehouses: Sequence[Warehouse]) -> List[Tuple[str, int]]:
+    """Split `demand` across warehouses, highest priority first.
+
+    Ties on priority are broken by name so the result is deterministic. The
+    input sequence is never mutated -- callers reuse their warehouse list
+    across several allocations and would otherwise see it quietly emptied.
+    """
+    if demand <= 0:
+        raise ValueError("demand must be positive")
+
+    ordered = sorted(warehouses, key=lambda w: (-w.priority, w.name))
+    available = sum(w.on_hand for w in ordered)
+    if available < demand:
+        raise InsufficientStock("<multiple>", demand, available)
+
+    plan: List[Tuple[str, int]] = []
+    remaining = demand
+    for warehouse in ordered:
+        if remaining <= 0:
+            break
+        take = min(warehouse.on_hand, remaining)
+        if take > 0:
+            plan.append((warehouse.name, take))
+            remaining -= take
+    return plan

source/corpus/python/ledger/repo/ledger/projections.py

@@ -0,0 +1,125 @@
+"""Read models built by folding the event log.
+
+A projection is resumable: it remembers the last sequence number it applied
+and asks the store only for what came after. That is what keeps a long ledger
+cheap to query, and it is why the store's `since` boundary matters so much.
+"""
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+from .errors import SequenceError, UnknownSku
+from .events import Adjusted, Event, Received, Shipped
+from .store import EventStore
+
+
+class StockProjection:
+    """Units on hand per SKU."""
+
+    def __init__(self) -> None:
+        self.levels: Dict[str, int] = {}
+        self.last_seq: int = 0
+
+    def apply(self, event: Event) -> None:
+        """Fold a single event into the running totals."""
+        if event.seq <= self.last_seq:
+            raise SequenceError(
+                f"event {event.seq} already applied (at {self.last_seq})")
+        current = self.levels.get(event.sku, 0)
+        if isinstance(event, Received):
+            current += event.qty
+        elif isinstance(event, Shipped):
+            current -= event.qty
+        elif isinstance(event, Adjusted):
+            current += event.delta
+        self.levels[event.sku] = current
+        self.last_seq = event.seq
+
+    def catch_up(self, store: EventStore) -> int:
+        """Apply everything appended since the last call. Returns the count."""
+        pending = store.since(self.last_seq)
+        for event in pending:
+            self.apply(event)
+        return len(pending)
+
+    def on_hand(self, sku: str) -> int:
+        if sku not in self.levels:
+            raise UnknownSku(sku)
+        return self.levels[sku]
+
+    def negative_skus(self) -> List[str]:
+        """SKUs the log says we hold a negative quantity of."""
+        return sorted(s for s, n in self.levels.items() if n < 0)
+
+
+@dataclass
+class Lot:
+    """One receipt still carrying unconsumed units."""
+    seq: int
+    qty: int
+    unit_cost: float
+
+
+class Valuation:
+    """Inventory value under first-in, first-out cost basis."""
+
+    def __init__(self) -> None:
+        self.lots: Dict[str, List[Lot]] = {}
+        self.last_seq: int = 0
+        self.cost_of_goods_sold: float = 0.0
+
+    def apply(self, event: Event) -> None:
+        lots = self.lots.setdefault(event.sku, [])
+        if isinstance(event, Received):
+            lots.append(Lot(seq=event.seq, qty=event.qty,
+                            unit_cost=event.unit_cost))
+        elif isinstance(event, Shipped):
+            self._consume(lots, event.qty)
+        elif isinstance(event, Adjusted):
+            if event.delta > 0:
+                unit_cost = lots[-1].unit_cost if lots else 0.0
+                lots.append(Lot(seq=event.seq, qty=event.delta,
+                                unit_cost=unit_cost))
+            else:
+                self._consume(lots, -event.delta)
+        self.last_seq = event.seq
+
+    def _consume(self, lots: List[Lot], qty: int) -> None:
+        """Draw `qty` units from the oldest lots first."""
+        remaining = qty
+        while remaining > 0 and lots:
+            oldest = lots[0]
+            take = min(oldest.qty, remaining)
+            self.cost_of_goods_sold += take * oldest.unit_cost
+            oldest.qty -= take
+            remaining -= take
+            if oldest.qty == 0:
+                lots.pop(0)
+
+    def catch_up(self, store: EventStore) -> int:
+        pending = store.since(self.last_seq)
+        for event in pending:
+            self.apply(event)
+        return len(pending)
+
+    def value_of(self, sku: str) -> float:
+        """Total carrying value of the units still on hand for one SKU."""
+        if sku not in self.lots:
+            raise UnknownSku(sku)
+        return sum(lot.qty * lot.unit_cost for lot in self.lots[sku])
+
+    def average_cost(self, sku: str) -> float:
+        """Weighted average cost of the units still on hand.
+
+        Zero when nothing is on hand, rather than a division error -- callers
+        display this per SKU and a depleted line is normal.
+        """
+        if sku not in self.lots:
+            raise UnknownSku(sku)
+        units = sum(lot.qty for lot in self.lots[sku])
+        if units == 0:
+            return 0.0
+        return self.value_of(sku) / units
+
+    def total_value(self) -> float:
+        return sum(lot.qty * lot.unit_cost
+                   for lots in self.lots.values() for lot in lots)

source/corpus/python/ledger/repo/ledger/store.py

@@ -0,0 +1,95 @@
+"""Append-only event store with snapshot support.
+
+The store owns sequence numbering. Nothing else in the package is allowed to
+assign a sequence number, because the ordering guarantee that projections rely
+on is only as good as the single place that hands the numbers out.
+"""
+from typing import Dict, Iterable, Iterator, List, Optional
+
+from .errors import SequenceError
+from .events import Adjusted, Event, Received, Shipped
+
+
+class EventStore:
+    """Holds every event ever appended, in order."""
+
+    def __init__(self) -> None:
+        self._events: List[Event] = []
+        self._next_seq: int = 1
+        self._clock: float = 0.0
+
+    # -- writing ---------------------------------------------------------
+
+    def _tick(self) -> float:
+        self._clock += 1.0
+        return self._clock
+
+    def _append(self, event: Event) -> Event:
+        if event.seq != self._next_seq:
+            raise SequenceError(
+                f"expected seq {self._next_seq}, got {event.seq}")
+        self._events.append(event)
+        self._next_seq += 1
+        return event
+
+    def receive(self, sku: str, qty: int, unit_cost: float) -> Received:
+        """Record stock arriving."""
+        if qty <= 0:
+            raise ValueError("received quantity must be positive")
+        return self._append(
+            Received(seq=self._next_seq, ts=self._tick(), sku=sku,
+                     qty=qty, unit_cost=unit_cost))
+
+    def ship(self, sku: str, qty: int) -> Shipped:
+        """Record stock leaving. Does not itself check availability."""
+        if qty <= 0:
+            raise ValueError("shipped quantity must be positive")
+        return self._append(
+            Shipped(seq=self._next_seq, ts=self._tick(), sku=sku, qty=qty))
+
+    def adjust(self, sku: str, delta: int, reason: str) -> Adjusted:
+        """Record a stocktake correction."""
+        if delta == 0:
+            raise ValueError("adjustment delta must not be zero")
+        return self._append(
+            Adjusted(seq=self._next_seq, ts=self._tick(), sku=sku,
+                     delta=delta, reason=reason))
+
+    # -- reading ---------------------------------------------------------
+
+    def __len__(self) -> int:
+        return len(self._events)
+
+    def __iter__(self) -> Iterator[Event]:
+        return iter(self._events)
+
+    @property
+    def head(self) -> int:
+        """Sequence number of the most recent event, or 0 when empty."""
+        return self._events[-1].seq if self._events else 0
+
+    def since(self, seq: int) -> List[Event]:
+        """Every event appended strictly after `seq`.
+
+        A projection resumes by passing the sequence number it last applied, so
+        this must be exclusive at the lower bound. Making it inclusive would
+        replay one already-applied event on every resume.
+        """
+        return [e for e in self._events if e.seq > seq]
+
+    def between(self, low: int, high: int) -> List[Event]:
+        """Events with low < seq <= high."""
+        return [e for e in self._events if low < e.seq <= high]
+
+    def for_sku(self, sku: str) -> List[Event]:
+        return [e for e in self._events if e.sku == sku]
+
+    def skus(self) -> List[str]:
+        seen: Dict[str, None] = {}
+        for event in self._events:
+            seen.setdefault(event.sku, None)
+        return list(seen)
+
+    def replay(self, events: Optional[Iterable[Event]] = None) -> List[Event]:
+        """Materialise an event iterable, defaulting to the whole log."""
+        return list(self._events if events is None else events)

source/corpus/python/ledger/tasks/allocate-mutates/break/ledger/policies.py

@@ -0,0 +1,86 @@
+"""Decisions taken on top of the read models.
+
+Nothing here touches the event log directly. Policies read a projection and
+return a plan; committing that plan is the caller's business.
+"""
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Sequence, Tuple
+
+from .errors import InsufficientStock, UnknownSku
+from .projections import StockProjection
+
+
+@dataclass(frozen=True)
+class Warehouse:
+    """A stocking location, with a priority used to break ties."""
+    name: str
+    priority: int
+    on_hand: int
+
+
+@dataclass(frozen=True)
+class ReorderSuggestion:
+    sku: str
+    order_qty: int
+    reason: str
+
+
+class ReorderPolicy:
+    """Suggests replenishment when a SKU falls to or below its threshold.
+
+    The comparison is deliberately inclusive: a SKU sitting exactly on its
+    reorder point has reached it, and waiting for it to drop further is how a
+    warehouse runs out during the lead time.
+    """
+
+    def __init__(self, thresholds: Dict[str, int], target: Dict[str, int]):
+        self.thresholds = dict(thresholds)
+        self.target = dict(target)
+
+    def threshold_for(self, sku: str) -> int:
+        if sku not in self.thresholds:
+            raise UnknownSku(sku)
+        return self.thresholds[sku]
+
+    def suggest(self, stock: StockProjection) -> List[ReorderSuggestion]:
+        """One suggestion per SKU at or below its reorder point."""
+        out: List[ReorderSuggestion] = []
+        for sku in sorted(self.thresholds):
+            level = stock.levels.get(sku, 0)
+            threshold = self.thresholds[sku]
+            if level <= threshold:
+                target = self.target.get(sku, threshold * 2)
+                qty = target - level
+                if qty > 0:
+                    out.append(ReorderSuggestion(
+                        sku=sku, order_qty=qty,
+                        reason=f"level {level} at or below threshold {threshold}"))
+        return out
+
+
+def allocate(demand: int, warehouses: Sequence[Warehouse]) -> List[Tuple[str, int]]:
+    """Split `demand` across warehouses, highest priority first.
+
+    Ties on priority are broken by name so the result is deterministic. The
+    input sequence is never mutated -- callers reuse their warehouse list
+    across several allocations and would otherwise see it quietly emptied.
+    """
+    if demand <= 0:
+        raise ValueError("demand must be positive")
+
+    ordered = warehouses
+    ordered.sort(key=lambda w: (-w.priority, w.name))
+    available = sum(w.on_hand for w in ordered)
+    if available < demand:
+        raise InsufficientStock("<multiple>", demand, available)
+
+    plan: List[Tuple[str, int]] = []
+    remaining = demand
+    for warehouse in ordered:
+        if remaining <= 0:
+            break
+        take = min(warehouse.on_hand, remaining)
+        if take > 0:
+            plan.append((warehouse.name, take))
+            remaining -= take
+    return plan

source/corpus/python/ledger/tasks/allocate-mutates/task.json

@@ -0,0 +1,6 @@
+{
+  "lang": "python",
+  "category": "logic",
+  "difficulty": 3,
+  "instruction": "A caller that allocates twice from the same warehouse list gets a different plan the second time, and reports that their own list comes back reordered afterwards.\n\nallocate() is supposed to be free of side effects on its arguments. Fix it."
+}

source/corpus/python/ledger/tasks/allocate-mutates/tests/test_allocate.py

@@ -0,0 +1,41 @@
+import unittest
+
+from ledger import allocate
+from ledger.policies import Warehouse
+
+
+def houses():
+    return [Warehouse("north", 1, 5),
+            Warehouse("south", 3, 5),
+            Warehouse("east", 2, 5)]
+
+
+class TestAllocateIsPure(unittest.TestCase):
+    def test_caller_list_order_is_untouched(self):
+        warehouses = houses()
+        before = [w.name for w in warehouses]
+        allocate(6, warehouses)
+        self.assertEqual([w.name for w in warehouses], before)
+
+    def test_repeated_calls_agree(self):
+        warehouses = houses()
+        first = allocate(7, warehouses)
+        second = allocate(7, warehouses)
+        self.assertEqual(first, second)
+
+
+class TestAllocateBehaviour(unittest.TestCase):
+    def test_highest_priority_first(self):
+        self.assertEqual(allocate(5, houses()), [("south", 5)])
+
+    def test_spills_into_next_priority(self):
+        self.assertEqual(allocate(8, houses()), [("south", 5), ("east", 3)])
+
+    def test_ties_broken_by_name(self):
+        tied = [Warehouse("b", 5, 2), Warehouse("a", 5, 2)]
+        self.assertEqual(allocate(3, tied), [("a", 2), ("b", 1)])
+
+    def test_insufficient_stock_raises(self):
+        from ledger.errors import InsufficientStock
+        with self.assertRaises(InsufficientStock):
+            allocate(999, houses())

source/corpus/python/ledger/tasks/audit-findings/break/ledger/policies.py

@@ -0,0 +1,85 @@
+"""Decisions taken on top of the read models.
+
+Nothing here touches the event log directly. Policies read a projection and
+return a plan; committing that plan is the caller's business.
+"""
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Sequence, Tuple
+
+from .errors import InsufficientStock, UnknownSku
+from .projections import StockProjection
+
+
+@dataclass(frozen=True)
+class Warehouse:
+    """A stocking location, with a priority used to break ties."""
+    name: str
+    priority: int
+    on_hand: int
+
+
+@dataclass(frozen=True)
+class ReorderSuggestion:
+    sku: str
+    order_qty: int
+    reason: str
+
+
+class ReorderPolicy:
+    """Suggests replenishment when a SKU falls to or below its threshold.
+
+    The comparison is deliberately inclusive: a SKU sitting exactly on its
+    reorder point has reached it, and waiting for it to drop further is how a
+    warehouse runs out during the lead time.
+    """
+
+    def __init__(self, thresholds: Dict[str, int], target: Dict[str, int]):
+        self.thresholds = dict(thresholds)
+        self.target = dict(target)
+
+    def threshold_for(self, sku: str) -> int:
+        if sku not in self.thresholds:
+            raise UnknownSku(sku)
+        return self.thresholds[sku]
+
+    def suggest(self, stock: StockProjection) -> List[ReorderSuggestion]:
+        """One suggestion per SKU at or below its reorder point."""
+        out: List[ReorderSuggestion] = []
+        for sku in sorted(self.thresholds):
+            level = stock.levels.get(sku, 0)
+            threshold = self.thresholds[sku]
+            if level < threshold:
+                target = self.target.get(sku, threshold * 2)
+                qty = target - level
+                if qty > 0:
+                    out.append(ReorderSuggestion(
+                        sku=sku, order_qty=qty,
+                        reason=f"level {level} at or below threshold {threshold}"))
+        return out
+
+
+def allocate(demand: int, warehouses: Sequence[Warehouse]) -> List[Tuple[str, int]]:
+    """Split `demand` across warehouses, highest priority first.
+
+    Ties on priority are broken by name so the result is deterministic. The
+    input sequence is never mutated -- callers reuse their warehouse list
+    across several allocations and would otherwise see it quietly emptied.
+    """
+    if demand <= 0:
+        raise ValueError("demand must be positive")
+
+    ordered = sorted(warehouses, key=lambda w: (-w.priority, w.name))
+    available = sum(w.on_hand for w in ordered)
+    if available < demand:
+        raise InsufficientStock("<multiple>", demand, available)
+
+    plan: List[Tuple[str, int]] = []
+    remaining = demand
+    for warehouse in ordered:
+        if remaining <= 0:
+            break
+        take = min(warehouse.on_hand, remaining)
+        if take > 0:
+            plan.append((warehouse.name, take))
+            remaining -= take
+    return plan

source/corpus/python/ledger/tasks/audit-findings/break/ledger/projections.py

@@ -0,0 +1,125 @@
+"""Read models built by folding the event log.
+
+A projection is resumable: it remembers the last sequence number it applied
+and asks the store only for what came after. That is what keeps a long ledger
+cheap to query, and it is why the store's `since` boundary matters so much.
+"""
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+from .errors import SequenceError, UnknownSku
+from .events import Adjusted, Event, Received, Shipped
+from .store import EventStore
+
+
+class StockProjection:
+    """Units on hand per SKU."""
+
+    def __init__(self) -> None:
+        self.levels: Dict[str, int] = {}
+        self.last_seq: int = 0
+
+    def apply(self, event: Event) -> None:
+        """Fold a single event into the running totals."""
+        if event.seq <= self.last_seq:
+            raise SequenceError(
+                f"event {event.seq} already applied (at {self.last_seq})")
+        current = self.levels.get(event.sku, 0)
+        if isinstance(event, Received):
+            current += event.qty
+        elif isinstance(event, Shipped):
+            current -= event.qty
+        elif isinstance(event, Adjusted):
+            current += event.delta
+        self.levels[event.sku] = current
+        self.last_seq = event.seq
+
+    def catch_up(self, store: EventStore) -> int:
+        """Apply everything appended since the last call. Returns the count."""
+        pending = store.since(self.last_seq)
+        for event in pending:
+            self.apply(event)
+        return len(pending)
+
+    def on_hand(self, sku: str) -> int:
+        if sku not in self.levels:
+            raise UnknownSku(sku)
+        return self.levels[sku]
+
+    def negative_skus(self) -> List[str]:
+        """SKUs the log says we hold a negative quantity of."""
+        return sorted(s for s, n in self.levels.items() if n < 0)
+
+
+@dataclass
+class Lot:
+    """One receipt still carrying unconsumed units."""
+    seq: int
+    qty: int
+    unit_cost: float
+
+
+class Valuation:
+    """Inventory value under first-in, first-out cost basis."""
+
+    def __init__(self) -> None:
+        self.lots: Dict[str, List[Lot]] = {}
+        self.last_seq: int = 0
+        self.cost_of_goods_sold: float = 0.0
+
+    def apply(self, event: Event) -> None:
+        lots = self.lots.setdefault(event.sku, [])
+        if isinstance(event, Received):
+            lots.append(Lot(seq=event.seq, qty=event.qty,
+                            unit_cost=event.unit_cost))
+        elif isinstance(event, Shipped):
+            self._consume(lots, event.qty)
+        elif isinstance(event, Adjusted):
+            if event.delta > 0:
+                unit_cost = lots[-1].unit_cost if lots else 0.0
+                lots.append(Lot(seq=event.seq, qty=event.delta,
+                                unit_cost=unit_cost))
+            else:
+                self._consume(lots, -event.delta)
+        self.last_seq = event.seq
+
+    def _consume(self, lots: List[Lot], qty: int) -> None:
+        """Draw `qty` units from the oldest lots first."""
+        remaining = qty
+        while remaining > 0 and lots:
+            oldest = lots[-1]
+            take = min(oldest.qty, remaining)
+            self.cost_of_goods_sold += take * oldest.unit_cost
+            oldest.qty -= take
+            remaining -= take
+            if oldest.qty == 0:
+                lots.pop()
+
+    def catch_up(self, store: EventStore) -> int:
+        pending = store.since(self.last_seq)
+        for event in pending:
+            self.apply(event)
+        return len(pending)
+
+    def value_of(self, sku: str) -> float:
+        """Total carrying value of the units still on hand for one SKU."""
+        if sku not in self.lots:
+            raise UnknownSku(sku)
+        return sum(lot.qty * lot.unit_cost for lot in self.lots[sku])
+
+    def average_cost(self, sku: str) -> float:
+        """Weighted average cost of the units still on hand.
+
+        Zero when nothing is on hand, rather than a division error -- callers
+        display this per SKU and a depleted line is normal.
+        """
+        if sku not in self.lots:
+            raise UnknownSku(sku)
+        units = sum(lot.qty for lot in self.lots[sku])
+        if units == 0:
+            return 0.0
+        return self.value_of(sku) / units
+
+    def total_value(self) -> float:
+        return sum(lot.qty * lot.unit_cost
+                   for lots in self.lots.values() for lot in lots)

source/corpus/python/ledger/tasks/audit-findings/break/ledger/store.py

@@ -0,0 +1,95 @@
+"""Append-only event store with snapshot support.
+
+The store owns sequence numbering. Nothing else in the package is allowed to
+assign a sequence number, because the ordering guarantee that projections rely
+on is only as good as the single place that hands the numbers out.
+"""
+from typing import Dict, Iterable, Iterator, List, Optional
+
+from .errors import SequenceError
+from .events import Adjusted, Event, Received, Shipped
+
+
+class EventStore:
+    """Holds every event ever appended, in order."""
+
+    def __init__(self) -> None:
+        self._events: List[Event] = []
+        self._next_seq: int = 1
+        self._clock: float = 0.0
+
+    # -- writing ---------------------------------------------------------
+
+    def _tick(self) -> float:
+        self._clock += 1.0
+        return self._clock
+
+    def _append(self, event: Event) -> Event:
+        if event.seq != self._next_seq:
+            raise SequenceError(
+                f"expected seq {self._next_seq}, got {event.seq}")
+        self._events.append(event)
+        self._next_seq += 1
+        return event
+
+    def receive(self, sku: str, qty: int, unit_cost: float) -> Received:
+        """Record stock arriving."""
+        if qty <= 0:
+            raise ValueError("received quantity must be positive")
+        return self._append(
+            Received(seq=self._next_seq, ts=self._tick(), sku=sku,
+                     qty=qty, unit_cost=unit_cost))
+
+    def ship(self, sku: str, qty: int) -> Shipped:
+        """Record stock leaving. Does not itself check availability."""
+        if qty <= 0:
+            raise ValueError("shipped quantity must be positive")
+        return self._append(
+            Shipped(seq=self._next_seq, ts=self._tick(), sku=sku, qty=qty))
+
+    def adjust(self, sku: str, delta: int, reason: str) -> Adjusted:
+        """Record a stocktake correction."""
+        if delta == 0:
+            raise ValueError("adjustment delta must not be zero")
+        return self._append(
+            Adjusted(seq=self._next_seq, ts=self._tick(), sku=sku,
+                     delta=delta, reason=reason))
+
+    # -- reading ---------------------------------------------------------
+
+    def __len__(self) -> int:
+        return len(self._events)
+
+    def __iter__(self) -> Iterator[Event]:
+        return iter(self._events)
+
+    @property
+    def head(self) -> int:
+        """Sequence number of the most recent event, or 0 when empty."""
+        return self._events[-1].seq if self._events else 0
+
+    def since(self, seq: int) -> List[Event]:
+        """Every event appended strictly after `seq`.
+
+        A projection resumes by passing the sequence number it last applied, so
+        this must be exclusive at the lower bound. Making it inclusive would
+        replay one already-applied event on every resume.
+        """
+        return [e for e in self._events if e.seq >= seq]
+
+    def between(self, low: int, high: int) -> List[Event]:
+        """Events with low < seq <= high."""
+        return [e for e in self._events if low < e.seq <= high]
+
+    def for_sku(self, sku: str) -> List[Event]:
+        return [e for e in self._events if e.sku == sku]
+
+    def skus(self) -> List[str]:
+        seen: Dict[str, None] = {}
+        for event in self._events:
+            seen.setdefault(event.sku, None)
+        return list(seen)
+
+    def replay(self, events: Optional[Iterable[Event]] = None) -> List[Event]:
+        """Materialise an event iterable, defaulting to the whole log."""
+        return list(self._events if events is None else events)

source/corpus/python/ledger/tasks/audit-findings/task.json

@@ -0,0 +1,7 @@
+{
+  "lang": "python",
+  "category": "logic",
+  "difficulty": 5,
+  "instruction": "Three findings from the stock audit. They are unrelated; all three need fixing.\n\n1. Valuation and cost of goods sold are wrong for any SKU received at more than\n   one unit cost. The ledger is documented as valuing inventory first-in,\n   first-out.\n\n2. A SKU sitting exactly at its configured reorder point produces no\n   replenishment suggestion, and we ran out during the supplier lead time. The\n   reorder point is meant to be inclusive.\n\n3. Catching a projection up a second time raises rather than applying only what\n   is new. A projection is supposed to be resumable, and catching up with\n   nothing new appended must apply zero events.",
+  "compound": true
+}

source/corpus/python/ledger/tasks/audit-findings/tests/test_catch_up.py

@@ -0,0 +1,56 @@
+import unittest
+
+from ledger import EventStore, StockProjection
+from ledger.errors import SequenceError
+
+
+class TestIncrementalCatchUp(unittest.TestCase):
+    def test_catch_up_twice_across_new_events(self):
+        store = EventStore()
+        store.receive("widget", 100, 2.50)
+        stock = StockProjection()
+        stock.catch_up(store)
+        store.ship("widget", 30)
+        stock.catch_up(store)
+        self.assertEqual(stock.on_hand("widget"), 70)
+
+    def test_catch_up_with_nothing_new_is_a_noop(self):
+        store = EventStore()
+        store.receive("widget", 10, 1.0)
+        stock = StockProjection()
+        self.assertEqual(stock.catch_up(store), 1)
+        self.assertEqual(stock.catch_up(store), 0)
+        self.assertEqual(stock.on_hand("widget"), 10)
+
+    def test_many_incremental_catch_ups_match_one_big_one(self):
+        incremental = StockProjection()
+        store = EventStore()
+        for i in range(1, 6):
+            store.receive("bolt", i * 10, 1.0)
+            incremental.catch_up(store)
+        oneshot = StockProjection()
+        oneshot.catch_up(store)
+        self.assertEqual(incremental.levels, oneshot.levels)
+        self.assertEqual(incremental.on_hand("bolt"), 150)
+
+
+class TestOrderingGuaranteesPreserved(unittest.TestCase):
+    """Deleting the ordering check would hide the symptom but corrupt totals."""
+
+    def test_replaying_an_applied_event_is_still_rejected(self):
+        store = EventStore()
+        store.receive("widget", 5, 1.0)
+        stock = StockProjection()
+        stock.catch_up(store)
+        already_applied = list(store)[0]
+        with self.assertRaises(SequenceError):
+            stock.apply(already_applied)
+
+    def test_store_since_is_exclusive_at_the_lower_bound(self):
+        store = EventStore()
+        store.receive("a", 1, 1.0)
+        store.receive("b", 1, 1.0)
+        store.receive("c", 1, 1.0)
+        self.assertEqual([e.seq for e in store.since(0)], [1, 2, 3])
+        self.assertEqual([e.seq for e in store.since(1)], [2, 3])
+        self.assertEqual([e.seq for e in store.since(3)], [])

source/corpus/python/ledger/tasks/audit-findings/tests/test_reorder.py

@@ -0,0 +1,42 @@
+import unittest
+
+from ledger import EventStore, ReorderPolicy, StockProjection
+
+
+def stock_at(levels):
+    store = EventStore()
+    for sku, qty in levels.items():
+        if qty > 0:
+            store.receive(sku, qty, 1.0)
+    projection = StockProjection()
+    projection.catch_up(store)
+    for sku in levels:
+        projection.levels.setdefault(sku, 0)
+    return projection
+
+
+class TestReorderBoundary(unittest.TestCase):
+    def test_sku_exactly_at_threshold_is_suggested(self):
+        policy = ReorderPolicy({"widget": 10}, {"widget": 40})
+        out = policy.suggest(stock_at({"widget": 10}))
+        self.assertEqual([s.sku for s in out], ["widget"])
+        self.assertEqual(out[0].order_qty, 30)
+
+    def test_sku_below_threshold_is_still_suggested(self):
+        policy = ReorderPolicy({"widget": 10}, {"widget": 40})
+        out = policy.suggest(stock_at({"widget": 3}))
+        self.assertEqual([s.sku for s in out], ["widget"])
+        self.assertEqual(out[0].order_qty, 37)
+
+    def test_sku_above_threshold_is_not_suggested(self):
+        policy = ReorderPolicy({"widget": 10}, {"widget": 40})
+        self.assertEqual(policy.suggest(stock_at({"widget": 11})), [])
+
+    def test_target_already_reached_yields_nothing(self):
+        policy = ReorderPolicy({"widget": 40}, {"widget": 40})
+        self.assertEqual(policy.suggest(stock_at({"widget": 40})), [])
+
+    def test_multiple_skus_reported_in_sorted_order(self):
+        policy = ReorderPolicy({"b": 5, "a": 5}, {"b": 10, "a": 10})
+        out = policy.suggest(stock_at({"a": 5, "b": 5}))
+        self.assertEqual([s.sku for s in out], ["a", "b"])

source/corpus/python/ledger/tasks/audit-findings/tests/test_valuation.py

@@ -0,0 +1,64 @@
+import unittest
+
+from ledger import EventStore, Valuation
+
+
+def valued(events):
+    store = EventStore()
+    for kind, sku, *rest in events:
+        getattr(store, kind)(sku, *rest)
+    valuation = Valuation()
+    valuation.catch_up(store)
+    return valuation
+
+
+class TestFifoCostBasis(unittest.TestCase):
+    def test_oldest_lot_is_consumed_first(self):
+        v = valued([("receive", "w", 10, 1.00),
+                    ("receive", "w", 10, 3.00),
+                    ("ship", "w", 10)])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 10.00)
+        self.assertAlmostEqual(v.value_of("w"), 30.00)
+
+    def test_shipment_spanning_two_lots(self):
+        v = valued([("receive", "w", 10, 1.00),
+                    ("receive", "w", 10, 3.00),
+                    ("ship", "w", 15)])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 10 * 1.00 + 5 * 3.00)
+        self.assertAlmostEqual(v.value_of("w"), 5 * 3.00)
+
+    def test_three_lots_consumed_in_arrival_order(self):
+        v = valued([("receive", "w", 5, 1.00),
+                    ("receive", "w", 5, 2.00),
+                    ("receive", "w", 5, 4.00),
+                    ("ship", "w", 12)])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 5 * 1.0 + 5 * 2.0 + 2 * 4.0)
+        self.assertAlmostEqual(v.value_of("w"), 3 * 4.00)
+
+    def test_negative_adjustment_also_consumes_oldest_first(self):
+        v = valued([("receive", "w", 10, 1.00),
+                    ("receive", "w", 10, 3.00),
+                    ("adjust", "w", -10, "stocktake")])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 10.00)
+        self.assertAlmostEqual(v.value_of("w"), 30.00)
+
+
+class TestValuationInvariants(unittest.TestCase):
+    def test_single_lot_is_unaffected(self):
+        v = valued([("receive", "w", 10, 2.00), ("ship", "w", 4)])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 8.00)
+        self.assertAlmostEqual(v.value_of("w"), 12.00)
+
+    def test_full_depletion_leaves_no_value(self):
+        v = valued([("receive", "w", 5, 1.00),
+                    ("receive", "w", 5, 9.00),
+                    ("ship", "w", 10)])
+        self.assertAlmostEqual(v.value_of("w"), 0.00)
+        self.assertAlmostEqual(v.cost_of_goods_sold, 50.00)
+
+    def test_separate_skus_do_not_interfere(self):
+        v = valued([("receive", "a", 5, 1.00),
+                    ("receive", "b", 5, 7.00),
+                    ("ship", "a", 5)])
+        self.assertAlmostEqual(v.value_of("b"), 35.00)
+        self.assertAlmostEqual(v.cost_of_goods_sold, 5.00)

source/corpus/python/ledger/tasks/audit2-01/break/ledger/policies.py

@@ -0,0 +1,86 @@
+"""Decisions taken on top of the read models.
+
+Nothing here touches the event log directly. Policies read a projection and
+return a plan; committing that plan is the caller's business.
+"""
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Sequence, Tuple
+
+from .errors import InsufficientStock, UnknownSku
+from .projections import StockProjection
+
+
+@dataclass(frozen=True)
+class Warehouse:
+    """A stocking location, with a priority used to break ties."""
+    name: str
+    priority: int
+    on_hand: int
+
+
+@dataclass(frozen=True)
+class ReorderSuggestion:
+    sku: str
+    order_qty: int
+    reason: str
+
+
+class ReorderPolicy:
+    """Suggests replenishment when a SKU falls to or below its threshold.
+
+    The comparison is deliberately inclusive: a SKU sitting exactly on its
+    reorder point has reached it, and waiting for it to drop further is how a
+    warehouse runs out during the lead time.
+    """
+
+    def __init__(self, thresholds: Dict[str, int], target: Dict[str, int]):
+        self.thresholds = dict(thresholds)
+        self.target = dict(target)
+
+    def threshold_for(self, sku: str) -> int:
+        if sku not in self.thresholds:
+            raise UnknownSku(sku)
+        return self.thresholds[sku]
+
+    def suggest(self, stock: StockProjection) -> List[ReorderSuggestion]:
+        """One suggestion per SKU at or below its reorder point."""
+        out: List[ReorderSuggestion] = []
+        for sku in sorted(self.thresholds):
+            level = stock.levels.get(sku, 0)
+            threshold = self.thresholds[sku]
+            if level <= threshold:
+                target = self.target.get(sku, threshold * 2)
+                qty = target - level
+                if qty > 0:
+                    out.append(ReorderSuggestion(
+                        sku=sku, order_qty=qty,
+                        reason=f"level {level} at or below threshold {threshold}"))
+        return out
+
+
+def allocate(demand: int, warehouses: Sequence[Warehouse]) -> List[Tuple[str, int]]:
+    """Split `demand` across warehouses, highest priority first.
+
+    Ties on priority are broken by name so the result is deterministic. The
+    input sequence is never mutated -- callers reuse their warehouse list
+    across several allocations and would otherwise see it quietly emptied.
+    """
+    if demand <= 0:
+        raise ValueError("demand must be positive")
+
+    ordered = warehouses
+    ordered.sort(key=lambda w: (-w.priority, w.name))
+    available = sum(w.on_hand for w in ordered)
+    if available < demand:
+        raise InsufficientStock("<multiple>", demand, available)
+
+    plan: List[Tuple[str, int]] = []
+    remaining = demand
+    for warehouse in ordered:
+        if remaining <= 0:
+            break
+        take = min(warehouse.on_hand, remaining)
+        if take > 0:
+            plan.append((warehouse.name, take))
+            remaining -= take
+    return plan

source/corpus/python/ledger/tasks/audit2-01/break/ledger/store.py

@@ -0,0 +1,95 @@
+"""Append-only event store with snapshot support.
+
+The store owns sequence numbering. Nothing else in the package is allowed to
+assign a sequence number, because the ordering guarantee that projections rely
+on is only as good as the single place that hands the numbers out.
+"""
+from typing import Dict, Iterable, Iterator, List, Optional
+
+from .errors import SequenceError
+from .events import Adjusted, Event, Received, Shipped
+
+
+class EventStore:
+    """Holds every event ever appended, in order."""
+
+    def __init__(self) -> None:
+        self._events: List[Event] = []
+        self._next_seq: int = 1
+        self._clock: float = 0.0
+
+    # -- writing ---------------------------------------------------------
+
+    def _tick(self) -> float:
+        self._clock += 1.0
+        return self._clock
+
+    def _append(self, event: Event) -> Event:
+        if event.seq != self._next_seq:
+            raise SequenceError(
+                f"expected seq {self._next_seq}, got {event.seq}")
+        self._events.append(event)
+        self._next_seq += 1
+        return event
+
+    def receive(self, sku: str, qty: int, unit_cost: float) -> Received:
+        """Record stock arriving."""
+        if qty <= 0:
+            raise ValueError("received quantity must be positive")
+        return self._append(
+            Received(seq=self._next_seq, ts=self._tick(), sku=sku,
+                     qty=qty, unit_cost=unit_cost))
+
+    def ship(self, sku: str, qty: int) -> Shipped:
+        """Record stock leaving. Does not itself check availability."""
+        if qty <= 0:
+            raise ValueError("shipped quantity must be positive")
+        return self._append(
+            Shipped(seq=self._next_seq, ts=self._tick(), sku=sku, qty=qty))
+
+    def adjust(self, sku: str, delta: int, reason: str) -> Adjusted:
+        """Record a stocktake correction."""
+        if delta == 0:
+            raise ValueError("adjustment delta must not be zero")
+        return self._append(
+            Adjusted(seq=self._next_seq, ts=self._tick(), sku=sku,
+                     delta=delta, reason=reason))
+
+    # -- reading ---------------------------------------------------------
+
+    def __len__(self) -> int:
+        return len(self._events)
+
+    def __iter__(self) -> Iterator[Event]:
+        return iter(self._events)
+
+    @property
+    def head(self) -> int:
+        """Sequence number of the most recent event, or 0 when empty."""
+        return self._events[-1].seq if self._events else 0
+
+    def since(self, seq: int) -> List[Event]:
+        """Every event appended strictly after `seq`.
+
+        A projection resumes by passing the sequence number it last applied, so
+        this must be exclusive at the lower bound. Making it inclusive would
+        replay one already-applied event on every resume.
+        """
+        return [e for e in self._events if e.seq > seq]
+
+    def between(self, low: int, high: int) -> List[Event]:
+        """Events with low < seq <= high."""
+        return [e for e in self._events if low <= e.seq <= high]
+
+    def for_sku(self, sku: str) -> List[Event]:
+        return [e for e in self._events if e.sku == sku]
+
+    def skus(self) -> List[str]:
+        seen: Dict[str, None] = {}
+        for event in self._events:
+            seen.setdefault(event.sku, None)
+        return list(seen)
+
+    def replay(self, events: Optional[Iterable[Event]] = None) -> List[Event]:
+        """Materialise an event iterable, defaulting to the whole log."""
+        return list(self._events if events is None else events)

source/corpus/python/ledger/tasks/audit2-01/task.json

@@ -0,0 +1,11 @@
+{
+  "lang": "python",
+  "category": "logic",
+  "difficulty": 5,
+  "compound": true,
+  "ingredients": [
+    "allocate-mutates",
+    "between-boundary"
+  ],
+  "instruction": "2 findings from this week's triage. They have separate causes and are not related to one another; all 2 need fixing.\n\n1. A caller that allocates twice from the same warehouse list gets a different plan the second time, and reports that their own list comes back reordered afterwards.\n   allocate() is supposed to be free of side effects on its arguments. Fix it.\n\n2. Our per-period stock report double-counts events on period boundaries.\n   Consecutive reports are produced by asking the store for the events between the\n   previous report's last sequence number and the current one. An event landing\n   exactly on a boundary shows up in both the earlier report and the later one.\n   The range is documented as excluding its lower bound and including its upper."
+}

source/corpus/python/ledger/tasks/audit2-01/tests/test_allocate.py

@@ -0,0 +1,41 @@
+import unittest
+
+from ledger import allocate
+from ledger.policies import Warehouse
+
+
+def houses():
+    return [Warehouse("north", 1, 5),
+            Warehouse("south", 3, 5),
+            Warehouse("east", 2, 5)]
+
+
+class TestAllocateIsPure(unittest.TestCase):
+    def test_caller_list_order_is_untouched(self):
+        warehouses = houses()
+        before = [w.name for w in warehouses]
+        allocate(6, warehouses)
+        self.assertEqual([w.name for w in warehouses], before)
+
+    def test_repeated_calls_agree(self):
+        warehouses = houses()
+        first = allocate(7, warehouses)
+        second = allocate(7, warehouses)
+        self.assertEqual(first, second)
+
+
+class TestAllocateBehaviour(unittest.TestCase):
+    def test_highest_priority_first(self):
+        self.assertEqual(allocate(5, houses()), [("south", 5)])
+
+    def test_spills_into_next_priority(self):
+        self.assertEqual(allocate(8, houses()), [("south", 5), ("east", 3)])
+
+    def test_ties_broken_by_name(self):
+        tied = [Warehouse("b", 5, 2), Warehouse("a", 5, 2)]
+        self.assertEqual(allocate(3, tied), [("a", 2), ("b", 1)])
+
+    def test_insufficient_stock_raises(self):
+        from ledger.errors import InsufficientStock
+        with self.assertRaises(InsufficientStock):
+            allocate(999, houses())

source/corpus/python/ledger/tasks/audit2-01/tests/test_between.py

@@ -0,0 +1,41 @@
+
+import unittest
+
+from ledger import EventStore
+
+
+def store_with(n):
+    store = EventStore()
+    for i in range(n):
+        store.receive(f"sku{i}", 1, 1.0)
+    return store
+
+
+class TestBetweenIsHalfOpen(unittest.TestCase):
+    def test_lower_bound_is_excluded(self):
+        self.assertEqual([e.seq for e in store_with(5).between(2, 4)], [3, 4])
+
+    def test_consecutive_ranges_do_not_overlap(self):
+        store = store_with(6)
+        first = {e.seq for e in store.between(0, 3)}
+        second = {e.seq for e in store.between(3, 6)}
+        self.assertEqual(first & second, set())
+
+    def test_consecutive_ranges_leave_no_gap(self):
+        store = store_with(6)
+        seen = {e.seq for e in store.between(0, 3)} | {e.seq for e in store.between(3, 6)}
+        self.assertEqual(seen, {1, 2, 3, 4, 5, 6})
+
+    def test_empty_range(self):
+        self.assertEqual(store_with(5).between(3, 3), [])
+
+
+class TestBetweenOtherwiseWorks(unittest.TestCase):
+    def test_upper_bound_is_included(self):
+        self.assertIn(4, [e.seq for e in store_with(5).between(2, 4)])
+
+    def test_full_range(self):
+        self.assertEqual(len(store_with(5).between(0, 5)), 5)
+
+    def test_beyond_the_end(self):
+        self.assertEqual(len(store_with(3).between(0, 99)), 3)

source/corpus/python/ledger/tasks/audit2-02/break/ledger/policies.py

@@ -0,0 +1,86 @@
+"""Decisions taken on top of the read models.
+
+Nothing here touches the event log directly. Policies read a projection and
+return a plan; committing that plan is the caller's business.
+"""
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Sequence, Tuple
+
+from .errors import InsufficientStock, UnknownSku
+from .projections import StockProjection
+
+
+@dataclass(frozen=True)
+class Warehouse:
+    """A stocking location, with a priority used to break ties."""
+    name: str
+    priority: int
+    on_hand: int
+
+
+@dataclass(frozen=True)
+class ReorderSuggestion:
+    sku: str
+    order_qty: int
+    reason: str
+
+
+class ReorderPolicy:
+    """Suggests replenishment when a SKU falls to or below its threshold.
+
+    The comparison is deliberately inclusive: a SKU sitting exactly on its
+    reorder point has reached it, and waiting for it to drop further is how a
+    warehouse runs out during the lead time.
+    """
+
+    def __init__(self, thresholds: Dict[str, int], target: Dict[str, int]):
+        self.thresholds = dict(thresholds)
+        self.target = dict(target)
+
+    def threshold_for(self, sku: str) -> int:
+        if sku not in self.thresholds:
+            raise UnknownSku(sku)
+        return self.thresholds[sku]
+
+    def suggest(self, stock: StockProjection) -> List[ReorderSuggestion]:
+        """One suggestion per SKU at or below its reorder point."""
+        out: List[ReorderSuggestion] = []
+        for sku in sorted(self.thresholds):
+            level = stock.levels.get(sku, 0)
+            threshold = self.thresholds[sku]
+            if level <= threshold:
+                target = self.target.get(sku, threshold * 2)
+                qty = target - level
+                if qty > 0:
+                    out.append(ReorderSuggestion(
+                        sku=sku, order_qty=qty,
+                        reason=f"level {level} at or below threshold {threshold}"))
+        return out
+
+
+def allocate(demand: int, warehouses: Sequence[Warehouse]) -> List[Tuple[str, int]]:
+    """Split `demand` across warehouses, highest priority first.
+
+    Ties on priority are broken by name so the result is deterministic. The
+    input sequence is never mutated -- callers reuse their warehouse list
+    across several allocations and would otherwise see it quietly emptied.
+    """
+    if demand <= 0:
+        raise ValueError("demand must be positive")
+
+    ordered = warehouses
+    ordered.sort(key=lambda w: (-w.priority, w.name))
+    available = sum(w.on_hand for w in ordered)
+    if available < demand:
+        raise InsufficientStock("<multiple>", demand, available)
+
+    plan: List[Tuple[str, int]] = []
+    remaining = demand
+    for warehouse in ordered:
+        if remaining <= 0:
+            break
+        take = min(warehouse.on_hand, remaining)
+        if take > 0:
+            plan.append((warehouse.name, take))
+            remaining -= take
+    return plan

source/corpus/python/ledger/tasks/audit2-02/break/ledger/projections.py

@@ -0,0 +1,112 @@
+"""Read models built by folding the event log.
+
+A projection is resumable: it remembers the last sequence number it applied
+and asks the store only for what came after. That is what keeps a long ledger
+cheap to query, and it is why the store's `since` boundary matters so much.
+"""
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+from .errors import SequenceError, UnknownSku
+from .events import Adjusted, Event, Received, Shipped
+from .store import EventStore
+
+
+class StockProjection:
+    """Units on hand per SKU."""
+
+    def __init__(self) -> None:
+        self.levels: Dict[str, int] = {}
+        self.last_seq: int = 0
+
+    def apply(self, event: Event) -> None:
+        """Fold a single event into the running totals."""
+        if event.seq <= self.last_seq:
+            raise SequenceError(
+                f"event {event.seq} already applied (at {self.last_seq})")
+        current = self.levels.get(event.sku, 0)
+        if isinstance(event, Received):
+            current += event.qty
+        elif isinstance(event, Shipped):
+            current -= event.qty
+        elif isinstance(event, Adjusted):
+            current += event.delta
+        self.levels[event.sku] = current
+        self.last_seq = event.seq
+
+    def catch_up(self, store: EventStore) -> int:
+        """Apply everything appended since the last call. Returns the count."""
+        pending = store.since(self.last_seq)
+        for event in pending:
+            self.apply(event)
+        return len(pending)
+
+    def on_hand(self, sku: str) -> int:
+        if sku not in self.levels:
+            raise UnknownSku(sku)
+        return self.levels[sku]
+
+    def negative_skus(self) -> List[str]:
+        """SKUs the log says we hold a negative quantity of."""
+        return sorted(s for s, n in self.levels.items() if n < 0)
+
+
+@dataclass
+class Lot:
+    """One receipt still carrying unconsumed units."""
+    seq: int
+    qty: int
+    unit_cost: float
+
+
+class Valuation:
+    """Inventory value under first-in, first-out cost basis."""
+
+    def __init__(self) -> None:
+        self.lots: Dict[str, List[Lot]] = {}
+        self.last_seq: int = 0
+        self.cost_of_goods_sold: float = 0.0
+
+    def apply(self, event: Event) -> None:
+        lots = self.lots.setdefault(event.sku, [])
+        if isinstance(event, Received):
+            lots.append(Lot(seq=event.seq, qty=event.qty,
+                            unit_cost=event.unit_cost))
+        elif isinstance(event, Shipped):
+            self._consume(lots, event.qty)
+        elif isinstance(event, Adjusted):
+            if event.delta > 0:
+                unit_cost = lots[-1].unit_cost if lots else 0.0
+                lots.append(Lot(seq=event.seq, qty=event.delta,
+                                unit_cost=unit_cost))
+            else:
+                self._consume(lots, -event.delta)
+        self.last_seq = event.seq
+
+    def _consume(self, lots: List[Lot], qty: int) -> None:
+        """Draw `qty` units from the oldest lots first."""
+        remaining = qty
+        while remaining > 0 and lots:
+            oldest = lots[-1]
+            take = min(oldest.qty, remaining)
+            self.cost_of_goods_sold += take * oldest.unit_cost
+            oldest.qty -= take
+            remaining -= take
+            if oldest.qty == 0:
+                lots.pop()
+
+    def catch_up(self, store: EventStore) -> int:
+        pending = store.since(self.last_seq)
+        for event in pending:
+            self.apply(event)
+        return len(pending)
+
+    def value_of(self, sku: str) -> float:
+        """Total carrying value of the units still on hand for one SKU."""
+        if sku not in self.lots:
+            raise UnknownSku(sku)
+        return sum(lot.qty * lot.unit_cost for lot in self.lots[sku])
+
+    def total_value(self) -> float:
+        return sum(lot.qty * lot.unit_cost
+                   for lots in self.lots.values() for lot in lots)

source/corpus/python/ledger/tasks/audit2-02/task.json

@@ -0,0 +1,11 @@
+{
+  "lang": "python",
+  "category": "logic",
+  "difficulty": 5,
+  "compound": true,
+  "ingredients": [
+    "allocate-mutates",
+    "fifo-lifo"
+  ],
+  "instruction": "2 findings from this week's triage. They have separate causes and are not related to one another; all 2 need fixing.\n\n1. A caller that allocates twice from the same warehouse list gets a different plan the second time, and reports that their own list comes back reordered afterwards.\n   allocate() is supposed to be free of side effects on its arguments. Fix it.\n\n2. Our finance team reports that inventory valuation and cost of goods sold are wrong whenever a SKU has been received at more than one unit cost.\n   Concrete case: receive 10 units at 1.00, then 10 units at 3.00, then ship 10 units. Cost of goods sold should be 10.00 and the remaining inventory should be valued at 30.00. We are getting those two numbers the other way round.\n   The ledger is documented as valuing inventory on a first-in, first-out basis. Make it do that."
+}

source/corpus/python/ledger/tasks/audit2-02/tests/test_allocate.py

@@ -0,0 +1,41 @@
+import unittest
+
+from ledger import allocate
+from ledger.policies import Warehouse
+
+
+def houses():
+    return [Warehouse("north", 1, 5),
+            Warehouse("south", 3, 5),
+            Warehouse("east", 2, 5)]
+
+
+class TestAllocateIsPure(unittest.TestCase):
+    def test_caller_list_order_is_untouched(self):
+        warehouses = houses()
+        before = [w.name for w in warehouses]
+        allocate(6, warehouses)
+        self.assertEqual([w.name for w in warehouses], before)
+
+    def test_repeated_calls_agree(self):
+        warehouses = houses()
+        first = allocate(7, warehouses)
+        second = allocate(7, warehouses)
+        self.assertEqual(first, second)
+
+
+class TestAllocateBehaviour(unittest.TestCase):
+    def test_highest_priority_first(self):
+        self.assertEqual(allocate(5, houses()), [("south", 5)])
+
+    def test_spills_into_next_priority(self):
+        self.assertEqual(allocate(8, houses()), [("south", 5), ("east", 3)])
+
+    def test_ties_broken_by_name(self):
+        tied = [Warehouse("b", 5, 2), Warehouse("a", 5, 2)]
+        self.assertEqual(allocate(3, tied), [("a", 2), ("b", 1)])
+
+    def test_insufficient_stock_raises(self):
+        from ledger.errors import InsufficientStock
+        with self.assertRaises(InsufficientStock):
+            allocate(999, houses())

source/corpus/python/ledger/tasks/audit2-02/tests/test_valuation.py

@@ -0,0 +1,64 @@
+import unittest
+
+from ledger import EventStore, Valuation
+
+
+def valued(events):
+    store = EventStore()
+    for kind, sku, *rest in events:
+        getattr(store, kind)(sku, *rest)
+    valuation = Valuation()
+    valuation.catch_up(store)
+    return valuation
+
+
+class TestFifoCostBasis(unittest.TestCase):
+    def test_oldest_lot_is_consumed_first(self):
+        v = valued([("receive", "w", 10, 1.00),
+                    ("receive", "w", 10, 3.00),
+                    ("ship", "w", 10)])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 10.00)
+        self.assertAlmostEqual(v.value_of("w"), 30.00)
+
+    def test_shipment_spanning_two_lots(self):
+        v = valued([("receive", "w", 10, 1.00),
+                    ("receive", "w", 10, 3.00),
+                    ("ship", "w", 15)])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 10 * 1.00 + 5 * 3.00)
+        self.assertAlmostEqual(v.value_of("w"), 5 * 3.00)
+
+    def test_three_lots_consumed_in_arrival_order(self):
+        v = valued([("receive", "w", 5, 1.00),
+                    ("receive", "w", 5, 2.00),
+                    ("receive", "w", 5, 4.00),
+                    ("ship", "w", 12)])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 5 * 1.0 + 5 * 2.0 + 2 * 4.0)
+        self.assertAlmostEqual(v.value_of("w"), 3 * 4.00)
+
+    def test_negative_adjustment_also_consumes_oldest_first(self):
+        v = valued([("receive", "w", 10, 1.00),
+                    ("receive", "w", 10, 3.00),
+                    ("adjust", "w", -10, "stocktake")])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 10.00)
+        self.assertAlmostEqual(v.value_of("w"), 30.00)
+
+
+class TestValuationInvariants(unittest.TestCase):
+    def test_single_lot_is_unaffected(self):
+        v = valued([("receive", "w", 10, 2.00), ("ship", "w", 4)])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 8.00)
+        self.assertAlmostEqual(v.value_of("w"), 12.00)
+
+    def test_full_depletion_leaves_no_value(self):
+        v = valued([("receive", "w", 5, 1.00),
+                    ("receive", "w", 5, 9.00),
+                    ("ship", "w", 10)])
+        self.assertAlmostEqual(v.value_of("w"), 0.00)
+        self.assertAlmostEqual(v.cost_of_goods_sold, 50.00)
+
+    def test_separate_skus_do_not_interfere(self):
+        v = valued([("receive", "a", 5, 1.00),
+                    ("receive", "b", 5, 7.00),
+                    ("ship", "a", 5)])
+        self.assertAlmostEqual(v.value_of("b"), 35.00)
+        self.assertAlmostEqual(v.cost_of_goods_sold, 5.00)

source/corpus/python/ledger/tasks/audit2-03/break/ledger/policies.py

@@ -0,0 +1,86 @@
+"""Decisions taken on top of the read models.
+
+Nothing here touches the event log directly. Policies read a projection and
+return a plan; committing that plan is the caller's business.
+"""
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Sequence, Tuple
+
+from .errors import InsufficientStock, UnknownSku
+from .projections import StockProjection
+
+
+@dataclass(frozen=True)
+class Warehouse:
+    """A stocking location, with a priority used to break ties."""
+    name: str
+    priority: int
+    on_hand: int
+
+
+@dataclass(frozen=True)
+class ReorderSuggestion:
+    sku: str
+    order_qty: int
+    reason: str
+
+
+class ReorderPolicy:
+    """Suggests replenishment when a SKU falls to or below its threshold.
+
+    The comparison is deliberately inclusive: a SKU sitting exactly on its
+    reorder point has reached it, and waiting for it to drop further is how a
+    warehouse runs out during the lead time.
+    """
+
+    def __init__(self, thresholds: Dict[str, int], target: Dict[str, int]):
+        self.thresholds = dict(thresholds)
+        self.target = dict(target)
+
+    def threshold_for(self, sku: str) -> int:
+        if sku not in self.thresholds:
+            raise UnknownSku(sku)
+        return self.thresholds[sku]
+
+    def suggest(self, stock: StockProjection) -> List[ReorderSuggestion]:
+        """One suggestion per SKU at or below its reorder point."""
+        out: List[ReorderSuggestion] = []
+        for sku in sorted(self.thresholds):
+            level = stock.levels.get(sku, 0)
+            threshold = self.thresholds[sku]
+            if level <= threshold:
+                target = self.target.get(sku, threshold * 2)
+                qty = target - level
+                if qty > 0:
+                    out.append(ReorderSuggestion(
+                        sku=sku, order_qty=qty,
+                        reason=f"level {level} at or below threshold {threshold}"))
+        return out
+
+
+def allocate(demand: int, warehouses: Sequence[Warehouse]) -> List[Tuple[str, int]]:
+    """Split `demand` across warehouses, highest priority first.
+
+    Ties on priority are broken by name so the result is deterministic. The
+    input sequence is never mutated -- callers reuse their warehouse list
+    across several allocations and would otherwise see it quietly emptied.
+    """
+    if demand <= 0:
+        raise ValueError("demand must be positive")
+
+    ordered = warehouses
+    ordered.sort(key=lambda w: (-w.priority, w.name))
+    available = sum(w.on_hand for w in ordered)
+    if available < demand:
+        raise InsufficientStock("<multiple>", demand, available)
+
+    plan: List[Tuple[str, int]] = []
+    remaining = demand
+    for warehouse in ordered:
+        if remaining <= 0:
+            break
+        take = min(warehouse.on_hand, remaining)
+        if take > 0:
+            plan.append((warehouse.name, take))
+            remaining -= take
+    return plan

source/corpus/python/ledger/tasks/audit2-03/break/ledger/projections.py

@@ -0,0 +1,112 @@
+"""Read models built by folding the event log.
+
+A projection is resumable: it remembers the last sequence number it applied
+and asks the store only for what came after. That is what keeps a long ledger
+cheap to query, and it is why the store's `since` boundary matters so much.
+"""
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+from .errors import SequenceError, UnknownSku
+from .events import Adjusted, Event, Received, Shipped
+from .store import EventStore
+
+
+class StockProjection:
+    """Units on hand per SKU."""
+
+    def __init__(self) -> None:
+        self.levels: Dict[str, int] = {}
+        self.last_seq: int = 0
+
+    def apply(self, event: Event) -> None:
+        """Fold a single event into the running totals."""
+        if event.seq <= self.last_seq:
+            raise SequenceError(
+                f"event {event.seq} already applied (at {self.last_seq})")
+        current = self.levels.get(event.sku, 0)
+        if isinstance(event, Received):
+            current += event.qty
+        elif isinstance(event, Shipped):
+            current -= event.qty
+        elif isinstance(event, Adjusted):
+            current += event.delta
+        self.levels[event.sku] = current
+        self.last_seq = event.seq
+
+    def catch_up(self, store: EventStore) -> int:
+        """Apply everything appended since the last call. Returns the count."""
+        pending = store.since(self.last_seq)
+        for event in pending:
+            self.apply(event)
+        return len(pending)
+
+    def on_hand(self, sku: str) -> int:
+        if sku not in self.levels:
+            raise UnknownSku(sku)
+        return self.levels[sku]
+
+    def negative_skus(self) -> List[str]:
+        """SKUs the log says we hold a negative quantity of."""
+        return sorted(s for s, n in self.levels.items() if n < 0)
+
+
+@dataclass
+class Lot:
+    """One receipt still carrying unconsumed units."""
+    seq: int
+    qty: int
+    unit_cost: float
+
+
+class Valuation:
+    """Inventory value under first-in, first-out cost basis."""
+
+    def __init__(self) -> None:
+        self.lots: Dict[str, List[Lot]] = {}
+        self.last_seq: int = 0
+        self.cost_of_goods_sold: float = 0.0
+
+    def apply(self, event: Event) -> None:
+        lots = self.lots.setdefault(event.sku, [])
+        if isinstance(event, Received):
+            lots.append(Lot(seq=event.seq, qty=event.qty,
+                            unit_cost=event.unit_cost))
+        elif isinstance(event, Shipped):
+            self._consume(lots, event.qty)
+        elif isinstance(event, Adjusted):
+            if event.delta > 0:
+                unit_cost = lots[-1].unit_cost if lots else 0.0
+                lots.append(Lot(seq=event.seq, qty=event.delta,
+                                unit_cost=unit_cost))
+            else:
+                self._consume(lots, -event.delta)
+        self.last_seq = event.seq
+
+    def _consume(self, lots: List[Lot], qty: int) -> None:
+        """Draw `qty` units from the oldest lots first."""
+        remaining = qty
+        while remaining > 0 and lots:
+            oldest = lots[-1]
+            take = min(oldest.qty, remaining)
+            self.cost_of_goods_sold += take * oldest.unit_cost
+            oldest.qty -= take
+            remaining -= take
+            if oldest.qty == 0:
+                lots.pop()
+
+    def catch_up(self, store: EventStore) -> int:
+        pending = store.since(self.last_seq)
+        for event in pending:
+            self.apply(event)
+        return len(pending)
+
+    def value_of(self, sku: str) -> float:
+        """Total carrying value of the units still on hand for one SKU."""
+        if sku not in self.lots:
+            raise UnknownSku(sku)
+        return sum(lot.qty * lot.unit_cost for lot in self.lots[sku])
+
+    def total_value(self) -> float:
+        return sum(lot.qty * lot.unit_cost
+                   for lots in self.lots.values() for lot in lots)

source/corpus/python/ledger/tasks/audit2-03/break/ledger/store.py

@@ -0,0 +1,95 @@
+"""Append-only event store with snapshot support.
+
+The store owns sequence numbering. Nothing else in the package is allowed to
+assign a sequence number, because the ordering guarantee that projections rely
+on is only as good as the single place that hands the numbers out.
+"""
+from typing import Dict, Iterable, Iterator, List, Optional
+
+from .errors import SequenceError
+from .events import Adjusted, Event, Received, Shipped
+
+
+class EventStore:
+    """Holds every event ever appended, in order."""
+
+    def __init__(self) -> None:
+        self._events: List[Event] = []
+        self._next_seq: int = 1
+        self._clock: float = 0.0
+
+    # -- writing ---------------------------------------------------------
+
+    def _tick(self) -> float:
+        self._clock += 1.0
+        return self._clock
+
+    def _append(self, event: Event) -> Event:
+        if event.seq != self._next_seq:
+            raise SequenceError(
+                f"expected seq {self._next_seq}, got {event.seq}")
+        self._events.append(event)
+        self._next_seq += 1
+        return event
+
+    def receive(self, sku: str, qty: int, unit_cost: float) -> Received:
+        """Record stock arriving."""
+        if qty <= 0:
+            raise ValueError("received quantity must be positive")
+        return self._append(
+            Received(seq=self._next_seq, ts=self._tick(), sku=sku,
+                     qty=qty, unit_cost=unit_cost))
+
+    def ship(self, sku: str, qty: int) -> Shipped:
+        """Record stock leaving. Does not itself check availability."""
+        if qty <= 0:
+            raise ValueError("shipped quantity must be positive")
+        return self._append(
+            Shipped(seq=self._next_seq, ts=self._tick(), sku=sku, qty=qty))
+
+    def adjust(self, sku: str, delta: int, reason: str) -> Adjusted:
+        """Record a stocktake correction."""
+        if delta == 0:
+            raise ValueError("adjustment delta must not be zero")
+        return self._append(
+            Adjusted(seq=self._next_seq, ts=self._tick(), sku=sku,
+                     delta=delta, reason=reason))
+
+    # -- reading ---------------------------------------------------------
+
+    def __len__(self) -> int:
+        return len(self._events)
+
+    def __iter__(self) -> Iterator[Event]:
+        return iter(self._events)
+
+    @property
+    def head(self) -> int:
+        """Sequence number of the most recent event, or 0 when empty."""
+        return self._events[-1].seq if self._events else 0
+
+    def since(self, seq: int) -> List[Event]:
+        """Every event appended strictly after `seq`.
+
+        A projection resumes by passing the sequence number it last applied, so
+        this must be exclusive at the lower bound. Making it inclusive would
+        replay one already-applied event on every resume.
+        """
+        return [e for e in self._events if e.seq >= seq]
+
+    def between(self, low: int, high: int) -> List[Event]:
+        """Events with low < seq <= high."""
+        return [e for e in self._events if low < e.seq <= high]
+
+    def for_sku(self, sku: str) -> List[Event]:
+        return [e for e in self._events if e.sku == sku]
+
+    def skus(self) -> List[str]:
+        seen: Dict[str, None] = {}
+        for event in self._events:
+            seen.setdefault(event.sku, None)
+        return list(seen)
+
+    def replay(self, events: Optional[Iterable[Event]] = None) -> List[Event]:
+        """Materialise an event iterable, defaulting to the whole log."""
+        return list(self._events if events is None else events)

source/corpus/python/ledger/tasks/audit2-03/task.json

@@ -0,0 +1,11 @@
+{
+  "lang": "python",
+  "category": "logic",
+  "difficulty": 5,
+  "compound": true,
+  "ingredients": [
+    "allocate-mutates",
+    "since-inclusive"
+  ],
+  "instruction": "2 findings from this week's triage. They have separate causes and are not related to one another; all 2 need fixing.\n\n1. A caller that allocates twice from the same warehouse list gets a different plan the second time, and reports that their own list comes back reordered afterwards.\n   allocate() is supposed to be free of side effects on its arguments. Fix it.\n\n2. Catching a projection up more than once crashes.\n   Reproduction: build an EventStore, receive some stock, call StockProjection.catch_up(store), append another event, then call catch_up(store) again. The second call raises SequenceError complaining that an event has already been applied.\n   A projection is supposed to be resumable -- repeatedly catching up must be safe, and calling it when nothing new has been appended must be a no-op that applies zero events. Find the underlying cause and fix it. Do not weaken the ledger's ordering guarantees to make the symptom disappear."
+}

source/corpus/python/ledger/tasks/audit2-03/tests/test_allocate.py

@@ -0,0 +1,41 @@
+import unittest
+
+from ledger import allocate
+from ledger.policies import Warehouse
+
+
+def houses():
+    return [Warehouse("north", 1, 5),
+            Warehouse("south", 3, 5),
+            Warehouse("east", 2, 5)]
+
+
+class TestAllocateIsPure(unittest.TestCase):
+    def test_caller_list_order_is_untouched(self):
+        warehouses = houses()
+        before = [w.name for w in warehouses]
+        allocate(6, warehouses)
+        self.assertEqual([w.name for w in warehouses], before)
+
+    def test_repeated_calls_agree(self):
+        warehouses = houses()
+        first = allocate(7, warehouses)
+        second = allocate(7, warehouses)
+        self.assertEqual(first, second)
+
+
+class TestAllocateBehaviour(unittest.TestCase):
+    def test_highest_priority_first(self):
+        self.assertEqual(allocate(5, houses()), [("south", 5)])
+
+    def test_spills_into_next_priority(self):
+        self.assertEqual(allocate(8, houses()), [("south", 5), ("east", 3)])
+
+    def test_ties_broken_by_name(self):
+        tied = [Warehouse("b", 5, 2), Warehouse("a", 5, 2)]
+        self.assertEqual(allocate(3, tied), [("a", 2), ("b", 1)])
+
+    def test_insufficient_stock_raises(self):
+        from ledger.errors import InsufficientStock
+        with self.assertRaises(InsufficientStock):
+            allocate(999, houses())

source/corpus/python/ledger/tasks/audit2-03/tests/test_between.py

@@ -0,0 +1,41 @@
+
+import unittest
+
+from ledger import EventStore
+
+
+def store_with(n):
+    store = EventStore()
+    for i in range(n):
+        store.receive(f"sku{i}", 1, 1.0)
+    return store
+
+
+class TestBetweenIsHalfOpen(unittest.TestCase):
+    def test_lower_bound_is_excluded(self):
+        self.assertEqual([e.seq for e in store_with(5).between(2, 4)], [3, 4])
+
+    def test_consecutive_ranges_do_not_overlap(self):
+        store = store_with(6)
+        first = {e.seq for e in store.between(0, 3)}
+        second = {e.seq for e in store.between(3, 6)}
+        self.assertEqual(first & second, set())
+
+    def test_consecutive_ranges_leave_no_gap(self):
+        store = store_with(6)
+        seen = {e.seq for e in store.between(0, 3)} | {e.seq for e in store.between(3, 6)}
+        self.assertEqual(seen, {1, 2, 3, 4, 5, 6})
+
+    def test_empty_range(self):
+        self.assertEqual(store_with(5).between(3, 3), [])
+
+
+class TestBetweenOtherwiseWorks(unittest.TestCase):
+    def test_upper_bound_is_included(self):
+        self.assertIn(4, [e.seq for e in store_with(5).between(2, 4)])
+
+    def test_full_range(self):
+        self.assertEqual(len(store_with(5).between(0, 5)), 5)
+
+    def test_beyond_the_end(self):
+        self.assertEqual(len(store_with(3).between(0, 99)), 3)

source/corpus/python/ledger/tasks/audit2-03/tests/test_catch_up.py

@@ -0,0 +1,56 @@
+import unittest
+
+from ledger import EventStore, StockProjection
+from ledger.errors import SequenceError
+
+
+class TestIncrementalCatchUp(unittest.TestCase):
+    def test_catch_up_twice_across_new_events(self):
+        store = EventStore()
+        store.receive("widget", 100, 2.50)
+        stock = StockProjection()
+        stock.catch_up(store)
+        store.ship("widget", 30)
+        stock.catch_up(store)
+        self.assertEqual(stock.on_hand("widget"), 70)
+
+    def test_catch_up_with_nothing_new_is_a_noop(self):
+        store = EventStore()
+        store.receive("widget", 10, 1.0)
+        stock = StockProjection()
+        self.assertEqual(stock.catch_up(store), 1)
+        self.assertEqual(stock.catch_up(store), 0)
+        self.assertEqual(stock.on_hand("widget"), 10)
+
+    def test_many_incremental_catch_ups_match_one_big_one(self):
+        incremental = StockProjection()
+        store = EventStore()
+        for i in range(1, 6):
+            store.receive("bolt", i * 10, 1.0)
+            incremental.catch_up(store)
+        oneshot = StockProjection()
+        oneshot.catch_up(store)
+        self.assertEqual(incremental.levels, oneshot.levels)
+        self.assertEqual(incremental.on_hand("bolt"), 150)
+
+
+class TestOrderingGuaranteesPreserved(unittest.TestCase):
+    """Deleting the ordering check would hide the symptom but corrupt totals."""
+
+    def test_replaying_an_applied_event_is_still_rejected(self):
+        store = EventStore()
+        store.receive("widget", 5, 1.0)
+        stock = StockProjection()
+        stock.catch_up(store)
+        already_applied = list(store)[0]
+        with self.assertRaises(SequenceError):
+            stock.apply(already_applied)
+
+    def test_store_since_is_exclusive_at_the_lower_bound(self):
+        store = EventStore()
+        store.receive("a", 1, 1.0)
+        store.receive("b", 1, 1.0)
+        store.receive("c", 1, 1.0)
+        self.assertEqual([e.seq for e in store.since(0)], [1, 2, 3])
+        self.assertEqual([e.seq for e in store.since(1)], [2, 3])
+        self.assertEqual([e.seq for e in store.since(3)], [])

source/corpus/python/ledger/tasks/audit2-03/tests/test_valuation.py

@@ -0,0 +1,64 @@
+import unittest
+
+from ledger import EventStore, Valuation
+
+
+def valued(events):
+    store = EventStore()
+    for kind, sku, *rest in events:
+        getattr(store, kind)(sku, *rest)
+    valuation = Valuation()
+    valuation.catch_up(store)
+    return valuation
+
+
+class TestFifoCostBasis(unittest.TestCase):
+    def test_oldest_lot_is_consumed_first(self):
+        v = valued([("receive", "w", 10, 1.00),
+                    ("receive", "w", 10, 3.00),
+                    ("ship", "w", 10)])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 10.00)
+        self.assertAlmostEqual(v.value_of("w"), 30.00)
+
+    def test_shipment_spanning_two_lots(self):
+        v = valued([("receive", "w", 10, 1.00),
+                    ("receive", "w", 10, 3.00),
+                    ("ship", "w", 15)])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 10 * 1.00 + 5 * 3.00)
+        self.assertAlmostEqual(v.value_of("w"), 5 * 3.00)
+
+    def test_three_lots_consumed_in_arrival_order(self):
+        v = valued([("receive", "w", 5, 1.00),
+                    ("receive", "w", 5, 2.00),
+                    ("receive", "w", 5, 4.00),
+                    ("ship", "w", 12)])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 5 * 1.0 + 5 * 2.0 + 2 * 4.0)
+        self.assertAlmostEqual(v.value_of("w"), 3 * 4.00)
+
+    def test_negative_adjustment_also_consumes_oldest_first(self):
+        v = valued([("receive", "w", 10, 1.00),
+                    ("receive", "w", 10, 3.00),
+                    ("adjust", "w", -10, "stocktake")])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 10.00)
+        self.assertAlmostEqual(v.value_of("w"), 30.00)
+
+
+class TestValuationInvariants(unittest.TestCase):
+    def test_single_lot_is_unaffected(self):
+        v = valued([("receive", "w", 10, 2.00), ("ship", "w", 4)])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 8.00)
+        self.assertAlmostEqual(v.value_of("w"), 12.00)
+
+    def test_full_depletion_leaves_no_value(self):
+        v = valued([("receive", "w", 5, 1.00),
+                    ("receive", "w", 5, 9.00),
+                    ("ship", "w", 10)])
+        self.assertAlmostEqual(v.value_of("w"), 0.00)
+        self.assertAlmostEqual(v.cost_of_goods_sold, 50.00)
+
+    def test_separate_skus_do_not_interfere(self):
+        v = valued([("receive", "a", 5, 1.00),
+                    ("receive", "b", 5, 7.00),
+                    ("ship", "a", 5)])
+        self.assertAlmostEqual(v.value_of("b"), 35.00)
+        self.assertAlmostEqual(v.cost_of_goods_sold, 5.00)

source/corpus/python/ledger/tasks/audit2-04/break/ledger/policies.py

@@ -0,0 +1,85 @@
+"""Decisions taken on top of the read models.
+
+Nothing here touches the event log directly. Policies read a projection and
+return a plan; committing that plan is the caller's business.
+"""
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Sequence, Tuple
+
+from .errors import InsufficientStock, UnknownSku
+from .projections import StockProjection
+
+
+@dataclass(frozen=True)
+class Warehouse:
+    """A stocking location, with a priority used to break ties."""
+    name: str
+    priority: int
+    on_hand: int
+
+
+@dataclass(frozen=True)
+class ReorderSuggestion:
+    sku: str
+    order_qty: int
+    reason: str
+
+
+class ReorderPolicy:
+    """Suggests replenishment when a SKU falls to or below its threshold.
+
+    The comparison is deliberately inclusive: a SKU sitting exactly on its
+    reorder point has reached it, and waiting for it to drop further is how a
+    warehouse runs out during the lead time.
+    """
+
+    def __init__(self, thresholds: Dict[str, int], target: Dict[str, int]):
+        self.thresholds = dict(thresholds)
+        self.target = dict(target)
+
+    def threshold_for(self, sku: str) -> int:
+        if sku not in self.thresholds:
+            raise UnknownSku(sku)
+        return self.thresholds[sku]
+
+    def suggest(self, stock: StockProjection) -> List[ReorderSuggestion]
+        """One suggestion per SKU at or below its reorder point."""
+        out: List[ReorderSuggestion] = []
+        for sku in sorted(self.thresholds):
+            level = stock.levels.get(sku, 0)
+            threshold = self.thresholds[sku]
+            if level <= threshold:
+                target = self.target.get(sku, threshold * 2)
+                qty = target - level
+                if qty > 0:
+                    out.append(ReorderSuggestion(
+                        sku=sku, order_qty=qty,
+                        reason=f"level {level} at or below threshold {threshold}"))
+        return out
+
+
+def allocate(demand: int, warehouses: Sequence[Warehouse]) -> List[Tuple[str, int]]:
+    """Split `demand` across warehouses, highest priority first.
+
+    Ties on priority are broken by name so the result is deterministic. The
+    input sequence is never mutated -- callers reuse their warehouse list
+    across several allocations and would otherwise see it quietly emptied.
+    """
+    if demand <= 0:
+        raise ValueError("demand must be positive")
+
+    ordered = sorted(warehouses, key=lambda w: (-w.priority, w.name))
+    available = sum(w.on_hand for w in ordered)
+    if available < demand:
+        raise InsufficientStock("<multiple>", demand, available)
+
+    plan: List[Tuple[str, int]] = []
+    remaining = demand
+    for warehouse in ordered:
+        if remaining <= 0:
+            break
+        take = min(warehouse.on_hand, remaining)
+        if take > 0:
+            plan.append((warehouse.name, take))
+            remaining -= take
+    return plan

source/corpus/python/ledger/tasks/audit2-04/break/ledger/projections.py

@@ -0,0 +1,112 @@
+"""Read models built by folding the event log.
+
+A projection is resumable: it remembers the last sequence number it applied
+and asks the store only for what came after. That is what keeps a long ledger
+cheap to query, and it is why the store's `since` boundary matters so much.
+"""
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+from .errors import SequenceError, UnknownSku
+from .events import Adjusted, Event, Received, Shipped
+from .store import EventStore
+
+
+class StockProjection:
+    """Units on hand per SKU."""
+
+    def __init__(self) -> None:
+        self.levels: Dict[str, int] = {}
+        self.last_seq: int = 0
+
+    def apply(self, event: Event) -> None:
+        """Fold a single event into the running totals."""
+        if event.seq <= self.last_seq:
+            raise SequenceError(
+                f"event {event.seq} already applied (at {self.last_seq})")
+        current = self.levels.get(event.sku, 0)
+        if isinstance(event, Received):
+            current += event.qty
+        elif isinstance(event, Shipped):
+            current -= event.qty
+        elif isinstance(event, Adjusted):
+            current += event.delta
+        self.levels[event.sku] = current
+        self.last_seq = event.seq
+
+    def catch_up(self, store: EventStore) -> int:
+        """Apply everything appended since the last call. Returns the count."""
+        pending = store.since(self.last_seq)
+        for event in pending:
+            self.apply(event)
+        return len(pending)
+
+    def on_hand(self, sku: str) -> int:
+        if sku not in self.levels:
+            raise UnknownSku(sku)
+        return self.levels[sku]
+
+    def negative_skus(self) -> List[str]:
+        """SKUs the log says we hold a negative quantity of."""
+        return sorted(s for s, n in self.levels.items() if n < 0)
+
+
+@dataclass
+class Lot:
+    """One receipt still carrying unconsumed units."""
+    seq: int
+    qty: int
+    unit_cost: float
+
+
+class Valuation:
+    """Inventory value under first-in, first-out cost basis."""
+
+    def __init__(self) -> None:
+        self.lots: Dict[str, List[Lot]] = {}
+        self.last_seq: int = 0
+        self.cost_of_goods_sold: float = 0.0
+
+    def apply(self, event: Event) -> None:
+        lots = self.lots.setdefault(event.sku, [])
+        if isinstance(event, Received):
+            lots.append(Lot(seq=event.seq, qty=event.qty,
+                            unit_cost=event.unit_cost))
+        elif isinstance(event, Shipped):
+            self._consume(lots, event.qty)
+        elif isinstance(event, Adjusted):
+            if event.delta > 0:
+                unit_cost = lots[-1].unit_cost if lots else 0.0
+                lots.append(Lot(seq=event.seq, qty=event.delta,
+                                unit_cost=unit_cost))
+            else:
+                self._consume(lots, -event.delta)
+        self.last_seq = event.seq
+
+    def _consume(self, lots: List[Lot], qty: int) -> None:
+        """Draw `qty` units from the oldest lots first."""
+        remaining = qty
+        while remaining > 0 and lots:
+            oldest = lots[-1]
+            take = min(oldest.qty, remaining)
+            self.cost_of_goods_sold += take * oldest.unit_cost
+            oldest.qty -= take
+            remaining -= take
+            if oldest.qty == 0:
+                lots.pop()
+
+    def catch_up(self, store: EventStore) -> int:
+        pending = store.since(self.last_seq)
+        for event in pending:
+            self.apply(event)
+        return len(pending)
+
+    def value_of(self, sku: str) -> float:
+        """Total carrying value of the units still on hand for one SKU."""
+        if sku not in self.lots:
+            raise UnknownSku(sku)
+        return sum(lot.qty * lot.unit_cost for lot in self.lots[sku])
+
+    def total_value(self) -> float:
+        return sum(lot.qty * lot.unit_cost
+                   for lots in self.lots.values() for lot in lots)

source/corpus/python/ledger/tasks/audit2-04/break/ledger/store.py

@@ -0,0 +1,95 @@
+"""Append-only event store with snapshot support.
+
+The store owns sequence numbering. Nothing else in the package is allowed to
+assign a sequence number, because the ordering guarantee that projections rely
+on is only as good as the single place that hands the numbers out.
+"""
+from typing import Dict, Iterable, Iterator, List, Optional
+
+from .errors import SequenceError
+from .events import Adjusted, Event, Received, Shipped
+
+
+class EventStore:
+    """Holds every event ever appended, in order."""
+
+    def __init__(self) -> None:
+        self._events: List[Event] = []
+        self._next_seq: int = 1
+        self._clock: float = 0.0
+
+    # -- writing ---------------------------------------------------------
+
+    def _tick(self) -> float:
+        self._clock += 1.0
+        return self._clock
+
+    def _append(self, event: Event) -> Event:
+        if event.seq != self._next_seq:
+            raise SequenceError(
+                f"expected seq {self._next_seq}, got {event.seq}")
+        self._events.append(event)
+        self._next_seq += 1
+        return event
+
+    def receive(self, sku: str, qty: int, unit_cost: float) -> Received:
+        """Record stock arriving."""
+        if qty <= 0:
+            raise ValueError("received quantity must be positive")
+        return self._append(
+            Received(seq=self._next_seq, ts=self._tick(), sku=sku,
+                     qty=qty, unit_cost=unit_cost))
+
+    def ship(self, sku: str, qty: int) -> Shipped:
+        """Record stock leaving. Does not itself check availability."""
+        if qty <= 0:
+            raise ValueError("shipped quantity must be positive")
+        return self._append(
+            Shipped(seq=self._next_seq, ts=self._tick(), sku=sku, qty=qty))
+
+    def adjust(self, sku: str, delta: int, reason: str) -> Adjusted:
+        """Record a stocktake correction."""
+        if delta == 0:
+            raise ValueError("adjustment delta must not be zero")
+        return self._append(
+            Adjusted(seq=self._next_seq, ts=self._tick(), sku=sku,
+                     delta=delta, reason=reason))
+
+    # -- reading ---------------------------------------------------------
+
+    def __len__(self) -> int:
+        return len(self._events)
+
+    def __iter__(self) -> Iterator[Event]:
+        return iter(self._events)
+
+    @property
+    def head(self) -> int:
+        """Sequence number of the most recent event, or 0 when empty."""
+        return self._events[-1].seq if self._events else 0
+
+    def since(self, seq: int) -> List[Event]:
+        """Every event appended strictly after `seq`.
+
+        A projection resumes by passing the sequence number it last applied, so
+        this must be exclusive at the lower bound. Making it inclusive would
+        replay one already-applied event on every resume.
+        """
+        return [e for e in self._events if e.seq > seq]
+
+    def between(self, low: int, high: int) -> List[Event]:
+        """Events with low < seq <= high."""
+        return [e for e in self._events if low <= e.seq <= high]
+
+    def for_sku(self, sku: str) -> List[Event]:
+        return [e for e in self._events if e.sku == sku]
+
+    def skus(self) -> List[str]:
+        seen: Dict[str, None] = {}
+        for event in self._events:
+            seen.setdefault(event.sku, None)
+        return list(seen)
+
+    def replay(self, events: Optional[Iterable[Event]] = None) -> List[Event]:
+        """Materialise an event iterable, defaulting to the whole log."""
+        return list(self._events if events is None else events)

source/corpus/python/ledger/tasks/audit2-04/task.json

@@ -0,0 +1,11 @@
+{
+  "lang": "python",
+  "category": "logic",
+  "difficulty": 5,
+  "compound": true,
+  "ingredients": [
+    "between-boundary",
+    "fifo-lifo"
+  ],
+  "instruction": "2 findings from this week's triage. They have separate causes and are not related to one another; all 2 need fixing.\n\n1. Our per-period stock report double-counts events on period boundaries.\n   Consecutive reports are produced by asking the store for the events between the\n   previous report's last sequence number and the current one. An event landing\n   exactly on a boundary shows up in both the earlier report and the later one.\n   The range is documented as excluding its lower bound and including its upper.\n\n2. Our finance team reports that inventory valuation and cost of goods sold are wrong whenever a SKU has been received at more than one unit cost.\n   Concrete case: receive 10 units at 1.00, then 10 units at 3.00, then ship 10 units. Cost of goods sold should be 10.00 and the remaining inventory should be valued at 30.00. We are getting those two numbers the other way round.\n   The ledger is documented as valuing inventory on a first-in, first-out basis. Make it do that."
+}

source/corpus/python/ledger/tasks/audit2-04/tests/test_between.py

@@ -0,0 +1,41 @@
+
+import unittest
+
+from ledger import EventStore
+
+
+def store_with(n):
+    store = EventStore()
+    for i in range(n):
+        store.receive(f"sku{i}", 1, 1.0)
+    return store
+
+
+class TestBetweenIsHalfOpen(unittest.TestCase):
+    def test_lower_bound_is_excluded(self):
+        self.assertEqual([e.seq for e in store_with(5).between(2, 4)], [3, 4])
+
+    def test_consecutive_ranges_do_not_overlap(self):
+        store = store_with(6)
+        first = {e.seq for e in store.between(0, 3)}
+        second = {e.seq for e in store.between(3, 6)}
+        self.assertEqual(first & second, set())
+
+    def test_consecutive_ranges_leave_no_gap(self):
+        store = store_with(6)
+        seen = {e.seq for e in store.between(0, 3)} | {e.seq for e in store.between(3, 6)}
+        self.assertEqual(seen, {1, 2, 3, 4, 5, 6})
+
+    def test_empty_range(self):
+        self.assertEqual(store_with(5).between(3, 3), [])
+
+
+class TestBetweenOtherwiseWorks(unittest.TestCase):
+    def test_upper_bound_is_included(self):
+        self.assertIn(4, [e.seq for e in store_with(5).between(2, 4)])
+
+    def test_full_range(self):
+        self.assertEqual(len(store_with(5).between(0, 5)), 5)
+
+    def test_beyond_the_end(self):
+        self.assertEqual(len(store_with(3).between(0, 99)), 3)

source/corpus/python/ledger/tasks/audit2-04/tests/test_catch_up.py

@@ -0,0 +1,56 @@
+import unittest
+
+from ledger import EventStore, StockProjection
+from ledger.errors import SequenceError
+
+
+class TestIncrementalCatchUp(unittest.TestCase):
+    def test_catch_up_twice_across_new_events(self):
+        store = EventStore()
+        store.receive("widget", 100, 2.50)
+        stock = StockProjection()
+        stock.catch_up(store)
+        store.ship("widget", 30)
+        stock.catch_up(store)
+        self.assertEqual(stock.on_hand("widget"), 70)
+
+    def test_catch_up_with_nothing_new_is_a_noop(self):
+        store = EventStore()
+        store.receive("widget", 10, 1.0)
+        stock = StockProjection()
+        self.assertEqual(stock.catch_up(store), 1)
+        self.assertEqual(stock.catch_up(store), 0)
+        self.assertEqual(stock.on_hand("widget"), 10)
+
+    def test_many_incremental_catch_ups_match_one_big_one(self):
+        incremental = StockProjection()
+        store = EventStore()
+        for i in range(1, 6):
+            store.receive("bolt", i * 10, 1.0)
+            incremental.catch_up(store)
+        oneshot = StockProjection()
+        oneshot.catch_up(store)
+        self.assertEqual(incremental.levels, oneshot.levels)
+        self.assertEqual(incremental.on_hand("bolt"), 150)
+
+
+class TestOrderingGuaranteesPreserved(unittest.TestCase):
+    """Deleting the ordering check would hide the symptom but corrupt totals."""
+
+    def test_replaying_an_applied_event_is_still_rejected(self):
+        store = EventStore()
+        store.receive("widget", 5, 1.0)
+        stock = StockProjection()
+        stock.catch_up(store)
+        already_applied = list(store)[0]
+        with self.assertRaises(SequenceError):
+            stock.apply(already_applied)
+
+    def test_store_since_is_exclusive_at_the_lower_bound(self):
+        store = EventStore()
+        store.receive("a", 1, 1.0)
+        store.receive("b", 1, 1.0)
+        store.receive("c", 1, 1.0)
+        self.assertEqual([e.seq for e in store.since(0)], [1, 2, 3])
+        self.assertEqual([e.seq for e in store.since(1)], [2, 3])
+        self.assertEqual([e.seq for e in store.since(3)], [])

source/corpus/python/ledger/tasks/audit2-04/tests/test_imports.py

@@ -0,0 +1,24 @@
+import unittest
+
+
+class TestPackageImports(unittest.TestCase):
+    def test_package_imports(self):
+        import ledger
+        self.assertTrue(hasattr(ledger, "EventStore"))
+
+    def test_policy_is_usable(self):
+        from ledger import EventStore, ReorderPolicy, StockProjection
+        store = EventStore()
+        store.receive("w", 3, 1.0)
+        stock = StockProjection()
+        stock.catch_up(store)
+        policy = ReorderPolicy({"w": 5}, {"w": 20})
+        self.assertEqual([s.sku for s in policy.suggest(stock)], ["w"])
+
+    def test_projection_still_works(self):
+        from ledger import EventStore, StockProjection
+        store = EventStore()
+        store.receive("w", 7, 1.0)
+        stock = StockProjection()
+        stock.catch_up(store)
+        self.assertEqual(stock.on_hand("w"), 7)

source/corpus/python/ledger/tasks/audit2-04/tests/test_valuation.py

@@ -0,0 +1,64 @@
+import unittest
+
+from ledger import EventStore, Valuation
+
+
+def valued(events):
+    store = EventStore()
+    for kind, sku, *rest in events:
+        getattr(store, kind)(sku, *rest)
+    valuation = Valuation()
+    valuation.catch_up(store)
+    return valuation
+
+
+class TestFifoCostBasis(unittest.TestCase):
+    def test_oldest_lot_is_consumed_first(self):
+        v = valued([("receive", "w", 10, 1.00),
+                    ("receive", "w", 10, 3.00),
+                    ("ship", "w", 10)])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 10.00)
+        self.assertAlmostEqual(v.value_of("w"), 30.00)
+
+    def test_shipment_spanning_two_lots(self):
+        v = valued([("receive", "w", 10, 1.00),
+                    ("receive", "w", 10, 3.00),
+                    ("ship", "w", 15)])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 10 * 1.00 + 5 * 3.00)
+        self.assertAlmostEqual(v.value_of("w"), 5 * 3.00)
+
+    def test_three_lots_consumed_in_arrival_order(self):
+        v = valued([("receive", "w", 5, 1.00),
+                    ("receive", "w", 5, 2.00),
+                    ("receive", "w", 5, 4.00),
+                    ("ship", "w", 12)])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 5 * 1.0 + 5 * 2.0 + 2 * 4.0)
+        self.assertAlmostEqual(v.value_of("w"), 3 * 4.00)
+
+    def test_negative_adjustment_also_consumes_oldest_first(self):
+        v = valued([("receive", "w", 10, 1.00),
+                    ("receive", "w", 10, 3.00),
+                    ("adjust", "w", -10, "stocktake")])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 10.00)
+        self.assertAlmostEqual(v.value_of("w"), 30.00)
+
+
+class TestValuationInvariants(unittest.TestCase):
+    def test_single_lot_is_unaffected(self):
+        v = valued([("receive", "w", 10, 2.00), ("ship", "w", 4)])
+        self.assertAlmostEqual(v.cost_of_goods_sold, 8.00)
+        self.assertAlmostEqual(v.value_of("w"), 12.00)
+
+    def test_full_depletion_leaves_no_value(self):
+        v = valued([("receive", "w", 5, 1.00),
+                    ("receive", "w", 5, 9.00),
+                    ("ship", "w", 10)])
+        self.assertAlmostEqual(v.value_of("w"), 0.00)
+        self.assertAlmostEqual(v.cost_of_goods_sold, 50.00)
+
+    def test_separate_skus_do_not_interfere(self):
+        v = valued([("receive", "a", 5, 1.00),
+                    ("receive", "b", 5, 7.00),
+                    ("ship", "a", 5)])
+        self.assertAlmostEqual(v.value_of("b"), 35.00)
+        self.assertAlmostEqual(v.cost_of_goods_sold, 5.00)

source/corpus/python/ledger/tasks/audit2-05/break/ledger/policies.py

@@ -0,0 +1,85 @@
+"""Decisions taken on top of the read models.
+
+Nothing here touches the event log directly. Policies read a projection and
+return a plan; committing that plan is the caller's business.
+"""
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Sequence, Tuple
+
+from .errors import InsufficientStock, UnknownSku
+from .projections import StockProjection
+
+
+@dataclass(frozen=True)
+class Warehouse:
+    """A stocking location, with a priority used to break ties."""
+    name: str
+    priority: int
+    on_hand: int
+
+
+@dataclass(frozen=True)
+class ReorderSuggestion:
+    sku: str
+    order_qty: int
+    reason: str
+
+
+class ReorderPolicy:
+    """Suggests replenishment when a SKU falls to or below its threshold.
+
+    The comparison is deliberately inclusive: a SKU sitting exactly on its
+    reorder point has reached it, and waiting for it to drop further is how a
+    warehouse runs out during the lead time.
+    """
+
+    def __init__(self, thresholds: Dict[str, int], target: Dict[str, int]):
+        self.thresholds = dict(thresholds)
+        self.target = dict(target)
+
+    def threshold_for(self, sku: str) -> int:
+        if sku not in self.thresholds:
+            raise UnknownSku(sku)
+        return self.thresholds[sku]
+
+    def suggest(self, stock: StockProjection) -> List[ReorderSuggestion]
+        """One suggestion per SKU at or below its reorder point."""
+        out: List[ReorderSuggestion] = []
+        for sku in sorted(self.thresholds):
+            level = stock.levels.get(sku, 0)
+            threshold = self.thresholds[sku]
+            if level <= threshold:
+                target = self.target.get(sku, threshold * 2)
+                qty = target - level
+                if qty > 0:
+                    out.append(ReorderSuggestion(
+                        sku=sku, order_qty=qty,
+                        reason=f"level {level} at or below threshold {threshold}"))
+        return out
+
+
+def allocate(demand: int, warehouses: Sequence[Warehouse]) -> List[Tuple[str, int]]:
+    """Split `demand` across warehouses, highest priority first.
+
+    Ties on priority are broken by name so the result is deterministic. The
+    input sequence is never mutated -- callers reuse their warehouse list
+    across several allocations and would otherwise see it quietly emptied.
+    """
+    if demand <= 0:
+        raise ValueError("demand must be positive")
+
+    ordered = sorted(warehouses, key=lambda w: (-w.priority, w.name))
+    available = sum(w.on_hand for w in ordered)
+    if available < demand:
+        raise InsufficientStock("<multiple>", demand, available)
+
+    plan: List[Tuple[str, int]] = []
+    remaining = demand
+    for warehouse in ordered:
+        if remaining <= 0:
+            break
+        take = min(warehouse.on_hand, remaining)
+        if take > 0:
+            plan.append((warehouse.name, take))
+            remaining -= take
+    return plan

source/corpus/python/ledger/tasks/audit2-05/break/ledger/store.py

@@ -0,0 +1,95 @@
+"""Append-only event store with snapshot support.
+
+The store owns sequence numbering. Nothing else in the package is allowed to
+assign a sequence number, because the ordering guarantee that projections rely
+on is only as good as the single place that hands the numbers out.
+"""
+from typing import Dict, Iterable, Iterator, List, Optional
+
+from .errors import SequenceError
+from .events import Adjusted, Event, Received, Shipped
+
+
+class EventStore:
+    """Holds every event ever appended, in order."""
+
+    def __init__(self) -> None:
+        self._events: List[Event] = []
+        self._next_seq: int = 1
+        self._clock: float = 0.0
+
+    # -- writing ---------------------------------------------------------
+
+    def _tick(self) -> float:
+        self._clock += 1.0
+        return self._clock
+
+    def _append(self, event: Event) -> Event:
+        if event.seq != self._next_seq:
+            raise SequenceError(
+                f"expected seq {self._next_seq}, got {event.seq}")
+        self._events.append(event)
+        self._next_seq += 1
+        return event
+
+    def receive(self, sku: str, qty: int, unit_cost: float) -> Received:
+        """Record stock arriving."""
+        if qty <= 0:
+            raise ValueError("received quantity must be positive")
+        return self._append(
+            Received(seq=self._next_seq, ts=self._tick(), sku=sku,
+                     qty=qty, unit_cost=unit_cost))
+
+    def ship(self, sku: str, qty: int) -> Shipped:
+        """Record stock leaving. Does not itself check availability."""
+        if qty <= 0:
+            raise ValueError("shipped quantity must be positive")
+        return self._append(
+            Shipped(seq=self._next_seq, ts=self._tick(), sku=sku, qty=qty))
+
+    def adjust(self, sku: str, delta: int, reason: str) -> Adjusted:
+        """Record a stocktake correction."""
+        if delta == 0:
+            raise ValueError("adjustment delta must not be zero")
+        return self._append(
+            Adjusted(seq=self._next_seq, ts=self._tick(), sku=sku,
+                     delta=delta, reason=reason))
+
+    # -- reading ---------------------------------------------------------
+
+    def __len__(self) -> int:
+        return len(self._events)
+
+    def __iter__(self) -> Iterator[Event]:
+        return iter(self._events)
+
+    @property
+    def head(self) -> int:
+        """Sequence number of the most recent event, or 0 when empty."""
+        return self._events[-1].seq if self._events else 0
+
+    def since(self, seq: int) -> List[Event]:
+        """Every event appended strictly after `seq`.
+
+        A projection resumes by passing the sequence number it last applied, so
+        this must be exclusive at the lower bound. Making it inclusive would
+        replay one already-applied event on every resume.
+        """
+        return [e for e in self._events if e.seq > seq]
+
+    def between(self, low: int, high: int) -> List[Event]:
+        """Events with low < seq <= high."""
+        return [e for e in self._events if low <= e.seq <= high]
+
+    def for_sku(self, sku: str) -> List[Event]:
+        return [e for e in self._events if e.sku == sku]
+
+    def skus(self) -> List[str]:
+        seen: Dict[str, None] = {}
+        for event in self._events:
+            seen.setdefault(event.sku, None)
+        return list(seen)
+
+    def replay(self, events: Optional[Iterable[Event]] = None) -> List[Event]:
+        """Materialise an event iterable, defaulting to the whole log."""
+        return list(self._events if events is None else events)

source/corpus/python/ledger/tasks/audit2-05/task.json

@@ -0,0 +1,11 @@
+{
+  "lang": "python",
+  "category": "logic",
+  "difficulty": 5,
+  "compound": true,
+  "ingredients": [
+    "between-boundary",
+    "import-syntax"
+  ],
+  "instruction": "2 findings from this week's triage. They have separate causes and are not related to one another; all 2 need fixing.\n\n1. Our per-period stock report double-counts events on period boundaries.\n   Consecutive reports are produced by asking the store for the events between the\n   previous report's last sequence number and the current one. An event landing\n   exactly on a boundary shows up in both the earlier report and the later one.\n   The range is documented as excluding its lower bound and including its upper.\n\n2. The package no longer imports -- `import ledger` fails immediately. Nothing else was changed. Find the syntax error and fix it."
+}

source/corpus/python/ledger/tasks/audit2-05/tests/test_between.py

@@ -0,0 +1,41 @@
+
+import unittest
+
+from ledger import EventStore
+
+
+def store_with(n):
+    store = EventStore()
+    for i in range(n):
+        store.receive(f"sku{i}", 1, 1.0)
+    return store
+
+
+class TestBetweenIsHalfOpen(unittest.TestCase):
+    def test_lower_bound_is_excluded(self):
+        self.assertEqual([e.seq for e in store_with(5).between(2, 4)], [3, 4])
+
+    def test_consecutive_ranges_do_not_overlap(self):
+        store = store_with(6)
+        first = {e.seq for e in store.between(0, 3)}
+        second = {e.seq for e in store.between(3, 6)}
+        self.assertEqual(first & second, set())
+
+    def test_consecutive_ranges_leave_no_gap(self):
+        store = store_with(6)
+        seen = {e.seq for e in store.between(0, 3)} | {e.seq for e in store.between(3, 6)}
+        self.assertEqual(seen, {1, 2, 3, 4, 5, 6})
+
+    def test_empty_range(self):
+        self.assertEqual(store_with(5).between(3, 3), [])
+
+
+class TestBetweenOtherwiseWorks(unittest.TestCase):
+    def test_upper_bound_is_included(self):
+        self.assertIn(4, [e.seq for e in store_with(5).between(2, 4)])
+
+    def test_full_range(self):
+        self.assertEqual(len(store_with(5).between(0, 5)), 5)
+
+    def test_beyond_the_end(self):
+        self.assertEqual(len(store_with(3).between(0, 99)), 3)

source/corpus/python/ledger/tasks/audit2-05/tests/test_catch_up.py

@@ -0,0 +1,56 @@
+import unittest
+
+from ledger import EventStore, StockProjection
+from ledger.errors import SequenceError
+
+
+class TestIncrementalCatchUp(unittest.TestCase):
+    def test_catch_up_twice_across_new_events(self):
+        store = EventStore()
+        store.receive("widget", 100, 2.50)
+        stock = StockProjection()
+        stock.catch_up(store)
+        store.ship("widget", 30)
+        stock.catch_up(store)
+        self.assertEqual(stock.on_hand("widget"), 70)
+
+    def test_catch_up_with_nothing_new_is_a_noop(self):
+        store = EventStore()
+        store.receive("widget", 10, 1.0)
+        stock = StockProjection()
+        self.assertEqual(stock.catch_up(store), 1)
+        self.assertEqual(stock.catch_up(store), 0)
+        self.assertEqual(stock.on_hand("widget"), 10)
+
+    def test_many_incremental_catch_ups_match_one_big_one(self):
+        incremental = StockProjection()
+        store = EventStore()
+        for i in range(1, 6):
+            store.receive("bolt", i * 10, 1.0)
+            incremental.catch_up(store)
+        oneshot = StockProjection()
+        oneshot.catch_up(store)
+        self.assertEqual(incremental.levels, oneshot.levels)
+        self.assertEqual(incremental.on_hand("bolt"), 150)
+
+
+class TestOrderingGuaranteesPreserved(unittest.TestCase):
+    """Deleting the ordering check would hide the symptom but corrupt totals."""
+
+    def test_replaying_an_applied_event_is_still_rejected(self):
+        store = EventStore()
+        store.receive("widget", 5, 1.0)
+        stock = StockProjection()
+        stock.catch_up(store)
+        already_applied = list(store)[0]
+        with self.assertRaises(SequenceError):
+            stock.apply(already_applied)
+
+    def test_store_since_is_exclusive_at_the_lower_bound(self):
+        store = EventStore()
+        store.receive("a", 1, 1.0)
+        store.receive("b", 1, 1.0)
+        store.receive("c", 1, 1.0)
+        self.assertEqual([e.seq for e in store.since(0)], [1, 2, 3])
+        self.assertEqual([e.seq for e in store.since(1)], [2, 3])
+        self.assertEqual([e.seq for e in store.since(3)], [])