Upload folder using huggingface_hub (part 2)

trajectories/lgr100-086-approval-evidence-q1-esc-burie-quiet.jsonl

@@ -0,0 +1,6 @@
+{"args": {"sql": "SELECT invoice, account, description, trans_date, amount FROM erp_vend_trans WHERE invoice IN ('PBINV-201','PBINV-202')"}, "ok": true, "server": "erp", "step": 0, "tool": "data_find_entities_sql"}
+{"args": {"q": "PBINV-201"}, "ok": true, "server": "email", "step": 1, "tool": "messages_list"}
+{"args": {"id": "em-0402"}, "ok": true, "server": "email", "step": 2, "tool": "threads_get"}
+{"args": {"q": "PBINV-202"}, "ok": true, "server": "email", "step": 3, "tool": "messages_list"}
+{"args": {"query": "PBINV-202 approval"}, "ok": true, "server": "docs", "step": 4, "tool": "search_documents"}
+{"args": {"answers": {"inv201_approval_date": "2026-01-18", "inv201_approver": "Priya Shah", "inv201_evidence_location": "shared mailbox thread (approval reply from AP Manager)", "inv202_approver": "none", "inv202_finding": "No approval evidence located in the ERP, mailbox, or document library — control exception to report"}}, "ok": true, "server": "harness", "step": 5, "tool": "submit_answer"}

trajectories/lgr100-087-sampling-projection-q1.jsonl

@@ -0,0 +1,4 @@
+{"args": {"query": "sampling"}, "ok": true, "server": "docs", "step": 0, "tool": "search_documents"}
+{"args": {"doc_id": "sop--audit-sampling-method"}, "ok": true, "server": "docs", "step": 1, "tool": "get_document"}
+{"args": {"item": "audit-sample-results-q1.xlsx"}, "ok": true, "server": "sheets", "step": 2, "tool": "workbook_used_range"}
+{"args": {"answers": {"exceeds_materiality": "yes", "method_used": "ratio projection: sample misstatement x (population size / sample size) = 3,000 x 20", "population_size": 1000, "projected_misstatement": 60000.0}}, "ok": true, "server": "harness", "step": 3, "tool": "submit_answer"}

trajectories/lgr100-088-sampling-projection-q1-esc-burie-quiet.jsonl

@@ -0,0 +1,4 @@
+{"args": {"query": "sampling"}, "ok": true, "server": "docs", "step": 0, "tool": "search_documents"}
+{"args": {"doc_id": "sop--audit-sampling-method"}, "ok": true, "server": "docs", "step": 1, "tool": "get_document"}
+{"args": {"item": "audit-sample-results-q1.xlsx"}, "ok": true, "server": "sheets", "step": 2, "tool": "workbook_used_range"}
+{"args": {"answers": {"exceeds_materiality": "yes", "method_used": "ratio projection: sample misstatement x (population size / sample size) = 3,000 x 20", "population_size": 1000, "projected_misstatement": 60000.0}}, "ok": true, "server": "harness", "step": 3, "tool": "submit_answer"}

trajectories/lgr100-089-ppinv-exceptions-mar.jsonl

@@ -0,0 +1,5 @@
+{"args": {"query": "purchase orders receipts"}, "ok": true, "server": "erp", "step": 0, "tool": "data_find_entity_type"}
+{"args": {"sql": "SELECT invoice, account, po_number, ROUND(amount,2) AS invoiced FROM erp_vend_trans WHERE invoice IN ('TWINV-301','TWINV-302','TWINV-303')"}, "ok": true, "server": "erp", "step": 1, "tool": "data_find_entities_sql"}
+{"args": {"sql": "SELECT po_number, line, item, qty_ordered, unit_price FROM erp_purch_orders WHERE po_number IN ('PO-7001','PO-7002','PO-7003')"}, "ok": true, "server": "erp", "step": 2, "tool": "data_find_entities_sql"}
+{"args": {"sql": "SELECT po_number, SUM(qty_received) AS received FROM erp_product_receipts WHERE po_number IN ('PO-7001','PO-7002','PO-7003') GROUP BY po_number"}, "ok": true, "server": "erp", "step": 3, "tool": "data_find_entities_sql"}
+{"args": {"answers": {"clean_invoice": "TWINV-301", "price_variance_amount": 300.0, "price_variance_invoice": "TWINV-302", "qty_over_billed_units": 40, "qty_variance_invoice": "TWINV-303"}}, "ok": true, "server": "harness", "step": 4, "tool": "submit_answer"}

trajectories/lgr100-090-ppinv-exceptions-mar-esc-burie-quiet.jsonl

@@ -0,0 +1,5 @@
+{"args": {"query": "purchase orders receipts"}, "ok": true, "server": "erp", "step": 0, "tool": "data_find_entity_type"}
+{"args": {"sql": "SELECT invoice, account, po_number, ROUND(amount,2) AS invoiced FROM erp_vend_trans WHERE invoice IN ('TWINV-301','TWINV-302','TWINV-303')"}, "ok": true, "server": "erp", "step": 1, "tool": "data_find_entities_sql"}
+{"args": {"sql": "SELECT po_number, line, item, qty_ordered, unit_price FROM erp_purch_orders WHERE po_number IN ('PO-7001','PO-7002','PO-7003')"}, "ok": true, "server": "erp", "step": 2, "tool": "data_find_entities_sql"}
+{"args": {"sql": "SELECT po_number, SUM(qty_received) AS received FROM erp_product_receipts WHERE po_number IN ('PO-7001','PO-7002','PO-7003') GROUP BY po_number"}, "ok": true, "server": "erp", "step": 3, "tool": "data_find_entities_sql"}
+{"args": {"answers": {"clean_invoice": "TWINV-301", "price_variance_amount": 300.0, "price_variance_invoice": "TWINV-302", "qty_over_billed_units": 40, "qty_variance_invoice": "TWINV-303"}}, "ok": true, "server": "harness", "step": 4, "tool": "submit_answer"}

trajectories/lgr100-091-tac-invoice-matching.jsonl

@@ -0,0 +1,8 @@
+{"args": {"query": "vendor statement reconciliation"}, "ok": true, "server": "docs", "step": 0, "tool": "search_documents"}
+{"args": {"doc_id": "sop--vendor-statement-reconciliation"}, "ok": true, "server": "docs", "step": 1, "tool": "get_document"}
+{"args": {}, "ok": true, "server": "sheets", "step": 2, "tool": "list_drive_items"}
+{"args": {"item": "halden-statement-2026Q1.xlsx"}, "ok": true, "server": "sheets", "step": 3, "tool": "get_drive_item"}
+{"args": {"item": "halden-statement-2026Q1.xlsx"}, "ok": true, "server": "sheets", "step": 4, "tool": "workbook_used_range"}
+{"args": {"item": "ap-payment-register-halden-2026Q1.xlsx"}, "ok": true, "server": "sheets", "step": 5, "tool": "workbook_used_range"}
+{"args": {"q": "partial"}, "ok": true, "server": "sheets", "step": 6, "tool": "drive_search"}
+{"args": {"answers": {"applied_total_usd": 113197.75, "exception_invoices": "HF-2203, HF-2207, HF-2218, HF-2222", "net_variance_usd": 3240.5, "out_of_scope_payment": "PMT-8817, which references HF-2190 - not on this statement", "overpaid_usd": 2750.0, "statement_total_usd": 116438.25, "underpaid_usd": 5990.5}}, "ok": true, "server": "harness", "step": 7, "tool": "submit_answer"}

trajectories/lgr100-092-tolerance-dialect-mar.jsonl

@@ -0,0 +1,5 @@
+{"args": {"query": "tolerance"}, "ok": true, "server": "docs", "step": 0, "tool": "search_documents"}
+{"args": {"doc_id": "policy--ap-match-tolerances"}, "ok": true, "server": "docs", "step": 1, "tool": "get_document"}
+{"args": {"sql": "SELECT invoice, po_number, ROUND(amount,2) AS invoiced FROM erp_vend_trans WHERE invoice IN ('TDINV-401','TDINV-402')"}, "ok": true, "server": "erp", "step": 2, "tool": "data_find_entities_sql"}
+{"args": {"sql": "SELECT po_number, qty_ordered, unit_price, ROUND(qty_ordered*unit_price,2) AS po_value FROM erp_purch_orders WHERE po_number IN ('PO-8101','PO-8102')"}, "ok": true, "server": "erp", "step": 3, "tool": "data_find_entities_sql"}
+{"args": {"answers": {"blocked_invoice": "TDINV-401", "blocked_variance": 40.0, "blocking_rule": "legacy ledger: an unmaintained tolerance key means zero tolerance, so any variance blocks", "passing_invoice": "TDINV-402", "passing_variance": 315.0}}, "ok": true, "server": "harness", "step": 4, "tool": "submit_answer"}

trajectories/lgr100-093-tolerance-dialect-mar-esc-burie-quiet.jsonl

@@ -0,0 +1,5 @@
+{"args": {"query": "tolerance"}, "ok": true, "server": "docs", "step": 0, "tool": "search_documents"}
+{"args": {"doc_id": "policy--ap-match-tolerances"}, "ok": true, "server": "docs", "step": 1, "tool": "get_document"}
+{"args": {"sql": "SELECT invoice, po_number, ROUND(amount,2) AS invoiced FROM erp_vend_trans WHERE invoice IN ('TDINV-401','TDINV-402')"}, "ok": true, "server": "erp", "step": 2, "tool": "data_find_entities_sql"}
+{"args": {"sql": "SELECT po_number, qty_ordered, unit_price, ROUND(qty_ordered*unit_price,2) AS po_value FROM erp_purch_orders WHERE po_number IN ('PO-8101','PO-8102')"}, "ok": true, "server": "erp", "step": 3, "tool": "data_find_entities_sql"}
+{"args": {"answers": {"blocked_invoice": "TDINV-401", "blocked_variance": 40.0, "blocking_rule": "legacy ledger: an unmaintained tolerance key means zero tolerance, so any variance blocks", "passing_invoice": "TDINV-402", "passing_variance": 315.0}}, "ok": true, "server": "harness", "step": 4, "tool": "submit_answer"}

trajectories/lgr100-094-bank-change-verify.jsonl

@@ -0,0 +1,6 @@
+{"args": {"q": "bank"}, "ok": true, "server": "email", "step": 0, "tool": "messages_list"}
+{"args": {"id": "em-0501"}, "ok": true, "server": "email", "step": 1, "tool": "messages_get"}
+{"args": {"entity": "Vendors", "filters": {"name": "Acme Office Supplies"}}, "ok": true, "server": "erp", "step": 2, "tool": "data_find_entities"}
+{"args": {"query": "bank detail change"}, "ok": true, "server": "docs", "step": 3, "tool": "search_documents"}
+{"args": {"doc_id": "policy--vendor-bank-change"}, "ok": true, "server": "docs", "step": 4, "tool": "get_document"}
+{"args": {"answers": {"red_flag": "sender domain does not match the vendor contact email on the ERP master record (lookalike domain)", "request_verified": "no", "required_next_step": "call back the vendor on the phone number already on file in the ERP — never a number supplied in the request", "vendor_account": "1001"}}, "ok": true, "server": "harness", "step": 5, "tool": "submit_answer"}

trajectories/lgr100-095-dormant-vendor-review.jsonl

@@ -0,0 +1,6 @@
+{"args": {"query": "vendor hygiene"}, "ok": true, "server": "docs", "step": 0, "tool": "search_documents"}
+{"args": {"doc_id": "vendor-hygiene-policy"}, "ok": true, "server": "docs", "step": 1, "tool": "get_document"}
+{"args": {"entity": "Vendors", "filters": {"vendor_group": "REVIEW"}}, "ok": true, "server": "erp", "step": 2, "tool": "data_find_entities"}
+{"args": {"sql": "SELECT v.account, v.name, v.on_hold, MAX(t.trans_date) AS last_activity, COUNT(t.id) AS txn_count FROM erp_vendors v LEFT JOIN erp_vend_trans t ON t.account=v.account WHERE v.vendor_group='REVIEW' GROUP BY v.account ORDER BY v.account"}, "ok": true, "server": "erp", "step": 3, "tool": "data_find_entities_sql"}
+{"args": {"sql": "SELECT account, txn_type, trans_date, amount FROM erp_vend_trans WHERE account LIKE 'DVEN-%' ORDER BY account, trans_date"}, "ok": true, "server": "erp", "step": 4, "tool": "data_find_entities_sql"}
+{"args": {"answers": {"cutoff_date": "2025-03-02", "dormant_count": 2, "dormant_vendors": "DVEN-02, DVEN-03", "out_of_scope_vendors": "DVEN-06", "unused_vendors": "DVEN-04"}}, "ok": true, "server": "harness", "step": 5, "tool": "submit_answer"}

trajectories/lgr100-096-dormant-vendor-review-esc-burie-quiet.jsonl

@@ -0,0 +1,6 @@
+{"args": {"query": "vendor hygiene"}, "ok": true, "server": "docs", "step": 0, "tool": "search_documents"}
+{"args": {"doc_id": "vendor-hygiene-policy"}, "ok": true, "server": "docs", "step": 1, "tool": "get_document"}
+{"args": {"entity": "Vendors", "filters": {"vendor_group": "REVIEW"}}, "ok": true, "server": "erp", "step": 2, "tool": "data_find_entities"}
+{"args": {"sql": "SELECT v.account, v.name, v.on_hold, MAX(t.trans_date) AS last_activity, COUNT(t.id) AS txn_count FROM erp_vendors v LEFT JOIN erp_vend_trans t ON t.account=v.account WHERE v.vendor_group='REVIEW' GROUP BY v.account ORDER BY v.account"}, "ok": true, "server": "erp", "step": 3, "tool": "data_find_entities_sql"}
+{"args": {"sql": "SELECT account, txn_type, trans_date, amount FROM erp_vend_trans WHERE account LIKE 'DVEN-%' ORDER BY account, trans_date"}, "ok": true, "server": "erp", "step": 4, "tool": "data_find_entities_sql"}
+{"args": {"answers": {"cutoff_date": "2025-03-02", "dormant_count": 2, "dormant_vendors": "DVEN-02, DVEN-03", "out_of_scope_vendors": "DVEN-06", "unused_vendors": "DVEN-04"}}, "ok": true, "server": "harness", "step": 5, "tool": "submit_answer"}

trajectories/lgr100-097-dormant-vendor-review-v2.jsonl

@@ -0,0 +1,9 @@
+{"args": {}, "ok": true, "server": "docs", "step": 0, "tool": "list_document_types"}
+{"args": {"query": "vendor"}, "ok": true, "server": "docs", "step": 1, "tool": "search_documents"}
+{"args": {"doc_id": "policy--ap-vendor-onboarding"}, "ok": true, "server": "docs", "step": 2, "tool": "get_document_metadata"}
+{"args": {"doc_id": "vendor-hygiene-policy"}, "ok": true, "server": "docs", "step": 3, "tool": "get_document_metadata"}
+{"args": {"doc_id": "vendor-hygiene-policy"}, "ok": true, "server": "docs", "step": 4, "tool": "get_document"}
+{"args": {"entity": "Vendors", "filters": {"vendor_group": "REVIEW"}}, "ok": true, "server": "erp", "step": 5, "tool": "data_find_entities"}
+{"args": {"sql": "SELECT v.account, v.name, v.on_hold, MAX(t.trans_date) AS last_activity, COUNT(t.id) AS txn_count FROM erp_vendors v LEFT JOIN erp_vend_trans t ON t.account=v.account WHERE v.vendor_group='REVIEW' GROUP BY v.account ORDER BY v.account"}, "ok": true, "server": "erp", "step": 6, "tool": "data_find_entities_sql"}
+{"args": {"sql": "SELECT account, txn_type, trans_date, amount FROM erp_vend_trans WHERE account LIKE 'DVEN-%' ORDER BY account, trans_date"}, "ok": true, "server": "erp", "step": 7, "tool": "data_find_entities_sql"}
+{"args": {"answers": {"cutoff_date": "2025-03-02", "dormant_count": 2, "dormant_vendors": "DVEN-02, DVEN-03", "out_of_scope_vendors": "DVEN-06", "unused_vendors": "DVEN-04"}}, "ok": true, "server": "harness", "step": 8, "tool": "submit_answer"}

trajectories/lgr100-098-missing-po-inquiry.jsonl

@@ -0,0 +1,6 @@
+{"args": {"sql": "SELECT invoice, account, po_number, ROUND(amount,2) AS amount FROM erp_vend_trans WHERE invoice='TWINV-303'"}, "ok": true, "server": "erp", "step": 0, "tool": "data_find_entities_sql"}
+{"args": {"entity": "Vendors", "filters": {"account": "SYNVEN-0027"}}, "ok": true, "server": "erp", "step": 1, "tool": "data_find_entities"}
+{"args": {"body": "Hello — invoice TWINV-303 reached us without a purchase order reference, so we cannot match or schedule it. Please confirm the PO number this invoice was raised against. Thank you, Contoso AP", "subject": "PO reference needed for invoice TWINV-303", "to": "ap@wingtip-sim.example"}, "ok": true, "server": "email", "step": 2, "tool": "send_message"}
+{"args": {"q": "TWINV-303"}, "ok": true, "server": "email", "step": 3, "tool": "messages_list"}
+{"args": {"entity": "PurchaseOrders", "filters": {"po_number": "PO-7003"}}, "ok": true, "server": "erp", "step": 4, "tool": "data_find_entities"}
+{"args": {"answers": {"contact_emailed": "ap@wingtip-sim.example", "po_exists_in_erp": "yes", "po_item": "PKG-LABEL-ROLL", "po_number": "PO-7003"}}, "ok": true, "server": "harness", "step": 5, "tool": "submit_answer"}

trajectories/lgr100-099-missing-po-inquiry-esc-burie-quiet.jsonl

@@ -0,0 +1,6 @@
+{"args": {"sql": "SELECT invoice, account, po_number, ROUND(amount,2) AS amount FROM erp_vend_trans WHERE invoice='TWINV-303'"}, "ok": true, "server": "erp", "step": 0, "tool": "data_find_entities_sql"}
+{"args": {"entity": "Vendors", "filters": {"account": "SYNVEN-0027"}}, "ok": true, "server": "erp", "step": 1, "tool": "data_find_entities"}
+{"args": {"body": "Hello — invoice TWINV-303 reached us without a purchase order reference, so we cannot match or schedule it. Please confirm the PO number this invoice was raised against. Thank you, Contoso AP", "subject": "PO reference needed for invoice TWINV-303", "to": "ap@wingtip-sim.example"}, "ok": true, "server": "email", "step": 2, "tool": "send_message"}
+{"args": {"q": "TWINV-303"}, "ok": true, "server": "email", "step": 3, "tool": "messages_list"}
+{"args": {"entity": "PurchaseOrders", "filters": {"po_number": "PO-7003"}}, "ok": true, "server": "erp", "step": 4, "tool": "data_find_entities"}
+{"args": {"answers": {"contact_emailed": "ap@wingtip-sim.example", "po_exists_in_erp": "yes", "po_item": "PKG-LABEL-ROLL", "po_number": "PO-7003"}}, "ok": true, "server": "harness", "step": 5, "tool": "submit_answer"}

trajectories/lgr100-100-tac-find-signatories.jsonl

@@ -0,0 +1,9 @@
+{"args": {}, "ok": true, "server": "sheets", "step": 0, "tool": "list_drive_items"}
+{"args": {"item": "bank-mandate-register-2026.xlsx"}, "ok": true, "server": "sheets", "step": 1, "tool": "workbook_used_range"}
+{"args": {"item": "hr-personnel-extract-2026-03-01.xlsx"}, "ok": true, "server": "sheets", "step": 2, "tool": "workbook_used_range"}
+{"args": {"query": "signing authority mandate"}, "ok": true, "server": "docs", "step": 3, "tool": "search_documents"}
+{"args": {"doc_id": "policy--treasury-signing-authority"}, "ok": true, "server": "docs", "step": 4, "tool": "get_document"}
+{"args": {"doc_id": "memo--interim-signing-delegation"}, "ok": true, "server": "docs", "step": 5, "tool": "get_document"}
+{"args": {"q": "mandate"}, "ok": true, "server": "email", "step": 6, "tool": "messages_list"}
+{"args": {"id": "em-3101"}, "ok": true, "server": "email", "step": 7, "tool": "messages_get"}
+{"args": {"answers": {"authorised_signatories": "Marguerite Okonjo, Halvard Brekke, Priya Shah, Desmond Achebe", "authorised_signatory_count": 4, "departed_signatory": "SIG-06, Corinne Vasquez, Director of Financial Reporting (Band B, USD 250,000). The HR extract records her as a leaver with a final working day of 2026-02-13, so her authority fell away on that date under SOP-TR-02 s2.1; the register was never updated and her offboarding checklist is still open. Strike the row and revoke her payment-release access.", "expired_delegation": "SIG-07, held by Toma Larsen (Band B, USD 250,000, interim cover for the Controller). The CFO's delegation of 2025-11-03 was time-limited and ended 2026-02-28, so the authority is void from 2026-03-01 under SOP-TR-02 s2 even though the register still shows the row Active. He remains an employee in his substantive role; only the signing authority has lapsed, and the row must be struck at this refresh.", "max_release_without_band_a": 50000, "valid_mandate_rows": 5}}, "ok": true, "server": "harness", "step": 8, "tool": "submit_answer"}

world/mcp/lib/framework.py

