pub struct Outcome {Show 49 fields
pub kind: String,
pub session: String,
pub lessons: Vec<String>,
pub ms: i64,
pub repo: String,
pub groups: Vec<Vec<String>>,
pub channel: String,
pub grades: Vec<u8>,
pub ranks: Vec<u16>,
pub applied: u16,
pub chosen: Vec<String>,
pub explore: bool,
pub cause: String,
pub credit: f64,
pub p: Vec<f64>,
pub pool: Vec<String>,
pub base: Vec<f64>,
pub scoped: Vec<bool>,
pub check: String,
pub policy: String,
pub fit: String,
pub seen: String,
pub source: String,
pub free: Vec<String>,
pub pf: Vec<f64>,
pub placebo: Vec<String>,
pub psi: f64,
pub nofree: Vec<String>,
pub xk: Option<u32>,
pub xs: Option<u32>,
pub alpha: Option<f64>,
pub tail: Vec<String>,
pub pt: f64,
pub rel: Vec<f64>,
pub route: String,
pub reason: String,
pub eligible: u32,
pub shown: u32,
pub tokens: u32,
pub fill: Vec<u16>,
pub model: String,
pub prompt_hash: String,
pub harness: String,
pub version: String,
pub dur_ms: u64,
pub failed: bool,
pub usd: f64,
pub judge: u8,
pub stripped: bool,
}Fields§
§kind: String§session: String§lessons: Vec<String>§ms: i64§repo: String§groups: Vec<Vec<String>>asked only: the asked lessons rendered as one disagreement (conscience.rs disagreements).
channel: StringHow the lessons were asked (asked and the judge’s results): stop (a turn-end block), live
(a live check during the turn, live.rs), early (early delivery, conscience.rs early),
queued (a graded check’s 2s and 1s, handed over free) or placebo (PLACEBO: never shown,
judged blindly where a free delivery would be). Empty in records from before delivery modes.
grades: Vec<u8>graded and asked: each lesson’s grade (3 certain, 2 likely, 1 worth a thought) and its rank in
the model’s applies (0 first), aligned with lessons, and how many lessons the check graded as
applying; on asked, 0 where no check of the session graded the lesson. For learning how many to
ask (attention.rs reads them from graded).
ranks: Vec<u16>§applied: u16§chosen: Vec<String>graded only: the lessons the check chose to ask.
explore: boolgraded only: the check explored, asking every apply up to attention::RAIL whatever the cut,
so its outcomes label the cut (attention.rs).
cause: Stringregretted: the regret episode (R…/V… id). The idempotence key with the lesson.
credit: f64regretted only: the lesson’s share of the regret, (0, 1].
p: Vec<f64>asked and graded: per lesson (aligned with lessons), the probability that the policy in force
at that check asked it: 1 or 0 under the fixed graded rule, the explore mixture under the learned
cut (attention.rs propensities), the share of Thompson draws that give it a slot in
budget/widen (conscience.rs propensity), the share that delivers it early (conscience.rs
early_propensity), 1 for a free hand-over of a graded check’s 2s and 1s. Rounded to 4 decimals
(round_p). Empty in records from before propensities and when unknown (BORG_ONLY, a state file
from an older binary). For off-policy evaluation (ope.rs).
pool: Vec<String>asked from a Thompson slot draw only (conscience.rs budget_pool/widen_pool, hook.rs
#borg-pool): the pool the check drew from, in ranking order, the asked lessons included; each
one’s score without its usefulness factor (conscience.rs pool_base, unrounded so a replay is
exact); and whether it is scoped. Aligned with each other, not with lessons. Empty for graded
and live asks and free deliveries. Local: never shared (share). For borg debug ope (ope.rs).
base: Vec<f64>§scoped: Vec<bool>§check: StringThe graded check (select.rs check_id): on graded, and on every record of a lesson that check
routed (its delivery, the judge’s result, a placebo’s), so a result joins the decision that made
it. Empty in records from before checks had ids.
policy: Stringgraded: the selection policy in force (select.rs Policy::name: fixed, cap, attention,
learned). Empty in records from before select.rs, which read as the fixed rule (policy_of).
fit: Stringgraded: the fit the policy decided with (select/policy.rs Fit::key); empty for the prior.
seen: Stringgraded: the selection summary the decision read (select/summary.rs Summary::key: the bytes
folded and their hash), and what set its routes (select.rs Log::source). A learned check reads
the summary again under the store’s decision lock after its model call (hook.rs decide), so
every learned decision recorded before it is in it; a check by a policy that reads no gate, and
one that fell back to the fixed rule (reason), names the summary it read at its start, which
records of checks that decided meanwhile may follow. Records other than decisions (a delivery, a
verdict) may still land between that read and this record; borg debug select P1 replays from
the logged state.
Empty in older records and for a failed call.
source: String§free: Vec<String>graded: the lessons the check handed over free, in delivery order (free_of for older records).
pf: Vec<f64>graded: per lesson (aligned with lessons), its probability of being handed over free under
the policy in force, as p is of being asked; rounded like p. Empty in older records, where
a free lesson’s was 1 under the fixed rule.
placebo: Vec<String>graded: the applies the check did not deliver and drew for the placebo arm (judged blindly
where a free delivery would be, never shown), and each undelivered apply’s chance of that draw.
psi: f64§nofree: Vec<String>graded: the graded applies that could not go free at this check because the session already
had them delivered (select.rs Ctx::had, conscience.rs graded_without), in the applies’ order:
the applies among the session’s deliveries when the check decided, and among the lessons waiting
in its queue to be asked or handed over by another check (hook.rs decide, waiting_in), so the
record alone holds every had that bears on its decision.
xk: Option<u32>graded, a check of the randomised question-count test (select/policy.rs Decision::xk,
sources experiment, experiment_control and gate): xk the fixed rule’s delivered non-3
lessons that may go free (k), xs how many of them it asked (s, drawn uniformly in 0..=k; 0 is
logged). None on every other record, so older lines and checks outside the test write back
unchanged. Local like the rest of a graded record (share).
xs: Option<u32>§alpha: Option<f64>graded: the collective’s tolerance the check was decided under (select.rs Log::alpha, its
risk), so a replay decides under it whatever the config says then; None at the default
(select/policy.rs ALPHA), so older lines and default collectives write back unchanged.
tail: Vec<String>graded: the lessons the pool budget dropped from the model call that a tail sample showed
anyway (whole.rs tail, under every policy), and each one’s chance of being sampled (one chance
for all of the check’s tail: k drawn uniformly of the eligible − shown dropped, unrounded).
Not in shown or tokens; each has its place past the budget’s in fill, after the applies’
(and, if it applies, among them too), so every place from shown to eligible − 1 is one
dropped lesson, shown with chance pt.
pt: f64§rel: Vec<f64>An early delivery’s record: per lesson (aligned with lessons), its score as a share of the best
on-topic match, done or not (conscience.rs early_pool, the share RELATIVE bars; hook.rs
early_rel), rounded as p is, for a learned early rule. A standing lesson has one too, though
no score gates it; empty when no plain lesson was on topic to scale by.
route: StringA delivery’s actual route for every lesson of the record (one of ROUTES), and why: a drop’s
cause, or why a delivered lesson stayed unjudged (no later call, the judge’s slots, its tries);
on graded, why its check fell back to the fixed rule (DECIDED_BUSY, DECIDED_NO_LOCK,
DECIDED_NO_RECORD).
reason: String§eligible: u32graded, the pool the model graded: lessons eligible for it, lessons its budget showed, their
size in tokens (the tail sample beside them in tail), and per lesson (aligned with lessons)
its fill position among the shown (0 first), so the yield of each position can be learned from
every check, a check without applies included; then, past the applies’, one position per tail
lesson (aligned with tail), so the yield past the budget is learned from the lessons a tail
showed that did not apply too (select/summary.rs tail_of). A tail lesson’s position goes on
past the budget’s: shown + its place among the lessons the budget dropped, in the order the
fill met them (whole.rs Filled::dropped), so it is never below shown.
shown: u32§tokens: u32§fill: Vec<u16>§model: Stringgraded, the model call: the model (empty: the CLI’s default), a hash of the prompt template,
the harness, borg’s version, the call’s duration, and whether it failed (the check then asked
nothing: fail open); then its cost (usd).
prompt_hash: String§harness: String§version: String§dur_ms: u64§failed: bool§usd: f64graded: the call’s cost in dollars as the harness’s CLI reported it (0: it reported none).
Measured and shown (borg debug select P3), never a limit.
judge: u8The judge’s results (asked_then_changed, asked_ignored): the judge template’s version, 0 for
the template before versions were logged; and whether the judge saw the question without the
drone’s <id>: applies|skip declaration (a random half are, to measure what it adds).
stripped: bool