cr150: freeze the four 1.7.0 contracts (P00: report sink ABI + writer, TradeLedger, metric accumulator/point source, bar views)

.dockerignore

@@ -27,3 +27,7 @@ scripts/
 tutorial/
 .playwright-mcp/
 node_modules/
+
+# Frozen Python report producer used only by the L9A comparison tests.
+tests/fixtures/run_json_frozen_pre_l9a.py
+tests/fixtures/run_json_frozen_pre_l9a.sha256

CMakeLists.txt

@@ -148,8 +148,11 @@ set(PINEFORGE_KERNEL_SOURCES
     src/timeframe.cpp
     src/timezone.cpp
     src/native_calendar.cpp
+    src/report_sink_writer.cpp
+    src/sha256.cpp
     src/native_run_spec.cpp
     src/native_fx_curve.cpp
+    src/native_bar_views.cpp
     src/selected_report_view.cpp
     src/selected_window_plan.cpp
 )

README.md

@@ -33,7 +33,7 @@ The separate PineForge compiler, [`pineforge-codegen`](https://github.com/pinefo
 - **Open runtime.** The engine and native live runner are Apache-2.0. The separately distributed [PineForge compiler](https://github.com/pineforge-4pass/pineforge-codegen-oss/blob/main/LICENSE) is source-available under the PineForge Source License 1.2 from its release 1.3.0 (release 1.2.0 keeps the PineForge Source License 1.1, and releases up to 1.1.0 keep the PolyForm Noncommercial terms they shipped with); personal trading is free, and commercial use requires a separate license; the capital in an account a proprietary-trading firm or funded-trader program provides or allocates, including a challenge, evaluation or simulated account, is investment capital. Public reference strategies, benchmarks and validation tooling are available in their respective repositories; the community-script test set is not redistributed.
 - **Fast.** In-process, no interpreter: median **36× faster than PyneCore** on the 200 strategies both engines time (100 corpus probes and 100 held-out private strategies), measured at engine `35db01c8` on 2026-09-29 on an AWS c7a.8xlarge with PyneCore timed as a subprocess, its interpreter start-up included (PineForge runs a median 807k bars/s per strategy over its 201 slots with the bar magnifier on; [method](benchmarks/results/speed.md)). Parameter sweeps re-run a loaded `.so` with new inputs — no recompile, no fork.
 - **Deterministic to the bit.** Two runs with the same inputs produce identical trade lists. Same on Linux and macOS.
-- **Yours to embed.** 145 `PF_API` declarations across five installed headers — `pineforge.h`'s 94 (74 of the 80 runtime exports, the other six being declared in `execution_observer.h` and `selected_window.h`, three each, and up to 20 per-strategy functions a generated module defines), `native_c_api.h`'s 43 native-host declarations and `selected_window_plan.h`'s two planner declarations — an ABI that is append-only within a major version from 1.0 on. Call it from C, Python, Rust, Go, Node, Julia — or let an AI agent drive it over MCP.
+- **Yours to embed.** 150 `PF_API` declarations across six installed headers — `pineforge.h`'s 96 (76 of the 85 runtime exports, the other nine being declared in `execution_observer.h`, `selected_window.h` and `report_sink.h`, three each, and up to 20 per-strategy functions a generated module defines), `native_c_api.h`'s 43 native-host declarations and `selected_window_plan.h`'s two planner declarations — an ABI that is append-only within a major version from 1.0 on. Call it from C, Python, Rust, Go, Node, Julia — or let an AI agent drive it over MCP.
 
 Recorded outputs and their additional API declarations described here are
 part of **1.5.0**.
@@ -517,13 +517,13 @@ API, the script ABI epoch and the pairing with codegen — is the
 [public contract](docs/pages/public-contract.md); what a 0.x user must act on
 is in [CHANGELOG.md](CHANGELOG.md).
 
-The counts below include recorded outputs and describe the released 1.5.0 API.
+The counts below describe the current API, including recorded outputs, the report sink and scratch-table selection; recorded outputs are not part of 1.4.0.
 
-A newly generated strategy `.so` exposes 96 compiled-strategy `PF_API` declarations
-(80 runtime implementations plus sixteen generated exports) plus 43 native-host
-declarations: 139 `PF_API` exports in total; `use_bar_magnifier = true` adds
+A newly generated strategy `.so` exposes 101 compiled-strategy `PF_API` declarations
+(85 runtime implementations plus sixteen generated exports) plus 43 native-host
+declarations: 144 `PF_API` exports in total; `use_bar_magnifier = true` adds
 `strategy_declares_bar_magnifier` and a module that records [outputs](docs/outputs.md) its
-three outputs exports, bringing the inventories to at most 100 and 143. Older modules lack the six opt-in
+three outputs exports, bringing the inventories to at most 105 and 148. Older modules lack the six opt-in
 [checked-settings exports](docs/checked-settings.md). Older modules can also lack
 the two opt-in [execution-capability exports](docs/strategy-capabilities.md).
 In an optimized build `nm -gU` also shows libc++'s
@@ -548,13 +548,14 @@ inventories are pinned by `scripts/check_c_abi_runtime.py`:
 | `strategy_set_chart_timezone` / `strategy_set_syminfo_timezone` / `strategy_set_syminfo_session` | Chart and exchange time |
 | `strategy_set_syminfo_mintick` / `_pointvalue` / `_metadata` / `_type` / `_string` | Symbol tick size, point value, numeric metadata, instrument class, string members |
 | `strategy_set_native_security_feed` / `strategy_set_aux_security_feed` | Feed `request.security()` from a native higher-timeframe series / an auxiliary bar-aligned feed |
-| `strategy_set_symbol_feed` / `_feed_column` / `strategy_set_symbol_facts` / `strategy_set_recorded_series` | Another symbol's data for `request.security()` of that symbol: its own bars (each with its close) and named columns, its `syminfo.*` facts, and recorded request values per chart bar (each behind its own `PINEFORGE_HAS_…_V1` probe; historical runs only) |
+| `strategy_set_symbol_feed` / `strategy_set_symbol_feed_borrowed_v1` / `_feed_column` / `strategy_set_symbol_facts` / `strategy_set_recorded_series` | Another symbol's data for `request.security()` of that symbol: its own copied or borrowed bars (each with its close) and named columns, its `syminfo.*` facts, and recorded request values per chart bar (each behind its own `PINEFORGE_HAS_…_V1` probe; historical runs only) |
 | `strategy_set_account_currency_fx_series` | Effective-time quote-to-account FX |
 | `strategy_get_last_error` | The latest runtime error |
 | `strategy_get_last_error_code` / `strategy_get_last_error_args` | The latest failure's stable code from the closed [run-failure vocabulary](docs/pages/run-failure-codes.md) (`""` when the run succeeded) and its typed arguments as canonical JSON; behind `PINEFORGE_HAS_RUN_FAILURE_CODES_V1` |
 | `pf_version_get` / `pf_version_string` / `pf_abi_version` | Runtime version, version string, struct-layout version (`PF_ABI_VERSION == 4`) |
 | `strategy_execution_contract` / `strategy_configure_native_v1` / `strategy_configure_native_fx_curve_v1` / `_fx_curve_ext_v1` | Query Legacy vs NativeMarketV1; apply the versioned native run specification (an invalid or refused base call returns `-1` and leaves the handle Failed; a cooperative `Aborted` handle may be reused with the same key and a higher run number); stage or clear an immutable native FX curve, `_fx_curve_ext_v1` also writing the typed refusal (`pf_native_fx_curve_error_e`) and the offending point's index |
 | `strategy_request_abort` / `strategy_last_run_status` | Cooperative abort of a run in progress; `0`=completed, `1`=aborted |
+| `strategy_set_scratch_tables_v1` | Copy disk-scratch or bounded-memory table policy and its eleven admission maxima while idle; NULL restores disk defaults (since 1.7.0) |
 | `strategy_set_realtime_tail` | Live-runtime surface (ABI v4): the array's last bar is a still-forming tail — `barstate.islast=false`, `last_bar_index`/`last_bar_time` frozen at the horizon bar, no range-end row |
 | `strategy_set_probe_suppress_tail_logic` | ABI v4: the last bar runs only the broker's pre-`on_bar` steps (pending-order settlement, intraday-cap/loss checks) and returns — no `on_bar`, no margin-call / `process_orders_on_close` second pass / bracket-reissue processing (the range-end row is `strategy_set_realtime_tail`'s to skip; the flags are independent) |
 | `strategy_set_path_order` / `strategy_last_bar_dual_entry_path` | ABI v4: force the intrabar O→H/L→C leg order (`AUTO`/`HIGH_FIRST`/`LOW_FIRST`) for path-dependent fill probing; read which side won a same-bar dual-entry-stop arbitration |

benchmarks/throughput/grid_search_repro.py

@@ -2,8 +2,14 @@
 import ctypes
 import csv
 import itertools
+import sys
 from pathlib import Path
 
+# Share the host's descriptor and policy arithmetic, including typed refusals.
+sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "docker"))
+from run_json import (RunFailure, _bind_scratch_tables, _check_bench_run,
+                      apply_scratch_tables, default_scratch_manifest, failure_line)
+
 class pf_bar_t(ctypes.Structure):
     _fields_ = [
         ("open", ctypes.c_double),
@@ -192,6 +198,16 @@ def main():
     lib.report_free.argtypes = [ctypes.POINTER(pf_report_t)]
     lib.report_free.restype = None
 
+    _bind_scratch_tables(lib)
+    for name in ("strategy_get_last_error", "strategy_get_last_error_code",
+                 "strategy_get_last_error_args"):
+        if hasattr(lib, name):
+            getattr(lib, name).argtypes = [ctypes.c_void_p]
+            getattr(lib, name).restype = ctypes.c_char_p
+    if hasattr(lib, "strategy_last_run_status"):
+        lib.strategy_last_run_status.argtypes = [ctypes.c_void_p]
+        lib.strategy_last_run_status.restype = ctypes.c_int
+
     # Load CSV
     bars_list = []
     print(f"Loading CSV data from {csv_path.name}...")
@@ -230,29 +246,40 @@ def main():
             print("Failed to create strategy instance!")
             continue
 
-        # Set inputs
-        lib.strategy_set_input(s, b"Fast EMA", str(fast).encode())
-        lib.strategy_set_input(s, b"Slow EMA", str(slow).encode())
-        lib.strategy_set_input(s, b"Take profit (ticks)", str(tp).encode())
-
         report = pf_report_t()
-        lib.run_backtest(s, bars_array, n, ctypes.byref(report))
-
-        profit = report.net_profit
-        trades = report.total_trades
-
-        print(f"Params: Fast_EMA={fast}, Slow_EMA={slow}, TP_ticks={tp} | Net Profit = {profit:.2f} | Trades = {trades}")
-
-        if profit > best_profit:
-            best_profit = profit
-            best_params = (fast, slow, tp)
-
-        lib.report_free(ctypes.byref(report))
-        lib.strategy_free(s)
+        try:
+            lib.strategy_set_input(s, b"Fast EMA", str(fast).encode())
+            lib.strategy_set_input(s, b"Slow EMA", str(slow).encode())
+            lib.strategy_set_input(s, b"Take profit (ticks)", str(tp).encode())
+
+            # P0 policy for THIS trial, after its overrides/feed selection.
+            # A fresh handle/run receives fresh occupancy, never its predecessor's.
+            manifest = default_scratch_manifest(n)
+            apply_scratch_tables(lib, s, manifest)
+            lib.run_backtest(s, bars_array, n, ctypes.byref(report))
+            _check_bench_run(lib, s)  # a failed trial cannot enter the ranking
+
+            profit = report.net_profit
+            trades = report.total_trades
+
+            print(f"Params: Fast_EMA={fast}, Slow_EMA={slow}, TP_ticks={tp} | Net Profit = {profit:.2f} | Trades = {trades}")
+
+            if profit > best_profit:
+                best_profit = profit
+                best_params = (fast, slow, tp)
+        finally:
+            try:
+                lib.report_free(ctypes.byref(report))
+            finally:
+                lib.strategy_free(s)
 
     print("\n=== OPTIMIZATION COMPLETE ===")
     print(f"Best Profit: {best_profit:.2f}")
     print(f"Best Parameters: Fast EMA = {best_params[0]}, Slow EMA = {best_params[1]}, Take profit (ticks) = {best_params[2]}")
 
 if __name__ == "__main__":
-    main()
+    try:
+        main()
+    except RunFailure as failure:
+        sys.stderr.write(failure_line(str(failure), failure.code, failure.code_args))
+        sys.exit(failure.exit_status)