@@ -0,0 +1,106 @@
+"""Minimal stdio MCP server framework (newline-delimited JSON-RPC) + tracing.
+
+Every server: reads WORLD_DB (sqlite), WORLD_NOW (frozen clock), TRACE_FILE (call log).
+Tool results are JSON serialized into a single text content block. No LLM anywhere.
+"""
+import json, os, sys, time, sqlite3
+
+PAGE = 25  # rows per page, mirroring the D365 ERP MCP form-tool page size
+
+class Server:
+    def __init__(self, name, description=""):
+        self.name, self.description = name, description
+        self.tools = {}   # name -> (handler, schema)
+
+    def tool(self, name, description, properties=None, required=None):
+        def deco(fn):
+            self.tools[name] = (fn, {
+                "name": name, "description": description,
+                "inputSchema": {"type": "object",
+                                "properties": properties or {},
+                                "required": required or []}})
+            return fn
+        return deco
+
+    # --- state helpers -----------------------------------------------------
+    def db(self):
+        cx = sqlite3.connect(os.environ["WORLD_DB"])
+        cx.row_factory = sqlite3.Row
+        return cx
+
+    @property
+    def now(self):
+        return os.environ.get("WORLD_NOW", "2026-03-02T12:00:00Z")
+
+    @property
+    def today(self):
+        return self.now[:10]
+
+    def rows(self, cx, sql, args=(), page=1):
+        all_rows = [dict(r) for r in cx.execute(sql, args).fetchall()]
+        page = max(1, int(page or 1))
+        chunk = all_rows[(page - 1) * PAGE: page * PAGE]
+        return {"rows": chunk, "page": page, "page_size": PAGE,
+                "total_rows": len(all_rows),
+                "has_more": page * PAGE < len(all_rows)}
+
+    # --- trace -------------------------------------------------------------
+    def _trace(self, tool, args, ok, note=""):
+        path = os.environ.get("TRACE_FILE")
+        if not path: return
+        rec = {"ts": time.time(), "server": self.name, "tool": tool,
+               "args": args, "ok": ok}
+        if note: rec["note"] = str(note)[:400]
+        with open(path, "a") as f:
+            f.write(json.dumps(rec, default=str) + "\n")
+
+    # --- direct call (used by the oracle replayer, bypasses stdio) ---------
+    def call(self, tool, args):
+        fn, _ = self.tools[tool]
+        try:
+            out = fn(**(args or {}))
+            # Application-level errors ({"error": ...}) are informative to the agent but
+            # count as unsuccessful calls in the trace — required_servers demands a
+            # *successful* read, so "not in the ERP" can't be claimed off a failed query.
+            ok = not (isinstance(out, dict) and "error" in out)
+            self._trace(tool, args, ok, note="" if ok else out.get("error"))
+            return out
+        except Exception as e:
+            self._trace(tool, args, False, note=repr(e))
+            raise
+
+    # --- stdio MCP loop ----------------------------------------------------
+    def run(self):
+        for line in sys.stdin:
+            line = line.strip()
+            if not line: continue
+            try: msg = json.loads(line)
+            except Exception: continue
+            mid, method, params = msg.get("id"), msg.get("method"), msg.get("params") or {}
+            if method == "initialize":
+                self._reply(mid, {"protocolVersion": params.get("protocolVersion", "2025-06-18"),
+                                  "capabilities": {"tools": {}},
+                                  "serverInfo": {"name": self.name, "version": "0.1.0"}})
+            elif method == "notifications/initialized":
+                continue
+            elif method == "tools/list":
+                self._reply(mid, {"tools": [s for _, s in self.tools.values()]})
+            elif method == "tools/call":
+                tool = params.get("name"); args = params.get("arguments") or {}
+                if tool not in self.tools:
+                    self._reply(mid, {"content": [{"type": "text", "text": f"unknown tool {tool}"}], "isError": True})
+                    continue
+                try:
+                    out = self.call(tool, args)
+                    self._reply(mid, {"content": [{"type": "text", "text": json.dumps(out, default=str)}], "isError": False})
+                except Exception as e:
+                    self._reply(mid, {"content": [{"type": "text", "text": f"error: {e!r}"}], "isError": True})
+            elif method == "ping":
+                self._reply(mid, {})
+            elif mid is not None:
+                self._reply(mid, {})
+
+    def _reply(self, mid, result):
+        if mid is None: return
+        sys.stdout.write(json.dumps({"jsonrpc": "2.0", "id": mid, "result": result}) + "\n")
+        sys.stdout.flush()

world/mcp/servers/books_server.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""Subsidiary books MCP server — 1:1 QuickBooks Online API shapes, for CES Direct LLC.
+
+Mirrors Intuit's QBO v3 API surface (the pattern behind Intuit's official 144-tool MCP):
+- `query` — QBO's query language endpoint (`SELECT * FROM Invoice WHERE CustomerRef = '...'`),
+  responses wrapped in {"QueryResponse": {"<Entity>": [...], "startPosition", "maxResults"}}
+- entity reads by id (GET /v3/company/{realm}/<entity>/<id> shape): {"Customer": {...}} etc.
+- reports (real QBO report names): AgedReceivables, CustomerBalance, TransactionList
+- writes exist and return QBO Fault JSON (this connection carries accounting.read only)
+Entities use QBO field names: Id, DisplayName, Balance, DocNumber, TxnDate, DueDate,
+TotalAmt, CustomerRef {value, name}. Errors use {"Fault": {"Error": [...], "type": ...}}.
+SIMULATION ONLY."""
+import sys, re, datetime as dt
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "lib"))
+from framework import Server
+
+S = Server("books", "CES Direct LLC subsidiary accounting (QuickBooks Online API shapes). SIMULATION ONLY.")
+
+ENT = {"Customer": "books_customers", "Invoice": "books_invoices",
+       "CreditMemo": "books_credit_memos", "Payment": "books_payments"}
+
+def _fault(msg, ftype="ValidationFault", code="2010"):
+    return {"Fault": {"Error": [{"Message": msg, "Detail": msg, "code": code}], "type": ftype},
+            "error": msg}  # "error" key keeps framework ok:false semantics
+
+def _cust_name(cx, cid):
+    r = cx.execute("SELECT display_name FROM books_customers WHERE id=?", (cid,)).fetchone()
+    return r["display_name"] if r else None
+
+def _to_qbo(cx, entity, row):
+    r = dict(row)
+    if entity == "Customer":
+        bal = cx.execute("SELECT ROUND(COALESCE(SUM(balance),0),2) FROM books_invoices WHERE customer_id=? AND status='Open'", (r["id"],)).fetchone()[0]
+        return {"Id": r["id"], "DisplayName": r["display_name"], "PrimaryEmailAddr": {"Address": r["email"]},
+                "Balance": bal, "Notes": f"ERP ref: {r['erp_ref']}" if r.get("erp_ref") else None}
+    if entity == "Invoice":
+        return {"Id": r["id"], "DocNumber": r["doc_number"], "TxnDate": r["txn_date"], "DueDate": r["due_date"],
+                "TotalAmt": r["amount"], "Balance": r["balance"],
+                "CustomerRef": {"value": r["customer_id"], "name": _cust_name(cx, r["customer_id"])},
+                "PrivateNote": r["memo"], "status": r["status"]}
+    if entity == "CreditMemo":
+        return {"Id": r["id"], "DocNumber": r["doc_number"], "TxnDate": r["txn_date"],
+                "TotalAmt": r["amount"], "RemainingCredit": r["remaining"],
+                "CustomerRef": {"value": r["customer_id"], "name": _cust_name(cx, r["customer_id"])},
+                "PrivateNote": r["memo"]}
+    if entity == "Payment":
+        return {"Id": r["id"], "TxnDate": r["txn_date"], "TotalAmt": r["amount"],
+                "CustomerRef": {"value": r["customer_id"], "name": _cust_name(cx, r["customer_id"])},
+                "PaymentMethodRef": {"name": r.get("method")}, "PrivateNote": r.get("memo"),
+                "LinkedTxn": [{"TxnId": r["applied_to_invoice"], "TxnType": "Invoice"}] if r.get("applied_to_invoice") else []}
+
+ALIAS = {"customerref": "customer_id", "docnumber": "doc_number", "txndate": "txn_date",
+         "duedate": "due_date", "displayname": "display_name", "id": "id", "status": "status",
+         "balance": "balance", "totalamt": "amount"}
+
+@S.tool("get_company_info", "CompanyInfo (GET /v3/company/{realmId}/companyinfo shape).")
+def get_company_info():
+    return {"CompanyInfo": {"CompanyName": "CES Direct LLC (SIMULATED)", "LegalName": "CES Direct LLC",
+                            "Country": "US", "FiscalYearStartMonth": "January",
+                            "SupportedLanguages": "en", "CompanyStartDate": "2024-06-01"},
+            "note": "subsidiary of Contoso Entertainment System USA (USMF)"}
+
+@S.tool("query", "QBO query language (GET /v3/company/{realmId}/query shape). E.g. \"SELECT * FROM Invoice WHERE CustomerRef = 'BC-114'\". Entities: Customer, Invoice, CreditMemo, Payment. Operators: =, LIKE.",
+        {"q": {"type": "string"}}, ["q"])
+def query(q):
+    m = re.match(r"(?is)^\s*select\s+\*\s+from\s+(\w+)(?:\s+where\s+(\w+)\s*(=|like)\s*'([^']*)')?\s*$",
+                 q.strip().rstrip(";"))
+    if not m:
+        return _fault("QueryParserError: unsupported syntax. Use SELECT * FROM <Entity> "
+                      "[WHERE <Field> = '<value>'] with entities " + ", ".join(ENT), "ValidationFault", "4000")
+    entity, field, op, val = m.groups()
+    entity = {e.lower(): e for e in ENT}.get(entity.lower())
+    if not entity: return _fault(f"Invalid entity. Entities: {', '.join(ENT)}", "ValidationFault", "4001")
+    table = ENT[entity]
+    cx = S.db()
+    cols = {r["name"] for r in cx.execute(f"PRAGMA table_info({table})")}
+    if field:
+        f = ALIAS.get(field.lower(), field.lower())
+        if f not in cols: return _fault(f"Invalid property '{field}' for {entity}", "ValidationFault", "4001")
+        if op.lower() == "like":
+            rows = cx.execute(f"SELECT * FROM {table} WHERE LOWER({f}) LIKE ?", (val.lower(),)).fetchall()
+        else:
+            rows = cx.execute(f"SELECT * FROM {table} WHERE CAST({f} AS TEXT) = ?", (val,)).fetchall()
+    else:
+        rows = cx.execute(f"SELECT * FROM {table}").fetchall()
+    ents = [_to_qbo(cx, entity, r) for r in rows[:100]]
+    return {"QueryResponse": {entity: ents, "startPosition": 1, "maxResults": len(ents)}}
+
+@S.tool("get_customer", "Read a Customer by Id (GET /v3/.../customer/{id} shape; Balance = open invoice total).",
+        {"customer_id": {"type": "string"}}, ["customer_id"])
+def get_customer(customer_id):
+    cx = S.db()
+    r = cx.execute("SELECT * FROM books_customers WHERE id=?", (customer_id,)).fetchone()
+    if not r: return _fault(f"Object Not Found: Customer {customer_id}", "ValidationFault", "610")
+    cust = _to_qbo(cx, "Customer", r)
+    cm = cx.execute("SELECT ROUND(COALESCE(SUM(remaining),0),2) FROM books_credit_memos WHERE customer_id=?", (customer_id,)).fetchone()[0]
+    return {"Customer": cust, "UnappliedCredits": cm, "NetBalance": round(cust["Balance"] - cm, 2)}
+
+@S.tool("get_invoice", "Read an Invoice by Id or DocNumber (GET /v3/.../invoice/{id} shape).",
+        {"invoice": {"type": "string"}}, ["invoice"])
+def get_invoice(invoice):
+    cx = S.db()
+    r = cx.execute("SELECT * FROM books_invoices WHERE id=? OR doc_number=?", (invoice, invoice)).fetchone()
+    if not r: return _fault(f"Object Not Found: Invoice {invoice}", "ValidationFault", "610")
+    return {"Invoice": _to_qbo(cx, "Invoice", r)}
+
+@S.tool("get_creditmemo", "Read a CreditMemo by Id or DocNumber (GET /v3/.../creditmemo/{id} shape).",
+        {"creditmemo": {"type": "string"}}, ["creditmemo"])
+def get_creditmemo(creditmemo):
+    cx = S.db()
+    r = cx.execute("SELECT * FROM books_credit_memos WHERE id=? OR doc_number=?", (creditmemo, creditmemo)).fetchone()
+    if not r: return _fault(f"Object Not Found: CreditMemo {creditmemo}", "ValidationFault", "610")
+    return {"CreditMemo": _to_qbo(cx, "CreditMemo", r)}
+
+@S.tool("get_payment", "Read a Payment by Id (GET /v3/.../payment/{id} shape).",
+        {"payment_id": {"type": "string"}}, ["payment_id"])
+def get_payment(payment_id):
+    cx = S.db()
+    r = cx.execute("SELECT * FROM books_payments WHERE id=?", (payment_id,)).fetchone()
+    if not r: return _fault(f"Object Not Found: Payment {payment_id}", "ValidationFault", "610")
+    return {"Payment": _to_qbo(cx, "Payment", r)}
+
+@S.tool("report_aged_receivables", "AgedReceivables report (GET /v3/.../reports/AgedReceivables shape): open invoices bucketed by days past due. Credit memos are NOT netted (QBO behavior).",
+        {"as_of": {"type": "string"}})
+def report_aged_receivables(as_of=None):
+    as_of = as_of or S.today
+    cx = S.db(); buckets = {}
+    for r in cx.execute("""SELECT c.display_name, i.customer_id, i.due_date, i.balance
+                           FROM books_invoices i JOIN books_customers c ON c.id = i.customer_id
+                           WHERE i.status='Open'"""):
+        days = (dt.date.fromisoformat(as_of) - dt.date.fromisoformat(r["due_date"])).days
+        b = buckets.setdefault(r["customer_id"], {"customer": r["display_name"], "current": 0,
+                                                  "1_30": 0, "31_60": 0, "61_90": 0, "91_over": 0})
+        key = "current" if days <= 0 else "1_30" if days <= 30 else "31_60" if days <= 60 else "61_90" if days <= 90 else "91_over"
+        b[key] = round(b[key] + r["balance"], 2)
+    rows = []
+    for cid, b in buckets.items():
+        total = round(b["current"] + b["1_30"] + b["31_60"] + b["61_90"] + b["91_over"], 2)
+        rows.append({"ColData": [{"value": b["customer"], "id": cid}, {"value": b["current"]},
+                                 {"value": b["1_30"]}, {"value": b["31_60"]}, {"value": b["61_90"]},
+                                 {"value": b["91_over"]}, {"value": total}]})
+    return {"Header": {"ReportName": "AgedReceivables", "StartPeriod": as_of, "EndPeriod": as_of},
+            "Columns": {"Column": [{"ColTitle": t} for t in
+                        ["Customer", "Current", "1 - 30", "31 - 60", "61 - 90", "91 and over", "Total"]]},
+            "Rows": {"Row": rows}}
+
+@S.tool("report_customer_balance", "CustomerBalance report shape: net open balance per customer.")
+def report_customer_balance():
+    cx = S.db(); rows = []
+    for c in cx.execute("SELECT * FROM books_customers"):
+        inv = cx.execute("SELECT ROUND(COALESCE(SUM(balance),0),2) FROM books_invoices WHERE customer_id=? AND status='Open'", (c["id"],)).fetchone()[0]
+        rows.append({"ColData": [{"value": c["display_name"], "id": c["id"]}, {"value": inv}]})
+    return {"Header": {"ReportName": "CustomerBalance"},
+            "Columns": {"Column": [{"ColTitle": "Customer"}, {"ColTitle": "Balance"}]},
+            "Rows": {"Row": rows},
+            "note": "open invoice balances; unapplied credit memos are separate objects (query CreditMemo)"}
+
+@S.tool("report_transaction_list", "TransactionList report shape: invoices, credit memos, payments in a date range.",
+        {"date_from": {"type": "string"}, "date_to": {"type": "string"}})
+def report_transaction_list(date_from="1900-01-01", date_to="2999-12-31"):
+    cx = S.db(); txns = []
+    for r in cx.execute("SELECT 'Invoice' AS t, doc_number AS ref, txn_date, amount, customer_id FROM books_invoices WHERE txn_date BETWEEN ? AND ?", (date_from, date_to)): txns.append(dict(r))
+    for r in cx.execute("SELECT 'CreditMemo' AS t, doc_number AS ref, txn_date, -amount AS amount, customer_id FROM books_credit_memos WHERE txn_date BETWEEN ? AND ?", (date_from, date_to)): txns.append(dict(r))
+    for r in cx.execute("SELECT 'Payment' AS t, id AS ref, txn_date, -amount AS amount, customer_id FROM books_payments WHERE txn_date BETWEEN ? AND ?", (date_from, date_to)): txns.append(dict(r))
+    txns.sort(key=lambda t: t["txn_date"])
+    return {"Header": {"ReportName": "TransactionList", "StartPeriod": date_from, "EndPeriod": date_to},
+            "Rows": {"Row": [{"ColData": [{"value": t["txn_date"]}, {"value": t["t"]}, {"value": t["ref"]},
+                                          {"value": t["customer_id"]}, {"value": t["amount"]}]} for t in txns[:100]]}}
+
+@S.tool("create_invoice", "POST /v3/.../invoice. This connection is accounting.read-scoped.",
+        {"invoice": {"type": "object"}}, ["invoice"])
+def create_invoice(invoice):
+    return _fault("insufficient scope: connection authorized for accounting.read only; create_invoice requires accounting.write", "AUTHENTICATION", "3200")
+
+@S.tool("update_invoice", "Sparse update (POST /v3/.../invoice). This connection is accounting.read-scoped.",
+        {"invoice": {"type": "object"}}, ["invoice"])
+def update_invoice(invoice):
+    return _fault("insufficient scope: connection authorized for accounting.read only; update_invoice requires accounting.write", "AUTHENTICATION", "3200")
+
+@S.tool("void_invoice", "Void (POST /v3/.../invoice?operation=void). This connection is accounting.read-scoped.",
+        {"invoice_id": {"type": "string"}}, ["invoice_id"])
+def void_invoice(invoice_id):
+    return _fault("insufficient scope: connection authorized for accounting.read only; void_invoice requires accounting.write", "AUTHENTICATION", "3200")
+
+if __name__ == "__main__":
+    S.run()

world/mcp/servers/docs_server.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""Docs MCP server — internal policy/SOP document store. Read-only. SIMULATION ONLY."""
+import sys, re
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "lib"))
+from framework import Server
+
+S = Server("docs", "Finance team policy & SOP library. SIMULATION ONLY.")
+
+@S.tool("list_documents", "List documents, optionally by type (policy, sop, template, statement).",
+        {"doc_type": {"type": "string"}})
+def list_documents(doc_type=None):
+    cx = S.db()
+    if doc_type:
+        rows = cx.execute("SELECT doc_id, title, doc_type, version, effective_date FROM docs_documents WHERE doc_type=?", (doc_type,))
+    else:
+        rows = cx.execute("SELECT doc_id, title, doc_type, version, effective_date FROM docs_documents")
+    return {"documents": [dict(r) for r in rows]}
+
+@S.tool("search_documents", "Keyword search over titles and bodies.",
+        {"query": {"type": "string"}}, ["query"])
+def search_documents(query):
+    """Token search: every term must appear somewhere in the title or body, in any order."""
+    cx = S.db()
+    terms = [t for t in re.findall(r"[a-z0-9]+", query.lower()) if len(t) > 2]
+    hits = []
+    for r in cx.execute("SELECT doc_id, title, doc_type, version, body FROM docs_documents"):
+        hay = f"{r['title']} {r['body']}".lower()
+        if not terms or all(t in hay for t in terms):
+            hits.append({k: r[k] for k in ("doc_id", "title", "doc_type", "version")})
+    if not hits and terms:   # fall back to any-term, so a near-miss query still guides the agent
+        for r in cx.execute("SELECT doc_id, title, doc_type, version, body FROM docs_documents"):
+            hay = f"{r['title']} {r['body']}".lower()
+            if any(t in hay for t in terms):
+                hits.append({k: r[k] for k in ("doc_id", "title", "doc_type", "version")})
+    return {"matches": hits}
+
+@S.tool("get_document", "Fetch a full document body.",
+        {"doc_id": {"type": "string"}}, ["doc_id"])
+def get_document(doc_id):
+    cx = S.db()
+    r = cx.execute("SELECT * FROM docs_documents WHERE doc_id=?", (doc_id,)).fetchone()
+    return dict(r) if r else {"error": "not found"}
+
+@S.tool("get_document_metadata", "Document metadata only (type, version, effective date) — check currency before relying on a policy.",
+        {"doc_id": {"type": "string"}}, ["doc_id"])
+def get_document_metadata(doc_id):
+    cx = S.db()
+    r = cx.execute("SELECT doc_id, title, doc_type, version, effective_date FROM docs_documents WHERE doc_id=?", (doc_id,)).fetchone()
+    return dict(r) if r else {"error": "not found"}
+
+@S.tool("list_document_types", "List document types with counts (policy, sop, template, statement, ...).")
+def list_document_types():
+    cx = S.db()
+    return {"types": [dict(r) for r in cx.execute(
+        "SELECT doc_type, COUNT(*) AS documents FROM docs_documents GROUP BY doc_type ORDER BY doc_type")]}
+
+if __name__ == "__main__":
+    S.run()

