From c7f1da715ec3de2929b0009600acc2ef4fb81c92 Mon Sep 17 00:00:00 2001 From: Alejandro Castellanos <5405628+k2jac9@users.noreply.github.com> Date: Mon, 16 Nov 2026 01:08:29 -0500 Subject: [PATCH 1/3] feat: add bounded local correction pilot with paired Store baseline --- docs/controlled-correction-pilot.md | 213 +++++ examples/controlled_correction_pilot.rs | 273 +++++++ .../controlled_correction_pilot/adapter.rs | 57 ++ examples/controlled_correction_pilot/tests.rs | 70 ++ scripts/run_controlled_correction_pilot.py | 742 ++++++++++++++++++ scripts/test_controlled_correction_pilot.py | 234 ++++++ 6 files changed, 1589 insertions(+) create mode 100644 docs/controlled-correction-pilot.md create mode 100644 examples/controlled_correction_pilot.rs create mode 100644 examples/controlled_correction_pilot/adapter.rs create mode 100644 examples/controlled_correction_pilot/tests.rs create mode 100644 scripts/run_controlled_correction_pilot.py create mode 100644 scripts/test_controlled_correction_pilot.py diff --git a/docs/controlled-correction-pilot.md b/docs/controlled-correction-pilot.md new file mode 100644 index 0000000..87de22e --- /dev/null +++ b/docs/controlled-correction-pilot.md @@ -0,0 +1,213 @@ +# Controlled local correction pilot + +This is a separate experimental harness, **offline-qualified only until a LIVE +receipt exists**. It exercises real Rust Store capture, scoped model reuse, +withdrawal, typed alternative support and fresh recomputation. Its fixed data and +prompts are copied from `scoped_model_reuse`; no dataset expansion, incident +held-out evaluation, training or change to existing Store/validator behavior is +included. It is separate from the main submission pinned to `20fab84` and from +the fixture-only incident Store bridge. + +The model candidate is cached `ornith-1.5:9b`, Q4_K_M, on Ollama 0.40.16. The +adapter fixes its selected variant digest and the supervisor pins the cached +container image and full model/config/projector/variant content hashes. This is +not the historical Qwen experiment or a claim of equal model behavior. No new +runtime upgrade is selected. The ML runtime compatibility matrix remains +unexecuted; core Rust/Python qualification does not cover it. + +## Paired schedule + +A new scratch Store registers BEFORE policy, two distinct GREEN observations A +and B, and an unadmitted RED replacement. Three real generations would produce +independent A and B report verdicts and the initial A-based release plan. The +closed Store checkpoint is copied into independent scenario stores. Full +recomputation uses a separate fresh Store without any prior model output. + +| Condition | Store change | Repair calls | Full recomputation calls | +| --- | --- | ---: | ---: | +| Report correction | Withdraw A/B, admit RED | 2 | 2 | +| Unrelated policy change | BEFORE to AFTER; A/B remain admitted | 1 | 2 | +| Withdrawal | Withdraw A/B; no replacement | 0 | 0 | +| Alternative support | Withdraw A; B remains admitted | 1 | 2 | + +The entire successful path has 13 generations including the shared three-call +bootstrap. The two skipped report calls are Store-authorized reuse hits with +original attempt lineage. The surviving B result can only use B's independently +validated origin, never A's withdrawn result. `A OR B` is checked against an +independent admission-set oracle; that deterministic support flag is not model +output and does not itself authorize opaque model reuse. + +Repair/fresh order alternates by condition. Both tasks use the same model, +decoding parameters and source selection rule. The second arm's exact request +bytes must equal the first arm's corresponding bytes **before dispatch**. Both +checked structured outputs must agree. Actual planner inputs come from the +actual validated model verdict, never an expected-answer fixture. Frozen prompt +examples are unchanged. The existing scoped-example validator rejects duplicate +keys, unexpected fields and inconsistent values; it retains that example's +acceptance of an outer JSON Markdown fence, so this is not a claim of raw-JSON +compliance. + +A rejected bootstrap stops execution and records all remaining slots and +conditions as unexecuted. Transport uncertainty also stops execution. There is +no retry, warmup, resampling, checkpoint resume or fallback model. A withdrawal +without surviving evidence causes infrastructure refusal before generation; it +is not a model's semantic abstention. + +## Execution and authority + +The public Python CLI supports `freeze`, `fixture`, and read-only `audit`. It has +no live option. The Rust `--bridge` mode opens no network connection; it emits +fixed requests on stdout and waits for measured replies on stdin. + +A trusted root caller must construct `LiveApproval` separately from artifact +contents, binding the exact source commit, executable SHA256, configuration +SHA256 and independent-review SHA256, then call `run_live`. A JSON field cannot +grant execution. This object is a caller attestation, not an unforgeable +capability against arbitrary same-user code. Source must be clean and match the +reviewed freeze; runtime, binary and full cached assets are checked again. + +Example offline qualification, using fresh project storage admission: + +```sh +python3 scripts/project_runtime.py --budget-gib 2 cargo test --offline --locked \ + --example controlled_correction_pilot +python3 scripts/project_runtime.py python -m unittest discover -s scripts \ + -p test_controlled_correction_pilot.py +python3 scripts/project_runtime.py --budget-gib 2 cargo build --offline --locked \ + --example controlled_correction_pilot --message-format=json +``` + +For compiled IPC tests, set `KAIROTENSOR_PILOT_TEST_BINARY` to that exact built +example while running the Python suite. This test-only variable enables three +zero-model integration tests; without it, that class is explicitly skipped. +The public fixture command invokes the binary's deterministic adapter and labels +its accounting units synthetic: + +```sh +python3 scripts/project_runtime.py python scripts/run_controlled_correction_pilot.py \ + fixture --binary /absolute/built/example --out /absolute/new/artifact-directory +python3 scripts/project_runtime.py python scripts/run_controlled_correction_pilot.py \ + freeze --binary /absolute/built/example --out /absolute/new/execution-freeze.json +``` + +Freeze only checks source/runtime/asset identities and does not start a model. +After review, root's trusted invocation is: + +```python +from pathlib import Path +from run_controlled_correction_pilot import LiveApproval, run_live, sha +config = Path('/absolute/execution-freeze.json') +# These values come from root's independent review, not from an untrusted manifest. +approval = LiveApproval(reviewed_commit, reviewed_binary_sha256, + sha(config), reviewed_review_sha256) +result = run_live(config, Path('/absolute/new/live-directory'), approval=approval) +``` + +Invoke this through the accepted project Python and a fresh `workstation-storage` +(or still-valid scoped project guard) `preflight` plus `run` reservation. The +source freeze is not storage admission. Suggested artifact growth is <=32 MiB +with a 1 GiB reservation for the pilot/runtime layer; Cargo has a separate 2 GiB +reservation. A failed admission blocks the run. Preserve all failed receipts. +No dependency install, model pull, training job, provider key or shared-runtime +change is allowed. + +## Runtime and bounds + +The supervisor creates a uniquely named owned container from the cached image +with `--pull=never`, a read-only root and model mount, explicit writable `/tmp` +and `/root/.ollama` tmpfs, 2 CPU quota, inherited affinity (no fixed cpuset), 12 GiB RAM, no GPU +devices, one loaded model and one parallel request. The supported network backend is `pasta:--no-map-gw`. The endpoint is only +`127.0.0.1:11445`; the existing shared service is untouched. Local cloud mode is +disabled and the adapter exposes neither pull nor arbitrary endpoint/model +selection. Loopback publication and this API restriction do not establish a +network-egress sandbox; the container network still has ordinary outbound +connectivity. No credentials are mounted or read. + +Readiness captures `/api/version`, `/api/tags`, `/api/show`, `/api/ps` and owned +container identity. It requires an empty loaded-model list initially. The cached +GGUF template explicitly supports disabling thinking. Every reply is followed by +`/api/ps`, requiring the selected model digest, `size_vram=0`, and observed +context length at most 2,048. Unexpected runtime identity stops execution after +retaining the already returned response/usage. + +Fixed request settings are seed 0, temperature 0, top_k 1, top_p 1, 96 requested +output tokens, context 2,048, two threads, num_gpu 0, think false, truncate false, +shift false and nonstreaming output. No answer grammar or oracle is supplied. +The exact installed-version [request API source](https://raw.githubusercontent.com/ollama/ollama/v0.40.16/api/types.go) +exposes the runtime fields, while [Ollama's chat API](https://docs.ollama.com/api/chat) +documents usage and duration fields. Definitions and metadata alone do not prove +the actual loaded model honored every setting; receipts and runtime observations +are necessary and mismatches fail closed. + +Limits are 13 durable generation claims, one in flight, 120 seconds of total elapsed time per HTTP +request (including slow streaming bodies), and one original 1,800-second BOOTTIME window starting before identity +verification/startup/load. No new work begins in the last 60 seconds. An +independent watchdog process observes the original absolute deadline and parent +pipe loss and kills only the named owned runtime. Conmon's container timeout starts at container startup and is a runtime-duration +backstop; the independent BOOTTIME watcher enforces the original absolute deadline. The Rust, HTTP transport and Podman creation children bind the expected parent PID +before fork and use parent-death SIGKILL. Normal cleanup kills/reaps owned process +groups. On parent loss during creation, the independent watcher kills the bound +startup group and reconciles a late container through the original deadline; +absence without observed stopped state is unresolved cleanup, never success. Deadline overrun is explicitly incomplete. Kernel hangs, +failed container-control commands and exact hard-real-time kill are not promised. +Stopped owned containers are retained for later explicit retirement. + +**Token-envelope narrowing authorized by root:** Ollama chat has no trusted +pre-dispatch tokenizer quote here. Therefore 2,048 input tokens per request, +2,144 combined quote units per claim, and 27,872 aggregate quote units are +configured/observed accounting envelopes, **not proven hard token budgets or +provider billing bounds**. Every returned count is retained without clamping, +including excess. Excess, missing/faulty usage, unexpected thinking, nonfinal +responses and ambiguous transport stop the run. Unknown claims retain the +administrative 2,144-unit hold, with actual additional liability explicitly +unbounded/unknown. There is no automatic release or redispatch. Model-provider +spend is zero for this local path; workstation CPU/electricity are unpriced. + +## Evidence and interpretation + +The supervisor persists each claim before HTTP I/O. A separate transport subprocess +streams response chunks to the parent, which independently syncs them before parsing. +An absolute deadline kills/reaps that owned transport process, preserving partial +raw bytes. Readable counts in an uncertain response remain observed usage while +its hold stays unresolved. Known partial usage remains an observation and +does not reconcile unknown final liability. Records include immutable claims, +raw receipts, usage reconciliation, runtime readiness and per-call observations, +watchdog/cleanup results, Store SQLite files/events and final outcome scheduling. +Audit is read-only and refuses corrupt accounting rather than inventing totals. +Simultaneous storage loss cannot guarantee a receipt that existed only in memory; +a prior durable claim stays unresolved. + +Rust Store charges for typed support checks use their existing deterministic +units; never sum those with provider token counts as though the entire Store +ledger were homogeneous. The external pilot ledger reports provider-observed +model usage separately. Invalid semantic/model replies remain charged and cannot +publish a head. A complete ledger does not establish a correct model answer. + +Report marginal repair and full-recompute model usage separately (expected valid +path calls 4 versus 6), followed by the actual shared 3-call bootstrap and full +13-call aggregate. Attribute the same shared prefix to each hypothetical +lifecycle comparison without double-charging it in actual-run totals. Include +cold/load time, preparation, failed/partial/unexecuted outcomes and original +deadline. One correlated synthetic case per condition cannot establish a latency +distribution, production benefit, semantic generalization, model necessity, +incident LIVE Store integration or held-out efficacy. Arithmetic report verdicts +still have the existing deterministic product route. + + +## Qualification operational notes + +Root's no-generation cached-runtime probe succeeded with `pasta:--no-map-gw`, +CPU quota 2 without a fixed cpuset, and the read-only/tmpfs settings above. +Version, selected digest, empty loaded-model state and template metadata were +verified, then that owned runtime was stopped. Earlier slirp4netns and cpuset +attempts were refused by the installed Podman/cgroup setup and retained as failed +receipts. These probes did not load or execute the model; CPU/token behavior +remains subject to actual run observations. + +During implementation, a host `rustfmt` command unexpectedly resolved through +rustup, which announced three component downloads and auto-installed a missing +host Rust 1.100.0 toolchain before reporting rustfmt unavailable. The formatting +command did not run. This was outside the planned no-download scope; an incident +receipt is retained and no cleanup was performed. No model download occurred. +The accepted project runtime remains separately pinned and is rechecked before +handoff; this side effect must not be described as a download-free overall task. diff --git a/examples/controlled_correction_pilot.rs b/examples/controlled_correction_pilot.rs new file mode 100644 index 0000000..d6cb867 --- /dev/null +++ b/examples/controlled_correction_pilot.rs @@ -0,0 +1,273 @@ +//! Isolated calibration pilot. No network access; LIVE transport belongs to the reviewed supervisor. +#[path = "controlled_correction_pilot/adapter.rs"] mod adapter; +use adapter::{Backend, Reply}; +use kairotensor::{Current, Disposition, ModelAction, Store}; +use serde::{de::DeserializeOwned, Deserialize, Serialize}; +use serde_json::{json,Value}; +use std::{fs,io::Write,path::{Path,PathBuf},time::Instant}; +type Result = std::result::Result>; +const ACTOR:&str="release-planner"; +const SCOPE:&str="R42"; +const CONTRACT:&str="ci-report-extractor/2+strict-verdict-validator/1+ollama-pilot/1"; +const SLOTS:[&str;13]=["bootstrap/report-a","bootstrap/report-b","bootstrap/plan", + "report_correction/repair/report","report_correction/repair/plan", + "report_correction/fresh/report","report_correction/fresh/plan", + "unrelated_policy_change/fresh/report","unrelated_policy_change/fresh/plan", + "unrelated_policy_change/repair/plan","alternative_support/fresh/report", + "alternative_support/fresh/plan","alternative_support/repair/plan"]; +const BEFORE: &[u8] = br#"{"version":"policy/v1","release":"R42","target":"staging","approval":"S42-A"}"#; +const AFTER: &[u8] = br#"{"version":"policy/v2","release":"R42","target":"canary","approval":"C42-B"}"#; +const GREEN: &[u8] = br#"{"version":"run/17","release":"R42","test_summary":"12/12","failing_cases":0}"#; +const RED: &[u8] = br#"{"version":"run/18","release":"R42","test_summary":"11/12","failing_cases":1}"#; +// The same balanced examples are shown for every run and release. +const REPORT_PROMPT: &str = r#"Extract the release test verdict. Even ONE failing case makes the entire verdict "fail". +CI example A: {"release":"EX1","test_summary":"7/8","failing_cases":1} -> {"release":"EX1","tests":"7/8","status":"fail"} +CI example B: {"release":"EX2","test_summary":"8/8","failing_cases":0} -> {"release":"EX2","tests":"8/8","status":"pass"} +Read the user's ci_report. Copy release and test_summary. If failing_cases is positive use "fail"; only zero uses "pass". Return only JSON with keys release, tests, status."#; +const PLAN_PROMPT: &str = r#"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {"status":"pass"} means {"action":"deploy"}; {"status":"fail"} means {"action":"hold"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation."#; + +#[derive(Debug, PartialEq, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct Verdict { release: String, tests: String, status: String } + +#[derive(Debug, PartialEq, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +struct Plan { release: String, target: String, approval: String, tests: String, action: String } + +fn parse_answer(text: &str) -> Result { + let text = text.trim(); + let body = if let Some(inner) = text.strip_prefix("```json\n") { + inner.strip_suffix("```").ok_or("unclosed JSON fence")?.trim() + } else { text }; + Ok(serde_json::from_str(body)?) +} + +fn field<'a>(value: &'a Value, name: &str) -> Result<&'a str> { + value[name].as_str().ok_or_else(|| format!("missing source field {name}").into()) +} + +fn validate_verdict(text: &str, report: &Value) -> Result { + let actual: Verdict = parse_answer(text)?; + let failed = report["failing_cases"].as_u64().ok_or("missing problem count")?; + let status = if failed == 0 { "pass" } else { "fail" }; + if actual.release != field(report, "release")? || actual.tests != field(report, "test_summary")? + || actual.status != status { + return Err("test verdict disagrees with captured evidence".into()); + } + Ok(actual) +} + +fn validate_plan(text: &str, requirement: &Value, verdict: &Verdict) -> Result { + let actual: Plan = parse_answer(text)?; + let action = if verdict.status == "pass" { "deploy" } else { "hold" }; + if actual.release != field(requirement, "release")? || actual.release != verdict.release + || actual.target != field(requirement, "target")? || actual.approval != field(requirement, "approval")? + || actual.tests != verdict.tests || actual.action != action { + return Err("release plan failed the checklist".into()); + } + Ok(actual) +} + +fn write_new(path:&Path,value:&Value)->Result<()> { + let mut f=fs::OpenOptions::new().write(true).create_new(true).open(path)?; + serde_json::to_writer(&mut f,value)?;f.write_all(b"\n")?;f.sync_all()?; + fs::File::open(path.parent().ok_or("missing parent")?)?.sync_all()?;Ok(()) +} +struct Journal<'a> { out:&'a Path, next:usize, dispatches:u64, reuse_hits:u64, backend:&'a mut dyn Backend, pairs:std::collections::BTreeMap> } +impl<'a> Journal<'a> { + fn new(out:&'a Path,backend:&'a mut dyn Backend)->Self {Self{out,next:0,dispatches:0,reuse_hits:0,backend,pairs:std::collections::BTreeMap::new()}} + fn event(&mut self,value:Value)->Result<()> {self.next+=1;write_new(&self.out.join(format!("event-{:03}.json",self.next)),&value)} + fn deliver(&mut self,store:&mut Store,attempt:i64,request:&[u8],context:Value, + check:impl Fn(&str)->Result,validator:&str,reuse:bool)->Result<(T,String,i64,bool)> { + if let Some((case,_))=context["route"].as_str().and_then(|r|r.rsplit_once('/')) { + let key=format!("{case}/{}",context["task"].as_str().ok_or("missing task")?); + if let Some(previous)=self.pairs.get(&key) { + if previous!=request {return Err("paired request mismatch before dispatch".into());} + }else{self.pairs.insert(key,request.to_vec());} + } + self.event(json!({"kind":"prepared","attempt":attempt,"context":context, + "request_utf8":std::str::from_utf8(request)?}))?; + let action=if reuse {store.resolve_model_attempt(attempt,request)?} else { + store.record_dispatch(attempt,request)?;ModelAction::Dispatch + }; + match action { + ModelAction::Reused{origin_attempt,output}=>{ + let text=String::from_utf8(output)?;let value=check(&text)?; + self.reuse_hits+=1; + self.event(json!({"kind":"reused","attempt":attempt,"origin":origin_attempt, + "context":context,"output":text,"new_usage":0}))?; + Ok((value,text,origin_attempt,true)) + }, + ModelAction::Dispatch=>{ + if self.dispatches>=13{return Err("global call ceiling".into());} + self.dispatches+=1; + self.event(json!({"kind":"dispatch","ordinal":self.dispatches,"attempt":attempt,"context":context}))?; + let start=Instant::now(); + let Reply{text,input,output}=match self.backend.dispatch(request) { + Ok(reply)=>reply, + Err(error)=>{self.event(json!({"kind":"uncertain","attempt":attempt, + "context":context,"error":error.to_string()}))?;return Err(error);} + }; + let usage=i64::try_from(input.checked_add(output).ok_or("usage overflow")?)?; + self.event(json!({"kind":"received","attempt":attempt,"context":context,"output":text, + "input_units":input,"output_units":output,"roundtrip_us":start.elapsed().as_micros()}))?; + let value=match check(&text) { + Ok(v)=>v, + Err(error)=>{ + let disposition=store.reject_invalid(attempt,text.as_bytes(),usage,validator,&error.to_string())?; + self.event(json!({"kind":"invalid_output","attempt":attempt,"context":context, + "usage":usage,"store_disposition":format!("{disposition:?}")}))?; + return Err(error); + } + }; + let disposition=store.settle(attempt,text.as_bytes(),usage)?; + self.event(json!({"kind":"settled","attempt":attempt,"context":context, + "usage":usage,"store_disposition":format!("{disposition:?}")}))?; + if disposition!=Disposition::Accepted{return Err("noncurrent publication".into());} + Ok((value,text,attempt,false)) + } + } + } +} +#[derive(Clone,Copy)] struct Ids{policy:i64,a:i64,b:i64,red:i64,after:i64} +fn setup(path:&Path)->Result<(Store,Ids)> { + let mut s=Store::open(path)?; + let ids=s.observe_and_admit_many(ACTOR,SCOPE,&[("policy/v1",BEFORE),("run/17-a",GREEN),("run/17-b",GREEN)])?; + let red=s.observe("run/18",RED)?;let after=s.observe("policy/v2",AFTER)?; + s.publish_support(ACTOR,SCOPE,"alternative-support",&[vec![ids[1]],vec![ids[2]]])?; + Ok((s,Ids{policy:ids[0],a:ids[1],b:ids[2],red,after})) +} +struct Certificate { value:Verdict,raw:String,attempt:i64,origin:i64,request:Vec,report:i64,branch:String,hit:bool } +fn certificate(s:&mut Store,j:&mut Journal<'_>,ids:Ids,branch:&str,context:&str,reuse:bool)->Result> { + let candidates=if branch=="report-b" {vec![ids.b]}else{vec![ids.a,ids.red]}; + let (attempt,captured)=if reuse {s.begin_model_attempt(ACTOR,SCOPE,branch,&candidates,CONTRACT)?} + else {s.begin_from_candidates(ACTOR,SCOPE,branch,&candidates)?}; + if captured.is_empty(){j.event(json!({"kind":"unavailable_evidence","context":context,"attempt":attempt}))?;return Ok(None);} + let [(report,payload)]=captured.as_slice() else{return Err("ambiguous report capture".into())}; + let value:Value=serde_json::from_slice(payload)?; + let request=adapter::freeze(REPORT_PROMPT,json!({"ci_report":value}))?; + let (verdict,raw,origin,hit)=j.deliver(s,attempt,&request,json!({"route":context,"task":branch}), + |text|validate_verdict(text,&value),"strict-verdict-validator/1",reuse)?; + Ok(Some(Certificate{value:verdict,raw,attempt,origin,request,report:*report,branch:branch.to_owned(),hit})) +} +fn plan(s:&mut Store,j:&mut Journal<'_>,policy:i64,cert:&Certificate,context:&str)->Result<(Plan,Vec)> { + let required=[policy,cert.report]; + let (attempt,captured)=s.begin_from_candidates(ACTOR,SCOPE,"release-plan",&required)?; + if captured.iter().map(|(id,_)|*id).ne(required) || s.read_current(ACTOR,SCOPE,&cert.branch)?!=Current::Ready(cert.raw.as_bytes().to_vec()) { + return Err("planner capture or certificate not current".into()); + } + let requirement:Value=serde_json::from_slice(&captured[0].1)?; + let report:Value=serde_json::from_slice(&captured[1].1)?; + let request=adapter::freeze(PLAN_PROMPT,json!({"requirement":requirement, + "test_certificate":cert.value,"report_version":report["version"]}))?; + let (answer,_,_,_)=j.deliver(s,attempt,&request,json!({"route":context,"task":"release-plan","certificate_attempt":cert.attempt}), + |text|validate_plan(text,&requirement,&cert.value),"scoped-release-plan-checklist/1",false)?; + Ok((answer,request)) +} +fn route(s:&mut Store,j:&mut Journal<'_>,ids:Ids,case:&str,reuse:bool)->Result { + let start=Instant::now();let offset=j.dispatches; + let context=format!("{case}/{}",if reuse{"repair"}else{"fresh"}); + // Selection is based only on actual admitted source capture, never a label/output. + let (_,primary)=s.begin_from_candidates(ACTOR,SCOPE,"selection-primary",&[ids.a,ids.red])?; + let branch=if primary.is_empty(){"report-b"}else{"report-a"}; + let (_,policies)=s.begin_from_candidates(ACTOR,SCOPE,"selection-policy",&[ids.policy,ids.after])?; + let [(policy,_)]=policies.as_slice() else{return Err("expected one current policy".into())}; + let Some(cert)=certificate(s,j,ids,branch,&context,reuse)? else { + if matches!(s.read_current(ACTOR,SCOPE,"release-plan")?,Current::Ready(_)){return Err("withdrawn planner still readable".into());} + return Ok(json!({"outcome":"unavailable_evidence","dispatches":0,"plan":null,"requests":[]})); + }; + let (answer,request)=plan(s,j,*policy,&cert,&context)?; + Ok(json!({"outcome":"accepted","dispatches":j.dispatches-offset,"report_branch":branch, + "origin":cert.origin,"reused":cert.hit,"plan":answer,"route_us":start.elapsed().as_micros(), + "requests":[std::str::from_utf8(&cert.request)?,std::str::from_utf8(&request)?]})) +} +fn mutate(s:&mut Store,ids:Ids,case:&str)->Result { + match case { + "report_correction"=>{s.set_admitted(ACTOR,SCOPE,ids.a,false)?;s.set_admitted(ACTOR,SCOPE,ids.b,false)?;s.set_admitted(ACTOR,SCOPE,ids.red,true)?;}, + "unrelated_policy_change"=>{s.set_admitted(ACTOR,SCOPE,ids.policy,false)?;s.set_admitted(ACTOR,SCOPE,ids.after,true)?;}, + "withdrawal"=>{s.set_admitted(ACTOR,SCOPE,ids.a,false)?;s.set_admitted(ACTOR,SCOPE,ids.b,false)?;}, + "alternative_support"=>{s.set_admitted(ACTOR,SCOPE,ids.a,false)?;}, + _=>return Err("unknown scenario".into()) + } + s.revise_support(ACTOR,SCOPE,"alternative-support")?; + let (_,active)=s.begin_from_candidates(ACTOR,SCOPE,"support-oracle",&[ids.a,ids.b])?; + let oracle=!active.is_empty(); + let expected=if oracle{b"supported".to_vec()}else{b"unsupported".to_vec()}; + if s.read_current(ACTOR,SCOPE,"alternative-support")?!=Current::Ready(expected){return Err("typed support differs from admission oracle".into());} + if matches!(s.read_current(ACTOR,SCOPE,"release-plan")?,Current::Ready(_)){return Err("old planner unexpectedly current".into());} + Ok(oracle) +} +fn snapshot(source:&Path,target:&Path)->Result<()> { + // Store uses rollback journaling. Only copy a closed, complete database. + for suffix in ["-wal","-journal"] { + if PathBuf::from(format!("{}{suffix}",source.display())).exists(){return Err("uncheckpointed Store".into());} + } + let check=rusqlite::Connection::open_with_flags(source,rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY)?; + let integrity:String=check.query_row("PRAGMA integrity_check",[],|r|r.get(0))?; + if integrity!="ok"{return Err("checkpoint integrity failure".into());}drop(check); + let mut input=fs::File::open(source)?;let mut output=fs::OpenOptions::new().create_new(true).write(true).open(target)?; + std::io::copy(&mut input,&mut output)?;output.sync_all()?;Ok(()) +} +fn run_pilot(out:&Path,backend:&mut dyn Backend)->Result { + fs::create_dir(out)?; + let mode=backend.mode().to_owned(); + let result=run_owned(out,backend); + let mut report=match &result {Ok(value)=>value.clone(),Err(error)=>json!({"complete":false,"error":error.to_string(),"mode":mode})}; + let mut dispatched=0usize; + let mut completed=std::collections::BTreeSet::new(); + for entry in fs::read_dir(out)? { + let path=entry?.path(); + if !path.file_name().and_then(|n|n.to_str()).is_some_and(|n|n.starts_with("event-")){continue;} + let value:Value=serde_json::from_slice(&fs::read(path)?)?; + if value["kind"]=="dispatch"{dispatched+=1;} + if value["kind"]=="pair_complete" {completed.insert(value["result"]["scenario"].as_str().ok_or("missing scenario")?.to_owned());} + } + report["unexecuted_slots"]=json!(&SLOTS[dispatched.min(SLOTS.len())..]); + report["unexecuted_scenarios"]=json!(["report_correction","unrelated_policy_change","withdrawal","alternative_support"] + .into_iter().filter(|name|!completed.contains(*name)).collect::>()); + report["rust_dispatch_intents"]=json!(dispatched); + write_new(&out.join("result.json"),&report)?; + result +} +fn run_owned(out:&Path,backend:&mut dyn Backend)->Result { + write_new(&out.join("manifest.json"),&json!({"schema":"controlled-correction-pilot/1","mode":backend.mode(), + "model":adapter::MODEL,"model_digest":adapter::DIGEST,"max_calls":13,"planned_slots":SLOTS, + "dataset":"existing scoped_model_reuse fixtures", + "accounting_units":if backend.mode()=="offline_fixture"{"synthetic fixture units"}else{"provider reported tokens"}}))?; + let mut j=Journal::new(out,backend); + let base=out.join("bootstrap.sqlite");let (mut original,ids)=setup(&base)?; + let a=certificate(&mut original,&mut j,ids,"report-a","bootstrap",true)?.ok_or("bootstrap A absent")?; + let b=certificate(&mut original,&mut j,ids,"report-b","bootstrap",true)?.ok_or("bootstrap B absent")?; + plan(&mut original,&mut j,ids.policy,&a,"bootstrap")?; + drop(original); + let bootstrap=json!({"a_origin":a.origin,"b_origin":b.origin,"dispatches":j.dispatches}); + let mut scenarios=Vec::new(); + for (case,repair_first) in [("report_correction",true),("unrelated_policy_change",false),("withdrawal",true),("alternative_support",false)] { + let repair_path=out.join(format!("{case}-repair.sqlite"));snapshot(&base,&repair_path)?; + let mut repair=Store::open(&repair_path)?; + let (mut fresh,fresh_ids)=setup(&out.join(format!("{case}-fresh.sqlite")))?; + let support=mutate(&mut repair,ids,case)?; + if mutate(&mut fresh,fresh_ids,case)?!=support{return Err("different final support views".into());} + let (r,f)=if repair_first { + let r=route(&mut repair,&mut j,ids,case,true)?;let f=route(&mut fresh,&mut j,fresh_ids,case,false)?;(r,f) + }else{ + let f=route(&mut fresh,&mut j,fresh_ids,case,false)?;let r=route(&mut repair,&mut j,ids,case,true)?;(r,f) + }; + if r["requests"]!=f["requests"] || r["plan"]!=f["plan"] || r["outcome"]!=f["outcome"] { + return Err("paired requests or checked outputs differ".into()); + } + let row=json!({"scenario":case,"typed_support":support,"repair":r,"fresh":f,"requests_equal":true}); + j.event(json!({"kind":"pair_complete","result":row}))?;scenarios.push(row); + } + Ok(json!({"complete":true,"mode":j.backend.mode(),"dispatches":j.dispatches,"reuse_hits":j.reuse_hits, + "bootstrap":bootstrap,"scenarios":scenarios})) +} +fn main()->Result<()> { + let mut args=std::env::args().skip(1); + let mode=args.next().ok_or("use --fixture or --bridge, followed by a new output directory")?; + let out=PathBuf::from(args.next().ok_or("missing output directory")?); + if args.next().is_some(){return Err("unexpected argument".into());} + let mut backend:Box=match mode.as_str(){"--fixture"=>Box::new(adapter::Fixture),"--bridge"=>Box::new(adapter::Bridge::new()),_=>return Err("invalid mode".into())}; + run_pilot(&out,backend.as_mut()).map(|_|()) +} +#[cfg(test)] #[path = "controlled_correction_pilot/tests.rs"] mod tests; diff --git a/examples/controlled_correction_pilot/adapter.rs b/examples/controlled_correction_pilot/adapter.rs new file mode 100644 index 0000000..b89b583 --- /dev/null +++ b/examples/controlled_correction_pilot/adapter.rs @@ -0,0 +1,57 @@ +//! Fixed request/IPC boundary. This module cannot open a network connection. +use super::{Result, REPORT_PROMPT, PLAN_PROMPT}; +use serde_json::{json, Value}; +use std::io::{BufRead, Read, Write}; +pub const MODEL: &str = "ornith-1.5:9b"; +pub const DIGEST: &str = "e5df7dcdd8a263994df62d610317e07be0d6af23f96fcbd8543273058fce575e"; +pub struct Reply { pub text: String, pub input: u64, pub output: u64 } +pub trait Backend { fn mode(&self)->&str; fn dispatch(&mut self, request:&[u8])->Result; } +pub fn freeze(system:&str,evidence:Value)->Result> { + if system!=REPORT_PROMPT && system!=PLAN_PROMPT { return Err("unexpected prompt".into()); } + Ok(serde_json::to_vec(&json!({"model":MODEL,"runner":"ggml","stream":false, + "think":false,"truncate":false,"shift":false,"keep_alive":"10m", + "options":{"seed":0,"temperature":0,"top_k":1,"top_p":1,"num_ctx":2048, + "num_predict":96,"num_thread":2,"num_gpu":0}, + "messages":[{"role":"system","content":system}, + {"role":"user","content":serde_json::to_string(&evidence)?}]}))?) +} +pub struct Fixture; +impl Backend for Fixture { + fn mode(&self)->&str { "offline_fixture" } + fn dispatch(&mut self,request:&[u8])->Result { + let envelope:Value=serde_json::from_slice(request)?; + let data:Value=serde_json::from_str(envelope["messages"][1]["content"].as_str().ok_or("missing evidence")?)?; + let result=if let Some(r)=data.get("ci_report") { + json!({"release":r["release"],"tests":r["test_summary"], + "status":if r["failing_cases"]==0 {"pass"} else {"fail"}}) + } else { + let (p,v)=(&data["requirement"],&data["test_certificate"]); + json!({"release":p["release"],"target":p["target"],"approval":p["approval"], + "tests":v["tests"],"action":if v["status"]=="pass" {"deploy"}else{"hold"}}) + }; + // Synthetic accounting units, deliberately unrelated to tokenizer measurements. + Ok(Reply{text:result.to_string(),input:1,output:1}) + } +} +pub struct Bridge { ordinal:u64 } +impl Bridge { pub fn new()->Self {Self{ordinal:0}} } +impl Backend for Bridge { + fn mode(&self)->&str { "trusted_local_bridge" } + fn dispatch(&mut self,request:&[u8])->Result { + self.ordinal+=1; + if self.ordinal>13 {return Err("call limit".into());} + let row=json!({"op":"generate","ordinal":self.ordinal,"model_digest":DIGEST, + "request_utf8":std::str::from_utf8(request)?}); + let mut stdout=std::io::stdout().lock(); + writeln!(stdout,"{row}")?;stdout.flush()?;drop(stdout); + let mut line=String::new(); + let read=std::io::stdin().lock().take(1_048_577).read_line(&mut line)?; + if read==0 || line.len()>1_048_576 {return Err("missing or oversized bridge reply".into());} + let reply:Value=serde_json::from_str(&line)?; + if reply["ordinal"]!=self.ordinal || reply["ok"]!=true {return Err("bridge refused or uncertain delivery".into());} + let input=reply["input_tokens"].as_u64().ok_or("missing measured input usage")?; + let output=reply["output_tokens"].as_u64().ok_or("missing measured output usage")?; + if input==0 || input>2048 || output==0 || output>96 {return Err("observed usage outside envelope".into());} + Ok(Reply{text:reply["text"].as_str().ok_or("missing text")?.to_owned(),input,output}) + } +} diff --git a/examples/controlled_correction_pilot/tests.rs b/examples/controlled_correction_pilot/tests.rs new file mode 100644 index 0000000..256d6e3 --- /dev/null +++ b/examples/controlled_correction_pilot/tests.rs @@ -0,0 +1,70 @@ +use super::*; +use std::sync::atomic::{AtomicU64, Ordering}; +static NEXT: AtomicU64 = AtomicU64::new(0); +struct Scratch(PathBuf); +impl Scratch { + fn new() -> Self { Self(std::env::temp_dir().join(format!("kt-pilot-{}-{}",std::process::id(),NEXT.fetch_add(1,Ordering::Relaxed)))) } +} +impl Drop for Scratch { fn drop(&mut self) { let _=fs::remove_dir_all(&self.0); } } + +#[test] +fn actual_store_pairs_recompute_and_refuse_withdrawn_origins() { + let scratch=Scratch::new(); + let result=run_pilot(&scratch.0,&mut adapter::Fixture).expect("pilot must execute the Store scenarios"); + assert_eq!(result["dispatches"],13); + assert_eq!(result["reuse_hits"],2); + assert_eq!(result["scenarios"].as_array().unwrap().len(),4); + let cases=result["scenarios"].as_array().unwrap(); + assert_eq!(cases[0]["repair"]["plan"]["action"],"hold"); + assert_eq!(cases[1]["repair"]["plan"]["target"],"canary"); + assert_eq!(cases[2]["repair"]["outcome"],"unavailable_evidence"); + assert_eq!(cases[2]["fresh"]["dispatches"],0); + assert_eq!(cases[3]["repair"]["report_branch"],"report-b"); + assert_eq!(cases[3]["repair"]["origin"],result["bootstrap"]["b_origin"]); + assert_ne!(cases[3]["repair"]["origin"],result["bootstrap"]["a_origin"]); + for (case,support) in cases.iter().zip([false,true,false,true]) { + assert_eq!(case["typed_support"],support); + assert_eq!(case["requests_equal"],true); + assert_eq!(case["repair"]["requests"],case["fresh"]["requests"]); + assert_eq!(case["repair"]["plan"],case["fresh"]["plan"]); + } + assert!(run_pilot(&scratch.0,&mut adapter::Fixture).is_err(),"existing evidence cannot be overwritten"); +} + +#[test] +fn paired_mismatch_is_refused_before_second_dispatch() { + let scratch=Scratch::new();fs::create_dir(&scratch.0).unwrap(); + let mut fixture=adapter::Fixture; + let mut journal=Journal::new(&scratch.0,&mut fixture); + let mut store=Store::in_memory().unwrap(); + let (a,_)=store.begin_from_candidates(ACTOR,SCOPE,"x",&[]).unwrap(); + let green:Value=serde_json::from_slice(GREEN).unwrap(); + let red:Value=serde_json::from_slice(RED).unwrap(); + let first=adapter::freeze(REPORT_PROMPT,json!({"ci_report":green})).unwrap(); + let second=adapter::freeze(REPORT_PROMPT,json!({"ci_report":red})).unwrap(); + journal.deliver(&mut store,a,&first,json!({"route":"paired/repair","task":"report-a"}), + |text|validate_verdict(text,&green),"v",false).unwrap(); + let (b,_)=store.begin_from_candidates(ACTOR,SCOPE,"y",&[]).unwrap(); + assert!(journal.deliver(&mut store,b,&second,json!({"route":"paired/fresh","task":"report-a"}), + |text|validate_verdict(text,&red),"v",false).is_err()); + assert_eq!(journal.dispatches,1,"second mismatched model request must never be sent"); +} + +struct InvalidFirst; +impl Backend for InvalidFirst { + fn mode(&self)->&str {"offline_test_invalid"} + fn dispatch(&mut self,_:&[u8])->Result { + Ok(Reply{text:r#"{"release":"R42","tests":"12/12","status":"fail"}"#.to_owned(),input:7,output:5}) + } +} +#[test] +fn invalid_bootstrap_is_charged_and_every_remaining_slot_is_unexecuted() { + let scratch=Scratch::new(); + assert!(run_pilot(&scratch.0,&mut InvalidFirst).is_err()); + let report:Value=serde_json::from_slice(&fs::read(scratch.0.join("result.json")).unwrap()).unwrap(); + assert_eq!(report["unexecuted_slots"].as_array().map(Vec::len),Some(12)); + assert_eq!(report["unexecuted_scenarios"].as_array().map(Vec::len),Some(4)); + let mut store=Store::open(scratch.0.join("bootstrap.sqlite")).unwrap(); + assert_eq!(store.charged_usage().unwrap(),14); // 12 reply units plus 2 typed support checks. + assert_eq!(store.read_current(ACTOR,SCOPE,"report-a").unwrap(),Current::Empty); +} diff --git a/scripts/run_controlled_correction_pilot.py b/scripts/run_controlled_correction_pilot.py new file mode 100644 index 0000000..cdf1037 --- /dev/null +++ b/scripts/run_controlled_correction_pilot.py @@ -0,0 +1,742 @@ +"""Local, single-shot correction calibration. CLI: freeze/fixture/audit only. + +LIVE needs an explicit trusted-caller LiveApproval; JSON never grants authority. +This is diagnostic accounting, not Store timed admission or a hard token budget. +""" +import argparse +import ctypes +import functools +from dataclasses import dataclass +import hashlib +import json +import math +import os +from pathlib import Path +import platform +import re +import selectors +import shutil +import signal +import subprocess +import sys +import time +import urllib.request +import uuid + +ROOT = Path(__file__).resolve().parents[1] +MODEL = 'ornith-1.5:9b' +MODEL_DIGEST = 'e5df7dcdd8a263994df62d610317e07be0d6af23f96fcbd8543273058fce575e' +MANIFEST_SHA = '4e3abcdcb78587e3709cc65607f590347deb217b5e45f48113734915548d0ef8' +IMAGE = 'docker.io/ollama/ollama@sha256:85b3c895222b1ddc9d63c40b20fc74f37a37593dcbbdfbf28910a925e43ead00' +IMAGE_ID = 'aa25f838bb0303774bc7540716dadd62605fd0724febfccfc511e67ef12274a5' +MODEL_ROOT = Path('/home/neo/Projects/dev-storage/persistent/local-ai/ollama-candidate-0.40.16-20261111/models') +MODEL_MANIFEST = MODEL_ROOT / 'manifests/registry.ollama.ai/library/ornith-1.5/9b' +SERVER = 'http://127.0.0.1:11445' +SOURCE_FILES = ('examples/controlled_correction_pilot.rs', 'examples/controlled_correction_pilot/adapter.rs', + 'examples/controlled_correction_pilot/tests.rs', 'scripts/run_controlled_correction_pilot.py', + 'scripts/test_controlled_correction_pilot.py', 'docs/controlled-correction-pilot.md', + 'Cargo.lock', 'Cargo.toml') +OPTIONS = dict(seed=0, temperature=0, top_k=1, top_p=1, num_ctx=2048, num_predict=96, num_thread=2, num_gpu=0) +ENVELOPE = dict(model=MODEL, runner='ggml', stream=False, think=False, truncate=False, + shift=False, keep_alive='10m', options=OPTIONS) +MAX_BYTES = 1024 * 1024 +SCENARIOS = ('report_correction', 'unrelated_policy_change', 'withdrawal', 'alternative_support') + + +def clock(): + return time.clock_gettime(time.CLOCK_BOOTTIME) + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def unique(pairs): + result = {} + for key, value in pairs: + require(key not in result, 'duplicate JSON key') + result[key] = value + return result + + +def parse(raw): + return json.loads(raw, object_pairs_hook=unique, + parse_constant=lambda _: (_ for _ in ()).throw(ValueError('nonfinite JSON'))) + + +def final_receipt(response): + message = response.get('message') + return (response.get('model') == MODEL and response.get('done') is True and + response.get('done_reason') in ('stop', 'length') and + type(message) is dict and message.get('role') == 'assistant' and + type(message.get('content')) is str and not message.get('thinking') and + not message.get('tool_calls')) + + +def digest(raw): + return hashlib.sha256(raw).hexdigest() + + +def sha(path): + with Path(path).open('rb') as f: + return hashlib.file_digest(f, 'sha256').hexdigest() + + +def write_new(path, value, raw=False): + data = value if raw else (json.dumps(value, sort_keys=True, separators=(',', ':')) + '\n').encode() + with Path(path).open('xb') as f: + f.write(data) + f.flush() + os.fsync(f.fileno()) + fd = os.open(Path(path).parent, os.O_RDONLY | os.O_DIRECTORY) + try: + os.fsync(fd) + finally: + os.close(fd) + + +class Ledger: + """Single in-process execution, no resume. A claim remains held on ambiguity.""" + def __init__(self, out, *, deadline, clock=clock): + self.out, self.deadline, self.clock = Path(out), deadline, clock + self.claims = 0 + self.pending = None + self.blocked = False + + def claim(self, request): + require(not self.blocked and self.pending is None, 'prior claim unresolved or run stopped') + require(self.claims < 13, 'thirteenth call is the last permitted call') + if self.clock() >= self.deadline - 60: + raise TimeoutError('original execution work cutoff reached') + ordinal = self.claims + 1 + # Persistence failure itself stops this process; it never authorizes transport. + self.blocked = True + write_new(self.out / f'claim-{ordinal:02}.json', + dict(ordinal=ordinal, request_utf8=request, request_sha256=digest(request.encode()), + observed_tick=self.clock(), quote_units=2144, quote_is_proven_bound=False)) + self.claims, self.pending, self.blocked = ordinal, ordinal, False + return ordinal + + def receive(self, ordinal, raw): + require(ordinal == self.pending and not self.blocked, 'no matching live claim') + self.blocked = True + tick = self.clock() + raw_path = self.out / f'raw-{ordinal:02}.bin' + if raw_path.exists(): + require(raw_path.is_file() and raw_path.read_bytes() == raw, 'streamed receipt differs from delivered bytes') + else: + write_new(raw_path, raw, raw=True) + require(len(raw) <= MAX_BYTES, 'oversized raw receipt') + response = parse(raw) + require(type(response) is dict, 'response must be object') + input_count, output_count = response.get('prompt_eval_count'), response.get('eval_count') + require(type(input_count) is int and input_count >= 0 and + type(output_count) is int and output_count >= 0, 'missing or malformed measured usage') + message = response.get('message') + final = final_receipt(response) + # Persist measured excess too. Known bad output is not unknown cost or zero cost. + usage = dict(ordinal=ordinal, input_tokens=input_count, output_tokens=output_count, + raw_sha256=digest(raw), received_tick=tick, late=tick >= self.deadline - 60, + within_envelope=0 < input_count <= 2048 and 0 < output_count <= 96, + reconciled=bool(final), transport_complete=True) + write_new(self.out / f'usage-{ordinal:02}.json', usage) + require(usage['within_envelope'], 'observed usage exceeds configured envelope; stopped without clamping') + require(final, 'incomplete, wrong-model or unexpected response; liability remains unresolved') + require(not usage['late'], 'late receipt retained; no further generation') + self.pending, self.blocked = None, False + return dict(ok=True, ordinal=ordinal, text=message['content'], input_tokens=input_count, + output_tokens=output_count) + + def observe_uncertain(self, ordinal): + """Preserve readable usage on a failed transport without releasing its hold.""" + require(ordinal == self.pending, 'no matching uncertain claim') + self.blocked = True + path = self.out/f'raw-{ordinal:02}.bin' + if not path.is_file():return + raw = path.read_bytes() + try: + response = parse(raw) + i, o = response.get('prompt_eval_count'), response.get('eval_count') + except (ValueError, UnicodeError, AttributeError): + return + if type(i) is not int or i < 0 or type(o) is not int or o < 0:return + write_new(self.out/f'usage-{ordinal:02}.json', dict(ordinal=ordinal, + input_tokens=i, output_tokens=o, raw_sha256=digest(raw), received_tick=self.clock(), + late=self.clock() >= self.deadline-60, within_envelope=0 < i <= 2048 and 0 < o <= 96, + reconciled=False, transport_complete=False)) + + +def audit(out): + out = Path(out) + claims = sorted(out.glob('claim-*.json')) + known = 0 + unresolved = 0 + observed_excess = False + for expected, path in enumerate(claims, 1): + claim = parse(path.read_bytes()) + require(path.name == f'claim-{expected:02}.json' and claim['ordinal'] == expected, + 'noncontiguous claims') + require(digest(claim['request_utf8'].encode()) == claim['request_sha256'], 'request digest mismatch') + usage_path = out / f'usage-{expected:02}.json' + if not usage_path.exists(): + unresolved += 1 + continue + usage = parse(usage_path.read_bytes()) + raw = (out / f'raw-{expected:02}.bin').read_bytes() + require(usage['ordinal'] == expected and usage['raw_sha256'] == digest(raw), 'receipt digest mismatch') + response = parse(raw) + i, o = usage['input_tokens'], usage['output_tokens'] + require(type(i) is int and i >= 0 and type(o) is int and o >= 0 and + response.get('prompt_eval_count') == i and response.get('eval_count') == o, + 'usage mismatch') + require(type(usage['transport_complete']) is bool and + usage['reconciled'] == bool(final_receipt(response) and usage['transport_complete']) and + usage['within_envelope'] == (0 < i <= 2048 and 0 < o <= 96), 'receipt classification mismatch') + known += i + o + if usage.get('reconciled') is not True: + unresolved += 1 + observed_excess |= not (0 < i <= 2048 and 0 < o <= 96) + require(len(claims) <= 13, 'claim ceiling exceeded') + require({p.name for p in out.glob('usage-*.json')} <= + {f'usage-{n:02}.json' for n in range(1, len(claims)+1)}, 'orphan usage receipt') + return dict(claims=len(claims), known_tokens=known, unresolved_claims=unresolved, + unresolved_quote_units=2144 * unresolved, observed_excess=observed_excess, + hard_token_liability_bound=None, + accounting_scope='provider-reported local token units; no proven unknown-liability bound') + + +def schedule_outcomes(out, claims): + store = Path(out) / 'store' + manifest = store / 'manifest.json' + slots = parse(manifest.read_bytes()).get('planned_slots', []) if manifest.exists() else [] + completed = set() + for path in sorted(store.glob('event-*.json')): + event = parse(path.read_bytes()) + if event.get('kind') == 'pair_complete': + completed.add(event['result']['scenario']) + return dict(unexecuted_slots=slots[claims:], scenario_outcomes={name: + 'complete' if name in completed else + 'incomplete' if any(slot.startswith(name + '/') for slot in slots[:claims]) else + 'unexecuted' for name in SCENARIOS}) + + +@dataclass(frozen=True) +class LiveApproval: + """Trusted caller attestation, not an unforgeable permission capability.""" + source_commit: str + binary_sha256: str + config_sha256: str + review_sha256: str + + +def run(args, timeout=20): + p = subprocess.run(args, cwd=ROOT, capture_output=True, text=True, timeout=timeout) + if p.returncode: + raise ValueError(f'command failed ({p.returncode}): {args[0]} {args[1] if len(args)>1 else ""}: {p.stderr[-2000:]}') + return p.stdout.strip() + + +def source_identity(): + require(not run(['git', 'status', '--porcelain', '--untracked-files=normal']), 'freeze requires clean source') + return dict(commit=run(['git', 'rev-parse', 'HEAD']), + files={name: sha(ROOT / name) for name in SOURCE_FILES}) + + +def assets(): + require(sha(MODEL_MANIFEST) == MANIFEST_SHA, 'local model manifest changed') + manifest = parse(MODEL_MANIFEST.read_bytes()) + files = [] + for item in [manifest['config'], *manifest['layers']]: + algorithm, value = item['digest'].split(':') + require(algorithm == 'sha256' and re.fullmatch('[0-9a-f]{64}', value), 'bad model digest') + path = MODEL_ROOT / 'blobs' / ('sha256-' + value) + require(path.is_file() and not path.is_symlink() and path.stat().st_size == item['size'], 'missing or changed model file') + require(sha(path) == value, 'model content digest mismatch') + files.append(dict(path=str(path), bytes=item['size'], sha256=value, mtime_ns=path.stat().st_mtime_ns)) + return files + + +def freeze(binary): + binary = Path(binary).resolve() + require(binary.is_file() and os.access(binary, os.X_OK), 'compiled executable required') + podman = Path(shutil.which('podman') or '').resolve() + image = parse(run([str(podman), 'image', 'inspect', IMAGE_ID]))[0] + require(image['Id'].removeprefix('sha256:') == IMAGE_ID, 'image identity changed') + return dict(schema='controlled-correction-execution/1', execution_authorized=False, + source=source_identity(), binary=dict(path=str(binary), sha256=sha(binary)), + python=dict(path=str(Path(sys.executable).resolve()), sha256=sha(sys.executable)), + podman=dict(path=str(podman), sha256=sha(podman)), image=IMAGE, image_id=IMAGE_ID, + model=MODEL, model_digest=MODEL_DIGEST, model_manifest_sha256=MANIFEST_SHA, + model_files=assets(), envelope=ENVELOPE, max_calls=13, wall_seconds=1800, + request_timeout_seconds=120, configured_input_limit=2048, requested_output_limit=96, + aggregate_quote_units=27872, hard_token_budget=False, + platform=platform.platform(), cpu_affinity=sorted(os.sched_getaffinity(0)), + new_model_calls=0, new_training_jobs=0) + + +def verify_config(config, approval): + require(config['schema'] == 'controlled-correction-execution/1' and config['execution_authorized'] is False, + 'configuration cannot grant execution') + require(config['source'] == source_identity() and config['source']['commit'] == approval.source_commit, + 'source no longer matches reviewed candidate') + require(config['binary']['sha256'] == approval.binary_sha256 and + sha(config['binary']['path']) == approval.binary_sha256, 'binary identity mismatch') + require(config['python']['sha256'] == sha(sys.executable), 'actual Python differs from freeze') + require(config['podman']['sha256'] == sha(config['podman']['path']), 'Podman identity changed') + require(config['image'] == IMAGE and config['image_id'] == IMAGE_ID and + config['model'] == MODEL and config['model_digest'] == MODEL_DIGEST and + config['model_manifest_sha256'] == MANIFEST_SHA and config['envelope'] == ENVELOPE, + 'runtime/request contract changed') + require(config['max_calls'] == 13 and config['wall_seconds'] == 1800 and + config['request_timeout_seconds'] == 120 and config['hard_token_budget'] is False, + 'execution bounds changed') + require(config['model_files'] == assets(), 'model assets changed since reviewed freeze') + + +def validate_request(record, ordinal): + require(set(record) == {'op', 'ordinal', 'model_digest', 'request_utf8'} and + record['op'] == 'generate' and record['ordinal'] == ordinal and + record['model_digest'] == MODEL_DIGEST, 'unexpected IPC claim') + raw = record['request_utf8'] + require(type(raw) is str and len(raw.encode()) <= 16384, 'request too large') + request = parse(raw) + require(set(request) == set(ENVELOPE) | {'messages'} and + json.dumps({k: v for k, v in request.items() if k != 'messages'}, sort_keys=True) == + json.dumps(ENVELOPE, sort_keys=True), 'request settings changed') + messages = request['messages'] + require(type(messages) is list and len(messages) == 2 and + all(type(m) is dict and set(m) == {'role', 'content'} and type(m['content']) is str for m in messages) and + [m['role'] for m in messages] == ['system', 'user'], 'unexpected messages') + source = (ROOT / 'examples/controlled_correction_pilot.rs').read_text() + prompts = [re.search(r'const ' + name + r':\s*&str\s*=\s*r#"(.*?)"#;', source, re.S).group(1) + for name in ('REPORT_PROMPT', 'PLAN_PROMPT')] + require(messages[0]['content'] in prompts, 'unfrozen prompt') + data = parse(messages[1]['content']) + require(type(data) is dict and set(data) in ({'ci_report'}, {'requirement', 'test_certificate', 'report_version'}), + 'unexpected task payload') + return raw + + +class HttpFailure(ValueError): + pass + + +def http(path, body=None, timeout=3, raw_path=None): + require(path in ('/api/version', '/api/tags', '/api/ps', '/api/show', '/api/chat'), 'endpoint forbidden') + require(timeout > 0 and math.isfinite(timeout), 'invalid request duration') + deadline = clock() + timeout + payload = json.dumps(dict(url=SERVER+path, body=None if body is None else body.decode(), timeout=timeout)).encode() + worker_code = ('import sys;sys.path.insert(0,sys.argv[1]);' + 'import run_controlled_correction_pilot as p;p.http_worker()') + process = subprocess.Popen([sys.executable, '-c', worker_code, str(ROOT/'scripts')], + stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, + start_new_session=True, preexec_fn=functools.partial(child_setup, os.getpid())) + sink = None + data = bytearray() + header = bytearray() + status = None + try: + if raw_path is not None: + sink = Path(raw_path).open('xb') + sink.flush();os.fsync(sink.fileno()) + fd = os.open(Path(raw_path).parent, os.O_RDONLY | os.O_DIRECTORY) + try:os.fsync(fd) + finally:os.close(fd) + process.stdin.write(payload);process.stdin.close() + with selectors.DefaultSelector() as selector: + selector.register(process.stdout, selectors.EVENT_READ) + eof = False + while not eof: + remaining = deadline-clock() + if remaining <= 0: + raise TimeoutError('absolute HTTP request deadline exceeded; partial receipt retained') + if not selector.select(min(0.05, remaining)): + continue + chunk = os.read(process.stdout.fileno(), 4096) + if not chunk: + eof = True + break + if status is None: + header.extend(chunk) + require(len(header) <= MAX_BYTES, 'invalid HTTP worker header') + if b'\n' not in header: + continue + line, chunk = bytes(header).split(b'\n', 1) + status = parse(line)['status'] + if chunk: + data.extend(chunk) + if sink is not None: + sink.write(chunk);sink.flush();os.fsync(sink.fileno()) + require(len(data) <= MAX_BYTES, 'response exceeds artifact limit') + code = process.wait(timeout=max(0.001, deadline-clock())) + if code != 0 or status != 200: + raise HttpFailure(f'HTTP transport/status failure: exit={code}, status={status}; partial receipt retained') + require(clock() <= deadline, 'HTTP request exceeded its original deadline') + return bytes(data) + finally: + if process.poll() is None: + os.killpg(process.pid, signal.SIGKILL) + process.wait() + if sink is not None:sink.close() + if not process.stdin.closed:process.stdin.close() + process.stdout.close();process.stderr.close() + + +def http_worker(): + """Private subprocess helper; parent enforces elapsed time and saves every chunk.""" + from urllib.parse import urlsplit + value = parse(sys.stdin.buffer.read(32768)) + url = urlsplit(value['url']) + require(url.scheme == 'http' and url.hostname == '127.0.0.1' and not url.username and not url.password, + 'worker only permits unauthenticated loopback HTTP') + body = None if value['body'] is None else value['body'].encode() + request = urllib.request.Request(value['url'], data=body, + headers={'Content-Type': 'application/json'}, method='POST' if body is not None else 'GET') + class NoRedirect(urllib.request.HTTPRedirectHandler): + def redirect_request(self, *args, **kwargs): + raise ValueError('redirect forbidden') + opener = urllib.request.build_opener(urllib.request.ProxyHandler({}), NoRedirect()) + try: + response = opener.open(request, timeout=value['timeout']) + except urllib.error.HTTPError as error: + response = error + with response: + sys.stdout.buffer.write((json.dumps({'status':response.status})+'\n').encode());sys.stdout.buffer.flush() + count = 0 + while True: + chunk = response.read1(1024) + if not chunk: + require(response.length in (None, 0), 'HTTP body ended before Content-Length') + break + count += len(chunk) + sys.stdout.buffer.write(chunk);sys.stdout.buffer.flush() + require(count <= MAX_BYTES, 'oversized HTTP body') + + +def child_setup(expected_parent): + # Owned Rust child dies if this Python controller disappears. No sibling kill. + parent = expected_parent + libc = ctypes.CDLL(None, use_errno=True) + if libc.prctl(1, signal.SIGKILL, 0, 0, 0) != 0 or os.getppid() != parent: + os._exit(127) + + +def read_record(process, deadline): + data = bytearray() + with selectors.DefaultSelector() as selector: + selector.register(process.stdout, selectors.EVENT_READ) + while clock() < deadline - 60: + if not selector.select(min(0.25, max(0, deadline - 60 - clock()))): + continue + chunk = os.read(process.stdout.fileno(), 1) + if not chunk: + if data: + raise ValueError('partial IPC at EOF') + return None + data.extend(chunk) + require(len(data) <= MAX_BYTES, 'oversized IPC') + if chunk == b'\n': + return parse(data) + raise TimeoutError('original work cutoff reached during IPC') + + +def validate_cpu_observation(value): + models = value.get('models') + require(type(models) is list and len(models) == 1, 'expected one owned loaded model') + model = models[0] + require(model.get('name') == MODEL and model.get('digest') == MODEL_DIGEST and + type(model.get('size_vram')) is int and model['size_vram'] == 0 and + type(model.get('context_length')) is int and 0 < model['context_length'] <= 2048, + 'loaded runtime is not the frozen CPU/context configuration') + + +def container_command(podman, name, remaining): + # --timeout is enforced by conmon outside this controller. No shared runtime changes. + return [podman, 'run', '--detach', '--name', name, '--pull=never', '--timeout', str(remaining), + '--cpus', '2', '--memory', '12g', '--memory-swap', '12g', '--restart=no', + '--pids-limit', '128', '--read-only', '--cap-drop=ALL', '--security-opt=no-new-privileges', + '--network=pasta:--no-map-gw', '--publish=127.0.0.1:11445:11434', + '--tmpfs=/root/.ollama:rw,size=16m,mode=700', + '--tmpfs=/tmp:rw,size=256m,mode=1777', + '--mount', f'type=bind,src={MODEL_ROOT},dst=/root/.ollama/models,ro', + '--env=OLLAMA_HOST=0.0.0.0:11434', '--env=OLLAMA_NO_CLOUD=1', + '--env=OLLAMA_MAX_LOADED_MODELS=1', '--env=OLLAMA_NUM_PARALLEL=1', + IMAGE_ID, 'serve'] + + +def process_start(pid): + try: + return Path(f'/proc/{pid}/stat').read_text().rsplit(')', 1)[1].split()[19] + except (OSError, IndexError): + return None + + +def owned_start(command, out, deadline): + """Bound the creation CLI itself; a lost reply never authorizes another create.""" + process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, + start_new_session=True, preexec_fn=functools.partial(child_setup, os.getpid())) + stdout, stderr = b'', b'' + try: + write_new(out/'startup-process.json', dict(pid=process.pid, start=process_start(process.pid))) + stdout, stderr = process.communicate(timeout=max(.01, min(30, deadline-clock()))) + finally: + if process.poll() is None: + os.killpg(process.pid, signal.SIGKILL) + stdout, stderr = process.communicate() + process.wait() + write_new(out/'startup-finished.json', dict(pid=process.pid, exit=process.returncode, + stdout=stdout.decode(errors='replace'), stderr=stderr.decode(errors='replace'), tick=clock())) + require(process.returncode == 0, 'owned runtime creation failed; inspect startup receipt') + return stdout.decode().strip() + + +def drive(binary, out, ledger, deadline, transport, after_reply=None): + """Real Rust IPC and accounting; tests replace only the external model transport.""" + process = None + try: + with (out / 'rust-stderr.log').open('xb') as stderr: + process = subprocess.Popen([binary, '--bridge', str(out / 'store')], + stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=stderr, + start_new_session=True, preexec_fn=functools.partial(child_setup, os.getpid())) + while True: + record = read_record(process, deadline) + if record is None: + break + request = validate_request(record, ledger.claims + 1) + ordinal = ledger.claim(request) + try: + raw = transport(request.encode(), min(120, max(1, deadline - 60 - clock()))) + except BaseException: + ledger.observe_uncertain(ordinal) + raise + reply = ledger.receive(ordinal, raw) + if after_reply is not None: + after_reply(ordinal) + process.stdin.write((json.dumps(reply) + '\n').encode()) + process.stdin.flush() + code = process.wait(timeout=max(1, min(5, deadline - clock()))) + result = parse((out / 'store/result.json').read_bytes()) + require(code == 0 and result.get('complete') is True and result.get('dispatches') == ledger.claims, + 'Rust Store pilot incomplete') + return result + finally: + if process is not None: + if process.poll() is None: + os.killpg(process.pid, signal.SIGKILL) + process.wait() + process.stdin.close() + process.stdout.close() + + +def run_live(config_path, out, *, approval=None): + # Must precede path reads, output creation, asset inspection and runtime commands. + if type(approval) is not LiveApproval: + raise PermissionError('LIVE requires a separate trusted-caller LiveApproval after independent review') + started = clock() + deadline = started + 1800 + raw_config = Path(config_path).read_bytes() + require(digest(raw_config) == approval.config_sha256 and + re.fullmatch('[0-9a-f]{64}', approval.review_sha256), 'approval does not bind configuration/review') + config = parse(raw_config) + verify_config(config, approval) + require(clock() < deadline - 60, 'preflight exhausted execution window') + out = Path(out) + out.mkdir(mode=0o700) + write_new(out / 'execution.json', dict(config=config, approval=approval.__dict__, + started_tick=started, deadline_tick=deadline, clock='CLOCK_BOOTTIME', local_provider_spend_usd=0)) + ledger = Ledger(out, deadline=deadline) + podman = config['podman']['path'] + name = 'kt-correction-' + uuid.uuid4().hex + watchdog = None + container = None + error = None + complete = False + # A unique name plus --pull=never and kernel/container timeout contains only owned work. + try: + remaining = math.floor(deadline - clock()) + require(remaining > 60, 'no runtime startup window') + command = container_command(podman, name, remaining) + write_new(out / 'runtime-launch.json', dict(name=name, command=command, remaining_seconds=remaining)) + watchdog = subprocess.Popen([sys.executable, __file__, '_watchdog', '--name', name, + '--deadline', str(deadline), '--out', str(out), '--podman', podman], + stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, + start_new_session=True) + container = owned_start(command, out, deadline) + require(re.fullmatch('[0-9a-f]{64}', container), 'unexpected container ID') + write_new(out / 'runtime-created.json', dict(id=container, name=name)) + ready = False + while clock() < min(started + 120, deadline - 60): + try: + version = parse(http('/api/version')) + require(version.get('version') == '0.40.16', 'wrong runtime version') + tags = parse(http('/api/tags')) + selected = [m for m in tags.get('models', []) if m.get('name') == MODEL] + require(len(selected) == 1 and selected[0].get('digest') == MODEL_DIGEST, 'wrong cached model variant') + show = parse(http('/api/show', json.dumps({'model': MODEL, 'verbose': False}).encode())) + initial_ps = parse(http('/api/ps')) + require(initial_ps.get('models') == [], 'owned runtime unexpectedly had a loaded model') + require('thinking' in show.get('capabilities', []) and + 'enable_thinking is false' in show.get('template', ''), 'cached template lacks verified no-thinking path') + write_new(out / 'runtime-ready.json', dict(version=version, selected=selected[0], show=show, ps=initial_ps, + inspect=parse(run([podman, 'inspect', container]))[0])) + ready = True + break + except (OSError, urllib.error.URLError, HttpFailure): + time.sleep(0.1) + require(ready, 'owned runtime failed readiness') + def transport(request, timeout): + tags = parse(http('/api/tags')) + require(any(m.get('name') == MODEL and m.get('digest') == MODEL_DIGEST for m in tags.get('models', [])), + 'model alias changed; claimed request retained without retry') + return http('/api/chat', request, timeout=timeout, raw_path=out/f'raw-{ledger.claims:02}.bin') + def observe_cpu(ordinal): + observation = parse(http('/api/ps')) + write_new(out / f'runtime-ps-{ordinal:02}.json', observation) + validate_cpu_observation(observation) + drive(config['binary']['path'], out, ledger, deadline, transport, observe_cpu) + complete = True + except BaseException as exc: + error = f'{type(exc).__name__}: {exc}' + finally: + # Even a lost create reply must reconcile the unique owned name; never touch the shared service. + cleanup = {} + try: + inspected = parse(run([podman, 'inspect', name]))[0] + require(inspected['Name'].lstrip('/') == name and inspected['Image'].removeprefix('sha256:') == IMAGE_ID, + 'owned container identity mismatch at cleanup') + owned_id = inspected['Id'] + if inspected['State'].get('Running'): + run([podman, 'kill', '--signal=KILL', owned_id]) + logs = subprocess.run([podman, 'logs', owned_id], capture_output=True, timeout=10) + write_new(out / 'runtime-log.txt', logs.stdout + logs.stderr, raw=True) + cleanup = parse(run([podman, 'inspect', owned_id]))[0] + require(cleanup['State'].get('Running') is False, 'owned runtime remains active') + write_new(out / 'runtime-final.json', cleanup) + # Retain stopped container and its writable tmpfs lifecycle evidence; owner can retire later. + except Exception as exc: + complete = False + cleanup = dict(error=f'{type(exc).__name__}: {exc}') + write_new(out / 'runtime-cleanup-error.json', cleanup) + if watchdog is not None: + try: + # EOF always means parent loss. Only this explicit completion marker disables the watcher. + if not cleanup.get('error'): + watchdog.stdin.write(b'done\n') + watchdog.stdin.flush() + watchdog.stdin.close() + watchdog.wait(timeout=15) + require(watchdog.returncode == 0, 'watchdog failed') + except Exception as exc: + complete = False + error = error or f'watchdog completion: {exc}' + finished = clock() + try: + accounting = audit(out) + schedule = schedule_outcomes(out, accounting['claims']) + except Exception as exc: + complete = False + accounting = dict(error=f'{type(exc).__name__}: {exc}', authoritative_totals=False) + schedule = dict(error='accounting audit failed; inspect retained schedule and events') + complete = complete and not error and not accounting.get('unresolved_claims') and finished <= deadline + report = dict(complete=bool(complete), error=error, started_tick=started, finished_tick=finished, + elapsed_seconds=finished-started, deadline_overrun=finished>deadline, accounting=accounting, + model_provider_spend_usd=0, + local_compute_cost='unpriced', shared_runtime_modified=False, + configured_token_envelope_is_hard_budget=False, schedule=schedule) + write_new(out / 'supervisor.json', report) + return report + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + sub = parser.add_subparsers(dest='command', required=True) + p = sub.add_parser('freeze');p.add_argument('--binary', required=True);p.add_argument('--out', required=True) + p = sub.add_parser('fixture');p.add_argument('--binary', required=True);p.add_argument('--out', required=True) + p = sub.add_parser('audit');p.add_argument('out') + p = sub.add_parser('_watchdog', help=argparse.SUPPRESS) + p.add_argument('--name', required=True);p.add_argument('--deadline', type=float, required=True) + p.add_argument('--out', required=True);p.add_argument('--podman', required=True) + args = parser.parse_args() + if args.command == '_watchdog': + return watchdog_main(args) + if args.command == 'freeze': + result = freeze(args.binary);write_new(Path(args.out), result);print(json.dumps(result, indent=2));return 0 + if args.command == 'fixture': + return subprocess.run([args.binary, '--fixture', args.out], timeout=120).returncode + print(json.dumps(audit(args.out), indent=2));return 0 + + +def watch_pipe(fd, deadline, stop, clock=clock): + with selectors.DefaultSelector() as selector: + selector.register(fd, selectors.EVENT_READ) + while clock() < deadline: + if selector.select(min(0.1, max(0, deadline-clock()))): + message = os.read(fd, 5) + if message == b'done\n': + return 'completed' + if not message: + stop() + return 'parent_lost' + raise ValueError('invalid watchdog completion message') + stop() + return 'deadline' + + +def watchdog_main(args): + require(re.fullmatch('kt-correction-[0-9a-f]{32}', args.name), 'not an owned pilot runtime name') + require(math.isfinite(args.deadline), 'invalid absolute deadline') + actions = [] + cleanup_verified = False + def stop(): + nonlocal cleanup_verified + startup = Path(args.out)/'startup-process.json' + if startup.exists(): + record = parse(startup.read_bytes()) + pid = record['pid'] + if record.get('start') is not None and process_start(pid) == record['start']: + try: + require(os.getpgid(pid) == pid, 'creation process is not the owned group leader') + os.killpg(pid, signal.SIGKILL) + actions.append(dict(startup_pid=pid, startup_kill='SIGKILL')) + except ProcessLookupError: + pass + # Absence during creation is unresolved. Keep reconciling through the original deadline. + while True: + p = subprocess.run([args.podman, 'inspect', args.name], capture_output=True, timeout=3) + if p.returncode == 0: + value = parse(p.stdout)[0] + require(value['Name'].lstrip('/') == args.name and + value['Image'].removeprefix('sha256:') == IMAGE_ID, 'wrong owned runtime identity') + if value['State'].get('Running'): + killed = subprocess.run([args.podman, 'kill', '--signal=KILL', value['Id']], + capture_output=True, timeout=3) + actions.append(dict(id=value['Id'], kill_exit=killed.returncode)) + # Observe stopped state even if the kill itself crossed the deadline. + final = subprocess.run([args.podman, 'inspect', value['Id']], capture_output=True, timeout=3) + if final.returncode == 0: + stopped = parse(final.stdout)[0] + cleanup_verified = (stopped['Id'] == value['Id'] and + stopped['State'].get('Running') is False) + break + else: + actions.append(dict(id=value['Id'], already_stopped=True)) + cleanup_verified = True + break + if clock() >= args.deadline: + actions.append(dict(unresolved='owned runtime never observed; absence during creation is not stopped proof')) + break + time.sleep(min(0.1, max(0, args.deadline-clock()))) + error = None + try: + reason = watch_pipe(sys.stdin.fileno(), args.deadline, stop) + if reason == 'completed':cleanup_verified = True + except BaseException as exc: + reason, error = 'error', f'{type(exc).__name__}: {exc}' + write_new(Path(args.out) / 'watchdog.json', dict(reason=reason, actions=actions, + deadline=args.deadline, observed_tick=clock(), cleanup_verified=cleanup_verified, error=error)) + return 0 if cleanup_verified and error is None else 2 + + +if __name__ == '__main__': + raise SystemExit(main()) diff --git a/scripts/test_controlled_correction_pilot.py b/scripts/test_controlled_correction_pilot.py new file mode 100644 index 0000000..2157f91 --- /dev/null +++ b/scripts/test_controlled_correction_pilot.py @@ -0,0 +1,234 @@ +"""Fault-focused checks: removing claim limits/durability/approval must fail these.""" +import importlib.util +import json +from pathlib import Path +import tempfile +import unittest +import sys +SPEC=importlib.util.spec_from_file_location('pilot_runner',Path(__file__).with_name('run_controlled_correction_pilot.py')) +pilot=importlib.util.module_from_spec(SPEC);sys.modules[SPEC.name]=pilot;SPEC.loader.exec_module(pilot) + +class PilotAccountingTests(unittest.TestCase): + def setUp(self): + self.tmp=tempfile.TemporaryDirectory();self.out=Path(self.tmp.name) + def tearDown(self):self.tmp.cleanup() + def response(self,**changes): + value={'model':'ornith-1.5:9b','done':True,'done_reason':'stop','message':{'role':'assistant','content':'{}'},'prompt_eval_count':181,'eval_count':30,'total_duration':11,'load_duration':0,'prompt_eval_duration':5,'eval_duration':6} + value.update(changes);return json.dumps(value).encode() + def test_unapproved_invocation_denied_before_artifacts_or_runtime(self): + with self.assertRaises(PermissionError):pilot.run_live(self.out/'absent.json',self.out/'run') + self.assertFalse((self.out/'run').exists()) + def test_fourteenth_claim_cannot_be_sent(self): + ledger=pilot.Ledger(self.out,deadline=1000,clock=lambda:0) + for _ in range(13): + n=ledger.claim('{}');ledger.receive(n,self.response()) + with self.assertRaises(ValueError):ledger.claim('{}') + audit=pilot.audit(self.out) + self.assertEqual(audit['claims'],13);self.assertEqual(audit['known_tokens'],2743) + def test_uncertain_reply_retained_and_blocks_further_claims(self): + ledger=pilot.Ledger(self.out,deadline=1000,clock=lambda:0) + n=ledger.claim('{}') + with self.assertRaises(ValueError):ledger.receive(n,b'{bad') + self.assertEqual((self.out/'raw-01.bin').read_bytes(),b'{bad') + with self.assertRaises(ValueError):ledger.claim('{}') + result=pilot.audit(self.out) + self.assertEqual(result['unresolved_claims'],1);self.assertIsNone(result['hard_token_liability_bound']) + self.assertEqual(result['unresolved_quote_units'],2144) + def test_observed_excess_usage_is_not_clamped_or_dropped(self): + ledger=pilot.Ledger(self.out,deadline=1000,clock=lambda:0) + n=ledger.claim('{}') + with self.assertRaises(ValueError):ledger.receive(n,self.response(prompt_eval_count=3000)) + with self.assertRaises(ValueError):ledger.claim('{}') + self.assertEqual(pilot.audit(self.out)['known_tokens'],3030) + def test_deadline_preserves_original_cutoff_and_sends_nothing(self): + ledger=pilot.Ledger(self.out,deadline=100,clock=lambda:40) + with self.assertRaises(TimeoutError):ledger.claim('{}') + self.assertEqual(pilot.audit(self.out)['claims'],0) + def test_duplicate_json_keys_and_boolean_usage_remain_unknown(self): + for name,body in [('duplicate',b'{"done":true,"done":false}'),('boolean',self.response(eval_count=True))]: + target=self.out/name;target.mkdir();ledger=pilot.Ledger(target,deadline=1000,clock=lambda:0) + n=ledger.claim('{}') + with self.assertRaises(ValueError):ledger.receive(n,body) + self.assertEqual(pilot.audit(target)['unresolved_claims'],1) + def test_failed_claim_persistence_cannot_authorize_send(self): + (self.out/'claim-01.json').mkdir() + ledger=pilot.Ledger(self.out,deadline=1000,clock=lambda:0) + with self.assertRaises(OSError):ledger.claim('{}') + self.assertEqual(ledger.claims,0) + + +class AdditionalFailureTests(unittest.TestCase): + def test_nonfinal_usage_cannot_release_unknown_liability(self): + with tempfile.TemporaryDirectory() as d: + out=Path(d);ledger=pilot.Ledger(out,deadline=1000,clock=lambda:0) + ordinal=ledger.claim('{}') + raw=json.dumps({'model':'ornith-1.5:9b','done':False,'prompt_eval_count':181,'eval_count':30}).encode() + with self.assertRaises(ValueError):ledger.receive(ordinal,raw) + result=pilot.audit(out) + self.assertEqual(result['known_tokens'],211) + self.assertEqual(result['unresolved_claims'],1,'partial measured usage cannot reconcile final liability') + +class WatchdogTests(unittest.TestCase): + def check_owned_child_terminated(self, close_writer): + import os,signal,subprocess + child=subprocess.Popen([sys.executable,'-c','import time;time.sleep(30)'],start_new_session=True) + r,w=os.pipe() + try: + if close_writer:os.close(w);w=None + result=pilot.watch_pipe(r,pilot.clock()+0.03,lambda:os.killpg(child.pid,signal.SIGKILL)) + self.assertEqual(result,'parent_lost' if close_writer else 'deadline') + self.assertIsNotNone(child.poll() if child.poll() is not None else child.wait(timeout=1)) + finally: + if child.poll() is None:os.killpg(child.pid,signal.SIGKILL) + child.wait();os.close(r) + if w is not None:os.close(w) + def test_eof_kills_only_owned_worker(self):self.check_owned_child_terminated(True) + def test_absolute_deadline_kills_owned_worker(self):self.check_owned_child_terminated(False) + +class RequestContractTests(unittest.TestCase): + def request(self): + import re + source=(pilot.ROOT/'examples/controlled_correction_pilot.rs').read_text() + prompt=re.search(r'const REPORT_PROMPT:\s*&str\s*=\s*r#"(.*?)"#;',source,re.S).group(1) + request={**pilot.ENVELOPE,'messages':[{'role':'system','content':prompt},{'role':'user','content':'{"ci_report":{"failing_cases":0,"release":"R42","test_summary":"12/12","version":"run/17"}}'}]} + return {'op':'generate','ordinal':1,'model_digest':pilot.MODEL_DIGEST,'request_utf8':json.dumps(request)} + def test_original_prompt_parity_and_changed_caps_are_refused(self): + import re + original=(pilot.ROOT/'examples/scoped_model_reuse.rs').read_text() + request=self.request();value=json.loads(request['request_utf8']) + current=(pilot.ROOT/'examples/controlled_correction_pilot.rs').read_text() + for name in ['REPORT_PROMPT','PLAN_PROMPT']: + pattern=r'const '+name+r':\s*&str\s*=\s*r#"(.*?)"#;' + self.assertEqual(re.search(pattern,current,re.S).group(1),re.search(pattern,original,re.S).group(1)) + expected=re.search(r'const REPORT_PROMPT:\s*&str\s*=\s*r#"(.*?)"#;',original,re.S).group(1) + self.assertEqual(value['messages'][0]['content'],expected) + pilot.validate_request(request,1) + value['options']={**pilot.OPTIONS,'num_predict':97};request['request_utf8']=json.dumps(value) + with self.assertRaises(ValueError):pilot.validate_request(request,1) + def test_cpu_observation_rejects_gpu_or_wrong_runtime_context(self): + for model in [dict(name=pilot.MODEL,digest=pilot.MODEL_DIGEST,size_vram=1,context_length=2048),dict(name=pilot.MODEL,digest=pilot.MODEL_DIGEST,size_vram=0,context_length=4096)]: + with self.assertRaises(ValueError):pilot.validate_cpu_observation({'models':[model]}) + pilot.validate_cpu_observation({'models':[dict(name=pilot.MODEL,digest=pilot.MODEL_DIGEST,size_vram=0,context_length=2048)]}) + +class CompiledBridgeTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + import os + cls.binary=os.environ.get('KAIROTENSOR_PILOT_TEST_BINARY') + if not cls.binary:raise unittest.SkipTest('compiled bridge checked by explicit offline qualification command') + def response(self,raw,timeout): + request=json.loads(raw);data=json.loads(request['messages'][1]['content']) + if 'ci_report' in data: + r=data['ci_report'];answer=dict(release=r['release'],tests=r['test_summary'],status='pass' if r['failing_cases']==0 else 'fail') + else: + r=data['requirement'];v=data['test_certificate'];answer=dict(release=r['release'],target=r['target'],approval=r['approval'],tests=v['tests'],action='deploy' if v['status']=='pass' else 'hold') + return json.dumps({'model':pilot.MODEL,'done':True,'done_reason':'stop','message':{'role':'assistant','content':json.dumps(answer)},'prompt_eval_count':181,'eval_count':30}).encode() + def test_real_binary_ipc_runs_thirteen_synthetic_deliveries(self): + with tempfile.TemporaryDirectory() as d: + out=Path(d);deadline=pilot.clock()+120;ledger=pilot.Ledger(out,deadline=deadline) + result=pilot.drive(self.binary,out,ledger,deadline,self.response) + self.assertEqual(result['dispatches'],13);self.assertEqual(result['reuse_hits'],2) + self.assertEqual(pilot.audit(out)['known_tokens'],2743) + self.assertEqual(pilot.schedule_outcomes(out,13)['unexecuted_slots'],[]) + def test_transport_eof_keeps_one_claim_and_twelve_unexecuted_slots(self): + with tempfile.TemporaryDirectory() as d: + out=Path(d);deadline=pilot.clock()+120;ledger=pilot.Ledger(out,deadline=deadline) + def broken(*_):raise ConnectionError('synthetic transport EOF') + with self.assertRaises(ConnectionError):pilot.drive(self.binary,out,ledger,deadline,broken) + self.assertEqual(pilot.audit(out)['unresolved_claims'],1) + self.assertEqual(len(pilot.schedule_outcomes(out,1)['unexecuted_slots']),12) + self.assertEqual(set(pilot.schedule_outcomes(out,1)['scenario_outcomes'].values()),{'unexecuted'}) + def test_invalid_model_verdict_charged_without_further_calls(self): + with tempfile.TemporaryDirectory() as d: + out=Path(d);deadline=pilot.clock()+120;ledger=pilot.Ledger(out,deadline=deadline) + def wrong(raw,timeout): + response=json.loads(self.response(raw,timeout));response['message']['content']='{"release":"R42","tests":"12/12","status":"fail"}';return json.dumps(response).encode() + with self.assertRaises(ValueError):pilot.drive(self.binary,out,ledger,deadline,wrong) + audit=pilot.audit(out);self.assertEqual(audit['claims'],1);self.assertEqual(audit['known_tokens'],211) + result=json.loads((out/'store/result.json').read_text());self.assertFalse(result['complete']);self.assertEqual(len(result['unexecuted_slots']),12) + + +class HttpDeadlineTests(unittest.TestCase): + def check_transport(self, drip): + import http.server,threading,time + from unittest.mock import patch + class Handler(http.server.BaseHTTPRequestHandler): + def do_POST(self): + self.rfile.read(int(self.headers.get('Content-Length','0'))) + self.send_response(200);self.send_header('Content-Length',str(len(b'partial-prefix')+(30 if drip else 86)));self.end_headers() + try: + self.wfile.write(b'partial-prefix');self.wfile.flush() + if drip: + for _ in range(30):self.wfile.write(b'x');self.wfile.flush();time.sleep(0.04) + else:time.sleep(1) + except (BrokenPipeError,ConnectionResetError):pass + def log_message(self,*args):pass + server=http.server.ThreadingHTTPServer(('127.0.0.1',0),Handler) + server.daemon_threads=True + thread=threading.Thread(target=server.serve_forever,daemon=True);thread.start() + try: + with tempfile.TemporaryDirectory() as d,patch.object(pilot,'SERVER',f'http://127.0.0.1:{server.server_port}'): + raw=Path(d)/'raw-01.bin';started=time.monotonic() + with self.assertRaises((TimeoutError,pilot.HttpFailure)): + pilot.http('/api/chat',b'{}',timeout=0.25,raw_path=raw) + self.assertLess(time.monotonic()-started,0.8,'deadline must bound total response time, not each socket read') + self.assertTrue(raw.exists(),'received prefix must survive timeout') + self.assertTrue(raw.read_bytes().startswith(b'partial-prefix')) + finally:server.shutdown();server.server_close();thread.join() + def test_slow_drip_has_absolute_deadline(self):self.check_transport(True) + def test_partial_stall_bytes_survive_timeout(self):self.check_transport(False) + + +class LateContainerTests(unittest.TestCase): + def test_parent_loss_reconciles_late_creation_or_reports_unresolved(self): + import os,time,types + from unittest.mock import patch + with tempfile.TemporaryDirectory() as d: + out=Path(d);fake=out/'fake-podman';name='kt-correction-'+'a'*32 + born=time.monotonic() + fake.write_text('#!'+sys.executable+'\n'+f'''import sys,time,json,pathlib +root=pathlib.Path({d!r}) +if sys.argv[1]=='inspect': + if time.monotonic() < {born+0.75!r}:sys.exit(1) + print(json.dumps([{{'Name':{name!r},'Image':{pilot.IMAGE_ID!r},'Id':'b'*64,'State':{{'Running':not (root/'killed').exists()}}}}])) +elif sys.argv[1]=='kill':(root/'killed').write_text('yes') +''');fake.chmod(0o700) + r,w=os.pipe();os.close(w) + try: + with os.fdopen(r,'rb') as reader,patch.object(pilot.sys,'stdin',reader): + code=pilot.watchdog_main(types.SimpleNamespace(name=name,deadline=pilot.clock()+1.5,out=str(out),podman=str(fake))) + self.assertTrue((out/'killed').exists(),'watcher must not report success before delayed creation is reconciled') + self.assertEqual(code,0) + self.assertTrue(json.loads((out/'watchdog.json').read_text())['cleanup_verified']) + finally:pass + def test_absence_without_a_sealed_startup_is_not_cleanup_success(self): + import os,types + from unittest.mock import patch + with tempfile.TemporaryDirectory() as d: + out=Path(d);fake=out/'fake-podman';fake.write_text('#!'+sys.executable+'\nimport sys;sys.exit(1)\n');fake.chmod(0o700) + r,w=os.pipe();os.close(w) + with os.fdopen(r,'rb') as reader,patch.object(pilot.sys,'stdin',reader): + code=pilot.watchdog_main(types.SimpleNamespace(name='kt-correction-'+'a'*32,deadline=pilot.clock()+0.2,out=str(out),podman=str(fake))) + self.assertNotEqual(code,0,'unobserved cleanup must not be reported successful') + self.assertFalse(json.loads((out/'watchdog.json').read_text())['cleanup_verified']) + + +class ParentBindingTests(unittest.TestCase): + def test_wrong_expected_parent_cannot_execute_child(self): + import functools,os,subprocess + process=subprocess.Popen([sys.executable,'-c','raise SystemExit(0)'], + preexec_fn=functools.partial(pilot.child_setup,os.getpid()+1000000)) + self.assertEqual(process.wait(timeout=2),127) + def test_uncertain_complete_json_keeps_observed_usage_and_hold(self): + with tempfile.TemporaryDirectory() as d: + out=Path(d);ledger=pilot.Ledger(out,deadline=1000,clock=lambda:0) + ordinal=ledger.claim('{}') + raw=json.dumps({'model':pilot.MODEL,'done':True,'done_reason':'stop', + 'message':{'role':'assistant','content':'{}'},'prompt_eval_count':181,'eval_count':30}).encode() + (out/'raw-01.bin').write_bytes(raw) + ledger.observe_uncertain(ordinal) + result=pilot.audit(out) + self.assertEqual(result['known_tokens'],211);self.assertEqual(result['unresolved_claims'],1) + with self.assertRaises(ValueError):ledger.claim('{}') + +if __name__=='__main__':unittest.main() From f6694110e3df5b1a13f71dbf9fae2bde89e07c44 Mon Sep 17 00:00:00 2001 From: Alejandro Castellanos <5405628+k2jac9@users.noreply.github.com> Date: Mon, 16 Nov 2026 01:13:07 -0500 Subject: [PATCH 2/3] Exercise compiled correction pilot in every offline CI lane --- .github/workflows/check.yml | 4 ++-- docs/controlled-correction-pilot.md | 2 ++ 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml index 5850930..33c4063 100644 --- a/.github/workflows/check.yml +++ b/.github/workflows/check.yml @@ -108,8 +108,8 @@ jobs: run: | python3 -m unittest discover -s reference -p test_memory.py python3 reference/belief_oracle.py - cargo build --locked --offline --example recovery_policy_eval --example decision_replay - KAIROTENSOR_RECOVERY_RUNNER="$PWD/target/debug/examples/recovery_policy_eval" KAIROTENSOR_DECISION_REPLAY="$PWD/target/debug/examples/decision_replay" python3 -m unittest discover -s scripts -p 'test_*.py' + cargo build --locked --offline --example recovery_policy_eval --example decision_replay --example controlled_correction_pilot + KAIROTENSOR_RECOVERY_RUNNER="$PWD/target/debug/examples/recovery_policy_eval" KAIROTENSOR_DECISION_REPLAY="$PWD/target/debug/examples/decision_replay" KAIROTENSOR_PILOT_TEST_BINARY="$PWD/target/debug/examples/controlled_correction_pilot" python3 -m unittest discover -s scripts -p 'test_*.py' - name: Verify bounded offline ablation planning and recorded scoring run: KAIROTENSOR_DECISION_REPLAY="$PWD/target/debug/examples/decision_replay" python3 -m unittest discover -s scripts -p test_decision_ablation.py - name: Export and replay a decision in separate offline processes diff --git a/docs/controlled-correction-pilot.md b/docs/controlled-correction-pilot.md index 87de22e..9c1ac90 100644 --- a/docs/controlled-correction-pilot.md +++ b/docs/controlled-correction-pilot.md @@ -80,6 +80,8 @@ python3 scripts/project_runtime.py --budget-gib 2 cargo build --offline --locked For compiled IPC tests, set `KAIROTENSOR_PILOT_TEST_BINARY` to that exact built example while running the Python suite. This test-only variable enables three zero-model integration tests; without it, that class is explicitly skipped. +The hosted workflow builds this executable and binds that variable in all five +runtime lanes, so these integration checks are included in the broad suite. The public fixture command invokes the binary's deterministic adapter and labels its accounting units synthetic: From 31f303bf3f5cbf732ee91699e1e110bcdf990e6d Mon Sep 17 00:00:00 2001 From: Alejandro Castellanos <5405628+k2jac9@users.noreply.github.com> Date: Mon, 16 Nov 2026 01:20:40 -0500 Subject: [PATCH 3/3] Record audited local correction pilot and paired accounting --- docs/controlled-correction-pilot.md | 3 + docs/controlled-correction-results.md | 57 + ...ontrolled-correction-pilot-2026-11-16.json | 2439 +++++++++++++++++ 3 files changed, 2499 insertions(+) create mode 100644 docs/controlled-correction-results.md create mode 100644 docs/evaluations/controlled-correction-pilot-2026-11-16.json diff --git a/docs/controlled-correction-pilot.md b/docs/controlled-correction-pilot.md index 9c1ac90..4ed03a6 100644 --- a/docs/controlled-correction-pilot.md +++ b/docs/controlled-correction-pilot.md @@ -8,6 +8,9 @@ held-out evaluation, training or change to existing Store/validator behavior is included. It is separate from the main submission pinned to `20fab84` and from the fixture-only incident Store bridge. +The [16 November recorded run](controlled-correction-results.md) completed this +fixed schedule; its source revision and observed limits are reported separately. + The model candidate is cached `ornith-1.5:9b`, Q4_K_M, on Ollama 0.40.16. The adapter fixes its selected variant digest and the supervisor pins the cached container image and full model/config/projector/variant content hashes. This is diff --git a/docs/controlled-correction-results.md b/docs/controlled-correction-results.md new file mode 100644 index 0000000..a04479f --- /dev/null +++ b/docs/controlled-correction-results.md @@ -0,0 +1,57 @@ +# Controlled correction pilot: observed results, 16 November 2026 + +One bounded local run completed all four planned evidence changes. After the +shared bootstrap, Store repair used **751 reported tokens and four calls**; +full recomputation used **1,167 tokens and six calls**. The difference was 416 +tokens, or **35.6% of post-change recomputation usage**. All corresponding +requests matched byte-for-byte and all checked structured plans agreed. + +| Evidence change | Checked behavior in both arms | Repair calls / tokens | Fresh calls / tokens | +| --- | --- | ---: | ---: | +| Replace passing report with failing report | Hold deployment; 11/12 tests | 2 / 389 | 2 / 389 | +| Change policy; retain report | Deploy to the new canary target | 1 / 181 | 2 / 389 | +| Withdraw both reports without replacement | Refuse before model dispatch | 0 / 0 | 0 / 0 | +| Withdraw A; retain distinct occurrence B | Use B's own accepted origin; retain staging plan | 1 / 181 | 2 / 389 | + +The common bootstrap cost three calls and 597 tokens. Adding that same prefix +to each hypothetical lifecycle gives 1,348 repair tokens versus 1,764 fresh +tokens, a **23.6% difference**. Actual collection charged the shared prefix once: +13 calls and 2,515 tokens overall. Two reuse hits are previously sampled results +with retained origin identities; they are not additional independent samples. + +The run finished in 70.14 seconds, within its original 30-minute window. All 13 +calls returned reconciled usage; there were no unresolved holds, excess observed +usage, retries, or unexecuted conditions. The owned runtime was stopped and +observed with PID 0, no OOM kill and no remaining running container. Exit 137 +records the supervisor's planned final SIGKILL. Only the original shared Ollama +service remained running. Remote model-provider spend was zero; workstation +CPU/electricity cost is unpriced. + +Execution used source `f6694110e3df5b1a13f71dbf9fae2bde89e07c44`, the reviewed +binary built at `c7f1da715ec3de2929b0009600acc2ef4fb81c92` with identical compiled +inputs, cached `ornith-1.5:9b` Q4_K_M and Ollama 0.40.16. Every recorded loaded +model observation passed the selected-digest, CPU-only and context checks. +The [protocol](controlled-correction-pilot.md) specifies the frozen requests, +authority, containment and accounting limits. The +[recorded trace](evaluations/controlled-correction-pilot-2026-11-16.json) includes +exact requests, base64-encoded raw responses, usage, Store events, runtime +observations and hashes for the retained evidence files. + +An independent read-only post-run audit reconciled every request, raw response, +claim, token receipt and Store event against the SQLite records. It checked the +two retained origins, all 13 CPU observations (context 2,048; VRAM zero), and +stopped-runtime evidence. The audit found no unknown, invalid or stale outcomes; +its hash is included in the trace. This audit made no model calls. + +This is one correlated synthetic example per condition using existing report and +policy fixtures. The collected conditions share one bootstrap and one runtime; cache warmth +and order affect timings. These observations support the tested reuse and +withdrawal behavior, but do not establish population accuracy, latency savings, +held-out incident quality, or broader epistemic improvement. The arithmetic +verdicts already have a deterministic product route. Runtime-reported counts are +observations; hashes do not authenticate model execution. Configured token +envelopes remain unproven hard bounds even though this run stayed within them. + +No dataset was expanded and no new training run was launched. The existing +AutoScientist experiment is separate. The submission report and its earlier +measurements remain pinned to `20fab84`; this readout is a separate supplement. diff --git a/docs/evaluations/controlled-correction-pilot-2026-11-16.json b/docs/evaluations/controlled-correction-pilot-2026-11-16.json new file mode 100644 index 0000000..5dfad50 --- /dev/null +++ b/docs/evaluations/controlled-correction-pilot-2026-11-16.json @@ -0,0 +1,2439 @@ +{ + "schema": "kairotensor-controlled-correction-observation/1", + "date": "2026-11-16", + "execution_source_commit": "f6694110e3df5b1a13f71dbf9fae2bde89e07c44", + "binary_built_at": "c7f1da715ec3de2929b0009600acc2ef4fb81c92", + "compiled_inputs_unchanged": true, + "binary_sha256": "a2c6f2d295f80df400c789ec537f59dcbe62ed2db558b8dc5f444563149fffb1", + "configuration_sha256": "e277b05b1ad03cd90549ac743974de535196b4aef89c8b3e537aa679b55594af", + "independent_preflight_review_sha256": "b9cb90dc3622964844745c76bddb2807563b9beb45cdbb26f54640adcdec67c1", + "runtime": { + "image": "docker.io/ollama/ollama@sha256:85b3c895222b1ddc9d63c40b20fc74f37a37593dcbbdfbf28910a925e43ead00", + "image_id": "aa25f838bb0303774bc7540716dadd62605fd0724febfccfc511e67ef12274a5", + "model": "ornith-1.5:9b", + "model_digest": "e5df7dcdd8a263994df62d610317e07be0d6af23f96fcbd8543273058fce575e", + "model_manifest_sha256": "4e3abcdcb78587e3709cc65607f590347deb217b5e45f48113734915548d0ef8", + "envelope": { + "keep_alive": "10m", + "model": "ornith-1.5:9b", + "options": { + "num_ctx": 2048, + "num_gpu": 0, + "num_predict": 96, + "num_thread": 2, + "seed": 0, + "temperature": 0, + "top_k": 1, + "top_p": 1 + }, + "runner": "ggml", + "shift": false, + "stream": false, + "think": false, + "truncate": false + }, + "platform": "Linux-7.3.4-x86_64-with-glibc2.44" + }, + "summary": { + "actual_calls": 13, + "actual_tokens": 2515, + "bootstrap_calls": 3, + "bootstrap_tokens": 597, + "post_change_repair_calls": 4, + "post_change_repair_tokens": 751, + "post_change_fresh_calls": 6, + "post_change_fresh_tokens": 1167, + "marginal_tokens_saved": 416, + "marginal_reduction_percent": 35.646958011996574, + "shared_prefix_lifecycle_repair_tokens": 1348, + "shared_prefix_lifecycle_fresh_tokens": 1764, + "shared_prefix_lifecycle_reduction_percent": 23.582766439909296, + "reuse_hits": 2 + }, + "supervisor": { + "accounting": { + "accounting_scope": "provider-reported local token units; no proven unknown-liability bound", + "claims": 13, + "hard_token_liability_bound": null, + "known_tokens": 2515, + "observed_excess": false, + "unresolved_claims": 0, + "unresolved_quote_units": 0 + }, + "complete": true, + "configured_token_envelope_is_hard_budget": false, + "deadline_overrun": false, + "elapsed_seconds": 70.14368417699734, + "error": null, + "finished_tick": 52130.479083738, + "local_compute_cost": "unpriced", + "model_provider_spend_usd": 0, + "schedule": { + "scenario_outcomes": { + "alternative_support": "complete", + "report_correction": "complete", + "unrelated_policy_change": "complete", + "withdrawal": "complete" + }, + "unexecuted_slots": [] + }, + "shared_runtime_modified": false, + "started_tick": 52060.335399561 + }, + "store_result": { + "bootstrap": { + "a_origin": 2, + "b_origin": 3, + "dispatches": 3 + }, + "complete": true, + "dispatches": 13, + "mode": "trusted_local_bridge", + "reuse_hits": 2, + "rust_dispatch_intents": 13, + "scenarios": [ + { + "fresh": { + "dispatches": 2, + "origin": 6, + "outcome": "accepted", + "plan": { + "action": "hold", + "approval": "S42-A", + "release": "R42", + "target": "staging", + "tests": "11/12" + }, + "report_branch": "report-a", + "requests": [ + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":1,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"11/12\\\",\\\"version\\\":\\\"run/18\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}", + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/18\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"S42-A\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"staging\\\",\\\"version\\\":\\\"policy/v1\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"fail\\\",\\\"tests\\\":\\\"11/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + ], + "reused": false, + "route_us": 5977737 + }, + "repair": { + "dispatches": 2, + "origin": 9, + "outcome": "accepted", + "plan": { + "action": "hold", + "approval": "S42-A", + "release": "R42", + "target": "staging", + "tests": "11/12" + }, + "report_branch": "report-a", + "requests": [ + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":1,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"11/12\\\",\\\"version\\\":\\\"run/18\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}", + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/18\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"S42-A\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"staging\\\",\\\"version\\\":\\\"policy/v1\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"fail\\\",\\\"tests\\\":\\\"11/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + ], + "reused": false, + "route_us": 9601611 + }, + "requests_equal": true, + "scenario": "report_correction", + "typed_support": false + }, + { + "fresh": { + "dispatches": 2, + "origin": 5, + "outcome": "accepted", + "plan": { + "action": "deploy", + "approval": "C42-B", + "release": "R42", + "target": "canary", + "tests": "12/12" + }, + "report_branch": "report-a", + "requests": [ + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":0,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"12/12\\\",\\\"version\\\":\\\"run/17\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}", + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/17\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"C42-B\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"canary\\\",\\\"version\\\":\\\"policy/v2\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"pass\\\",\\\"tests\\\":\\\"12/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + ], + "reused": false, + "route_us": 9668588 + }, + "repair": { + "dispatches": 1, + "origin": 2, + "outcome": "accepted", + "plan": { + "action": "deploy", + "approval": "C42-B", + "release": "R42", + "target": "canary", + "tests": "12/12" + }, + "report_branch": "report-a", + "requests": [ + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":0,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"12/12\\\",\\\"version\\\":\\\"run/17\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}", + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/17\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"C42-B\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"canary\\\",\\\"version\\\":\\\"policy/v2\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"pass\\\",\\\"tests\\\":\\\"12/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + ], + "reused": true, + "route_us": 3697907 + }, + "requests_equal": true, + "scenario": "unrelated_policy_change", + "typed_support": true + }, + { + "fresh": { + "dispatches": 0, + "outcome": "unavailable_evidence", + "plan": null, + "requests": [] + }, + "repair": { + "dispatches": 0, + "outcome": "unavailable_evidence", + "plan": null, + "requests": [] + }, + "requests_equal": true, + "scenario": "withdrawal", + "typed_support": false + }, + { + "fresh": { + "dispatches": 2, + "origin": 5, + "outcome": "accepted", + "plan": { + "action": "deploy", + "approval": "S42-A", + "release": "R42", + "target": "staging", + "tests": "12/12" + }, + "report_branch": "report-b", + "requests": [ + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":0,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"12/12\\\",\\\"version\\\":\\\"run/17\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}", + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/17\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"S42-A\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"staging\\\",\\\"version\\\":\\\"policy/v1\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"pass\\\",\\\"tests\\\":\\\"12/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + ], + "reused": false, + "route_us": 8159465 + }, + "repair": { + "dispatches": 1, + "origin": 3, + "outcome": "accepted", + "plan": { + "action": "deploy", + "approval": "S42-A", + "release": "R42", + "target": "staging", + "tests": "12/12" + }, + "report_branch": "report-b", + "requests": [ + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":0,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"12/12\\\",\\\"version\\\":\\\"run/17\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}", + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/17\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"S42-A\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"staging\\\",\\\"version\\\":\\\"policy/v1\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"pass\\\",\\\"tests\\\":\\\"12/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + ], + "reused": true, + "route_us": 3628795 + }, + "requests_equal": true, + "scenario": "alternative_support", + "typed_support": true + } + ], + "unexecuted_scenarios": [], + "unexecuted_slots": [] + }, + "by_route": { + "bootstrap": { + "calls": 3, + "input_tokens": 525, + "output_tokens": 72, + "tokens": 597 + }, + "report_correction/repair": { + "calls": 2, + "input_tokens": 337, + "output_tokens": 52, + "tokens": 389 + }, + "report_correction/fresh": { + "calls": 2, + "input_tokens": 337, + "output_tokens": 52, + "tokens": 389 + }, + "unrelated_policy_change/fresh": { + "calls": 2, + "input_tokens": 337, + "output_tokens": 52, + "tokens": 389 + }, + "unrelated_policy_change/repair": { + "calls": 1, + "input_tokens": 149, + "output_tokens": 32, + "tokens": 181 + }, + "alternative_support/fresh": { + "calls": 2, + "input_tokens": 337, + "output_tokens": 52, + "tokens": 389 + }, + "alternative_support/repair": { + "calls": 1, + "input_tokens": 149, + "output_tokens": 32, + "tokens": 181 + } + }, + "calls": [ + { + "ordinal": 1, + "context": { + "route": "bootstrap", + "task": "report-a" + }, + "claim": { + "observed_tick": 52064.430498642, + "ordinal": 1, + "quote_is_proven_bound": false, + "quote_units": 2144, + "request_sha256": "9f8a53322cbab65c56dbf9bff48791aaa7ff6e2ded62d45cc4d51dc68c49365a", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":0,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"12/12\\\",\\\"version\\\":\\\"run/17\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + "usage": { + "input_tokens": 188, + "late": false, + "ordinal": 1, + "output_tokens": 20, + "raw_sha256": "9242e57f7f025233bf5da6cca2c38b63a12f4e8b58a806c5324130716b94e33e", + "received_tick": 52077.62409132, + "reconciled": true, + "transport_complete": true, + "within_envelope": true + }, + "raw_response_base64": "eyJtb2RlbCI6Im9ybml0aC0xLjU6OWIiLCJjcmVhdGVkX2F0IjoiMjAyNi0xMS0xNlQwNjoxNTozMy43NjY2MTM3OTRaIiwibWVzc2FnZSI6eyJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6IntcInJlbGVhc2VcIjpcIlI0MlwiLFwidGVzdHNcIjpcIjEyLzEyXCIsXCJzdGF0dXNcIjpcInBhc3NcIn0ifSwiZG9uZSI6dHJ1ZSwiZG9uZV9yZWFzb24iOiJzdG9wIiwidG90YWxfZHVyYXRpb24iOjEzMDYzODQzNTgxLCJsb2FkX2R1cmF0aW9uIjo1MDUxODA1NTI1LCJwcm9tcHRfZXZhbF9jb3VudCI6MTg4LCJwcm9tcHRfZXZhbF9jYWNoZWRfY291bnQiOjAsInByb21wdF9ldmFsX2R1cmF0aW9uIjo2MTY0ODUzMDAwLCJldmFsX2NvdW50IjoyMCwiZXZhbF9kdXJhdGlvbiI6MTg0NTQ3NDAwMH0=", + "runtime_observation": { + "models": [ + { + "context_length": 2048, + "details": { + "families": [ + "qwen35" + ], + "family": "qwen35", + "format": "gguf", + "parameter_size": "9.0B", + "parent_model": "", + "quantization_level": "Q4_K_M" + }, + "digest": "e5df7dcdd8a263994df62d610317e07be0d6af23f96fcbd8543273058fce575e", + "expires_at": "2026-11-16T06:25:33.766760658Z", + "model": "ornith-1.5:9b", + "name": "ornith-1.5:9b", + "runner": "llamacpp", + "size": 6118650673, + "size_vram": 0 + } + ] + } + }, + { + "ordinal": 2, + "context": { + "route": "bootstrap", + "task": "report-b" + }, + "claim": { + "observed_tick": 52077.761457335, + "ordinal": 2, + "quote_is_proven_bound": false, + "quote_units": 2144, + "request_sha256": "9f8a53322cbab65c56dbf9bff48791aaa7ff6e2ded62d45cc4d51dc68c49365a", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":0,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"12/12\\\",\\\"version\\\":\\\"run/17\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + "usage": { + "input_tokens": 188, + "late": false, + "ordinal": 2, + "output_tokens": 20, + "raw_sha256": "d77401a1c579c0e43179ad5009a979053d5baeee9384139609954a61f5ad4978", + "received_tick": 52080.014650312, + "reconciled": true, + "transport_complete": true, + "within_envelope": true + }, + "raw_response_base64": "eyJtb2RlbCI6Im9ybml0aC0xLjU6OWIiLCJjcmVhdGVkX2F0IjoiMjAyNi0xMS0xNlQwNjoxNTozNi4xNTMwNDIzNjhaIiwibWVzc2FnZSI6eyJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6IntcInJlbGVhc2VcIjpcIlI0MlwiLFwidGVzdHNcIjpcIjEyLzEyXCIsXCJzdGF0dXNcIjpcInBhc3NcIn0ifSwiZG9uZSI6dHJ1ZSwiZG9uZV9yZWFzb24iOiJzdG9wIiwidG90YWxfZHVyYXRpb24iOjIxMTU0NjQ5MjIsImxvYWRfZHVyYXRpb24iOjQ5OTY1OSwicHJvbXB0X2V2YWxfY291bnQiOjE4OCwicHJvbXB0X2V2YWxfY2FjaGVkX2NvdW50IjoxODQsInByb21wdF9ldmFsX2R1cmF0aW9uIjoyNzM3MDUwMDAsImV2YWxfY291bnQiOjIwLCJldmFsX2R1cmF0aW9uIjoxODM5NTQyMDAwfQ==", + "runtime_observation": { + "models": [ + { + "context_length": 2048, + "details": { + "families": [ + "qwen35" + ], + "family": "qwen35", + "format": "gguf", + "parameter_size": "9.0B", + "parent_model": "", + "quantization_level": "Q4_K_M" + }, + "digest": "e5df7dcdd8a263994df62d610317e07be0d6af23f96fcbd8543273058fce575e", + "expires_at": "2026-11-16T06:25:36.153166783Z", + "model": "ornith-1.5:9b", + "name": "ornith-1.5:9b", + "runner": "llamacpp", + "size": 6118650673, + "size_vram": 0 + } + ] + } + }, + { + "ordinal": 3, + "context": { + "certificate_attempt": 2, + "route": "bootstrap", + "task": "release-plan" + }, + "claim": { + "observed_tick": 52080.155618598, + "ordinal": 3, + "quote_is_proven_bound": false, + "quote_units": 2144, + "request_sha256": "4289c0401c6f95b37414bd6664f022a6b57102dcd2744e94e1b14a820d6ca1dd", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/17\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"S42-A\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"staging\\\",\\\"version\\\":\\\"policy/v1\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"pass\\\",\\\"tests\\\":\\\"12/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + "usage": { + "input_tokens": 149, + "late": false, + "ordinal": 3, + "output_tokens": 32, + "raw_sha256": "93ee3a753b7285cfca5b7bd48e94786679844f8c8b4cb9e1aa36c53f8806aa85", + "received_tick": 52088.243852016, + "reconciled": true, + "transport_complete": true, + "within_envelope": true + }, + "raw_response_base64": "eyJtb2RlbCI6Im9ybml0aC0xLjU6OWIiLCJjcmVhdGVkX2F0IjoiMjAyNi0xMS0xNlQwNjoxNTo0NC4zODg1ODg4NjFaIiwibWVzc2FnZSI6eyJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6IntcInJlbGVhc2VcIjpcIlI0MlwiLFwidGFyZ2V0XCI6XCJzdGFnaW5nXCIsXCJhcHByb3ZhbFwiOlwiUzQyLUFcIixcInRlc3RzXCI6XCIxMi8xMlwiLFwiYWN0aW9uXCI6XCJkZXBsb3lcIn0ifSwiZG9uZSI6dHJ1ZSwiZG9uZV9yZWFzb24iOiJzdG9wIiwidG90YWxfZHVyYXRpb24iOjc5NTkzOTIxMDUsImxvYWRfZHVyYXRpb24iOjQ1NDMzMCwicHJvbXB0X2V2YWxfY291bnQiOjE0OSwicHJvbXB0X2V2YWxfY2FjaGVkX2NvdW50IjowLCJwcm9tcHRfZXZhbF9kdXJhdGlvbiI6NDkwMDkwNjAwMCwiZXZhbF9jb3VudCI6MzIsImV2YWxfZHVyYXRpb24iOjMwMzc1MDkwMDB9", + "runtime_observation": { + "models": [ + { + "context_length": 2048, + "details": { + "families": [ + "qwen35" + ], + "family": "qwen35", + "format": "gguf", + "parameter_size": "9.0B", + "parent_model": "", + "quantization_level": "Q4_K_M" + }, + "digest": "e5df7dcdd8a263994df62d610317e07be0d6af23f96fcbd8543273058fce575e", + "expires_at": "2026-11-16T06:25:44.388668738Z", + "model": "ornith-1.5:9b", + "name": "ornith-1.5:9b", + "runner": "llamacpp", + "size": 6118650673, + "size_vram": 0 + } + ] + } + }, + { + "ordinal": 4, + "context": { + "route": "report_correction/repair", + "task": "report-a" + }, + "claim": { + "observed_tick": 52088.617690718, + "ordinal": 4, + "quote_is_proven_bound": false, + "quote_units": 2144, + "request_sha256": "fbb114cef1c2c2d69313855e8f82900b3dbead1138a5b011a70bc299842ce278", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":1,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"11/12\\\",\\\"version\\\":\\\"run/18\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + "usage": { + "input_tokens": 188, + "late": false, + "ordinal": 4, + "output_tokens": 20, + "raw_sha256": "a65329ecd86909bee32a7902983cbffd21d86b6dfe5402129cb03470eed91967", + "received_tick": 52092.349589054, + "reconciled": true, + "transport_complete": true, + "within_envelope": true + }, + "raw_response_base64": "eyJtb2RlbCI6Im9ybml0aC0xLjU6OWIiLCJjcmVhdGVkX2F0IjoiMjAyNi0xMS0xNlQwNjoxNTo0OC40OTM4NDYxNjdaIiwibWVzc2FnZSI6eyJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6IntcInJlbGVhc2VcIjpcIlI0MlwiLFwidGVzdHNcIjpcIjExLzEyXCIsXCJzdGF0dXNcIjpcImZhaWxcIn0ifSwiZG9uZSI6dHJ1ZSwiZG9uZV9yZWFzb24iOiJzdG9wIiwidG90YWxfZHVyYXRpb24iOjM2MDMyMjEwNTksImxvYWRfZHVyYXRpb24iOjQyMzAzMiwicHJvbXB0X2V2YWxfY291bnQiOjE4OCwicHJvbXB0X2V2YWxfY2FjaGVkX2NvdW50IjoxNDQsInByb21wdF9ldmFsX2R1cmF0aW9uIjoxNzQxNzQyMDAwLCJldmFsX2NvdW50IjoyMCwiZXZhbF9kdXJhdGlvbiI6MTgzNDMzMTAwMH0=", + "runtime_observation": { + "models": [ + { + "context_length": 2048, + "details": { + "families": [ + "qwen35" + ], + "family": "qwen35", + "format": "gguf", + "parameter_size": "9.0B", + "parent_model": "", + "quantization_level": "Q4_K_M" + }, + "digest": "e5df7dcdd8a263994df62d610317e07be0d6af23f96fcbd8543273058fce575e", + "expires_at": "2026-11-16T06:25:48.493925833Z", + "model": "ornith-1.5:9b", + "name": "ornith-1.5:9b", + "runner": "llamacpp", + "size": 6118650673, + "size_vram": 0 + } + ] + } + }, + { + "ordinal": 5, + "context": { + "certificate_attempt": 9, + "route": "report_correction/repair", + "task": "release-plan" + }, + "claim": { + "observed_tick": 52092.487485204, + "ordinal": 5, + "quote_is_proven_bound": false, + "quote_units": 2144, + "request_sha256": "055c700171bb57bb9845a99e9fab8aa2acc15f0d5acf06c6ff9fc4321946c859", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/18\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"S42-A\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"staging\\\",\\\"version\\\":\\\"policy/v1\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"fail\\\",\\\"tests\\\":\\\"11/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + "usage": { + "input_tokens": 149, + "late": false, + "ordinal": 5, + "output_tokens": 32, + "raw_sha256": "1d3a0c1aeccb5eae41bf16538395948996c6eb1aee20ceb11f93d6d7b2271946", + "received_tick": 52098.039154395, + "reconciled": true, + "transport_complete": true, + "within_envelope": true + }, + "raw_response_base64": "eyJtb2RlbCI6Im9ybml0aC0xLjU6OWIiLCJjcmVhdGVkX2F0IjoiMjAyNi0xMS0xNlQwNjoxNTo1NC4xODE5OTkxNTNaIiwibWVzc2FnZSI6eyJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6IntcInJlbGVhc2VcIjpcIlI0MlwiLFwidGFyZ2V0XCI6XCJzdGFnaW5nXCIsXCJhcHByb3ZhbFwiOlwiUzQyLUFcIixcInRlc3RzXCI6XCIxMS8xMlwiLFwiYWN0aW9uXCI6XCJob2xkXCJ9In0sImRvbmUiOnRydWUsImRvbmVfcmVhc29uIjoic3RvcCIsInRvdGFsX2R1cmF0aW9uIjo1NDIyMDc3NjkyLCJsb2FkX2R1cmF0aW9uIjo1MTY1NjksInByb21wdF9ldmFsX2NvdW50IjoxNDksInByb21wdF9ldmFsX2NhY2hlZF9jb3VudCI6ODAsInByb21wdF9ldmFsX2R1cmF0aW9uIjoyNDA3OTU4MDAwLCJldmFsX2NvdW50IjozMiwiZXZhbF9kdXJhdGlvbiI6Mjk4NjczMDAwMH0=", + "runtime_observation": { + "models": [ + { + "context_length": 2048, + "details": { + "families": [ + "qwen35" + ], + "family": "qwen35", + "format": "gguf", + "parameter_size": "9.0B", + "parent_model": "", + "quantization_level": "Q4_K_M" + }, + "digest": "e5df7dcdd8a263994df62d610317e07be0d6af23f96fcbd8543273058fce575e", + "expires_at": "2026-11-16T06:25:54.182116248Z", + "model": "ornith-1.5:9b", + "name": "ornith-1.5:9b", + "runner": "llamacpp", + "size": 6118650673, + "size_vram": 0 + } + ] + } + }, + { + "ordinal": 6, + "context": { + "route": "report_correction/fresh", + "task": "report-a" + }, + "claim": { + "observed_tick": 52098.200580582, + "ordinal": 6, + "quote_is_proven_bound": false, + "quote_units": 2144, + "request_sha256": "fbb114cef1c2c2d69313855e8f82900b3dbead1138a5b011a70bc299842ce278", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":1,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"11/12\\\",\\\"version\\\":\\\"run/18\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + "usage": { + "input_tokens": 188, + "late": false, + "ordinal": 6, + "output_tokens": 20, + "raw_sha256": "9b7eae5cc8a4028796b73def23ed93baf8cb3304ff7fe3f557b744fb64182cd1", + "received_tick": 52100.479729856, + "reconciled": true, + "transport_complete": true, + "within_envelope": true + }, + "raw_response_base64": "eyJtb2RlbCI6Im9ybml0aC0xLjU6OWIiLCJjcmVhdGVkX2F0IjoiMjAyNi0xMS0xNlQwNjoxNTo1Ni42MjI3MzE2NzdaIiwibWVzc2FnZSI6eyJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6IntcInJlbGVhc2VcIjpcIlI0MlwiLFwidGVzdHNcIjpcIjExLzEyXCIsXCJzdGF0dXNcIjpcImZhaWxcIn0ifSwiZG9uZSI6dHJ1ZSwiZG9uZV9yZWFzb24iOiJzdG9wIiwidG90YWxfZHVyYXRpb24iOjIxNDcwMTIyMTAsImxvYWRfZHVyYXRpb24iOjQ2MDUxMSwicHJvbXB0X2V2YWxfY291bnQiOjE4OCwicHJvbXB0X2V2YWxfY2FjaGVkX2NvdW50IjoxODQsInByb21wdF9ldmFsX2R1cmF0aW9uIjoyNzA4NjgwMDAsImV2YWxfY291bnQiOjIwLCJldmFsX2R1cmF0aW9uIjoxODQ4MzI5MDAwfQ==", + "runtime_observation": { + "models": [ + { + "context_length": 2048, + "details": { + "families": [ + "qwen35" + ], + "family": "qwen35", + "format": "gguf", + "parameter_size": "9.0B", + "parent_model": "", + "quantization_level": "Q4_K_M" + }, + "digest": "e5df7dcdd8a263994df62d610317e07be0d6af23f96fcbd8543273058fce575e", + "expires_at": "2026-11-16T06:25:56.622803594Z", + "model": "ornith-1.5:9b", + "name": "ornith-1.5:9b", + "runner": "llamacpp", + "size": 6118650673, + "size_vram": 0 + } + ] + } + }, + { + "ordinal": 7, + "context": { + "certificate_attempt": 6, + "route": "report_correction/fresh", + "task": "release-plan" + }, + "claim": { + "observed_tick": 52100.619417554, + "ordinal": 7, + "quote_is_proven_bound": false, + "quote_units": 2144, + "request_sha256": "055c700171bb57bb9845a99e9fab8aa2acc15f0d5acf06c6ff9fc4321946c859", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/18\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"S42-A\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"staging\\\",\\\"version\\\":\\\"policy/v1\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"fail\\\",\\\"tests\\\":\\\"11/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + "usage": { + "input_tokens": 149, + "late": false, + "ordinal": 7, + "output_tokens": 32, + "raw_sha256": "e9093b103ed472a6205345f44daead390da9c96edab552c504037613819d5cf3", + "received_tick": 52104.013598868, + "reconciled": true, + "transport_complete": true, + "within_envelope": true + }, + "raw_response_base64": "eyJtb2RlbCI6Im9ybml0aC0xLjU6OWIiLCJjcmVhdGVkX2F0IjoiMjAyNi0xMS0xNlQwNjoxNjowMC4xNTYxNTUzOTRaIiwibWVzc2FnZSI6eyJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6IntcInJlbGVhc2VcIjpcIlI0MlwiLFwidGFyZ2V0XCI6XCJzdGFnaW5nXCIsXCJhcHByb3ZhbFwiOlwiUzQyLUFcIixcInRlc3RzXCI6XCIxMS8xMlwiLFwiYWN0aW9uXCI6XCJob2xkXCJ9In0sImRvbmUiOnRydWUsImRvbmVfcmVhc29uIjoic3RvcCIsInRvdGFsX2R1cmF0aW9uIjozMjYzNDI5OTg2LCJsb2FkX2R1cmF0aW9uIjo4MjIyMzcsInByb21wdF9ldmFsX2NvdW50IjoxNDksInByb21wdF9ldmFsX2NhY2hlZF9jb3VudCI6MTQ1LCJwcm9tcHRfZXZhbF9kdXJhdGlvbiI6MjcwMTU4MDAwLCJldmFsX2NvdW50IjozMiwiZXZhbF9kdXJhdGlvbiI6Mjk2NTIzMjAwMH0=", + "runtime_observation": { + "models": [ + { + "context_length": 2048, + "details": { + "families": [ + "qwen35" + ], + "family": "qwen35", + "format": "gguf", + "parameter_size": "9.0B", + "parent_model": "", + "quantization_level": "Q4_K_M" + }, + "digest": "e5df7dcdd8a263994df62d610317e07be0d6af23f96fcbd8543273058fce575e", + "expires_at": "2026-11-16T06:26:00.1562592Z", + "model": "ornith-1.5:9b", + "name": "ornith-1.5:9b", + "runner": "llamacpp", + "size": 6118650673, + "size_vram": 0 + } + ] + } + }, + { + "ordinal": 8, + "context": { + "route": "unrelated_policy_change/fresh", + "task": "report-a" + }, + "claim": { + "observed_tick": 52104.334795745, + "ordinal": 8, + "quote_is_proven_bound": false, + "quote_units": 2144, + "request_sha256": "9f8a53322cbab65c56dbf9bff48791aaa7ff6e2ded62d45cc4d51dc68c49365a", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":0,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"12/12\\\",\\\"version\\\":\\\"run/17\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + "usage": { + "input_tokens": 188, + "late": false, + "ordinal": 8, + "output_tokens": 20, + "raw_sha256": "760f4362f00d77abc376d4c9d315257092db2068a0aaffffe380d2fd2283f853", + "received_tick": 52108.075199768, + "reconciled": true, + "transport_complete": true, + "within_envelope": true + }, + "raw_response_base64": "eyJtb2RlbCI6Im9ybml0aC0xLjU6OWIiLCJjcmVhdGVkX2F0IjoiMjAyNi0xMS0xNlQwNjoxNjowNC4yMTc4NDg2MzlaIiwibWVzc2FnZSI6eyJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6IntcInJlbGVhc2VcIjpcIlI0MlwiLFwidGVzdHNcIjpcIjEyLzEyXCIsXCJzdGF0dXNcIjpcInBhc3NcIn0ifSwiZG9uZSI6dHJ1ZSwiZG9uZV9yZWFzb24iOiJzdG9wIiwidG90YWxfZHVyYXRpb24iOjM2MTA4NTA5NjgsImxvYWRfZHVyYXRpb24iOjQwOTQzMywicHJvbXB0X2V2YWxfY291bnQiOjE4OCwicHJvbXB0X2V2YWxfY2FjaGVkX2NvdW50IjoxNDQsInByb21wdF9ldmFsX2R1cmF0aW9uIjoxNzYzMjk5MDAwLCJldmFsX2NvdW50IjoyMCwiZXZhbF9kdXJhdGlvbiI6MTgxOTM5ODAwMH0=", + "runtime_observation": { + "models": [ + { + "context_length": 2048, + "details": { + "families": [ + "qwen35" + ], + "family": "qwen35", + "format": "gguf", + "parameter_size": "9.0B", + "parent_model": "", + "quantization_level": "Q4_K_M" + }, + "digest": "e5df7dcdd8a263994df62d610317e07be0d6af23f96fcbd8543273058fce575e", + "expires_at": "2026-11-16T06:26:04.217969414Z", + "model": "ornith-1.5:9b", + "name": "ornith-1.5:9b", + "runner": "llamacpp", + "size": 6118650673, + "size_vram": 0 + } + ] + } + }, + { + "ordinal": 9, + "context": { + "certificate_attempt": 5, + "route": "unrelated_policy_change/fresh", + "task": "release-plan" + }, + "claim": { + "observed_tick": 52108.222164532, + "ordinal": 9, + "quote_is_proven_bound": false, + "quote_units": 2144, + "request_sha256": "dc1ce58c72ae48fc0bc0de9734c5842fc3c9b0d3eb238f41482aa3296ff8948e", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/17\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"C42-B\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"canary\\\",\\\"version\\\":\\\"policy/v2\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"pass\\\",\\\"tests\\\":\\\"12/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + "usage": { + "input_tokens": 149, + "late": false, + "ordinal": 9, + "output_tokens": 32, + "raw_sha256": "59aa599bfeb6bbd17c0a2656eede2337e6aaa9c739e42e9172f5492a83478e4d", + "received_tick": 52113.838244671, + "reconciled": true, + "transport_complete": true, + "within_envelope": true + }, + "raw_response_base64": "eyJtb2RlbCI6Im9ybml0aC0xLjU6OWIiLCJjcmVhdGVkX2F0IjoiMjAyNi0xMS0xNlQwNjoxNjowOS45ODEwNTYyOTJaIiwibWVzc2FnZSI6eyJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6IntcInJlbGVhc2VcIjpcIlI0MlwiLFwidGFyZ2V0XCI6XCJjYW5hcnlcIixcImFwcHJvdmFsXCI6XCJDNDItQlwiLFwidGVzdHNcIjpcIjEyLzEyXCIsXCJhY3Rpb25cIjpcImRlcGxveVwifSJ9LCJkb25lIjp0cnVlLCJkb25lX3JlYXNvbiI6InN0b3AiLCJ0b3RhbF9kdXJhdGlvbiI6NTQ4NjQzNTE3OSwibG9hZF9kdXJhdGlvbiI6Mzc2NDY1LCJwcm9tcHRfZXZhbF9jb3VudCI6MTQ5LCJwcm9tcHRfZXZhbF9jYWNoZWRfY291bnQiOjgwLCJwcm9tcHRfZXZhbF9kdXJhdGlvbiI6MjQwNzIwMjAwMCwiZXZhbF9jb3VudCI6MzIsImV2YWxfZHVyYXRpb24iOjMwNTE4OTIwMDB9", + "runtime_observation": { + "models": [ + { + "context_length": 2048, + "details": { + "families": [ + "qwen35" + ], + "family": "qwen35", + "format": "gguf", + "parameter_size": "9.0B", + "parent_model": "", + "quantization_level": "Q4_K_M" + }, + "digest": "e5df7dcdd8a263994df62d610317e07be0d6af23f96fcbd8543273058fce575e", + "expires_at": "2026-11-16T06:26:09.981140509Z", + "model": "ornith-1.5:9b", + "name": "ornith-1.5:9b", + "runner": "llamacpp", + "size": 6118650673, + "size_vram": 0 + } + ] + } + }, + { + "ordinal": 10, + "context": { + "certificate_attempt": 8, + "route": "unrelated_policy_change/repair", + "task": "release-plan" + }, + "claim": { + "observed_tick": 52114.03530755, + "ordinal": 10, + "quote_is_proven_bound": false, + "quote_units": 2144, + "request_sha256": "dc1ce58c72ae48fc0bc0de9734c5842fc3c9b0d3eb238f41482aa3296ff8948e", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/17\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"C42-B\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"canary\\\",\\\"version\\\":\\\"policy/v2\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"pass\\\",\\\"tests\\\":\\\"12/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + "usage": { + "input_tokens": 149, + "late": false, + "ordinal": 10, + "output_tokens": 32, + "raw_sha256": "e94f0271335e3755c68787e5b9b173da9113ff3c6eae0a780d8d4d085a190f6d", + "received_tick": 52117.534747366, + "reconciled": true, + "transport_complete": true, + "within_envelope": true + }, + "raw_response_base64": "eyJtb2RlbCI6Im9ybml0aC0xLjU6OWIiLCJjcmVhdGVkX2F0IjoiMjAyNi0xMS0xNlQwNjoxNjoxMy42Nzc4OTQ4OTJaIiwibWVzc2FnZSI6eyJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6IntcInJlbGVhc2VcIjpcIlI0MlwiLFwidGFyZ2V0XCI6XCJjYW5hcnlcIixcImFwcHJvdmFsXCI6XCJDNDItQlwiLFwidGVzdHNcIjpcIjEyLzEyXCIsXCJhY3Rpb25cIjpcImRlcGxveVwifSJ9LCJkb25lIjp0cnVlLCJkb25lX3JlYXNvbiI6InN0b3AiLCJ0b3RhbF9kdXJhdGlvbiI6MzM3MjEwMjAwMiwibG9hZF9kdXJhdGlvbiI6NDk1ODMwLCJwcm9tcHRfZXZhbF9jb3VudCI6MTQ5LCJwcm9tcHRfZXZhbF9jYWNoZWRfY291bnQiOjE0NSwicHJvbXB0X2V2YWxfZHVyYXRpb24iOjI3Mjk1MDAwMCwiZXZhbF9jb3VudCI6MzIsImV2YWxfZHVyYXRpb24iOjMwOTY1NTcwMDB9", + "runtime_observation": { + "models": [ + { + "context_length": 2048, + "details": { + "families": [ + "qwen35" + ], + "family": "qwen35", + "format": "gguf", + "parameter_size": "9.0B", + "parent_model": "", + "quantization_level": "Q4_K_M" + }, + "digest": "e5df7dcdd8a263994df62d610317e07be0d6af23f96fcbd8543273058fce575e", + "expires_at": "2026-11-16T06:26:13.677981928Z", + "model": "ornith-1.5:9b", + "name": "ornith-1.5:9b", + "runner": "llamacpp", + "size": 6118650673, + "size_vram": 0 + } + ] + } + }, + { + "ordinal": 11, + "context": { + "route": "alternative_support/fresh", + "task": "report-b" + }, + "claim": { + "observed_tick": 52118.087713159, + "ordinal": 11, + "quote_is_proven_bound": false, + "quote_units": 2144, + "request_sha256": "9f8a53322cbab65c56dbf9bff48791aaa7ff6e2ded62d45cc4d51dc68c49365a", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":0,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"12/12\\\",\\\"version\\\":\\\"run/17\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + "usage": { + "input_tokens": 188, + "late": false, + "ordinal": 11, + "output_tokens": 20, + "raw_sha256": "32469c778b6b08cb165b6850327dc96dc0a86f2f102dc8cee98f8ad8dd415504", + "received_tick": 52120.36717979, + "reconciled": true, + "transport_complete": true, + "within_envelope": true + }, + "raw_response_base64": "eyJtb2RlbCI6Im9ybml0aC0xLjU6OWIiLCJjcmVhdGVkX2F0IjoiMjAyNi0xMS0xNlQwNjoxNjoxNi41MTAwNzAzODRaIiwibWVzc2FnZSI6eyJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6IntcInJlbGVhc2VcIjpcIlI0MlwiLFwidGVzdHNcIjpcIjEyLzEyXCIsXCJzdGF0dXNcIjpcInBhc3NcIn0ifSwiZG9uZSI6dHJ1ZSwiZG9uZV9yZWFzb24iOiJzdG9wIiwidG90YWxfZHVyYXRpb24iOjIxNDY3NDk0MzYsImxvYWRfZHVyYXRpb24iOjM4NzIwNSwicHJvbXB0X2V2YWxfY291bnQiOjE4OCwicHJvbXB0X2V2YWxfY2FjaGVkX2NvdW50IjoxODQsInByb21wdF9ldmFsX2R1cmF0aW9uIjoyNzM3ODAwMDAsImV2YWxfY291bnQiOjIwLCJldmFsX2R1cmF0aW9uIjoxODQzMjAxMDAwfQ==", + "runtime_observation": { + "models": [ + { + "context_length": 2048, + "details": { + "families": [ + "qwen35" + ], + "family": "qwen35", + "format": "gguf", + "parameter_size": "9.0B", + "parent_model": "", + "quantization_level": "Q4_K_M" + }, + "digest": "e5df7dcdd8a263994df62d610317e07be0d6af23f96fcbd8543273058fce575e", + "expires_at": "2026-11-16T06:26:16.510230138Z", + "model": "ornith-1.5:9b", + "name": "ornith-1.5:9b", + "runner": "llamacpp", + "size": 6118650673, + "size_vram": 0 + } + ] + } + }, + { + "ordinal": 12, + "context": { + "certificate_attempt": 5, + "route": "alternative_support/fresh", + "task": "release-plan" + }, + "claim": { + "observed_tick": 52120.502403968, + "ordinal": 12, + "quote_is_proven_bound": false, + "quote_units": 2144, + "request_sha256": "4289c0401c6f95b37414bd6664f022a6b57102dcd2744e94e1b14a820d6ca1dd", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/17\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"S42-A\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"staging\\\",\\\"version\\\":\\\"policy/v1\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"pass\\\",\\\"tests\\\":\\\"12/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + "usage": { + "input_tokens": 149, + "late": false, + "ordinal": 12, + "output_tokens": 32, + "raw_sha256": "a27506cb84628292c574590ef8c3b4f2b2a172a009d90e7d19a0d98a103ae548", + "received_tick": 52126.08510628, + "reconciled": true, + "transport_complete": true, + "within_envelope": true + }, + "raw_response_base64": "eyJtb2RlbCI6Im9ybml0aC0xLjU6OWIiLCJjcmVhdGVkX2F0IjoiMjAyNi0xMS0xNlQwNjoxNjoyMi4yMjk1MjEwOVoiLCJtZXNzYWdlIjp7InJvbGUiOiJhc3Npc3RhbnQiLCJjb250ZW50Ijoie1wicmVsZWFzZVwiOlwiUjQyXCIsXCJ0YXJnZXRcIjpcInN0YWdpbmdcIixcImFwcHJvdmFsXCI6XCJTNDItQVwiLFwidGVzdHNcIjpcIjEyLzEyXCIsXCJhY3Rpb25cIjpcImRlcGxveVwifSJ9LCJkb25lIjp0cnVlLCJkb25lX3JlYXNvbiI6InN0b3AiLCJ0b3RhbF9kdXJhdGlvbiI6NTQ1MTg4MTUwNSwibG9hZF9kdXJhdGlvbiI6NDY1MzMxLCJwcm9tcHRfZXZhbF9jb3VudCI6MTQ5LCJwcm9tcHRfZXZhbF9jYWNoZWRfY291bnQiOjgwLCJwcm9tcHRfZXZhbF9kdXJhdGlvbiI6MjQxNTA1OTAwMCwiZXZhbF9jb3VudCI6MzIsImV2YWxfZHVyYXRpb24iOjMwMDc1MjEwMDB9", + "runtime_observation": { + "models": [ + { + "context_length": 2048, + "details": { + "families": [ + "qwen35" + ], + "family": "qwen35", + "format": "gguf", + "parameter_size": "9.0B", + "parent_model": "", + "quantization_level": "Q4_K_M" + }, + "digest": "e5df7dcdd8a263994df62d610317e07be0d6af23f96fcbd8543273058fce575e", + "expires_at": "2026-11-16T06:26:22.229605017Z", + "model": "ornith-1.5:9b", + "name": "ornith-1.5:9b", + "runner": "llamacpp", + "size": 6118650673, + "size_vram": 0 + } + ] + } + }, + { + "ordinal": 13, + "context": { + "certificate_attempt": 8, + "route": "alternative_support/repair", + "task": "release-plan" + }, + "claim": { + "observed_tick": 52126.283342748, + "ordinal": 13, + "quote_is_proven_bound": false, + "quote_units": 2144, + "request_sha256": "4289c0401c6f95b37414bd6664f022a6b57102dcd2744e94e1b14a820d6ca1dd", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/17\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"S42-A\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"staging\\\",\\\"version\\\":\\\"policy/v1\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"pass\\\",\\\"tests\\\":\\\"12/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + "usage": { + "input_tokens": 149, + "late": false, + "ordinal": 13, + "output_tokens": 32, + "raw_sha256": "b61ff5e96fd5303475b02c863395cbb4569ed16e98ca1d51b943af3052a1a66d", + "received_tick": 52129.711824261, + "reconciled": true, + "transport_complete": true, + "within_envelope": true + }, + "raw_response_base64": "eyJtb2RlbCI6Im9ybml0aC0xLjU6OWIiLCJjcmVhdGVkX2F0IjoiMjAyNi0xMS0xNlQwNjoxNjoyNS44NTQ0MjU1NDJaIiwibWVzc2FnZSI6eyJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6IntcInJlbGVhc2VcIjpcIlI0MlwiLFwidGFyZ2V0XCI6XCJzdGFnaW5nXCIsXCJhcHByb3ZhbFwiOlwiUzQyLUFcIixcInRlc3RzXCI6XCIxMi8xMlwiLFwiYWN0aW9uXCI6XCJkZXBsb3lcIn0ifSwiZG9uZSI6dHJ1ZSwiZG9uZV9yZWFzb24iOiJzdG9wIiwidG90YWxfZHVyYXRpb24iOjMyOTM2MjI0ODcsImxvYWRfZHVyYXRpb24iOjUzMDM1OSwicHJvbXB0X2V2YWxfY291bnQiOjE0OSwicHJvbXB0X2V2YWxfY2FjaGVkX2NvdW50IjoxNDUsInByb21wdF9ldmFsX2R1cmF0aW9uIjoyNzMwMjAwMDAsImV2YWxfY291bnQiOjMyLCJldmFsX2R1cmF0aW9uIjozMDE4MzUyMDAwfQ==", + "runtime_observation": { + "models": [ + { + "context_length": 2048, + "details": { + "families": [ + "qwen35" + ], + "family": "qwen35", + "format": "gguf", + "parameter_size": "9.0B", + "parent_model": "", + "quantization_level": "Q4_K_M" + }, + "digest": "e5df7dcdd8a263994df62d610317e07be0d6af23f96fcbd8543273058fce575e", + "expires_at": "2026-11-16T06:26:25.854495099Z", + "model": "ornith-1.5:9b", + "name": "ornith-1.5:9b", + "runner": "llamacpp", + "size": 6118650673, + "size_vram": 0 + } + ] + } + } + ], + "store_events": [ + { + "attempt": 2, + "context": { + "route": "bootstrap", + "task": "report-a" + }, + "kind": "prepared", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":0,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"12/12\\\",\\\"version\\\":\\\"run/17\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + { + "attempt": 2, + "context": { + "route": "bootstrap", + "task": "report-a" + }, + "kind": "dispatch", + "ordinal": 1 + }, + { + "attempt": 2, + "context": { + "route": "bootstrap", + "task": "report-a" + }, + "input_units": 188, + "kind": "received", + "output": "{\"release\":\"R42\",\"tests\":\"12/12\",\"status\":\"pass\"}", + "output_units": 20, + "roundtrip_us": 13267972 + }, + { + "attempt": 2, + "context": { + "route": "bootstrap", + "task": "report-a" + }, + "kind": "settled", + "store_disposition": "Accepted", + "usage": 208 + }, + { + "attempt": 3, + "context": { + "route": "bootstrap", + "task": "report-b" + }, + "kind": "prepared", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":0,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"12/12\\\",\\\"version\\\":\\\"run/17\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + { + "attempt": 3, + "context": { + "route": "bootstrap", + "task": "report-b" + }, + "kind": "dispatch", + "ordinal": 2 + }, + { + "attempt": 3, + "context": { + "route": "bootstrap", + "task": "report-b" + }, + "input_units": 188, + "kind": "received", + "output": "{\"release\":\"R42\",\"tests\":\"12/12\",\"status\":\"pass\"}", + "output_units": 20, + "roundtrip_us": 2330464 + }, + { + "attempt": 3, + "context": { + "route": "bootstrap", + "task": "report-b" + }, + "kind": "settled", + "store_disposition": "Accepted", + "usage": 208 + }, + { + "attempt": 4, + "context": { + "certificate_attempt": 2, + "route": "bootstrap", + "task": "release-plan" + }, + "kind": "prepared", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/17\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"S42-A\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"staging\\\",\\\"version\\\":\\\"policy/v1\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"pass\\\",\\\"tests\\\":\\\"12/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + { + "attempt": 4, + "context": { + "certificate_attempt": 2, + "route": "bootstrap", + "task": "release-plan" + }, + "kind": "dispatch", + "ordinal": 3 + }, + { + "attempt": 4, + "context": { + "certificate_attempt": 2, + "route": "bootstrap", + "task": "release-plan" + }, + "input_units": 149, + "kind": "received", + "output": "{\"release\":\"R42\",\"target\":\"staging\",\"approval\":\"S42-A\",\"tests\":\"12/12\",\"action\":\"deploy\"}", + "output_units": 32, + "roundtrip_us": 8162710 + }, + { + "attempt": 4, + "context": { + "certificate_attempt": 2, + "route": "bootstrap", + "task": "release-plan" + }, + "kind": "settled", + "store_disposition": "Accepted", + "usage": 181 + }, + { + "attempt": 9, + "context": { + "route": "report_correction/repair", + "task": "report-a" + }, + "kind": "prepared", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":1,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"11/12\\\",\\\"version\\\":\\\"run/18\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + { + "attempt": 9, + "context": { + "route": "report_correction/repair", + "task": "report-a" + }, + "kind": "dispatch", + "ordinal": 4 + }, + { + "attempt": 9, + "context": { + "route": "report_correction/repair", + "task": "report-a" + }, + "input_units": 188, + "kind": "received", + "output": "{\"release\":\"R42\",\"tests\":\"11/12\",\"status\":\"fail\"}", + "output_units": 20, + "roundtrip_us": 3809404 + }, + { + "attempt": 9, + "context": { + "route": "report_correction/repair", + "task": "report-a" + }, + "kind": "settled", + "store_disposition": "Accepted", + "usage": 208 + }, + { + "attempt": 10, + "context": { + "certificate_attempt": 9, + "route": "report_correction/repair", + "task": "release-plan" + }, + "kind": "prepared", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/18\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"S42-A\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"staging\\\",\\\"version\\\":\\\"policy/v1\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"fail\\\",\\\"tests\\\":\\\"11/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + { + "attempt": 10, + "context": { + "certificate_attempt": 9, + "route": "report_correction/repair", + "task": "release-plan" + }, + "kind": "dispatch", + "ordinal": 5 + }, + { + "attempt": 10, + "context": { + "certificate_attempt": 9, + "route": "report_correction/repair", + "task": "release-plan" + }, + "input_units": 149, + "kind": "received", + "output": "{\"release\":\"R42\",\"target\":\"staging\",\"approval\":\"S42-A\",\"tests\":\"11/12\",\"action\":\"hold\"}", + "output_units": 32, + "roundtrip_us": 5626679 + }, + { + "attempt": 10, + "context": { + "certificate_attempt": 9, + "route": "report_correction/repair", + "task": "release-plan" + }, + "kind": "settled", + "store_disposition": "Accepted", + "usage": 181 + }, + { + "attempt": 6, + "context": { + "route": "report_correction/fresh", + "task": "report-a" + }, + "kind": "prepared", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":1,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"11/12\\\",\\\"version\\\":\\\"run/18\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + { + "attempt": 6, + "context": { + "route": "report_correction/fresh", + "task": "report-a" + }, + "kind": "dispatch", + "ordinal": 6 + }, + { + "attempt": 6, + "context": { + "route": "report_correction/fresh", + "task": "report-a" + }, + "input_units": 188, + "kind": "received", + "output": "{\"release\":\"R42\",\"tests\":\"11/12\",\"status\":\"fail\"}", + "output_units": 20, + "roundtrip_us": 2357802 + }, + { + "attempt": 6, + "context": { + "route": "report_correction/fresh", + "task": "report-a" + }, + "kind": "settled", + "store_disposition": "Accepted", + "usage": 208 + }, + { + "attempt": 7, + "context": { + "certificate_attempt": 6, + "route": "report_correction/fresh", + "task": "release-plan" + }, + "kind": "prepared", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/18\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"S42-A\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"staging\\\",\\\"version\\\":\\\"policy/v1\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"fail\\\",\\\"tests\\\":\\\"11/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + { + "attempt": 7, + "context": { + "certificate_attempt": 6, + "route": "report_correction/fresh", + "task": "release-plan" + }, + "kind": "dispatch", + "ordinal": 7 + }, + { + "attempt": 7, + "context": { + "certificate_attempt": 6, + "route": "report_correction/fresh", + "task": "release-plan" + }, + "input_units": 149, + "kind": "received", + "output": "{\"release\":\"R42\",\"target\":\"staging\",\"approval\":\"S42-A\",\"tests\":\"11/12\",\"action\":\"hold\"}", + "output_units": 32, + "roundtrip_us": 3472339 + }, + { + "attempt": 7, + "context": { + "certificate_attempt": 6, + "route": "report_correction/fresh", + "task": "release-plan" + }, + "kind": "settled", + "store_disposition": "Accepted", + "usage": 181 + }, + { + "kind": "pair_complete", + "result": { + "fresh": { + "dispatches": 2, + "origin": 6, + "outcome": "accepted", + "plan": { + "action": "hold", + "approval": "S42-A", + "release": "R42", + "target": "staging", + "tests": "11/12" + }, + "report_branch": "report-a", + "requests": [ + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":1,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"11/12\\\",\\\"version\\\":\\\"run/18\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}", + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/18\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"S42-A\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"staging\\\",\\\"version\\\":\\\"policy/v1\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"fail\\\",\\\"tests\\\":\\\"11/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + ], + "reused": false, + "route_us": 5977737 + }, + "repair": { + "dispatches": 2, + "origin": 9, + "outcome": "accepted", + "plan": { + "action": "hold", + "approval": "S42-A", + "release": "R42", + "target": "staging", + "tests": "11/12" + }, + "report_branch": "report-a", + "requests": [ + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":1,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"11/12\\\",\\\"version\\\":\\\"run/18\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}", + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/18\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"S42-A\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"staging\\\",\\\"version\\\":\\\"policy/v1\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"fail\\\",\\\"tests\\\":\\\"11/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + ], + "reused": false, + "route_us": 9601611 + }, + "requests_equal": true, + "scenario": "report_correction", + "typed_support": false + } + }, + { + "attempt": 5, + "context": { + "route": "unrelated_policy_change/fresh", + "task": "report-a" + }, + "kind": "prepared", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":0,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"12/12\\\",\\\"version\\\":\\\"run/17\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + { + "attempt": 5, + "context": { + "route": "unrelated_policy_change/fresh", + "task": "report-a" + }, + "kind": "dispatch", + "ordinal": 8 + }, + { + "attempt": 5, + "context": { + "route": "unrelated_policy_change/fresh", + "task": "report-a" + }, + "input_units": 188, + "kind": "received", + "output": "{\"release\":\"R42\",\"tests\":\"12/12\",\"status\":\"pass\"}", + "output_units": 20, + "roundtrip_us": 3817252 + }, + { + "attempt": 5, + "context": { + "route": "unrelated_policy_change/fresh", + "task": "report-a" + }, + "kind": "settled", + "store_disposition": "Accepted", + "usage": 208 + }, + { + "attempt": 6, + "context": { + "certificate_attempt": 5, + "route": "unrelated_policy_change/fresh", + "task": "release-plan" + }, + "kind": "prepared", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/17\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"C42-B\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"canary\\\",\\\"version\\\":\\\"policy/v2\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"pass\\\",\\\"tests\\\":\\\"12/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + { + "attempt": 6, + "context": { + "certificate_attempt": 5, + "route": "unrelated_policy_change/fresh", + "task": "release-plan" + }, + "kind": "dispatch", + "ordinal": 9 + }, + { + "attempt": 6, + "context": { + "certificate_attempt": 5, + "route": "unrelated_policy_change/fresh", + "task": "release-plan" + }, + "input_units": 149, + "kind": "received", + "output": "{\"release\":\"R42\",\"target\":\"canary\",\"approval\":\"C42-B\",\"tests\":\"12/12\",\"action\":\"deploy\"}", + "output_units": 32, + "roundtrip_us": 5692689 + }, + { + "attempt": 6, + "context": { + "certificate_attempt": 5, + "route": "unrelated_policy_change/fresh", + "task": "release-plan" + }, + "kind": "settled", + "store_disposition": "Accepted", + "usage": 181 + }, + { + "attempt": 8, + "context": { + "route": "unrelated_policy_change/repair", + "task": "report-a" + }, + "kind": "prepared", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":0,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"12/12\\\",\\\"version\\\":\\\"run/17\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + { + "attempt": 8, + "context": { + "route": "unrelated_policy_change/repair", + "task": "report-a" + }, + "kind": "reused", + "new_usage": 0, + "origin": 2, + "output": "{\"release\":\"R42\",\"tests\":\"12/12\",\"status\":\"pass\"}" + }, + { + "attempt": 9, + "context": { + "certificate_attempt": 8, + "route": "unrelated_policy_change/repair", + "task": "release-plan" + }, + "kind": "prepared", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/17\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"C42-B\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"canary\\\",\\\"version\\\":\\\"policy/v2\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"pass\\\",\\\"tests\\\":\\\"12/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + { + "attempt": 9, + "context": { + "certificate_attempt": 8, + "route": "unrelated_policy_change/repair", + "task": "release-plan" + }, + "kind": "dispatch", + "ordinal": 10 + }, + { + "attempt": 9, + "context": { + "certificate_attempt": 8, + "route": "unrelated_policy_change/repair", + "task": "release-plan" + }, + "input_units": 149, + "kind": "received", + "output": "{\"release\":\"R42\",\"target\":\"canary\",\"approval\":\"C42-B\",\"tests\":\"12/12\",\"action\":\"deploy\"}", + "output_units": 32, + "roundtrip_us": 3576692 + }, + { + "attempt": 9, + "context": { + "certificate_attempt": 8, + "route": "unrelated_policy_change/repair", + "task": "release-plan" + }, + "kind": "settled", + "store_disposition": "Accepted", + "usage": 181 + }, + { + "kind": "pair_complete", + "result": { + "fresh": { + "dispatches": 2, + "origin": 5, + "outcome": "accepted", + "plan": { + "action": "deploy", + "approval": "C42-B", + "release": "R42", + "target": "canary", + "tests": "12/12" + }, + "report_branch": "report-a", + "requests": [ + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":0,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"12/12\\\",\\\"version\\\":\\\"run/17\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}", + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/17\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"C42-B\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"canary\\\",\\\"version\\\":\\\"policy/v2\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"pass\\\",\\\"tests\\\":\\\"12/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + ], + "reused": false, + "route_us": 9668588 + }, + "repair": { + "dispatches": 1, + "origin": 2, + "outcome": "accepted", + "plan": { + "action": "deploy", + "approval": "C42-B", + "release": "R42", + "target": "canary", + "tests": "12/12" + }, + "report_branch": "report-a", + "requests": [ + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":0,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"12/12\\\",\\\"version\\\":\\\"run/17\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}", + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/17\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"C42-B\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"canary\\\",\\\"version\\\":\\\"policy/v2\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"pass\\\",\\\"tests\\\":\\\"12/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + ], + "reused": true, + "route_us": 3697907 + }, + "requests_equal": true, + "scenario": "unrelated_policy_change", + "typed_support": true + } + }, + { + "attempt": 9, + "context": "withdrawal/repair", + "kind": "unavailable_evidence" + }, + { + "attempt": 6, + "context": "withdrawal/fresh", + "kind": "unavailable_evidence" + }, + { + "kind": "pair_complete", + "result": { + "fresh": { + "dispatches": 0, + "outcome": "unavailable_evidence", + "plan": null, + "requests": [] + }, + "repair": { + "dispatches": 0, + "outcome": "unavailable_evidence", + "plan": null, + "requests": [] + }, + "requests_equal": true, + "scenario": "withdrawal", + "typed_support": false + } + }, + { + "attempt": 5, + "context": { + "route": "alternative_support/fresh", + "task": "report-b" + }, + "kind": "prepared", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":0,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"12/12\\\",\\\"version\\\":\\\"run/17\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + { + "attempt": 5, + "context": { + "route": "alternative_support/fresh", + "task": "report-b" + }, + "kind": "dispatch", + "ordinal": 11 + }, + { + "attempt": 5, + "context": { + "route": "alternative_support/fresh", + "task": "report-b" + }, + "input_units": 188, + "kind": "received", + "output": "{\"release\":\"R42\",\"tests\":\"12/12\",\"status\":\"pass\"}", + "output_units": 20, + "roundtrip_us": 2354055 + }, + { + "attempt": 5, + "context": { + "route": "alternative_support/fresh", + "task": "report-b" + }, + "kind": "settled", + "store_disposition": "Accepted", + "usage": 208 + }, + { + "attempt": 6, + "context": { + "certificate_attempt": 5, + "route": "alternative_support/fresh", + "task": "release-plan" + }, + "kind": "prepared", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/17\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"S42-A\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"staging\\\",\\\"version\\\":\\\"policy/v1\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"pass\\\",\\\"tests\\\":\\\"12/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + { + "attempt": 6, + "context": { + "certificate_attempt": 5, + "route": "alternative_support/fresh", + "task": "release-plan" + }, + "kind": "dispatch", + "ordinal": 12 + }, + { + "attempt": 6, + "context": { + "certificate_attempt": 5, + "route": "alternative_support/fresh", + "task": "release-plan" + }, + "input_units": 149, + "kind": "received", + "output": "{\"release\":\"R42\",\"target\":\"staging\",\"approval\":\"S42-A\",\"tests\":\"12/12\",\"action\":\"deploy\"}", + "output_units": 32, + "roundtrip_us": 5658512 + }, + { + "attempt": 6, + "context": { + "certificate_attempt": 5, + "route": "alternative_support/fresh", + "task": "release-plan" + }, + "kind": "settled", + "store_disposition": "Accepted", + "usage": 181 + }, + { + "attempt": 8, + "context": { + "route": "alternative_support/repair", + "task": "report-b" + }, + "kind": "prepared", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":0,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"12/12\\\",\\\"version\\\":\\\"run/17\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + { + "attempt": 8, + "context": { + "route": "alternative_support/repair", + "task": "report-b" + }, + "kind": "reused", + "new_usage": 0, + "origin": 3, + "output": "{\"release\":\"R42\",\"tests\":\"12/12\",\"status\":\"pass\"}" + }, + { + "attempt": 9, + "context": { + "certificate_attempt": 8, + "route": "alternative_support/repair", + "task": "release-plan" + }, + "kind": "prepared", + "request_utf8": "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/17\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"S42-A\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"staging\\\",\\\"version\\\":\\\"policy/v1\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"pass\\\",\\\"tests\\\":\\\"12/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + }, + { + "attempt": 9, + "context": { + "certificate_attempt": 8, + "route": "alternative_support/repair", + "task": "release-plan" + }, + "kind": "dispatch", + "ordinal": 13 + }, + { + "attempt": 9, + "context": { + "certificate_attempt": 8, + "route": "alternative_support/repair", + "task": "release-plan" + }, + "input_units": 149, + "kind": "received", + "output": "{\"release\":\"R42\",\"target\":\"staging\",\"approval\":\"S42-A\",\"tests\":\"12/12\",\"action\":\"deploy\"}", + "output_units": 32, + "roundtrip_us": 3507287 + }, + { + "attempt": 9, + "context": { + "certificate_attempt": 8, + "route": "alternative_support/repair", + "task": "release-plan" + }, + "kind": "settled", + "store_disposition": "Accepted", + "usage": 181 + }, + { + "kind": "pair_complete", + "result": { + "fresh": { + "dispatches": 2, + "origin": 5, + "outcome": "accepted", + "plan": { + "action": "deploy", + "approval": "S42-A", + "release": "R42", + "target": "staging", + "tests": "12/12" + }, + "report_branch": "report-b", + "requests": [ + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":0,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"12/12\\\",\\\"version\\\":\\\"run/17\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}", + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/17\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"S42-A\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"staging\\\",\\\"version\\\":\\\"policy/v1\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"pass\\\",\\\"tests\\\":\\\"12/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + ], + "reused": false, + "route_us": 8159465 + }, + "repair": { + "dispatches": 1, + "origin": 3, + "outcome": "accepted", + "plan": { + "action": "deploy", + "approval": "S42-A", + "release": "R42", + "target": "staging", + "tests": "12/12" + }, + "report_branch": "report-b", + "requests": [ + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Extract the release test verdict. Even ONE failing case makes the entire verdict \\\"fail\\\".\\nCI example A: {\\\"release\\\":\\\"EX1\\\",\\\"test_summary\\\":\\\"7/8\\\",\\\"failing_cases\\\":1} -> {\\\"release\\\":\\\"EX1\\\",\\\"tests\\\":\\\"7/8\\\",\\\"status\\\":\\\"fail\\\"}\\nCI example B: {\\\"release\\\":\\\"EX2\\\",\\\"test_summary\\\":\\\"8/8\\\",\\\"failing_cases\\\":0} -> {\\\"release\\\":\\\"EX2\\\",\\\"tests\\\":\\\"8/8\\\",\\\"status\\\":\\\"pass\\\"}\\nRead the user's ci_report. Copy release and test_summary. If failing_cases is positive use \\\"fail\\\"; only zero uses \\\"pass\\\". Return only JSON with keys release, tests, status.\",\"role\":\"system\"},{\"content\":\"{\\\"ci_report\\\":{\\\"failing_cases\\\":0,\\\"release\\\":\\\"R42\\\",\\\"test_summary\\\":\\\"12/12\\\",\\\"version\\\":\\\"run/17\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}", + "{\"keep_alive\":\"10m\",\"messages\":[{\"content\":\"Create a JSON release plan. Copy release, target and approval from requirement. Copy tests from test_certificate. The certificate decides the action: {\\\"status\\\":\\\"pass\\\"} means {\\\"action\\\":\\\"deploy\\\"}; {\\\"status\\\":\\\"fail\\\"} means {\\\"action\\\":\\\"hold\\\"} even with an approval code. Return exactly five string fields: release, target, approval, tests, action. No explanation.\",\"role\":\"system\"},{\"content\":\"{\\\"report_version\\\":\\\"run/17\\\",\\\"requirement\\\":{\\\"approval\\\":\\\"S42-A\\\",\\\"release\\\":\\\"R42\\\",\\\"target\\\":\\\"staging\\\",\\\"version\\\":\\\"policy/v1\\\"},\\\"test_certificate\\\":{\\\"release\\\":\\\"R42\\\",\\\"status\\\":\\\"pass\\\",\\\"tests\\\":\\\"12/12\\\"}}\",\"role\":\"user\"}],\"model\":\"ornith-1.5:9b\",\"options\":{\"num_ctx\":2048,\"num_gpu\":0,\"num_predict\":96,\"num_thread\":2,\"seed\":0,\"temperature\":0,\"top_k\":1,\"top_p\":1},\"runner\":\"ggml\",\"shift\":false,\"stream\":false,\"think\":false,\"truncate\":false}" + ], + "reused": true, + "route_us": 3628795 + }, + "requests_equal": true, + "scenario": "alternative_support", + "typed_support": true + } + } + ], + "runtime_final_state": { + "CheckpointedAt": "0001-01-01T00:00:00Z", + "Dead": false, + "Error": "", + "ExitCode": 137, + "FinishedAt": "2026-11-16T01:16:26.4046793-05:00", + "OOMKilled": false, + "OciVersion": "1.3.0", + "Paused": false, + "Pid": 0, + "Restarting": false, + "RestoredAt": "0001-01-01T00:00:00Z", + "Running": false, + "StartedAt": "2026-11-16T01:15:20.067782892-05:00", + "Status": "exited", + "StoppedByUser": true + }, + "watchdog": { + "actions": [], + "cleanup_verified": true, + "deadline": 53860.335399561, + "error": null, + "observed_tick": 52130.466236245, + "reason": "completed" + }, + "retained_file_manifest": [ + { + "path": "claim-01.json", + "bytes": 1362, + "sha256": "1e8f02691aa2ff6bdcdc42a9c487953f58a2c16bf5a24223a5e3d50be78a8683" + }, + { + "path": "claim-02.json", + "bytes": 1362, + "sha256": "bfb1e57df146f214572e498c3a62c660683dc1cceb36c2f5a8b1aff77503de5f" + }, + { + "path": "claim-03.json", + "bytes": 1263, + "sha256": "6c723620fb6489ad72ddac788fec49e2b1d80c5ab1f42cf17a5cdb0023a29717" + }, + { + "path": "claim-04.json", + "bytes": 1362, + "sha256": "419689fc19270dd799de2b4b2d9d2a11473921fe804d43e3c404bd115a622ab6" + }, + { + "path": "claim-05.json", + "bytes": 1263, + "sha256": "25213167e9b26d1869b4f611244bceb9e03ce9b6d386b3d6494f4c8bf23f2b51" + }, + { + "path": "claim-06.json", + "bytes": 1362, + "sha256": "524c4c263c4bdb95ff5cdbd71c6dc0e70f103f2805a2701670949f8622a47219" + }, + { + "path": "claim-07.json", + "bytes": 1263, + "sha256": "76f3643c69f29cb8c10973f8c151b0f5a3936b94b69066fcd170564f175502b0" + }, + { + "path": "claim-08.json", + "bytes": 1362, + "sha256": "5aa48f2a1597d81303763607735819bebf6f792d10e21212ab248e022b06932d" + }, + { + "path": "claim-09.json", + "bytes": 1262, + "sha256": "48575e3f65f5c2e72f3aa635dc8062b121f5f4c66be7cfdc4d182d2311da0ff8" + }, + { + "path": "claim-10.json", + "bytes": 1262, + "sha256": "df0fed73f3a384d68dd15643a5102f452b88c87a7e0511ca42465a2101cbe87a" + }, + { + "path": "claim-11.json", + "bytes": 1363, + "sha256": "54b7013877cb827a0b8ef4a777c72d59bdf1f5d880d276c9f956c1682ed63eb0" + }, + { + "path": "claim-12.json", + "bytes": 1264, + "sha256": "56dc62a4d884d66ac849081b0a1447e6029ffbdc4cac60031ffde055e8755468" + }, + { + "path": "claim-13.json", + "bytes": 1264, + "sha256": "8758a3392085d29b2ab2d6d6fe0381b336d1326a33141c908d2b2fe12524d381" + }, + { + "path": "execution.json", + "bytes": 4252, + "sha256": "3e3b5cd1bf24bdbe052b8ec3dbaaef9a4383c78f343227d2a432c719c528acd2" + }, + { + "path": "raw-01.bin", + "bytes": 395, + "sha256": "9242e57f7f025233bf5da6cca2c38b63a12f4e8b58a806c5324130716b94e33e" + }, + { + "path": "raw-02.bin", + "bytes": 391, + "sha256": "d77401a1c579c0e43179ad5009a979053d5baeee9384139609954a61f5ad4978" + }, + { + "path": "raw-03.bin", + "bytes": 438, + "sha256": "93ee3a753b7285cfca5b7bd48e94786679844f8c8b4cb9e1aa36c53f8806aa85" + }, + { + "path": "raw-04.bin", + "bytes": 392, + "sha256": "a65329ecd86909bee32a7902983cbffd21d86b6dfe5402129cb03470eed91967" + }, + { + "path": "raw-05.bin", + "bytes": 437, + "sha256": "1d3a0c1aeccb5eae41bf16538395948996c6eb1aee20ceb11f93d6d7b2271946" + }, + { + "path": "raw-06.bin", + "bytes": 391, + "sha256": "9b7eae5cc8a4028796b73def23ed93baf8cb3304ff7fe3f557b744fb64182cd1" + }, + { + "path": "raw-07.bin", + "bytes": 437, + "sha256": "e9093b103ed472a6205345f44daead390da9c96edab552c504037613819d5cf3" + }, + { + "path": "raw-08.bin", + "bytes": 392, + "sha256": "760f4362f00d77abc376d4c9d315257092db2068a0aaffffe380d2fd2283f853" + }, + { + "path": "raw-09.bin", + "bytes": 438, + "sha256": "59aa599bfeb6bbd17c0a2656eede2337e6aaa9c739e42e9172f5492a83478e4d" + }, + { + "path": "raw-10.bin", + "bytes": 438, + "sha256": "e94f0271335e3755c68787e5b9b173da9113ff3c6eae0a780d8d4d085a190f6d" + }, + { + "path": "raw-11.bin", + "bytes": 391, + "sha256": "32469c778b6b08cb165b6850327dc96dc0a86f2f102dc8cee98f8ad8dd415504" + }, + { + "path": "raw-12.bin", + "bytes": 438, + "sha256": "a27506cb84628292c574590ef8c3b4f2b2a172a009d90e7d19a0d98a103ae548" + }, + { + "path": "raw-13.bin", + "bytes": 439, + "sha256": "b61ff5e96fd5303475b02c863395cbb4569ed16e98ca1d51b943af3052a1a66d" + }, + { + "path": "runtime-created.json", + "bytes": 130, + "sha256": "44afda302ee2e732db8fcb81a3b3a0943295ad2e4747233f40c76af52578a300" + }, + { + "path": "runtime-final.json", + "bytes": 8239, + "sha256": "bb6540a24af1374ab3942a845d7e8f4107a977602df12594bfdb69fef8a8aa80" + }, + { + "path": "runtime-launch.json", + "bytes": 921, + "sha256": "e87f8582a08eff98b49ba09671ad7ac8893a71925e1cb27fc79ac32e253e0816" + }, + { + "path": "runtime-log.txt", + "bytes": 66097, + "sha256": "3224bfe4be94e3cbe5b0915aa0dd647302faf679d723a1448a53a89efce8201b" + }, + { + "path": "runtime-ps-01.json", + "bytes": 398, + "sha256": "02d5324bce1d46d50bf223802d6abfc1437efd3c784274f1b4d005e4e7bf184b" + }, + { + "path": "runtime-ps-02.json", + "bytes": 398, + "sha256": "50a4104a0732dbcd73f0ac11386e3fe4a6264285b265cb696df94bcb5cdbc2f8" + }, + { + "path": "runtime-ps-03.json", + "bytes": 398, + "sha256": "0a40b73cad9732ccb5ad9858d06bca4c538e6902920d945a6d4a930d92d405cd" + }, + { + "path": "runtime-ps-04.json", + "bytes": 398, + "sha256": "5338bc675abd4dc9e0235cb3bef76df19401a8699ff28a15f721000b38523ee7" + }, + { + "path": "runtime-ps-05.json", + "bytes": 398, + "sha256": "31c92164e471dbd00567715d00b7d2eef4bca7194a3eb1ffa345b44b10932180" + }, + { + "path": "runtime-ps-06.json", + "bytes": 398, + "sha256": "af6f163f925b7e35aae2f48efc1e680f49329f56a6b8b7630c4eccdb0101eb4c" + }, + { + "path": "runtime-ps-07.json", + "bytes": 396, + "sha256": "94d97eac8a1072eb00fecf6da40207e0de54b842ebf2a7e606adcc5ab00fca1e" + }, + { + "path": "runtime-ps-08.json", + "bytes": 398, + "sha256": "7429d54db4d638bb505b31b9fbbf7b9229612625ec3ddeb734c9b5fdb3f37632" + }, + { + "path": "runtime-ps-09.json", + "bytes": 398, + "sha256": "6e28036312e746a5fcf78a701ad0ed92461be2231a085e4b5b25b7f4413a9cbb" + }, + { + "path": "runtime-ps-10.json", + "bytes": 398, + "sha256": "e5a19460c7fd967b9e69e7d85162ee66e63e178db617021c9b6bc79a82758314" + }, + { + "path": "runtime-ps-11.json", + "bytes": 398, + "sha256": "537725c2d9cb7b2175d50cd39e07a693a3db982e2d2875ad3749167820663c81" + }, + { + "path": "runtime-ps-12.json", + "bytes": 398, + "sha256": "824437d8ae0c5f97aa1c4912cd0029c3e81e27dcacf14fa7d060689841e4b1ca" + }, + { + "path": "runtime-ps-13.json", + "bytes": 398, + "sha256": "04db9b5565d5ae5ea68d7c2319a9e4546e79e2927482e3c7a634ce26ebd56044" + }, + { + "path": "runtime-ready.json", + "bytes": 19960, + "sha256": "656e08e712d788fbcb30801bbbdc2f7c00f1370dc46deb7a7e6a0a8ae32290e8" + }, + { + "path": "rust-stderr.log", + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "path": "startup-finished.json", + "bytes": 136, + "sha256": "ed8ffdc3c0dbfb8dd5ac3bbe2002eea2f55d98f731cf99f01bea7d6957bcfeb2" + }, + { + "path": "startup-process.json", + "bytes": 33, + "sha256": "2dd8bdee515a5065201f187f0471273577100cce46a48c39f3e4cb7e3979510f" + }, + { + "path": "store/alternative_support-fresh.sqlite", + "bytes": 200704, + "sha256": "c0fd8fc3fccbc77e6a7f561394bb2cbf6b3bc72b0a45da0049e17606b8343734" + }, + { + "path": "store/alternative_support-repair.sqlite", + "bytes": 200704, + "sha256": "d146e30a63ca2598cb9287279299a9f041035701fb0f9d593c1753f9a40e8307" + }, + { + "path": "store/bootstrap.sqlite", + "bytes": 200704, + "sha256": "ec98cc2d4a276fdffd2a6d0c7c5fc5b7418f1fa1675086f6754778bd03a86eee" + }, + { + "path": "store/event-001.json", + "bytes": 1265, + "sha256": "bedb820f799c8674f15a21c47f35ff0eab63e3c2328bc9e4020c6a65f04d54b5" + }, + { + "path": "store/event-002.json", + "bytes": 94, + "sha256": "c439aeaafabcac60799222cf3589f689f1cbeab9051b60cf04f157c38bb7b198" + }, + { + "path": "store/event-003.json", + "bytes": 215, + "sha256": "5da3da9487f40b98cb734ceff77b11ca5fa636da036e9d5ebcc223569380c2de" + }, + { + "path": "store/event-004.json", + "bytes": 124, + "sha256": "22f59f6e14118c2c5e60226e5ab2639752a1b9ff327d1d341177495f004cc5c2" + }, + { + "path": "store/event-005.json", + "bytes": 1265, + "sha256": "0e0f7b135685b17e99376111023317773fc187cda3863ec2b9a6e22cb24611ec" + }, + { + "path": "store/event-006.json", + "bytes": 94, + "sha256": "f0737f39b0749aab8a3c818bb92ab689de4177071585efa92a1bf04f762862d4" + }, + { + "path": "store/event-007.json", + "bytes": 214, + "sha256": "579908eef301b2c3d75218ff011ebc324a06ce497b20838dee6120ffeb9a6b06" + }, + { + "path": "store/event-008.json", + "bytes": 124, + "sha256": "f3eeb845fad19c5a632047ee76661f0df742cd444584012fc7a171db156e786b" + }, + { + "path": "store/event-009.json", + "bytes": 1194, + "sha256": "da539a1445db7cd79080387812dee464975bf735c6cddae20b2abf63fa522459" + }, + { + "path": "store/event-010.json", + "bytes": 122, + "sha256": "6f011aa5d7d011aa822ce5b519e1f15d29c0ece71e7081f301875aa58436d64f" + }, + { + "path": "store/event-011.json", + "bytes": 290, + "sha256": "077071cae2e65dde0749903059a837fcd7f70bda19dce0885bbc91b1ba48787a" + }, + { + "path": "store/event-012.json", + "bytes": 152, + "sha256": "ac73f1db97c16c92c8cd0ce81eb86c3a63796537f79c8ccd10ab79a2d166ba2d" + }, + { + "path": "store/event-013.json", + "bytes": 1280, + "sha256": "ec77ac4446f712966672861ff8ea2ef96ba291b7a20fba42e386eeb19c969b78" + }, + { + "path": "store/event-014.json", + "bytes": 109, + "sha256": "ef61f20cfd33f77eb026cecfe3a1560fa5af6cc07ba0b4681df8f2972f8643fa" + }, + { + "path": "store/event-015.json", + "bytes": 229, + "sha256": "223b01f9961bf82e253302ac5a2e9a0e7873a0f2e1293b56ab0129e91600572c" + }, + { + "path": "store/event-016.json", + "bytes": 139, + "sha256": "1a5fcdd50f4b68352230e060f3250527aada26130313c9ac738b5fd9ae814085" + }, + { + "path": "store/event-017.json", + "bytes": 1210, + "sha256": "cd2c340bee01f4410717f63b1873f1da687ba21b26a5b74a97b19e3de56bac94" + }, + { + "path": "store/event-018.json", + "bytes": 138, + "sha256": "87e55ae58a48ddee6ef282ba9b18b7960a51a273f00cdc1e7d1c5bc1075b2101" + }, + { + "path": "store/event-019.json", + "bytes": 304, + "sha256": "d767a836dd34ae94d6baf0b89d3c0792f3067a5ad5b444bfe7b2b2be49919dfd" + }, + { + "path": "store/event-020.json", + "bytes": 168, + "sha256": "bcd7490746618881cfd535338cba7c0327a4e6adfaa618f9dd702039cbb92655" + }, + { + "path": "store/event-021.json", + "bytes": 1279, + "sha256": "06cc8983438e68608837c98479f6fe7d3c941287db8b475c96a55ce50fffef73" + }, + { + "path": "store/event-022.json", + "bytes": 108, + "sha256": "42dfb116c5a110845dbb54c143c18a6c78e1aad1d91834d13cbd31317fb7971a" + }, + { + "path": "store/event-023.json", + "bytes": 228, + "sha256": "8587d49348b6bf7f2d2fed51c998cfaf2af96435891378249ffe0bd1214087b8" + }, + { + "path": "store/event-024.json", + "bytes": 138, + "sha256": "a9918378ac7ab07455e9ee1acb5fbaebe76ea848ef590c8c4137e1379a8e6dd4" + }, + { + "path": "store/event-025.json", + "bytes": 1208, + "sha256": "2f0da545ea9a554aa860b09ffc28e5507b87e28b2a0770afaa23e6de8ad0496e" + }, + { + "path": "store/event-026.json", + "bytes": 136, + "sha256": "b540cb652160062f8c5892e524c2aaef7e5fef23f54bc851bf32cb39619a2e42" + }, + { + "path": "store/event-027.json", + "bytes": 302, + "sha256": "bede9329fc80151db84d126815bfeb7ef996d93a0e796ebe7c9eb2a76c39f726" + }, + { + "path": "store/event-028.json", + "bytes": 166, + "sha256": "334329b45ff778d27891779444dc815cadf2584b8767001a9f0e797c97d01868" + }, + { + "path": "store/event-029.json", + "bytes": 5038, + "sha256": "cf6ee64b790cb4d3fbbe43ebf617315b65e5f4a9729d859e5d5d9cc0392c8b36" + }, + { + "path": "store/event-030.json", + "bytes": 1285, + "sha256": "338ad3dcc28d86edafacf12573cf9836000802f03045a718e3b00ec65069223d" + }, + { + "path": "store/event-031.json", + "bytes": 114, + "sha256": "93e2e8f84fe34c2b111320f953e60f8ca0fb203ed7a08a330861df34d494281e" + }, + { + "path": "store/event-032.json", + "bytes": 234, + "sha256": "b0ac1b2a42519e9b5f60072fcbb22184cc1b2fe77203ec9818aabbcf8c1e9c70" + }, + { + "path": "store/event-033.json", + "bytes": 144, + "sha256": "d2df9f5a955ff57a425ce0d3f0966c32c74d503fa7833d4c6d0b995050c7c3fa" + }, + { + "path": "store/event-034.json", + "bytes": 1213, + "sha256": "0c2cf30f5b2e8d74e92bb54f9e4c0c285181a047311a39bd9699ffc8532a6e48" + }, + { + "path": "store/event-035.json", + "bytes": 142, + "sha256": "7cbcd21f76c92bdd7bd0fe59f6c66dca08aabc7ca19df71eb304e2d049af4dba" + }, + { + "path": "store/event-036.json", + "bytes": 309, + "sha256": "70b20bf11c7aa2a684f434635e4e665413635ab457c6f9d810b80710d2f64e82" + }, + { + "path": "store/event-037.json", + "bytes": 172, + "sha256": "b74a7db1f7b9286015900bb93b1499c87d2f800bc71ed72564db596fb29747c7" + }, + { + "path": "store/event-038.json", + "bytes": 1286, + "sha256": "8ce48984cc56e5240d102168e04fd28be0803ad698bddad7b200e0c8f396258c" + }, + { + "path": "store/event-039.json", + "bytes": 199, + "sha256": "6e04221c57ca04f6c0fd3b86ee1083a55e52a65ce8fbfe98324ee9e6ff67e304" + }, + { + "path": "store/event-040.json", + "bytes": 1214, + "sha256": "abd403ea879f1f60406e4ec9ed2f95d91b377951b5a03d087ab24474c765fecb" + }, + { + "path": "store/event-041.json", + "bytes": 144, + "sha256": "fdec64cde68792ecc2e85c61fb6d0350fca042ad9cd311c966d1e85ad48ecdd1" + }, + { + "path": "store/event-042.json", + "bytes": 310, + "sha256": "1e8892cf29a0d1c778e424b6da4578f6403709d1cb1cfb77a540eddea09650d6" + }, + { + "path": "store/event-043.json", + "bytes": 173, + "sha256": "caa11dd72ea60f71eeca6507c0b8902ea6af3fe3bd0984f04f1a9471092e7834" + }, + { + "path": "store/event-044.json", + "bytes": 5042, + "sha256": "2ac7fd11896b61e594d8d1a6c5029fc6db40ebe0d81a3cf76c8dba23d9a617a6" + }, + { + "path": "store/event-045.json", + "bytes": 74, + "sha256": "41bcec11703f3c09231ebe2ffc884ca9c8dd0b01c0ef11552d7bab1888d99959" + }, + { + "path": "store/event-046.json", + "bytes": 73, + "sha256": "9d9ab7d9ef31b844dd23ec58d8a9dc132cbb7c6d163d60a6120b738460318339" + }, + { + "path": "store/event-047.json", + "bytes": 273, + "sha256": "5d1f6ebe22c505b096aa056063021dd8838a431da5e4f75c7a15da36771b3c4e" + }, + { + "path": "store/event-048.json", + "bytes": 1281, + "sha256": "ddda8628cd8321a3911a26db62e7f32fd37ffcf6973159919f020f7b4aae5576" + }, + { + "path": "store/event-049.json", + "bytes": 111, + "sha256": "c5fdb27dab2d130b2868b411f66768f3bdc0ee97d7675485c7d06991b6901fa9" + }, + { + "path": "store/event-050.json", + "bytes": 230, + "sha256": "1b1c3fa34327e7d49eaf5dc0d93d749ba9524d7be4c692b0842a7fe4e2f3cc42" + }, + { + "path": "store/event-051.json", + "bytes": 140, + "sha256": "6023bd1d3b7ebdaf4a14e57de7705d9c8589f83c4d472253246743817346a8ec" + }, + { + "path": "store/event-052.json", + "bytes": 1210, + "sha256": "1b291a34cdddc51e6f890535be34cbe126a404597266bd755c6340a8f70e09b1" + }, + { + "path": "store/event-053.json", + "bytes": 139, + "sha256": "7490d6cfaa92af1bf704a92022d35494d24c3c87b4f756119359564a8fb5e2fe" + }, + { + "path": "store/event-054.json", + "bytes": 306, + "sha256": "0d60007814e13be439cbbaab61a1fbb1097f620d6dcc02db6c62b54c2d3089fe" + }, + { + "path": "store/event-055.json", + "bytes": 168, + "sha256": "196e52ffdc269e385af135aad80d9e91743ac5c6028c0af002a432c1444116bd" + }, + { + "path": "store/event-056.json", + "bytes": 1282, + "sha256": "64ea506fad9787ff5176a748fb07463f0fb4e448d003e1d25675eb5b282d10f4" + }, + { + "path": "store/event-057.json", + "bytes": 195, + "sha256": "f1312aeaf6fe663cc4f47bb6bf349fb33282b1e2d9d5fe118d14379bdd5a372a" + }, + { + "path": "store/event-058.json", + "bytes": 1211, + "sha256": "3e9b9c27abf8a9ff11a8c9b3dfac1c9275676cf6b5de5661e7473f6b75ce007e" + }, + { + "path": "store/event-059.json", + "bytes": 140, + "sha256": "9e0d48c694a07c6baf4c08158da3c2bf4c83949e5a892870af328bfaba050565" + }, + { + "path": "store/event-060.json", + "bytes": 307, + "sha256": "572becf3fd28eedb1fd39cad481ad8ec36eff57091533fa43eef721b474d86f1" + }, + { + "path": "store/event-061.json", + "bytes": 169, + "sha256": "831c22d574f93d07206f7d7c371c68dd843033bd8a2ba6f2dfde9441dae6c12f" + }, + { + "path": "store/event-062.json", + "bytes": 5042, + "sha256": "eb86ee1694c7d5349591406939bd91febb7d12f2f65a188a5ab5aef4fc46f9c0" + }, + { + "path": "store/manifest.json", + "bytes": 712, + "sha256": "935533f03448359a866d158e538d15bfcf5539a14fb2a69cead03366ec51e644" + }, + { + "path": "store/report_correction-fresh.sqlite", + "bytes": 200704, + "sha256": "41bd22553607f7e174af109f61ef40d0f9645102a8d127df40aa77a2548426c2" + }, + { + "path": "store/report_correction-repair.sqlite", + "bytes": 208896, + "sha256": "f5550a6eee76aef988c013330e1f93c1c9f96dee08941c395a4e752e5ee37028" + }, + { + "path": "store/result.json", + "bytes": 15482, + "sha256": "705613da17db26dc4514b1d3a73ed9be0ab90d907d718228e724dc56eb28c236" + }, + { + "path": "store/unrelated_policy_change-fresh.sqlite", + "bytes": 200704, + "sha256": "741196190e35b69f9ddc005642d433587895c264b628cedf3790b521cbcab4b7" + }, + { + "path": "store/unrelated_policy_change-repair.sqlite", + "bytes": 200704, + "sha256": "09179dbf89c84041e79ed7bc3fd076cbb64c3bb477ce96b8a1086995b1026b0f" + }, + { + "path": "store/withdrawal-fresh.sqlite", + "bytes": 200704, + "sha256": "77fd28192b977ebbee707105cb9ee4002a9e899c6719a137e26165884ef92267" + }, + { + "path": "store/withdrawal-repair.sqlite", + "bytes": 200704, + "sha256": "e9c58de5e0d2a04eb0823182e5f04097eeda62873b26e20a84acabbce4739c72" + }, + { + "path": "supervisor.json", + "bytes": 725, + "sha256": "9dd18981495aa61b2ddd2641b680065dafa083d265f214a8c373e9be2eaf3c75" + }, + { + "path": "usage-01.json", + "bytes": 243, + "sha256": "7dfa8d7a326cd3c13f9f84cd6b5e011859dbc59a5c3f668235f991dc60aabaab" + }, + { + "path": "usage-02.json", + "bytes": 244, + "sha256": "70ccee7709bf7aec5e73f6e3a53adbfd365330d351c265de41f05688afecd850" + }, + { + "path": "usage-03.json", + "bytes": 244, + "sha256": "6f1a10669766db6079ddc1d7716ad3edc07e0a055918952359d8c094ff520f35" + }, + { + "path": "usage-04.json", + "bytes": 244, + "sha256": "ba880337070d3b07b63978031e78625e66ebdd0f2b60866fcb707a354edf186b" + }, + { + "path": "usage-05.json", + "bytes": 244, + "sha256": "0637fd8d05be4b538683fb4d4602424adc1460fcc08e1d58f73fa4500249787d" + }, + { + "path": "usage-06.json", + "bytes": 244, + "sha256": "b6a6ecfffa7fb556fdb930e8cbb6d1a264c26c7589c6adc99f5e42ba6896b8d3" + }, + { + "path": "usage-07.json", + "bytes": 244, + "sha256": "c3a04bfabdd1ecb24567aaad7886449482ca0d250e7fc0d900065c1e993f2fb7" + }, + { + "path": "usage-08.json", + "bytes": 244, + "sha256": "b36692aa73796654ca471ef3b6f4b5995773ff3384e120f06740d0015b59793a" + }, + { + "path": "usage-09.json", + "bytes": 244, + "sha256": "a7518506677c4bd2d77d718ac451e90ca816df64338b33d5445c966bba615b36" + }, + { + "path": "usage-10.json", + "bytes": 245, + "sha256": "8d1d1257575b6605920d7b3c0666c4d997351bb8bb263f7618832702ff7c2f22" + }, + { + "path": "usage-11.json", + "bytes": 244, + "sha256": "46f0a6909fe5f5116affcef284a6044cb88d12650b7ee19e2cf58d3696de6a11" + }, + { + "path": "usage-12.json", + "bytes": 244, + "sha256": "37ca7a7dcb4cd373e5eac5e57c5f2a40db226d8e43e2b0e9aa6a0ae1c034f793" + }, + { + "path": "usage-13.json", + "bytes": 245, + "sha256": "60ea3b74159c74975b11c055c8b58468b9ca88759f6febc1c684506e130c25a3" + }, + { + "path": "watchdog.json", + "bytes": 132, + "sha256": "39a2fe510503a4ce2b62126d35352f0a026d2b43364d0584048995284736e73d" + } + ], + "interpretation": [ + "One correlated synthetic case per condition; no population accuracy or latency guarantee.", + "Same fixed existing fixtures; no dataset expansion, training or remote provider requests.", + "Reported token usage is a local-runtime observation, not authenticated execution or billing proof.", + "Configured token envelopes are not proven hard bounds; no unresolved holds occurred.", + "Model provider spend was zero; workstation compute cost is unpriced.", + "The submission report remains pinned to 20fab84; this is a separate supplement." + ], + "independent_post_run_audit": { + "sha256": "361cb1bfc24d4ee8c13812cde9343dfaad3efdb6689d31e5267bd088cb66fd95", + "result": "passed", + "scope": "Raw requests and responses, claims, usage, Store events and SQLite admission/origin history, CPU observations and cleanup; no new inference." + } +}