aria-code 0.141.0__tar.gz → 0.142.0__tar.gz

{aria_code-0.141.0/src/aria_code.egg-info → aria_code-0.142.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.141.0
+Version: 0.142.0
 Summary: Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code
@@ -172,7 +172,7 @@ Numbers you can check, client data kept apart, actions a person approves.</p>
 <p align="center">
   <a href="https://www.npmjs.com/package/@artheras/aria-code"><img src="https://img.shields.io/npm/v/@artheras/aria-code/latest?style=flat-square&logo=npm&label=npm" alt="npm version"></a>
   <!-- Release automation pins PyPI: the default endpoint still selects legacy 4.x. -->
-  <a href="https://pypi.org/project/aria-code/0.141.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.141.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
+  <a href="https://pypi.org/project/aria-code/0.142.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.142.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
   <a href="https://github.com/artheras/aria-code/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/artheras/aria-code/ci.yml?branch=main&style=flat-square&logo=githubactions&label=CI" alt="CI status"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-64748b?style=flat-square" alt="Apache License 2.0"></a>
 </p>

{aria_code-0.141.0 → aria_code-0.142.0}/README.md

@@ -15,7 +15,7 @@ Numbers you can check, client data kept apart, actions a person approves.</p>
 <p align="center">
   <a href="https://www.npmjs.com/package/@artheras/aria-code"><img src="https://img.shields.io/npm/v/@artheras/aria-code/latest?style=flat-square&logo=npm&label=npm" alt="npm version"></a>
   <!-- Release automation pins PyPI: the default endpoint still selects legacy 4.x. -->
-  <a href="https://pypi.org/project/aria-code/0.141.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.141.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
+  <a href="https://pypi.org/project/aria-code/0.142.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.142.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
   <a href="https://github.com/artheras/aria-code/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/artheras/aria-code/ci.yml?branch=main&style=flat-square&logo=githubactions&label=CI" alt="CI status"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-64748b?style=flat-square" alt="Apache License 2.0"></a>
 </p>

{aria_code-0.141.0 → aria_code-0.142.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.141.0"
+version = "0.142.0"
 description = "Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{aria_code-0.141.0 → aria_code-0.142.0}/src/aria_code/_version.py

@@ -17,4 +17,4 @@ from __future__ import annotations
 
 __all__ = ["__version__"]
 
-__version__ = "0.141.0"
+__version__ = "0.142.0"

{aria_code-0.141.0 → aria_code-0.142.0/src/aria_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.141.0
+Version: 0.142.0
 Summary: Open-source AI agent for coding, financial analysis and logistics operations: numbers you can check, client data kept apart, actions a person approves
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code
@@ -172,7 +172,7 @@ Numbers you can check, client data kept apart, actions a person approves.</p>
 <p align="center">
   <a href="https://www.npmjs.com/package/@artheras/aria-code"><img src="https://img.shields.io/npm/v/@artheras/aria-code/latest?style=flat-square&logo=npm&label=npm" alt="npm version"></a>
   <!-- Release automation pins PyPI: the default endpoint still selects legacy 4.x. -->
-  <a href="https://pypi.org/project/aria-code/0.141.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.141.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
+  <a href="https://pypi.org/project/aria-code/0.142.0/"><img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fpypi.org%2Fpypi%2Faria-code%2F0.142.0%2Fjson&amp;query=%24.info.version&amp;prefix=v&amp;style=flat-square&amp;logo=pypi&amp;label=PyPI&amp;color=blue&amp;cacheSeconds=300" alt="PyPI version"></a>
   <a href="https://github.com/artheras/aria-code/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/artheras/aria-code/ci.yml?branch=main&style=flat-square&logo=githubactions&label=CI" alt="CI status"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-64748b?style=flat-square" alt="Apache License 2.0"></a>
 </p>

{aria_code-0.141.0 → aria_code-0.142.0}/src/aria_code.egg-info/SOURCES.txt

@@ -691,8 +691,14 @@ tests/test_native_binary_entrypoints.py
 tests/test_native_branding.py
 tests/test_native_bridge.py
 tests/test_native_entry.py
+tests/test_native_go_app.py
+tests/test_native_go_bridge.py
+tests/test_native_go_stream.py
 tests/test_native_index.py
 tests/test_native_installer.py
+tests/test_native_runtime_domain.py
+tests/test_native_training_compare.py
+tests/test_native_training_dataset.py
 tests/test_natural_language_routing.py
 tests/test_new_modules.py
 tests/test_no_hardcoded_developer_paths.py

aria_code-0.142.0/tests/test_native_go_app.py

@@ -0,0 +1,62 @@
+"""Exercise the actual Go app executable and its Rust containment barrier."""
+import json
+import os
+import queue
+import subprocess
+import threading
+import time
+
+import pytest
+
+
+def binary():
+    value = os.environ.get("ARIA_GO_RUNTIME_BINARY")
+    if not value:
+        pytest.skip("The native-runtime CI job builds this executable")
+    return value
+
+
+def test_native_app_does_not_touch_state_before_the_host_barrier(tmp_path):
+    program = binary()
+    state = tmp_path / "state"
+    project = tmp_path / "project"
+    state.mkdir()
+    project.mkdir()
+    cfg = state / "config.json"
+    original = json.dumps(dict(local_provider="google", model="gemini-3.5-flash"))
+    cfg.write_text(original, encoding="utf-8")
+    env = dict(os.environ, ARIA_HOME=str(state))
+    process = subprocess.Popen([program, "app"], cwd=project, env=env, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    events = queue.Queue()
+    def read():
+        for line in process.stdout:
+            events.put(json.loads(line))
+    threading.Thread(target=read, daemon=True).start()
+    try:
+        time.sleep(0.2)
+        assert not (state / "sessions").exists()
+        assert cfg.read_text(encoding="utf-8") == original
+        assert events.empty()
+        process.stdin.write("\n")
+        process.stdin.flush()
+        assert events.get(timeout=5)["type"] == "session.ready"
+        process.stdin.write(json.dumps(dict(protocol=1, type="shutdown")) + "\n")
+        process.stdin.flush()
+        assert events.get(timeout=5)["type"] == "session.closed"
+        assert process.wait(timeout=5) == 0
+    finally:
+        if process.poll() is None:
+            process.kill()
+            process.wait()
+
+
+def test_unsupported_native_provider_preserves_existing_user_state(tmp_path):
+    cfg = tmp_path / "config.json"
+    original = json.dumps(dict(local_provider="ollama", last_session_id="previous"))
+    cfg.write_text(original, encoding="utf-8")
+    process = subprocess.run([binary(), "app"], input="\n", env=dict(os.environ, ARIA_HOME=str(tmp_path)), capture_output=True, text=True, timeout=5)
+    assert process.returncode != 0
+    assert cfg.read_text(encoding="utf-8") == original
+    assert not (tmp_path / "sessions").exists()
+    events = [json.loads(line) for line in process.stdout.splitlines()]
+    assert [event["type"] for event in events] == ["session.failed", "session.closed"]

aria_code-0.142.0/tests/test_native_go_bridge.py

@@ -0,0 +1,98 @@
+"""Actual native bridge effects and compatibility with existing file handlers."""
+import json
+import os
+import subprocess
+
+import pytest
+
+from aria_code.apps.cli.native_bridge import dispatch
+
+
+@pytest.fixture
+def bridge(tmp_path, monkeypatch):
+    binary = os.environ.get("ARIA_GO_RUNTIME_BINARY")
+    if not binary:
+        pytest.skip("Build the native Go application before exercising the bridge")
+    project = tmp_path / "project"
+    state = tmp_path / "state"
+    project.mkdir()
+    state.mkdir()
+    monkeypatch.setenv("ARIA_HOME", str(state))
+    env = dict(os.environ, ARIA_PYTHON="missing-python-for-this-test")
+
+    def call(request, approved=""):
+        args = [binary, "bridge", "--workspace", str(project)]
+        if approved:
+            args += ["--approve-tool", approved]
+        result = subprocess.run(args, input="\n" + json.dumps(request) + "\n", env=env,
+                                capture_output=True, text=True, timeout=5)
+        assert result.returncode == 0, result.stderr
+        return json.loads(result.stdout) if result.stdout else None
+    return project, state, call
+
+
+def request(name, **arguments):
+    return dict(jsonrpc="2.0", id="request-你好", method="tools.call",
+                params=dict(name=name, arguments=arguments))
+
+
+@pytest.mark.parametrize("name,arguments", [
+    ("read_file", dict(path="你好.txt")),
+    ("read_file", dict(path="你好.txt", offset=1, limit=1)),
+    ("list_files", dict(path=".", pattern="*")),
+    ("search_code", dict(path=".", pattern="needle", glob="**/*.rs")),
+])
+def test_native_bridge_matches_existing_read_results(bridge, name, arguments):
+    project, _, call = bridge
+    (project / "你好.txt").write_text("first line\n你好 needle\nthird line\n", encoding="utf-8")
+    (project / "source.rs").write_text("// needle evidence\nfn main() {}\n", encoding="utf-8")
+    req = request(name, **arguments)
+    want = dispatch(req, project)
+    got = call(req)
+    assert want["result"]["success"], want
+    assert got == want
+
+
+def test_native_bridge_approved_edits_are_actual_and_keep_crlf(bridge):
+    project, state, call = bridge
+    path = project / "note.txt"
+    req = request("write_file", path="note.txt", content="A complete file body.\r\n")
+    assert not call(req)["result"]["success"]
+    assert not path.exists()
+    assert call(req, "write_file")["result"]["success"]
+    assert path.read_bytes() == b"A complete file body.\r\n"
+    edit = request("edit_file", path="note.txt", old_string="complete", new_string="verified")
+    assert call(edit, "edit_file")["result"]["success"]
+    assert path.read_bytes() == b"A verified file body.\r\n"
+    (state / "tool_policy.json").write_text(json.dumps(dict(denied=["edit_file"])), encoding="utf-8")
+    edit["params"]["arguments"].update(old_string="verified", new_string="blocked")
+    assert not call(edit, "edit_file")["result"]["success"]
+    assert path.read_bytes() == b"A verified file body.\r\n"
+
+
+def test_native_bridge_notification_and_forged_scope_never_execute(bridge):
+    project, _, call = bridge
+    notification = request("write_file", path="new.txt", content="A complete file body.")
+    del notification["id"]
+    assert call(notification, "write_file") is None
+    assert not (project / "new.txt").exists()
+    outside = project.parent / "private.txt"
+    outside.write_text("private document", encoding="utf-8")
+    forged = request("read_file", path="../private.txt", _allowed_read_roots=[str(project.parent)])
+    assert not call(forged)["result"]["success"]
+    write = request("write_file", path="../private.txt", content="Overwrite private document.")
+    assert not call(write, "write_file")["result"]["success"]
+    assert outside.read_text(encoding="utf-8") == "private document"
+
+
+def test_actual_rust_tool_routes_to_go_without_python(bridge):
+    native = os.environ.get("ARIA_NATIVE_BINARY")
+    if not native:
+        pytest.skip("Build the Rust frontend for the complete process-boundary test")
+    project, _, _ = bridge
+    (project / "note.txt").write_text("native process boundary evidence", encoding="utf-8")
+    env = dict(os.environ, ARIA_RUNTIME=os.environ["ARIA_GO_RUNTIME_BINARY"], ARIA_PYTHON="missing-python-for-this-test")
+    result = subprocess.run([native, "-C", str(project), "tool", "read_file", json.dumps(dict(path="note.txt"))],
+                            env=env, capture_output=True, text=True, timeout=5)
+    assert result.returncode == 0, result.stderr
+    assert "native process boundary evidence" in json.loads(result.stdout)["result"]["data"]["content"]

aria_code-0.142.0/tests/test_native_go_stream.py

@@ -0,0 +1,141 @@
+"""Headless Go binary with the actual Google SDK and a local protocol fixture."""
+import json
+import os
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+import subprocess
+import threading
+
+import pytest
+
+
+@pytest.fixture
+def stream(tmp_path):
+    binary = os.environ.get("ARIA_GO_RUNTIME_BINARY")
+    if not binary:
+        pytest.skip("Build the native Go application before checking its public stream")
+    project = tmp_path / "project"
+    state = tmp_path / "state"
+    project.mkdir()
+    state.mkdir()
+    (state / "config.json").write_text(json.dumps(dict(local_provider="google", model="gemini-test",
+                                                       use_vertexai=False, api_key="fixture-only-key")), encoding="utf-8")
+    requests = []
+
+    class Handler(BaseHTTPRequestHandler):
+        def log_message(self, *_):
+            pass
+
+        def do_POST(self):
+            body = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
+            requests.append(body)
+            parts = body["contents"][-1]["parts"]
+            response = parts[0].get("functionResponse")
+            if response:
+                result = response["response"]
+                if result["success"]:
+                    text = result.get("data", {}).get("content", "Actual write completed.")
+                else:
+                    text = "Operation declined: " + result["error"]
+                output = [{"text": text}]
+            else:
+                text = parts[0]["text"]
+                if text == "read note.txt":
+                    output = [dict(functionCall=dict(name="read_file", args=dict(path="note.txt")))]
+                elif text == "write note.txt":
+                    output = [dict(functionCall=dict(name="write_file", args=dict(path="note.txt", content="Actual SDK native write.\n")))]
+                else:
+                    output = [{"text": "你好！"}]
+            self.send_response(200)
+            self.send_header("Content-Type", "text/event-stream")
+            self.end_headers()
+            record = dict(candidates=[dict(content=dict(role="model", parts=output), finishReason="STOP")])
+            self.wfile.write(("data: " + json.dumps(record) + "\n\n").encode())
+            self.wfile.flush()
+
+    server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    env = dict(os.environ, ARIA_HOME=str(state), ARIA_PYTHON="missing-python-for-this-test",
+               GOOGLE_GEMINI_BASE_URL=f"http://127.0.0.1:{server.server_port}", GOOGLE_GENAI_USE_VERTEXAI="false",
+               NO_PROXY="127.0.0.1,localhost", no_proxy="127.0.0.1,localhost")
+
+    def call(prompt, *args, rust=False):
+        if rust:
+            native = os.environ.get("ARIA_NATIVE_BINARY")
+            if not native:
+                pytest.skip("Build the Rust frontend for the complete execution boundary")
+            command = [native, "-C", str(project), "exec", "--jsonl", prompt, "--", *args]
+            call_env = dict(env, ARIA_RUNTIME=binary)
+            data = None
+        else:
+            command = [binary, "stream", "--format=jsonl", "--quiet", "--no-banner", "--prompt="+prompt, *args]
+            call_env = env
+            data = "\n"
+        process = subprocess.run(command, cwd=project, env=call_env, input=data,
+                                 capture_output=True, text=True, timeout=10)
+        events = [json.loads(line) for line in process.stdout.splitlines()]
+        assert events[0]["type"] == "turn.started"
+        assert events[-1]["type"] == "turn.completed"
+        assert sum(e["type"] == "turn.completed" for e in events) == 1
+        return process, events
+    yield project, state, requests, call
+    server.shutdown()
+    server.server_close()
+    thread.join(timeout=5)
+
+
+def test_native_stream_reads_actual_file_and_saves_session(stream):
+    project, state, requests, call = stream
+    evidence = "unpredictable-file-marker-" + os.urandom(8).hex()
+    (project / "note.txt").write_text(evidence, encoding="utf-8")
+    process, events = call("read note.txt")
+    assert process.returncode == 0, process.stderr
+    assert evidence in events[-1]["response"]
+    assert len(requests) == 2
+    assert [e["tool"] for e in events if e["type"] == "tool.started"] == ["read_file"]
+    session_id = events[-1]["session_id"]
+    saved = json.loads((state / "sessions" / (session_id + ".json")).read_text(encoding="utf-8"))
+    assert evidence in saved["messages"][-1]["content"]
+
+
+def test_native_stream_refuses_unapproved_write_then_accepts_explicit_grant(stream):
+    project, _, _, call = stream
+    process, events = call("write note.txt")
+    assert process.returncode == 0, process.stderr
+    assert "approval required" in events[-1]["response"]
+    assert not (project / "note.txt").exists()
+    assert not any(e["type"] == "approval.requested" for e in events)
+    process, events = call("write note.txt", "--allow-tools", "write_file")
+    assert process.returncode == 0, process.stderr
+    assert (project / "note.txt").read_text(encoding="utf-8") == "Actual SDK native write.\n"
+    assert events[-1]["success"] is True
+
+
+def test_native_stream_greeting_has_no_tools_and_prompt_is_literal(stream):
+    project, _, requests, call = stream
+    process, events = call("你好")
+    assert process.returncode == 0, process.stderr
+    assert events[-1]["response"] == "你好！"
+    assert not requests[0].get("tools")
+    assert not any(e["type"] == "tool.started" for e in events)
+    process, _ = call("literal ; $(touch SHOULD_NOT_EXIST)")
+    assert process.returncode == 0, process.stderr
+    assert not (project / "SHOULD_NOT_EXIST").exists()
+
+
+def test_native_stream_nonzero_shell_exit_remains_failure(stream):
+    _, _, requests, call = stream
+    process, events = call("!echo actual-command-output & exit 7" if os.name == "nt" else "!printf actual-command-output; exit 7",
+                           "--allow-tools", "run_command")
+    assert process.returncode == 1
+    result = next(e for e in events if e["type"] == "tool.completed")
+    assert result["exit_code"] == 7 and result["success"] is False
+    assert "actual-command-output" in result["output"]
+    assert not requests
+
+
+def test_rust_exec_and_go_sdk_keep_existing_jsonl_contract(stream):
+    _, _, _, call = stream
+    process, events = call("你好", rust=True)
+    assert process.returncode == 0, process.stderr
+    assert events[-1]["response"] == "你好！" and events[-1]["success"] is True

aria_code-0.142.0/tests/test_native_runtime_domain.py

@@ -0,0 +1,83 @@
+"""Functional parity of the native domain binary against the current engine.
+
+Only the test oracle uses Python; the program under test is the Go executable.
+CI supplies ARIA_GO_RUNTIME_BINARY after building it from the checkout.
+"""
+from __future__ import annotations
+
+import dataclasses
+import datetime as dt
+import json
+import math
+import os
+import random
+import subprocess
+
+import pytest
+
+from aria_code.domain.backtest_engine import Bar, BacktestEngine, get_strategy
+
+
+def cases():
+    def series(values, opens=None, missing=()):
+        return [dict(date=(dt.date(2026, 1, 1) + dt.timedelta(days=i)).isoformat(),
+                     open=opens[i] if opens else close, high=close, low=close,
+                     close=close, volume=1000)
+                for i, close in enumerate(values) if i not in missing]
+
+    common = dict(starting_cash=10000.0, commission=0.0, slippage=0.0)
+    yield "next-open-gap", dict(common, data={"AAA": series([10, 20], [10, 20])}, strategy="buy_hold")
+    yield "exact-profit", dict(common, data={"AAA": series([10, 12, 12], [10, 10, 12])}, strategy="buy_hold")
+    yield "fees-slippage", dict(common, commission=0.01, slippage=0.01, data={"AAA": series([10, 12, 12], [10, 10, 12])}, strategy="buy_hold")
+    yield "sma-sell", dict(common, data={"AAA": series([10, 10, 10, 12, 14, 16, 10, 8, 7, 6])}, strategy="sma_cross", fast=2, slow=3)
+    yield "missing-days", dict(common, data={"ZZZ": series([10, 12, 11, 9, 10], missing=(2,)), "AAA": series([20, 21, 18, 20, 22], missing=(1,))}, strategy="buy_hold")
+    yield "empty", dict(common, data={}, strategy="buy_hold")
+    yield "one-bar", dict(common, data={"AAA": series([10])}, strategy="buy_hold")
+    yield "empty-series", dict(common, data={"ZZZ": [], "AAA": series([10, 11, 12])}, strategy="buy_hold")
+    rng = random.Random(731)
+    for i in range(40):
+        data = {}
+        for symbol in ("ZZZ", "AAA", "MID")[:1 + i % 3]:
+            closes, opens = [], []
+            last = rng.uniform(50, 150)
+            for _ in range(35):
+                opens.append(round(last * rng.uniform(0.98, 1.02), 4))
+                last = round(last * rng.uniform(0.97, 1.03), 4)
+                closes.append(last)
+            data[symbol] = series(closes, opens, missing=(8, 19) if symbol == "AAA" else ())
+        yield f"deterministic-{i}", dict(common, data=data, commission=0.0005, slippage=0.0005,
+                                         strategy="sma_cross" if i % 2 else "buy_hold", fast=3, slow=8)
+
+
+def expected(request):
+    data = {s: [Bar(**b) for b in bars] for s, bars in request["data"].items()}
+    engine = BacktestEngine(**{k: request[k] for k in ("starting_cash", "commission", "slippage", "periods_per_year") if k in request})
+    parameters = {k: request[k] for k in ("fast", "slow", "weight") if k in request and (k == "weight" or request["strategy"] == "sma_cross")}
+    return dataclasses.asdict(engine.run(data, get_strategy(request["strategy"], **parameters)))
+
+
+def same_result(got, want, path="result"):
+    if isinstance(want, dict):
+        assert isinstance(got, dict) and got.keys() == want.keys(), path
+        for key in want:
+            same_result(got[key], want[key], f"{path}.{key}")
+    elif isinstance(want, list):
+        assert isinstance(got, list) and len(got) == len(want), path
+        for index, (actual, reference) in enumerate(zip(got, want)):
+            same_result(actual, reference, f"{path}[{index}]")
+    elif isinstance(want, (int, float)):
+        assert math.isclose(got, want, rel_tol=1e-12, abs_tol=1e-8), (path, got, want)
+    else:
+        assert got == want, path
+
+
+@pytest.mark.parametrize("name,case", list(cases()))
+def test_native_backtest_matches_existing_business_results(tmp_path, name, case):
+    binary = os.environ.get("ARIA_GO_RUNTIME_BINARY")
+    if not binary:
+        pytest.skip("Native Go runtime is built by the native-runtime CI job")
+    source = tmp_path / "bars.json"
+    source.write_text(json.dumps(case), encoding="utf-8")
+    process = subprocess.run([binary, "backtest", "--input", str(source)], capture_output=True, text=True, timeout=10)
+    assert process.returncode == 0, (name, process.stderr)
+    same_result(json.loads(process.stdout), expected(case))

aria_code-0.142.0/tests/test_native_training_compare.py

@@ -0,0 +1,33 @@
+"""Compare the Go training evaluator with the existing Python business rules."""
+import json
+import os
+import random
+import subprocess
+
+import pytest
+
+from aria_code.training.compare import compare
+from test_native_runtime_domain import same_result
+
+
+@pytest.mark.parametrize("seed", range(12))
+def test_native_training_statistics_match_existing_reports(tmp_path, seed):
+    binary = os.environ.get("ARIA_GO_RUNTIME_BINARY")
+    if not binary:
+        pytest.skip("Native Go runtime is built in the native-runtime CI job")
+    rng = random.Random(seed)
+    paths = []
+    for name in ("baseline", "candidate"):
+        results = []
+        for task in range(8):
+            if seed == 0:
+                continue
+            for attempt in range(4):
+                outcome = rng.choice(("pass", "fail", "error", "invalid"))
+                results.append(dict(task_id=f"task-{task}", outcome=outcome, seconds=10 + attempt))
+        path = tmp_path / (name + ".json")
+        path.write_text(json.dumps(dict(results=results)), encoding="utf-8")
+        paths.append(path)
+    process = subprocess.run([binary, "training", "compare", "--baseline", str(paths[0]), "--candidate", str(paths[1])], capture_output=True, text=True, timeout=10)
+    assert process.returncode == 0, process.stderr
+    same_result(json.loads(process.stdout), compare(paths[:1], paths[1:]))

aria_code-0.142.0/tests/test_native_training_dataset.py

@@ -0,0 +1,70 @@
+"""Native SFT preparation must retain the existing eligibility and provenance."""
+import json
+import os
+import subprocess
+
+import pytest
+
+from aria_code.training.sft_dataset import build
+from test_native_runtime_domain import same_result
+from test_training_pipeline import _examples, _suites, _traj
+
+
+def make_data(root):
+    suites = _suites(root)
+    _traj(root, "core", "fix-a", 1, "pass")
+    _traj(root, "core", "fix-a", 2, "pass", response="Second verified answer.")
+    _traj(root, "core", "rec-b", 1, "pass")
+    _traj(root, "core", "rec-b", 2, "fail")
+    _traj(root, "core", "fin-c", 1, "pass", path_read="test_grade.py")
+    _traj(root, "core", "fin-c", 2, "pass", acceptance={"verified": False})
+    _traj(root, "hard", "hard-x", 1, "pass")
+    # This duplicate has different attempt metadata, which must not make an
+    # otherwise identical task trajectory into a second training example.
+    _traj(root, "core", "rec-b", 3, "pass")
+    _traj(root, "core", "unknown", 1, "pass")
+    return suites
+
+
+def native_dataset(root, suites, out, share):
+    binary = os.environ.get("ARIA_GO_RUNTIME_BINARY")
+    if not binary:
+        pytest.skip("Native Go runtime is built in the native-runtime CI job")
+    return subprocess.run([binary, "training", "dataset", str(root / "traj"), "--suites", str(suites), "--out", str(out), "--validation-share", str(share)], text=True, capture_output=True, timeout=10)
+
+
+@pytest.mark.parametrize("share", (0.0, 0.2, 0.5, 1.0))
+def test_native_training_dataset_keeps_holdout_rules_dedup_and_provenance(tmp_path, share):
+    suites = make_data(tmp_path)
+    reference = build(tmp_path / "traj", suites, tmp_path / "python-out", validation_share=share)
+    actual = native_dataset(tmp_path, suites, tmp_path / "go-out", share)
+    assert actual.returncode == 0, actual.stderr
+    same_result(json.loads(actual.stdout), reference)
+    same_result(_examples(tmp_path / "go-out"), _examples(tmp_path / "python-out"))
+    assert not set(reference["tasks"].get("train", [])) & set(reference["tasks"].get("validation", []))
+
+
+def test_native_dataset_keeps_unicode_truncation_and_tool_result_types(tmp_path):
+    suites = make_data(tmp_path)
+    file = tmp_path / "traj/core/fix-a-1.jsonl"
+    events = [json.loads(line) for line in file.read_text().splitlines()]
+    result = events[3]["result"]
+    result.update(content="中文😀" * 2200 + "<>&\\u2028\u2028", score=1.0)
+    file.write_text("\n".join(json.dumps(event) for event in events) + "\n", encoding="utf-8")
+    reference = build(tmp_path / "traj", suites, tmp_path / "python-out")
+    actual = native_dataset(tmp_path, suites, tmp_path / "go-out", 0.2)
+    assert actual.returncode == 0, actual.stderr
+    same_result(json.loads(actual.stdout), reference)
+    same_result(_examples(tmp_path / "go-out"), _examples(tmp_path / "python-out"))
+
+
+def test_failed_native_dataset_build_preserves_existing_outputs(tmp_path):
+    suites = make_data(tmp_path)
+    out = tmp_path / "go-out"
+    assert native_dataset(tmp_path, suites, out, 0.2).returncode == 0
+    prior = {name: (out / name).read_bytes() for name in ("train.jsonl", "validation.jsonl", "manifest.json")}
+    (tmp_path / "traj/core/broken.jsonl").write_text('{"type":"eval.task"}\n{broken}\n')
+    actual = native_dataset(tmp_path, suites, out, 0.2)
+    assert actual.returncode != 0
+    assert all((out / name).read_bytes() == value for name, value in prior.items())
+    assert not list(out.glob(".aria-sft-*"))