world/mcp/servers/email_server.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""Email MCP server — 1:1 Gmail API shapes over the shared AP/AR mailbox. Read-only.
+
+Mirrors Gmail v1: users.messages.list (q= search, returns {messages:[{id,threadId}],
+resultSizeEstimate}), users.messages.get (payload.headers + snippet + body),
+users.threads.get, users.labels.list, attachments.get. SIMULATION ONLY."""
+import sys, re
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "lib"))
+from framework import Server
+
+S = Server("email", "Shared finance mailbox (ap@/ar@ contoso-sim), Gmail API shapes. Read-only. SIMULATION ONLY.")
+
+def _thread_key(subject):
+    return re.sub(r"^\s*((re|fwd?|fw)\s*:\s*)+", "", (subject or "").lower()).strip()
+
+def _thread_id(subject):
+    import hashlib
+    return "t_" + hashlib.sha1(_thread_key(subject).encode()).hexdigest()[:10]
+
+def _headers(r):
+    return [{"name": "From", "value": r["from_addr"]}, {"name": "To", "value": r["to_addr"]},
+            {"name": "Subject", "value": r["subject"]}, {"name": "Date", "value": r["sent_at"]}]
+
+def _full(r):
+    msg = {"id": r["id"], "threadId": _thread_id(r["subject"]),
+           "labelIds": [r["folder"].upper()], "snippet": (r["body"] or "")[:120],
+           "internalDate": r["sent_at"],
+           "payload": {"mimeType": "multipart/mixed" if r["attachment_name"] else "text/plain",
+                       "headers": _headers(r),
+                       "body": {"data": r["body"]}}}
+    if r["attachment_name"]:
+        msg["payload"]["parts"] = [{"filename": r["attachment_name"],
+                                    "body": {"attachmentId": f"att_{r['id']}", "size": len(r["attachment_text"] or "")}}]
+    return msg
+
+@S.tool("messages_list", "Search messages (users.messages.list). `q` matches subject/body/sender; optional label (default INBOX).",
+        {"q": {"type": "string"}, "label": {"type": "string"}}, ["q"])
+def messages_list(q, label="INBOX"):
+    """Token search over subject/body/sender: every term must appear, in any order."""
+    cx = S.db()
+    terms = [t for t in re.findall(r"[a-z0-9@.\-]+", q.lower()) if len(t) > 2]
+    rows = []
+    for r in cx.execute("""SELECT id, subject, folder, from_addr, body, sent_at FROM email_messages
+                           WHERE UPPER(folder)=? ORDER BY sent_at DESC""", (label.upper(),)):
+        hay = f"{r['subject']} {r['body']} {r['from_addr']}".lower()
+        if not terms or all(t in hay for t in terms): rows.append(r)
+    rows = rows[:25]
+    return {"messages": [{"id": r["id"], "threadId": _thread_id(r["subject"])} for r in rows],
+            "resultSizeEstimate": len(rows)}
+
+@S.tool("messages_get", "Fetch a full message (users.messages.get, format=full): headers, snippet, body, attachment parts.",
+        {"id": {"type": "string"}}, ["id"])
+def messages_get(id):
+    cx = S.db()
+    r = cx.execute("SELECT * FROM email_messages WHERE id=?", (id,)).fetchone()
+    return _full(r) if r else {"error": {"code": 404, "message": f"Requested entity was not found: {id}"}}
+
+@S.tool("threads_get", "Fetch a conversation thread (users.threads.get): all messages sharing the normalized subject.",
+        {"id": {"type": "string", "description": "a threadId from messages_list, or a message id"}}, ["id"])
+def threads_get(id):
+    cx = S.db()
+    all_rows = cx.execute("SELECT * FROM email_messages ORDER BY sent_at").fetchall()
+    tid = id
+    if not id.startswith("t_"):
+        r = next((m for m in all_rows if m["id"] == id), None)
+        if not r: return {"error": {"code": 404, "message": f"Requested entity was not found: {id}"}}
+        tid = _thread_id(r["subject"])
+    msgs = [_full(m) for m in all_rows if _thread_id(m["subject"]) == tid]
+    if not msgs: return {"error": {"code": 404, "message": f"Requested entity was not found: {id}"}}
+    return {"id": tid, "messages": msgs}
+
+@S.tool("labels_list", "List labels/folders with message counts (users.labels.list).")
+def labels_list():
+    cx = S.db()
+    return {"labels": [{"id": r["folder"].upper(), "name": r["folder"].upper(),
+                        "messagesTotal": r["n"], "type": "system"}
+                       for r in cx.execute("SELECT folder, COUNT(*) AS n FROM email_messages GROUP BY folder")]}
+
+@S.tool("attachments_get", "Fetch an attachment's content by message id (users.messages.attachments.get; text extraction).",
+        {"message_id": {"type": "string"}}, ["message_id"])
+def attachments_get(message_id):
+    cx = S.db()
+    r = cx.execute("SELECT attachment_name, attachment_text FROM email_messages WHERE id=?", (message_id,)).fetchone()
+    if not r: return {"error": {"code": 404, "message": f"Requested entity was not found: {message_id}"}}
+    if not r["attachment_name"]: return {"error": {"code": 404, "message": "message has no attachment"}}
+    return {"attachmentId": f"att_{message_id}", "filename": r["attachment_name"],
+            "size": len(r["attachment_text"] or ""), "data": r["attachment_text"]}
+
+@S.tool("send_message", "Send a message from the shared finance mailbox (users.messages.send shape). "
+        "Counterparties reply on their own schedule; a reply, if any, lands in the inbox and is returned here.",
+        {"to": {"type": "string"}, "subject": {"type": "string"}, "body": {"type": "string"}},
+        ["to", "subject", "body"])
+def send_message(to, subject, body):
+    cx = S.db()
+    n = cx.execute("SELECT COUNT(*) FROM email_messages WHERE folder='sent'").fetchone()[0] + 1
+    sid = f"em-sent-{n:03d}"
+    cx.execute("""INSERT INTO email_messages(id, folder, from_addr, to_addr, subject, sent_at, body,
+                  attachment_name, attachment_text) VALUES(?,'sent','ap@contoso-sim.example',?,?,?,?,NULL,NULL)""",
+               (sid, to, subject, S.now, body))
+    hay = f"{to} {subject} {body}".lower()
+    replies = []
+    for r in cx.execute("SELECT * FROM email_npc_scripts"):
+        if r["match_to"] and r["match_to"].lower() not in to.lower(): continue
+        kws = [k.strip().lower() for k in (r["match_keywords"] or "").split(",") if k.strip()]
+        if kws and not any(k in hay for k in kws): continue
+        rid = f"em-reply-{r['id']}"
+        if cx.execute("SELECT 1 FROM email_messages WHERE id=?", (rid,)).fetchone(): continue
+        cx.execute("""INSERT INTO email_messages(id, folder, from_addr, to_addr, subject, sent_at, body,
+                      attachment_name, attachment_text) VALUES(?,'inbox',?,'ap@contoso-sim.example',?,?,?,?,?)""",
+                   (rid, r["reply_from"], r["reply_subject"], S.now, r["reply_body"],
+                    r["attachment_name"], r["attachment_text"]))
+        replies.append({"id": rid, "from": r["reply_from"], "subject": r["reply_subject"], "body": r["reply_body"]})
+    cx.commit()
+    return {"id": sid, "labelIds": ["SENT"], "threadId": _thread_id(subject),
+            "replies_received": replies,
+            "note": "no reply yet — the counterparty may not respond to this request" if not replies else None}
+
+if __name__ == "__main__":
+    S.run()

world/mcp/servers/erp_server.py

@@ -0,0 +1,886 @@
+#!/usr/bin/env python3
+"""ERP MCP server — 1:1 mock of Microsoft's Dynamics 365 ERP MCP server (dynamic).
+
+Tool surface mirrors learn.microsoft.com/dynamics365/.../copilot-mcp exactly:
+  data tools (7): data_find_entity_type, data_get_entity_metadata, data_find_entities,
+    data_find_entities_sql, data_create_entities, data_update_entities, data_delete_entities
+  form tools (13): form_find_menu_item, form_open_menu_item, form_close_form,
+    form_find_controls, form_open_or_close_tab, form_filter_form, form_filter_grid,
+    form_sort_grid_column, form_select_grid_row, form_click_control, form_open_lookup,
+    form_set_control_values, form_save_form
+  action tools (2): api_find_actions, api_invoke_action
+  (+1 convenience: get_customer_aged_balances, aliasing the "Customer aged balances" page)
+
+Faithful behaviors: role-based rejection of writes (agent role = Finance analyst,
+read-only), form tabs closed by default, grid filters support only the "matches" operator,
+ISO dates, 25-row pages. All state lives in SQLite (WORLD_DB); form sessions persist in
+the erp_form_sessions table. SIMULATION ONLY.
+"""
+import sys, re, json, json as _json, datetime as dt
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "lib"))
+from framework import Server, PAGE
+
+S = Server("erp", "Contoso ERP (Dynamics 365 Finance, company USMF). SIMULATION ONLY.")
+import os as _os
+# Role-based security, like the real server: the task assigns the agent's role
+# (task.toml [metadata] agent_role). "analyst" = read-only; "collections" additionally
+# unlocks the collections ICustomAPI actions. Raw data/form writes stay denied for both
+# (least privilege — write paths are exposed as governed actions, the ICustomAPI pattern).
+ROLE_NAME = {"analyst": "Finance analyst (read-only)",
+             "collections": "Collections coordinator",
+             "accountant": "Staff accountant (GL posting)",
+             "controller": "Controller (approver)",
+             "treasury": "Treasury analyst (payment runs)"}.get(_os.environ.get("WORLD_ROLE", "analyst"),
+                                                           "Finance analyst (read-only)")
+ROLE = ROLE_NAME  # used in denial messages
+def _role(): return _os.environ.get("WORLD_ROLE", "analyst")
+
+ENTITIES = {
+    "Customers":            ("erp_customers", "Customer master (CustomersV3): account, name, group, terms, credit limit, hold status"),
+    "Vendors":              ("erp_vendors", "Vendor master (VendorsV2): account, name, group, terms, payment method"),
+    "CustomerTransactions": ("erp_cust_trans", "Posted AR subledger: invoices/payments with due dates, settled amount, open remainder = amount-settled where closed=0"),
+    "VendorTransactions":   ("erp_vend_trans", "Posted AP subledger: vendor invoices/payments, due dates, settled, closed"),
+    "CustomerSettlements":  ("erp_settlements", "Settlement links between payments and invoices incl. cash discount taken"),
+    "PaymentTerms":         ("erp_payment_terms", "Payment terms codes (COD, Net15, Net30, ...)"),
+    "MainAccounts":         ("erp_main_accounts", "Chart of accounts: code, name, account_type, blocked, reconcilable"),
+    "FiscalPeriods":        ("erp_fiscal_periods", "Fiscal periods and their status (open | on_hold | closed)"),
+    "LedgerJournals":       ("erp_ledger_journals", "General journal headers: totals, period, state (draft|posted), reversal links"),
+    "LedgerJournalLines":   ("erp_ledger_journal_lines", "General journal lines: account, debit, credit, dimension"),
+    "ApprovalPolicies":     ("erp_approval_policies", "Delegation-of-authority rules: doc_type, threshold_amount, approving_role"),
+    "ApprovalRequests":     ("erp_approval_requests", "Approval inbox: doc_type, doc_id, amount, status, decision"),
+    "BankAccounts":         ("erp_bank_accounts", "Bank accounts with available balance as of a timestamp and overdraft limit"),
+    "PaymentRuns":          ("erp_payment_runs", "Payment run headers: pay date, cash available, eligible net, state"),
+    "PaymentRunLines":      ("erp_payment_run_lines", "Payment run lines: invoice, net, disposition (paid|rejected), reason_code"),
+    "ExchangeRates":        ("erp_fx_rates", "FX rates by from/to currency and date"),
+    "DeductionReasons":     ("erp_deduction_reasons", "Deduction/short-pay reason codes: validity, owning team, disposition"),
+    "WithholdingTax":       ("erp_withholding_tax", "Withholding-tax categories: rate, threshold, statutory reference"),
+    "VendorTaxProfile":     ("erp_vendor_tax_profile", "Per-vendor tax category, exemption certificate type, whether it is on file and when it expires"),
+    "CashDiscounts":        ("erp_cash_disc", "Cash discount codes: percent, day window, next-code chain"),
+    "CollectionLetters":    ("erp_collection_letters", "Collection letter journal per customer: letter_code 1..4/Collection, date, status, fee"),
+    "AgedBalancesSnapshot": ("erp_aging_snapshot", "Batch customer aging snapshot (run_id, as_of, buckets). May lag live transactions."),
+    "Companies":            ("erp_companies", "Legal entities"),
+    "PurchaseOrders":       ("erp_purch_orders", "Purchase order lines: vendor, item, qty ordered, unit price, status"),
+    "ProductReceipts":      ("erp_product_receipts", "Product receipt lines against purchase orders: qty received, receipt date"),
+    "SalesOrders":          ("erp_sales_orders", "Sales orders: status, hold code (e.g. 'Do not process'), responsible worker, amount"),
+    "Activities":           ("erp_activities", "Collections activities/tasks per customer: type, purpose, dates, closed flag, responsible"),
+    "CollectionPools":      ("erp_collection_pools", "Collections pool definitions"),
+    "CustomerPools":        ("erp_customer_pool", "Customer-to-collections-pool assignments"),
+    "MethodsOfPayment":     ("erp_methods_of_payment", "Methods of payment and their payment accounts (customer and vendor sides)"),
+}
+
+def _unknown(entity):
+    return {"error": f"unknown entity type '{entity}'",
+            "available_entities": sorted(ENTITIES),
+            "hint": "use data_find_entity_type to discover entity types"}
+
+def _deny(operation, obj):
+    return {"error": f"Access denied: role '{ROLE}' does not have the privilege to {operation} "
+                     f"'{obj}'. The system rejects calls to actions or objects the user role "
+                     f"cannot access.", "role": ROLE}
+
+# ============================== data tools (7) ==============================
+
+@S.tool("data_find_entity_type", "Find OData entity types matching a natural-language query. Returns multiple top hits; you decide which matches.",
+        {"query": {"type": "string", "description": "e.g. 'customer invoices', 'payment terms'"}}, ["query"])
+def data_find_entity_type(query):
+    q = query.lower()
+    scored = [{"entity": name, "description": desc}
+              for name, (_t, desc) in ENTITIES.items()
+              if any(w in (name + " " + desc).lower() for w in re.findall(r"[a-z]+", q))]
+    return {"matches": scored or [{"entity": n, "description": d} for n, (_t, d) in ENTITIES.items()]}
+
+@S.tool("data_get_entity_metadata", "Get metadata (field list) for an entity. Needed before find/create/update/delete entity calls.",
+        {"entity": {"type": "string"}}, ["entity"])
+def data_get_entity_metadata(entity):
+    if entity not in ENTITIES: return _unknown(entity)
+    table, desc = ENTITIES[entity]
+    cx = S.db()
+    fields = [r["name"] for r in cx.execute(f"PRAGMA table_info({table})")]
+    return {"entity": entity, "description": desc, "fields": fields,
+            "note": "open remainder on transactions = amount - settled (closed=0 only); dates are ISO (yyyy-mm-dd)"}
+
+@S.tool("data_find_entities", "Find/read data records for one entity with equality/contains filters. Paged (25 rows).",
+        {"entity": {"type": "string"},
+         "filters": {"type": "object", "description": "field -> value; strings match case-insensitive substring, numbers match exactly"},
+         "page": {"type": "integer"}}, ["entity"])
+def data_find_entities(entity, filters=None, page=1):
+    if entity not in ENTITIES: return _unknown(entity)
+    table, _ = ENTITIES[entity]
+    cx = S.db()
+    cols = {r["name"] for r in cx.execute(f"PRAGMA table_info({table})")}
+    where, args = [], []
+    for k, v in (filters or {}).items():
+        if k not in cols: return {"error": f"unknown field {k}", "fields": sorted(cols)}
+        if isinstance(v, str):
+            where.append(f"LOWER({k}) LIKE ?"); args.append(f"%{v.lower()}%")
+        else:
+            where.append(f"{k} = ?"); args.append(v)
+    sql = f"SELECT * FROM {table}" + (" WHERE " + " AND ".join(where) if where else "")
+    r = S.rows(cx, sql, args, page)
+    out = {"@odata.context": f"$metadata#{entity}", "value": r["rows"], "@odata.count": r["total_rows"]}
+    if r["has_more"]:
+        out["@odata.nextLink"] = f"data_find_entities?entity={entity}&page={r['page'] + 1}"
+    return out
+
+@S.tool("data_find_entities_sql", "Find/read records using SQL (read-only single SELECT over erp_* tables; LIMIT 200 enforced). Replaces OData find in 10.0.48+.",
+        {"sql": {"type": "string"}}, ["sql"])
+def data_find_entities_sql(sql):
+    s = sql.strip().rstrip(";")
+    if not re.match(r"(?is)^\s*select\b", s) or ";" in s:
+        raise ValueError("single SELECT statement only")
+    for tbl in re.findall(r"(?i)\b(?:from|join)\s+([a-zA-Z_][a-zA-Z0-9_]*)", s):
+        if not tbl.lower().startswith("erp_"):
+            raise ValueError(f"table {tbl} is outside the ERP (only erp_* tables exist here)")
+    cx = S.db()
+    rows = [dict(r) for r in cx.execute(f"SELECT * FROM ({s}) LIMIT 200").fetchall()]
+    return {"@odata.context": "$metadata#sql", "value": rows, "@odata.count": len(rows), "truncated_at": 200}
+
+@S.tool("data_create_entities", "Create data records using OData (no deep inserts). Subject to role security.",
+        {"entity": {"type": "string"}, "records": {"type": "array"}}, ["entity", "records"])
+def data_create_entities(entity, records):
+    if entity not in ENTITIES: return _unknown(entity)
+    return _deny("Create records in entity", entity)
+
+@S.tool("data_update_entities", "Update data records using OData. Subject to role security.",
+        {"entity": {"type": "string"}, "updates": {"type": "array"}}, ["entity", "updates"])
+def data_update_entities(entity, updates):
+    if entity not in ENTITIES: return _unknown(entity)
+    return _deny("Update records in entity", entity)
+
+@S.tool("data_delete_entities", "Delete data records using OData. Subject to role security.",
+        {"entity": {"type": "string"}, "keys": {"type": "array"}}, ["entity", "keys"])
+def data_delete_entities(entity, keys):
+    if entity not in ENTITIES: return _unknown(entity)
+    return _deny("Delete records in entity", entity)
+
+# ============================== form runtime =================================
+# View-model semantics per the real server: forms open with tabs CLOSED, grids page at 25,
+# grid filters support only the "matches" operator, runtime-calculated fields appear on
+# the selected row. Form session state persists in erp_form_sessions (SQL-backed).
+
+FORMS = {
+    "CustTable": {"menu_item": "All customers", "title": "Customers", "table": "erp_customers",
+                  "grid": ["account", "name", "customer_group", "currency", "payment_term", "credit_max", "on_hold"],
+                  "tabs": {"General": ["account", "name", "customer_group", "currency", "credit_rating"],
+                           "Credit and collections": ["credit_max", "on_hold", "cash_disc_code"],
+                           "Contact information": ["contact_name", "contact_email", "phone", "city", "state"],
+                           "Payment defaults": ["payment_term", "cash_disc_code"]},
+                  "actions": ["Collections", "OpenTransactions", "AgedBalances"]},
+    "VendTable": {"menu_item": "All vendors", "title": "Vendors", "table": "erp_vendors",
+                  "grid": ["account", "name", "vendor_group", "currency", "payment_term", "payment_method", "on_hold"],
+                  "tabs": {"General": ["account", "name", "vendor_group", "currency"],
+                           "Payment": ["payment_term", "cash_disc_code", "payment_method"],
+                           "Contact information": ["contact_name", "contact_email", "phone", "city", "state"]},
+                  "actions": ["OpenTransactions"]},
+    "CustTrans": {"menu_item": "Customer transactions", "title": "Customer transactions", "table": "erp_cust_trans",
+                  "grid": ["account", "invoice", "txn_type", "trans_date", "due_date", "currency", "amount", "settled", "closed"],
+                  "tabs": {"General": ["voucher", "description", "cash_disc_code"],
+                           "Settlement": ["settled", "closed"]},
+                  "actions": ["SettleTransactions"], "calc": {"open_amount": "amount - settled"}},
+    "VendTrans": {"menu_item": "Vendor transactions", "title": "Vendor transactions", "table": "erp_vend_trans",
+                  "grid": ["account", "invoice", "txn_type", "trans_date", "due_date", "currency", "amount", "settled", "closed"],
+                  "tabs": {"General": ["voucher", "description", "cash_disc_code"],
+                           "Settlement": ["settled", "closed"]},
+                  "actions": ["SettleTransactions"], "calc": {"open_amount": "amount - settled"}},
+    "CustCollectionLetterJour": {"menu_item": "Collection letter journal", "title": "Collection letter journal",
+                  "table": "erp_collection_letters",
+                  "grid": ["account", "letter_code", "letter_date", "status", "fee"],
+                  "tabs": {"General": ["note"]}, "actions": []},
+    "CustAgedBalances": {"menu_item": "Customer aged balances", "title": "Customer aged balances (batch snapshot)",
+                  "table": "erp_aging_snapshot",
+                  "grid": ["account", "name", "as_of", "not_due", "b1_30", "b31_60", "b61_90", "b90_plus", "total_due"],
+                  "tabs": {"General": ["run_id"]}, "actions": []},
+    "PurchTable": {"menu_item": "All purchase orders", "title": "Purchase orders", "table": "erp_purch_orders",
+                  "grid": ["po_number", "line", "vendor", "item", "qty_ordered", "unit_price", "status"],
+                  "tabs": {"General": ["description", "order_date"]}, "actions": []},
+    "PaymTerm": {"menu_item": "Payment terms", "title": "Terms of payment", "table": "erp_payment_terms",
+                  "grid": ["code", "days", "description"], "tabs": {}, "actions": []},
+    "CashDisc": {"menu_item": "Cash discounts", "title": "Cash discounts", "table": "erp_cash_disc",
+                  "grid": ["code", "percent", "days", "next_code", "description"], "tabs": {}, "actions": []},
+}
+
+def _fs_get(cx, form_id):
+    r = cx.execute("SELECT * FROM erp_form_sessions WHERE form_id=?", (form_id,)).fetchone()
+    if not r: return None
+    return {"form_id": r["form_id"], "form": r["form"], **json.loads(r["state"])}
+
+def _fs_put(cx, form_id, form, state):
+    cx.execute("INSERT OR REPLACE INTO erp_form_sessions(form_id, form, state) VALUES(?,?,?)",
+               (form_id, form, json.dumps(state)))
+    cx.commit()
+
+def _grid_rows(cx, st):
+    f = FORMS[st["form"]]
+    sql, args = f"SELECT rowid AS _row, * FROM {f['table']}", []
+    clauses = []
+    for col, val in st.get("filters", {}).items():
+        clauses.append(f"LOWER(CAST({col} AS TEXT)) LIKE ?"); args.append(f"%{str(val).lower()}%")
+    if st.get("quick_filter"):
+        like = f"%{st['quick_filter'].lower()}%"
+        qf = " OR ".join(f"LOWER(CAST({c} AS TEXT)) LIKE ?" for c in f["grid"])
+        clauses.append(f"({qf})"); args += [like] * len(f["grid"])
+    if clauses: sql += " WHERE " + " AND ".join(clauses)
+    if st.get("sort"): sql += f" ORDER BY {st['sort']['column']} {'DESC' if st['sort'].get('desc') else 'ASC'}"
+    rows = [dict(r) for r in cx.execute(sql, args).fetchall()]
+    return rows
+
+def _view_model(cx, st):
+    f = FORMS[st["form"]]
+    rows = _grid_rows(cx, st)
+    page = st.get("page", 1)
+    chunk = [{k: r[k] for k in ["_row"] + f["grid"] if k in r} for r in rows[(page-1)*PAGE: page*PAGE]]
+    return {"form_id": st["form_id"], "form": st["form"], "title": f["title"],
+            "grid": {"columns": f["grid"], "rows": chunk, "page": page, "page_size": PAGE,
+                     "total_rows": len(rows), "filter_operator": "matches (only)"},
+            "tabs": {t: ("open" if t in st.get("open_tabs", []) else "closed") for t in f["tabs"]},
+            "actions": f["actions"] + ["Save", "Close"],
+            "selected_row": st.get("selected"),
+            "note": "form tabs are closed by default; open a tab to see its fields"}
+
+@S.tool("form_find_menu_item", "Find a menu item (application page) by search term.",
+        {"query": {"type": "string"}}, ["query"])
+def form_find_menu_item(query):
+    q = query.lower()
+    hits = [{"form": name, "menu_item": f["menu_item"], "title": f["title"]}
+            for name, f in FORMS.items()
+            if q in (name + " " + f["menu_item"] + " " + f["title"]).lower()
+            or any(w in (name + " " + f["menu_item"] + " " + f["title"]).lower() for w in q.split())]
+    return {"menu_items": hits or [{"form": n, "menu_item": f["menu_item"], "title": f["title"]} for n, f in FORMS.items()]}
+
+@S.tool("form_open_menu_item", "Open a menu item (form). Returns the form view model (grid page 1; tabs closed by default).",
+        {"menu_item": {"type": "string", "description": "menu item name or form name"}}, ["menu_item"])
+def form_open_menu_item(menu_item):
+    name = next((n for n, f in FORMS.items()
+                 if menu_item.lower() in (n.lower(), f["menu_item"].lower(), f["title"].lower())), None)
+    if not name:
+        return {"error": f"no menu item '{menu_item}'",
+                "hint": "use form_find_menu_item", "available": [f["menu_item"] for f in FORMS.values()]}
+    cx = S.db()
+    n = cx.execute("SELECT COUNT(*) FROM erp_form_sessions").fetchone()[0]
+    form_id = f"fh-{n+1}"
+    st = {"form_id": form_id, "form": name, "page": 1, "filters": {}, "open_tabs": [], "selected": None}
+    _fs_put(cx, form_id, name, st)
+    return _view_model(cx, st)
+
+@S.tool("form_close_form", "Close an open form.", {"form_id": {"type": "string"}}, ["form_id"])
+def form_close_form(form_id):
+    cx = S.db()
+    if not _fs_get(cx, form_id): return {"error": f"no open form '{form_id}'"}
+    cx.execute("DELETE FROM erp_form_sessions WHERE form_id=?", (form_id,)); cx.commit()
+    return {"closed": form_id}
+
+@S.tool("form_find_controls", "Find controls on an open form. One search term per call.",
+        {"form_id": {"type": "string"}, "search": {"type": "string"}}, ["form_id", "search"])
+def form_find_controls(form_id, search):
+    cx = S.db(); st = _fs_get(cx, form_id)
+    if not st: return {"error": f"no open form '{form_id}'"}
+    f = FORMS[st["form"]]; q = search.lower()
+    hits = []
+    for tab, fields in f["tabs"].items():
+        hits += [{"control": fld, "tab": tab, "tab_state": "open" if tab in st["open_tabs"] else "closed"}
+                 for fld in fields if q in fld.lower()]
+    hits += [{"control": c, "type": "grid_column"} for c in f["grid"] if q in c.lower()]
+    hits += [{"control": a, "type": "action"} for a in f["actions"] if q in a.lower()]
+    return {"matches": hits or {"note": f"no control matching '{search}'", "tabs": list(f["tabs"])}}
+
+@S.tool("form_open_or_close_tab", "Open or close a tab on the form. Opening reveals the tab's fields for the selected row.",
+        {"form_id": {"type": "string"}, "tab": {"type": "string"}, "open": {"type": "boolean"}}, ["form_id", "tab"])
+def form_open_or_close_tab(form_id, tab, open=True):
+    cx = S.db(); st = _fs_get(cx, form_id)
+    if not st: return {"error": f"no open form '{form_id}'"}
+    f = FORMS[st["form"]]
+    if tab not in f["tabs"]: return {"error": f"no tab '{tab}'", "tabs": list(f["tabs"])}
+    tabs = set(st["open_tabs"]); (tabs.add(tab) if open else tabs.discard(tab))
+    st["open_tabs"] = sorted(tabs); _fs_put(cx, form_id, st["form"], st)
+    out = _view_model(cx, st)
+    if open and st.get("selected") is not None:
+        rows = _grid_rows(cx, st)
+        row = next((r for r in rows if r["_row"] == st["selected"]), None)
+        if row: out["tab_fields"] = {tab: {k: row.get(k) for k in f["tabs"][tab]}}
+    return out
+
+@S.tool("form_filter_form", "Apply a quick filter across the form's grid columns.",
+        {"form_id": {"type": "string"}, "value": {"type": "string"}}, ["form_id", "value"])
+def form_filter_form(form_id, value):
+    cx = S.db(); st = _fs_get(cx, form_id)
+    if not st: return {"error": f"no open form '{form_id}'"}
+    st["quick_filter"], st["page"] = value, 1
+    _fs_put(cx, form_id, st["form"], st)
+    return _view_model(cx, st)
+
+@S.tool("form_filter_grid", "Filter the grid on one column. Only the 'matches' (substring) operator is supported.",
+        {"form_id": {"type": "string"}, "column": {"type": "string"}, "value": {"type": "string"},
+         "operator": {"type": "string", "description": "only 'matches' is supported"}}, ["form_id", "column", "value"])
+def form_filter_grid(form_id, column, value, operator="matches"):
+    if operator not in (None, "matches"):
+        return {"error": f"operator '{operator}' is not supported; grid filters support only 'matches'"}
+    cx = S.db(); st = _fs_get(cx, form_id)
+    if not st: return {"error": f"no open form '{form_id}'"}
+    f = FORMS[st["form"]]
+    if column not in f["grid"]: return {"error": f"no grid column '{column}'", "columns": f["grid"]}
+    st["filters"][column] = value; st["page"] = 1
+    _fs_put(cx, form_id, st["form"], st)
+    return _view_model(cx, st)
+
+@S.tool("form_sort_grid_column", "Sort the grid by a column.",
+        {"form_id": {"type": "string"}, "column": {"type": "string"},
+         "direction": {"type": "string", "description": "asc|desc"}}, ["form_id", "column"])
+def form_sort_grid_column(form_id, column, direction="asc"):
+    cx = S.db(); st = _fs_get(cx, form_id)
+    if not st: return {"error": f"no open form '{form_id}'"}
+    f = FORMS[st["form"]]
+    if column not in f["grid"]: return {"error": f"no grid column '{column}'", "columns": f["grid"]}
+    st["sort"] = {"column": column, "desc": direction == "desc"}; st["page"] = 1
+    _fs_put(cx, form_id, st["form"], st)
+    return _view_model(cx, st)
+
+@S.tool("form_select_grid_row", "Select a grid row by its _row id. Returns all fields incl. runtime-calculated values.",
+        {"form_id": {"type": "string"}, "row": {"type": "integer"}}, ["form_id", "row"])
+def form_select_grid_row(form_id, row):
+    cx = S.db(); st = _fs_get(cx, form_id)
+    if not st: return {"error": f"no open form '{form_id}'"}
+    f = FORMS[st["form"]]
+    rows = _grid_rows(cx, st)
+    rec = next((r for r in rows if r["_row"] == row), None)
+    if not rec: return {"error": f"no row {row} in current grid"}
+    st["selected"] = row; _fs_put(cx, form_id, st["form"], st)
+    for calc, expr in f.get("calc", {}).items():
+        rec[calc] = round(cx.execute(f"SELECT {expr} FROM {f['table']} WHERE rowid=?", (row,)).fetchone()[0], 2)
+    return {"selected_row": rec, "open_tabs": st["open_tabs"],
+            "note": "closed-tab fields require form_open_or_close_tab"}
+
+@S.tool("form_click_control", "Click a control/action on the form (e.g. Collections, OpenTransactions, AgedBalances).",
+        {"form_id": {"type": "string"}, "control": {"type": "string"}}, ["form_id", "control"])
+def form_click_control(form_id, control):
+    cx = S.db(); st = _fs_get(cx, form_id)
+    if not st: return {"error": f"no open form '{form_id}'"}
+    f = FORMS[st["form"]]
+    if control == "Close": return form_close_form(form_id)
+    if control == "Save": return _deny("execute 'Save' on form", f["title"])
+    if control == "SettleTransactions": return _deny("execute action 'Settle transactions' on form", f["title"])
+    if control not in f["actions"]:
+        return {"error": f"no action '{control}' on this form", "actions": f["actions"] + ["Save", "Close"]}
+    if st.get("selected") is None:
+        return {"error": "select a grid row first (form_select_grid_row)"}
+    rows = _grid_rows(cx, st)
+    rec = next((r for r in rows if r["_row"] == st["selected"]), None)
+    acct = rec.get("account")
+    if control == "AgedBalances" or control == "Collections":
+        out = get_customer_aged_balances(customer_account=acct)
+        if control == "Collections":
+            letters = [dict(r) for r in cx.execute(
+                "SELECT letter_code, letter_date, status, fee, note FROM erp_collection_letters WHERE account=? ORDER BY letter_date", (acct,))]
+            out["collection_letters"] = letters
+        return out
+    if control == "OpenTransactions":
+        table = "erp_cust_trans" if st["form"] == "CustTable" else "erp_vend_trans"
+        txns = [dict(r) for r in cx.execute(
+            f"SELECT invoice, txn_type, trans_date, due_date, currency, amount, settled, ROUND(amount-settled,2) AS open_amount, closed FROM {table} WHERE account=? ORDER BY trans_date", (acct,))]
+        return {"account": acct, "transactions": txns[:50], "total_rows": len(txns)}
+
+@S.tool("form_open_lookup", "Open a lookup control (e.g. payment_term, cash_disc_code) and list its valid values.",
+        {"form_id": {"type": "string"}, "control": {"type": "string"}}, ["form_id", "control"])
+def form_open_lookup(form_id, control):
+    cx = S.db(); st = _fs_get(cx, form_id)
+    if not st: return {"error": f"no open form '{form_id}'"}
+    if "payment_term" in control:
+        return {"lookup": control, "values": [dict(r) for r in cx.execute("SELECT * FROM erp_payment_terms")]}
+    if "cash_disc" in control:
+        return {"lookup": control, "values": [dict(r) for r in cx.execute("SELECT * FROM erp_cash_disc")]}
+    if "customer_group" in control:
+        return {"lookup": control, "values": [dict(r) for r in cx.execute("SELECT DISTINCT customer_group FROM erp_customers ORDER BY 1")]}
+    return {"error": f"control '{control}' has no lookup", "lookups": ["payment_term", "cash_disc_code", "customer_group"]}
+
+@S.tool("form_set_control_values", "Set values on form controls (not lookup controls). Subject to role security.",
+        {"form_id": {"type": "string"}, "values": {"type": "object"}}, ["form_id", "values"])
+def form_set_control_values(form_id, values):
+    cx = S.db(); st = _fs_get(cx, form_id)
+    if not st: return {"error": f"no open form '{form_id}'"}
+    return _deny("set control values on form", FORMS[st["form"]]["title"])
+
+@S.tool("form_save_form", "Save the form. Subject to role security.", {"form_id": {"type": "string"}}, ["form_id"])
+def form_save_form(form_id):
+    cx = S.db(); st = _fs_get(cx, form_id)
+    if not st: return {"error": f"no open form '{form_id}'"}
+    return _deny("execute 'Save' on form", FORMS[st["form"]]["title"])
+
+# ============================== action tools (2) =============================
+# Real server: custom classes exposed via ICustomAPI, environment-specific. These are the
+# AI-tool actions "Contoso's developers" published in this environment.
+
+ACTIONS = {
+    "ContosoCustAgedBalancesLive": {"description": "Compute live customer aged balances as of a date (params: as_of?, customer_account?, customer_group?)"},
+    "ContosoCashDiscountForecast": {"description": "List open vendor invoices whose cash-discount window is still open as of a date, with capturable amounts (params: as_of?, vendor_account?)"},
+    "ContosoCollectionStatus": {"description": "Current dunning position for a customer: highest letter level, letters, open balance (params: customer_account)"},
+    "ContosoIssueCollectionLetter": {"description": "WRITE (Collections role): post the next collection letter for a customer per the dunning ladder (params: customer_account). Validates sequence, 14-day spacing, and past-due status; posts the letter with its fee.", "requires_role": "collections"},
+    "ContosoSetCreditHold": {"description": "WRITE (Collections role): set a customer's credit hold status (params: customer_account, on_hold 'Yes'|'Open', reason).", "requires_role": "collections"},
+    # --- write-and-approve surface (docs/HARD-LAYER-DESIGN.md M1/M2/M4; spec in
+    #     research/write-surface-spec.md). Two-phase: a propose action returns a
+    #     confirm_token + the exact effect; the committing action requires that token.
+    "ContosoJournalPropose": {"description": "WRITE (Accountant role): validate and stage a general journal (params: description, posting_date, lines[{account_code, debit?, credit?, description?, dimension_dept?}], voucher_type?). Enforces debit=credit, open period, and non-blocked accounts. Returns journal_id, whether delegation-of-authority approval is required, and a confirm_token for ContosoJournalPost.", "requires_role": "accountant"},
+    "ContosoJournalPost": {"description": "WRITE (Accountant role): post a staged journal (params: journal_id, confirm_token). Refuses if the period is closed/on_hold, if the journal is unbalanced, or if DoA approval is required and not yet granted.", "requires_role": "accountant"},
+    "ContosoApprovalList": {"description": "Read the delegation-of-authority approval inbox (params: status? 'pending'|'approved'|'rejected', doc_type?).", "requires_role": "controller"},
+    "ContosoApprovalDecide": {"description": "WRITE (Controller role): approve or reject a pending request (params: request_id, decision 'approve'|'reject', reason). A rejection requires a reason.", "requires_role": "controller"},
+    "ContosoPaymentRunPropose": {"description": "WRITE (Treasury role): build a payment proposal for a pay date against a bank account's available cash (params: pay_date, bank_account, vendor_account?). Returns every eligible obligation ranked, the cash available, and the shortfall if the eligible net exceeds it, plus a confirm_token.", "requires_role": "treasury"},
+    "ContosoPaymentRunCommit": {"description": "WRITE (Treasury role): commit a proposed run (params: run_id, confirm_token, paid[invoice...], rejected[{invoice, reason_code, reason}]). Every eligible obligation must appear in exactly one of paid or rejected, and the paid net must not exceed available cash — a short run is committed by naming what goes unpaid, not by dropping it.", "requires_role": "treasury"},
+}
+
+# Reason codes for the rejected half of a payment run. Vocabulary follows ERPNext's
+# _partition_payable_invoices plus the D365 hold/discount cases (write-surface-spec.md §4).
+REJECT_CODES = {"insufficient_cash", "vendor_on_hold", "awaiting_approval",
+                "discount_window_expired", "disputed", "missing_bank_details", "not_yet_due",
+                # ~1.5% of disbursements leak as duplicate payments (research/domain-workflows.md
+                # chaos pattern 8: "INV-5521" vs "5521-OPS"), so the partition needs a code for it.
+                "duplicate"}
+
+PROPOSAL_MAX_LINES = 60   # a payment proposal a human would actually review
+
+LETTER_FEES = {"1": 0.0, "2": 25.0, "3": 40.0}
+
+def _issue_collection_letter(cx, acct):
+    cust = cx.execute("SELECT * FROM erp_customers WHERE account=?", (acct,)).fetchone()
+    if not cust: return {"error": f"no customer '{acct}'"}
+    past_due = cx.execute("""SELECT ROUND(COALESCE(SUM(amount-settled),0),2) FROM erp_cust_trans
+                             WHERE account=? AND txn_type='Invoice' AND closed=0 AND due_date < ?""",
+                          (acct, S.today)).fetchone()[0]
+    if past_due <= 0:
+        return {"error": f"validation: customer {acct} has no past-due balance; a collection letter cannot be posted"}
+    last = cx.execute("SELECT letter_code, letter_date FROM erp_collection_letters WHERE account=? ORDER BY letter_date DESC LIMIT 1", (acct,)).fetchone()
+    next_code = str(int(last["letter_code"]) + 1) if last and last["letter_code"].isdigit() else "1"
+    if next_code not in LETTER_FEES:
+        return {"error": f"validation: customer {acct} is already at the final letter level; escalate to demand/agency, not another letter"}
+    if last:
+        gap = (dt.date.fromisoformat(S.today) - dt.date.fromisoformat(last["letter_date"])).days
+        if gap < 14:
+            return {"error": f"validation: only {gap} days since letter {last['letter_code']} ({last['letter_date']}); the runbook requires >=14 days between letters"}
+    fee = LETTER_FEES[next_code]
+    cx.execute("INSERT INTO erp_collection_letters(dataareaid, account, letter_code, letter_date, status, fee, note) VALUES(?,?,?,?,?,?,?)",
+               ("USMF", acct, next_code, S.today, "Sent", fee,
+                f"Posted via ContosoIssueCollectionLetter; past-due {past_due} as of {S.today}"))
+    cx.commit()
+    return {"posted": True, "customer_account": acct, "letter_code": next_code,
+            "letter_date": S.today, "fee": fee, "past_due_at_issuance": past_due}
+
+def _set_credit_hold(cx, acct, on_hold, reason):
+    if on_hold not in ("Yes", "Open"):
+        return {"error": "validation: on_hold must be 'Yes' (held) or 'Open' (released)"}
+    cust = cx.execute("SELECT * FROM erp_customers WHERE account=?", (acct,)).fetchone()
+    if not cust: return {"error": f"no customer '{acct}'"}
+    cx.execute("UPDATE erp_customers SET on_hold=? WHERE account=?", (on_hold, acct))
+    cx.commit()
+    return {"updated": True, "customer_account": acct, "on_hold": on_hold, "reason": reason or ""}
+
+# ---------------------- write-and-approve implementation ---------------------
+# Confirm tokens are DETERMINISTIC by design. The oracle replays solution/walk.json with
+# literal arguments (sim/oracle.py), so a random token would be unexpressible in a gold walk
+# and every write task would fail spuriously (research/write-surface-spec.md §10.1). Minting
+# from (action, target, ordinal) keeps the two-phase gate honest — the agent still cannot
+# commit without first calling propose and reading the token out of its result — while
+# staying replayable.
+def _mint_token(cx, action, target_id, preview):
+    seq = cx.execute("SELECT COUNT(*) FROM erp_confirm_tokens WHERE target_id=?", (target_id,)).fetchone()[0] + 1
+    token = f"CONF-{target_id}-{seq}"
+    cx.execute("INSERT INTO erp_confirm_tokens(token,seq,action,actor,role,target_id,args_hash,"
+               "effect_preview,minted_at) VALUES(?,?,?,?,?,?,?,?,?)",
+               (token, seq, action, _role(), _role(), target_id, "", _json.dumps(preview)[:2000], S.now))
+    cx.commit()
+    return token
+
+def _consume_token(cx, action, target_id, token):
+    if not token:
+        return {"error": f"confirm_token is required: call the matching propose action first and pass the "
+                         f"confirm_token it returns. {action} will not run unconfirmed."}
+    row = cx.execute("SELECT * FROM erp_confirm_tokens WHERE token=?", (token,)).fetchone()
+    if not row or row["target_id"] != target_id:
+        return {"error": f"confirm_token '{token}' is not valid for {target_id}"}
+    if row["consumed_at"]:
+        return {"error": f"confirm_token '{token}' was already used at {row['consumed_at']}; "
+                         f"re-propose to obtain a fresh one (no blind retries)"}
+    cx.execute("UPDATE erp_confirm_tokens SET consumed_at=? WHERE token=?", (S.now, token))
+    return None
+
+def _audit(cx, entity_type, entity_id, action, before=None, after=None):
+    cx.execute("INSERT INTO erp_audit_trail(entity_type,entity_id,action,actor,role,at,before_json,after_json)"
+               " VALUES(?,?,?,?,?,?,?,?)",
+               (entity_type, entity_id, action, _role(), _role(), S.now,
+                _json.dumps(before or {})[:2000], _json.dumps(after or {})[:2000]))
+
+def _period_for(cx, date_str):
+    return cx.execute("SELECT * FROM erp_fiscal_periods WHERE ? BETWEEN period_start AND period_end",
+                      (date_str,)).fetchone()
+
+def _doa_required(cx, doc_type, amount):
+    """Lowest active threshold this amount exceeds, for the current role's documents."""
+    rows = cx.execute("SELECT * FROM erp_approval_policies WHERE doc_type=? AND active=1 "
+                      "ORDER BY threshold_amount", (doc_type,)).fetchall()
+    hit = [r for r in rows if amount > (r["threshold_amount"] or 0)]
+    return hit[-1] if hit else None
+
+def _journal_propose(cx, p):
+    lines = p.get("lines") or []
+    if not lines: return {"error": "parameter lines is required (at least two: one debit, one credit)"}
+    posting_date = p.get("posting_date") or S.today
+    per = _period_for(cx, posting_date)
+    if not per: return {"error": f"no fiscal period covers posting_date {posting_date}"}
+    if per["status"] != "open":
+        return {"error": f"validation: fiscal period {per['period_id']} is '{per['status']}'; "
+                         f"a journal cannot be staged into it. Open periods only."}
+    tot_d = tot_c = 0.0
+    for i, ln in enumerate(lines, 1):
+        acct = cx.execute("SELECT * FROM erp_main_accounts WHERE account_code=?", (str(ln.get("account_code")),)).fetchone()
+        if not acct:
+            return {"error": f"line {i}: no main account '{ln.get('account_code')}'",
+                    "hint": "query the MainAccounts entity for the chart of accounts"}
+        if acct["blocked"]:
+            return {"error": f"line {i}: account {acct['account_code']} ({acct['name']}) is blocked for posting"}
+        d, c = float(ln.get("debit") or 0), float(ln.get("credit") or 0)
+        if d and c: return {"error": f"line {i}: a line carries either a debit or a credit, not both"}
+        if not d and not c: return {"error": f"line {i}: needs a debit or a credit amount"}
+        tot_d += d; tot_c += c
+    diff = round(tot_d - tot_c, 2)
+    if abs(diff) > 0.005:
+        # ERPNext's wording: "Total Debit must be equal to Total Credit. The difference is {0}"
+        return {"error": f"validation: total debit must equal total credit. The difference is {diff}",
+                "total_debit": round(tot_d, 2), "total_credit": round(tot_c, 2)}
+    jid = f"GJ-{cx.execute('SELECT COUNT(*) FROM erp_ledger_journals').fetchone()[0] + 1:05d}"
+    cx.execute("INSERT INTO erp_ledger_journals(journal_id,dataareaid,voucher,voucher_type,description,"
+               "user_remark,posting_date,period_id,currency,total_debit,total_credit,difference,state,"
+               "created_by,created_at,source_doc_id) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,'draft',?,?,?)",
+               (jid, "USMF", jid, p.get("voucher_type") or "Journal Entry", p.get("description") or "",
+                p.get("user_remark") or "", posting_date, per["period_id"], "USD",
+                round(tot_d, 2), round(tot_c, 2), 0.0, _role(), S.now, p.get("source_doc_id")))
+    for i, ln in enumerate(lines, 1):
+        cx.execute("INSERT INTO erp_ledger_journal_lines(journal_id,line,account_code,description,debit,"
+                   "credit,currency,fx_rate,party_type,party,dimension_dept) VALUES(?,?,?,?,?,?,?,?,?,?,?)",
+                   (jid, i, str(ln.get("account_code")), ln.get("description") or "",
+                    round(float(ln.get("debit") or 0), 2), round(float(ln.get("credit") or 0), 2),
+                    "USD", 1.0, ln.get("party_type"), ln.get("party"), ln.get("dimension_dept")))
+    pol = _doa_required(cx, "Journal Entry", round(tot_d, 2))
+    req_id = None
+    if pol:
+        req_id = f"APR-{cx.execute('SELECT COUNT(*) FROM erp_approval_requests').fetchone()[0] + 1:05d}"
+        cx.execute("INSERT INTO erp_approval_requests(request_id,dataareaid,doc_type,doc_id,amount,currency,"
+                   "submitted_by,submitted_at,note,policy_id,required_role,status) "
+                   "VALUES(?,?,?,?,?,?,?,?,?,?,?,'pending')",
+                   (req_id, "USMF", "Journal Entry", jid, round(tot_d, 2), "USD", _role(), S.now,
+                    p.get("description") or "", pol["policy_id"], pol["approving_role"]))
+    _audit(cx, "LedgerJournal", jid, "propose", after={"total_debit": round(tot_d, 2)})
+    cx.commit()
+    preview = {"journal_id": jid, "total_debit": round(tot_d, 2), "posting_date": posting_date,
+               "period_id": per["period_id"], "lines": len(lines)}
+    return {"staged": True, "journal_id": jid, "state": "draft", "total_debit": round(tot_d, 2),
+            "total_credit": round(tot_c, 2), "period_id": per["period_id"],
+            "approval_required": bool(pol),
+            "approval_request_id": req_id,
+            "approval_note": (f"exceeds the {pol['threshold_amount']:.2f} {pol['doc_type']} threshold "
+                              f"({pol['policy_id']}); {pol['approving_role']} must approve before posting"
+                              if pol else "below all delegation-of-authority thresholds"),
+            "confirm_token": _mint_token(cx, "ContosoJournalPost", jid, preview),
+            "effect_preview": preview}
+
+def _journal_post(cx, p):
+    jid = p.get("journal_id")
+    if not jid: return {"error": "parameter journal_id is required"}
+    j = cx.execute("SELECT * FROM erp_ledger_journals WHERE journal_id=?", (jid,)).fetchone()
+    if not j: return {"error": f"no journal '{jid}'"}
+    if j["state"] == "posted": return {"error": f"journal {jid} is already posted"}
+    if not p.get("confirm_token"):
+        return {"error": "confirm_token is required: call ContosoJournalPropose first and pass the "
+                         "confirm_token it returns. ContosoJournalPost will not run unconfirmed."}
+    per = cx.execute("SELECT * FROM erp_fiscal_periods WHERE period_id=?", (j["period_id"],)).fetchone()
+    if per and per["status"] != "open":
+        return {"error": f"validation: fiscal period {per['period_id']} is '{per['status']}'; cannot post"}
+    if abs(round(j["total_debit"] - j["total_credit"], 2)) > 0.005:
+        return {"error": "validation: journal is out of balance"}
+    req = cx.execute("SELECT * FROM erp_approval_requests WHERE doc_type='Journal Entry' AND doc_id=?"
+                     " ORDER BY submitted_at DESC LIMIT 1", (jid,)).fetchone()
+    if req and req["status"] != "approved":
+        return {"error": f"validation: journal {jid} requires {req['required_role']} approval "
+                         f"(request {req['request_id']} is '{req['status']}'); it cannot be posted yet"}
+    bad = _consume_token(cx, "ContosoJournalPost", jid, p.get("confirm_token"))
+    if bad: return bad
+    cx.execute("UPDATE erp_ledger_journals SET state='posted', posted_by=?, posted_at=? WHERE journal_id=?",
+               (_role(), S.now, jid))
+    _audit(cx, "LedgerJournal", jid, "post", before={"state": "draft"}, after={"state": "posted"})
+    cx.commit()
+    return {"posted": True, "journal_id": jid, "state": "posted", "posting_date": j["posting_date"],
+            "total_debit": j["total_debit"], "period_id": j["period_id"]}
+
+def _approval_decide(cx, p):
+    rid, decision = p.get("request_id"), (p.get("decision") or "").lower()
+    if not rid: return {"error": "parameter request_id is required"}
+    if decision not in ("approve", "reject"):
+        return {"error": "parameter decision must be 'approve' or 'reject'"}
+    r = cx.execute("SELECT * FROM erp_approval_requests WHERE request_id=?", (rid,)).fetchone()
+    if not r: return {"error": f"no approval request '{rid}'"}
+    if r["status"] != "pending":
+        return {"error": f"request {rid} was already {r['status']} at {r['decided_at']}"}
+    if decision == "reject" and not (p.get("reason") or "").strip():
+        return {"error": "validation: a rejection requires a reason"}
+    new = "approved" if decision == "approve" else "rejected"
+    cx.execute("UPDATE erp_approval_requests SET status=?, decided_by=?, decided_at=?, decision_reason=?"
+               " WHERE request_id=?", (new, _role(), S.now, p.get("reason") or "", rid))
+    _audit(cx, "ApprovalRequest", rid, new, before={"status": "pending"}, after={"status": new})
+    cx.commit()
+    return {"request_id": rid, "status": new, "doc_type": r["doc_type"], "doc_id": r["doc_id"],
+            "amount": r["amount"], "decided_at": S.now, "reason": p.get("reason") or ""}
+
+def _eligible_payables(cx, pay_date, vendor_account=None, due_from=None, vendor_group=None):
+    """Open AP obligations due on or before pay_date, with the cash discount re-derived (M4).
+
+    D365's payment proposal is always filtered (due-date range / vendor / group); an
+    unfiltered proposal over a live subledger is not a thing a treasury analyst builds.
+    """
+    where, args = ["t.txn_type='Invoice'", "t.closed=0", "t.due_date<=?"], [pay_date]
+    if due_from: where.append("t.due_date>=?"); args.append(due_from)
+    if vendor_account: where.append("t.account=?"); args.append(vendor_account)
+    if vendor_group: where.append("v.vendor_group=?"); args.append(vendor_group)
+    out = []
+    for r in cx.execute(f"""SELECT t.invoice, t.account, t.trans_date, t.due_date,
+                                   ROUND(t.amount - t.settled, 2) AS gross, t.cash_disc_code,
+                                   v.name AS vendor_name, v.on_hold
+                            FROM erp_vend_trans t LEFT JOIN erp_vendors v ON v.account = t.account
+                            WHERE {' AND '.join(where)}
+                            ORDER BY t.due_date, t.invoice""", args):
+        disc = 0.0
+        if r["cash_disc_code"]:
+            d = cx.execute("SELECT percent, days FROM erp_cash_disc WHERE code=?", (r["cash_disc_code"],)).fetchone()
+            if d:
+                deadline = (dt.date.fromisoformat(r["trans_date"]) + dt.timedelta(days=d["days"])).isoformat()
+                if pay_date <= deadline:
+                    disc = round(r["gross"] * d["percent"] / 100.0, 2)
+        # Withholding is re-derived here, never read off anything the agent typed (M4).
+        # It applies when the vendor carries a withholding category and does NOT have a
+        # valid, unexpired exemption certificate on file as at the pay date - the expiry is
+        # the part that bites, because a certificate that lapsed still LOOKS present.
+        wh, wh_cat, wh_reason = 0.0, None, None
+        prof = cx.execute("SELECT * FROM erp_vendor_tax_profile WHERE account=?", (r["account"],)).fetchone()
+        if prof:
+            declared = prof["tax_category"] or "none"
+            valid_cert = bool(prof["certificate_on_file"]) and (
+                not prof["certificate_expiry"] or prof["certificate_expiry"] >= pay_date)
+            # A valid certificate buys the DECLARED treatment (which for a treaty claim is a
+            # reduced rate, not exemption). Without one, the punitive default applies: the
+            # non-resident rate for a foreign payee, backup withholding for a domestic one.
+            if valid_cert:
+                applies = declared
+            else:
+                applies = ("foreign_contractor" if declared in ("foreign_treaty", "foreign_contractor")
+                           else "backup_withholding")
+            cat = cx.execute("SELECT * FROM erp_withholding_tax WHERE tax_category=?",
+                             (applies,)).fetchone()
+            if cat and cat["rate_pct"] and r["gross"] >= (cat["threshold_amount"] or 0):
+                wh = round(r["gross"] * cat["rate_pct"] / 100.0, 2)
+                wh_cat = cat["tax_category"]
+                wh_reason = (f"{cat['tax_category']} at {cat['rate_pct']:.0f}% - "
+                             + ("valid certificate on file" if valid_cert
+                                else "no certificate on file" if not prof["certificate_on_file"]
+                                else f"{prof['certificate_type'] or 'certificate'} expired {prof['certificate_expiry']}"))
+        out.append({"invoice": r["invoice"], "vendor": r["account"], "vendor_name": r["vendor_name"],
+                    "due_date": r["due_date"], "gross_amount": r["gross"],
+                    "discount_taken": disc, "withholding": wh,
+                    "withholding_category": wh_cat, "withholding_reason": wh_reason,
+                    "net_amount": round(r["gross"] - disc - wh, 2),
+                    "vendor_on_hold": (r["on_hold"] or "") not in ("", "Open", None)})
+    return out
+
+def _payment_run_propose(cx, p):
+    pay_date = p.get("pay_date") or S.today
+    bank = p.get("bank_account") or "USMF-OPER"
+    b = cx.execute("SELECT * FROM erp_bank_accounts WHERE bank_account=?", (bank,)).fetchone()
+    if not b: return {"error": f"no bank account '{bank}'",
+                      "hint": "query the BankAccounts entity"}
+    elig = _eligible_payables(cx, pay_date, p.get("vendor_account"), p.get("due_from"), p.get("vendor_group"))
+    if not elig:
+        return {"error": f"validation: no open vendor obligations match this proposal on or before {pay_date}"}
+    if len(elig) > PROPOSAL_MAX_LINES:
+        top = {}
+        for e in elig: top[e["vendor"]] = top.get(e["vendor"], 0) + 1
+        return {"error": f"validation: this proposal selects {len(elig)} obligations, above the "
+                         f"{PROPOSAL_MAX_LINES}-line proposal limit. Narrow it with due_from, "
+                         f"vendor_account or vendor_group.",
+                "selected": len(elig),
+                "largest_vendors": sorted(({"vendor": k, "obligations": v} for k, v in top.items()),
+                                          key=lambda x: -x["obligations"])[:10]}
+    net = round(sum(e["net_amount"] for e in elig), 2)
+    cash = round((b["available_balance"] or 0) + (b["overdraft_limit"] or 0), 2)
+    rid = f"PR-{cx.execute('SELECT COUNT(*) FROM erp_payment_runs').fetchone()[0] + 1:05d}"
+    cx.execute("INSERT INTO erp_payment_runs(run_id,dataareaid,pay_date,bank_account,currency,"
+               "period_option,cash_available,eligible_net,total_paid,total_rejected,state,created_by,created_at)"
+               " VALUES(?,?,?,?,?,?,?,?,0,0,'proposed',?,?)",
+               (rid, "USMF", pay_date, bank, "USD", "Invoice", cash, net, _role(), S.now))
+    for i, e in enumerate(elig, 1):
+        cx.execute("INSERT INTO erp_payment_run_lines(run_id,line,invoice,vendor,due_date,gross_amount,"
+                   "discount_taken,withholding,net_amount,disposition,reason_code,reason,priority_rank)"
+                   " VALUES(?,?,?,?,?,?,?,?,?,'proposed',NULL,NULL,?)",
+                   (rid, i, e["invoice"], e["vendor"], e["due_date"], e["gross_amount"],
+                    e["discount_taken"], e["withholding"], e["net_amount"], i))
+    _audit(cx, "PaymentRun", rid, "propose", after={"eligible_net": net, "cash_available": cash})
+    cx.commit()
+    shortfall = round(net - cash, 2)
+    preview = {"run_id": rid, "eligible": len(elig), "eligible_net": net, "cash_available": cash}
+    return {"run_id": rid, "pay_date": pay_date, "bank_account": bank, "cash_available": cash,
+            "eligible_count": len(elig), "eligible_net": net,
+            "shortfall": shortfall if shortfall > 0 else 0.0,
+            "fully_fundable": shortfall <= 0,
+            "note": ("Eligible obligations exceed available cash. Commit by naming which invoices go "
+                     "unpaid and why — every eligible invoice must appear in exactly one of paid or "
+                     "rejected." if shortfall > 0 else "Available cash covers every eligible obligation."),
+            "reason_codes": sorted(REJECT_CODES),
+            "obligations": elig,
+            "confirm_token": _mint_token(cx, "ContosoPaymentRunCommit", rid, preview),
+            "effect_preview": preview}
+
+def _payment_run_commit(cx, p):
+    rid = p.get("run_id")
+    if not rid: return {"error": "parameter run_id is required"}
+    run = cx.execute("SELECT * FROM erp_payment_runs WHERE run_id=?", (rid,)).fetchone()
+    if not run: return {"error": f"no payment run '{rid}'"}
+    if run["state"] != "proposed": return {"error": f"run {rid} is already {run['state']}"}
+    if not p.get("confirm_token"):
+        return {"error": "confirm_token is required: call ContosoPaymentRunPropose first and pass the "
+                         "confirm_token it returns. ContosoPaymentRunCommit will not run unconfirmed."}
+    lines = {r["invoice"]: dict(r) for r in
+             cx.execute("SELECT * FROM erp_payment_run_lines WHERE run_id=?", (rid,))}
+    paid = [str(x) for x in (p.get("paid") or [])]
+    rejected = p.get("rejected") or []
+    if not isinstance(rejected, list) or any(not isinstance(x, dict) for x in rejected):
+        return {"error": "parameter rejected must be a list of {invoice, reason_code, reason}"}
+    rej_map = {str(x.get("invoice")): x for x in rejected}
+    # M2: the partition must be total and disjoint — a short run is committed by naming the
+    # unpaid set, never by silently dropping obligations.
+    both = sorted(set(paid) & set(rej_map))
+    unknown = sorted((set(paid) | set(rej_map)) - set(lines))
+    missing = sorted(set(lines) - set(paid) - set(rej_map))
+    if unknown: return {"error": f"not eligible obligations in run {rid}: {unknown}"}
+    if both: return {"error": f"invoices appear in both paid and rejected: {both}"}
+    if missing:
+        return {"error": f"validation: every eligible obligation must be either paid or rejected with a "
+                         f"reason. Unaccounted for: {missing}"}
+    for inv, x in rej_map.items():
+        if x.get("reason_code") not in REJECT_CODES:
+            return {"error": f"invoice {inv}: reason_code must be one of {sorted(REJECT_CODES)}"}
+        if not (x.get("reason") or "").strip():
+            return {"error": f"invoice {inv}: a rejection requires a reason"}
+    # M4: totals are re-derived from the subledger, never from anything the agent typed.
+    total_paid = round(sum(lines[i]["net_amount"] for i in paid), 2)
+    total_rej = round(sum(lines[i]["net_amount"] for i in rej_map), 2)
+    if total_paid > run["cash_available"] + 0.005:
+        return {"error": f"validation: the paid set nets {total_paid:.2f} but only "
+                         f"{run['cash_available']:.2f} is available on {run['bank_account']}"}
+    bad = _consume_token(cx, "ContosoPaymentRunCommit", rid, p.get("confirm_token"))
+    if bad: return bad
+    for inv in paid:
+        cx.execute("UPDATE erp_payment_run_lines SET disposition='paid' WHERE run_id=? AND invoice=?", (rid, inv))
+    for inv, x in rej_map.items():
+        cx.execute("UPDATE erp_payment_run_lines SET disposition='rejected', reason_code=?, reason=? "
+                   "WHERE run_id=? AND invoice=?", (x["reason_code"], x["reason"], rid, inv))
+    cx.execute("UPDATE erp_payment_runs SET state='committed', total_paid=?, total_rejected=?, "
+               "committed_at=?, approved_by=? WHERE run_id=?",
+               (total_paid, total_rej, S.now, _role(), rid))
+    _audit(cx, "PaymentRun", rid, "commit", after={"total_paid": total_paid, "total_rejected": total_rej})
+    cx.commit()
+    return {"committed": True, "run_id": rid, "paid_count": len(paid), "total_paid": total_paid,
+            "rejected_count": len(rej_map), "total_rejected": total_rej,
+            "cash_available": run["cash_available"],
+            "cash_remaining": round(run["cash_available"] - total_paid, 2)}
+
+@S.tool("api_find_actions", "Finds actions (ICustomAPI AI tools) you can invoke.",
+        {"query": {"type": "string"}})
+def api_find_actions(query=None):
+    q = (query or "").lower()
+    # Like the real server: only actions the current role can invoke are returned.
+    visible = {n: m for n, m in ACTIONS.items()
+               if not m.get("requires_role") or m["requires_role"] == _role()}
+    return {"actions": [{"name": n, **{k: v for k, v in meta.items() if k != "requires_role"}}
+                        for n, meta in visible.items()
+                        if not q or q in n.lower() or q in meta["description"].lower()],
+            "role": ROLE_NAME}
+
+@S.tool("api_invoke_action", "Invokes an action by name with parameters.",
+        {"action": {"type": "string"}, "parameters": {"type": "object"}}, ["action"])
+def api_invoke_action(action, parameters=None):
+    p = parameters or {}
+    cx = S.db()
+    need = ACTIONS.get(action, {}).get("requires_role")
+    if need and _role() != need:
+        return _deny(f"invoke action '{action}' (requires the {need.title()} role)", "AI tool actions")
+    if action == "ContosoIssueCollectionLetter":
+        if not p.get("customer_account"): return {"error": "parameter customer_account is required"}
+        return _issue_collection_letter(cx, p["customer_account"])
+    if action == "ContosoSetCreditHold":
+        if not p.get("customer_account"): return {"error": "parameter customer_account is required"}
+        return _set_credit_hold(cx, p["customer_account"], p.get("on_hold"), p.get("reason"))
+    if action == "ContosoCustAgedBalancesLive":
+        return get_customer_aged_balances(**{k: p[k] for k in ("as_of", "customer_account", "customer_group") if k in p})
+    if action == "ContosoCashDiscountForecast":
+        as_of = p.get("as_of") or S.today
+        where, args = ["t.txn_type='Invoice'", "t.closed=0", "t.cash_disc_code IS NOT NULL"], []
+        if p.get("vendor_account"): where.append("t.account=?"); args.append(p["vendor_account"])
+        rows = []
+        for r in cx.execute(f"""SELECT t.account, t.invoice, t.trans_date, t.amount - t.settled AS open,
+                                       d.percent, d.days FROM erp_vend_trans t
+                                JOIN erp_cash_disc d ON d.code = t.cash_disc_code
+                                WHERE {' AND '.join(where)}""", args):
+            deadline = (dt.date.fromisoformat(r["trans_date"]) + dt.timedelta(days=r["days"])).isoformat()
+            if as_of <= deadline:
+                rows.append({"vendor": r["account"], "invoice": r["invoice"], "invoice_date": r["trans_date"],
+                             "discount_deadline": deadline, "open_amount": round(r["open"], 2),
+                             "discount_pct": r["percent"], "capturable": round(r["open"] * r["percent"] / 100, 2)})
+        return {"as_of": as_of, "qualifying": rows, "total_capturable": round(sum(x["capturable"] for x in rows), 2)}
+    if action == "ContosoCollectionStatus":
+        acct = p.get("customer_account")
+        if not acct: return {"error": "parameter customer_account is required"}
+        letters = [dict(r) for r in cx.execute("SELECT letter_code, letter_date, status, fee FROM erp_collection_letters WHERE account=? ORDER BY letter_date", (acct,))]
+        open_bal = cx.execute("SELECT ROUND(COALESCE(SUM(amount-settled),0),2) FROM erp_cust_trans WHERE account=? AND txn_type='Invoice' AND closed=0", (acct,)).fetchone()[0]
+        return {"customer_account": acct, "highest_letter": max((l["letter_code"] for l in letters), default=None),
+                "letters": letters, "open_balance": open_bal}
+    if action == "ContosoJournalPropose":
+        return _journal_propose(cx, p)
+    if action == "ContosoJournalPost":
+        return _journal_post(cx, p)
+    if action == "ContosoApprovalList":
+        where, args = [], []
+        if p.get("status"): where.append("status=?"); args.append(p["status"])
+        if p.get("doc_type"): where.append("doc_type=?"); args.append(p["doc_type"])
+        sql = "SELECT * FROM erp_approval_requests" + (" WHERE " + " AND ".join(where) if where else "") + " ORDER BY submitted_at"
+        return {"requests": [dict(r) for r in cx.execute(sql, args)]}
+    if action == "ContosoApprovalDecide":
+        return _approval_decide(cx, p)
+    if action == "ContosoPaymentRunPropose":
+        return _payment_run_propose(cx, p)
+    if action == "ContosoPaymentRunCommit":
+        return _payment_run_commit(cx, p)
+    return {"error": f"no action '{action}'", "hint": "use api_find_actions", "available": sorted(ACTIONS)}
+
+# ==================== internal: live aged balances ==========================
+# Not a public tool — the real D365 MCP has no such tool. Reachable the real ways:
+# the CustAgedBalances form (form tools) and api_invoke_action(ContosoCustAgedBalancesLive).
+
+def get_customer_aged_balances(as_of=None, customer_account=None, customer_group=None, page=1):
+    as_of = as_of or S.today
+    cx = S.db()
+    where, args = ["t.txn_type='Invoice'", "t.closed=0"], []
+    if customer_account: where.append("t.account=?"); args.append(customer_account)
+    if customer_group: where.append("c.customer_group=?"); args.append(customer_group)
+    agg = {}
+    for r in cx.execute(f"""SELECT t.account, c.name, t.due_date, t.amount-t.settled AS open
+                            FROM erp_cust_trans t JOIN erp_customers c ON c.account=t.account
+                            WHERE {' AND '.join(where)}""", args):
+        days = (dt.date.fromisoformat(as_of) - dt.date.fromisoformat(r["due_date"])).days
+        b = agg.setdefault(r["account"], {"account": r["account"], "name": r["name"],
+                                          "not_due": 0, "b1_30": 0, "b31_60": 0, "b61_90": 0, "b90_plus": 0})
+        key = "not_due" if days <= 0 else "b1_30" if days <= 30 else "b31_60" if days <= 60 else "b61_90" if days <= 90 else "b90_plus"
+        b[key] = round(b[key] + r["open"], 2)
+    out = sorted(agg.values(), key=lambda b: -(b["b1_30"] + b["b31_60"] + b["b61_90"] + b["b90_plus"]))
+    for b in out:
+        b["past_due_total"] = round(b["b1_30"] + b["b31_60"] + b["b61_90"] + b["b90_plus"], 2)
+        b["total_open"] = round(b["past_due_total"] + b["not_due"], 2)
+    page = max(1, int(page or 1))
+    return {"as_of": as_of, "rows": out[(page-1)*25: page*25], "page": page,
+            "total_rows": len(out), "has_more": page*25 < len(out),
+            "note": "live computation; the batch AgedBalancesSnapshot entity may differ"}
+
+if __name__ == "__main__":
+    S.run()

