rovecode 0.4.0-beta.3 → 0.4.0

package/src/server/openapi.ts

@@ -0,0 +1,246 @@
+/** Hand-authored OpenAPI 3.1 document for the rovecode server surface (port #19).
+ *  opencode serves its spec at GET /doc — packages/opencode/src/server/routes/
+ *  instance/httpapi/server.ts:190 (route) + :188 (lazy OpenApi.fromApi(PublicApi))
+ *  — and generates its client SDK from that spec (packages/sdk/js, @hey-api/openapi-ts).
+ *  Their spec is derived from Effect httpapi endpoint schemas; ADR-001 rejects Effect
+ *  idioms, and this surface is five routes, so the object is written by hand — no
+ *  codegen dependency, the doc IS the source of truth for what the server exposes. */
+
+/** Honesty note (bar requirement): served verbatim in the doc so HTTP clients know
+ *  interactive approvals do not exist in v1. */
+export const APPROVALS_NOTE =
+  "v1 approvals are policy-only: the server runs with rule-based permissions and has no " +
+  "interactive approver over HTTP. A tool call whose permission rule resolves to effect " +
+  "\"prompt\" is NOT paused for approval — it surfaces as a failed tool call " +
+  "(tool_call_failed, reason permission_denied, \"approval required but no approver " +
+  "connected\") and the run continues. Start the server with --yolo (allow-all rules) " +
+  "or provide allow rules to let gated tools run.";
+
+/** RunEvent discriminator values (src/core/types.ts RunEvent union). Hand-listed:
+ *  types are erased at runtime, and the doc is hand-authored by design. */
+export const RUN_EVENT_TYPES = [
+  "run_start", "turn_start", "message_update", "reasoning_update",
+  "tool_execution_start", "tool_execution_update", "tool_execution_end",
+  "tool_call_failed", "compaction", "turn_end", "steer", "run_end",
+] as const;
+
+const errorResponse = (description: string) => ({
+  description,
+  content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } },
+});
+
+/** Build the OpenAPI 3.1 object. `serverUrl` is the actually-bound base URL. */
+export function buildOpenApiDoc(serverUrl: string): Record<string, unknown> {
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: "rovecode server",
+      version: "0.1.0",
+      description:
+        "Headless HTTP surface over the one rovecode agent loop (ADR-003). " +
+        "Five routes: create a session, prompt it (SSE stream of typed run events; " +
+        "DELETE the same path cancels the in-flight run mid-turn), " +
+        "list its background tasks, list sessions, and this document. " + APPROVALS_NOTE,
+    },
+    servers: [{ url: serverUrl }],
+    paths: {
+      "/session": {
+        post: {
+          operationId: "session.create",
+          summary: "Create a new session",
+          description: "Creates a session backed by the append-only JSONL session store and returns its id.",
+          responses: {
+            "201": {
+              description: "Session created",
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    required: ["id"],
+                    properties: { id: { type: "string", description: "Session id (also the session directory name)" } },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+      "/session/{id}/prompt": {
+        post: {
+          operationId: "session.prompt",
+          summary: "Run the agent loop on a session and stream its events",
+          description:
+            "Runs one agent loop over the session with the given text as the goal. " +
+            "The response is a Server-Sent Events stream: each event is framed as " +
+            "`event: <RunEvent.type>` + `data: <RunEvent JSON>`, and the stream closes " +
+            "after the terminal run_end event. " + APPROVALS_NOTE,
+          parameters: [
+            { name: "id", in: "path", required: true, schema: { type: "string" }, description: "Session id from POST /session" },
+          ],
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  required: ["text"],
+                  properties: {
+                    text: { type: "string", description: "The user goal for this run" },
+                    model: {
+                      type: "object",
+                      description: "Optional model override; defaults to the server's resolved provider/model",
+                      required: ["provider", "model"],
+                      properties: { provider: { type: "string" }, model: { type: "string" } },
+                    },
+                  },
+                },
+              },
+            },
+          },
+          responses: {
+            "200": {
+              description: "SSE stream of RunEvent frames; closes after run_end",
+              content: { "text/event-stream": { schema: { $ref: "#/components/schemas/RunEvent" } } },
+            },
+            "400": errorResponse("Body is not JSON or lacks a string `text`"),
+            "404": errorResponse("Unknown session id"),
+            "409": errorResponse("A run is already in progress for this session"),
+            "503": errorResponse("No provider configured — run `rovecode setup` (or rovecode provider add + rovecode auth set, or set ROVECODE_BASE_URL/ROVECODE_API_KEY)"),
+          },
+        },
+        delete: {
+          operationId: "session.cancel",
+          summary: "Cancel the in-flight run on a session",
+          description:
+            "Aborts the running prompt's AbortController: the in-flight provider fetch and " +
+            "tool subprocesses are killed mid-turn, and the run's SSE stream ends with a " +
+            "run_end event of status \"stopped\". The session stays busy (409 on new prompts) " +
+            "until that stream has actually settled. Idempotent: cancelling an idle session " +
+            "returns cancelled: false.",
+          parameters: [
+            { name: "id", in: "path", required: true, schema: { type: "string" }, description: "Session id from POST /session" },
+          ],
+          responses: {
+            "200": {
+              description: "Cancellation signalled (cancelled: true) or nothing was running (cancelled: false)",
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object",
+                    required: ["cancelled"],
+                    properties: { cancelled: { type: "boolean" } },
+                  },
+                },
+              },
+            },
+            "404": errorResponse("Unknown session id"),
+          },
+        },
+      },
+      "/session/{id}/tasks": {
+        get: {
+          operationId: "session.tasks",
+          summary: "List the session's background subagent tasks",
+          description:
+            "Snapshot of the session's background tasks (port #26): child agent sessions started by " +
+            "the `task` tool, oldest first, with status queued|running|done|failed|cancelled, timing, " +
+            "the child's final text (done) or error (failed). Tasks are process-local and not durable " +
+            "across server restarts. Completion notes reach the model as steering on the session's next prompt.",
+          parameters: [
+            { name: "id", in: "path", required: true, schema: { type: "string" }, description: "Session id from POST /session" },
+          ],
+          responses: {
+            "200": {
+              description: "Task snapshots",
+              content: {
+                "application/json": {
+                  schema: { type: "array", items: { $ref: "#/components/schemas/TaskInfo" } },
+                },
+              },
+            },
+            "404": errorResponse("Unknown session id"),
+          },
+        },
+      },
+      "/sessions": {
+        get: {
+          operationId: "session.list",
+          summary: "List sessions",
+          description: "Scans the session root and returns summaries, sorted by updatedAt descending. Corrupt or foreign directories are skipped, never errors.",
+          responses: {
+            "200": {
+              description: "Session summaries",
+              content: {
+                "application/json": {
+                  schema: { type: "array", items: { $ref: "#/components/schemas/SessionSummary" } },
+                },
+              },
+            },
+          },
+        },
+      },
+      "/doc": {
+        get: {
+          operationId: "doc",
+          summary: "This OpenAPI 3.1 document",
+          description: "Returns the OpenAPI 3.1 JSON describing exactly this server surface.",
+          responses: {
+            "200": { description: "OpenAPI 3.1 document", content: { "application/json": { schema: { type: "object" } } } },
+          },
+        },
+      },
+    },
+    components: {
+      schemas: {
+        Error: {
+          type: "object",
+          required: ["error"],
+          properties: { error: { type: "string" } },
+        },
+        SessionSummary: {
+          type: "object",
+          required: ["id", "createdAt", "updatedAt", "entryCount", "preview"],
+          properties: {
+            id: { type: "string" },
+            createdAt: { type: "number" },
+            updatedAt: { type: "number" },
+            entryCount: { type: "number" },
+            preview: { type: "string", description: "First user-message text, single line, ≤80 chars" },
+          },
+        },
+        RunEvent: {
+          type: "object",
+          description:
+            "Typed agent-loop event (src/core/types.ts RunEvent union), discriminated by `type`. " +
+            "The SSE `event:` field always equals this `type` field.",
+          required: ["type"],
+          properties: {
+            type: { type: "string", enum: [...RUN_EVENT_TYPES] },
+          },
+          additionalProperties: true,
+        },
+        TaskInfo: {
+          type: "object",
+          description: "Background subagent task snapshot (src/core/tasks.ts TaskInfo).",
+          required: ["id", "label", "agent", "goal", "isolated", "depth", "status", "createdAt"],
+          properties: {
+            id: { type: "string", description: "Task id (t1, t2, …; scoped to the session)" },
+            label: { type: "string" },
+            agent: { type: "string", description: "Agent definition the child runs" },
+            goal: { type: "string", description: "Bounded preview of the child's goal (≤200 chars)" },
+            isolated: { type: "boolean", description: "Ran in a worktree copy; file changes merge back as a patch on success" },
+            depth: { type: "number", description: "Child depth (root-started tasks run at 1)" },
+            status: { type: "string", enum: ["queued", "running", "done", "failed", "cancelled"] },
+            createdAt: { type: "number" },
+            startedAt: { type: "number" },
+            finishedAt: { type: "number" },
+            summary: { type: "string", description: "The child's final text (status done), ≤4000 chars" },
+            error: { type: "string", description: "Failure reason (status failed) or \"cancelled\"" },
+            usage: { type: "object", properties: { input: { type: "number" }, output: { type: "number" } } },
+            patchLines: { type: "number", description: "Isolated children: line count of the merged-back patch" },
+          },
+        },
+      },
+    },
+  };
+}

