closebench 0.1.0__tar.gz

closebench-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 closebench contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

closebench-0.1.0/PKG-INFO

@@ -0,0 +1,182 @@
+Metadata-Version: 2.4
+Name: closebench
+Version: 0.1.0
+Summary: Deterministic, seeded double-entry ledgers with planted closing errors and a programmatic grader — test fixtures for bookkeeping agents.
+License: MIT
+Keywords: accounting,bookkeeping,ledger,double-entry,month-end close,test-fixtures,benchmark,agent-evaluation,llm-agents,fintech
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business :: Financial :: Accounting
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# closebench
+
+[![tests](https://github.com/pahrya-arch/Closebench/actions/workflows/tests.yml/badge.svg)](https://github.com/pahrya-arch/Closebench/actions/workflows/tests.yml)
+
+Deterministic, seeded double-entry ledgers with planted month-end closing errors and a
+programmatic grader. Zero dependencies. Built for testing bookkeeping agents.
+
+```python
+from closebench.world import World
+from closebench.tools import Session
+from closebench.grader import grade
+
+world = World(seed=7).build()        # same seed → byte-identical books, every time
+agent = Session(world)               # the only surface an agent ever sees
+
+print(agent.trial_balance())         # ...agent reads the books, documents, policy...
+agent.post_entry("2026-11-30", "capitalise HW-7781", [
+    {"account": "1500", "debit": "175000.00"},
+    {"account": "6900", "credit": "175000.00"},
+])
+
+print(grade(world, agent))
+# {'passed': False, 'score': 0.143, 'found': ['E3'], 'partial': [], 'missed': [...],
+#  'spurious_entries': [], 'tb_balanced': True, ...}
+```
+
+## Why this exists
+
+If you are building an agent that closes the books, you need books to close — with
+errors you planted yourself, so you know the answer. Real ERP exports are messy, slow,
+legally encumbered and never reproducible. LLM-judged rubrics drift.
+
+`closebench` gives you a company: eleven months of operations, a chart of accounts,
+supporting documents, an accounting policy, and a fixed set of closing errors chosen by
+the seed. The grader checks the agent's adjusting entries against the planted errors by
+account and amount — no rubric, no judge model, no human in the loop.
+
+Use it as a regression suite: run your agent over 50 seeds on every change and watch
+`pass_rate` and `mean_score`.
+
+## What a world contains
+
+| | |
+|---|---|
+| Ledger | ~140 balanced entries across 11 months, 26-account chart, cash and inventory never negative |
+| Documents | ~25: vendor invoices, contracts, bank statement, intercompany email, FX rate certificate, accounting policy |
+| Planted errors | 6–9 per world in `hard` mode, 4–6 in `absence` mode |
+| Distractors | legitimate transactions that look like errors — correcting them costs points |
+| Decoys | every error type has a legitimate twin, so the document inventory never reveals what was planted |
+| Truth | `world.errors` — hidden from the agent, used by the grader |
+
+Two locales: `lang="en"` (default) and `lang="ru"`. Numbers, dates, accounts and errors are
+identical across locales; only text differs.
+
+## Error taxonomy
+
+**Document-backed** (the evidence is in a document the agent can read):
+
+| kind | what went wrong | correct fix |
+|---|---|---|
+| `unrecorded_invoice` | subcontractor act never posted | Dr 5000 / Cr 2000 |
+| `duplicate_invoice` | one invoice posted twice under two refs | Dr 2000 / Cr 6300 |
+| `capex_expensed` | fixed asset above the policy limit expensed | Dr 1500 / Cr 6900 |
+| `prepaid_not_deferred` | 12-month licence expensed in full | Dr 1300 / Cr 6500 |
+| `revenue_cutoff` | customer prepayment for next year booked as revenue | Dr 4000 / Cr 2400 |
+| `unrecorded_bank_fee` | fee on the bank statement, not in the books | Dr 6900 / Cr 1000 |
+| `misclassified_expense` | warehouse rent booked to professional services | Dr 6100 / Cr 6300 |
+| `intercompany_mismatch` | subsidiary's services never recorded | Dr 6900 / Cr 2500 |
+| `fx_revaluation` | open EUR payable not revalued at period-end rate | Dr 6700 / Cr 2000 |
+| `depreciation_prorata` | new asset in service mid-month, no depreciation (day-prorated) | Dr 6400 / Cr 1590 |
+| `service_span_cutoff` | 60-day contract straddling period end, expensed in full (day-prorated) | Dr 1300 / Cr 6300 |
+
+**Absence-only** (no document points at them — the error exists only as a gap in a series,
+and it is hidden in a **random month of the year**, not the closing month):
+
+| kind | what went wrong | correct fix |
+|---|---|---|
+| `missing_recurring` | one month's security-services accrual missing | Dr 6600 / Cr 2100 |
+| `payroll_cutoff` | one month's end-of-month payroll accrual missing | Dr 6000 / Cr 2200 |
+| `depreciation_stopped` | one month's depreciation missing | Dr 6400 / Cr 1590 |
+| `prepaid_amort_stopped` | one month's insurance amortisation missing | Dr 6800 / Cr 1300 |
+| `accrual_not_released` | prior-month accrual not released at payment; expense double-counted | Dr 2200 / Cr 6000 |
+| `inventory_receipt_gap` | goods received never posted although COGS was | Dr 1200 / Cr 2000 |
+
+`hard` mode samples 6–9 kinds from all seventeen. `absence` mode samples 4–6 from the six
+absence-only kinds. Amounts are seeded so that no two planted errors in one world share
+the same account pair and amount.
+
+## Grading
+
+```python
+grade(world, session) -> {
+  "passed": bool,          # every error found (exact or partial), TB balanced, nothing spurious
+  "score": float,          # (exact + 0.5·partial) / total − 0.1·spurious, floored at 0
+  "found": [...],          # exact account pair and amount
+  "partial": [...],        # right amount, economically equivalent account (e.g. 6300 for 6900)
+  "missed": [...],
+  "spurious_entries": [...],   # adjustments matching no planted error
+  "tb_balanced": bool,
+  "adjustments_posted": int,
+  "tool_calls": int,
+}
+```
+
+An adjustment can satisfy at most one planted error. Equivalence groups are small and
+explicit (`grader.EQUIV`); a defensible account choice earns half credit, never a penalty.
+
+## Agent tools
+
+`chart_of_accounts`, `trial_balance`, `journal`, `account_detail`, `list_documents`,
+`read_document`, `pnl`, `post_entry`. Nothing else. The agent never sees `world.errors`.
+
+## Command line
+
+The CLI keeps truth in process memory only: the world is rebuilt from the seed on every
+call and just the agent's postings are persisted, so an agent driving the CLI cannot read
+the answer key from disk.
+
+```bash
+closebench --session demo --start 7 --lang en
+closebench --session demo --tool trial_balance
+closebench --session demo --tool read_document --args '{"doc_id": "POL-01"}'
+closebench --session demo --tool post_entry --args '{"date":"2026-11-30","memo":"...","lines":[...]}'
+closebench --session demo --finish        # grades and seals the session
+```
+
+Seeds ≥ 1000 select `absence` mode. Sessions are sealed after `--finish`.
+Session state lives in `./closebench_runs/` (override with `CLOSEBENCH_RUNS`).
+
+## Running a model
+
+`closebench.runner` contains a minimal tool-calling loop with Anthropic and OpenAI
+backends (API key from the environment). It is deliberately small; wire in your own agent.
+
+```bash
+python -m closebench.runner --seeds 1,2,3,4,5 --backend anthropic --model claude-sonnet-5
+```
+
+## What to expect
+
+This is a **regression suite, not a hard benchmark.** In our runs a frontier model with a
+neutral prompt closed `hard` worlds with 83 % pass rate and `absence` worlds with 58 %
+(92 % if you accept the agent's refusal to book an undocumented goods receipt). Distractors
+caught nobody. Use the score to catch regressions in your own agent, not to rank models.
+
+The one thing models still get wrong: two errors that cancel in the balances (e.g. a
+missing accrual and an unreleased accrual of the same amount). They are still two errors.
+
+## Install
+
+```bash
+pip install closebench
+```
+
+Python ≥ 3.10, no dependencies. Tests: `pip install pytest && python -m pytest -q`.
+
+## Licence
+
+MIT.

closebench-0.1.0/README.md

@@ -0,0 +1,159 @@
+# closebench
+
+[![tests](https://github.com/pahrya-arch/Closebench/actions/workflows/tests.yml/badge.svg)](https://github.com/pahrya-arch/Closebench/actions/workflows/tests.yml)
+
+Deterministic, seeded double-entry ledgers with planted month-end closing errors and a
+programmatic grader. Zero dependencies. Built for testing bookkeeping agents.
+
+```python
+from closebench.world import World
+from closebench.tools import Session
+from closebench.grader import grade
+
+world = World(seed=7).build()        # same seed → byte-identical books, every time
+agent = Session(world)               # the only surface an agent ever sees
+
+print(agent.trial_balance())         # ...agent reads the books, documents, policy...
+agent.post_entry("2026-11-30", "capitalise HW-7781", [
+    {"account": "1500", "debit": "175000.00"},
+    {"account": "6900", "credit": "175000.00"},
+])
+
+print(grade(world, agent))
+# {'passed': False, 'score': 0.143, 'found': ['E3'], 'partial': [], 'missed': [...],
+#  'spurious_entries': [], 'tb_balanced': True, ...}
+```
+
+## Why this exists
+
+If you are building an agent that closes the books, you need books to close — with
+errors you planted yourself, so you know the answer. Real ERP exports are messy, slow,
+legally encumbered and never reproducible. LLM-judged rubrics drift.
+
+`closebench` gives you a company: eleven months of operations, a chart of accounts,
+supporting documents, an accounting policy, and a fixed set of closing errors chosen by
+the seed. The grader checks the agent's adjusting entries against the planted errors by
+account and amount — no rubric, no judge model, no human in the loop.
+
+Use it as a regression suite: run your agent over 50 seeds on every change and watch
+`pass_rate` and `mean_score`.
+
+## What a world contains
+
+| | |
+|---|---|
+| Ledger | ~140 balanced entries across 11 months, 26-account chart, cash and inventory never negative |
+| Documents | ~25: vendor invoices, contracts, bank statement, intercompany email, FX rate certificate, accounting policy |
+| Planted errors | 6–9 per world in `hard` mode, 4–6 in `absence` mode |
+| Distractors | legitimate transactions that look like errors — correcting them costs points |
+| Decoys | every error type has a legitimate twin, so the document inventory never reveals what was planted |
+| Truth | `world.errors` — hidden from the agent, used by the grader |
+
+Two locales: `lang="en"` (default) and `lang="ru"`. Numbers, dates, accounts and errors are
+identical across locales; only text differs.
+
+## Error taxonomy
+
+**Document-backed** (the evidence is in a document the agent can read):
+
+| kind | what went wrong | correct fix |
+|---|---|---|
+| `unrecorded_invoice` | subcontractor act never posted | Dr 5000 / Cr 2000 |
+| `duplicate_invoice` | one invoice posted twice under two refs | Dr 2000 / Cr 6300 |
+| `capex_expensed` | fixed asset above the policy limit expensed | Dr 1500 / Cr 6900 |
+| `prepaid_not_deferred` | 12-month licence expensed in full | Dr 1300 / Cr 6500 |
+| `revenue_cutoff` | customer prepayment for next year booked as revenue | Dr 4000 / Cr 2400 |
+| `unrecorded_bank_fee` | fee on the bank statement, not in the books | Dr 6900 / Cr 1000 |
+| `misclassified_expense` | warehouse rent booked to professional services | Dr 6100 / Cr 6300 |
+| `intercompany_mismatch` | subsidiary's services never recorded | Dr 6900 / Cr 2500 |
+| `fx_revaluation` | open EUR payable not revalued at period-end rate | Dr 6700 / Cr 2000 |
+| `depreciation_prorata` | new asset in service mid-month, no depreciation (day-prorated) | Dr 6400 / Cr 1590 |
+| `service_span_cutoff` | 60-day contract straddling period end, expensed in full (day-prorated) | Dr 1300 / Cr 6300 |
+
+**Absence-only** (no document points at them — the error exists only as a gap in a series,
+and it is hidden in a **random month of the year**, not the closing month):
+
+| kind | what went wrong | correct fix |
+|---|---|---|
+| `missing_recurring` | one month's security-services accrual missing | Dr 6600 / Cr 2100 |
+| `payroll_cutoff` | one month's end-of-month payroll accrual missing | Dr 6000 / Cr 2200 |
+| `depreciation_stopped` | one month's depreciation missing | Dr 6400 / Cr 1590 |
+| `prepaid_amort_stopped` | one month's insurance amortisation missing | Dr 6800 / Cr 1300 |
+| `accrual_not_released` | prior-month accrual not released at payment; expense double-counted | Dr 2200 / Cr 6000 |
+| `inventory_receipt_gap` | goods received never posted although COGS was | Dr 1200 / Cr 2000 |
+
+`hard` mode samples 6–9 kinds from all seventeen. `absence` mode samples 4–6 from the six
+absence-only kinds. Amounts are seeded so that no two planted errors in one world share
+the same account pair and amount.
+
+## Grading
+
+```python
+grade(world, session) -> {
+  "passed": bool,          # every error found (exact or partial), TB balanced, nothing spurious
+  "score": float,          # (exact + 0.5·partial) / total − 0.1·spurious, floored at 0
+  "found": [...],          # exact account pair and amount
+  "partial": [...],        # right amount, economically equivalent account (e.g. 6300 for 6900)
+  "missed": [...],
+  "spurious_entries": [...],   # adjustments matching no planted error
+  "tb_balanced": bool,
+  "adjustments_posted": int,
+  "tool_calls": int,
+}
+```
+
+An adjustment can satisfy at most one planted error. Equivalence groups are small and
+explicit (`grader.EQUIV`); a defensible account choice earns half credit, never a penalty.
+
+## Agent tools
+
+`chart_of_accounts`, `trial_balance`, `journal`, `account_detail`, `list_documents`,
+`read_document`, `pnl`, `post_entry`. Nothing else. The agent never sees `world.errors`.
+
+## Command line
+
+The CLI keeps truth in process memory only: the world is rebuilt from the seed on every
+call and just the agent's postings are persisted, so an agent driving the CLI cannot read
+the answer key from disk.
+
+```bash
+closebench --session demo --start 7 --lang en
+closebench --session demo --tool trial_balance
+closebench --session demo --tool read_document --args '{"doc_id": "POL-01"}'
+closebench --session demo --tool post_entry --args '{"date":"2026-11-30","memo":"...","lines":[...]}'
+closebench --session demo --finish        # grades and seals the session
+```
+
+Seeds ≥ 1000 select `absence` mode. Sessions are sealed after `--finish`.
+Session state lives in `./closebench_runs/` (override with `CLOSEBENCH_RUNS`).
+
+## Running a model
+
+`closebench.runner` contains a minimal tool-calling loop with Anthropic and OpenAI
+backends (API key from the environment). It is deliberately small; wire in your own agent.
+
+```bash
+python -m closebench.runner --seeds 1,2,3,4,5 --backend anthropic --model claude-sonnet-5
+```
+
+## What to expect
+
+This is a **regression suite, not a hard benchmark.** In our runs a frontier model with a
+neutral prompt closed `hard` worlds with 83 % pass rate and `absence` worlds with 58 %
+(92 % if you accept the agent's refusal to book an undocumented goods receipt). Distractors
+caught nobody. Use the score to catch regressions in your own agent, not to rank models.
+
+The one thing models still get wrong: two errors that cancel in the balances (e.g. a
+missing accrual and an unreleased accrual of the same amount). They are still two errors.
+
+## Install
+
+```bash
+pip install closebench
+```
+
+Python ≥ 3.10, no dependencies. Tests: `pip install pytest && python -m pytest -q`.
+
+## Licence
+
+MIT.

closebench-0.1.0/closebench/__init__.py

@@ -0,0 +1,8 @@
+"""closebench — deterministic, seeded double-entry ledgers with planted closing errors
+and a programmatic grader. Test fixtures for bookkeeping agents.
+
+    from closebench.world import World
+    from closebench.tools import Session
+    from closebench.grader import grade
+"""
+__version__ = "0.1.0"

closebench-0.1.0/closebench/cli.py

@@ -0,0 +1,104 @@
+"""Интерфейс агента: состояние сессии на диске, истина только в памяти процесса.
+Агент вызывает инструменты и не имеет доступа к посаженным ошибкам."""
+from __future__ import annotations
+import argparse, json, os, sys
+from closebench.world import World
+from closebench.tools import Session, tool_spec
+from closebench.grader import grade
+from closebench.strings import T, LANGS
+
+RUNS = os.environ.get("CLOSEBENCH_RUNS", os.path.join(os.getcwd(), "closebench_runs"))
+
+def state_path(sid): return os.path.join(RUNS, f"session_{sid}.json")
+
+def mode_for(seed: int) -> str:
+    """Режим кодируется номером сида, а не флагом: флаг виден агенту в командной
+    строке и сам по себе является подсказкой о характере задачи."""
+    return "absence" if seed >= 1000 else "hard"
+
+def load(sid):
+    p = state_path(sid)
+    if not os.path.exists(p): return None
+    return json.load(open(p))
+
+def save(sid, st):
+    os.makedirs(RUNS, exist_ok=True)
+    json.dump(st, open(state_path(sid), "w"), ensure_ascii=False)
+
+def rebuild(sid):
+    """Восстанавливаем мир по seed и переигрываем проводки агента."""
+    st = load(sid)
+    if not st: return None, None, None
+    # Сессии, записанные до появления поля lang, были русскими.
+    w = World(seed=st["seed"], lang=st.get("lang", "ru"),
+              difficulty=st.get("mode", "hard")).build()
+    s = Session(w)
+    for a in st["posted"]:
+        s.post_entry(a["date"], a["memo"], a["lines"])
+    s.external_calls = st.get("calls", 0)
+    return st, w, s
+
+def tools_text(lang: str) -> str:
+    return "\n".join(T(lang, "cli.tool_line", **t) for t in tool_spec(lang))
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--session", required=True)
+    ap.add_argument("--start", type=int, help="seed of a new episode")
+    ap.add_argument("--lang", choices=LANGS, default="en",
+                    help="world language for --start (default: en); stored in the session")
+    ap.add_argument("--tool")
+    ap.add_argument("--args", default="{}")
+    ap.add_argument("--finish", action="store_true")
+    a = ap.parse_args()
+
+    if a.start is not None:
+        mode, lang = mode_for(a.start), a.lang
+        w = World(seed=a.start, lang=lang, difficulty=mode).build()
+        save(a.session, {"seed": a.start, "mode": mode, "lang": lang, "posted": [], "calls": 0})
+        print(T(lang, "cli.started", start=w.period_start, end=w.period_end, name=w.name))
+        print(T(lang, "cli.counts", entries=len(w.ledger.entries), documents=len(w.documents)))
+        print(T(lang, "cli.task", end=w.period_end))
+        print(T(lang, "cli.no_extra"))
+        print(T(lang, "cli.tools", tools=tools_text(lang)))
+        return
+
+    st, w, s = rebuild(a.session)
+    if not st:
+        print(T(a.lang, "cli.session_not_found")); sys.exit(1)
+    lang = w.lang
+
+    if a.finish:
+        res = grade(w, s)
+        res["seed"] = st["seed"]
+        st["closed"] = True
+        save(a.session, st)
+        print(json.dumps(res, ensure_ascii=False, indent=1))
+        return
+
+    if st.get("closed"):
+        print(T(lang, "cli.closed")); sys.exit(1)
+
+    try:
+        args = json.loads(a.args)
+    except json.JSONDecodeError as e:
+        print(T(lang, "cli.bad_json", e=e)); sys.exit(1)
+
+    fn = getattr(s, a.tool, None)
+    if not fn or a.tool.startswith("_"):
+        print(T(lang, "cli.no_tool", tool=a.tool)); sys.exit(1)
+    before = len(s.posted)
+    try:
+        out = fn(**args)
+    except TypeError as e:
+        print(T(lang, "cli.bad_params", e=e)); sys.exit(1)
+
+    # Успешная проводка распознаётся по факту, а не по тексту ответа (текст зависит от языка).
+    if a.tool == "post_entry" and len(s.posted) > before:
+        st["posted"].append({"date": args["date"], "memo": args["memo"], "lines": args["lines"]})
+    st["calls"] += 1
+    save(a.session, st)
+    print(out)
+
+if __name__ == "__main__":
+    main()

closebench-0.1.0/closebench/grader.py

@@ -0,0 +1,79 @@
+"""Программная награда. Никаких рубрик и оценок человеком."""
+from __future__ import annotations
+from decimal import Decimal
+from closebench.ledger import D
+
+def _adj_entries(world, session):
+    return [e for e in world.ledger.entries if e.eid in set(session.posted)]
+
+# Экономически эквивалентные счета: ошибка в выборе внутри группы — не ошибка по сути.
+EQUIV = [
+    {"6900", "6300"},            # прочие расходы / профуслуги
+    {"2500", "2000"},            # межкомпанийные / кредиторка
+    {"2400", "2000"},            # доходы будущих периодов / кредиторка
+    {"1300", "1200"},            # расходы будущих периодов / запасы
+    {"6700", "6900"},            # курсовые разницы / прочие расходы
+    {"2100", "2000"},            # начисленные обязательства / кредиторка
+    {"2200", "2100"},            # зарплата к выплате / начисленные обязательства
+    {"6600", "6900"},            # связь и охрана / прочие расходы
+]
+
+def _same(a: str, b: str) -> bool:
+    if a == b:
+        return True
+    return any(a in grp and b in grp for grp in EQUIV)
+
+def _matches(e, want_dr, want_cr, amount, strict=True) -> bool:
+    amt = D(amount)
+    eq = (lambda a, b: a == b) if strict else _same
+    dr = [l for l in e.lines if l.debit == amt and eq(l.account, want_dr)]
+    cr = [l for l in e.lines if l.credit == amt and eq(l.account, want_cr)]
+    return bool(dr and cr)
+
+def grade(world, session) -> dict:
+    adjs = _adj_entries(world, session)
+    found, partial, missed = [], [], []
+    matched_eids = set()
+    for err in world.errors:
+        fix = err.fix
+        exact = near = None
+        for e in adjs:
+            if e.eid in matched_eids:          # одна проводка закрывает максимум одну ошибку
+                continue
+            if not (fix["period"][0] <= e.date <= fix["period"][1]):
+                continue
+            if fix["type"] not in ("require_entry", "require_reversal"):
+                continue
+            if _matches(e, fix["debit_account"], fix["credit_account"], fix["amount"], strict=True):
+                exact = e.eid
+                break
+            if near is None and _matches(e, fix["debit_account"], fix["credit_account"],
+                                         fix["amount"], strict=False):
+                near = e.eid
+        if exact:
+            found.append(err.err_id); matched_eids.add(exact)
+        elif near:
+            partial.append(err.err_id); matched_eids.add(near)
+        else:
+            missed.append(err.err_id)
+
+    d, c = world.ledger.tb_totals(world.period_end)
+    tb_balanced = d == c
+
+    # «ничего лишнего»: корректировки, не сопоставленные ни одной ошибке
+    spurious = [e.eid for e in adjs if e.eid not in matched_eids]
+
+    total = len(world.errors)
+    score = (len(found) + 0.5 * len(partial)) / total if total else 0.0
+    penalty = 0.1 * len(spurious)
+    passed = (len(found) + len(partial) == total) and tb_balanced and not spurious
+
+    return {
+        "passed": passed,
+        "score": round(max(0.0, score - penalty), 3),
+        "found": found, "partial": partial, "missed": missed,
+        "spurious_entries": spurious,
+        "tb_balanced": tb_balanced,
+        "adjustments_posted": len(adjs),
+        "tool_calls": getattr(session, "external_calls", len(session.calls)),
+    }

closebench-0.1.0/closebench/ledger.py

@@ -0,0 +1,117 @@
+"""Детерминированная двойная запись. Ядро мира: без внешних зависимостей."""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from decimal import Decimal, ROUND_HALF_UP
+from typing import Iterable
+from closebench.strings import T
+
+def D(x) -> Decimal:
+    return Decimal(str(x)).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
+
+ASSET, LIAB, EQUITY, INCOME, EXPENSE = "asset", "liability", "equity", "income", "expense"
+DEBIT_NORMAL = {ASSET, EXPENSE}
+
+@dataclass(frozen=True)
+class Account:
+    code: str
+    name: str
+    type: str
+
+@dataclass(frozen=True)
+class Line:
+    account: str
+    debit: Decimal = Decimal("0.00")
+    credit: Decimal = Decimal("0.00")
+
+@dataclass
+class Entry:
+    eid: str
+    date: str          # YYYY-MM-DD
+    memo: str
+    lines: list[Line]
+    source: str = "manual"      # manual | ap | ar | bank | accrual | payroll
+    ref: str = ""               # номер документа
+    tags: dict = field(default_factory=dict)
+
+    def total_debit(self) -> Decimal:
+        return sum((l.debit for l in self.lines), Decimal("0.00"))
+
+    def total_credit(self) -> Decimal:
+        return sum((l.credit for l in self.lines), Decimal("0.00"))
+
+    def is_balanced(self) -> bool:
+        return self.total_debit() == self.total_credit()
+
+class Ledger:
+    def __init__(self, accounts: Iterable[Account], lang: str = "en"):
+        self.accounts: dict[str, Account] = {a.code: a for a in accounts}
+        self.entries: list[Entry] = []
+        self.lang = lang            # язык сообщений об ошибках проводки
+        self._seq = 0
+
+    def next_id(self, prefix="JE") -> str:
+        self._seq += 1
+        return f"{prefix}{self._seq:05d}"
+
+    def post(self, entry: Entry) -> str:
+        if not entry.lines:
+            raise ValueError(T(self.lang, "ledger.no_lines"))
+        for l in entry.lines:
+            if l.account not in self.accounts:
+                raise ValueError(T(self.lang, "ledger.unknown_account", account=l.account))
+            if l.debit < 0 or l.credit < 0:
+                raise ValueError(T(self.lang, "ledger.negative"))
+            if l.debit > 0 and l.credit > 0:
+                raise ValueError(T(self.lang, "ledger.both_sides"))
+        if not entry.is_balanced():
+            raise ValueError(T(self.lang, "ledger.unbalanced",
+                               d=entry.total_debit(), c=entry.total_credit()))
+        self.entries.append(entry)
+        return entry.eid
+
+    def in_period(self, start: str, end: str) -> list[Entry]:
+        return [e for e in self.entries if start <= e.date <= end]
+
+    def balance(self, code: str, upto: str | None = None) -> Decimal:
+        acc = self.accounts[code]
+        bal = Decimal("0.00")
+        for e in self.entries:
+            if upto and e.date > upto:
+                continue
+            for l in e.lines:
+                if l.account == code:
+                    bal += l.debit - l.credit
+        return bal if acc.type in DEBIT_NORMAL else -bal
+
+    def trial_balance(self, upto: str) -> list[dict]:
+        rows = []
+        for code, acc in sorted(self.accounts.items()):
+            raw = Decimal("0.00")
+            for e in self.entries:
+                if e.date > upto:
+                    continue
+                for l in e.lines:
+                    if l.account == code:
+                        raw += l.debit - l.credit
+            if raw == 0:
+                continue
+            rows.append({"code": code, "name": acc.name, "type": acc.type,
+                         "debit": raw if raw > 0 else Decimal("0.00"),
+                         "credit": -raw if raw < 0 else Decimal("0.00")})
+        return rows
+
+    def tb_totals(self, upto: str) -> tuple[Decimal, Decimal]:
+        rows = self.trial_balance(upto)
+        return (sum((r["debit"] for r in rows), Decimal("0.00")),
+                sum((r["credit"] for r in rows), Decimal("0.00")))
+
+    def pnl(self, start: str, end: str) -> dict:
+        income = expense = Decimal("0.00")
+        for e in self.in_period(start, end):
+            for l in e.lines:
+                t = self.accounts[l.account].type
+                if t == INCOME:
+                    income += l.credit - l.debit
+                elif t == EXPENSE:
+                    expense += l.debit - l.credit
+        return {"income": income, "expense": expense, "net": income - expense}