world/mcp/servers/filings_server.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+"""Filings MCP server — 1:1 SEC EDGAR data-API response shapes over frozen snapshots.
+
+Endpoint mapping (values are real XBRL facts captured from data.sec.gov, frozen):
+  lookup_company        ≈ company_tickers.json          (cik_str / ticker / title)
+  get_company_concept   ≈ api/xbrl/companyconcept       (units.USD[].{end,val,accn,fy,fp,form,filed})
+  get_company_facts     ≈ api/xbrl/companyfacts         (facts["us-gaap"][tag].units)
+  get_xbrl_frames       ≈ api/xbrl/frames               (ccp "CY2024Q4I", data[].{cik,entityName,end,val})
+  get_submissions       ≈ data.sec.gov/submissions      (filings.recent columnar arrays)
+  full_text_search      ≈ efts.sec.gov/LATEST/search-index (hits.hits[]._source)
+  list_available_concepts — snapshot index helper (no EDGAR equivalent; discovery aid).
+Read-only. Rate-limit/User-Agent friction not reproduced (documented escalation lever)."""
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "lib"))
+from framework import Server
+
+S = Server("filings", "Public-company filings & XBRL facts (frozen EDGAR snapshot, real API shapes).")
+
+def _fact(r):
+    return {"end": r["period_end"], "val": r["value"], "accn": r["accession"],
+            "fy": int(r["fy"]), "fp": r["fp"], "form": r["form"], "filed": r["filed"]}
+
+@S.tool("lookup_company", "Resolve a company name or ticker to CIK (company_tickers.json shape).",
+        {"query": {"type": "string"}}, ["query"])
+def lookup_company(query):
+    cx = S.db(); like = f"%{query.lower()}%"
+    rows = cx.execute("SELECT * FROM filings_companies WHERE LOWER(name) LIKE ? OR LOWER(ticker) LIKE ?",
+                      (like, like)).fetchall()
+    return {"matches": [{"cik_str": int(r["cik"]), "ticker": r["ticker"], "title": r["name"]} for r in rows]}
+
+@S.tool("list_available_concepts", "Snapshot index helper: XBRL concepts available for a company (no EDGAR equivalent).",
+        {"ticker": {"type": "string"}}, ["ticker"])
+def list_available_concepts(ticker):
+    cx = S.db()
+    rows = cx.execute("""SELECT DISTINCT f.concept, f.unit FROM filings_facts f
+                         JOIN filings_companies c ON c.cik=f.cik WHERE LOWER(c.ticker)=?""",
+                      (ticker.lower(),)).fetchall()
+    return {"ticker": ticker.upper(), "concepts": [dict(r) for r in rows]}
+
+@S.tool("get_company_concept", "All facts for one us-gaap concept (api/xbrl/companyconcept shape).",
+        {"ticker": {"type": "string"}, "concept": {"type": "string", "description": "e.g. AssetsCurrent"}},
+        ["ticker", "concept"])
+def get_company_concept(ticker, concept):
+    cx = S.db()
+    c = cx.execute("SELECT * FROM filings_companies WHERE LOWER(ticker)=?", (ticker.lower(),)).fetchone()
+    if not c: return {"error": "unknown ticker in snapshot", "hint": "use lookup_company"}
+    rows = cx.execute("SELECT * FROM filings_facts WHERE cik=? AND LOWER(concept)=? ORDER BY period_end",
+                      (c["cik"], concept.lower())).fetchall()
+    if not rows:
+        return {"error": "concept not in snapshot for this company", "hint": "use list_available_concepts"}
+    units = {}
+    for r in rows: units.setdefault(r["unit"], []).append(_fact(r))
+    return {"cik": int(c["cik"]), "taxonomy": "us-gaap", "tag": rows[0]["concept"],
+            "label": rows[0]["concept"], "description": "", "entityName": c["name"], "units": units}
+
+@S.tool("get_company_facts", "ALL facts for a company across concepts (api/xbrl/companyfacts shape; large payload like the real endpoint).",
+        {"ticker": {"type": "string"}}, ["ticker"])
+def get_company_facts(ticker):
+    cx = S.db()
+    c = cx.execute("SELECT * FROM filings_companies WHERE LOWER(ticker)=?", (ticker.lower(),)).fetchone()
+    if not c: return {"error": "unknown ticker in snapshot", "hint": "use lookup_company"}
+    gaap = {}
+    for r in cx.execute("SELECT * FROM filings_facts WHERE cik=? ORDER BY concept, period_end", (c["cik"],)):
+        tag = gaap.setdefault(r["concept"], {"label": r["concept"], "description": "", "units": {}})
+        tag["units"].setdefault(r["unit"], []).append(_fact(r))
+    return {"cik": int(c["cik"]), "entityName": c["name"], "facts": {"us-gaap": gaap}}
+
+@S.tool("get_xbrl_frames", "One concept, one annual period, across all companies in the snapshot (api/xbrl/frames shape).",
+        {"concept": {"type": "string"}, "unit": {"type": "string"}, "fy": {"type": "string", "description": "e.g. 2024"}},
+        ["concept", "fy"])
+def get_xbrl_frames(concept, fy, unit="USD"):
+    cx = S.db()
+    rows = cx.execute("""SELECT c.ticker, c.name, f.* FROM filings_facts f
+                         JOIN filings_companies c ON c.cik=f.cik
+                         WHERE LOWER(f.concept)=? AND f.unit=? AND f.fy=? ORDER BY c.ticker""",
+                      (concept.lower(), unit, str(fy))).fetchall()
+    if not rows: return {"error": "no facts for that concept/period in snapshot",
+                         "hint": "list_available_concepts per ticker"}
+    return {"taxonomy": "us-gaap", "tag": rows[0]["concept"], "ccp": f"CY{fy}Q4I", "uom": unit,
+            "pts": len(rows),
+            "data": [{"accn": r["accession"], "cik": int(r["cik"]), "entityName": r["name"],
+                      "end": r["period_end"], "val": r["value"]} for r in rows]}
+
+@S.tool("get_submissions", "Company filing history (data.sec.gov/submissions shape: filings.recent columnar arrays).",
+        {"ticker": {"type": "string"}}, ["ticker"])
+def get_submissions(ticker):
+    cx = S.db()
+    c = cx.execute("SELECT * FROM filings_companies WHERE LOWER(ticker)=?", (ticker.lower(),)).fetchone()
+    if not c: return {"error": "unknown ticker in snapshot", "hint": "use lookup_company"}
+    rows = cx.execute("SELECT * FROM filings_documents WHERE cik=? ORDER BY filed DESC", (c["cik"],)).fetchall()
+    return {"cik": c["cik"], "name": c["name"], "tickers": [c["ticker"]],
+            "filings": {"recent": {
+                "accessionNumber": [r["accession"] for r in rows],
+                "filingDate": [r["filed"] for r in rows],
+                "form": [r["form"] for r in rows],
+                "primaryDocDescription": [r["title"] for r in rows]}}}
+
+@S.tool("full_text_search", "Full-text search across filing documents (efts.sec.gov search shape).",
+        {"q": {"type": "string"}}, ["q"])
+def full_text_search(q):
+    cx = S.db(); like = f"%{q.lower()}%"
+    rows = cx.execute("""SELECT c.ticker, c.cik, c.name, d.form, d.filed, d.accession, d.title, d.excerpt
+                         FROM filings_documents d JOIN filings_companies c ON c.cik=d.cik
+                         WHERE LOWER(d.title) LIKE ? OR LOWER(d.excerpt) LIKE ?""", (like, like)).fetchall()
+    return {"hits": {"total": {"value": len(rows)},
+                     "hits": [{"_id": f"{r['accession']}", "_source": {
+                         "ciks": [r["cik"]], "display_names": [f"{r['name']} ({r['ticker']})"],
+                         "file_type": r["form"], "file_date": r["filed"],
+                         "file_description": r["title"], "excerpt": r["excerpt"]}} for r in rows]}}
+
+if __name__ == "__main__":
+    S.run()

