tumwater 0.4.0 → 0.4.2

package/dist/src/gui/gui-operator-commands.js

@@ -2,21 +2,21 @@
  * The dashboard's POST operator-lifecycle command handlers (barrelled into
  * gui/gui-endpoint-commands.ts, which routes to them from src/gui/gui-server.ts): reset-counters,
  * restart, reclaim, abort, stop-schedule, role-notes, retire, revert, brief-edit, queue-cancel,
- * queue-top, post-review-accept, and commit-backlog — every POST handler that is not
- * prompt/backlog/config/team. Each handler
+ * queue-top, post-review-accept, commit-backlog, and archive-backlog — every POST handler
+ * that is not prompt/backlog/config/team. Each handler
  * adapts HTTP onto the domain work
  * one layer down (operator-intent, role-notes-write, brief-edit) and touches no socket beyond
  * its own `res`.
  */
 import { resyncRootInstall, rootInstallResyncLines } from "../build/dep-install.js";
-import { cancelScheduledStopMessage, requestAbort, requestResetCounters, requestRestart, requestScheduledStop, runManualReclaim } from "../operator/operator-intent.js";
-import { runDoctor } from "../doctor/doctor.js";
+import { cancelScheduledStopMessage, requestAbort, requestAbortAll, requestResetCounters, requestRestart, requestScheduledStop, runManualReclaim } from "../operator/operator-intent.js";
 import { killOrphans, orphanKillLines } from "../doctor/doctor-orphans.js";
 import { dropBrokenPins, brokenPinDropLines, retireLeftovers, leftoverRetireLines } from "../doctor/doctor-contention-checks.js";
 import { commitUncommittedBacklog, backlogCommitMessage } from "../doctor/doctor-backlog.js";
+import { archiveFinishedOnMain, describeArchivedFile } from "../backlog/backlog-archive.js";
 import { loadConfigSafe } from "../config/config.js";
 import { saveRoleNote } from "../agent/role-notes-write.js";
-import { roleNotesPath } from "../paths.js";
+import { roleNotesPath, MERGE_LOCK_WAIT_MS } from "../paths.js";
 import { DIRECTOR_ROLE } from "../roles/roles.js";
 import { artifactPhrase, retireRole } from "../operator/retire.js";
 import { previewRevert, revertFollowUp, revertMergedCommit } from "../operator/revert.js";
@@ -30,7 +30,7 @@ import { orchestratorAlive } from "../team/orchestrator-info.js";
 import { shortSha } from "../text/format.js";
 import { editBriefText } from "../brief/brief-edit.js";
 import { requireStringField, validRoleIds } from "./gui-args.js";
-import { badRequest, sendJson } from "./http-body.js";
+import { badRequest, sendJson } from "./gui-http-body.js";
 import { errorMessage, gotSuffix } from "../text/text.js";
 import { readPostBody, readRoleBody, sendRequestResult } from "./gui-endpoint-common.js";
 import { wakeInSecondsMs } from "./gui-team-commands.js";
@@ -140,6 +140,35 @@ export async function handleCommitBacklog(req, res, root, commit = (r) => commit
     const report = await commit(root);
     sendJson(res, 200, { ok: report.failed.length === 0, message: backlogCommitMessage(report), committed: report.committed, failed: report.failed, skipped: report.skipped, base: report.base });
 }