package/src/sextant/card-hits.ts

@@ -0,0 +1,102 @@
+/** Click zones for the modal card (approval verdicts, question options, free text, skip).
+ *
+ *  Why this exists: the card is the single most frequent interaction in the surface — every gated
+ *  edit, every shell command, every ask_user question goes through it — and until now it answered
+ *  only to the arrow keys. Clicking `allow` did nothing at all: keys.ts's onMouse walks the hit zones
+ *  the drawers registered that frame, and nobody registered any for the card, so the click fell
+ *  through to the "focus the panel under the pointer" fallback. That is the complaint "most things do
+ *  not respond to clicks, it only works with the arrow keys", in its most-used place.
+ *
+ *  Geometry, not painting: draw-messages.ts owns how the card looks, this file owns where its targets
+ *  landed. The two are kept honest by deriving everything from the SAME exported helpers the painter
+ *  uses (areas, cardShape, cardRows) rather than re-deriving row counts — a second copy of the layout
+ *  arithmetic would drift the moment the card grew a row.
+ *
+ *  Two subtleties the card forces:
+ *    - The card is CLIPPED from the top when it does not fit (draw-messages keeps the tail so the
+ *      buttons stay reachable), so a row's screen y is its index minus the hidden count, and a target
+ *      scrolled off the top has no zone at all rather than a wrong one.
+ *    - The approval verdicts share ONE row, laid out horizontally, so they need x ranges; the question
+ *      card gives every option its own row.
+ *
+ *  `confirm` is false for exactly one target, the free-text row: clicking it means "I want to type
+ *  here", not "submit an empty answer". Every other target is a labelled button, and a click on a
+ *  button is the decision — the same as clicking OK in any dialog. */
+
+import { areas, cardRows, cardShape, questionRows, SKIP_LABEL, VERDICT_LABEL } from "./draw-messages.ts";
+import { inner } from "./draw-util.ts";
+import { strWidth } from "./screen.ts";
+import type { Rect, SextantState, Theme } from "./types.ts";
+
+export interface CardHit {
+  rect: Rect;
+  /** the value card.selected takes when this target is clicked */
+  index: number;
+  /** replay Enter after selecting (a button); false leaves the caret on the row (free text) */
+  confirm: boolean;
+}
+
+/** button() in draw-messages renders a label as ` label `, and the verdict row separates them by two
+ *  spaces at indent 2. */
+const BUTTON_PAD = 2;
+const BUTTON_GAP = 2;
+const ROW_INDENT = 2;
+
+/** The card's clickable targets in screen coordinates, or [] when no card is open, the panel is too
+ *  small to draw one, or every target is clipped away. `rect` is the messages panel, as passed to
+ *  drawMessages. */
+export function cardHits(rect: Rect, s: SextantState, theme: Theme): CardHit[] {
+  const card = s.card;
+  if (card === null || card === undefined) return [];
+  if (rect.w < 4 || rect.h < 3) return []; // drawMessages paints nothing at all below this
+  const B = inner(rect);
+  const { cardH, msgH, maxDetail } = areas(B, s);
+  if (cardH <= 0) return [];
+
+  const all = cardRows(card, B.w, maxDetail, theme);
+  // when the card is taller than its slot the painter keeps the TAIL: rows [hidden..] are on screen
+  const hidden = all.length - cardH;
+  const yOf = (i: number): number | null => {
+    const v = i - hidden;
+    return v < 0 || v >= cardH ? null : B.y + msgH + v;
+  };
+  const out: CardHit[] = [];
+
+  if (card.kind === "approval") {
+    // the verdicts are the last row, so they survive clipping — that is why the painter keeps the tail
+    const y = yOf(all.length - 1);
+    if (y === null) return [];
+    let x = B.x + ROW_INDENT;
+    for (const [i, v] of card.verdicts.entries()) {
+      const w = strWidth(VERDICT_LABEL[v] ?? String(v)) + BUTTON_PAD;
+      if (x + w > B.x + B.w) break; // a verdict pushed past the right edge was never drawn
+      out.push({ rect: { x, y, w, h: 1 }, index: i, confirm: true });
+      x += w + BUTTON_GAP;
+    }
+    return out;
+  }
+
+  // question card: blank, q question rows, one row per option, [free text, wrapped], skip, hint.
+  // The row arithmetic comes from questionRows — the same helper the painter and the caret use — so
+  // the three cannot disagree; cardShape is still consulted for the clip.
+  const opts = card.prompt.options ?? [];
+  const { q, freeRows } = questionRows(card, B.w);
+  const shape = cardShape(card, B.w, maxDetail);
+  if (shape.total !== 1 + q + opts.length + freeRows + 2) return []; // the painter and the helper disagree: register nothing rather than wrong zones
+  const push = (rowIndex: number, index: number, w: number, confirm: boolean, h = 1): void => {
+    const y = yOf(rowIndex);
+    if (y !== null && w > 0) out.push({ rect: { x: B.x + ROW_INDENT, y, w, h }, index, confirm });
+  };
+  const full = Math.max(0, B.w - ROW_INDENT);
+  for (const [i, o] of opts.entries()) push(1 + q + i, i, Math.min(strWidth(o) + BUTTON_PAD, full), true);
+  // the free-text field is one zone across all its wrapped rows: select it, do not answer for the human.
+  // Rows clipped off the top shrink the zone from above (the first visible row is where it starts).
+  if (freeRows > 0) {
+    const first = 1 + q + opts.length;
+    const visibleFrom = Math.max(first, hidden);
+    const rows = first + freeRows - visibleFrom;
+    if (rows > 0) push(visibleFrom, opts.length, full, false, rows);
+  }
+  push(1 + q + opts.length + freeRows, opts.length + (freeRows > 0 ? 1 : 0), Math.min(strWidth(SKIP_LABEL) + BUTTON_PAD, full), true);
+  return out;
+}

