/**
* `harn models lora promote` renderer.
*
* Rust reads manifest/eval receipt files and supplies a typed evidence bundle.
* This Harn source owns promotion policy, final receipt rendering, and
* optional receipt writes.
*
* Inputs:
* HARN_MODELS_LORA_PROMOTE_PAYLOAD_JSON - compact report JSON.
* HARN_MODELS_LORA_PROMOTE_PAYLOAD_PRETTY - pretty report JSON.
* HARN_OUTPUT_JSON - "1" for JSON, else human text.
*/
import { render_trainer_identity_check } from "std/cli/models/lora_render"
import {
cli_json_envelope,
print_list,
safe_bool,
safe_dict,
safe_int_string,
safe_list,
safe_number_string,
safe_string,
} from "std/cli/render"
fn __render_human(harness: Harness, report: dict) {
const request = safe_dict(report["request"])
const contract = safe_dict(report["contract"])
const totals = safe_dict(report["totals"])
const cases = safe_list(report["cases"])
const warnings = safe_list(report["warnings"])
const errors = safe_list(report["errors"])
harness.stdio.println("LoRA promotion probe matrix")
harness.stdio.println(" manifest: " + safe_string(request["manifest"], ""))
harness.stdio.println(" probe root: " + safe_string(request["probe_root"], ""))
const out = safe_string(request["out"], "")
if out != "" {
harness.stdio.println(" receipt: " + out)
}
harness.stdio.println(" promotion id: " + safe_string(contract["promotion_id"], ""))
harness.stdio.println(" LoRA contract: " + safe_string(contract["lora_contract_id"], ""))
render_trainer_identity_check(harness, contract["trainer_identity"])
harness.stdio.println(" eval dataset: " + safe_string(contract["eval_dataset"], ""))
harness.stdio
.println(" minimum trials: " + safe_int_string(contract["minimum_trials"], "0"))
harness.stdio
.println(
" totals: adapter_passed="
+ safe_int_string(totals["adapter_passed"], "0")
+ " adapter_failed="
+ safe_int_string(totals["adapter_failed"], "0")
+ " base_present="
+ safe_int_string(totals["base_present"], "0")
+ " missing="
+ safe_int_string(totals["missing"], "0")
+ " cost_usd="
+ safe_number_string(totals["total_cost_usd"], "0"),
)
if len(cases) > 0 {
harness.stdio.println(" probe cases:")
for item in cases {
const probe = safe_dict(item)
const summary_path = safe_string(probe["summary_path"], "")
let line = safe_string(probe["case_id"], "")
+ " "
+ safe_string(probe["route_role"], "")
+ " "
+ safe_string(probe["status"], "")
+ " "
+ safe_int_string(probe["passed_cases"], "0")
+ "/"
+ safe_int_string(probe["total_cases"], "0")
const reason = safe_string(probe["reason"], "")
if reason != "" {
line = line + " - " + reason
}
if summary_path != "" {
line = line + " (" + summary_path + ")"
}
harness.stdio.println(" - " + line)
print_list(
harness,
"probe " + safe_string(probe["case_id"], "") + " failures",
safe_list(probe["failed_case_reasons"]),
)
}
}
print_list(harness, "warnings", warnings)
print_list(harness, "errors", errors)
const result = if safe_bool(report["ok"], false) {
"PASS"
} else {
"FAIL"
}
harness.stdio.println(" result: " + result)
}
fn __render_json(report: dict) -> string {
const ok = safe_bool(report["ok"], false)
const envelope = if ok {
cli_json_envelope({schema_version: 1, ok: true, data: report})
} else {
cli_json_envelope(
{
schema_version: 1,
ok: false,
error: {
code: "lora_promotion_probe_matrix_failed",
message: "LoRA promotion probe matrix is incomplete or failing.",
details: report,
},
},
)
}
return json_stringify_pretty(envelope)
}
fn __as_int(value) {
return to_int(value) ?? 0
}
fn __as_number(value) {
return to_float(value) ?? 0.0
}
fn __case_ids_match(case_id: string, ids: list) -> bool {
if len(ids) == 0 {
return false
}
for id in ids {
if safe_string(id, "") != case_id {
return false
}
}
return true
}
fn __case_status(evidence: dict, minimum_trials: int) -> dict {
const route_role = safe_string(evidence["route_role"], "")
const case_id = safe_string(evidence["case_id"], "")
const total_cases = __as_int(evidence["total_cases"])
const passed_cases = __as_int(evidence["passed_cases"])
const failed_case_reasons = safe_list(evidence["failed_case_reasons"])
const per_case_count = __as_int(evidence["per_case_count"])
const per_case_passed_count = __as_int(evidence["per_case_passed_count"])
const per_case_ids = safe_list(evidence["per_case_ids"])
const summary_sha256 = safe_string(evidence["summary_sha256"], "")
const per_case_sha256 = safe_string(evidence["per_case_sha256"], "")
let status = "pass"
let reason = to_string(passed_cases) + "/" + to_string(total_cases) + " probe cases passed"
let errors = []
if !safe_bool(evidence["present"], false) {
status = "missing"
reason = safe_string(evidence["missing_reason"], "summary.json was not found")
errors = errors + [case_id + " " + route_role + " missing: " + reason]
} else if summary_sha256 == "" || per_case_sha256 == "" {
status = "fail"
reason = "summary/per_case artifacts must both be hash-bound"
errors = errors + [case_id + " " + route_role + " is missing artifact digest evidence"]
} else if total_cases < minimum_trials {
status = "fail"
reason = "minimum_trials_not_met: " + to_string(total_cases) + "/" + to_string(minimum_trials)
errors = errors
+ [
case_id
+ " "
+ route_role
+ " has only "
+ to_string(total_cases)
+ " trials; required "
+ to_string(minimum_trials),
]
} else if per_case_count != total_cases {
status = "fail"
reason = "per_case_count_mismatch: " + to_string(per_case_count) + "/" + to_string(total_cases)
errors = errors + [case_id + " " + route_role + " per_case row count does not match summary total"]
} else if !__case_ids_match(case_id, per_case_ids) {
status = "fail"
reason = "per_case_identity_mismatch"
errors = errors + [case_id + " " + route_role + " per_case rows do not all match the required case id"]
} else if route_role == "adapter" && (passed_cases != total_cases || len(failed_case_reasons) > 0) {
status = "fail"
reason = to_string(passed_cases) + "/" + to_string(total_cases) + " adapter probe cases passed"
errors = errors + [case_id + " adapter did not pass every probe row"]
} else if route_role == "adapter" && per_case_passed_count != passed_cases {
status = "fail"
reason = "per_case_passed_count_mismatch: "
+ to_string(per_case_passed_count)
+ "/"
+ to_string(passed_cases)
errors = errors + [case_id + " adapter per_case pass count does not match summary"]
} else if route_role == "base" && (passed_cases != total_cases || len(failed_case_reasons) > 0) {
status = "baseline_fail"
reason = to_string(passed_cases) + "/" + to_string(total_cases) + " base probe cases passed"
}
return evidence + {status: status, reason: reason, decision_errors: errors}
}
fn __promotion_report(bundle: dict) -> dict {
const request = safe_dict(bundle["request"])
const contract = safe_dict(bundle["contract"])
const minimum_trials = __as_int(contract["minimum_trials"])
const evidence_cases = safe_list(bundle["evidence_cases"])
let cases = []
let errors = []
let total_cost_usd = 0.0
let adapter_passed = 0
let adapter_failed = 0
let base_present = 0
let missing = 0
let baseline_failed = 0
for item in evidence_cases {
const probe = __case_status(safe_dict(item), minimum_trials)
cases = cases + [probe]
errors = errors + safe_list(probe["decision_errors"])
total_cost_usd = total_cost_usd + __as_number(probe["total_cost_usd"])
const route_role = safe_string(probe["route_role"], "")
const status = safe_string(probe["status"], "")
if status == "missing" {
missing = missing + 1
}
if route_role == "adapter" && status == "pass" {
adapter_passed = adapter_passed + 1
}
if route_role == "adapter" && status != "pass" {
adapter_failed = adapter_failed + 1
}
if route_role == "base" && status != "missing" {
base_present = base_present + 1
}
if route_role == "base" && status == "baseline_fail" {
baseline_failed = baseline_failed + 1
}
}
const trainer_identity = safe_dict(contract["trainer_identity"])
if !safe_bool(trainer_identity["promotable"], false)
&& safe_string(request["trainer_identity_exception"], "") == "" {
for error in safe_list(trainer_identity["errors"]) {
errors = errors + ["trainer identity: " + safe_string(error, "trainer identity is not promotable")]
}
if len(safe_list(trainer_identity["errors"])) == 0 {
errors = errors + ["trainer identity is not promotable"]
}
}
const ok = len(errors) == 0
return {
schema_version: 2,
producer: "harn_models_lora_promote_v2",
ok: ok,
receipt_kind: "promotion_evidence_bundle_receipt",
request: request,
contract: contract,
totals: {
required_cases: len(evidence_cases) / 2,
evidence_records: len(evidence_cases),
adapter_passed: adapter_passed,
adapter_failed: adapter_failed,
base_present: base_present,
baseline_failed: baseline_failed,
missing: missing,
total_cost_usd: total_cost_usd,
},
cases: cases,
warnings: safe_list(bundle["warnings"]),
errors: errors,
}
}
fn main(harness: Harness) -> int {
const raw = harness.env.get_or("HARN_MODELS_LORA_PROMOTE_PAYLOAD_JSON", "")
if raw == "" {
harness.stdio.eprintln("internal error: HARN_MODELS_LORA_PROMOTE_PAYLOAD_JSON not set")
return 70
}
const bundle = try {
json_parse(raw)
} catch (e) {
harness.stdio.eprintln("internal error: failed to parse LoRA promote payload: " + e.message)
return 70
}
const report = __promotion_report(safe_dict(bundle))
const ok = safe_bool(report["ok"], false)
const request = safe_dict(report["request"])
const check = safe_bool(request["check"], false)
const json_mode = harness.env.get_or("HARN_OUTPUT_JSON", "0") == "1"
if json_mode {
harness.stdio.println(__render_json(report))
} else {
__render_human(harness, report)
}
if ok || !check {
return 0
}
return 1
}