+/** Handle POST /api/doctor-archive-backlog: the dashboard Health card's Archive backlog
+ * button — the same archiveFinishedOnMain `tumwater archive` runs (holding the merge lock),
+ * answering its message verbatim. `ok` is true when the finished entries were archived or
+ * there was nothing to archive; `skipped` (an off-base checkout, uncommitted backlog/archive
+ * files, or an unreadable file) answers `ok: false` with the skip reason and writes nothing.
+ * The archived body also carries the full commit sha and the moved files so the card can
+ * repaint precisely. Same body discipline as /api/kill-orphans; `archive` is injectable so a
+ * test need not touch git or hold the merge lock. */
+export async function handleArchiveBacklog(req, res, root, archive = (r) => archiveFinishedOnMain(r, { lockTimeoutMs: MERGE_LOCK_WAIT_MS })) {
+    const body = await readPostBody(req, res, "{}");
+    if (!body)
+        return;
+    const outcome = await archive(root);
+    if (outcome.status === "nothing") {
+        sendJson(res, 200, { ok: true, message: "nothing to archive: PLANS.md ## Done and BUGS.md ## Fixed hold no finished entries" });
+        return;
+    }
+    if (outcome.status === "skipped") {
+        sendJson(res, 200, { ok: false, message: `nothing archived: ${outcome.reason}` });
+        return;
+    }
+    sendJson(res, 200, {
+        ok: true,
+        message: [...outcome.moved.map(describeArchivedFile), `committed ${shortSha(outcome.commit)}`].join("; "),
+        archived: true,
+        commit: outcome.commit,
+        moved: outcome.moved,
+    });
+}
 /** Handle POST /api/doctor-resync-install: the dashboard Health card's Re-sync install button —
  * the terminal twin of `tumwater doctor --resync-install` and the TUI's Ctrl+U, all reached
  * through the same resyncRootInstall. It answers the same lines the CLI prints
@@ -154,17 +183,6 @@ export async function handleResyncInstall(req, res, root, resync = resyncRootIns
     const r = await resync(root);
     sendJson(res, 200, { ok: r.ok, message: rootInstallResyncLines(r).join("; ") });
 }
-/** Handle POST /api/doctor-reprobe: the dashboard Health card's Re-probe models button, the
- * twin of `tumwater doctor --reprobe`. A POST because it spends one model call per claimed pi
- * image-input model and rewrites `.tumwater/state/image-probes.json`; GET /api/doctor stays
- * probe-free. Same body discipline as /api/kill-orphans; `run` takes the probe mode so a test
- * can pin that the handler asks for "all" without spawning a probe. */
-export async function handleDoctorReprobe(req, res, root, run = (r, p) => runDoctor(r, undefined, undefined, p)) {
-    const body = await readPostBody(req, res, "{}");
-    if (!body)
-        return;
-    sendJson(res, 200, await run(root, "all"));
-}
 /** Handle POST /api/abort: the dashboard's per-row abort control — the same marker-writing
  * core `tumwater abort` calls (requestAbort). The role is required and validated like
  * /api/transcript; requestAbort's not-live error comes back 409 — the marker is valid but
@@ -176,6 +194,14 @@ export async function handleAbort(req, res, root) {
         return;
     sendRequestResult(res, requestAbort(root, body.role));
 }
+/** Handle POST /api/abort-all: the dashboard Roles card's Abort all button — the same
+ * marker-writing core `tumwater abort --all` calls (requestAbortAll). It reads no body (the
+ * request targets every enabled runner), so a stale `role` field from another request changes
+ * nothing; requestAbortAll's not-live error comes back 409 like /api/abort's, through
+ * sendRequestResult. */
+export async function handleAbortAll(_req, res, root) {
+    sendRequestResult(res, requestAbortAll(root));
+}
 /** Handle POST /api/role-notes: the role drawer's notes Edit/Clear — the same saveRoleNote
  * `tumwater role <id> --notes-file` / `--clear-notes` call, so the 4 KB cap and its wording
  * cannot drift. `"text": ""` clears. The director has no notes (400, the CLI's wording); a

package/dist/src/gui/gui-prompt-commands.js

@@ -17,7 +17,7 @@ import { parseDurationMs } from "../cli/cli-args.js";
 import { PAUSE_FOR_MAX_MS, submitRolePromptAndWake } from "../operator/operator-intent.js";
 import { DIRECTOR_ROLE } from "../roles/roles.js";
 import { rejectBadQueueFileName, rejectBadRole, requirePromptText } from "./gui-args.js";
-import { badRequest, OK_GONE, sendJson } from "./http-body.js";
+import { badRequest, OK_GONE, sendJson } from "./gui-http-body.js";
 import { errorMessage, gotSuffix, joinParts } from "../text/text.js";
 import { readPostBody, readRoleBody } from "./gui-endpoint-common.js";
 /** Handle POST /api/prompt: queue a director prompt. An over-long prompt
@@ -92,6 +92,23 @@ function checkedPromptFields(res, body, role = DIRECTOR_ROLE) {
         return null;
     return { text, images, notBeforeMs };
 }
+/** The GUI prompt handlers' shared image-input gate (plans/image-input.md "Attachments",
+ * part 5/5): when the body carries images, refuse (400) an attachment the target role
+ * cannot read and that no tier reroutes — the same gate submitRolePrompt enforces, surfaced
+ * as a user-input error rather than the server's 500 — and return the notice a blinder's
+ * reroute should flash, or "" when there is nothing to say (image-less, or a rerouted role).
+ * Callers answer 400 and stop when it returns null. The role-queue submit and file-edit
+ * handlers share this one gate so their refusal text cannot drift from each other's. */
+function promptImageGate(res, root, role, hasImages) {
+    if (!hasImages)
+        return "";
+    const guidance = imagePromptGuidance(root, role);
+    if (guidance.refusal) {
+        badRequest(res, guidance.refusal);
+        return null;
+    }
+    return guidance.notice ?? "";
+}
 /** Handle POST /api/prompt-role: queue a prompt for one role — the dashboard's per-row
  * prompt affordance submits here, calling the same path `tumwater prompt --role <id>` uses
  * (submitRolePrompt enqueues into that role's own queue and logs under it, then a single-role
@@ -113,15 +130,9 @@ export async function handlePromptRole(req, res, root) {
     // anything is queued — the same gate submitRolePrompt enforces, surfaced as a user-input
     // error rather than the server's 500. A role that reroutes a blind read is not refused; its
     // notice rides in the confirmation the composer flashes.
-    let notice = "";
-    if (fields.images && fields.images.length > 0) {
-        const guidance = imagePromptGuidance(root, role);
-        if (guidance.refusal) {
-            badRequest(res, guidance.refusal);
-            return;
-        }
-        notice = guidance.notice ?? "";
-    }
+    const notice = promptImageGate(res, root, role, (fields.images?.length ?? 0) > 0);
+    if (notice === null)
+        return;
     const message = joinParts([
         submitRolePromptAndWake(root, role, fields.text, fields.images, fields.notBeforeMs),
         notice,
@@ -183,17 +194,12 @@ export async function handlePromptEdit(req, res, root) {
     const fields = checkedPromptFields(res, body, role);
     if (!fields)
         return;
-    // Image-input gate (plans/image-input.md "Attachments", part 5/5), the edit twin of
-    // handlePromptRole's: an image edited into the queued prompt answers 400 naming the fix
-    // when the target role cannot read it (and no tier reroutes it) — the same gate
-    // submitRolePrompt enforces — before anything is written.
-    if (fields.images && fields.images.length > 0) {
-        const guidance = imagePromptGuidance(root, role);
-        if (guidance.refusal) {
-            badRequest(res, guidance.refusal);
-            return;
-        }
-    }
+    // Image-input gate (plans/image-input.md "Attachments", part 5/5): an image edited into
+    // the queued prompt answers 400 naming the fix when the target role cannot read it (and no
+    // tier reroutes it) — the same gate submitRolePrompt enforces — before anything is written.
+    // The edit handler does not flash a reroute notice, so it ignores the helper's return.
+    if (promptImageGate(res, root, role, (fields.images?.length ?? 0) > 0) === null)
+        return;
     let outcome;
     try {
         outcome = editQueuedFile(root, role, body.file, fields.text, fields.images);

package/dist/src/gui/gui-quarantine-commands.js

@@ -0,0 +1,30 @@
+/**
+ * The dashboard's POST flake-quarantine command handler (barrelled into
+ * gui/gui-endpoint-commands.ts, which routes to it from src/gui/gui-server.ts):
+ * quarantine-release — the twin of `tumwater quarantine --release <n>`. The dashboard Failures
+ * view's per-entry "Release" button and the CLI predicate run the same releaseQuarantinedTest
+ * core, so the operator who decides a quarantined test's filed bug is fixed can retire it from
+ * the card without opening a terminal. The handler adapts HTTP onto that domain work and
+ * touches no socket beyond its own `res`.
+ */
+import { releaseQuarantinedTest } from "../review/known-flakes.js";
+import { readPostBody } from "./gui-endpoint-common.js";
+import { badRequest, sendJson } from "./gui-http-body.js";
+/** Handle POST /api/quarantine-release: release one quarantined test (the body's `test`), so
+ * the review gate no longer excuses its failures. A missing/empty `test` 400s (nothing
+ * written); a name not currently quarantined answers ok:false (nothing written); a hit removes
+ * it from .tumwater/state/quarantine.json and answers ok:true naming the test. */
+export async function handleQuarantineRelease(req, res, root) {
+    const body = await readPostBody(req, res, "{}");
+    if (!body)
+        return;
+    const test = typeof body.test === "string" ? body.test : "";
+    if (test === "") {
+        badRequest(res, "a quarantined test name is required");
+        return;
+    }
+    const ok = releaseQuarantinedTest(root, test);
+    sendJson(res, 200, ok
+        ? { ok: true, message: `released quarantined test: ${test} — the gate no longer excuses it` }
+        : { ok: false, message: `not in the flake quarantine: ${test}` });
+}

