bench

type AgentScore struct {
	Calls     int
	Bytes     int
	Tokens    int
	TaskState string // state of the judge task, "" if absent
	BugState  string // state of the judge bug, "" if absent
	CheckOK   bool
	Valid     bool
	// ManifestBytes is the connect-time manifest's size when the run was
	// prepped -with-manifest (read from the manifest.size sidecar), zero
	// otherwise. Kept OUT of Bytes: the aggregate spreads compare tool
	// diets, and folding a per-session constant into them would blur
	// exactly the wandering signal they exist to show.
	ManifestBytes int
	// Scenario is "basic" or "tricky" (from the scenario sidecar); RuleOK
	// is the tricky rule goal, DecideOK the tricky decide-answer proof.
	Scenario string
	RuleOK   bool
	DecideOK bool
	// Disqualified marks a run whose METER failed integrity (B-01KYE6G):
	// sequence gap, nonce mismatch, or more journal write events than
	// metered calls. Distinct from invalid because the remedies differ —
	// invalid means the texts failed the agent, disqualified means the
	// measurement failed the harness. DisqualifyReason names the check.
	Disqualified     bool
	DisqualifyReason string

	// Violations are role-boundary hits (ROLE-BOUNDARY-001): tool-result
	// text instructing the agent to run git, scanned off transcript.log.
	// Non-empty kills Valid — a surface that delegates mechanical git back
	// to the agent fails the run regardless of cost.
	Violations []string
	// GoalsOK is the scenario's goal conjunction ALONE — set beside every
	// Valid assignment so the report can tell "goals held but violations
	// voided the run" from "goals not reached" (B-01KYJ67RF9) without
	// re-deriving scoring in the render.
	GoalsOK bool

	// Outcome scenario (T-01KYFSQQ): hidden-acceptance results as "n/m"
	// fractions — FirstPass at the first done edge (or "unavailable" when
	// no done edge exists to check out), FinalPass on the tree at scoring
	// time — plus the reopen rounds the run paid. Completeness per token
	// is computed from FirstPass; Rounds prices the correction loops.
	FirstPass string
	FinalPass string
	Rounds    int
	// AskCount: exit-0 decide op=ask calls in the meter — the elicitation
	// usage the outcome-ask variant measures (T-01KYH6H9).
	AskCount int
	// contains filtered or unexported fields
}

type Result struct {
	Steps      []StepResult
	Bytes      int
	Tokens     int // Bytes/4 — a stated estimate, not a tokenizer
	Valid      bool
	Violations []string // why Valid is false, or informational notes
	Coverage   map[string]bool
	// ManifestBytes is the initialize-handshake manifest's size, metered
	// SEPARATELY from the per-call total: its cost multiplier is sessions,
	// not calls, and folding it into Bytes would corrupt both figures
	// (T-01KYE3 — 7238 bytes stayed invisible through eleven benchmarked
	// landings for lack of this line).
	ManifestBytes int

	// SchemaBytes is the tools/list payload's size: every tool's description
	// and input schema, as the wire delivers it at connect time.
	//
	// It is metered because it was the largest thing nobody was counting. The
	// manifest line presented itself as THE once-per-session cost at 4.3KB,
	// while a real handshake writes 24623B — tools/list is 81% of it, measured,
	// and the initialize result is ~95% manifest text, so schema+manifest tracks
	// the real wire to within 1.2% rather than double-counting. So every
	// byte-economy conclusion drawn from this benchmark was reasoning about a
	// denominator missing three quarters of what a session actually pays, and
	// BENCH-001 ("revert a surface change whose judged metric did not improve")
	// is only as trustworthy as the metric it defers to (B-01KYS711ZFFG0).
	//
	// Measured over the wire rather than by marshalling the tool structs, so it
	// cannot drift from what a client receives.
	SchemaBytes int
}

type Step struct {
	Name string // tool name
	Args string // JSON arguments; {ID}, {ID2}, {BID}, {ADR} expand to captured IDs
	// Capture stores the first item ID of the result under the given key.
	Capture string
	// ExpectRefusal marks a step that must exit non-zero with a "! ... E"
	// record. Optional marks a step whose outcome is informational only
	// (e.g. prefix-ambiguity probes, which depend on mint timing).
	ExpectRefusal bool
	Optional      bool
	// Label names the step in the per-step report.
	Label string
}

type StepResult struct {
	Label   string
	Bytes   int
	Refused bool
}