savemytokens 0.2.0

package/dist/report/graph.js

@@ -0,0 +1,162 @@
+import { paint, pressureRole } from "../runtime/kernel.mjs";
+import { padStartVisible } from "../util/ansi.js";
+const BLOCKS = ["", "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+const HEAT = [" ", "░", "▒", "▓", "█"];
+export function columns(series, width, until = Infinity) {
+    const out = new Array(width).fill(null);
+    const span = Math.max(1, series.to - series.from);
+    const lastColumn = Number.isFinite(until)
+        ? Math.min(width - 1, Math.floor(((until - series.from) / span) * width))
+        : width - 1;
+    for (const point of series.points) {
+        if (point.at < series.from || point.at > series.to)
+            continue;
+        const index = Math.min(width - 1, Math.floor(((point.at - series.from) / span) * width));
+        out[index] = point.value;
+    }
+    let carried = null;
+    for (let index = 0; index <= lastColumn; index++) {
+        const value = out[index];
+        if (value === null || value === undefined)
+            out[index] = carried;
+        else
+            carried = value;
+    }
+    return out;
+}
+export function projection(series, now) {
+    const points = series.points.filter((point) => point.at >= series.from && point.at <= now);
+    if (points.length < 2)
+        return null;
+    const last = points[points.length - 1];
+    const window = 45 * 60 * 1000;
+    const earlier = points.find((point) => point.at >= (last?.at ?? now) - window) ?? points[0];
+    if (!last || !earlier || last.at <= earlier.at)
+        return null;
+    const rate = ((last.value - earlier.value) / (last.at - earlier.at)) * 60 * 60 * 1000;
+    const hoursLeft = Math.max(0, (series.to - now) / (60 * 60 * 1000));
+    return { rate, atReset: last.value + rate * hoursLeft };
+}
+function clockAt(ms) {
+    const at = new Date(ms);
+    return `${String(at.getHours()).padStart(2, "0")}:${String(at.getMinutes()).padStart(2, "0")}`;
+}
+export function burnChart(series, now, width, height, theme, color) {
+    const plotWidth = Math.max(12, width - 6);
+    const values = columns(series, plotWidth, now);
+    const forecast = projection(series, now);
+    const nowIndex = Math.min(plotWidth - 1, Math.floor(((now - series.from) / Math.max(1, series.to - series.from)) * plotWidth));
+    const last = [...values].reverse().find((value) => value !== null) ?? 0;
+    const rows = [];
+    for (let row = height - 1; row >= 0; row--) {
+        const top = ((row + 1) / height) * 100;
+        const bottom = (row / height) * 100;
+        const label = row === height - 1 ? "100%" : row === 0 ? "  0%" : row === Math.floor(height / 2) ? " 50%" : "    ";
+        let line = "";
+        for (let index = 0; index < plotWidth; index++) {
+            const value = values[index];
+            if (value === null || value === undefined) {
+                if (index > nowIndex && forecast) {
+                    const share = index / Math.max(1, plotWidth - 1);
+                    const projected = last + (forecast.atReset - last) * ((share * plotWidth - nowIndex) / Math.max(1, plotWidth - nowIndex));
+                    line += projected >= bottom && projected < top + (100 / height) ? paint(theme, "dim", "┈", color) : " ";
+                }
+                else {
+                    line += " ";
+                }
+                continue;
+            }
+            if (value >= top) {
+                line += paint(theme, pressureRole(value / 100), "█", color);
+            }
+            else if (value > bottom) {
+                const fraction = (value - bottom) / (top - bottom);
+                const glyph = BLOCKS[Math.max(1, Math.round(fraction * 8))] ?? "▁";
+                line += paint(theme, pressureRole(value / 100), glyph, color);
+            }
+            else {
+                line += " ";
+            }
+        }
+        rows.push(`${paint(theme, "dim", label, color)} ${line}`);
+    }
+    const axis = `     ${paint(theme, "dim", clockAt(series.from).padEnd(Math.max(1, plotWidth - 10)) + `reset ${clockAt(series.to)}`, color)}`;
+    rows.push(axis);
+    return rows;
+}
+export function verdict(series, now, theme, color) {
+    const forecast = projection(series, now);
+    if (!forecast)
+        return paint(theme, "dim", "not enough readings yet — the line fills in as you work", color);
+    const atReset = Math.round(forecast.atReset);
+    const rate = forecast.rate;
+    if (rate <= 0.5) {
+        return paint(theme, "ok", `flat — barely burning; on this rate the window ends near ${Math.max(0, atReset)}%`, color);
+    }
+    if (forecast.atReset >= 100) {
+        const last = series.points[series.points.length - 1];
+        const remaining = last ? ((100 - last.value) / rate) * 60 : 0;
+        const out = new Date(now + remaining * 60 * 1000);
+        return paint(theme, "danger", `${Math.round(rate)}%/h — at this rate you run out at ${clockAt(out.getTime())}, before the reset`, color);
+    }
+    return paint(theme, atReset > 85 ? "warn" : "ok", `${Math.round(rate)}%/h — at this rate the window ends at ${atReset}%`, color);
+}
+export function dualBar(target, used, width, theme, color) {
+    const cells = Math.max(6, width);
+    const usedCells = Math.round(Math.max(0, Math.min(1, used)) * cells);
+    const targetCell = Math.round(Math.max(0, Math.min(1, target)) * cells);
+    let out = "";
+    for (let index = 0; index < cells; index++) {
+        if (index === targetCell - 1 && targetCell > 0) {
+            out += paint(theme, "accent", index < usedCells ? "┃" : "╵", color);
+        }
+        else if (index < usedCells) {
+            out += paint(theme, pressureRole(target > 0 ? used / target : 0), "█", color);
+        }
+        else {
+            out += paint(theme, "track", "░", color);
+        }
+    }
+    return out;
+}
+export function heatStrip(buckets, from, to, width, theme, color) {
+    const slots = new Array(width).fill(0);
+    const span = Math.max(1, to - from);
+    let peak = 0;
+    for (const row of buckets) {
+        const at = row[0] ?? 0;
+        if (at < from || at > to)
+            continue;
+        const weighted = (row[1] ?? 0) + (row[2] ?? 0) * 5 + (row[3] ?? 0) * 1.25 + (row[4] ?? 0) * 0.1;
+        const index = Math.min(width - 1, Math.floor(((at - from) / span) * width));
+        slots[index] += weighted;
+        if (slots[index] > peak)
+            peak = slots[index];
+    }
+    return slots
+        .map((value) => {
+        if (peak <= 0 || value <= 0)
+            return paint(theme, "track", HEAT[0] ?? " ", color);
+        const level = Math.max(1, Math.min(HEAT.length - 1, Math.round((value / peak) * (HEAT.length - 1))));
+        return paint(theme, pressureRole(value / peak), HEAT[level] ?? "█", color);
+    })
+        .join("");
+}
+export function miniSpark(buckets, from, to, width) {
+    const slots = new Array(width).fill(0);
+    const span = Math.max(1, to - from);
+    for (const row of buckets) {
+        const at = row[0] ?? 0;
+        if (at < from || at > to)
+            continue;
+        const weighted = (row[1] ?? 0) + (row[2] ?? 0) * 5 + (row[3] ?? 0) * 1.25 + (row[4] ?? 0) * 0.1;
+        slots[Math.min(width - 1, Math.floor(((at - from) / span) * width))] += weighted;
+    }
+    const peak = Math.max(...slots, 0);
+    if (peak <= 0)
+        return " ".repeat(width);
+    return slots.map((value) => BLOCKS[Math.max(0, Math.min(8, Math.round((value / peak) * 8)))] ?? " ").join("");
+}
+export function percentLabel(value, width = 4) {
+    return padStartVisible(`${Math.round(value)}%`, width);
+}

package/dist/report/graphs.js

@@ -0,0 +1,61 @@
+import { paint, pressureRole } from "../runtime/kernel.mjs";
+import { padStartVisible } from "../util/ansi.js";
+const BLOCKS = [" ", "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+const HEAT = [" ", "░", "▒", "▓", "█"];
+export function percentLabel(value, width = 4) {
+    if (!Number.isFinite(value))
+        return padStartVisible("-", width);
+    const rounded = Math.round(value);
+    return padStartVisible(rounded > 999 ? ">999%" : `${rounded}%`, width);
+}
+export function weighted(row) {
+    return (row[1] ?? 0) + (row[2] ?? 0) * 5 + (row[3] ?? 0) * 1.25 + (row[4] ?? 0) * 0.1;
+}
+export function smallBar(ratio, width, theme, color, role) {
+    const cells = Math.max(4, width);
+    const glyphs = theme.tui ?? {};
+    const fill = glyphs.fill ?? "|";
+    const empty = glyphs.empty ?? ".";
+    const open = glyphs.open ? paint(theme, "dim", glyphs.open, color) : "";
+    const close = glyphs.close ? paint(theme, "dim", glyphs.close, color) : "";
+    if (ratio > 1)
+        return `${open}${paint(theme, "danger", fill.repeat(cells - 1) + (glyphs.over ?? "»"), color)}${close}`;
+    const filled = Math.max(0, Math.min(cells, Math.round(Math.max(0, ratio) * cells)));
+    return `${open}${paint(theme, role, fill.repeat(filled), color)}${paint(theme, "track", empty.repeat(cells - filled), color)}${close}`;
+}
+export function emptyBar(width, theme, color) {
+    const glyphs = theme.tui ?? {};
+    const open = glyphs.open ?? "";
+    const close = glyphs.close ?? "";
+    return paint(theme, "dim", `${open}${(glyphs.empty ?? ".").repeat(Math.max(4, width))}${close}`, color);
+}
+function slotsFor(buckets, from, to, width) {
+    const slots = new Array(width).fill(0);
+    const span = Math.max(1, to - from);
+    for (const row of buckets) {
+        const at = row[0] ?? 0;
+        if (at < from || at > to)
+            continue;
+        slots[Math.min(width - 1, Math.floor(((at - from) / span) * width))] += weighted(row);
+    }
+    return slots;
+}
+export function heatStrip(buckets, from, to, width, theme, color) {
+    const slots = slotsFor(buckets, from, to, width);
+    const peak = Math.max(...slots, 0);
+    return slots
+        .map((value) => {
+        if (peak <= 0 || value <= 0)
+            return paint(theme, "track", "·", color);
+        const level = Math.max(1, Math.min(HEAT.length - 1, Math.round((value / peak) * (HEAT.length - 1))));
+        return paint(theme, pressureRole(value / peak), HEAT[level] ?? "█", color);
+    })
+        .join("");
+}
+export function miniSpark(buckets, from, to, width) {
+    const slots = slotsFor(buckets, from, to, width);
+    const peak = Math.max(...slots, 0);
+    if (peak <= 0)
+        return " ".repeat(width);
+    return slots.map((value) => BLOCKS[Math.max(0, Math.min(8, Math.round((value / peak) * 8)))] ?? " ").join("");
+}

package/dist/report/render.js

@@ -0,0 +1,183 @@
+import { bold, clip, dim, green, padEndVisible, padStartVisible, red, visibleWidth } from "../util/ansi.js";
+import { ago, bar, compactNumber, money, percent, plural, shortDate, sparkline } from "../util/fmt.js";
+import { displayHome } from "../storage/paths.js";
+import { pricingNote } from "../core/pricing.js";
+const INDENT = "  ";
+const BAR_WIDTH = 8;
+function width() {
+    const columns = process.stdout.columns ?? 80;
+    return Math.max(48, Math.min(columns - 2, 96));
+}
+export function wrap(text, indent, max = width()) {
+    const limit = Math.max(24, max - indent.length);
+    const lines = [];
+    let line = "";
+    for (const word of text.split(/\s+/)) {
+        if (!word)
+            continue;
+        if (line.length === 0)
+            line = word;
+        else if (line.length + 1 + word.length <= limit)
+            line += ` ${word}`;
+        else {
+            lines.push(indent + line);
+            line = word;
+        }
+    }
+    if (line)
+        lines.push(indent + line);
+    return lines;
+}
+function hanging(text, indent, marker, columns) {
+    const lines = wrap(text, "", columns - indent.length - visibleWidth(marker));
+    return lines.map((line, index) => index === 0 ? `${indent}${marker}${line}` : `${indent}${" ".repeat(visibleWidth(marker))}${line}`);
+}
+function taskRows(tasks, columns, limit) {
+    const top = tasks.slice(0, limit);
+    if (top.length === 0)
+        return [];
+    const max = Math.max(...top.map((t) => t.usd));
+    const amounts = top.map((t) => money(t.usd));
+    const projects = top.map((t) => (t.project || "").split("/").pop() || "unknown");
+    const moneyWidth = Math.max(...amounts.map((a) => a.length));
+    const projectWidth = Math.min(14, Math.max(...projects.map((p) => p.length)));
+    return top.map((task, index) => {
+        const amount = padStartVisible(amounts[index] ?? "", moneyWidth);
+        const meter = padEndVisible(dim(bar(task.usd, max, BAR_WIDTH)), BAR_WIDTH);
+        const project = padEndVisible((projects[index] ?? "").slice(0, projectWidth), projectWidth);
+        const room = Math.max(20, columns - moneyWidth - BAR_WIDTH - projectWidth - INDENT.length - 6);
+        return `${INDENT}${amount}  ${meter}  ${project}  ${clip(task.prompt, room)}`;
+    });
+}
+function footer(audit, previous, history, verbose) {
+    const scores = history
+        .filter((run) => run.scope.days === audit.scope.days && (run.scope.project ?? null) === (audit.scope.project ?? null))
+        .slice(-16)
+        .map((run) => run.score);
+    const spark = sparkline([...scores, audit.score]);
+    const parts = [];
+    if (previous) {
+        const delta = audit.wasteRatio - previous.wasteRatio;
+        const direction = delta < -0.005
+            ? `${green("less waste")} than`
+            : delta > 0.005
+                ? `${red("more waste")} than`
+                : "about the same as";
+        parts.push(`${direction} ${ago(previous.ranAt)}`);
+    }
+    if (spark && verbose)
+        parts.push(spark);
+    return parts.length > 0 ? [dim(parts.join(" · "))] : [];
+}
+export function renderAudit(input) {
+    const { audit, previous, history = [], nudges = null, installed = false, verbose = false } = input;
+    const columns = width();
+    const out = [""];
+    if (audit.totals.sessions === 0) {
+        out.push(`No agent sessions in the last ${audit.scope.days} days.`);
+        out.push(dim("Wider window: npx savemytokens --days 30"));
+        out.push("");
+        return out.join("\n");
+    }
+    const wasted = Math.min(audit.findings.reduce((sum, f) => sum + f.wastedUsd, 0), audit.totals.usd);
+    const scope = audit.scope.project ? (audit.scope.project.split("/").pop() ?? "") : "all projects";
+    out.push(`${bold(money(audit.totals.usd))} in ${audit.scope.days} ${plural(audit.scope.days, "day")} · ${bold(money(wasted))} wasted  ${dim(`${scope} · ${audit.totals.tasks} tasks`)}`);
+    if (audit.rateLimitHits > 0) {
+        out.push(dim(`hit your usage limit ${audit.rateLimitHits} ${plural(audit.rateLimitHits, "time")}`));
+    }
+    out.push("");
+    const rows = taskRows(audit.topTasks, columns, verbose ? 5 : 3);
+    if (rows.length > 0) {
+        out.push(...rows);
+        out.push("");
+    }
+    const yours = audit.findings.filter((f) => f.actor === "you");
+    const claudes = audit.findings.filter((f) => f.actor === "claude");
+    const shown = verbose ? yours.slice(0, 3) : yours.slice(0, 1);
+    for (const finding of shown) {
+        out.push(...wrap(`${bold(finding.title)}  ${bold(money(finding.wastedUsd))}`, ""));
+        for (const line of finding.measured.slice(0, verbose ? 3 : 2)) {
+            out.push(...hanging(line, INDENT, dim("· "), columns));
+        }
+        if (finding.receipts?.length) {
+            out.push("");
+            for (const line of finding.receipts.slice(0, verbose ? 3 : 2)) {
+                out.push(`${INDENT}${dim(clip(line, columns - INDENT.length))}`);
+            }
+        }
+        out.push("");
+        out.push(...hanging(`${bold("Do this:")} ${finding.fix}`, INDENT, "", columns));
+        if (verbose && finding.detail) {
+            out.push("");
+            for (const detail of finding.detail)
+                out.push(`${INDENT}${dim(detail)}`);
+        }
+        out.push("");
+    }
+    const rest = yours.length - shown.length;
+    if (rest > 0 && !verbose) {
+        const restUsd = yours.slice(shown.length).reduce((sum, f) => sum + f.wastedUsd, 0);
+        out.push(dim(`${rest} smaller ${plural(rest, "finding")} worth ${money(restUsd)} · npx savemytokens -v`));
+        out.push("");
+    }
+    const claudeUsd = claudes.reduce((sum, f) => sum + f.wastedUsd, 0);
+    if (claudes.length > 0 && !installed) {
+        out.push(...wrap(dim(`${money(claudeUsd)} more is how Claude works, not how you work: ${claudes.map((f) => f.title.toLowerCase()).join(", ")}. Nothing for you to do by hand; install writes the rules that fix them.`), ""));
+        out.push("");
+    }
+    if (nudges && installed) {
+        out.push(`${green("Since you installed:")} ${nudges.fired} ${plural(nudges.fired, "warning")}, ${money(nudges.usdAtStake)} at stake ${dim(`(${ago(nudges.installedAt)})`)}`);
+    }
+    else if (!installed) {
+        out.push(`${green("Do this:")}  ${bold("npx savemytokens install")}   ${dim("→ warns you before the next one, and gives each session a target share")}`);
+    }
+    out.push(...footer(audit, previous, history, verbose));
+    if (verbose) {
+        out.push("");
+        out.push(dim(`Efficiency ${audit.score}/100`));
+        for (const component of audit.scoreBreakdown) {
+            const points = `${component.points > 0 ? "+" : ""}${component.points}`;
+            out.push(dim(`${INDENT}${points.padStart(5)}  ${component.label}`));
+        }
+        out.push("");
+        out.push(dim("Spend by project"));
+        const maxProject = Math.max(...audit.projects.map((p) => p.usd), 0);
+        for (const project of audit.projects.slice(0, 8)) {
+            const amount = padStartVisible(money(project.usd), 7);
+            const meter = padEndVisible(bar(project.usd, maxProject, BAR_WIDTH), BAR_WIDTH);
+            out.push(dim(`${INDENT}${amount}  ${meter}  ${project.name} · ${project.tasks} ${plural(project.tasks, "task")}`));
+        }
+        out.push("");
+        out.push(dim("Models"));
+        for (const model of audit.models.slice(0, 6)) {
+            const context = model.usage.input + model.usage.cacheWrite + model.usage.cacheRead;
+            out.push(dim(`${INDENT}${model.model} · ${model.turns} ${plural(model.turns, "turn")} · in ${compactNumber(context)} · out ${compactNumber(model.usage.output)}`));
+        }
+        out.push("");
+        out.push(dim(pricingNote()));
+        out.push(dim(`Saved to ${displayHome()} · nothing left this machine`));
+    }
+    out.push("");
+    return out.join("\n");
+}
+export function renderHistory(runs) {
+    if (runs.length === 0)
+        return `\n${bold("SaveMyTokens")}\n\nNo runs recorded yet. Run: npx savemytokens\n`;
+    const recent = runs.slice(-20);
+    const out = ["", bold("SaveMyTokens"), "", dim("date               score   waste   scope"), ""];
+    for (const run of recent) {
+        const scope = `${run.scope.days}d${run.scope.project ? " · " + (run.scope.project.split("/").pop() ?? "") : ""}`;
+        out.push(`${shortDate(run.ranAt).padEnd(18)} ${String(run.score).padStart(3)}/100  ${percent(run.wasteRatio).padStart(5)}   ${dim(scope)}`);
+    }
+    const spark = sparkline(recent.map((run) => run.score));
+    const first = recent[0];
+    const last = recent[recent.length - 1];
+    if (spark && first && last) {
+        const delta = last.score - first.score;
+        const marker = delta > 0 ? green(`+${delta}`) : delta < 0 ? red(String(delta)) : dim("0");
+        out.push("");
+        out.push(`${dim(spark)}  ${marker} ${dim("points since the first run shown")}`);
+    }
+    out.push("");
+    return out.join("\n");
+}

package/dist/report/schedule.js

@@ -0,0 +1,143 @@
+import { activeViews } from "../scheduler/plan.js";
+import { formatReset, meterBar, paint, pressureRole } from "../runtime/kernel.mjs";
+import { padEndVisible, padStartVisible, visibleWidth } from "../util/ansi.js";
+import { ago, compactNumber } from "../util/fmt.js";
+const BAR_WIDTH = 10;
+const STATE_MARK = { active: "•", "needs-more": "+", done: "✓", blocked: "!" };
+function percent(value) {
+    return `${Math.round(value)}%`;
+}
+function clip(text, max) {
+    if (max <= 1)
+        return "";
+    return visibleWidth(text) <= max ? text : `${text.slice(0, Math.max(0, max - 1))}…`;
+}
+function capacityLines(control, options, now) {
+    const { theme, color = true } = options;
+    const out = [];
+    const published = control.resources.filter((resource) => resource.usedPercent !== null);
+    const label = `${control.provider.label} capacity`;
+    if (published.length === 0) {
+        out.push(`  ${paint(theme, "dim", label, color)}  ${paint(theme, "warn", "not published to this machine yet", color)}`);
+        out.push(`  ${paint(theme, "dim", control.provider.id === "claude-code" ? "Anthropic publishes your 5h and 7d usage to the status line only. Run: npx savemytokens install" : "No session has written a rate limit to disk in this window.", color)}`);
+        return out;
+    }
+    const asOf = control.schedule.quota?.at ?? 0;
+    out.push(`  ${paint(theme, "dim", label, color)}  ${paint(theme, "dim", `published · read ${ago(asOf, now)}`, color)}`);
+    for (const resource of published) {
+        const used = resource.usedPercent ?? 0;
+        const key = resource.id.split(":")[1] ?? "";
+        const label = key === "five_hour" ? "5h" : key === "seven_day" ? "7d" : "spend";
+        const reset = resource.window.resetsAt ? `resets ${formatReset(resource.window.resetsAt, now)}` : "";
+        out.push(`    ${padEndVisible(label, 5)} ${meterBar(theme, used / 100, BAR_WIDTH, pressureRole(used / 100), color)} ${padStartVisible(percent(used), 4)} ${paint(theme, "dim", `used · ${reset}`, color)}`);
+    }
+    return out;
+}
+function rowFor(view, index, widths, options, attributed) {
+    const { theme, selected, color = true } = options;
+    const chosen = selected === index;
+    const cursor = chosen ? paint(theme, "accent", "❯ ", color) : "  ";
+    const mark = paint(theme, view.state === "blocked" ? "danger" : view.state === "done" ? "dim" : "ok", STATE_MARK[view.state] ?? "•", color);
+    const label = padEndVisible(clip(widths.name, widths.label), widths.label);
+    const pinned = view.allocation.pinned ? paint(theme, "dim", "*", color) : " ";
+    const running = view.state === "active" || view.state === "needs-more";
+    const role = running ? pressureRole(view.pressure.value) : "dim";
+    const target = padStartVisible(percent(view.allocation.target * 100), 6);
+    const used = attributed
+        ? padStartVisible(paint(theme, role, percent(view.attributedPercent ?? 0), color), 6)
+        : "";
+    const share = padStartVisible(paint(theme, attributed ? "dim" : role, percent(view.observed * 100), color), 6);
+    const priority = padEndVisible(paint(theme, view.claimant.priority === "high" ? "accent" : "dim", view.claimant.priority.toUpperCase(), color), 8);
+    const prompt = paint(theme, "dim", clip(view.claimant.prompt || "—", widths.prompt), color);
+    return `${cursor}${mark} ${label} ${target}${pinned}${used}  ${share}  ${priority} ${prompt}`;
+}
+export function renderSchedule(control, options) {
+    const { theme, color = true, interactive = false } = options;
+    const now = control.schedule.now;
+    const columns = Math.max(60, Math.min(options.columns ?? 100, 120));
+    const views = activeViews(control.schedule);
+    const out = [""];
+    const windowLabel = control.schedule.key === "seven_day" ? "7-day window" : "5-hour window";
+    out.push(`  ${paint(theme, "accent", "SaveMyTokens", color)} ${paint(theme, "dim", `· ${control.provider.label} · ${windowLabel}`, color)}`);
+    out.push("");
+    out.push(...capacityLines(control, options, now));
+    out.push("");
+    const attributed = control.schedule.live !== null;
+    const seen = new Map();
+    for (const view of views)
+        seen.set(view.claimant.label, (seen.get(view.claimant.label) ?? 0) + 1);
+    const labels = new Map();
+    for (const view of views) {
+        const base = view.claimant.label || view.claimant.id.slice(0, 8);
+        const started = new Date(view.claimant.startedAt);
+        const stamp = `${String(started.getHours()).padStart(2, "0")}:${String(started.getMinutes()).padStart(2, "0")}`;
+        labels.set(view.claimant.id, (seen.get(view.claimant.label) ?? 0) > 1 ? `${base} ${stamp}` : base);
+    }
+    const stamped = new Map();
+    for (const label of labels.values())
+        stamped.set(label, (stamped.get(label) ?? 0) + 1);
+    for (const [id, label] of labels) {
+        if ((stamped.get(label) ?? 0) > 1)
+            labels.set(id, `${label}·${id.slice(0, 4)}`);
+    }
+    const labelWidth = Math.min(22, Math.max(9, ...[...labels.values()].map((label) => label.length)));
+    const promptWidth = Math.max(16, columns - labelWidth - (attributed ? 38 : 30));
+    out.push(paint(theme, "dim", `    ${padEndVisible("session", labelWidth)} ${padStartVisible("target", 6)}${attributed ? ` ${padStartVisible("used", 6)}` : ""}  ${padStartVisible("share", 6)}  ${padEndVisible("priority", 8)} last prompt`, color));
+    if (views.length === 0) {
+        out.push("");
+        out.push(`    ${paint(theme, "dim", `No ${control.provider.label} sessions in this window.`, color)}`);
+    }
+    for (const [index, view] of views.entries()) {
+        out.push(rowFor(view, index, { label: labelWidth, prompt: promptWidth, name: labels.get(view.claimant.id) ?? view.claimant.label }, options, attributed));
+    }
+    out.push("");
+    out.push(`    ${paint(theme, "dim", "spare target capacity", color)}  ${paint(theme, control.schedule.unusedPool > 0.01 ? "warn" : "dim", percent(control.schedule.unusedPool * 100), color)}`);
+    const basis = control.schedule.live
+        ? `target and used are percentages of the 5h window Anthropic publishes; share is this session's part of ${compactNumber(control.schedule.totalWeighted)} weighted tokens measured on disk, and used is ${percent(control.schedule.live.usedPercent)} × that share`
+        : `no published window on this machine, so target and share are portions of the ${compactNumber(control.schedule.totalWeighted)} weighted tokens measured on disk`;
+    for (const line of basis.match(/.{1,92}(\s|$)/g) ?? [basis]) {
+        out.push(`    ${paint(theme, "dim", line.trim(), color)}`);
+    }
+    const enforcement = control.enforcement.length > 0
+        ? `enforcement: ${control.enforcement.join(", ")} only — a hook injects text, nothing here can hold a session to a number`
+        : `${control.provider.label} has no hook to inject through, so this view is visibility only`;
+    out.push(`    ${paint(theme, "dim", enforcement, color)}`);
+    const policy = control.config.policyFor?.[process.cwd()] ?? control.config.policy;
+    out.push(`    ${paint(theme, "dim", `when a session passes its target: policy ${policy} · npx savemytokens policy`, color)}`);
+    if (control.deferred.length > 0) {
+        out.push("");
+        out.push(`    ${paint(theme, "warn", "deferred to the next session", color)}`);
+        for (const group of control.deferred.slice(0, 3)) {
+            const name = group.project.split("/").pop() || group.project;
+            for (const item of group.items.slice(-2)) {
+                out.push(`      ${paint(theme, "dim", `${name} · ${clip(item.text, columns - 20)}`, color)}`);
+            }
+        }
+    }
+    for (const other of control.others) {
+        const published = other.resources.filter((resource) => resource.usedPercent !== null);
+        if (published.length === 0)
+            continue;
+        const parts = published.map((resource) => {
+            const key = resource.id.split(":")[1] ?? "";
+            return `${key === "seven_day" ? "7d" : "5h"} ${percent(resource.usedPercent ?? 0)}`;
+        });
+        out.push("");
+        out.push(`    ${paint(theme, "dim", `${other.label}: ${parts.join(" · ")} — npx savemytokens --adapter ${other.id}`, color)}`);
+    }
+    if (control.unattributed !== null) {
+        out.push(`    ${paint(theme, "warn", `${percent(control.unattributed)} of the window moved while no local session was running`, color)}`);
+    }
+    if (control.schedule.lockouts.length > 0) {
+        const last = control.schedule.lockouts[control.schedule.lockouts.length - 1] ?? 0;
+        out.push(`    ${paint(theme, "danger", `hit the limit ${control.schedule.lockouts.length}× this window, last ${ago(last, now)}`, color)}`);
+    }
+    out.push("");
+    if (interactive) {
+        const preserve = control.config.preserveFor[process.cwd()] ?? control.config.preserveFor.default;
+        out.push(paint(theme, "dim", `    preserving ${preserve && preserve.length > 0 ? preserve.join(", ") : "testing and finalisation (default)"} · P to change`, color));
+        out.push(paint(theme, "dim", "    ↑↓ select   ←→ target   p priority   e equalize   d done   b blocked   a active   q quit", color));
+        out.push("");
+    }
+    return out.join("\n");
+}