package/dist/src/gui/gui-report-endpoints.js

@@ -5,15 +5,17 @@
  * this module only adapts HTTP onto it. Barrelled into gui/gui-endpoints.ts beside the other
  * per-family GET endpoint modules.
  */
-import { collectReport, collectReportSince } from "../report/report-data.js";
+import { collectReport } from "../report/report-data.js";
+import { collectReportSince } from "../report/report-since-data.js";
 import { collectFailureReport, collectFailureReportSince } from "../failure/failure-data.js";
 import { renderFailureMarkdown } from "../failure/failure-render.js";
 import { renderSinceReportMarkdown } from "../report/report-render.js";
 import { loadQuarantine } from "../review/known-flakes.js";
-import { quarantineRows, renderQuarantineSection } from "../review/quarantine-render.js";
+import { quarantineRows, quarantineViewRows } from "../review/quarantine-render.js";
+import { quarantineWarning } from "../baseline/main-guardrails.js";
 import { REPORT_SINCE_MAX_MS, reportSinceMsg } from "../events/event-window.js";
 import { roleListQuery, sinceMsQuery, untilMsQuery, windowDays } from "./gui-args.js";
-import { badRequest, sendJson } from "./http-body.js";
+import { badRequest, sendJson } from "./gui-http-body.js";
 /** Parse and validate the role-scoped, sinceMs-or-days query the report and failures endpoints
  * both take: the `?role=` filter, a comma-separated list (each id trimmed, deduplicated, and
  * validated by rejectBadRole — an unknown id or an empty list → 400 naming it) and, when
@@ -73,11 +75,12 @@ export function handleReport(q, res, root) {
  * same bounded Markdown failure digest the selfcheck role feeds on and `tumwater report
  * --failures` prints, as JSON ({ markdown }) — the dashboard's failures tab renders it; with
  * sinceMs it is the trailing-window digest (collectFailureReportSince) through the same render,
- * the CLI's `report --failures --since` shape. The response also carries `quarantine`, the
- * Markdown section (renderQuarantineSection over the current loadQuarantine list, an empty
- * string when it is empty) the Failures view paints below the digest — the read twin of the
- * amber quarantine alert, current rather than window- or role-scoped. The digest's `markdown`
- * is unchanged. The days window follows windowDays (so it can
+ * the CLI's `report --failures --since` shape. The response also carries `quarantine` —
+ * `{ warning, rows }` (quarantineViewRows over the current loadQuarantine list, an empty
+ * rows list when it is empty) the Failures view's card paints below the digest — the interactive
+ * twin of `tumwater quarantine --release <n>` (each row's Release button posts to
+ * POST /api/quarantine-release), current rather than window- or role-scoped. The digest's
+ * `markdown` is unchanged. The days window follows windowDays (so it can
  * never drift from /api/report's). role rides the same rule as
  * handleReport: absent → the team digest, present → the validated listed roles, summed. Reads files
  * directly, so it works with no team running. */