package/src/sextant/card-keys.ts

@@ -0,0 +1,55 @@
+/** Sextant card keys (port #43): the key route of the ONE modal card — ←→↑↓ (and Tab) move the
+ *  selection, Enter resolves it (approval: once / always / deny; question: an option, the free-text
+ *  row or skip), Esc dismisses (deny / null) and the free-text row takes typing and Backspace.
+ *  Ported from the user's own sextant v0.4.0 prototype app.js:1503-1510 and :1434; split out of
+ *  keys.ts for the line budget. Pure state mutation, no clock: the card leaves the state before
+ *  its promise settles, so a re-entrant hook never sees a stale card. */
+
+import type { CardState, KeyEvent, SextantState } from "./types.ts";
+
+/** false = not a card key: it falls through to the prompt (typing a follow-up while a card waits) */
+export function onCardKey(s: SextantState, c: CardState, ev: KeyEvent): boolean {
+  const { name } = ev;
+  const n = c.kind === "approval" ? c.verdicts.length // allow · always · [all edits] · deny
+    : (c.prompt.options?.length ?? 0) + (c.prompt.allowFreeText !== false ? 1 : 0) + 1; // options · free text · skip
+  if (name === "left" || name === "up") return move(c, n, -1);
+  if (name === "right" || name === "down" || name === "tab") return move(c, n, 1);
+  if (name === "escape") { dismissCard(s); return true; }
+  if (c.kind === "approval") {
+    if (name !== "enter") return false;
+    s.card = null;
+    c.resolve(c.verdicts[c.selected] ?? "deny");
+    return true;
+  }
+  const opts = c.prompt.options?.length ?? 0, freeIdx = c.prompt.allowFreeText !== false ? opts : -1;
+  if (name === "enter") {
+    if (c.selected === n - 1) { dismissCard(s); return true; } // skip
+    if (c.selected !== freeIdx) { s.card = null; c.resolve({ kind: "option", index: c.selected }); return true; }
+    const t = c.freeText.trim();
+    if (t) { s.card = null; c.resolve({ kind: "text", text: t }); }
+    return true; // an empty free-text row is not an answer yet
+  }
+  if (c.selected !== freeIdx) return false;
+  if (name === "backspace") { // by code point: 😀 is one glyph, two UTF-16 units
+    c.freeText = [...c.freeText].slice(0, -1).join("");
+    return true;
+  }
+  const ch = name === "space" ? " " : ev.ch;
+  if (!ch || ev.alt) return false;
+  c.freeText += ch;
+  return true;
+}
+
+/** wrap the selection over the card's n rows */
+function move(c: CardState, n: number, d: -1 | 1): true {
+  const v = (c.selected + d + n) % n;
+  c.selected = v;
+  return true;
+}
+
+/** approval → deny, question → null; the card leaves the state before the promise settles */
+export function dismissCard(s: SextantState): void {
+  const c = s.card;
+  s.card = null;
+  if (c?.kind === "approval") c.resolve("deny"); else c?.resolve(null);
+}

