--- title: The run record description: Every field of a run's JSON record, and the history folder layout. --- > ## Documentation Index > Fetch the complete documentation index at: https://docs.reeval.ai/llms.txt > Use this file to discover all available pages before exploring further. Each run is one JSON file, `.json`, plus optional artifacts in `/`. The record is immutable once written. `reeval show --json` prints it. A record written before a field existed still loads everywhere: reeval reads the missing field as empty (`[]`, or `false` for `todo`). A record from a newer reeval loads too, ignoring fields this reeval doesn't know, unless its `schemaVersion` is higher: then reeval skips it with a warning to upgrade. ```bash npx reeval show latest --json | jq '.evals[] | select(.outcome != "pass") | .id' ``` ## Layout ```text evals/.history/ commit this .gitignore un-ignores recorded files (`*.log` and the rest) .json the record /summary.md the run as Markdown /insights.json insights and remarks (see Insights) /worktree.patch uncommitted changes, when the run was dirty //questions/.json what pairwise question n's model was sent //// one directory per attempt transcript.jsonl timed agent events (see Transcripts) diff.patch the agent's changes, dependency noise dropped judge-input.json what each judge call saw setup.log each environment setup step's output checks/.log each c.exec: command, exit code, stdout, stderr artifacts/.png each c.capture() PNG (`history.artifacts` keeps it) questions/.json what question n's model was sent about this attempt .reeval/ scratch: gitignore it current the run id minted (or resumed) this session staging// a run in progress, until assemble runs/.json + / every reeval run, same shape debug//… local debug data, never recorded history.db reeval query's projection ``` The record is `kind: "reeval-run"`, `schemaVersion: 1`. The schema only grows: a newer reeval reads an older record, and an older reeval skips a record with a higher `schemaVersion`, saying to upgrade. Single tool outputs, check streams and per-file diffs over 128 KB keep their head and tail, a truncation marker and the full text's sha256. Records are redacted before they're written. ## Reading one Start at `evals[]` where `outcome != "pass"`, then its `cells[]` for pass@1 (`passRate`), roles and lift, then each failing attempt's `error` and `judgements`. Open the files its `files` points to. ```json title="evals/.history/.json (trimmed)" { "kind": "reeval-run", "schemaVersion": 1, "runId": "20260926T170558Z_bd6205e_ada-lovelace_sycz", "status": "complete", "summary": { "evals": 1, "attempts": 4, "pass": 2, "fail": 2, "notGated": 2, "infraError": 0, "skipped": 0 }, "evals": [{ "id": "evals/skill.eval.ts › house greeting › greets in the house style", "outcome": "pass", "…": "…" }] } ``` ## Fields The type definitions are in `packages/reeval/src/history/types.ts`; the environment, egress and image records are in `src/types.ts`. This section is generated from them. ### Value types [//]: # (generated:record-values) | Type | Values | |---|---| | `Outcome` | `'pass'`, `'fail'`, `'infra_error'`, `'skipped'` | | `ErrorKind` | `'assertion'`, `'timeout'`, `'aborted'`, `'infra'`, `'judge'` | | `TurnStatus` | `'completed'`, `'aborted'`, `'error'` | | `ArtifactLevel` | `'all'`, `'failures'`, `'none'` | | `RecordMode` | `'manual'`, `'ci'`, `'always'` | | `FamilyVerdict` | `'lift'`, `'drop'`, `'noise'`, `'insufficient'` | [//]: # (/generated:record-values) `runner` is `{ kind: 'ci', provider, runUrl, attempt, pr: { number, baseRef } | null }` in CI, or `{ kind: 'local', hostHash }` on your machine. An attempt's `error` is `{ kind, message, prepare?, resource? }`: | Field | Set when | Shape | |---|---|---| | `prepare` | Its sandbox couldn't be prepared before the run (see [Sandbox providers](/reference/sandbox/providers)), the same on every attempt that needed it | `{ class, stage, ref, cause, log, setBy }`, `class` one of `config`, `transient` or `resource` | | `prepare` | A git `workspace` couldn't be fetched | `stage: "workspace"`, the workspace as `ref`, such as `../repo#v9` | | `resource` | The kernel killed `kills` processes at the sandbox's memory limit | `{ cause: 'oom', kills }` | An attempt with `prepare` never started, so it has no artifacts directory. One with `resource` has `kind: infra` and outcome `infra_error`, whatever its checks said, so it's left out of pass rates and lift. [//]: # (generated:record-types) ### RunRecord Also the file name: `__`. `budget` when `budget.duration` stopped new attempts from starting. Each environment the run applied, fingerprinted; secret values are never included. The profile the run was sized with, and why it was chosen. What the run planned before it started, and each level whose sandbox ran as root or with capabilities added back. The run's settings. `sandbox` is the id of each sandbox the planned attempts ran on, after the profile's defaults, joined with `, `. Which artifacts sit next to this record. Refs to files that weren't kept are removed. Each pooled `evaluate.each` that ran; unset when none did. Errors outside any attempt, redacted: an eval file that didn't load, a rejection or throw no attempt awaited, a worker that died. Any one fails the run. Unset when there were none. ### GitInfo The commit the run executed at: HEAD when `reeval run` started. The later commit that adds the history file is a different, descendant commit. Uncommitted changes, outside `.reeval/` and the history folder, when the run started. sha256 of the uncommitted changes (tracked and untracked, as a binary patch), when dirty. Those changes as `worktree.patch` in the artifact dir; apply on `sha` to reproduce. Why a dirty run has no `worktree.patch`: too large, artifacts: 'none', or it looked like it held a secret (then where, and which rule, never the value). The `origin` URL with any credentials removed. ### Stack What ran and graded the agents: the machine, images, harnesses and judge. The reeval version that wrote the run. `process.versions.node`: under Bun or Deno, the Node version they're compatible with. The runtime reeval ran on, `node`, `bun`, `deno` or another, and its own version. Absent in runs recorded before it, which ran on Node. The language the evals are written in, `typescript` for `*.eval.ts`, and the version of its toolchain when the runner reports one. Absent in runs recorded before it. Every image an attempt started from. `id` is content-addressed; `repoDigests` only exist once pushed. Exact versions of the packages that run and grade the agent. Each harness: its configured `model` and requested `effort`, `resolvedModels` (what it reported serving, with the variant it resolved), and `resolvedEffort` (reasoning-effort suffixes those labels named). Fast (`[fast=true]`) is not `resolvedEffort`. The run's judge: the config's, with what the profile's `judge` and `defaults.judge` set over it. `config.judgeModel` and `config.threshold` name the same one. Union of every attempt's context files. What eval fingerprints hash; fingerprints from different scopes aren't comparable. ### RunSummary Counts attempts, except `evals`. Every failed attempt, including `notGated` ones. Failed attempts in ungated cells (controls, by default), which don't fail the run. ### SandboxWarning A sandbox with more privilege than the default `reeval` user: `docker({ root: true })`, or `docker({ capabilities })`. One per level that set such a sandbox, however many evals inherit it. Which level set the sandbox. That level as reeval names it: `reeval.config.ts`, `profiles.pr.defaults`, `group("net")` or `evaluate("installs deps")`. The eval file that sets it, for a group or eval; null for the config or a profile. The capabilities added back, for `capabilities`. The line reeval prints, after `WARNING: ` (root) or `warning: ` (capabilities). ### Cost The tokens the run used, as the harnesses count them; reeval prices nothing. Prompt tokens, cache reads and writes included. The same totals split as each turn reports them. ### EvalEntry `file › group › … › name`, as shown. What the eval is matched on across runs; currently the same as `id`. Directory name inside the artifact directory, from `key`. Results are comparable only when fingerprints match. The eval file and every local file it imports, directly or not, by content hash. The baseline environment, when the eval uses `compare`. Over gated cells: `fail` if any failed, else `infra_error` if any is (a cell is `infra_error` only when nothing counted), else `skipped` if all were, else `pass`. An ungated cell's failures don't fail the eval. A placeholder, `evaluate.todo` or `group.todo`: it never runs, and its outcome is `skipped`. pass@1, pass / (pass + fail), over the gated cells' attempts; infra errors and skips excluded. The eval's pairwise questions (those with `across`), answered after its attempts by votes, one per question; unset without any. They annotate: `outcome` and `passRate` never depend on them. Each vote may include a short `reason` (capped). `reeval analyze` includes each answer in the digest (rates by cut, votes, ties, a failed call, a sample of reasons). Each answer's `input` is `/questions/.json`: every call its model was sent, per pair and order, secrets masked and screenshots as refs; unset where the eval's files weren't kept. Set on each case of a pooled `evaluate.each`; `RunRecord.families` has the suite. ### CellRecord One harness and environment of an eval, and how its attempts went. Also has every field of `Cell`. `sha256` of `fingerprintParts`; results are comparable only when it matches. The environment's digest: the join key into `RunRecord.environments`; null for none. The gateway in the config's `gateway` list its harness resolved to (`direct` is each provider's own key); unset when no config, profile or pin named one. The configured harness model, when it has one. The reasoning effort the harness factory asked for; null when it left it unset. Fast is not this. How the attempts decide the cell's outcome; `'none'` when it doesn't fail the eval. Environment keys the variant replaced on the control's (or a child on its parent's). pass@1: pass / (pass + fail); infra errors and skips excluded. By `gate`. `'all'` (pass^k: every counted attempt passes) matches `{ passRate: 1 }`; `{ passRate }` is a pass@1 threshold. Infra only when nothing counted; `'none'` reports the worst outcome. A variant below its `minLift` fails too. Each check (assertion label) seen in any attempt of the eval, over this cell's counted attempts; on a variant cell, the control's beside it. Unset when no attempt recorded any. ### Lift A variant cell's pass@1 against the control's, on the same harness and sandbox. The control cell's key. Passes out of counted attempts (passes and fails) on each side. Variant pass@1 minus control pass@1, from -1 to 1. 95% interval on the difference, by Newcombe's hybrid score method from two Wilson intervals. The interval spans 0: the attempts can't tell the variant from the control. Set when the compare has a `minLift`; the cell fails when `interval.lo` is below it. ### FamilyRecord A pooled `evaluate.each`: its cases as samples of one suite. Each case is also an eval. `file › group › … › template`. The name template, e.g. `fixes $id`. Cases in the list. Cases with an eval in this run; fewer when a filter or tag left some out. One per cell. One per variant cell, with `compare`. `fail` when a lift is below its `minLift`. The cases still pass or fail on their own. ### FamilyRate One cell's pass@1 over a family's cases. The cell's key, the same in every case. Cases with at least one counted attempt in this cell. Passes and counted attempts over those cases. The mean of the cases' pass@1; at one attempt a case, `pass / counted`. ### FamilyLift A variant cell against its control over a family's cases, paired by case. The variant cell's key. The control cell's key. Cases with counted attempts on both sides. Mean pass@1 over the paired cases on each side. Set at one attempt a case and side: pairs where only one side passed. Variant minus control, from -1 to 1. McNemar's exact p (one attempt a case), else Wilcoxon signed-rank over the cases. The interval spans 0. The compare's `minLift`: on a family it gates this lower bound, not each case's. `fail` when `interval.lo` is below `minLift`. ### FamilyInterval A 95% interval on a pooled rate or difference. `wilson` / `newcombe-paired`: one counted attempt a case and side, so each case is one Bernoulli trial (or pair). `t-cases`: several, so a t interval over the cases' pass@1, with attempts within a case never counted as independent. ### FamilyEffort The variant's effort against the control's, paired by case. Over the cases where every counted attempt reported usage; omitted when none did. ### FamilyEffortMetric One effort metric over a family's paired cases. Cases with a value on both sides. The median over cases of the variant's per-case median, over the control's; null at 0. Wilcoxon signed-rank over the per-case differences; null when every difference is 0. `insufficient` below 6 non-zero differences, where the exact test can't reach 0.05. `fewer` and `more` are the test's direction (which side's differences rank higher), not the median's. ### FingerprintParts Each input of a cell fingerprint, hashed on its own, so a change can be named. Over `EvalEntry.sources`. Over the harness descriptor, less concurrency caps. Over the judge's model, threshold and version, and the config's `state` when it sets one. Over the attempt's context files. The gateway its model calls went through; unset on `direct`, each provider's own key. ### AttemptRecord ` # #`: unique in the run. `#`: unique in its eval. The cell's key; see `EvalEntry.cells`. Run number within the cell, from 1. Start order across the run, from 1; null for attempts that never started. The image the container started from, in `stack.images`; null for the fake sandbox. Names of the variables and secrets set in the sandbox, and the brokered ones; never values. Skills, rules and MCP config visible to the agent in its sandbox, by content hash. The egress policy and, when the sandbox records it, the hosts contacted and refused; null if it never ran. The models the harness's own API calls were served by, as the egress gateway saw them: named in the request (e.g. `gemini-3.8-flash` for the id `gemini-3.8-flash-low`, plus any the agent uses on the side) or, for Codex, in the response, with its effort (`gpt-5.6-luna[effort=medium]`); null when neither names one (Cursor) or nothing recorded them. The models the harness's successful API calls asked for, when nothing named the one that served them (fx on Vercel AI Gateway with a Gemini model): the agent's word, not the gateway's, so never part of `servedModels`. Absent when there's none. The upstream providers a gateway said served the harness's own API calls (OpenRouter's `provider`), each with how many it served, in the order first seen; more than one means the gateway spread or failed the calls over between them. Absent when the gateway names none. What a gateway said the harness's own API calls cost, in US dollars, summed (OpenRouter's `usage.cost`); absent when it names none. The reasoning effort the harness factory asked for (`claudeCode({ effort: 'high' })`); null when the factory left it unset. Fast is not this. The reasoning effort the harness's API said it ran at, from `servedModels` / each turn's `model` (`medium` from `gpt-5.6-luna[effort=medium]`); null when those labels name none. Fast (`[fast=true]`) is not this. `text` is the agent's final message, cut at 8 KB; the whole of it is in `transcript.jsonl`. `mcpStartup` times each stdio MCP server's start in the turn (`McpStartup`). Tokens across the attempt's turns; null when the harness reported none. Tokens the capture vision loop used. Infrastructure only: never folded into `usage`, effort, compare or lift. Counts from the transcript, so a run's shape is visible without reading it. `webSearches` includes refused searches. Harness session starts that didn't become ready within `startTimeout` and were started again (at most one). Each foreground `c.exec`: its last try's exit code, and `durationMs` over all its tries. With `retries`, `tries` has each try's `{ exitCode, durationMs }` and the log each try's output. Every `expect` and `expect.soft` matcher call that settled, in call order; unset with none. Files under a dependency directory (node_modules/, .venv/, …) collapse to one entry with `count`. The eval's questions asked of this attempt on its own (those without `across`), in question order; unset without any. They annotate: `outcome` never depends on them. Asked once the attempt ends, when it ran to a pass or a fail. Each answer's `input` is `questions/.json` in the attempt's directory, `` the question's place in the eval's `questions`. ### AttemptFiles Each environment setup step's command, exit code, duration and output. Unnormalised harness stream parts, only with `REEVAL_RAW_TRANSCRIPT=1`. PNGs from `c.capture()`, under `artifacts/.png`. ### ArtifactRef A generic attempt file from `c.capture()` (and later video). Also has every field of `FileRef`. Set when the file came from `c.capture()`. ### JudgementRecord The model id the provider says served the call, when it reports one. The gateway from the config's `gateway` list the call went through; unset without one. The upstream provider the gateway says served the call (OpenRouter's); unset when it names none. What the gateway says the call cost, in US dollars (OpenRouter's `usage.cost`); unset when it names none. `:`: the same question at the same place in the eval, so a verdict can be followed across runs (and an edited question starts a new series). Transient provider errors retried before this verdict, with the backoff before each retry. Captures this call sent the judge as file parts, when any. ### JudgeArtifactRef A capture this judge call sent as a file part. Bytes live in `artifacts/.png`. `artifacts/.png` under the attempt directory. ### JudgeRetry One failed judge try that was retried, and the backoff before the next. ### FileRef `path` is relative to the run's artifact directory; `sha256` is of the bytes on disk. ### ContextFile ### Cell One cell of an eval: a harness, an environment (`-` when none is set) and that environment's image (`sandbox` id: tag, dockerfile and install). With `compare`, the control is `baseline` (or the cascaded environment, or an empty `baseline`) and each variant is that environment on its own, including its sandbox. The environment's own name, also on a variant cell (`with-house-greeting`, with no prefix). The variant's name, for variant cells. ### EnvironmentRecord An environment as it was applied, without secret values. The previous `extendEnvironment` layer's name, else null. Keys a later layer replaced, e.g. `env.KEY`, `skills.genkit`, `mcp.docs`, `rules`. Covers every field but the rules file's path; secret names are included, values never are. The image is the sandbox's. Every MCP server, a plugin's as `:`. The plugins placed, each with what it placed; in the digest. Unset when there are none. Secrets the sandbox only had placeholders for, swapped in by the egress gateway. Optional secrets whose host variable was unset, so they weren't injected. The policy the attempt ran under, from the options and the environment; in the digest unless `proxy`. The git repository the workspace started as: the repo as written (a local one relative to the project root), the ref and path asked for (null when unset), the commit the ref resolved to and the hash of the tree that was copied in, which is in the digest. ### PluginRecord A plugin as an attempt placed it. The manifest's `name`. Where it came from, e.g. `local:plugins/review`, `github:acme/agent-plugins#v1:plugins/review` or `npm:@acme/review@1.2.0`; for a marketplace entry, the entry's own source. The marketplace it was listed in, with its `marketplace.json` name, its source as written (`github:acme/agent-plugins#v3`, `npm:@acme/plugins@2.0.0`) and the commit a git one resolved to (null for npm); null when the plugin was named directly. The commit a git source resolved to (the marketplace's, for an entry inside it); null for a local or npm one. The hash of the files placed. The tag of the image layer its build ran in (`reeval-plugin:…`); null without a build. What it placed: skill, agent, command and MCP server names, hook events, and whether it had rules. ### EgressRecord An attempt's network traffic. `allowed` is every host a restricted policy let through, its own and the automatic ones; null under `proxy` and `allow-all`. `recorded` is false when the sandbox can't see the traffic, and then `contacted` and `blocked` are empty. Bytes are counted between the sandbox and the egress gateway, TLS included. `expectedBlocked` are refused hosts the harness always tries (its CLI's telemetry, say), kept out of `blocked` so a real block stands out. True when traffic could leave around the gateway (`allow-all` in a container that kept its network): `contacted` lists only what went through the gateway, and anything that ignored the proxy (raw TCP and UDP, SSH, database drivers) went out unrecorded. Unset otherwise. ### AttemptImage The image an attempt's container started from, and how reeval made it. Content-addressed image id (`sha256:…`). The harness image `install` and plugin builds were baked onto: `ref` itself without either. The `docker({ install })` commands, in order. `docker({ dockerfile })`: the path from the project root and the build context's hash. `docker({ from })`: the base as written and the digest the image was built on (a local-only base's image id); `reeval image build` rebuilds it when the tag has moved since. ### PhaseTimings Where an eval's time went, in ms. `agentMs` is the harness turns; `diffMs` reading changes. ### FileChange ### McpStartup One start of a stdio MCP server during a turn (`turns[].mcpStartup`, in start order), timed by reeval's MCP timer, which every stdio server runs through. An agent CLI that runs a process per turn (Antigravity, pi, Codex) starts its servers on every turn; one that keeps a session starts them once, on the first. A server that doesn't answer within 60s fails the attempt as an infra error naming it; one whose client closes it first doesn't. `mcpStartup` is absent when the environment has no stdio MCP server, or the sandbox has no `node` to run the timer. The server's name in the environment's `mcp`. Milliseconds from spawning the server to its answer to the client's `initialize`; null when it never answered (it exited first, timed out, or its client closed it first). [//]: # (/generated:record-types) ## Insights `reeval run` writes `/insights.json` beside the record once its attempts finish, when `analysis.model` is set, and `reeval record` copies it; `reeval analyze --insights` writes it for a run without one, and finishes one with `stopped`, `failed` or `budget.skipped` evals, replacing it whole. A complete one is written once: delete it to write new ones. `reeval show` prints it with the run, on one line a sentence. It's `kind: "reeval-insights"`, `schemaVersion: 1`, and grows like the record. One from a newer reeval, or one that isn't valid JSON (a merge conflict), is skipped with a warning and the run prints without it. A run's [remarks](/reference/cli/run#remarks) go in the same file. A run that raises remarks but writes no insights (no `analysis.model`, `--no-insights`, or insights that fail or are skipped) writes one with no model's words (`model` and `promptVersion` `"none"`, `headline` `null`, `evals` empty), and `reeval analyze --insights` replaces it, keeping its remarks. `reeval record` copies a model's file byte for byte, so one written for other facts is still left out; a remarks-only one gets the recorded record's `factsHash`. ```json title="evals/.history//insights.json (trimmed)" { "kind": "reeval-insights", "schemaVersion": 1, "runId": "20261020T231903Z_2e69951_cursor-agent_8s1m", "model": "fake", "promptVersion": "insights-v6-9a7a2325", "factsHash": "sha256:0d56643daa2ea23e32a66492facca73fc5b3a85c6051d4f8690abec7c5281a18", "usage": { "inputTokens": 0, "outputTokens": 0, "costUsd": null }, "headline": { "text": "9 fail; start with \"recommends Genkit for $task\".", "cites": ["evals%2Fchoose.eval.ts › recommends Genkit for $task"] }, "evals": [{ "evalId": "evals%2Fchoose.eval.ts › recommends Genkit for $task", "intent": { "job": "choose", "across": "none", "question": "Does the agent pick Genkit?", "subject": { "tool": "Genkit" }, "name": "states-intent", "key": "2c0c59de…" }, "answer": { "text": "Not for a Python agent: 0 of 2 tries passed.", "cites": ["evals%2Fchoose.eval.ts › recommends Genkit for $task/a Python agent"] }, "findings": [], "rows": [{ "row": "…/a Python agent", "text": "It also names LangChain, …", "cites": ["…"] }], "namedTools": [{ "attempt": "…/a chat app/advisor+-+fake#1", "tools": ["Genkit", "LangChain"] }] }], "remarks": [], "validation": { "dropped": 0, "regenerated": 0, "drops": [] } } ``` | Field | What it holds | |---|---| | `model`, `promptVersion` | The analysis model and the prompts' version that wrote it: their revision and the first 8 hex characters of the eval rubric's sha256 | | `factsHash` | `sha256:` of the run's facts as canonical JSON; when the facts no longer match, `reeval show` leaves the insights out with a note | | `usage` | Tokens over every call; `outputTokens` includes `reasoningTokens`, the model's thinking, when it reports them; `costUsd` is `null`, since reeval has no prices | | `budget` | `maxTokens`, the `analysis.maxTokens` of the `reeval run` or `reeval analyze --insights` that wrote the file, and `skipped`, the evals it ran out before | | `failed` | The evals whose calls failed twice (an error, a reply cut off at the output cap, or a call past its timeout), each with `evalId` and the last `error`; they print their facts. Absent when none failed | | `stopped` | Set when Ctrl-C or SIGTERM stopped insights before every eval had finished: `signal` (`SIGINT` or `SIGTERM`) and `skipped`, the evals that hadn't. Absent otherwise; a stop during the headline call only leaves `headline` `null` | | `headline` | One sentence on the run, printed before the tally, or `null` | | `evals[].evalId` | The eval's or family's path: its file and name, `›` between them | | `evals[].intent` | The classification: `job` (`choose`, `finish` or `other`), `across`, `question`, `subject` (`tool`, `change`), `name` (`states-intent`, `no-intent` or `contradicts`) and `key`, the hash of what it read | | `evals[].answer` | Its answer, at most two sentences, or `null` | | `evals[].findings` | At most three sentences under a choose or finish eval that measures a change | | `evals[].rows` | A sentence under each row it names (`row`, a fact path) | | `evals[].namedTools` | On a choose eval, the tools each attempt's final message names (`#`) | | `remarks` | Each remark the run raised, including ones an earlier run printed first: `id` (one per kind and eval: for reeval's own, per eval version and, for `slow-mcp-start`, server; for a model's, per quote), `evalId`, `kind`, `severity` (`concern` or `suggestion`), `text`, `source` (a model's: `at`, `source:#L`, and `quote`, copied exactly from that line), `evidence` (fact paths, or `#` for an attempt), `fix` (`at`, `source:#L`, and `edit`; a model's `edit` is empty when it gave none, and its `at` the quoted line when it named no line), `origin` (`deterministic` or `model`), `firstSeenRun` (the first run that printed it, else this run) and `printed` (whether this run's `reeval run` output printed it; `false` when an earlier run printed it, or when the cap or a run without `-v` left it out, so a later run prints it; missing in files from an older reeval, read as printed in `firstSeenRun` only) | | `validation` | `dropped`, the sentences the checks dropped, and `regenerated`, those asked for again | | `validation.drops` | Each dropped sentence or model remark: `slot` (` › answer`, `› finding `, `› row `, `› named tools `, `› remark ` or `headline`), `text` and `reason`; absent in files written before it | | `error` | Set when writing the insights failed; `reeval show` prints it instead | Each sentence is `{ text, cites }`. A cite is a fact path (``, `/`, `//checks/