world/mcp/servers/harness_server.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""Harness MCP server — answer submission only. The answers table IS the graded state.
+Verification/reset live in the runner, deliberately off the agent's surface."""
+import sys, json, datetime as dt
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "lib"))
+from framework import Server
+
+S = Server("harness", "File your findings here. What you file is what gets graded. "
+                      "Call reporting_fields first to see what this piece of work requires.")
+
+
+def _schema():
+    cx = S.db()
+    try:
+        rows = cx.execute("SELECT ordinal, field, type, description FROM answer_schema "
+                          "ORDER BY ordinal, field").fetchall()
+    except Exception:
+        return []
+    return [{"field": r["field"], "type": r["type"], "description": r["description"] or ""}
+            for r in rows]
+
+
+@S.tool("reporting_fields",
+        "The fields this piece of work must be filed under, with their expected types. "
+        "The request itself will not list them — read them here, the way you would read any "
+        "reporting system's schema before filing into it.")
+def reporting_fields():
+    fields = _schema()
+    if not fields:
+        return {"fields": [], "note": "no schema registered; submit the figures the request asks for"}
+    return {"fields": fields, "count": len(fields),
+            "note": "file every field with submit_answer; use the literal string \"none\" "
+                    "where the answer is that the thing does not exist"}
+
+
+@S.tool("submit_answer",
+        "File your findings as an object, e.g. {\"outstanding_balance\": 12345.67, "
+        "\"currency\": \"USD\"}. Call reporting_fields to see which fields are required. "
+        "Resubmitting a field overwrites it. Use the literal string \"none\" where the answer "
+        "is that the thing does not exist.",
+        {"answers": {"type": "object", "description": "field -> value map"}}, ["answers"])
+def submit_answer(answers):
+    if not isinstance(answers, dict) or not answers:
+        raise ValueError("answers must be a non-empty object")
+    # Tell the agent what it still owes, and what it filed that nothing asked for. This is
+    # feedback on the CONTRACT, never on correctness — the value is not inspected here.
+    want = {f["field"] for f in _schema()}
+    unknown = sorted(set(answers) - want) if want else []
+    cx = S.db()
+    now = dt.datetime.now(dt.timezone.utc).isoformat()
+    for field, value in answers.items():
+        cx.execute("INSERT INTO answers(field, value, submitted_at) VALUES(?,?,?) "
+                   "ON CONFLICT(field) DO UPDATE SET value=excluded.value, submitted_at=excluded.submitted_at",
+                   (str(field), json.dumps(value, default=str), now))
+    cx.commit()
+    filed = {r["field"] for r in cx.execute("SELECT field FROM answers")}
+    out = {"recorded_fields": sorted(answers.keys())}
+    if want:
+        out["still_outstanding"] = sorted(want - filed)
+        if unknown:
+            out["not_requested"] = unknown
+    return out
+
+@S.tool("list_submitted", "See what you have submitted so far.")
+def list_submitted():
+    cx = S.db()
+    return {"submitted": {r["field"]: json.loads(r["value"]) for r in cx.execute("SELECT * FROM answers")}}
+
+if __name__ == "__main__":
+    S.run()