package/src/sextant/context-source.ts

@@ -0,0 +1,157 @@
+/** The seam between the context overlay and core/context-report.ts.
+ *
+ *  draw-context.ts is pure over `ContextState` and never counts anything. This file is the only place that
+ *  knows the report module exists: it lazily imports it (the boot rule — nothing in that dependency tree is
+ *  loaded until someone opens /context), asks the LIVE runtime for the two rows a transcript cannot know,
+ *  and maps the report onto the overlay's flat view.
+ *
+ *  The live runtime is the whole reason this overlay is worth having. `rovecode context` on a shell has to
+ *  BUILD a runtime to learn the system prompt and the tool schemas, and in a fresh session those two are
+ *  most of the window; here they are already in memory, so the number is complete without constructing
+ *  anything. What is still missing is MCP tools — their schemas do not exist until a server is connected —
+ *  and the panel says so on its own line rather than letting a complete-looking total imply otherwise.
+ *
+ *  Two numbers travel, never one. `raw` is what o200k counted; `estimated` is that corrected towards the
+ *  model's own tokenizer. Presenting only the second would be presenting a corrected figure as a
+ *  measurement, and someone comparing this panel against a provider's dashboard needs to know which is
+ *  which. `scale.note` says where the factor came from, including when nobody has measured this model.
+ *
+ *  Nothing here throws. A runtime that cannot answer, a model the catalog does not know, an empty
+ *  transcript — each is a state the overlay draws, because a panel that reports on the session must not be
+ *  the thing that ends it. */
+
+import type { ContextState } from "./draw-context.ts";
+
+/** What the live runtime can tell us that the transcript cannot. Both optional: a session whose runtime
+ *  is mid-rebuild still opens the panel, and `live: false` makes the total read as a floor. */
+export interface ContextFixed {
+  /** the system prompt a real turn would send — buildDef's, not the base alone */
+  system?: string;
+  /** rovecode's own tool schemas, serialized. MCP tools are deliberately absent. */
+  toolSchemas?: string;
+}
+
+/** the runtime shape this file needs, structurally — declared here so the overlay never imports the
+ *  runtime's types and so a test can hand in three lines instead of a process */
+export interface LiveRuntime {
+  registry: { list(): { schema: unknown }[] };
+  // method syntax, and `unknown` for the prompt: the real AgentDefinition types `systemPrompt` as a string
+  // or a function over its own AgentVars, and pinning either shape here would make this file depend on the
+  // runtime's types — which is exactly what the overlay must not do. It is narrowed where it is read.
+  buildDef(ref: { provider: string; model: string; effort: "auto" }): { systemPrompt: unknown };
+  /** optional: the market overlay uses it after installing an MCP server (types.ts SextantAttach) */
+  reloadMcp?(): Promise<{ added: string[]; removed: string[]; failed: { name: string; error: string }[]; skipped: string[] }>;
+}
+
+/** Pull the two fixed rows out of a runtime that is ALREADY running.
+ *
+ *  Deliberately not `createRuntime`: the CLI builds one because it has none, and paid for that decision
+ *  with a session directory it had to pass in to avoid creating a stray empty session. Inside the TUI the
+ *  runtime is the one the next turn will use, so this is a read, not a construction — and it cannot leave
+ *  anything behind.
+ *
+ *  `buildDef`, not `systemPrompt()`: the prompt a run actually sends is the base plus the model profile,
+ *  the design section, and — for a model without native tool calling — the tool block. Asking for the base
+ *  alone under-counts the largest fixed row by everything that makes it large. */
+export function fixedFrom(rt: LiveRuntime | null | undefined, ref: { provider: string; model: string }): ContextFixed {
+  if (!rt) return {};
+  try {
+    const schemas = rt.registry.list().map((t) => t.schema);
+    const def = rt.buildDef({ ...ref, effort: "auto" });
+    const sp = def.systemPrompt;
+    const system = typeof sp === "string" ? sp : typeof sp === "function" ? String((sp as (x: Record<string, unknown>) => unknown)({})) : undefined;
+    if (system === undefined) return {};
+    return { system, toolSchemas: JSON.stringify(schemas) };
+  } catch {
+    // a runtime that cannot describe itself is a panel that says so, not a crashed frame
+    return {};
+  }
+}
+
+/** the report module's shape, structurally: this file must compile and be testable without importing it */
+interface Slice { label: string; tokens: number; share: number; note?: string }
+interface Drift { estimated: number; reported: number; delta: number; fraction: number; beyondTolerance: boolean }
+interface Report {
+  model: { provider: string; model: string };
+  window?: number;
+  estimated: number;
+  corrected: number;
+  scale: { factor: number; measured: boolean; note: string };
+  slices: Slice[];
+  remaining?: number;
+  fraction?: number;
+  nearLimit?: boolean;
+  drift?: Drift;
+  totals: { inputTokens?: number; outputTokens?: number; cacheReadTokens?: number; cacheWriteTokens?: number };
+  costUsd?: number;
+  unpricedTurns: number;
+  images: number;
+}
+
+export interface ContextLoadInput {
+  messages: readonly unknown[];
+  current: { provider: string; model: string };
+  /** window + pricing, however the caller has them */
+  lookup: (r: { provider: string; model: string }) => unknown;
+  fixed: ContextFixed;
+  /** the tolerance drift is judged against; printed by the panel, never assumed by a reader */
+  tolerance?: number;
+  /** tests inject the report function; production lazily imports the real one */
+  report?: (input: unknown) => Report;
+}
+
+/** the fraction past which drift is called out rather than merely shown. Matches core/context-report.ts;
+ *  it travels in the state so the panel can print it instead of asserting a number the reader cannot see. */
+const TOLERANCE = 0.05;
+
+/** Build the overlay's state. Never throws: every failure becomes something the panel can draw. */
+export async function loadContext(input: ContextLoadInput): Promise<Omit<ContextState, "scroll">> {
+  const tolerance = input.tolerance ?? TOLERANCE;
+  const model = `${input.current.provider}/${input.current.model}`;
+
+  let report: Report;
+  try {
+    const fn = input.report ?? (await import("../core/context-report.ts")).contextReport as unknown as (i: unknown) => Report;
+    report = fn({
+      messages: input.messages,
+      current: input.current,
+      lookup: input.lookup,
+      ...(input.fixed.system !== undefined ? { system: input.fixed.system } : {}),
+      ...(input.fixed.toolSchemas !== undefined ? { toolSchemas: input.fixed.toolSchemas } : {}),
+    });
+  } catch {
+    // the panel opens and says it has nothing, which is more useful than a frame that died counting
+    return {
+      model, raw: 0, estimated: 0, scale: { factor: 1, measured: false, note: "the context report could not be built" },
+      slices: [], images: 0, billed: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      unpricedTurns: 0, live: false, tolerance,
+    };
+  }
+
+  const t = report.totals;
+  return {
+    model,
+    ...(report.window !== undefined ? { window: report.window } : {}),
+    // `estimated` on the panel is the CORRECTED number, because that is what the window and the bill are
+    // computed from; `raw` carries what o200k counted so the panel can show both
+    raw: report.estimated,
+    estimated: report.corrected,
+    scale: report.scale,
+    ...(report.remaining !== undefined ? { remaining: report.remaining } : {}),
+    ...(report.fraction !== undefined ? { fraction: report.fraction } : {}),
+    ...(report.nearLimit !== undefined ? { nearLimit: report.nearLimit } : {}),
+    slices: report.slices.map((s) => ({ label: s.label, tokens: s.tokens, share: s.share, ...(s.note ? { note: s.note } : {}) })),
+    images: report.images,
+    ...(report.drift ? { drift: { ...report.drift } } : {}),
+    billed: {
+      input: t.inputTokens ?? 0, output: t.outputTokens ?? 0,
+      cacheRead: t.cacheReadTokens ?? 0, cacheWrite: t.cacheWriteTokens ?? 0,
+    },
+    ...(report.costUsd !== undefined ? { costUsd: report.costUsd } : {}),
+    unpricedTurns: report.unpricedTurns,
+    // "live" is about the two rows a transcript cannot know. The system prompt is the one that matters:
+    // tool schemas can legitimately be an empty list, so their absence proves nothing.
+    live: input.fixed.system !== undefined,
+    tolerance,
+  };
+}