@@ -88,7 +91,8 @@ export function handleFailures(q, res, root) {
     const untilMs = untilMsQuery(q, res, scope.sinceMs);
     if (untilMs === null)
         return;
-    const quarantine = renderQuarantineSection(quarantineRows(loadQuarantine(root)), Date.now());
+    const rows = quarantineRows(loadQuarantine(root));
+    const quarantine = { warning: quarantineWarning(rows, Date.now()), rows: quarantineViewRows(rows, Date.now()) };
     if (scope.sinceMs !== undefined) {
         sendJson(res, 200, { markdown: renderFailureMarkdown(collectFailureReportSince(root, scope.sinceMs, scope.roles, untilMs)), quarantine });
         return;

package/dist/src/gui/gui-server.js

@@ -13,8 +13,8 @@ import { captureStartupBuild, createReloadWatch, reexecSelf, watchReloadSupervis
 import { warnEvent, TUMWATER_SOURCE } from "../events/events.js";
 import { errorMessage } from "../text/text.js";
 import { handleBacklog, handleBacklogMatch, handleBrief, handleConfig, handleDiff, handleFailures, handleReport, handleHistory, handleLogs, handlePromptText, handleRun, handleRole, handleTranscript, handleDoctor, handleRetireList, } from "./gui-endpoints.js";
-import { handleAbort, handleBriefEdit, handleBudget, handleConfigSet, handleConfigUnset, handleRoleCap, handleRoleReviewAfterMerge, handleRoleEnable, handleRoleDisable, handleRoleInstances, handleRoleInterval, handleRoleInstructions, handleRoleModel, handleRoleQuietHours, handleNotifyTest, handlePause, handlePauseRole, handlePrompt, handleBacklogFile, handleBacklogCancel, handleBacklogRelease, handleBacklogTop, handleBacklogEdit, handlePromptCancel, handlePromptEdit, handlePromptRole, handlePromptTop, handleQuestionAnswer, handleReclaim, handleKillOrphans, handleDropBrokenPins, handleCommitBacklog, handleResyncInstall, handleRetireLeftovers, handleDoctorReprobe, handleRestart, handleStopSchedule, handleResetCounters, handleRoleNotes, handleRetire, handleRevert, handleQueueCancel, handleQueueTop, handlePostReviewAccept, handleWake, handleWakeCancel, } from "./gui-endpoint-commands.js";
-import { sendJson } from "./http-body.js";
+import { handleAbort, handleAbortAll, handleBriefEdit, handleBudget, handleConfigSet, handleConfigUnset, handleRoleCap, handleRoleReviewAfterMerge, handleRoleEnable, handleRoleDisable, handleRoleInstances, handleRoleInterval, handleRoleInstructions, handleRoleModel, handleRoleQuietHours, handleNotifyTest, handlePause, handlePauseRole, handlePrompt, handleBacklogFile, handleBacklogCancel, handleBacklogRelease, handleBacklogTop, handleBacklogEdit, handlePromptCancel, handlePromptEdit, handlePromptRole, handlePromptTop, handleQuestionAnswer, handleReclaim, handleKillOrphans, handleDropBrokenPins, handleCommitBacklog, handleResyncInstall, handleRetireLeftovers, handleArchiveBacklog, handleRestart, handleStopSchedule, handleResetCounters, handleRoleNotes, handleRetire, handleRevert, handleQueueCancel, handleQueueTop, handlePostReviewAccept, handleQuarantineRelease, handleWake, handleWakeCancel, } from "./gui-endpoint-commands.js";
+import { sendJson } from "./gui-http-body.js";
 /** Constant-time credential comparison for the shared-token gate: `timingSafeEqual` throws
  * on unequal lengths, so the length equality is the guard. A naive `===` string compare
  * would leak the token's length and prefix byte by byte. */
@@ -194,6 +194,7 @@ export function startGui(root, port, allInterfaces = false, token = "", watch =
         "POST /api/queue-cancel": (req, res) => handleQueueCancel(req, res, root),
         "POST /api/queue-top": (req, res) => handleQueueTop(req, res, root),
         "POST /api/post-review-accept": (req, res) => handlePostReviewAccept(req, res, root),
+        "POST /api/quarantine-release": (req, res) => handleQuarantineRelease(req, res, root),
         "POST /api/restart": (req, res) => handleRestart(req, res, root),
         "POST /api/stop-schedule": (req, res) => handleStopSchedule(req, res, root),
         "POST /api/reclaim": (req, res) => handleReclaim(req, res, root),
@@ -202,8 +203,9 @@ export function startGui(root, port, allInterfaces = false, token = "", watch =
         "POST /api/doctor-commit-backlog": (req, res) => handleCommitBacklog(req, res, root),
         "POST /api/doctor-resync-install": (req, res) => handleResyncInstall(req, res, root),
         "POST /api/doctor-retire-leftovers": (req, res) => handleRetireLeftovers(req, res, root),
-        "POST /api/doctor-reprobe": (req, res) => handleDoctorReprobe(req, res, root),
+        "POST /api/doctor-archive-backlog": (req, res) => handleArchiveBacklog(req, res, root),
         "POST /api/abort": (req, res) => handleAbort(req, res, root),
+        "POST /api/abort-all": (req, res) => handleAbortAll(req, res, root),
         "POST /api/pause-role": (req, res) => handlePauseRole(req, res, root),
     };
     const server = http.createServer(async (req, res) => {

package/dist/src/gui/gui-team-commands.js

@@ -9,7 +9,7 @@ import { baseRoleOf, INSTANCE_ROLES } from "../roles/runner-ids.js";
 import { normalizePauseReason, pauseTeam, pauseRole, resumeTeam, resumeRole } from "../team/team-state.js";
 import { cancelWakes, PAUSE_FOR_MAX_MS, requestWake } from "../operator/operator-intent.js";
 import { requirePausedFlag, validRoleIds } from "./gui-args.js";
-import { badRequest, sendJson } from "./http-body.js";
+import { badRequest, sendJson } from "./gui-http-body.js";
 import { gotSuffix } from "../text/text.js";
 import { readPostBody, readRoleBody } from "./gui-endpoint-common.js";
 /** The shared optional-seconds rule behind the timed pause's `forSeconds` and the scheduled

package/dist/src/history/history-data.js

@@ -17,6 +17,7 @@ import { shortSpanPhrase } from "../text/phrases.js";
 import { outcomeText, usageText } from "../events/event-format.js";
 import { compareCodeUnits } from "../collections.js";
 import { bucketMergeEvents, resolveQueuedResult } from "./history-queued.js";
+import { nonNegativeNumber } from "../files/json-object.js";
 /** `history`'s default row count and ceiling. The default shows a working hour of a quiet
  * team; the ceiling bounds how much log one ask re-reads — more rows only re-read more log
  * with no added signal, so an explicit flag above it fails fast (the report's --days pattern). */
@@ -68,6 +69,8 @@ function tallyRows(rows, keyOf) {
             t.costUsd += row.costUsd;
             if (row.durationMs !== null)
                 t.durationMs = (t.durationMs ?? 0) + row.durationMs;
+            if (row.peakContextTokens !== undefined)
+                t.peakContextTokens = Math.max(t.peakContextTokens ?? 0, row.peakContextTokens);
             if (cls === "changes")
                 t.lastChangeTs = Math.max(t.lastChangeTs ?? row.ts, row.ts);
         }
@@ -118,7 +121,7 @@ export function runRowCells(row) {
     return {
         role: roleLabel(row.role),
         run: String(row.run),
-        result: eventTypeLabel(row.result),
+        result: row.cutOff === true ? `${eventTypeLabel(row.result)} (cut off)` : eventTypeLabel(row.result),
         model: row.model ?? "",
         duration: row.durationMs === null ? "—" : shortSpanPhrase(row.durationMs),
         usage: row.usage,
@@ -209,11 +212,14 @@ export function runRows(events, limit, role, join) {
                 ?.result ?? rawResult)
             : rawResult;
         const usage = eventUsage(e);
+        const peak = nonNegativeNumber(e.peakContextTokens, 0);
         rows.push({
             ts: e.ts,
             time: formatTimestamp(e.ts),
             tokens: usage.tokens,
             costUsd: usage.costUsd,
+            ...(peak > 0 ? { peakContextTokens: peak } : {}),
+            ...(e.cutOff === true ? { cutOff: true } : {}),
             role: eventRole(e),
             run: eventRun(e),
             result,

package/dist/src/history/history-render.js

@@ -77,20 +77,25 @@ export function renderModelSummary(summary) {
 }
 function renderSummaryTable(header, all) {
     const roleWidth = Math.max(...[header, ...all.map((r) => r.label)].map(displayWidth));
-    const cols = ["runs", "changes", "none", "refused", "problems", "tokens", "cost", "time"];
+    const cols = ["runs", "changes", "none", "refused", "problems", "tokens", "peak", "cost", "time"];
+    const colLabel = { runs: "runs", changes: "changes", none: "none", refused: "refused", problems: "problems", tokens: "tokens", peak: "peak ctx", cost: "cost", time: "time" };
     const cell = (r, c) => c === "tokens"
         ? compactTokens(r.tokens)
-        : c === "cost"
-            ? usd(r.costUsd)
-            : c === "time"
-                ? r.durationMs === undefined
-                    ? "—"
-                    : humanSeconds(r.durationMs / 1000)
-                : String(c === "runs" ? r.runs : r[c]);
-    const widths = cols.map((c) => Math.max(c.length, ...all.map((r) => cell(r.row, c).length)));
+        : c === "peak"
+            ? r.peakContextTokens === undefined
+                ? "—"
+                : compactTokens(r.peakContextTokens)
+            : c === "cost"
+                ? usd(r.costUsd)
+                : c === "time"
+                    ? r.durationMs === undefined
+                        ? "—"
+                        : humanSeconds(r.durationMs / 1000)
+                    : String(c === "runs" ? r.runs : r[c]);
+    const widths = cols.map((c) => Math.max(colLabel[c].length, ...all.map((r) => cell(r.row, c).length)));
     const line = (role, cells, lastChange) => [padToWidth(role, roleWidth), ...cells.map((c, i) => c.padStart(widths[i] ?? 0)), lastChange].join("  ").trimEnd();
     return [
-        line(header, [...cols], "last change"),
+        line(header, cols.map((c) => colLabel[c]), "last change"),
         ...all.map(({ label, row }) => line(label, cols.map((c) => cell(row, c)), row.lastChangeTs === null ? "—" : formatTimestamp(row.lastChangeTs))),
     ].join("\n");
 }