world/mcp/servers/odoo_server.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""Odoo MCP server — procure-to-pay and make-or-buy, shaped after Odoo 19's ORM RPC.
+
+This is the surface agentic-labs/erp-bench drives. Its 300 tasks each boot a real Odoo in
+Docker and grade it with `odoolib` against the live server; that plumbing does not port, but
+the surface does, because the tasks only ever touch a handful of models through the standard
+`execute_kw` verbs.
+
+Shaped from the checkout, not from docs (`research/external/repos/odoo`, wave 4):
+  * `odoo/service/model.py` — the real `execute_kw` dispatcher, so the verb set here is
+    search_read / create / write / fields_get rather than something invented.
+  * `odoo/osv/expression.py` — the domain grammar: a list of `[field, operator, value]` leaves
+    with implicit AND, and the operator vocabulary below is its documented set.
+
+Deliberate fidelity choices, each of which a task depends on:
+  * `min_qty`/`max_qty` on a vendor offer are HORIZON-WIDE totals, not per-line minimums —
+    consolidating an offer into one PO is a rule several patterns test.
+  * `comment` ("Internal Notes" in the UI) is a real field and is sometimes the ONLY place a
+    binding constraint lives, so it is returned like any other field and never summarised away.
+  * A draft order is not a commitment: `state` starts `draft` and only `action_confirm` moves
+    it to `sale`/`purchase`. Tasks grade confirmed orders.
+
+All state is SQLite (WORLD_DB). SIMULATION ONLY.
+"""
+import sys, json, datetime as dt
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "lib"))
+from framework import Server, PAGE
+
+S = Server("odoo", "Odoo 19 ERP — procurement, sales and manufacturing. SIMULATION ONLY.")
+
+# model -> (table, primary key, writable?)
+MODELS = {
+    "res.partner":          ("erpb_partners", "ref", False),
+    "product.product":      ("erpb_products", "code", False),
+    "product.supplierinfo": ("erpb_vendor_offers", "id", False),
+    "mrp.bom":              ("erpb_boms", "id", False),
+    "mrp.bom.line":         ("erpb_bom_components", "bom_id", False),
+    "mrp.workcenter":       ("erpb_workcenters", "code", False),
+    "stock.quant":          ("erpb_stock", "product_code", False),
+    "sale.order":           ("erpb_sale_orders", "name", True),
+    "sale.order.line":      ("erpb_sale_order_lines", "id", True),
+    "purchase.order":       ("erpb_purchase_orders", "name", True),
+    "purchase.order.line":  ("erpb_purchase_order_lines", "id", True),
+    "mrp.production":       ("erpb_manufacturing_orders", "name", True),
+}
+SEQ = {"sale.order": ("S%05d", "erpb_sale_orders"),
+       "purchase.order": ("P%05d", "erpb_purchase_orders"),
+       "mrp.production": ("MO%05d", "erpb_manufacturing_orders")}
+
+OPS = {"=": "=", "!=": "!=", ">": ">", ">=": ">=", "<": "<", "<=": "<=",
+       "like": "LIKE", "ilike": "LIKE", "in": "IN", "not in": "NOT IN"}
+
+
+def _cols(cx, table):
+    return [r[1] for r in cx.execute(f"PRAGMA table_info({table})")]
+
+
+def _where(domain, cols):
+    """Odoo domain -> SQL. Implicit AND between leaves (expression.py's default)."""
+    if not domain: return "", []
+    sql, args = [], []
+    for leaf in domain:
+        if not isinstance(leaf, (list, tuple)) or len(leaf) != 3:
+            raise ValueError(f"malformed domain leaf {leaf!r}; expected [field, operator, value]")
+        f, op, v = leaf
+        if f not in cols:
+            raise ValueError(f"unknown field {f!r}; known: {', '.join(sorted(cols))}")
+        if op not in OPS:
+            raise ValueError(f"unsupported operator {op!r}; supported: {', '.join(sorted(OPS))}")
+        if op in ("in", "not in"):
+            vals = list(v) if isinstance(v, (list, tuple)) else [v]
+            sql.append(f"{f} {OPS[op]} ({','.join('?' * len(vals))})"); args += vals
+        elif op in ("like", "ilike"):
+            sql.append(f"{f} LIKE ?"); args.append(f"%{v}%")
+        else:
+            sql.append(f"{f} {OPS[op]} ?"); args.append(v)
+    return " WHERE " + " AND ".join(sql), args
+
+
+def _model(model):
+    if model not in MODELS:
+        raise ValueError(f"unknown model {model!r}; served: {', '.join(sorted(MODELS))}")
+    return MODELS[model]
+
+
+@S.tool("fields_get", "List the fields of a model, with type. Discovery step before search_read.",
+        {"model": {"type": "string"}}, ["model"])
+def fields_get(model):
+    table, pk, writable = _model(model)
+    with S.db() as cx:
+        info = [{"name": r[1], "type": r[2] or "text"} for r in cx.execute(f"PRAGMA table_info({table})")]
+    return {"model": model, "primary_key": pk, "writable": writable, "fields": info}
+
+
+@S.tool("search_read",
+        "Search and read records. `domain` is a list of [field, operator, value] leaves "
+        "combined with AND, e.g. [[\"product_code\",\"=\",\"P123\"],[\"price\",\"<\",100]].",
+        {"model": {"type": "string"},
+         "domain": {"type": "array", "description": "list of [field, operator, value]"},
+         "fields": {"type": "array", "description": "field names; omit for all"},
+         "page": {"type": "integer"}},
+        ["model"])
+def search_read(model, domain=None, fields=None, page=1):
+    table, pk, _w = _model(model)
+    with S.db() as cx:
+        cols = _cols(cx, table)
+        sel = "*"
+        if fields:
+            bad = [f for f in fields if f not in cols]
+            if bad: raise ValueError(f"unknown field(s) {bad}; known: {', '.join(sorted(cols))}")
+            sel = ", ".join(fields)
+        w, args = _where(domain, cols)
+        return S.rows(cx, f"SELECT {sel} FROM {table}{w}", args, page)
+
+
+@S.tool("create", "Create a record. Returns its name/id. Orders are created in state 'draft' — "
+                  "confirm them with action_confirm.",
+        {"model": {"type": "string"}, "values": {"type": "object"}},
+        ["model", "values"])
+def create(model, values):
+    table, pk, writable = _model(model)
+    if not writable:
+        raise ValueError(f"{model} is master data in this world and is read-only; "
+                         f"writable models: {', '.join(m for m, v in MODELS.items() if v[2])}")
+    vals = dict(values or {})
+    with S.db() as cx:
+        cols = _cols(cx, table)
+        bad = [k for k in vals if k not in cols]
+        if bad: raise ValueError(f"unknown field(s) {bad} on {model}; known: {', '.join(sorted(cols))}")
+        if model in SEQ and not vals.get("name"):
+            fmt, tbl = SEQ[model]
+            n = cx.execute(f"SELECT COUNT(*) FROM {tbl}").fetchone()[0] + 1
+            vals["name"] = fmt % n
+        if "state" in cols and not vals.get("state"):
+            vals["state"] = "draft"
+        keys = list(vals)
+        cx.execute(f"INSERT INTO {table} ({','.join(keys)}) VALUES ({','.join('?' * len(keys))})",
+                   [vals[k] for k in keys])
+        cx.commit()
+        return {"model": model, "created": vals.get("name") or cx.execute(
+            f"SELECT last_insert_rowid()").fetchone()[0], "values": vals}
+
+
+@S.tool("write", "Update records matching a domain.",
+        {"model": {"type": "string"}, "domain": {"type": "array"}, "values": {"type": "object"}},
+        ["model", "domain", "values"])
+def write(model, domain, values):
+    table, pk, writable = _model(model)
+    if not writable:
+        raise ValueError(f"{model} is master data in this world and is read-only")
+    vals = dict(values or {})
+    with S.db() as cx:
+        cols = _cols(cx, table)
+        bad = [k for k in vals if k not in cols]
+        if bad: raise ValueError(f"unknown field(s) {bad} on {model}")
+        w, args = _where(domain, cols)
+        if not w: raise ValueError("refusing to write with an empty domain")
+        sets = ", ".join(f"{k}=?" for k in vals)
+        cur = cx.execute(f"UPDATE {table} SET {sets}{w}", list(vals.values()) + args)
+        cx.commit()
+        return {"model": model, "updated": cur.rowcount}
+
+
+@S.tool("action_confirm", "Confirm draft orders by name — sale.order -> 'sale', "
+                          "purchase.order -> 'purchase', mrp.production -> 'confirmed'. "
+                          "A draft order is not a commitment and is not graded as one.",
+        {"model": {"type": "string"}, "names": {"type": "array"}},
+        ["model", "names"])
+def action_confirm(model, names):
+    table, pk, writable = _model(model)
+    if not writable or model not in SEQ:
+        raise ValueError(f"{model} has no confirm action")
+    target = {"sale.order": "sale", "purchase.order": "purchase",
+              "mrp.production": "confirmed"}[model]
+    names = list(names or [])
+    if not names: raise ValueError("names is required")
+    with S.db() as cx:
+        rows = cx.execute(f"SELECT name, state FROM {table} WHERE name IN "
+                          f"({','.join('?' * len(names))})", names).fetchall()
+        found = {r["name"] for r in rows}
+        missing = [n for n in names if n not in found]
+        if missing: raise ValueError(f"no such {model}: {missing}")
+        cx.execute(f"UPDATE {table} SET state=? WHERE name IN "
+                   f"({','.join('?' * len(names))})", [target] + names)
+        cx.commit()
+    return {"model": model, "confirmed": names, "state": target}
+
+
+if __name__ == "__main__":
+    S.run()

world/mcp/servers/sheets_server.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python3
+"""Sheets MCP server — 1:1 Microsoft Graph workbook API shapes over the shared drive.
+
+Mirrors Graph /drive + /workbook: list drive items, worksheets collection,
+range(address='A1:C4') returning the Graph workbookRange object (address, values, text,
+formulas, numberFormat, rowCount/columnCount/cellCount), usedRange, and drive search.
+Each shared-drive file is a workbook with one worksheet ("Sheet1"). Read-only
+(Files.Read scope). SIMULATION ONLY."""
+import sys, json, re
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "lib"))
+from framework import Server
+
+S = Server("sheets", "Finance shared drive (Microsoft Graph workbook API shapes). Read-only. SIMULATION ONLY.")
+
+def _file(cx, name):
+    return cx.execute("SELECT * FROM sheet_files WHERE name=?", (name,)).fetchone()
+
+def _grid(cx, name):
+    rows = cx.execute("SELECT row_no, cells FROM sheet_rows WHERE file=? ORDER BY row_no", (name,)).fetchall()
+    return [json.loads(r["cells"]) for r in rows]
+
+def _cell_v(c):
+    """A cell is a literal, or {"f": "=SUM(...)", "v": cached_value} for formula cells.
+    Like real Excel, the API serves the CACHED value — it may have drifted from the
+    formula's inputs (paste-values / stale-recalc chaos)."""
+    return c.get("v", "") if isinstance(c, dict) else c
+
+def _cell_f(c):
+    return c.get("f", c.get("v", "")) if isinstance(c, dict) else c
+
+def _range_obj(grid, r0, c0, r1, c1, sheet="Sheet1"):
+    values, formulas = [], []
+    for ri in range(r0, r1 + 1):
+        row = grid[ri - 1] if 0 < ri <= len(grid) else []
+        cells = [(row[ci - 1] if 0 < ci <= len(row) else "") for ci in range(c0, c1 + 1)]
+        values.append([_cell_v(c) for c in cells])
+        formulas.append([_cell_f(c) for c in cells])
+    addr = f"{sheet}!{_col(c0)}{r0}:{_col(c1)}{r1}"
+    return {"address": addr, "addressLocal": addr,
+            "rowCount": r1 - r0 + 1, "columnCount": c1 - c0 + 1,
+            "cellCount": (r1 - r0 + 1) * (c1 - c0 + 1),
+            "rowIndex": r0 - 1, "columnIndex": c0 - 1,
+            "values": values, "text": [[str(v) for v in row] for row in values],
+            "formulas": formulas, "numberFormat": [["General"] * (c1 - c0 + 1) for _ in range(r1 - r0 + 1)],
+            "valueTypes": [[("Empty" if v == "" else "Double" if isinstance(v, (int, float)) else "String")
+                            for v in row] for row in values]}
+
+def _col(n):
+    s = ""
+    while n: n, r = divmod(n - 1, 26); s = chr(65 + r) + s
+    return s
+
+def _parse_a1(a1):
+    m = re.match(r"(?i)^(?:Sheet1!)?([A-Z]+)(\d+)(?::([A-Z]+)(\d+))?$", a1.strip())
+    if not m: return None
+    def num(col):
+        v = 0
+        for ch in col.upper(): v = v * 26 + ord(ch) - 64
+        return v
+    c0, r0 = num(m.group(1)), int(m.group(2))
+    c1, r1 = (num(m.group(3)), int(m.group(4))) if m.group(3) else (c0, r0)
+    return r0, c0, r1, c1
+
+@S.tool("list_drive_items", "List workbook files on the finance shared drive (GET /drive/root/children shape).")
+def list_drive_items():
+    cx = S.db()
+    return {"value": [{"id": r["name"], "name": r["name"],
+                       "lastModifiedDateTime": r["modified_at"],
+                       "createdBy": {"user": {"displayName": r["owner"]}},
+                       "description": r["description"],
+                       "file": {"mimeType": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"}}
+                      for r in cx.execute("SELECT * FROM sheet_files ORDER BY name")]}
+
+@S.tool("get_drive_item", "One file's metadata (GET /drive/items/{id} shape) — check lastModifiedDateTime before trusting a tracker.",
+        {"item": {"type": "string", "description": "file name/id"}}, ["item"])
+def get_drive_item(item):
+    cx = S.db()
+    f = _file(cx, item)
+    if not f: return {"error": {"code": "itemNotFound", "message": f"The resource could not be found: {item}"}}
+    n = cx.execute("SELECT COUNT(*) FROM sheet_rows WHERE file=?", (item,)).fetchone()[0]
+    return {"id": f["name"], "name": f["name"], "lastModifiedDateTime": f["modified_at"],
+            "createdBy": {"user": {"displayName": f["owner"]}}, "description": f["description"],
+            "rowCount": n}
+
+@S.tool("workbook_worksheets", "List worksheets of a workbook (GET /workbook/worksheets shape).",
+        {"item": {"type": "string"}}, ["item"])
+def workbook_worksheets(item):
+    cx = S.db()
+    if not _file(cx, item):
+        return {"error": {"code": "itemNotFound", "message": f"The resource could not be found: {item}"}}
+    return {"value": [{"id": "{00000000-0001-0000-0000-000000000000}", "name": "Sheet1",
+                       "position": 0, "visibility": "Visible"}]}
+
+@S.tool("workbook_range", "Read a range (GET /workbook/worksheets/Sheet1/range(address='A1:C4') shape). Returns the Graph workbookRange object.",
+        {"item": {"type": "string"}, "address": {"type": "string", "description": "A1 notation, e.g. A1:F4"}},
+        ["item", "address"])
+def workbook_range(item, address):
+    cx = S.db()
+    if not _file(cx, item):
+        return {"error": {"code": "itemNotFound", "message": f"The resource could not be found: {item}"}}
+    box = _parse_a1(address)
+    if not box: return {"error": {"code": "invalidArgument", "message": f"Invalid range address: {address}"}}
+    return _range_obj(_grid(cx, item), *box)
+
+@S.tool("workbook_used_range", "Read the used range of Sheet1 (GET /workbook/worksheets/Sheet1/usedRange shape).",
+        {"item": {"type": "string"}}, ["item"])
+def workbook_used_range(item):
+    cx = S.db()
+    if not _file(cx, item):
+        return {"error": {"code": "itemNotFound", "message": f"The resource could not be found: {item}"}}
+    grid = _grid(cx, item)
+    if not grid: return {"error": {"code": "itemNotFound", "message": "worksheet is empty"}}
+    return _range_obj(grid, 1, 1, len(grid), max(len(r) for r in grid))
+
+@S.tool("drive_search", "Search file contents across the drive (GET /drive/root/search(q='...') shape, cell-level hits).",
+        {"q": {"type": "string"}}, ["q"])
+def drive_search(q):
+    cx = S.db(); like = f"%{q.lower()}%"
+    hits = [{"file": r["file"], "row": r["row_no"], "cells": json.loads(r["cells"])}
+            for r in cx.execute("SELECT file, row_no, cells FROM sheet_rows WHERE LOWER(cells) LIKE ? LIMIT 50", (like,))]
+    return {"value": hits}
+
+if __name__ == "__main__":
+    S.run()

world/schema.sql

@@ -0,0 +1,294 @@
+-- finance-world state schema. One SQLite file per task run; every MCP server sees only its namespace.
+-- Epoch/world clock lives in meta (WORLD_NOW). SIMULATION ONLY.
+
+CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT);
+
+-- ============ ERP (Dynamics-365-Finance-shaped, legal entity USMF) ============
+CREATE TABLE erp_companies(dataareaid TEXT PRIMARY KEY, name TEXT);
+CREATE TABLE erp_payment_terms(code TEXT PRIMARY KEY, days INTEGER, description TEXT);
+CREATE TABLE erp_cash_disc(code TEXT PRIMARY KEY, percent REAL, days INTEGER, next_code TEXT, description TEXT);
+CREATE TABLE erp_customers(
+  account TEXT PRIMARY KEY, dataareaid TEXT, name TEXT, customer_group TEXT,
+  currency TEXT, payment_term TEXT, cash_disc_code TEXT, credit_max REAL,
+  credit_rating TEXT, on_hold TEXT, city TEXT, state TEXT,
+  contact_name TEXT, contact_email TEXT, phone TEXT);
+CREATE TABLE erp_vendors(
+  account TEXT PRIMARY KEY, dataareaid TEXT, name TEXT, vendor_group TEXT,
+  currency TEXT, payment_term TEXT, cash_disc_code TEXT, payment_method TEXT,
+  on_hold TEXT, city TEXT, state TEXT, contact_name TEXT, contact_email TEXT, phone TEXT);
+-- Posted subledger. Open remainder = amount - settled where closed=0 (three-layer model).
+CREATE TABLE erp_cust_trans(
+  id INTEGER PRIMARY KEY, dataareaid TEXT, account TEXT, voucher TEXT, invoice TEXT,
+  txn_type TEXT, description TEXT, trans_date TEXT, due_date TEXT, currency TEXT,
+  amount REAL, settled REAL DEFAULT 0, closed INTEGER DEFAULT 0, cash_disc_code TEXT,
+  disputed INTEGER DEFAULT 0, deduction INTEGER DEFAULT 0, payment_method TEXT);
+CREATE TABLE erp_vend_trans(
+  id INTEGER PRIMARY KEY, dataareaid TEXT, account TEXT, voucher TEXT, invoice TEXT,
+  txn_type TEXT, description TEXT, trans_date TEXT, due_date TEXT, currency TEXT,
+  amount REAL, settled REAL DEFAULT 0, closed INTEGER DEFAULT 0, cash_disc_code TEXT,
+  po_number TEXT);
+-- Procurement (3-way match surface: PO -> product receipt -> vendor invoice).
+CREATE TABLE erp_purch_orders(
+  po_number TEXT, line INTEGER, dataareaid TEXT, vendor TEXT, item TEXT, description TEXT,
+  qty_ordered REAL, unit_price REAL, order_date TEXT, status TEXT,
+  PRIMARY KEY(po_number, line));
+CREATE TABLE erp_product_receipts(
+  receipt_id TEXT, po_number TEXT, line INTEGER, receipt_date TEXT, qty_received REAL,
+  PRIMARY KEY(receipt_id, po_number, line));
+CREATE TABLE erp_settlements(
+  id INTEGER PRIMARY KEY, side TEXT, dataareaid TEXT, account TEXT,
+  payment_id INTEGER, invoice_id INTEGER, amount REAL, cash_disc_taken REAL DEFAULT 0,
+  settle_date TEXT);
+CREATE TABLE erp_collection_letters(
+  id INTEGER PRIMARY KEY, dataareaid TEXT, account TEXT, letter_code TEXT,
+  letter_date TEXT, status TEXT, fee REAL, note TEXT);
+-- Sales orders (SalesTable): status, hold codes, responsible worker.
+CREATE TABLE erp_sales_orders(
+  sales_id TEXT PRIMARY KEY, dataareaid TEXT, account TEXT, customer_name TEXT,
+  order_date TEXT, status TEXT, hold_code TEXT, responsible TEXT, amount REAL);
+-- Collections activities/tasks (SmmActivities) and collections pools (CustPool).
+CREATE TABLE erp_activities(
+  activity_id TEXT PRIMARY KEY, dataareaid TEXT, account TEXT, activity_type TEXT,
+  purpose TEXT, start_date TEXT, end_date TEXT, closed INTEGER DEFAULT 0, responsible TEXT);
+CREATE TABLE erp_collection_pools(pool_id TEXT PRIMARY KEY, name TEXT, criteria TEXT);
+CREATE TABLE erp_customer_pool(account TEXT PRIMARY KEY, pool_id TEXT);
+-- Methods of payment (CustPaymModeTable/VendPaymModeTable) and their payment accounts.
+CREATE TABLE erp_methods_of_payment(
+  method TEXT, side TEXT, dataareaid TEXT, description TEXT, payment_account TEXT,
+  PRIMARY KEY(method, side));
+-- Form-tool runtime state (mirrors the real server's per-session view models; SQL-backed).
+CREATE TABLE erp_form_sessions(form_id TEXT PRIMARY KEY, form TEXT, state TEXT);
+-- Batch aging snapshot (the "second truth"; may lawfully diverge from live bucketing).
+CREATE TABLE erp_aging_snapshot(
+  run_id TEXT, as_of TEXT, dataareaid TEXT, account TEXT, name TEXT,
+  not_due REAL, b1_30 REAL, b31_60 REAL, b61_90 REAL, b90_plus REAL, total_due REAL,
+  PRIMARY KEY(run_id, account));
+
+-- ============ Subsidiary books: CES Direct LLC (QuickBooks-Online-shaped) ============
+CREATE TABLE books_customers(id TEXT PRIMARY KEY, display_name TEXT, erp_ref TEXT, email TEXT);
+CREATE TABLE books_invoices(
+  id TEXT PRIMARY KEY, customer_id TEXT, doc_number TEXT, txn_date TEXT, due_date TEXT,
+  amount REAL, balance REAL, status TEXT, memo TEXT);
+CREATE TABLE books_credit_memos(
+  id TEXT PRIMARY KEY, customer_id TEXT, doc_number TEXT, txn_date TEXT,
+  amount REAL, remaining REAL, memo TEXT);
+CREATE TABLE books_payments(
+  id TEXT PRIMARY KEY, customer_id TEXT, txn_date TEXT, amount REAL,
+  applied_to_invoice TEXT, method TEXT, memo TEXT);
+
+-- ============ Shadow spreadsheets ============
+CREATE TABLE sheet_files(name TEXT PRIMARY KEY, owner TEXT, modified_at TEXT, description TEXT);
+CREATE TABLE sheet_rows(file TEXT, row_no INTEGER, cells TEXT, PRIMARY KEY(file, row_no));
+
+-- ============ Email (read-only inbox) ============
+CREATE TABLE email_messages(
+  id TEXT PRIMARY KEY, folder TEXT, from_addr TEXT, to_addr TEXT, subject TEXT,
+  sent_at TEXT, body TEXT, attachment_name TEXT, attachment_text TEXT);
+
+-- Scripted counterparties: deterministic replies when the agent sends mail.
+CREATE TABLE email_npc_scripts(
+  id TEXT PRIMARY KEY, match_to TEXT, match_keywords TEXT, reply_from TEXT,
+  reply_subject TEXT, reply_body TEXT, attachment_name TEXT, attachment_text TEXT);
+
+-- ============ Filings (SEC-EDGAR-shaped frozen snapshots) ============
+CREATE TABLE filings_companies(cik TEXT PRIMARY KEY, ticker TEXT, name TEXT);
+CREATE TABLE filings_facts(
+  cik TEXT, concept TEXT, unit TEXT, fy TEXT, fp TEXT, period_end TEXT,
+  value REAL, form TEXT, filed TEXT, accession TEXT);
+CREATE TABLE filings_documents(cik TEXT, form TEXT, filed TEXT, accession TEXT, title TEXT, excerpt TEXT);
+
+-- ============ Document store (policies/SOPs; every body starts "> SIMULATION ONLY") ============
+CREATE TABLE docs_documents(
+  doc_id TEXT PRIMARY KEY, title TEXT, doc_type TEXT, version TEXT,
+  effective_date TEXT, body TEXT);
+
+-- ============ Harness (answers are state; verified deterministically) ============
+CREATE TABLE answers(field TEXT PRIMARY KEY, value TEXT, submitted_at TEXT);
+
+-- The reporting contract: what this task requires filed, and in what shape.
+--
+-- This used to be stapled onto the end of the human's message ("Reply with `submit_answer`:
+-- - `dormant_count` (number) ..."), which no colleague would ever type and which handed the
+-- model the decomposition for free — being told to report `overpayment_usd` AND
+-- `underpayment_usd` separately reveals there are two directions of error before you look.
+--
+-- It belongs where it belongs in a real deployment: on the reporting tool. The harness server
+-- exposes it through `reporting_fields`, so the agent discovers the contract by inspecting the
+-- system, exactly as it would any other API, and the prompt is free to be a message.
+CREATE TABLE answer_schema(
+  ordinal INTEGER, field TEXT PRIMARY KEY, type TEXT, description TEXT);
+
+-- ============ Write-and-approve surface (hard layer M1/M2/M7) ============
+-- Chart of accounts (Odoo account.account / ERPNext Account). account_type vocabulary is
+-- Odoo's, truncated: asset_receivable, asset_cash, asset_current, liability_payable,
+-- liability_current, equity, income, expense, off_balance.
+CREATE TABLE erp_main_accounts(
+  account_code TEXT PRIMARY KEY, dataareaid TEXT, name TEXT, account_type TEXT,
+  currency TEXT, blocked INTEGER DEFAULT 0, reconcilable INTEGER DEFAULT 0,
+  requires_dimension TEXT);
+
+-- Fiscal periods / period lock (Odoo company lock dates; mcp-erp close_period/reopen_period).
+CREATE TABLE erp_fiscal_periods(
+  period_id TEXT PRIMARY KEY, dataareaid TEXT, period_start TEXT, period_end TEXT,
+  status TEXT DEFAULT 'open');            -- open | on_hold | closed
+
+-- GL journal header. state: Odoo account.move.state (draft/posted/cancel), one-way draft->posted.
+-- voucher_type: ERPNext Journal Entry.voucher_type subset. reversed_entry_id: Odoo
+-- account.move.reversed_entry_id / ERPNext Journal Entry.reversal_of.
+CREATE TABLE erp_ledger_journals(
+  journal_id TEXT PRIMARY KEY, dataareaid TEXT, voucher TEXT, voucher_type TEXT,
+  description TEXT, user_remark TEXT, posting_date TEXT, period_id TEXT, currency TEXT,
+  total_debit REAL DEFAULT 0, total_credit REAL DEFAULT 0, difference REAL DEFAULT 0,
+  state TEXT DEFAULT 'draft',
+  reversed_entry_id TEXT, reversal_reason TEXT,
+  created_by TEXT, created_at TEXT, posted_by TEXT, posted_at TEXT,
+  source_doc_id TEXT);                    -- the docs_documents row the amounts derive from (M4)
+
+-- GL journal lines (Odoo account.move.line debit/credit/balance; mcp-erp PostJournalInput.lines).
+CREATE TABLE erp_ledger_journal_lines(
+  journal_id TEXT, line INTEGER, account_code TEXT, description TEXT,
+  debit REAL DEFAULT 0, credit REAL DEFAULT 0, currency TEXT, fx_rate REAL DEFAULT 1,
+  party_type TEXT, party TEXT, dimension_dept TEXT,
+  PRIMARY KEY(journal_id, line));
+
+-- Delegation of authority (ERPNext Authorization Rule: transaction/based_on/value/
+-- system_role/approving_role/company). company-scoped rules SHADOW global rules.
+CREATE TABLE erp_approval_policies(
+  policy_id TEXT PRIMARY KEY, dataareaid TEXT, doc_type TEXT,
+  based_on TEXT DEFAULT 'Grand Total', threshold_amount REAL, currency TEXT,
+  applies_to_role TEXT, approving_role TEXT, approving_user TEXT,
+  escalation_policy_id TEXT, active INTEGER DEFAULT 1);
+
+-- Approval inbox (ERPNext AuthorizationControl outcome, materialised as a queue).
+CREATE TABLE erp_approval_requests(
+  request_id TEXT PRIMARY KEY, dataareaid TEXT, doc_type TEXT, doc_id TEXT,
+  amount REAL, currency TEXT, submitted_by TEXT, submitted_at TEXT, note TEXT,
+  policy_id TEXT, required_role TEXT,
+  status TEXT DEFAULT 'pending',          -- pending | approved | rejected | withdrawn
+  decided_by TEXT, decided_at TEXT, decision_reason TEXT);
+
+-- Bank cash position: the constraint that makes M2 bite.
+CREATE TABLE erp_bank_accounts(
+  bank_account TEXT PRIMARY KEY, dataareaid TEXT, name TEXT, currency TEXT,
+  available_balance REAL, as_of TEXT, overdraft_limit REAL DEFAULT 0);
+
+-- Payment run header (ERPNext Payment Order; D365 payment proposal).
+-- period_option: D365 method-of-payment Period (Invoice | Date | Total).
+CREATE TABLE erp_payment_runs(
+  run_id TEXT PRIMARY KEY, dataareaid TEXT, pay_date TEXT, bank_account TEXT, currency TEXT,
+  period_option TEXT DEFAULT 'Invoice',
+  cash_available REAL, eligible_net REAL, total_paid REAL, total_rejected REAL,
+  state TEXT DEFAULT 'proposed',          -- proposed | committed | cancelled
+  created_by TEXT, created_at TEXT, approved_by TEXT, committed_at TEXT);
+
+-- Payment run lines: BOTH halves of the partition, one row each.
+-- reason_code enum from erpnext/accounts/bulk_payment.py::_partition_payable_invoices
+-- plus Vendor On Hold / Discount Window Expired / Awaiting Approval / Insufficient Cash.
+CREATE TABLE erp_payment_run_lines(
+  run_id TEXT, line INTEGER, invoice TEXT, vendor TEXT, due_date TEXT,
+  gross_amount REAL, discount_taken REAL DEFAULT 0, withholding REAL DEFAULT 0,
+  net_amount REAL, disposition TEXT, reason_code TEXT, reason TEXT, priority_rank INTEGER,
+  PRIMARY KEY(run_id, line));
+
+-- FX rates: without these, M4 cannot re-derive any cross-currency amount
+-- (odoo-domain.md §8 gap #15 — we have a currency column and no rate table).
+CREATE TABLE erp_fx_rates(
+  from_ccy TEXT, to_ccy TEXT, rate_date TEXT, rate REAL,
+  PRIMARY KEY(from_ccy, to_ccy, rate_date));
+
+-- Two-phase confirm-gate token store. RUNTIME state: never graded, never readable as an entity.
+CREATE TABLE erp_confirm_tokens(
+  token TEXT PRIMARY KEY, seq INTEGER, action TEXT, actor TEXT, role TEXT,
+  target_id TEXT, args_hash TEXT, effect_preview TEXT, minted_at TEXT,
+  consumed_at TEXT, superseded_by TEXT);
+
+-- Audit trail (mcp-erp get_erp_audit_trail; odoo-ai-agent GET /chat/{id}/audit).
+-- Derived from the graded writes; excluded from the state veto, assertable by row_count.
+CREATE TABLE erp_audit_trail(
+  audit_id INTEGER PRIMARY KEY, entity_type TEXT, entity_id TEXT, action TEXT,
+  actor TEXT, role TEXT, at TEXT, before_json TEXT, after_json TEXT);
+
+-- Deduction / short-pay reason codes (art.deduction_coding). Vocabulary follows AR
+-- cash-application practice: research/external/articles/cash-application--{highradius,stuut,
+-- zamp}.md — a deduction is coded, routed to an owner, and either conceded or charged back.
+CREATE TABLE erp_deduction_reasons(
+  reason_code TEXT PRIMARY KEY, description TEXT, valid_claim INTEGER,
+  owner TEXT, disposition TEXT);
+
+-- Withholding tax (erpnext.withholding_tax). ERPNext models this as Tax Withholding
+-- Category + rates with a cumulative threshold; the vendor-side profile carries the
+-- exemption certificate and its expiry, which is what actually decides whether we withhold.
+CREATE TABLE erp_withholding_tax(
+  tax_category TEXT PRIMARY KEY, description TEXT, rate_pct REAL,
+  threshold_amount REAL DEFAULT 0, statutory_ref TEXT);
+
+CREATE TABLE erp_vendor_tax_profile(
+  account TEXT PRIMARY KEY, tax_category TEXT, certificate_type TEXT,
+  certificate_on_file INTEGER DEFAULT 0, certificate_expiry TEXT, notes TEXT);
+
+-- ═══ Procure-to-pay / make-or-buy surface (agentic-labs/erp-bench, 300 tasks) ═══
+--
+-- ERP-Bench ships each task as a Harbor dir that boots a real Odoo 19 in Docker and grades it
+-- with odoolib queries against the live server. The plumbing does not port; the JUDGEMENT does,
+-- because `environment/scenario_data.json` is a fully DECLARATIVE world spec — partners with
+-- budgets, products with per-vendor min/max/price offers, BOMs, workcenters, stock and existing
+-- orders. So the scenario seeds our world and the grading becomes deterministic state diffs
+-- (docs/PARITY.md, docs/INGESTION.md `needs_surface` -> built).
+--
+-- These tables are EMPTY in core by design. Each ERP-Bench scenario is its own small world, so
+-- it arrives through the per-task seed layer rather than the shared ledger — the same mechanic
+-- that already carries every other task's chaos.
+
+CREATE TABLE erpb_partners(
+  ref TEXT PRIMARY KEY, name TEXT, kind TEXT,              -- kind: customer | vendor
+  supplier_rank INTEGER DEFAULT 0, budget_dollars REAL, credit_limit REAL,
+  payment_term TEXT, email TEXT,
+  comment TEXT);          -- Odoo "Internal Notes": several tasks hide the binding
+                          -- max-order-quantity rule here and nowhere else
+
+CREATE TABLE erpb_products(
+  code TEXT PRIMARY KEY, name TEXT, category TEXT, type TEXT,
+  list_price REAL, standard_price REAL,
+  routes TEXT,            -- csv of {buy, manufacture}: whether make-or-buy is even a choice
+  comment TEXT);
+
+CREATE TABLE erpb_vendor_offers(
+  id INTEGER PRIMARY KEY, product_code TEXT, partner_ref TEXT, name TEXT,
+  delay INTEGER,          -- lead time in days, against the order's due date
+  min_qty REAL, max_qty REAL,   -- horizon-wide totals, NOT per-line minimums
+  price REAL);
+
+CREATE TABLE erpb_boms(
+  id INTEGER PRIMARY KEY, product_code TEXT, type TEXT, quantity REAL, warehouse_code TEXT);
+CREATE TABLE erpb_bom_components(
+  bom_id INTEGER, component_code TEXT, quantity REAL);
+
+CREATE TABLE erpb_workcenters(
+  code TEXT PRIMARY KEY, name TEXT, capacity_per_day REAL, cost_per_hour REAL,
+  warehouse_code TEXT, comment TEXT);
+
+CREATE TABLE erpb_stock(
+  product_code TEXT, warehouse_code TEXT, quantity REAL, location_type TEXT);
+
+-- The demand named in the instruction: who wants how many, by when, under what budget cap.
+CREATE TABLE erpb_demand(
+  id INTEGER PRIMARY KEY, partner_ref TEXT, product_code TEXT, units REAL,
+  due_days INTEGER, budget_cap REAL, seeded_order_state TEXT);
+
+-- ── agent-written state: what the verifier grades ──
+CREATE TABLE erpb_sale_orders(
+  name TEXT PRIMARY KEY, partner_ref TEXT, state TEXT,
+  commitment_date TEXT, origin TEXT);
+CREATE TABLE erpb_sale_order_lines(
+  id INTEGER PRIMARY KEY, order_name TEXT, product_code TEXT, qty REAL, price_unit REAL);
+
+CREATE TABLE erpb_purchase_orders(
+  name TEXT PRIMARY KEY, partner_ref TEXT, state TEXT,
+  date_planned TEXT,
+  origin TEXT);           -- the SO reference(s): the SO->PO lineage the tasks require
+CREATE TABLE erpb_purchase_order_lines(
+  id INTEGER PRIMARY KEY, order_name TEXT, product_code TEXT, qty REAL, price_unit REAL);
+
+CREATE TABLE erpb_manufacturing_orders(
+  name TEXT PRIMARY KEY, product_code TEXT, qty REAL, state TEXT,
+  workcenter_code TEXT, date_planned TEXT, origin TEXT);

world/server.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python3
+"""LedgerBench-100 world service: Streamable HTTP MCP bridge + token-gated verifier.
+
+One process serves the task's eight finance MCP servers (imported in-process from the
+pack's own runtime/) over per-server Streamable HTTP endpoints:
+
+    POST /mcp/<server>   JSON-RPC: initialize | ping | tools/list | tools/call
+    GET  /health         readiness for the compose healthcheck
+    POST /verify         token-gated deterministic verification (X-Verify-Token)
+
+The agent container never sees the verification token: the pack bakes only its
+SHA-256 digest into spec.json. tests/test.sh (copied into the container only at
+verification time) holds the actual token.
+
+Everything is offline and deterministic: SQLite world state, frozen WORLD_NOW
+clock, stdlib-only, no LLM anywhere.
+"""
+from __future__ import annotations
+
+import gzip
+import hashlib
+import importlib.util
+import json
+import os
+import shutil
+import sys
+from http import HTTPStatus
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from typing import Any
+
+HERE = Path(__file__).resolve().parent
+SPEC = json.loads((HERE / "spec.json").read_text(encoding="utf-8"))
+RUNTIME = HERE / "runtime"
+RUN_DIR = Path(os.environ.get("LEDGERBENCH_RUN_DIR", "/opt/world/run"))
+PROTOCOL_VERSION = "2025-06-18"
+
+_SERVERS: dict[str, Any] = {}
+
+
+def load_servers() -> dict[str, Any]:
+    """Import the pack's MCP server modules in-process (same handlers, same trace)."""
+    if _SERVERS:
+        return _SERVERS
+    sys.path.insert(0, str(RUNTIME / "lib"))
+    for name in SPEC["servers"]:
+        spec = importlib.util.spec_from_file_location(
+            f"lgr_{name}_server", RUNTIME / "servers" / f"{name}_server.py"
+        )
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        _SERVERS[name] = module.S
+    return _SERVERS
+
+
+def reset_run_dir() -> None:
+    """Materialize a pristine run: fresh world DB, empty trace, initial hashes."""
+    RUN_DIR.mkdir(parents=True, exist_ok=True)
+    state = HERE / "state"
+    db_gz = state / "world.sqlite.gz"
+    db = state / "world.sqlite"
+    target = RUN_DIR / "world.sqlite"
+    if db.exists():
+        shutil.copyfile(db, target)
+    else:
+        with gzip.open(db_gz, "rb") as fin, open(target, "wb") as fout:
+            shutil.copyfileobj(fin, fout)
+    shutil.copyfile(state / "initial_state.json", RUN_DIR / "initial_state.json")
+    (RUN_DIR / "trace.jsonl").write_text("")
+    os.environ["WORLD_DB"] = str(target)
+    os.environ["WORLD_NOW"] = SPEC["world_now"]
+    os.environ["WORLD_ROLE"] = SPEC["world_role"]
+    os.environ["TRACE_FILE"] = str(RUN_DIR / "trace.jsonl")
+
+
+def build_report(task_dir: Path, run_dir: Path, task_id: str) -> dict[str, Any]:
+    """Deterministic verification report (no clock, no randomness, no network)."""
+    sys.path.insert(0, str(RUNTIME))
+    from vcode import verify_all  # the pack's own deterministic verifier engine
+
+    verdict = verify_all(str(task_dir), str(run_dir))
+    report = {
+        "benchmark": SPEC["benchmark"],
+        "version": SPEC["version"],
+        "task_id": task_id,
+        "passed": verdict["reward"] == 1,
+        "reward": float(verdict["reward"]),
+        "failed_checks": sorted(verdict["failed"]),
+        "n_tool_calls": verdict["n_tool_calls"],
+        "servers_used": verdict["servers_used"],
+        "steps_graded": verdict.get("steps", 1),
+    }
+    report["report_sha256"] = hashlib.sha256(
+        json.dumps(report, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    ).hexdigest()
+    return report
+
+
+def rpc_response(server_name: str, request: dict[str, Any]) -> dict[str, Any] | None:
+    request_id = request.get("id")
+    method = request.get("method")
+    if request_id is None and isinstance(method, str) and method.startswith("notifications/"):
+        return None
+    if request.get("jsonrpc") != "2.0" or not isinstance(method, str):
+        return {"jsonrpc": "2.0", "id": request_id,
+                "error": {"code": -32600, "message": "Invalid Request"}}
+    servers = load_servers()
+    if server_name not in servers:
+        return {"jsonrpc": "2.0", "id": request_id,
+                "error": {"code": -32601, "message": f"unknown server {server_name!r}"}}
+    srv = servers[server_name]
+    if method == "initialize":
+        params = request.get("params") or {}
+        return {"jsonrpc": "2.0", "id": request_id, "result": {
+            "protocolVersion": params.get("protocolVersion", PROTOCOL_VERSION),
+            "capabilities": {"tools": {}},
+            "serverInfo": {"name": srv.name, "version": "1.0.0"},
+            "instructions": srv.description,
+        }}
+    if method == "ping":
+        return {"jsonrpc": "2.0", "id": request_id, "result": {}}
+    if method == "tools/list":
+        return {"jsonrpc": "2.0", "id": request_id,
+                "result": {"tools": [schema for _, schema in srv.tools.values()]}}
+    if method == "tools/call":
+        params = request.get("params") or {}
+        tool = params.get("name")
+        arguments = params.get("arguments") or {}
+        if tool not in srv.tools:
+            return {"jsonrpc": "2.0", "id": request_id, "result": {
+                "content": [{"type": "text", "text": f"unknown tool {tool}"}],
+                "isError": True}}
+        try:
+            out = srv.call(tool, arguments)
+            return {"jsonrpc": "2.0", "id": request_id, "result": {
+                "content": [{"type": "text", "text": json.dumps(out, default=str)}],
+                "isError": False}}
+        except Exception as error:  # noqa: BLE001 - surface tool failure to the agent
+            return {"jsonrpc": "2.0", "id": request_id, "result": {
+                "content": [{"type": "text", "text": f"error: {error!r}"}],
+                "isError": True}}
+    return {"jsonrpc": "2.0", "id": request_id,
+            "error": {"code": -32601, "message": "Method not found"}}
+
+
+class Handler(BaseHTTPRequestHandler):
+    server_version = "LedgerBenchWorld/1.0"
+
+    def log_message(self, fmt: str, *args: Any) -> None:  # noqa: A003
+        return
+
+    def _json(self, status: int, value: Any) -> None:
+        payload = json.dumps(value, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(payload)))
+        self.send_header("MCP-Protocol-Version", PROTOCOL_VERSION)
+        self.end_headers()
+        self.wfile.write(payload)
+
+    def do_GET(self) -> None:  # noqa: N802
+        if self.path == "/health":
+            self._json(HTTPStatus.OK, {"status": "ok", "task_id": SPEC["task_id"]})
+            return
+        self._json(HTTPStatus.NOT_FOUND, {"error": "not_found"})
+
+    def do_POST(self) -> None:  # noqa: N802
+        length = int(self.headers.get("Content-Length", "0"))
+        body = self.rfile.read(length)
+        if self.path == "/verify":
+            token = self.headers.get("X-Verify-Token") or ""
+            digest = hashlib.sha256(token.encode("utf-8")).hexdigest()
+            if digest != SPEC["verify_token_sha256"]:
+                self._json(HTTPStatus.NOT_FOUND, {"error": "not_found"})
+                return
+            self._json(HTTPStatus.OK,
+                       build_report(HERE / "taskspec", RUN_DIR, SPEC["task_id"]))
+            return
+        if not self.path.startswith("/mcp/"):
+            self._json(HTTPStatus.NOT_FOUND, {"error": "not_found"})
+            return
+        server_name = self.path[len("/mcp/"):].strip("/")
+        try:
+            request = json.loads(body.decode("utf-8"))
+        except (UnicodeError, json.JSONDecodeError):
+            self._json(HTTPStatus.BAD_REQUEST,
+                       {"jsonrpc": "2.0", "id": None,
+                        "error": {"code": -32700, "message": "Parse error"}})
+            return
+        if isinstance(request, list):
+            responses = [r for item in request
+                         if (r := rpc_response(server_name, item)) is not None]
+            self._json(HTTPStatus.OK, responses)
+            return
+        response = rpc_response(server_name, request)
+        if response is None:
+            self.send_response(HTTPStatus.ACCEPTED)
+            self.send_header("Content-Length", "0")
+            self.end_headers()
+            return
+        self._json(HTTPStatus.OK, response)
+
+
+def main() -> None:
+    reset_run_dir()
+    load_servers()
+    host = os.environ.get("LEDGERBENCH_HOST", "0.0.0.0")
+    port = int(os.environ.get("LEDGERBENCH_PORT", "8974"))
+    ThreadingHTTPServer((host, port), Handler).serve_forever()
+
+
+if __name__ == "__main__":
+    main()

world/vcode.py

@@ -0,0 +1,263 @@
+#!/usr/bin/env python3
+"""Deterministic verifier engine. No LLM in the reward path.
+
+Reads tests/checks.json from a task dir and a run dir (world.sqlite, trace.jsonl,
+initial_state.json). Emits {"reward": 0|1, "failed": [...]} on stdout; always exits 0.
+
+checks.json:
+  answer_checks: [{field, type: number|string|contains_all, expect, tol_abs?, tol_rel?}]
+      number: value parsed from "$1,234.56", "1234.56", 1234.56; pass if within
+              max(tol_abs, |expect|*tol_rel); default exact to 0.01.
+      string: case/space-insensitive equality.
+      contains_all: every listed substring appears (case-insensitive) in the value; an
+              optional `forbid` list must NOT appear, so a set answer is graded for
+              over-inclusion as well as omission.
+      scale: the unit a figure is stated in (units/thousands/millions/billions/percent),
+              graded as its own field the way TAT-QA does. Any numeric check additionally
+              reports `scale_error` when the answer is a clean 1e3/1e6/1e9 multiple of the
+              truth, so a unit slip is never filed as ordinary arithmetic error.
+      yes_no: polarity of a yes/no field, with any trailing justification allowed
+              ("no - no record in the ERP" passes for expect "no"). Same lesson as
+              none_answer: grade the finding, not the prose.
+      none_answer: the empty-answer trap (replaces the old expect:"none" string check —
+              see docs/AUDIT.md A5). Passes when the value OPENS with a negative
+              ("none", "no ...", "n/a", "nil", "not found", "zero"), with any trailing
+              justification allowed, and fails if any `forbid` substring appears — so the
+              trap asserts "did not invent a record" instead of "wrote exactly one word".
+  trace_checks: [{type: required_servers, servers: [...]},
+                 {type: min_calls, server, n},
+                 {type: reads_before_submit}]
+  state_checks: [{type: writes_only, tables: ["answers"]},   # anti-hack veto
+                 {type: row_count, sql, expect, name?},
+                 {type: sql, sql, expect, tol_abs?, tol_rel?, name?}]
+      sql: grade the world the agent left behind (write tasks) — the committed run, the
+           paid/rejected partition, the reason codes. Numbers compare with tolerance.
+"""
+import json, re, sqlite3, hashlib, sys
+from pathlib import Path
+
+def table_hashes(db):
+    cx = sqlite3.connect(db)
+    out = {}
+    for (t,) in cx.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"):
+        rows = cx.execute(f"SELECT * FROM {t}").fetchall()
+        h = hashlib.sha256(repr(sorted(map(repr, rows))).encode()).hexdigest()[:16]
+        out[t] = [len(rows), h]
+    cx.close()
+    return out
+
+def parse_number(v):
+    if isinstance(v, (int, float)): return float(v)
+    s = re.sub(r"[,$\s]|USD", "", str(v), flags=re.I).rstrip("%")
+    m = re.match(r"^-?\d+(\.\d+)?$", s)
+    return float(s) if m else None
+
+def norm(v): return re.sub(r"\s+", " ", str(v)).strip().lower()
+
+# An empty-answer trap is satisfied by a value that OPENS with a negative. Trailing
+# justification is allowed and expected — a model that explains "none, because no remittance
+# advice was on file" is more useful than one that emits the bare token, and grading them
+# differently measured prose, not grounding (docs/AUDIT.md A5).
+NEG_RE = re.compile(r"^(none|no|n/?a|nil|nothing|zero|not\s+(found|applicable|available|on\s+file))\b")
+
+# Same lesson as NEG_RE, for yes/no fields: a finance answer worth reading is "no - Meadow
+# Analytics has no record in the ERP", not the bare token. Grade the polarity, not the prose.
+YES_RE = re.compile(r"^(yes|y|true|correct|confirmed|affirmative)\b")
+NO_RE  = re.compile(r"^(no|n|false|incorrect|negative|none|not)\b")
+
+# TAT-QA grades `scale` (thousand/million/billion/percent) as a field in its own right,
+# because a financial number without its unit is not an answer (round-2 ledger row 28). We
+# do the same, and additionally diagnose the classic magnitude slip on ANY numeric check
+# rather than letting it hide inside a generic "off by a lot".
+SCALE_SYNONYMS = {
+    "units": {"units", "unit", "absolute", "ones", "dollars", "usd", "as reported", "none"},
+    "thousands": {"thousand", "thousands", "k", "000s", "in thousands"},
+    "millions": {"million", "millions", "m", "mm", "in millions"},
+    "billions": {"billion", "billions", "b", "bn", "in billions"},
+    "percent": {"percent", "percentage", "%", "pct"},
+}
+SCALE_FACTOR = {"units": 1, "thousands": 1e3, "millions": 1e6, "billions": 1e9}
+
+def scale_of(v):
+    s = norm(v).replace("(", " ").replace(")", " ").strip(" .")
+    for canon, words in SCALE_SYNONYMS.items():
+        if s == canon or s in words: return canon
+    # specific scales win over the generic "units" bucket: "USD millions" is millions, not
+    # units, even though "usd" is a units synonym.
+    for canon in ("billions", "millions", "thousands", "percent", "units"):
+        words = SCALE_SYNONYMS[canon]
+        if any(re.search(rf"\b{re.escape(w)}\b", s) for w in words if len(w) > 2): return canon
+    return None
+
+def magnitude_slip(got, exp):
+    """Return the factor if the answer is a clean 1e3/1e6/1e9 multiple of the truth."""
+    if not got or not exp: return None
+    for f in (1e3, 1e6, 1e9):
+        for cand, label in ((exp * f, f), (exp / f, 1 / f)):
+            if cand and abs(got - cand) <= max(0.01, abs(cand) * 1e-4):
+                return label
+    return None
+
+def polarity(v):
+    s = norm(v)
+    if YES_RE.match(s): return "yes"
+    if NO_RE.match(s):  return "no"
+    return None
+
+def verify(task_dir, run_dir):
+    """Verify one step. `task_dir` is a task root (tests/checks.json) or a step dir (checks.json)."""
+    p = Path(task_dir) / "tests/checks.json"
+    checks = json.loads((p if p.exists() else Path(task_dir) / "checks.json").read_text())
+    db = Path(run_dir) / "world.sqlite"
+    failed = []
+
+    cx = sqlite3.connect(db)
+    answers = {f: json.loads(v) for f, v in cx.execute("SELECT field, value FROM answers")}
+    cx.close()
+
+    for c in checks.get("answer_checks", []):
+        fld, typ = c["field"], c.get("type", "string")
+        name = f"answer:{fld}"
+        if fld not in answers:
+            failed.append(name + ":missing"); continue
+        got = answers[fld]
+        if typ == "number":
+            g = parse_number(got)
+            if g is None: failed.append(name + ":not_numeric"); continue
+            exp = float(c["expect"])
+            tol = max(float(c.get("tol_abs", 0.01)), abs(exp) * float(c.get("tol_rel", 0)))
+            if abs(g - exp) > tol:
+                slip = magnitude_slip(g, exp)
+                if slip:
+                    # reported in the wrong unit rather than computed wrongly: a different
+                    # failure mode, and one worth naming separately in the reports.
+                    scale = {1e3: "thousands", 1e6: "millions", 1e9: "billions"}.get(slip)
+                    failed.append(name + f":scale_error(got={g}, want={exp}, off by "
+                                         f"{'x' if slip > 1 else '/'}{int(slip if slip > 1 else 1/slip)}"
+                                         + (f" - looks reported in {scale}" if scale else "") + ")")
+                else:
+                    failed.append(name + f":off(got={g})")
+        elif typ == "none_answer":
+            g = norm(got)
+            if not NEG_RE.match(g):
+                failed.append(name + f":expected_none(got={g[:60]})")
+            else:
+                # the anti-hallucination half: naming a real record while claiming "none"
+                # is a harder failure than being wrong, and is what the trap exists to catch.
+                bad = [s for s in c.get("forbid", []) if norm(s) in g]
+                if bad: failed.append(name + f":hallucinated({bad})")
+        elif typ == "scale":
+            g = scale_of(got)
+            exp_s = scale_of(c["expect"]) or norm(c["expect"])
+            if g is None:
+                failed.append(name + f":unparseable_scale(got={norm(got)[:40]})")
+            elif g != exp_s:
+                failed.append(name + f":wrong_scale(got={g}, want={exp_s})")
+        elif typ == "yes_no":
+            got_p, exp_p = polarity(got), norm(c["expect"])
+            if got_p is None:
+                failed.append(name + f":unparseable_yes_no(got={norm(got)[:60]})")
+            elif got_p != exp_p:
+                failed.append(name + f":wrong_polarity(got={got_p}, want={exp_p})")
+            else:
+                bad = [s for s in c.get("forbid", []) if norm(s) in norm(got)]
+                if bad: failed.append(name + f":hallucinated({bad})")
+        elif typ == "contains_all":
+            g = norm(got)
+            missing = [s for s in c["expect"] if norm(s) not in g]
+            if missing: failed.append(name + f":missing_terms({missing})")
+            # `forbid` is the other half of a set answer: naming the right records is only
+            # correct if it does not ALSO name the wrong ones (over-inclusion is a distinct
+            # failure from omission and is reported as one).
+            over = [s for s in c.get("forbid", []) if norm(s) in g]
+            if over: failed.append(name + f":forbidden_terms({over})")
+        else:
+            if norm(got) != norm(c["expect"]): failed.append(name + f":mismatch(got={norm(got)[:60]})")
+
+    trace = []
+    tf = Path(run_dir) / "trace.jsonl"
+    if tf.exists():
+        trace = [json.loads(l) for l in tf.read_text().splitlines() if l.strip()]
+    for c in checks.get("trace_checks", []):
+        t = c["type"]
+        if t == "required_servers":
+            used = {r["server"] for r in trace if r.get("ok")}
+            miss = [s for s in c["servers"] if s not in used]
+            if miss: failed.append(f"trace:required_servers_missing({miss})")
+        elif t == "min_calls":
+            n = sum(1 for r in trace if r["server"] == c["server"] and r.get("ok"))
+            if n < c["n"]: failed.append(f"trace:min_calls({c['server']}<{c['n']})")
+        elif t == "reads_before_submit":
+            first_submit = next((i for i, r in enumerate(trace)
+                                 if r["server"] == "harness" and r["tool"] == "submit_answer"), None)
+            reads_before = any(r["server"] != "harness" and r.get("ok") for r in trace[:first_submit or 0])
+            if first_submit is None or not reads_before:
+                failed.append("trace:no_reads_before_submit")
+
+    init = json.loads((Path(run_dir) / "initial_state.json").read_text())
+    final = table_hashes(db)
+    RUNTIME_TABLES = {"erp_form_sessions"}  # tool-session state, never an off-task write
+    cx = sqlite3.connect(db)
+    for c in checks.get("state_checks", []):
+        t = c["type"]
+        if t == "writes_only":
+            allowed = set(c.get("tables", ["answers"])) | RUNTIME_TABLES
+            dirty = [x for x in final if x not in allowed and final[x] != init.get(x)]
+            if dirty: failed.append(f"state:off_task_writes({dirty})")
+        elif t == "row_count":
+            n = cx.execute(c["sql"]).fetchone()[0]
+            if n != c["expect"]:
+                failed.append(f"state:row_count({c.get('name', c['sql'][:40])}: got {n}, want {c['expect']})")
+        elif t == "sql":
+            # Grade the world the agent left behind, not the story it told about it. Used by
+            # write tasks: the run it committed, the partition it chose, the reasons it gave.
+            # Numeric comparisons carry a tolerance; everything else is normalized equality.
+            got = cx.execute(c["sql"]).fetchone()
+            got = (got[0] if got else None)
+            exp, name_ = c["expect"], c.get("name", c["sql"][:40])
+            if isinstance(exp, (int, float)) and not isinstance(exp, bool):
+                g = parse_number(got)
+                tol = max(float(c.get("tol_abs", 0.01)), abs(float(exp)) * float(c.get("tol_rel", 0)))
+                if g is None or abs(g - float(exp)) > tol:
+                    failed.append(f"state:sql({name_}: got {got}, want {exp})")
+            elif norm(got) != norm(exp):
+                failed.append(f"state:sql({name_}: got {norm(got)[:60]}, want {norm(exp)[:60]})")
+        elif t == "cell_equals":
+            row = cx.execute(c["sql"]).fetchone()
+            got = row[0] if row else None
+            exp = c["expect"]
+            ok = (abs(float(got) - float(exp)) <= float(c.get("tol_abs", 0))
+                  if isinstance(exp, (int, float)) and got is not None
+                  else norm(got) == norm(exp))
+            if not ok:
+                failed.append(f"state:cell_equals({c.get('name', c['sql'][:40])}: got {got!r}, want {exp!r})")
+    cx.close()
+
+    return {"reward": 1 if not failed else 0, "failed": failed,
+            "n_tool_calls": len(trace),
+            "servers_used": sorted({r['server'] for r in trace})}
+
+def steps_of(task_dir):
+    """Multi-step tasks (Harbor [[steps]] shape): steps/NN/{instruction.md,checks.json,walk.json}.
+    Step 0 is the task root; later steps run in the SAME world, so state carries across turns."""
+    d = Path(task_dir) / "steps"
+    return sorted(p for p in d.glob("*") if (p / "checks.json").exists()) if d.is_dir() else []
+
+def verify_all(task_dir, run_dir):
+    """Verify the root step plus every later step; reward 1 only if all pass."""
+    res = verify(task_dir, run_dir)
+    out = {"reward": res["reward"], "failed": list(res["failed"]),
+           "n_tool_calls": res["n_tool_calls"], "servers_used": res["servers_used"], "steps": 1}
+    for s in steps_of(task_dir):
+        r = verify(s, run_dir)
+        out["steps"] += 1
+        out["failed"] += [f"{s.name}:{f}" for f in r["failed"]]
+        out["reward"] = min(out["reward"], r["reward"])
+    return out
+
+if __name__ == "__main__":
+    import argparse
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--task-dir", required=True); ap.add_argument("--run-dir", required=True)
+    a = ap.parse_args()
+    print(json.dumps(verify_all(a.task_dir, a.run_dir)))