Nick
f83396eecd
Contract BUILDER-2026-10-11T22:03:40Z-7aeb7a-factory-wave (#2479 tranche). Faithful port of src/rune/toolchain.py: ToolchainConstraints known/unknown classification, DecisionRecord normalization, _major_change, resolve_toolchain (INSUFFICIENT_EVIDENCE gate, KEEP_EXISTING, CHANGE_MAJOR, greenfield recommendation), CONSTRAINT_KEYS vocabulary. Doc-envelope FFI (tl_* symbols, free via cs_free_string), ctypes loader (tl_loader.py, TC_RUST_LIB override), facade delegation with RUNE_TC_CORE=python pin. Frozen oracle truth: 43 cases across every public function and branch (frozen_tc_truth.json), replayed VERBATIM by branch_battery.rs (6 tests). Live parity 613/613 (truth + 570 fuzz, seed 2479).
187 lines
9.3 KiB
Python
187 lines
9.3 KiB
Python
#!/usr/bin/env python3
|
|
"""Freeze toolchain oracle truth for the Rust port battery (dichotomy
|
|
wave #2479 tranche, batch: toolchain — RUST side verdict).
|
|
|
|
Exercises EVERY public function across EVERY branch:
|
|
ToolchainConstraints (known/unknown key classification, get with and
|
|
without default, to_dict), DecisionRecord (list normalization: sorting
|
|
of libraries/decisive_constraints/evidence_refs, None-list defaults,
|
|
alternatives copy, confidence), CONSTRAINT_KEYS (frozen vocabulary),
|
|
_major_change (existing-language equality branches), resolve_toolchain
|
|
(INSUFFICIENT_EVIDENCE short path, KEEP_EXISTING with/without hard
|
|
factors and performance evidence, same-language request, CHANGE_MAJOR
|
|
with and without significant evidence, greenfield recommendation,
|
|
greenfield INSUFFICIENT_EVIDENCE, falsy existing_language edges).
|
|
|
|
Output: src/rust/toolchain/src/frozen_tc_truth.json — replayed VERBATIM
|
|
by src/rust/toolchain/src/branch_battery.rs.
|
|
|
|
The module is fully deterministic (no wall-clock fields) — every case
|
|
compares exactly, no masking.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
os.environ["RUNE_TC_CORE"] = "python" # POISONED-TRUTH LAW: freeze the ORACLE, never the kernel
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
|
|
|
|
from rune import toolchain as tc # noqa: E402
|
|
|
|
cases: dict[str, list] = {}
|
|
|
|
|
|
def run(fn: str, name: str, *args, **kwargs):
|
|
out = getattr(tc, fn)(**kwargs) if args == () else getattr(tc, fn)(*args, **kwargs)
|
|
if hasattr(out, "to_dict"):
|
|
out = out.to_dict()
|
|
cases.setdefault(fn, []).append(
|
|
{"name": name, "input": kwargs if args == () else {"args": args, "kwargs": kwargs},
|
|
"expected": out})
|
|
|
|
|
|
# ── CONSTRAINT_KEYS: the frozen vocabulary ────────────────────────────
|
|
cases["constraint_keys"] = [{"name": "vocabulary",
|
|
"input": {},
|
|
"expected": sorted(tc.CONSTRAINT_KEYS)}]
|
|
|
|
# ── ToolchainConstraints: classification, get, to_dict ────────────────
|
|
for nm, kw in (
|
|
("known-only", dict(existing_language="python", target_platform="linux")),
|
|
("unknown-only", dict(wibble="future-thing", flurb=42)),
|
|
("mixed", dict(existing_language="rust", existing_runtime="tokio",
|
|
not_a_key=[1, 2], performance_sensitive=True, none_val=None)),
|
|
("empty", {}),
|
|
("every-known-key", {k: f"v-{k}" for k in tc.CONSTRAINT_KEYS}),
|
|
("falsy-values", dict(existing_language="", performance_sensitive=False,
|
|
memory_constrained=0)),
|
|
):
|
|
c = tc.ToolchainConstraints(**kw)
|
|
cases.setdefault("constraints", []).append(
|
|
{"name": nm, "input": {"kwargs": kw}, "expected": c.to_dict()})
|
|
|
|
for nm, kw, key, default, has_default in (
|
|
("get-known", dict(existing_language="python"), "existing_language", None, False),
|
|
("get-missing-no-default", dict(existing_language="python"), "existing_runtime", None, False),
|
|
("get-missing-with-default", dict(existing_language="python"), "existing_runtime", "", True),
|
|
("get-unknown-key-stored", dict(wibble="x"), "wibble", None, False),
|
|
("get-known-falsy-value", dict(existing_language=""), "existing_language", "dflt", True),
|
|
("get-default-none-explicit", dict(a="1"), "b", None, True),
|
|
):
|
|
c = tc.ToolchainConstraints(**kw)
|
|
val = c.get(key, default) if has_default else c.get(key)
|
|
cases.setdefault("constraints_get", []).append(
|
|
{"name": nm, "input": {"known": c.known, "key": key,
|
|
"default": default if has_default else None},
|
|
"expected": val})
|
|
|
|
# ── DecisionRecord: normalization branches ────────────────────────────
|
|
for nm, kw in (
|
|
("full-fields", dict(
|
|
selected_language="rust", runtime="tokio", framework="axum",
|
|
libraries=["zlib", "openssl", "a-lib"], build_system="cargo",
|
|
alternatives=[{"language": "go", "rejected_because": "no evidence"}],
|
|
decisive_constraints=["requested_language", "existing_language"],
|
|
rationale="measured benefit", evidence_refs=["bench-2", "bench-1"],
|
|
confidence=0.8, user_approval_required=True, resolution="CHANGE_MAJOR")),
|
|
("defaults", dict(selected_language="python")),
|
|
("none-lists-become-sorted-empty", dict(
|
|
selected_language="python", libraries=None, decisive_constraints=None,
|
|
evidence_refs=None, alternatives=None)),
|
|
("unsorted-normalized", dict(
|
|
selected_language="python", libraries=["b", "a", "c"],
|
|
decisive_constraints=["z", "a"], evidence_refs=["e2", "e1", "e0"],
|
|
confidence=0.85)),
|
|
("empty-lists-kept", dict(
|
|
selected_language="python", libraries=[], alternatives=[],
|
|
decisive_constraints=[], evidence_refs=[], resolution="KEEP_EXISTING")),
|
|
):
|
|
d = tc.DecisionRecord(**kw)
|
|
cases.setdefault("decision_record", []).append(
|
|
{"name": nm, "input": kw, "expected": d.to_dict()})
|
|
|
|
# ── _major_change ─────────────────────────────────────────────────────
|
|
for nm, kw, language in (
|
|
("different-language", dict(existing_language="python"), "rust"),
|
|
("same-language", dict(existing_language="python"), "python"),
|
|
("no-existing", {}, "rust"),
|
|
("falsy-existing", dict(existing_language=""), "rust"),
|
|
("non-str-existing", dict(existing_language=None), "rust"),
|
|
):
|
|
c = tc.ToolchainConstraints(**kw)
|
|
cases.setdefault("major_change", []).append(
|
|
{"name": nm, "input": {"known": c.known, "language": language},
|
|
"expected": tc._major_change(c, language)})
|
|
|
|
# ── resolve_toolchain: every branch ───────────────────────────────────
|
|
def res(nm, ckw, **kw):
|
|
c = tc.ToolchainConstraints(**ckw)
|
|
d = tc.resolve_toolchain(c, **kw)
|
|
cases.setdefault("resolve_toolchain", []).append(
|
|
{"name": nm,
|
|
"input": {"known": c.known, "unknown": c.unknown, **kw},
|
|
"expected": d.to_dict()})
|
|
|
|
# INSUFFICIENT short path: no existing, no request, <2 hard factors
|
|
res("insufficient-no-factors", dict(existing_runtime="tokio"))
|
|
res("insufficient-one-factor", dict(target_platform="linux"))
|
|
# falls through to greenfield INSUFFICIENT: >=2 hard factors, approval required
|
|
res("greenfield-insufficient-two-factors", dict(target_platform="linux", deployment="server"))
|
|
res("greenfield-insufficient-bools-count", dict(performance_sensitive=True, memory_constrained=True))
|
|
# KEEP_EXISTING branches
|
|
res("keep-existing-no-hard-factors", dict(existing_language="python"))
|
|
res("keep-existing-with-hard-factors", dict(existing_language="rust",
|
|
performance_sensitive=True))
|
|
res("keep-existing-with-runtime-framework", dict(
|
|
existing_language="typescript", existing_runtime="node",
|
|
existing_framework="svelte", target_platform="web"))
|
|
res("keep-existing-performance-evidence-rejected", dict(
|
|
existing_language="python", performance_sensitive=True),
|
|
performance_evidence={"significant_benefit": True, "basis": "measured 10x"})
|
|
res("keep-existing-empty-perf-evidence", dict(existing_language="python"),
|
|
performance_evidence={})
|
|
res("keep-existing-same-language-request", dict(existing_language="python"),
|
|
requested_language="python")
|
|
res("keep-existing-with-evidence-refs", dict(existing_language="go"),
|
|
evidence_refs=["ref-b", "ref-a", "ref-c"])
|
|
# CHANGE_MAJOR branches
|
|
res("change-major-no-evidence", dict(existing_language="python"),
|
|
requested_language="rust")
|
|
res("change-major-significant", dict(existing_language="python",
|
|
performance_sensitive=True),
|
|
requested_language="rust",
|
|
performance_evidence={"significant_benefit": True, "basis": "measured"})
|
|
res("change-major-falsy-significant", dict(existing_language="python"),
|
|
requested_language="rust",
|
|
performance_evidence={"significant_benefit": False})
|
|
res("change-major-null-significant", dict(existing_language="python"),
|
|
requested_language="zig", performance_evidence={"significant_benefit": None})
|
|
# greenfield recommendation
|
|
res("greenfield-requested", dict(target_platform="linux", deployment="server"),
|
|
requested_language="zig")
|
|
res("greenfield-requested-no-factors", dict(), requested_language="go")
|
|
# falsy existing_language edges: "" behaves as absent
|
|
res("falsy-existing-no-request", dict(existing_language=""))
|
|
res("falsy-existing-with-request", dict(existing_language=""),
|
|
requested_language="rust")
|
|
# unknown keys ride along but do not affect the decision
|
|
res("unknown-keys-ignored", dict(existing_language="python", wibble="x"),
|
|
requested_language="python")
|
|
|
|
truth = {
|
|
"frozen": "toolchain full oracle truth (dichotomy wave #2479)",
|
|
"oracle": "src/rune/toolchain.py",
|
|
"note": ("The module is fully deterministic — no wall-clock fields, "
|
|
"every case compares exactly. error = the exact Python "
|
|
"exception message where applicable."),
|
|
"cases": cases,
|
|
}
|
|
out = Path(__file__).resolve().parents[1] / "src" / "rust" / "toolchain" / "src" / "frozen_tc_truth.json"
|
|
out.write_text(json.dumps(truth, indent=1, sort_keys=True) + "\n")
|
|
total = sum(len(v) for v in cases.values())
|
|
print(f"frozen {total} cases across {len(cases)} functions -> {out}")
|